summary refs log blame commit diff stats
path: root/doc/rst.txt
blob: 1e858d617fb2f0abadd13f7534b9c2d2a24a63da (plain) (tree)
1
2
3
4
5
6
7
8
                                                                           
                                    


                                                                           
                      
 
             



            
                                                                            
                                                                      
                                                                     
                                                                          
                                                            
 
                                                                          
                                                                              

                                                                            





                  
                                            




            
                               


























                                                        

                


                                                                  
                          
 
                                                                        


                                                                           
                                    




      
                                               





                                                                   
                                      











                                                                   
                                    









                                                                                      
===========================================================================
       Nim's implementation of |rst|
===========================================================================

:Author: Andreas Rumpf
:Version: |nimversion|

.. contents::

Introduction
============

This document describes the subset of `Docutils`_' `reStructuredText`_ as it
has been implemented in the Nim compiler for generating documentation.
Elements of |rst| that are not listed here have not been implemented.
Unfortunately, the specification of |rst| is quite vague, so Nim is not as
compatible to the original implementation as one would like.

Even though Nim's |rst| parser does not parse all constructs, it is pretty
usable. The missing features can easily be circumvented. An indication of this
fact is that Nim's *whole* documentation itself (including this document) is
processed by Nim's |rst| parser. (Which is an order of magnitude faster than
Docutils' parser.)


Inline elements
===============

Ordinary text may contain *inline elements*.


Bullet lists
============

*Bullet lists* look like this::

  * Item 1
  * Item 2 that
    spans over multiple lines
  * Item 3
  * Item 4
    - bullet lists may nest
    - item 3b
    - valid bullet characters are ``+``, ``*`` and ``-``

This results in:
* Item 1
* Item 2 that
  spans over multiple lines
* Item 3
* Item 4
  - bullet lists may nest
  - item 3b
  - valid bullet characters are ``+``, ``*`` and ``-``


Enumerated lists
================

*Enumerated lists*


Definition lists
================

Save this code to the file "greeting.nim". Now compile and run it:

  ``nim run greeting.nim``

As you see, with the ``run`` command Nim executes the file automatically
after compilation. You can even give your program command line arguments by
appending them after the filename that is to be compiled and run:

  ``nim run greeting.nim arg1 arg2``


Tables
======

Nim only implements simple tables of the form::

  ==================      ===============       ===================
  header 1                header 2              header n
  ==================      ===============       ===================
  Cell 1                  Cell 2                Cell 3
  Cell 4                  Cell 5; any           Cell 6
                          cell that is
                          not in column 1
                          may span over
                          multiple lines
  Cell 7                  Cell 8                Cell 9
  ==================      ===============       ===================

This results in:
==================      ===============       ===================
header 1                header 2              header n
==================      ===============       ===================
Cell 1                  Cell 2                Cell 3
Cell 4                  Cell 5; any           Cell 6
                        cell that is
                        not in column 1
                        may span over
                        multiple lines
Cell 7                  Cell 8                Cell 9
==================      ===============       ===================


.. |rst| replace:: reStructuredText
.. _reStructuredText: http://docutils.sourceforge.net/rst.html#reference-documentation
.. _docutils: http://docutils.sourceforge.net/
ref='#n931'>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 4043 4044 4045 4046 4047 4048 4049 4050 4051 4052 4053 4054 4055 4056 4057 4058 4059 4060 4061 4062 4063 4064 4065 4066 4067 4068 4069 4070 4071 4072 4073 4074 4075 4076 4077 4078 4079 4080 4081 4082 4083 4084 4085 4086 4087 4088 4089 4090 4091 4092 4093 4094 4095 4096 4097 4098 4099 4100 4101 4102 4103 4104 4105 4106 4107 4108 4109 4110 4111 4112 4113 4114 4115 4116 4117 4118 4119 4120 4121 4122 4123 4124 4125 4126 4127 4128 4129 4130 4131 4132 4133 4134 4135 4136 4137 4138 4139 4140 4141 4142 4143 4144 4145 4146 4147 4148 4149 4150 4151 4152 4153 4154 4155 4156 4157 4158 4159 4160 4161 4162 4163 4164 4165 4166 4167 4168 4169 4170 4171 4172 4173 4174 4175 4176 4177 4178 4179 4180 4181 4182 4183 4184 4185 4186 4187 4188 4189 4190 4191 4192 4193 4194 4195 4196 4197 4198 4199 4200 4201 4202 4203 4204 4205 4206 4207 4208 4209 4210 4211 4212 4213 4214 4215 4216 4217 4218 4219 4220 4221 4222 4223 4224 4225 4226 4227 4228 4229 4230 4231 4232 4233 4234 4235 4236 4237 4238 4239 4240 4241 4242 4243 4244 4245 4246 4247 4248 4249 4250 4251 4252 4253 4254 4255 4256 4257 4258 4259 4260 4261 4262 4263 4264 4265 4266 4267 4268 4269 4270 4271 4272 4273 4274 4275 4276 4277 4278 4279 4280 4281 4282 4283 4284 4285 4286 4287 4288 4289 4290 4291 4292 4293 4294 4295 4296 4297 4298 4299 4300 4301 4302 4303 4304 4305 4306 4307 4308 4309 4310 4311 4312 4313 4314 4315 4316 4317 4318 4319 4320 4321 4322 4323 4324 4325 4326 4327 4328 4329 4330 4331 4332 4333 4334 4335 4336 4337 4338 4339 4340 4341 4342 4343 4344 4345 4346 4347 4348 4349 4350 4351 4352 4353 4354 4355 4356 4357 4358 4359 4360 4361 4362 4363 4364 4365 4366 4367 4368 4369 4370 4371 4372 4373 4374 4375 4376 4377 4378 4379 4380 4381 4382 4383 4384 4385 4386 4387 4388 4389 4390 4391 4392 4393 4394 4395 4396 4397 4398 4399 4400 4401 4402 4403 4404 4405 4406 4407 4408 4409 4410 4411 4412 4413 4414 4415 4416 4417 4418 4419 4420 4421 4422 4423 4424 4425 4426 4427 4428 4429 4430 4431 4432 4433 4434 4435 4436 4437 4438 4439 4440 4441 4442 4443 4444 4445 4446 4447 4448 4449 4450 4451 4452 4453 4454 4455 4456 4457 4458 4459 4460 4461 4462 4463 4464 4465 4466 4467 4468 4469 4470 4471 4472 4473 4474 4475 4476 4477 4478 4479 4480 4481 4482 4483 4484 4485 4486 4487 4488 4489 4490 4491 4492 4493 4494 4495 4496 4497 4498 4499 4500 4501 4502 4503 4504 4505 4506 4507 4508 4509 4510 4511 4512 4513 4514 4515 4516 4517 4518 4519 4520 4521 4522 4523 4524 4525 4526 4527 4528 4529 4530 4531 4532 4533 4534 4535 4536 4537 4538 4539 4540 4541 4542 4543 4544 4545 4546 4547 4548 4549 4550 4551 4552 4553 4554 4555 4556 4557 4558 4559 4560 4561 4562 4563 4564 4565 4566 4567 4568 4569 4570 4571 4572 4573 4574 4575 4576 4577 4578 4579 4580 4581 4582 4583 4584 4585 4586 4587 4588 4589 4590 4591 4592 4593 4594 4595 4596 4597 4598 4599 4600 4601 4602 4603 4604 4605 4606 4607 4608 4609 4610 4611 4612 4613 4614 4615 4616 4617 4618 4619 4620 4621 4622 4623 4624 4625 4626 4627 4628 4629 4630 4631 4632 4633 4634 4635 4636 4637 4638 4639 4640 4641 4642 4643 4644 4645 4646 4647 4648 4649 4650 4651 4652 4653 4654 4655 4656 4657 4658 4659 4660 4661 4662 4663 4664 4665 4666 4667 4668 4669 4670 4671 4672 4673 4674 4675 4676 4677 4678 4679 4680 4681 4682 4683 4684 4685 4686 4687 4688 4689 4690 4691 4692 4693 4694 4695 4696 4697 4698 4699 4700 4701 4702 4703 4704 4705 4706 4707 4708 4709 4710 4711 4712 4713 4714 4715 4716 4717 4718 4719 4720 4721 4722 4723 4724 4725 4726 4727 4728 4729 4730 4731 4732 4733 4734 4735 4736 4737 4738 4739 4740 4741 4742 4743 4744 4745 4746 4747 4748 4749 4750 4751 4752 4753 4754 4755 4756 4757 4758 4759 4760 4761 4762 4763 4764 4765 4766 4767 4768 4769 4770 4771 4772 4773 4774 4775 4776 4777 4778 4779 4780 4781 4782 4783 4784 4785 4786 4787 4788 4789 4790 4791 4792 4793 4794 4795 4796 4797 4798 4799 4800 4801 4802 4803 4804 4805 4806 4807 4808 4809 4810 4811 4812 4813 4814 4815 4816 4817 4818 4819 4820 4821 4822 4823 4824 4825 4826 4827 4828 4829 4830 4831 4832 4833 4834 4835 4836 4837 4838 4839 4840 4841 4842 4843 4844 4845 4846 4847 4848 4849 4850 4851 4852 4853 4854 4855 4856 4857 4858 4859 4860 4861 4862 4863 4864 4865 4866 4867 4868 4869 4870 4871 4872 4873 4874 4875 4876 4877 4878 4879 4880 4881 4882 4883 4884 4885 4886 4887 4888 4889 4890 4891 4892 4893 4894 4895 4896 4897 4898 4899 4900 4901 4902 4903 4904 4905 4906 4907 4908 4909 4910 4911 4912 4913 4914 4915 4916 4917 4918 4919 4920 4921 4922 4923 4924 4925 4926 4927 4928 4929 4930 4931 4932 4933 4934 4935 4936 4937 4938 4939 4940 4941 4942 4943 4944 4945 4946 4947 4948 4949 4950 4951 4952 4953 4954 4955 4956 4957 4958 4959 4960 4961 4962 4963 4964 4965 4966 4967 4968 4969 4970 4971 4972 4973 4974 4975 4976 4977 4978 4979 4980 4981 4982 4983 4984 4985 4986 4987 4988 4989 4990 4991 4992 4993 4994 4995 4996 4997 4998 4999 5000 5001 5002 5003 5004 5005 5006 5007 5008 5009 5010 5011 5012 5013 5014 5015 5016 5017 5018 5019 5020 5021 5022 5023 5024 5025 5026 5027 5028 5029 5030 5031 5032 5033 5034 5035 5036 5037 5038 5039 5040 5041 5042 5043 5044 5045 5046 5047 5048 5049 5050 5051 5052 5053 5054 5055 5056 5057 5058 5059 5060 5061 5062 5063 5064 5065 5066 5067 5068 5069 5070 5071 5072 5073 5074 5075 5076 5077 5078 5079 5080 5081 5082 5083 5084 5085 5086 5087 5088 5089 5090 5091 5092 5093 5094 5095 5096 5097 5098 5099 5100 5101 5102 5103 5104 5105 5106 5107 5108 5109 5110 5111 5112 5113 5114 5115 5116 5117 5118 5119 5120 5121 5122 5123 5124 5125 5126 5127 5128 5129 5130 5131 5132 5133 5134 5135 5136 5137 5138 5139 5140 5141 5142 5143 5144 5145 5146 5147 5148 5149 5150 5151 5152 5153 5154 5155 5156 5157 5158 5159 5160 5161 5162 5163 5164 5165 5166 5167 5168 5169 5170 5171 5172 5173 5174 5175 5176 5177 5178 5179 5180 5181 5182 5183 5184 5185 5186 5187 5188 5189 5190 5191 5192 5193 5194 5195 5196 5197 5198 5199 5200 5201 5202 5203 5204 5205 5206 5207 5208 5209 5210 5211 5212 5213 5214 5215 5216 5217 5218 5219 5220 5221 5222 5223 5224 5225 5226 5227 5228 5229 5230 5231 5232 5233 5234 5235 5236 5237 5238 5239 5240 5241 5242 5243 5244 5245 5246 5247 5248 5249 5250 5251 5252 5253 5254 5255 5256 5257 5258 5259 5260 5261 5262 5263 5264 5265 5266 5267 5268 5269 5270 5271 5272 5273 5274 5275 5276 5277 5278 5279 5280 5281 5282 5283 5284 5285 5286 5287 5288 5289 5290 5291 5292 5293 5294 5295 5296 5297 5298 5299 5300 5301 5302 5303 5304 5305 5306 5307 5308 5309 5310 5311 5312 5313 5314 5315 5316 5317 5318 5319 5320 5321 5322 5323 5324 5325 5326 5327 5328 5329 5330 5331 5332 5333 5334 5335 5336 5337 5338 5339 5340 5341 5342 5343 5344 5345 5346 5347 5348 5349 5350 5351 5352 5353 5354 5355 5356 5357 5358 5359 5360 5361 5362 5363 5364 5365 5366 5367 5368 5369 5370 5371 5372 5373 5374 5375 5376 5377 5378 5379 5380 5381 5382 5383 5384 5385 5386 5387 5388 5389 5390 5391 5392 5393 5394 5395 5396 5397 5398 5399 5400 5401 5402 5403 5404 5405 5406 5407 5408 5409 5410 5411 5412 5413 5414 5415 5416 5417 5418 5419 5420 5421 5422 5423 5424 5425 5426 5427 5428 5429 5430 5431 5432 5433 5434 5435 5436 5437 5438 5439 5440 5441 5442 5443 5444 5445 5446 5447 5448 5449 5450 5451 5452 5453 5454 5455 5456 5457 5458 5459 5460 5461 5462 5463 5464 5465 5466 5467 5468 5469 5470 5471 5472 5473 5474 5475 5476 5477 5478 5479 5480 5481 5482 5483 5484 5485 5486 5487 5488 5489 5490 5491 5492 5493 5494 5495 5496 5497 5498 5499 5500 5501 5502 5503 5504 5505 5506 5507 5508 5509 5510 5511 5512 5513 5514 5515 5516 5517 5518 5519 5520 5521 5522 5523 5524 5525 5526 5527 5528 5529 5530 5531 5532 5533 5534 5535 5536 5537 5538 5539 5540 5541 5542 5543 5544 5545 5546 5547 5548 5549 5550 5551 5552 5553 5554 5555 5556 5557 5558 5559 5560 5561 5562 5563 5564 5565 5566 5567 5568 5569 5570 5571 5572 5573 5574 5575 5576 5577 5578 5579 5580 5581 5582 5583 5584 5585 5586 5587 5588 5589 5590 5591 5592 5593 5594 5595 5596 5597 5598 5599 5600 5601 5602 5603 5604 5605 5606 5607 5608 5609 5610 5611 5612 5613 5614 5615 5616 5617 5618 5619 5620 5621 5622 5623 5624 5625 5626 5627 5628 5629 5630 5631 5632 5633 5634 5635 5636 5637 5638 5639 5640 5641 5642 5643 5644 5645 5646 5647 5648 5649 5650 5651 5652 5653 5654 5655 5656 5657 5658 5659 5660 5661 5662 5663 5664 5665 5666 5667 5668 5669 5670 5671 5672 5673 5674 5675 5676 5677 5678 5679 5680 5681 5682 5683 5684 5685 5686 5687 5688 5689 5690 5691 5692 5693 5694 5695 5696 5697 5698 5699 5700 5701 5702 5703 5704 5705 5706 5707 5708 5709 5710 5711 5712 5713 5714 5715 5716 5717 5718 5719 5720 5721 5722 5723 5724 5725 5726 5727 5728 5729 5730 5731 5732 5733 5734 5735 5736 5737 5738 5739 5740 5741 5742 5743 5744 5745 5746 5747 5748 5749 5750 5751 5752 5753 5754 5755 5756 5757 5758 5759 5760 5761 5762 5763 5764 5765 5766 5767 5768 5769 5770 5771 5772 5773 5774 5775 5776 5777 5778 5779 5780 5781 5782 5783 5784 5785 5786 5787 5788 5789 5790 5791 5792 5793 5794 5795 5796 5797 5798 5799 5800 5801 5802 5803 5804 5805 5806 5807 5808 5809 5810 5811 5812 5813 5814 5815 5816 5817 5818 5819 5820 5821 5822 5823 5824 5825 5826 5827 5828 5829 5830 5831 5832 5833 5834 5835 5836 5837 5838 5839 5840 5841 5842 5843 5844 5845 5846 5847 5848 5849 5850 5851 5852 5853 5854 5855 5856 5857 5858 5859 5860 5861 5862 5863 5864 5865 5866 5867 5868 5869 5870 5871 5872 5873 5874 5875 5876 5877 5878 5879 5880 5881 5882 5883 5884 5885 5886 5887 5888 5889 5890 5891 5892 5893 5894 5895 5896 5897 5898 5899 5900 5901 5902 5903 5904 5905 5906 5907 5908 5909 5910 5911 5912 5913 5914 5915 5916 5917 5918 5919 5920 5921 5922 5923 5924 5925 5926 5927 5928 5929 5930 5931 5932 5933 5934 5935 5936 5937 5938 5939 5940 5941 5942 5943 5944 5945 5946 5947 5948 5949 5950 5951 5952 5953 5954 5955 5956 5957 5958 5959 5960 5961 5962 5963 5964 5965 5966 5967 5968 5969 5970 5971 5972 5973 5974 5975 5976 5977 5978 5979 5980 5981 5982 5983 5984 5985 5986 5987 5988 5989 5990 5991 5992 5993 5994 5995 5996 5997 5998 5999 6000 6001 6002 6003 6004 6005 6006 6007 6008 6009 6010 6011 6012 6013 6014 6015 6016 6017 6018 6019 6020 6021 6022 6023 6024 6025 6026 6027 6028 6029 6030 6031 6032 6033 6034 6035 6036 6037 6038 6039 6040 6041 6042 6043 6044 6045 6046 6047 6048 6049 6050 6051 6052 6053 6054 6055 6056 6057 6058 6059 6060 6061 6062 6063 6064 6065 6066 6067 6068 6069 6070 6071 6072 6073 6074 6075 6076 6077 6078 6079 6080 6081 6082 6083 6084 6085 6086 6087 6088 6089 6090 6091 6092 6093 6094 6095 6096 6097 6098 6099 6100 6101 6102 6103 6104 6105 6106 6107 6108 6109 6110 6111 6112 6113 6114 6115 6116 6117 6118 6119 6120 6121 6122 6123 6124 6125 6126 6127 6128 6129 6130 6131 6132 6133 6134 6135 6136 6137 6138 6139 6140 6141 6142 6143 6144 6145 6146 6147 6148 6149 6150 6151 6152 6153 6154 6155 6156 6157 6158 6159 6160 6161 6162 6163 6164 6165 6166 6167 6168 6169 6170 6171 6172 6173 6174 6175 6176 6177 6178 6179 6180 6181 6182 6183 6184 6185 6186 6187 6188 6189 6190 6191 6192 6193 6194 6195 6196 6197 6198 6199 6200 6201 6202 6203 6204 6205 6206 6207 6208 6209 6210 6211 6212 6213 6214 6215 6216 6217 6218 6219 6220 6221 6222 6223 6224 6225 6226 6227 6228 6229 6230 6231 6232 6233 6234 6235 6236 6237 6238 6239 6240 6241 6242 6243 6244 6245 6246 6247 6248 6249 6250 6251 6252 6253 6254 6255 6256 6257 6258 6259 6260 6261 6262 6263 6264 6265 6266 6267 6268 6269 6270 6271 6272 6273 6274 6275 6276 6277 6278 6279 6280 6281 6282 6283 6284 6285 6286 6287 6288 6289 6290 6291 6292 6293 6294 6295 6296 6297 6298 6299 6300 6301 6302 6303 6304 6305 6306 6307 6308 6309 6310 6311 6312 6313 6314 6315 6316 6317 6318 6319 6320 6321 6322 6323 6324 6325 6326 6327 6328 6329 6330 6331 6332 6333 6334 6335 6336 6337 6338 6339 6340 6341 6342 6343 6344 6345 6346 6347 6348 6349 6350 6351 6352 6353 6354 6355 6356 6357 6358 6359 6360 6361 6362 6363 6364 6365 6366 6367 6368 6369 6370 6371 6372 6373 6374 6375 6376 6377 6378 6379 6380 6381 6382 6383 6384 6385 6386 6387 6388 6389 6390 6391 6392 6393 6394 6395 6396 6397 6398 6399 6400 6401 6402 6403 6404 6405 6406 6407 6408 6409 6410 6411 6412 6413 6414 6415 6416 6417 6418 6419 6420 6421 6422 6423 6424 6425 6426 6427 6428 6429 6430 6431 6432 6433 6434 6435 6436 6437 6438 6439 6440 6441 6442 6443 6444 6445 6446 6447 6448 6449 6450 6451 6452 6453 6454 6455 6456 6457 6458 6459 6460 6461 6462 6463 6464 6465 6466 6467 6468 6469 6470 6471 6472 6473 6474 6475 6476 6477 6478 6479 6480 6481 6482 6483 6484 6485 6486 6487 6488 6489 6490 6491 6492 6493 6494 6495 6496 6497 6498 6499 6500 6501 6502 6503 6504 6505 6506 6507 6508 6509 6510 6511 6512 6513 6514 6515 6516 6517 6518 6519 6520 6521 6522 6523 6524 6525 6526 6527 6528 6529 6530 6531 6532 6533 6534 6535 6536 6537 6538 6539 6540 6541 6542 6543 6544 6545 6546 6547 6548 6549 6550 6551 6552 6553 6554 6555 6556 6557 6558 6559 6560 6561 6562 6563 6564 6565 6566 6567 6568 6569 6570 6571 6572 6573 6574 6575 6576 6577 6578 6579 6580 6581 6582 6583 6584 6585 6586 6587 6588 6589 6590 6591 6592 6593 6594 6595 6596 6597 6598 6599 6600 6601 6602 6603 6604 6605 6606 6607 6608 6609 6610 6611 6612 6613 6614 6615 6616 6617 6618 6619 6620 6621 6622 6623 6624 6625 6626 6627 6628 6629 6630 6631 6632 6633 6634 6635 6636 6637 6638 6639 6640 6641 6642 6643 6644 6645 6646 6647 6648 6649 6650 6651 6652 6653 6654 6655 6656 6657 6658 6659 6660 6661 6662 6663 6664 6665 6666 6667 6668 6669 6670 6671 6672 6673 6674 6675 6676 6677 6678 6679 6680 6681 6682 6683 6684 6685 6686 6687 6688 6689 6690 6691 6692 6693 6694 6695 6696 6697 6698 6699 6700 6701 6702 6703 6704 6705 6706 6707 6708 6709 6710 6711 6712 6713 6714 6715 6716 6717 6718 6719 6720 6721 6722 6723 6724 6725 6726 6727 6728 6729 6730 6731 6732 6733 6734 6735 6736 6737 6738 6739 6740 6741 6742 6743 6744 6745 6746 6747 6748 6749 6750 6751 6752 6753 6754 6755 6756 6757 6758 6759 6760 6761 6762 6763 6764 6765 6766 6767 6768 6769 6770 6771 6772 6773 6774 6775 6776 6777 6778 6779 6780 6781 6782 6783 6784 6785 6786 6787 6788 6789 6790 6791 6792 6793 6794 6795 6796 6797 6798 6799 6800 6801 6802 6803 6804 6805 6806 6807 6808 6809 6810 6811 6812 6813 6814 6815 6816 6817 6818 6819 6820 6821 6822 6823 6824 6825 6826 6827 6828 6829 6830 6831 6832 6833 6834 6835 6836 6837 6838 6839 6840 6841 6842 6843 6844 6845 6846 6847 6848 6849 6850 6851 6852 6853 6854 6855 6856 6857 6858 6859 6860 6861 6862 6863 6864 6865 6866 6867 6868 6869 6870 6871 6872 6873 6874 6875 6876 6877 6878 6879 6880 6881 6882 6883 6884 6885 6886 6887 6888 6889 6890 6891 6892 6893 6894 6895 6896 6897 6898 6899 6900 6901 6902 6903 6904 6905 6906 6907 6908 6909 6910 6911 6912 6913 6914 6915 6916 6917 6918 6919 6920 6921 6922 6923 6924 6925 6926 6927 6928 6929 6930 6931 6932 6933 6934 6935 6936 6937 6938 6939 6940 6941 6942 6943 6944 6945 6946 6947 6948 6949 6950 6951 6952 6953 6954 6955 6956 6957 6958 6959 6960 6961 6962 6963 6964 6965 6966 6967 6968 6969 6970 6971 6972 6973 6974 6975 6976 6977 6978 6979 6980 6981 6982 6983 6984 6985 6986 6987 6988 6989 6990 6991 6992 6993 6994 6995 6996 6997 6998 6999 7000 7001 7002 7003 7004 7005 7006 7007 7008 7009 7010 7011 7012 7013 7014 7015 7016 7017 7018 7019 7020 7021 7022 7023 7024 7025 7026 7027 7028 7029 7030 7031 7032 7033 7034 7035 7036 7037 7038 7039 7040 7041 7042 7043 7044 7045 7046 7047 7048 7049 7050 7051 7052 7053 7054 7055 7056 7057 7058 7059 7060 7061 7062 7063 7064 7065 7066 7067 7068 7069 7070 7071 7072 7073 7074 7075 7076 7077 7078 7079 7080 7081 7082 7083 7084 7085 7086 7087 7088 7089 7090 7091 7092 7093 7094 7095 7096 7097 7098 7099 7100 7101 7102 7103 7104 7105 7106 7107 7108 7109 7110 7111 7112 7113 7114 7115 7116 7117 7118 7119 7120 7121 7122 7123 7124 7125 7126 7127 7128 7129 7130 7131 7132 7133 7134 7135 7136 7137 7138 7139 7140 7141 7142 7143 7144 7145 7146 7147 7148 7149 7150 7151 7152 7153 7154 7155 7156 7157 7158 7159 7160 7161 7162 7163 7164 7165 7166 7167 7168 7169 7170 7171 7172 7173 7174 7175 7176 7177 7178 7179 7180 7181 7182 7183 7184 7185 7186 7187 7188 7189 7190 7191 7192 7193 7194 7195 7196 7197 7198 7199 7200 7201 7202 7203 7204 7205 7206 7207 7208 7209 7210 7211 7212 7213 7214 7215 7216 7217 7218 7219 7220 7221 7222 7223 7224 7225 7226 7227 7228 7229 7230 7231 7232 7233 7234 7235 7236 7237 7238 7239 7240 7241 7242 7243 7244 7245 7246 7247 7248 7249 7250 7251 7252 7253 7254 7255 7256 7257 7258 7259 7260 7261 7262 7263 7264 7265 7266 7267 7268 7269 7270 7271 7272 7273 7274 7275 7276 7277 7278 7279 7280 7281 7282 7283 7284 7285 7286 7287 7288 7289 7290 7291 7292 7293 7294 7295 7296 7297 7298 7299 7300 7301 7302 7303 7304 7305 7306 7307 7308 7309 7310 7311 7312 7313 7314 7315 7316 7317 7318 7319 7320 7321 7322 7323 7324 7325 7326 7327 7328 7329 7330 7331 7332 7333 7334 7335 7336 7337 7338 7339 7340 7341 7342 7343 7344 7345 7346 7347 7348 7349 7350 7351 7352 7353 7354 7355 7356 7357 7358 7359 7360 7361 7362 7363 7364 7365 7366 7367 7368 7369 7370 7371 7372 7373 7374 7375 7376 7377 7378 7379 7380 7381 7382 7383 7384 7385 7386 7387 7388 7389 7390 7391 7392 7393 7394 7395 7396 7397 7398 7399 7400 7401 7402 7403 7404 7405 7406 7407 7408 7409 7410 7411 7412 7413 7414 7415 7416 7417 7418 7419 7420 7421 7422 7423 7424 7425 7426 7427 7428 7429 7430 7431 7432 7433 7434 7435 7436 7437 7438 7439 7440 7441 7442 7443 7444 7445 7446 7447 7448 7449 7450 7451 7452 7453 7454 7455 7456 7457 7458 7459 7460 7461 7462 7463 7464 7465 7466 7467 7468 7469 7470 7471 7472 7473 7474 7475 7476 7477 7478 7479 7480 7481 7482 7483 7484 7485 7486 7487 7488 7489 7490 7491 7492 7493 7494 7495 7496 7497 7498 7499 7500 7501 7502 7503 7504 7505 7506 7507 7508 7509 7510 7511 7512 7513 7514 7515 7516 7517 7518 7519 7520 7521 7522 7523 7524 7525 7526 7527 7528 7529 7530 7531 7532 7533 7534 7535 7536 7537 7538 7539 7540 7541 7542 7543 7544 7545 7546 7547 7548 7549 7550 7551 7552 7553 7554 7555 7556 7557 7558 7559 7560 7561 7562 7563 7564 7565 7566 7567 7568 7569 7570 7571 7572 7573 7574 7575 7576 7577 7578 7579 7580 7581 7582 7583 7584 7585 7586 7587 7588 7589 7590 7591 7592 7593 7594 7595 7596 7597 7598 7599 7600 7601 7602 7603 7604 7605 7606 7607 7608 7609 7610 7611 7612 7613 7614 7615 7616 7617 7618 7619 7620 7621 7622 7623 7624 7625 7626 7627 7628 7629 7630 7631 7632 7633 7634 7635 7636 7637 7638 7639 7640 7641 7642 7643 7644 7645 7646 7647 7648 7649 7650 7651 7652 7653 7654 7655 7656 7657 7658 7659 7660 7661 7662 7663 7664 7665 7666 7667 7668 7669 7670 7671 7672 7673 7674 7675 7676 7677 7678 7679 7680 7681 7682 7683 7684 7685 7686 7687 7688 7689 7690 7691 7692 7693 7694 7695 7696 7697 7698 7699 7700 7701 7702 7703 7704 7705 7706 7707 7708 7709 7710 7711 7712 7713 7714 7715 7716 7717 7718 7719 7720 7721 7722 7723 7724 7725 7726 7727 7728 7729 7730 7731 7732 7733 7734 7735 7736 7737 7738 7739 7740 7741 7742 7743 7744 7745 7746 7747 7748 7749 7750 7751 7752 7753 7754 7755 7756 7757 7758 7759 7760 7761 7762 7763 7764 7765 7766 7767 7768 7769 7770 7771 7772 7773 7774 7775 7776 7777 7778 7779 7780 7781 7782 7783 7784 7785 7786 7787 7788 7789 7790 7791 7792 7793 7794 7795 7796 7797 7798 7799 7800 7801 7802 7803 7804 7805 7806 7807 7808 7809 7810 7811 7812 7813 7814 7815 7816 7817 7818 7819 7820 7821 7822 7823 7824 7825 7826 7827 7828 7829 7830 7831 7832 7833 7834 7835 7836 7837 7838 7839 7840 7841 7842 7843 7844 7845 7846 7847 7848 7849 7850 7851 7852 7853 7854 7855 7856 7857 7858 7859 7860 7861 7862 7863 7864 7865 7866 7867 7868 7869 7870 7871 7872 7873 7874 7875 7876 7877 7878 7879 7880 7881 7882 7883 7884 7885 7886 7887 7888 7889 7890 7891 7892 7893 7894 7895 7896 7897 7898 7899 7900 7901 7902 7903 7904 7905 7906 7907 7908 7909 7910 7911 7912 7913 7914 7915 7916 7917 7918 7919 7920 7921 7922 7923 7924 7925 7926 7927 7928 7929 7930 7931 7932 7933 7934 7935 7936 7937 7938 7939 7940 7941 7942 7943 7944 7945 7946 7947 7948 7949 7950 7951 7952 7953 7954 7955 7956 7957 7958 7959 7960 7961 7962 7963 7964 7965 7966 7967 7968 7969 7970 7971 7972 7973 7974 7975 7976 7977 7978 7979 7980 7981 7982 7983 7984 7985 7986 7987 7988 7989 7990 7991 7992 7993 7994 7995 7996 7997 7998 7999 8000 8001 8002 8003 8004 8005 8006 8007 8008 8009 8010 8011 8012 8013 8014 8015 8016 8017 8018 8019 8020 8021 8022 8023 8024 8025 8026 8027 8028 8029 8030 8031 8032 8033 8034 8035 8036 8037 8038 8039 8040 8041 8042 8043 8044 8045 8046 8047 8048 8049 8050 8051 8052 8053 8054 8055 8056 8057 8058 8059 8060 8061 8062 8063 8064 8065 8066 8067 8068 8069 8070 8071 8072 8073 8074 8075 8076 8077 8078 8079 8080 8081 8082 8083 8084 8085 8086 8087 8088 8089 8090 8091 8092 8093 8094 8095 8096 8097 8098 8099 8100 8101 8102 8103 8104 8105 8106 8107 8108 8109 8110 8111 8112 8113 8114 8115 8116 8117 8118 8119 8120 8121 8122 8123 8124 8125 8126 8127 8128 8129 8130 8131 8132 8133 8134 8135 8136 8137 8138 8139 8140 8141 8142 8143 8144 8145 8146 8147 8148 8149 8150 8151 8152 8153 8154 8155 8156 8157 8158 8159 8160 8161 8162 8163 8164 8165 8166 8167 8168 8169 8170 8171 8172 8173 8174 8175 8176 8177 8178 8179 8180 8181 8182 8183 8184 8185 8186 8187 8188 8189 8190 8191 8192 8193 8194 8195 8196 8197 8198 8199 8200 8201 8202 8203 8204 8205 8206 8207 8208 8209 8210 8211 8212 8213 8214 8215 8216 8217 8218 8219 8220 8221 8222 8223 8224 8225 8226 8227 8228 8229 8230 8231 8232 8233 8234 8235 8236 8237 8238 8239 8240 8241 8242 8243 8244 8245 8246 8247 8248 8249 8250 8251 8252 8253 8254 8255 8256 8257 8258 8259 8260 8261 8262 8263 8264 8265 8266 8267 8268 8269 8270 8271 8272 8273 8274 8275 8276 8277 8278 8279 8280 8281 8282 8283 8284 8285 8286 8287 8288 8289 8290 8291 8292 8293 8294 8295 8296 8297 8298 8299 8300 8301 8302 8303 8304 8305 8306 8307 8308 8309 8310 8311 8312 8313 8314 8315 8316 8317 8318 8319 8320 8321 8322 8323 8324 8325 8326 8327 8328 8329 8330 8331 8332 8333 8334 8335 8336 8337 8338 8339 8340 8341 8342 8343 8344 8345 8346 8347 8348 8349 8350 8351 8352 8353 8354 8355 8356 8357 8358 8359 8360 8361 8362 8363 8364 8365 8366 8367 8368 8369 8370 8371 8372 8373 8374 8375 8376 8377 8378 8379 8380 8381 8382 8383 8384 8385 8386 8387 8388 8389 8390 8391 8392 8393 8394 8395 8396 8397 8398 8399 8400 8401 8402 8403 8404 8405 8406 8407 8408 8409 8410 8411 8412 8413 8414 8415 8416 8417 8418 8419 8420 8421 8422 8423 8424 8425 8426 8427 8428 8429 8430 8431 8432 8433 8434 8435 8436 8437 8438 8439 8440 8441 8442 8443 8444 8445 8446 8447 8448 8449 8450 8451 8452 8453 8454 8455 8456 8457 8458 8459 8460 8461 8462 8463 8464 8465 8466 8467 8468 8469 8470 8471 8472 8473 8474 8475 8476 8477 8478 8479 8480 8481 8482 8483 8484 8485 8486 8487 8488 8489 8490 8491 8492 8493 8494 8495 8496 8497 8498 8499 8500 8501 8502 8503 8504 8505 8506 8507 8508 8509 8510 8511 8512 8513 8514 8515 8516 8517 8518 8519 8520 8521 8522 8523 8524 8525 8526 8527 8528 8529 8530 8531 8532 8533 8534 8535 8536 8537 8538 8539 8540 8541 8542 8543 8544 8545 8546 8547 8548 8549 8550 8551 8552 8553 8554 8555 8556 8557 8558 8559 8560 8561 8562 8563 8564 8565 8566 8567 8568 8569 8570 8571 8572 8573 8574 8575 8576 8577 8578 8579 8580 8581 8582 8583 8584 8585 8586 8587 8588 8589 8590 8591 8592 8593 8594 8595 8596 8597 8598 8599 8600 8601 8602 8603 8604 8605 8606 8607 8608 8609 8610 8611 8612 8613 8614 8615 8616 8617 8618 8619 8620 8621 8622 8623 8624 8625 8626 8627 8628 8629 8630 8631 8632 8633 8634 8635 8636 8637 8638 8639 8640 8641 8642 8643 8644 8645 8646 8647 8648 8649 8650 8651 8652 8653 8654 8655 8656 8657 8658 8659 8660 8661 8662 8663 8664 8665 8666 8667 8668 8669 8670 8671 8672 8673 8674 8675 8676 8677 8678 8679 8680 8681 8682 8683 8684 8685 8686 8687 8688 8689 8690 8691 8692 8693 8694 8695 8696 8697 8698 8699 8700 8701 8702 8703 8704 8705 8706 8707 8708 8709 8710 8711 8712 8713 8714 8715 8716 8717 8718 8719 8720 8721 8722 8723 8724 8725 8726 8727 8728 8729 8730 8731 8732 8733 8734 8735 8736 8737 8738 8739 8740 8741 8742 8743 8744 8745 8746 8747 8748 8749 8750 8751 8752 8753 8754 8755 8756 8757 8758 8759 8760 8761 8762 8763 8764 8765 8766 8767 8768 8769 8770 8771 8772 8773 8774 8775 8776 8777 8778 8779 8780 8781 8782 8783 8784 8785 8786 8787 8788 8789 8790 8791 8792 8793 8794 8795 8796 8797 8798 8799 8800 8801 8802 8803 8804 8805 8806 8807 8808 8809 8810 8811 8812 8813 8814 8815 8816 8817 8818 8819 8820 8821 8822 8823 8824 8825 8826 8827 8828 8829 8830 8831 8832 8833 8834 8835 8836 8837 8838 8839 8840 8841 8842 8843 8844 8845 8846 8847 8848 8849 8850 8851 8852 8853 8854 8855 8856 8857 8858 8859 8860 8861 8862 8863 8864 8865 8866 8867 8868 8869 8870 8871 8872 8873 8874 8875 8876 8877 8878 8879 8880 8881 8882 8883 8884 8885 8886 8887 8888 8889 8890 8891 8892 8893 8894 8895 8896 8897 8898 8899 8900 8901 8902 8903 8904 8905 8906 8907 8908 8909 8910 8911 8912 8913 8914 8915 8916 8917 8918 8919 8920 8921 8922 8923 8924 8925 8926 8927 8928 8929 8930 8931 8932 8933 8934 8935 8936 8937 8938 8939 8940 8941 8942 8943 8944 8945 8946 8947 8948 8949 8950 8951 8952 8953 8954 8955 8956 8957 8958 8959 8960 8961 8962 8963 8964 8965 8966 8967 8968 8969 8970 8971 8972 8973 8974 8975 8976 8977 8978 8979 8980 8981 8982 8983 8984 8985 8986 8987 8988 8989 8990 8991 8992 8993 8994 8995 8996 8997 8998 8999 9000 9001 9002 9003 9004 9005 9006 9007 9008 9009 9010 9011 9012 9013 9014 9015 9016 9017 9018 9019 9020 9021 9022 9023 9024 9025 9026 9027 9028 9029 9030 9031 9032 9033 9034 9035 9036 9037 9038 9039 9040 9041 9042 9043 9044 9045 9046 9047 9048 9049 9050 9051 9052 9053 9054 9055 9056 9057 9058 9059 9060 9061 9062 9063 9064 9065 9066 9067 9068 9069 9070 9071 9072 9073 9074 9075 9076 9077 9078 9079 9080 9081 9082 9083 9084 9085 9086 9087 9088 9089 9090 9091 9092 9093 9094 9095 9096 9097 9098 9099 9100 9101 9102 9103 9104 9105 9106 9107 9108 9109 9110 9111 9112 9113 9114 9115 9116 9117 9118 9119 9120 9121 9122 9123 9124 9125 9126 9127 9128 9129 9130 9131 9132 9133 9134 9135 9136 9137 9138 9139 9140 9141 9142 9143 9144 9145 9146 9147 9148 9149 9150 9151 9152 9153 9154 9155 9156 9157 9158 9159 9160 9161 9162 9163 9164 9165 9166 9167 9168 9169 9170 9171 9172 9173 9174 9175 9176 9177 9178 9179 9180 9181 9182 9183 9184 9185 9186 9187 9188 9189 9190 9191 9192 9193 9194 9195 9196 9197 9198 9199 9200 9201 9202 9203 9204 9205 9206 9207 9208 9209 9210 9211 9212 9213 9214 9215 9216 9217 9218 9219 9220 9221 9222 9223 9224 9225 9226 9227 9228 9229 9230 9231 9232 9233 9234 9235 9236 9237 9238 9239 9240 9241 9242 9243 9244 9245 9246 9247 9248 9249 9250 9251 9252 9253 9254 9255 9256 9257 9258 9259 9260 9261 9262 9263 9264 9265 9266 9267 9268 9269 9270 9271 9272 9273 9274 9275 9276 9277 9278 9279 9280 9281 9282 9283 9284 9285 9286 9287 9288 9289 9290 9291 9292 9293 9294 9295 9296 9297 9298 9299 9300 9301 9302 9303 9304 9305 9306 9307 9308 9309 9310 9311 9312 9313 9314 9315 9316 9317 9318 9319 9320 9321 9322 9323 9324 9325 9326 9327 9328 9329 9330 9331 9332 9333 9334 9335 9336 9337 9338 9339 9340 9341 9342 9343 9344 9345 9346 9347 9348 9349 9350 9351 9352 9353 9354 9355 9356 9357 9358 9359 9360 9361 9362 9363 9364 9365 9366 9367 9368 9369 9370 9371 9372 9373 9374 9375 9376 9377 9378 9379 9380 9381 9382 9383 9384 9385 9386 9387 9388 9389 9390 9391 9392 9393 9394 9395 9396 9397 9398 9399 9400 9401 9402 9403 9404 9405 9406 9407 9408 9409 9410 9411 9412 9413 9414 9415 9416 9417 9418 9419 9420 9421 9422 9423 9424 9425 9426 9427 9428 9429 9430 9431 9432 9433 9434 9435 9436 9437 9438 9439 9440 9441 9442 9443 9444 9445 9446 9447 9448 9449 9450 9451 9452 9453 9454 9455 9456 9457 9458 9459 9460 9461 9462 9463 9464 9465 9466 9467 9468 9469 9470 9471 9472 9473 9474 9475 9476 9477 9478 9479 9480 9481 9482 9483 9484 9485 9486 9487 9488 9489 9490 9491 9492 9493 9494 9495 9496 9497 9498 9499 9500 9501 9502 9503 9504 9505 9506 9507 9508 9509 9510 9511 9512 9513 9514 9515 9516 9517 9518 9519 9520 9521 9522 9523 9524 9525 9526 9527 9528 9529 9530 9531 9532 9533 9534 9535 9536 9537 9538 9539 9540 9541 9542 9543 9544 9545 9546 9547 9548 9549 9550 9551 9552 9553 9554 9555 9556 9557 9558 9559 9560 9561 9562 9563 9564 9565 9566 9567 9568 9569 9570 9571 9572 9573 9574 9575 9576 9577 9578 9579 9580 9581 9582 9583 9584 9585 9586 9587 9588 9589 9590 9591 9592 9593 9594 9595 9596 9597 9598 9599 9600 9601 9602 9603 9604 9605 9606 9607 9608 9609 9610 9611 9612 9613 9614 9615 9616 9617 9618 9619 9620 9621 9622 9623 9624 9625 9626 9627 9628 9629 9630 9631 9632 9633 9634 9635 9636 9637 9638 9639 9640 9641 9642 9643 9644 9645 9646 9647 9648 9649 9650 9651 9652 9653 9654 9655 9656 9657 9658 9659 9660 9661 9662 9663 9664 9665 9666 9667 9668 9669 9670 9671 9672 9673 9674 9675 9676 9677 9678 9679 9680 9681 9682 9683 9684 9685 9686 9687 9688 9689 9690 9691 9692 9693 9694 9695 9696 9697 9698 9699 9700 9701 9702 9703 9704 9705 9706 9707 9708 9709 9710 9711 9712 9713 9714 9715 9716 9717 9718 9719 9720 9721 9722 9723 9724 9725 9726 9727 9728 9729 9730 9731 9732 9733 9734 9735 9736 9737 9738 9739 9740 9741 9742 9743 9744 9745 9746 9747 9748 9749 9750 9751 9752 9753 9754 9755 9756 9757 9758 9759 9760 9761 9762 9763 9764 9765 9766 9767 9768 9769 9770 9771 9772 9773 9774 9775 9776 9777 9778 9779 9780 9781 9782 9783 9784 9785 9786 9787 9788 9789 9790 9791 9792 9793 9794 9795 9796 9797 9798 9799 9800 9801 9802 9803 9804 9805 9806 9807 9808 9809 9810 9811 9812 9813 9814 9815 9816 9817 9818 9819 9820 9821 9822 9823 9824 9825 9826 9827 9828 9829 9830 9831 9832 9833 9834 9835 9836 9837 9838 9839 9840 9841 9842 9843 9844 9845 9846 9847 9848 9849 9850 9851 9852 9853 9854 9855 9856 9857 9858 9859 9860 9861 9862 9863 9864 9865 9866 9867 9868 9869 9870 9871 9872 9873 9874 9875 9876 9877 9878 9879 9880 9881 9882 9883 9884 9885 9886 9887 9888 9889 9890 9891 9892 9893 9894 9895 9896 9897 9898 9899 9900 9901 9902 9903 9904 9905 9906 9907 9908 9909 9910 9911 9912 9913 9914 9915 9916 9917 9918 9919 9920 9921 9922 9923 9924 9925 9926 9927 9928 9929 9930 9931 9932 9933 9934 9935 9936 9937 9938 9939 9940 9941 9942 9943 9944 9945 9946 9947 9948 9949 9950 9951 9952 9953 9954 9955 9956 9957 9958 9959 9960 9961 9962 9963 9964 9965 9966 9967 9968 9969 9970 9971 9972 9973 9974 9975 9976 9977 9978 9979 9980 9981 9982 9983 9984 9985 9986 9987 9988 9989 9990 9991 9992 9993 9994 9995 9996 9997 9998 9999 10000 10001 10002 10003 10004 10005 10006 10007 10008 10009 10010 10011 10012 10013 10014 10015 10016 10017 10018 10019 10020 10021 10022 10023 10024 10025 10026 10027 10028 10029 10030 10031 10032 10033 10034 10035 10036 10037 10038 10039 10040 10041 10042 10043 10044 10045 10046 10047 10048 10049 10050 10051 10052 10053 10054 10055 10056 10057 10058 10059 10060 10061 10062 10063 10064 10065 10066 10067 10068 10069 10070 10071 10072 10073 10074 10075 10076 10077 10078 10079 10080 10081 10082 10083 10084 10085 10086 10087 10088 10089 10090 10091 10092 10093 10094 10095 10096 10097 10098 10099 10100 10101 10102 10103 10104 10105 10106 10107 10108 10109 10110 10111 10112 10113 10114 10115 10116 10117 10118 10119 10120 10121 10122 10123 10124 10125 10126 10127 10128 10129 10130 10131 10132 10133 10134 10135 10136 10137 10138 10139 10140 10141 10142 10143 10144 10145 10146 10147 10148 10149 10150 10151 10152 10153 10154 10155 10156 10157 10158 10159 10160 10161 10162 10163 10164 10165 10166 10167 10168 10169 10170 10171 10172 10173 10174 10175 10176 10177 10178 10179 10180 10181 10182 10183 10184 10185 10186 10187 10188 10189 10190 10191 10192 10193 10194 10195 10196 10197 10198 10199 10200 10201 10202 10203 10204 10205 10206 10207 10208 10209 10210 10211 10212 10213 10214 10215 10216 10217 10218 10219 10220 10221 10222 10223 10224 10225 10226 10227 10228 10229 10230 10231 10232 10233 10234 10235 10236 10237 10238 10239 10240 10241 10242 10243 10244 10245 10246 10247 10248 10249 10250 10251 10252 10253 10254 10255 10256 10257 10258 10259 10260 10261 10262 10263 10264 10265 10266 10267 10268 10269 10270 10271 10272 10273 10274 10275 10276 10277 10278 10279 10280 10281 10282 10283 10284 10285 10286 10287 10288 10289 10290 10291 10292 10293 10294 10295 10296 10297 10298 10299 10300 10301 10302 10303 10304 10305 10306 10307 10308 10309 10310 10311 10312 10313 10314 10315 10316 10317 10318 10319 10320 10321 10322 10323 10324 10325 10326 10327 10328 10329 10330 10331 10332 10333 10334 10335 10336 10337 10338 10339 10340 10341 10342 10343 10344 10345 10346 10347 10348 10349 10350 10351 10352 10353 10354 10355 10356 10357 10358 10359 10360 10361 10362 10363 10364 10365 10366 10367 10368 10369 10370 10371 10372 10373 10374 10375 10376 10377 10378 10379 10380 10381 10382 10383 10384 10385 10386 10387 10388 10389 10390 10391 10392 10393 10394 10395 10396 10397 10398 10399 10400 10401 10402 10403 10404 10405 10406 10407 10408 10409 10410 10411 10412 10413 10414 10415 10416 10417 10418 10419 10420 10421 10422 10423 10424 10425 10426 10427 10428 10429 10430 10431 10432 10433 10434 10435 10436 10437 10438 10439 10440 10441 10442 10443 10444 10445 10446 10447 10448 10449 10450 10451 10452 10453 10454 10455 10456 10457 10458 10459 10460 10461 10462 10463 10464 10465 10466 10467 10468 10469 10470 10471 10472 10473 10474 10475 10476 10477 10478 10479 10480 10481 10482 10483 10484 10485 10486 10487 10488 10489 10490 10491 10492 10493 10494 10495 10496 10497 10498 10499 10500 10501 10502 10503 10504 10505 10506 10507 10508 10509 10510 10511 10512 10513 10514 10515 10516 10517 10518 10519 10520 10521 10522 10523 10524 10525 10526 10527 10528 10529 10530 10531 10532 10533 10534 10535 10536 10537 10538 10539 10540 10541 10542 10543 10544 10545 10546 10547 10548 10549 10550 10551 10552 10553 10554 10555 10556 10557 10558 10559 10560 10561 10562 10563 10564 10565 10566 10567 10568 10569 10570 10571 10572 10573 10574 10575 10576 10577 10578 10579 10580 10581 10582 10583 10584 10585 10586 10587 10588 10589 10590 10591 10592 10593 10594 10595 10596 10597 10598 10599 10600 10601 10602 10603 10604 10605 10606 10607 10608 10609 10610 10611 10612 10613 10614 10615 10616 10617 10618 10619 10620 10621 10622 10623 10624 10625 10626 10627 10628 10629 10630 10631 10632 10633 10634 10635 10636 10637 10638 10639 10640 10641 10642 10643 10644 10645 10646 10647 10648 10649 10650 10651 10652 10653 10654 10655 10656 10657 10658 10659 10660 10661 10662 10663 10664 10665 10666 10667 10668 10669 10670 10671 10672 10673 10674 10675 10676 10677 10678 10679 10680 10681 10682 10683 10684 10685 10686 10687 10688 10689 10690 10691 10692 10693 10694 10695 10696 10697 10698 10699 10700 10701 10702 10703 10704 10705 10706 10707 10708 10709 10710 10711 10712 10713 10714 10715 10716 10717 10718 10719 10720 10721 10722 10723 10724 10725 10726 10727 10728 10729 10730 10731 10732 10733 10734 10735 10736 10737 10738 10739 10740 10741 10742 10743 10744 10745 10746 10747 10748 10749 10750 10751 10752 10753 10754 10755 10756 10757 10758 10759 10760 10761 10762 10763 10764 10765 10766 10767 10768 10769 10770 10771 10772 10773 10774 10775 10776 10777 10778 10779 10780 10781 10782 10783 10784 10785 10786 10787 10788 10789 10790 10791 10792 10793 10794 10795 10796 10797 10798 10799 10800 10801 10802 10803 10804 10805 10806 10807 10808 10809 10810 10811 10812 10813 10814 10815 10816 10817 10818 10819 10820 10821 10822 10823 10824 10825 10826 10827 10828 10829 10830 10831 10832 10833 10834 10835 10836 10837 10838 10839 10840 10841 10842 10843 10844 10845 10846 10847 10848 10849 10850 10851 10852 10853 10854 10855 10856 10857 10858 10859 10860 10861 10862 10863 10864 10865 10866 10867 10868 10869 10870 10871 10872 10873 10874 10875 10876 10877 10878 10879 10880 10881 10882 10883 10884 10885 10886 10887 10888 10889 10890 10891 10892 10893 10894 10895 10896 10897 10898 10899 10900 10901 10902 10903 10904 10905 10906 10907 10908 10909 10910 10911 10912 10913 10914 10915 10916 10917 10918 10919 10920 10921 10922 10923 10924 10925 10926 10927 10928 10929 10930 10931 10932 10933 10934 10935 10936 10937 10938 10939 10940 10941 10942 10943 10944 10945 10946 10947 10948 10949 10950 10951 10952 10953 10954 10955 10956 10957 10958 10959 10960 10961 10962 10963 10964 10965 10966 10967 10968 10969 10970 10971 10972 10973 10974 10975 10976 10977 10978 10979 10980 10981 10982 10983 10984 10985 10986 10987 10988 10989 10990 10991 10992 10993 10994 10995 10996 10997 10998 10999 11000 11001 11002 11003 11004 11005 11006 11007 11008 11009 11010 11011 11012 11013 11014 11015 11016 11017 11018 11019 11020 11021 11022 11023 11024 11025 11026 11027 11028 11029 11030 11031 11032 11033 11034 11035 11036 11037 11038 11039 11040 11041 11042 11043 11044 11045 11046 11047 11048 11049 11050 11051 11052 11053 11054 11055 11056 11057 11058 11059 11060 11061 11062 11063 11064 11065 11066 11067 11068 11069 11070 11071 11072 11073 11074 11075 11076 11077 11078 11079 11080 11081 11082 11083 11084 11085 11086 11087 11088 11089 11090 11091 11092 11093 11094 11095 11096 11097 11098 11099 11100 11101 11102 11103 11104 11105 11106 11107 11108 11109 11110 11111 11112 11113 11114 11115 11116 11117 11118 11119 11120 11121 11122 11123 11124 11125 11126 11127 11128 11129 11130 11131 11132 11133 11134 11135 11136 11137 11138 11139 11140 11141 11142 11143 11144 11145 11146 11147 11148 11149 11150 11151 11152 11153 11154 11155 11156 11157 11158 11159 11160 11161 11162 11163 11164 11165 11166 11167 11168 11169 11170 11171 11172 11173 11174 11175 11176 11177 11178 11179 11180 11181 11182 11183 11184 11185 11186 11187 11188 11189 11190 11191 11192 11193 11194 11195 11196 11197 11198 11199 11200 11201 11202 11203 11204 11205 11206 11207 11208 11209 11210 11211 11212 11213 11214 11215 11216 11217 11218 11219 11220 11221 11222 11223 11224 11225 11226 11227 11228 11229 11230 11231 11232 11233 11234 11235 11236 11237 11238 11239 11240 11241 11242 11243 11244 11245 11246 11247 11248 11249 11250 11251 11252 11253 11254 11255 11256 11257 11258 11259 11260 11261 11262 11263 11264 11265 11266 11267 11268 11269 11270 11271 11272 11273 11274 11275 11276 11277 11278 11279 11280 11281 11282 11283 11284 11285 11286 11287 11288 11289 11290 11291 11292 11293 11294 11295 11296 11297 11298 11299 11300 11301 11302 11303 11304 11305 11306 11307 11308 11309 11310 11311 11312 11313 11314 11315 11316 11317 11318 11319 11320 11321 11322 11323 11324 11325 11326 11327 11328 11329 11330 11331 11332 11333 11334 11335 11336 11337 11338 11339 11340 11341 11342 11343 11344 11345 11346 11347 11348 11349 11350 11351 11352 11353 11354 11355 11356 11357 11358 11359 11360 11361 11362 11363 11364 11365 11366 11367 11368 11369 11370 11371 11372 11373 11374 11375 11376 11377 11378 11379 11380 11381 11382 11383 11384 11385 11386 11387 11388 11389 11390 11391 11392 11393 11394 11395 11396 11397 11398 11399 11400 11401 11402 11403 11404 11405 11406 11407 11408 11409 11410 11411 11412 11413 11414 11415 11416 11417 11418 11419 11420 11421 11422 11423 11424 11425 11426 11427 11428 11429 11430 11431 11432 11433 11434 11435 11436 11437 11438 11439 11440 11441 11442 11443 11444 11445 11446 11447 11448 11449 11450 11451 11452 11453 11454 11455 11456 11457 11458 11459 11460 11461 11462 11463 11464 11465 11466 11467 11468 11469 11470 11471 11472 11473 11474 11475 11476 11477 11478 11479 11480 11481 11482 11483 11484 11485 11486 11487 11488 11489 11490 11491 11492 11493 11494 11495 11496 11497 11498 11499 11500 11501 11502 11503 11504 11505 11506 11507 11508 11509 11510 11511 11512 11513 11514 11515 11516 11517 11518 11519 11520 11521 11522 11523 11524 11525 11526 11527 11528 11529 11530 11531 11532 11533 11534 11535 11536 11537 11538 11539 11540 11541 11542 11543 11544 11545 11546 11547 11548 11549 11550 11551 11552 11553 11554 11555 11556 11557 11558 11559 11560 11561 11562 11563 11564 11565 11566 11567 11568 11569 11570 11571 11572 11573 11574 11575 11576 11577 11578 11579 11580 11581 11582 11583 11584 11585 11586 11587 11588 11589 11590 11591 11592 11593 11594 11595 11596 11597 11598 11599 11600 11601 11602 11603 11604 11605 11606 11607 11608 11609 11610 11611 11612 11613 11614 11615 11616 11617 11618 11619 11620 11621 11622 11623 11624 11625 11626 11627 11628 11629 11630 11631 11632 11633 11634 11635 11636 11637 11638 11639 11640 11641 11642 11643 11644 11645 11646 11647 11648 11649 11650 11651 11652 11653 11654 11655 11656 11657 11658 11659 11660 11661 11662 11663 11664 11665 11666 11667 11668 11669 11670 11671 11672 11673 11674 11675 11676 11677 11678 11679 11680 11681 11682 11683 11684 11685 11686 11687 11688 11689 11690 11691 11692 11693 11694 11695 11696 11697 11698 11699 11700 11701 11702 11703 11704 11705 11706 11707 11708 11709 11710 11711 11712 11713 11714 11715 11716 11717 11718 11719 11720 11721 11722 11723 11724 11725 11726 11727 11728 11729 11730 11731 11732 11733 11734 11735 11736 11737 11738 11739 11740 11741 11742 11743 11744 11745 11746 11747 11748 11749 11750 11751 11752 11753 11754 11755 11756 11757 11758 11759 11760 11761 11762 11763 11764 11765 11766 11767 11768 11769 11770 11771 11772 11773 11774 11775 11776 11777 11778 11779 11780 11781 11782 11783 11784 11785 11786 11787 11788 11789 11790 11791 11792 11793 11794 11795 11796 11797 11798 11799 11800 11801 11802 11803 11804 11805 11806 11807 11808 11809 11810 11811 11812 11813 11814 11815 11816 11817 11818 11819 11820 11821 11822 11823 11824 11825 11826 11827 11828 11829 11830 11831 11832 11833 11834 11835 11836 11837 11838 11839 11840 11841 11842 11843 11844 11845 11846 11847 11848 11849 11850 11851 11852 11853 11854 11855 11856 11857 11858 11859 11860 11861 11862 11863 11864 11865 11866 11867 11868 11869 11870 11871 11872 11873 11874 11875 11876 11877 11878 11879 11880 11881 11882 11883 11884 11885 11886 11887 11888 11889 11890 11891 11892 11893 11894 11895 11896 11897 11898 11899 11900 11901 11902 11903 11904 11905 11906 11907 11908 11909 11910 11911 11912 11913 11914 11915 11916 11917 11918 11919 11920 11921 11922 11923 11924 11925 11926 11927 11928 11929 11930 11931 11932 11933 11934 11935 11936 11937 11938 11939 11940 11941 11942 11943 11944 11945 11946 11947 11948 11949 11950 11951 11952 11953 11954 11955 11956 11957 11958 11959 11960 11961 11962 11963 11964 11965 11966 11967 11968 11969 11970 11971 11972 11973 11974 11975 11976 11977 11978 11979 11980 11981 11982 11983 11984 11985 11986 11987 11988 11989 11990 11991 11992 11993 11994 11995 11996 11997 11998 11999 12000 12001 12002 12003 12004 12005 12006 12007 12008 12009 12010 12011 12012 12013 12014 12015 12016 12017 12018 12019 12020 12021 12022 12023 12024 12025 12026 12027 12028 12029 12030 12031 12032 12033 12034 12035 12036 12037 12038 12039 12040 12041 12042 12043 12044 12045 12046 12047 12048 12049 12050 12051 12052 12053 12054 12055 12056 12057 12058 12059 12060 12061 12062 12063 12064 12065 12066 12067 12068 12069 12070 12071 12072 12073 12074 12075 12076 12077 12078 12079 12080 12081 12082 12083 12084 12085 12086 12087 12088 12089 12090 12091 12092 12093 12094 12095 12096 12097 12098 12099 12100 12101 12102 12103 12104 12105 12106 12107 12108 12109 12110 12111 12112 12113 12114 12115 12116 12117 12118 12119 12120 12121 12122 12123 12124 12125 12126 12127 12128 12129 12130 12131 12132 12133 12134 12135 12136 12137 12138 12139 12140 12141 12142 12143 12144 12145 12146 12147 12148 12149 12150 12151 12152 12153 12154 12155 12156 12157 12158 12159 12160 12161 12162 12163 12164 12165 12166 12167 12168 12169 12170 12171 12172 12173 12174 12175 12176 12177 12178 12179 12180 12181 12182 12183 12184 12185 12186 12187 12188 12189 12190 12191 12192 12193 12194 12195 12196 12197 12198 12199 12200 12201 12202 12203 12204 12205 12206 12207 12208 12209 12210 12211 12212 12213 12214 12215 12216 12217 12218 12219 12220 12221 12222 12223 12224 12225 12226 12227 12228 12229 12230 12231 12232 12233 12234 12235 12236 12237 12238 12239 12240 12241 12242 12243 12244 12245 12246 12247 12248 12249 12250 12251 12252 12253 12254 12255 12256 12257 12258 12259 12260 12261 12262 12263 12264 12265 12266 12267 12268 12269 12270 12271 12272 12273 12274 12275 12276 12277 12278 12279 12280 12281 12282 12283 12284 12285 12286 12287 12288 12289 12290 12291 12292 12293 12294 12295 12296 12297 12298 12299 12300 12301 12302 12303 12304 12305 12306 12307 12308 12309 12310 12311 12312 12313 12314 12315 12316 12317 12318 12319 12320 12321 12322 12323 12324 12325 12326 12327 12328 12329 12330 12331 12332 12333 12334 12335 12336 12337 12338 12339 12340 12341 12342 12343 12344 12345 12346 12347 12348 12349 12350 12351 12352 12353 12354 12355 12356 12357 12358 12359 12360 12361 12362 12363 12364 12365 12366 12367 12368 12369 12370 12371 12372 12373 12374 12375 12376 12377 12378 12379 12380 12381 12382 12383 12384 12385 12386 12387 12388 12389 12390 12391 12392 12393 12394 12395 12396 12397 12398 12399 12400 12401 12402 12403 12404 12405 12406 12407 12408 12409 12410 12411 12412 12413 12414 12415 12416 12417 12418 12419 12420 12421 12422 12423 12424 12425 12426 12427 12428 12429 12430 12431 12432 12433 12434 12435 12436 12437 12438 12439 12440 12441 12442 12443 12444 12445 12446 12447 12448 12449 12450 12451 12452 12453 12454 12455 12456 12457 12458 12459 12460 12461 12462 12463 12464 12465 12466 12467 12468 12469 12470 12471 12472 12473 12474 12475 12476 12477 12478 12479 12480 12481 12482 12483 12484 12485 12486 12487 12488 12489 12490 12491 12492 12493 12494 12495 12496 12497 12498 12499 12500 12501 12502 12503 12504 12505 12506 12507 12508 12509 12510 12511 12512 12513 12514 12515 12516 12517 12518 12519 12520 12521 12522 12523 12524 12525 12526 12527 12528 12529 12530 12531 12532 12533 12534 12535 12536 12537 12538 12539 12540 12541 12542 12543 12544 12545 12546 12547 12548 12549 12550 12551 12552 12553 12554 12555 12556 12557 12558 12559 12560 12561 12562 12563 12564 12565 12566 12567 12568 12569 12570 12571 12572 12573 12574 12575 12576 12577 12578 12579 12580 12581 12582 12583 12584 12585 12586 12587 12588 12589 12590 12591 12592 12593 12594 12595 12596 12597 12598 12599 12600 12601 12602 12603 12604 12605 12606 12607 12608 12609 12610 12611 12612 12613 12614 12615 12616 12617 12618 12619 12620 12621 12622 12623 12624 12625 12626 12627 12628 12629 12630 12631 12632 12633 12634 12635 12636 12637 12638 12639 12640 12641 12642 12643 12644 12645 12646 12647 12648 12649 12650 12651 12652 12653 12654 12655 12656 12657 12658 12659 12660 12661 12662 12663 12664 12665 12666 12667 12668 12669 12670 12671 12672 12673 12674 12675 12676 12677 12678 12679 12680 12681 12682 12683 12684 12685 12686 12687 12688 12689 12690 12691 12692 12693 12694 12695 12696 12697 12698 12699 12700 12701 12702 12703 12704 12705 12706 12707 12708 12709 12710 12711 12712 12713 12714 12715 12716 12717 12718 12719 12720 12721 12722 12723 12724 12725 12726 12727 12728 12729 12730 12731 12732 12733 12734 12735 12736 12737 12738 12739 12740 12741 12742 12743 12744 12745 12746 12747 12748 12749 12750 12751 12752 12753 12754 12755 12756 12757 12758 12759 12760 12761 12762 12763 12764 12765 12766 12767 12768 12769 12770 12771 12772 12773 12774 12775 12776 12777 12778 12779 12780 12781 12782 12783 12784 12785 12786 12787 12788 12789 12790 12791 12792 12793 12794 12795 12796 12797 12798 12799 12800 12801 12802 12803 12804 12805 12806 12807 12808 12809 12810 12811 12812 12813 12814 12815 12816 12817 12818 12819 12820 12821 12822 12823 12824 12825 12826 12827 12828 12829 12830 12831 12832 12833 12834 12835 12836 12837 12838 12839 12840 12841 12842 12843 12844 12845 12846 12847 12848 12849 12850 12851 12852 12853 12854 12855 12856 12857 12858 12859 12860 12861 12862 12863 12864 12865 12866 12867 12868 12869 12870 12871 12872 12873 12874 12875 12876 12877 12878 12879 12880 12881 12882 12883 12884 12885 12886 12887 12888 12889 12890 12891 12892 12893 12894 12895 12896 12897 12898 12899 12900 12901 12902 12903 12904 12905 12906 12907 12908 12909 12910 12911 12912 12913 12914 12915 12916 12917 12918 12919 12920 12921 12922 12923 12924 12925 12926 12927 12928 12929 12930 12931 12932 12933 12934 12935 12936 12937 12938 12939 12940 12941 12942 12943 12944 12945 12946 12947 12948 12949 12950 12951 12952 12953 12954 12955 12956 12957 12958 12959 12960 12961 12962 12963 12964 12965 12966 12967 12968 12969 12970 12971 12972 12973 12974 12975 12976 12977 12978 12979 12980 12981 12982 12983 12984 12985 12986 12987 12988 12989 12990 12991 12992 12993 12994 12995 12996 12997 12998 12999 13000 13001 13002 13003 13004 13005 13006 13007 13008 13009 13010 13011 13012 13013 13014 13015 13016 13017 13018 13019 13020 13021 13022 13023 13024 13025 13026 13027 13028 13029 13030 13031 13032 13033 13034 13035 13036 13037 13038 13039 13040 13041 13042 13043 13044 13045 13046 13047 13048 13049 13050 13051 13052 13053 13054 13055 13056 13057 13058 13059 13060 13061 13062 13063 13064 13065 13066 13067 13068 13069 13070 13071 13072 13073 13074 13075 13076 13077 13078 13079 13080 13081 13082 13083 13084 13085 13086 13087 13088 13089 13090 13091 13092 13093 13094 13095 13096 13097 13098 13099 13100 13101 13102 13103 13104 13105 13106 13107 13108 13109 13110 13111 13112 13113 13114 13115 13116 13117 13118 13119 13120 13121 13122 13123 13124 13125 13126 13127 13128 13129 13130 13131 13132 13133 13134 13135 13136 13137 13138 13139 13140 13141 13142 13143 13144 13145 13146 13147 13148 13149 13150 13151 13152 13153 13154 13155 13156 13157 13158 13159 13160 13161 13162 13163 13164 13165 13166 13167 13168 13169 13170 13171 13172 13173 13174 13175 13176 13177 13178 13179 13180 13181 13182 13183 13184 13185 13186 13187 13188 13189 13190 13191 13192 13193 13194 13195 13196 13197 13198 13199 13200 13201 13202 13203 13204 13205 13206 13207 13208 13209 13210 13211 13212 13213 13214 13215 13216 13217 13218 13219 13220 13221 13222 13223 13224 13225 13226 13227 13228 13229 13230 13231 13232 13233 13234 13235 13236 13237 13238 13239 13240 13241 13242 13243 13244 13245 13246 13247 13248 13249 13250 13251 13252 13253 13254 13255 13256 13257 13258 13259 13260 13261 13262 13263 13264 13265 13266 13267 13268 13269 13270 13271 13272 13273 13274 13275 13276 13277 13278 13279 13280 13281 13282 13283 13284 13285 13286 13287 13288 13289 13290 13291 13292 13293 13294 13295 13296 13297 13298 13299 13300 13301 13302 13303 13304 13305 13306 13307 13308 13309 13310 13311 13312 13313 13314 13315 13316 13317 13318 13319 13320 13321 13322 13323 13324 13325 13326 13327 13328 13329 13330 13331 13332 13333 13334 13335 13336 13337 13338 13339 13340 13341 13342 13343 13344 13345 13346 13347 13348 13349 13350 13351 13352 13353 13354 13355 13356 13357 13358 13359 13360 13361 13362 13363 13364 13365 13366 13367 13368 13369 13370 13371 13372 13373 13374 13375 13376 13377 13378 13379 13380 13381 13382 13383 13384 13385 13386 13387 13388 13389 13390 13391 13392 13393 13394 13395 13396 13397 13398 13399 13400 13401 13402 13403 13404 13405 13406 13407 13408 13409 13410 13411 13412 13413 13414 13415 13416 13417 13418 13419 13420 13421 13422 13423 13424 13425 13426 13427 13428 13429 13430 13431 13432 13433 13434 13435 13436 13437 13438 13439 13440 13441 13442 13443 13444 13445 13446 13447 13448 13449 13450 13451 13452 13453 13454 13455 13456 13457 13458 13459 13460 13461 13462 13463 13464 13465 13466 13467 13468 13469 13470 13471 13472 13473 13474 13475 13476 13477 13478 13479 13480 13481 13482 13483 13484 13485 13486 13487 13488 13489 13490 13491 13492 13493 13494 13495 13496 13497 13498 13499 13500 13501 13502 13503 13504 13505 13506 13507 13508 13509 13510 13511 13512 13513 13514 13515 13516 13517 13518 13519 13520 13521 13522 13523 13524 13525 13526 13527 13528 13529 13530 13531 13532 13533 13534 13535 13536 13537 13538 13539 13540 13541 13542 13543 13544 13545 13546 13547 13548 13549 13550 13551 13552 13553 13554 13555 13556 13557 13558 13559 13560 13561 13562 13563 13564 13565 13566 13567 13568 13569 13570 13571 13572 13573 13574 13575 13576 13577 13578 13579 13580 13581 13582 13583 13584 13585 13586 13587 13588 13589 13590 13591 13592 13593 13594 13595 13596 13597 13598 13599 13600 13601 13602 13603 13604 13605 13606 13607 13608 13609 13610 13611 13612 13613 13614 13615 13616 13617 13618 13619 13620 13621 13622 13623 13624 13625 13626 13627 13628 13629 13630 13631 13632 13633 13634 13635 13636 13637 13638 13639 13640 13641 13642 13643 13644 13645 13646 13647 13648 13649 13650 13651 13652 13653 13654 13655 13656 13657 13658 13659 13660 13661 13662 13663 13664 13665 13666 13667 13668 13669 13670 13671 13672 13673 13674 13675 13676 13677 13678 13679 13680 13681 13682 13683 13684 13685 13686 13687 13688 13689 13690 13691 13692 13693 13694 13695 13696 13697 13698 13699 13700 13701 13702 13703 13704 13705 13706 13707 13708 13709 13710 13711 13712 13713 13714 13715 13716 13717 13718 13719 13720 13721 13722 13723 13724 13725 13726 13727 13728 13729 13730 13731 13732 13733 13734 13735 13736 13737 13738 13739 13740 13741 13742 13743 13744 13745 13746 13747 13748 13749 13750 13751 13752 13753 13754 13755 13756 13757 13758 13759 13760 13761 13762 13763 13764 13765 13766 13767 13768 13769 13770 13771 13772 13773 13774 13775 13776 13777 13778 13779 13780 13781 13782 13783 13784 13785 13786 13787 13788 13789 13790 13791 13792 13793 13794 13795 13796 13797 13798 13799 13800 13801 13802 13803 13804 13805 13806 13807 13808 13809 13810 13811 13812 13813 13814 13815 13816 13817 13818 13819 13820 13821 13822 13823 13824 13825 13826 13827 13828 13829 13830 13831 13832 13833 13834 13835 13836 13837 13838 13839 13840 13841 13842 13843 13844 13845 13846 13847 13848 13849 13850 13851 13852 13853 13854 13855 13856 13857 13858 13859 13860 13861 13862 13863 13864 13865 13866 13867 13868 13869 13870 13871 13872 13873 13874 13875 13876 13877 13878 13879 13880 13881 13882 13883 13884 13885 13886 13887 13888 13889 13890 13891 13892 13893 13894 13895 13896 13897 13898 13899 13900 13901 13902 13903 13904 13905 13906 13907 13908 13909 13910 13911 13912 13913 13914 13915 13916 13917 13918 13919 13920 13921 13922 13923 13924 13925 13926 13927 13928 13929 13930 13931 13932 13933 13934 13935 13936 13937 13938 13939 13940 13941 13942 13943 13944 13945 13946 13947 13948 13949 13950 13951 13952 13953 13954 13955 13956 13957 13958 13959 13960 13961 13962 13963 13964 13965 13966 13967 13968 13969 13970 13971 13972 13973 13974 13975 13976 13977 13978 13979 13980 13981 13982 13983 13984 13985 13986 13987 13988 13989 13990 13991 13992 13993 13994 13995 13996 13997 13998 13999 14000 14001 14002 14003 14004 14005 14006 14007 14008 14009 14010 14011 14012 14013 14014 14015 14016 14017 14018 14019 14020 14021 14022 14023 14024 14025 14026 14027 14028 14029 14030 14031 14032 14033 14034 14035 14036 14037 14038 14039 14040 14041 14042 14043 14044 14045 14046 14047 14048 14049 14050 14051 14052 14053 14054 14055 14056 14057 14058 14059 14060 14061 14062 14063 14064 14065 14066 14067 14068 14069 14070 14071 14072 14073 14074 14075 14076 14077 14078 14079 14080 14081 14082 14083 14084 14085 14086 14087 14088 14089 14090 14091 14092 14093 14094 14095 14096 14097 14098 14099 14100 14101 14102 14103 14104 14105 14106 14107 14108 14109 14110 14111 14112 14113 14114 14115 14116 14117 14118 14119 14120 14121 14122 14123 14124 14125 14126 14127 14128 14129 14130 14131 14132 14133 14134 14135 14136 14137 14138 14139 14140 14141 14142 14143 14144 14145 14146 14147 14148 14149 14150 14151 14152 14153 14154 14155 14156 14157 14158 14159 14160 14161 14162 14163 14164 14165 14166 14167 14168 14169 14170 14171 14172 14173 14174 14175 14176 14177 14178 14179 14180 14181 14182 14183 14184 14185 14186 14187 14188 14189 14190 14191 14192 14193 14194 14195 14196 14197 14198 14199 14200 14201 14202 14203 14204 14205 14206 14207 14208 14209 14210 14211 14212 14213 14214 14215 14216 14217 14218 14219 14220 14221 14222 14223 14224 14225 14226 14227 14228 14229 14230 14231 14232 14233 14234 14235 14236 14237 14238 14239 14240 14241 14242 14243 14244 14245 14246 14247 14248 14249 14250 14251 14252 14253 14254 14255 14256 14257 14258 14259 14260 14261 14262 14263 14264 14265 14266 14267 14268 14269 14270 14271 14272 14273 14274 14275 14276 14277 14278 14279 14280 14281 14282 14283 14284 14285 14286 14287 14288 14289 14290 14291 14292 14293 14294 14295 14296 14297 14298 14299 14300 14301 14302 14303 14304 14305 14306 14307 14308 14309 14310 14311 14312 14313 14314 14315 14316 14317 14318 14319 14320 14321 14322 14323 14324 14325 14326 14327 14328 14329 14330 14331 14332 14333 14334 14335 14336 14337 14338 14339 14340 14341 14342 14343 14344 14345 14346 14347 14348 14349 14350 14351 14352 14353 14354 14355 14356 14357 14358 14359 14360 14361 14362 14363 14364 14365 14366 14367 14368 14369 14370 14371 14372 14373 14374 14375 14376 14377 14378 14379 14380 14381 14382 14383 14384 14385 14386 14387 14388 14389 14390 14391 14392 14393 14394 14395 14396 14397 14398 14399 14400 14401 14402 14403 14404 14405 14406 14407 14408 14409 14410 14411 14412 14413 14414 14415 14416 14417 14418 14419 14420 14421 14422 14423 14424 14425 14426 14427 14428 14429 14430 14431 14432 14433 14434 14435 14436 14437 14438 14439 14440 14441 14442 14443 14444 14445 14446 14447 14448 14449 14450 14451 14452 14453 14454 14455 14456 14457 14458 14459 14460 14461 14462 14463 14464 14465 14466 14467 14468 14469 14470 14471 14472 14473 14474 14475 14476 14477 14478 14479 14480 14481 14482 14483 14484 14485 14486 14487 14488 14489 14490 14491 14492 14493 14494 14495 14496 14497 14498 14499 14500 14501 14502 14503 14504 14505 14506 14507 14508 14509 14510 14511 14512 14513 14514 14515 14516 14517 14518 14519 14520 14521 14522 14523 14524 14525 14526 14527 14528 14529 14530 14531 14532 14533 14534 14535 14536 14537 14538 14539 14540 14541 14542 14543 14544 14545 14546 14547 14548 14549 14550 14551 14552 14553 14554 14555 14556 14557 14558 14559 14560 14561 14562 14563 14564 14565 14566 14567 14568 14569 14570 14571 14572 14573 14574 14575 14576 14577 14578 14579 14580 14581 14582 14583 14584 14585 14586 14587 14588 14589 14590 14591 14592 14593 14594 14595 14596 14597 14598 14599 14600 14601 14602 14603 14604 14605 14606 14607 14608 14609 14610 14611 14612 14613 14614 14615 14616 14617 14618 14619 14620 14621 14622 14623 14624 14625 14626 14627 14628 14629 14630 14631 14632 14633 14634 14635 14636 14637 14638 14639 14640 14641 14642 14643 14644 14645 14646 14647 14648 14649 14650 14651 14652 14653 14654 14655 14656 14657 14658 14659 14660 14661 14662 14663 14664 14665 14666 14667 14668 14669 14670 14671 14672 14673 14674 14675 14676 14677 14678 14679 14680 14681 14682 14683 14684 14685 14686 14687 14688 14689 14690 14691 14692 14693 14694 14695 14696 14697 14698 14699 14700 14701 14702 14703 14704 14705 14706 14707 14708 14709 14710 14711 14712 14713 14714 14715 14716 14717 14718 14719 14720 14721 14722 14723 14724 14725 14726 14727 14728 14729 14730 14731 14732 14733 14734 14735 14736 14737 14738 14739 14740 14741 14742 14743 14744 14745 14746 14747 14748 14749 14750 14751 14752 14753 14754 14755 14756 14757 14758 14759 14760 14761 14762 14763 14764 14765 14766 14767 14768 14769 14770 14771 14772 14773 14774 14775 14776 14777 14778 14779 14780 14781 14782 14783 14784 14785 14786 14787 14788 14789 14790 14791 14792 14793 14794 14795 14796 14797 14798 14799 14800 14801 14802 14803 14804 14805 14806 14807 14808 14809 14810 14811 14812 14813 14814 14815 14816 14817 14818 14819 14820 14821 14822 14823 14824 14825 14826 14827 14828 14829 14830 14831 14832 14833 14834 14835 14836 14837 14838 14839 14840 14841 14842 14843 14844 14845 14846 14847 14848 14849 14850 14851 14852 14853 14854 14855 14856 14857 14858 14859 14860 14861 14862 14863 14864 14865 14866 14867 14868 14869 14870 14871 14872 14873 14874 14875 14876 14877 14878 14879 14880 14881 14882 14883 14884 14885 14886 14887 14888 14889 14890 14891 14892 14893 14894 14895 14896 14897 14898 14899 14900 14901 14902 14903 14904 14905 14906 14907 14908 14909 14910 14911 14912 14913 14914 14915 14916 14917 14918 14919 14920 14921 14922 14923 14924 14925 14926 14927 14928 14929 14930 14931 14932 14933 14934 14935 14936 14937 14938 14939 14940 14941 14942 14943 14944 14945 14946 14947 14948 14949 14950 14951 14952 14953 14954 14955 14956 14957 14958 14959 14960 14961 14962 14963 14964 14965 14966 14967 14968 14969 14970 14971 14972 14973 14974 14975 14976 14977 14978 14979 14980 14981 14982 14983 14984 14985 14986 14987 14988 14989 14990 14991 14992 14993 14994 14995 14996 14997 14998 14999 15000 15001 15002 15003 15004 15005 15006 15007 15008 15009 15010 15011 15012 15013 15014 15015 15016 15017 15018 15019 15020 15021 15022 15023 15024 15025 15026 15027 15028 15029 15030 15031 15032 15033 15034 15035 15036 15037 15038 15039 15040 15041 15042 15043 15044 15045 15046 15047 15048 15049 15050 15051 15052 15053 15054 15055 15056 15057 15058 15059 15060 15061 15062 15063 15064 15065 15066 15067 15068 15069 15070 15071 15072 15073 15074 15075 15076 15077 15078 15079 15080 15081 15082 15083 15084 15085 15086 15087 15088 15089 15090 15091 15092 15093 15094 15095 15096 15097 15098 15099 15100 15101 15102 15103 15104 15105 15106 15107 15108 15109 15110 15111 15112 15113 15114 15115 15116 15117 15118 15119 15120 15121 15122 15123 15124 15125 15126 15127 15128 15129 15130 15131 15132 15133 15134 15135 15136 15137 15138 15139 15140 15141 15142 15143 15144 15145 15146 15147 15148 15149 15150 15151 15152 15153 15154 15155 15156 15157 15158 15159 15160 15161 15162 15163 15164 15165 15166 15167 15168 15169 15170 15171 15172 15173 15174 15175 15176 15177 15178 15179 15180 15181 15182 15183 15184 15185 15186 15187 15188 15189 15190 15191 15192 15193 15194 15195 15196 15197 15198 15199 15200 15201 15202 15203 15204 15205 15206 15207 15208 15209 15210 15211 15212 15213 15214 15215 15216 15217 15218 15219 15220 15221 15222 15223 15224 15225 15226 15227 15228 15229 15230 15231 15232 15233 15234 15235 15236 15237 15238 15239 15240 15241 15242 15243 15244 15245 15246 15247 15248 15249 15250 15251 15252 15253 15254 15255 15256 15257 15258 15259 15260 15261 15262 15263 15264 15265 15266 15267 15268 15269 15270 15271 15272 15273 15274 15275 15276 15277 15278 15279 15280 15281 15282 15283 15284 15285 15286 15287 15288 15289 15290 15291 15292 15293 15294 15295 15296 15297 15298 15299 15300 15301 15302 15303 15304 15305 15306 15307 15308 15309 15310 15311 15312 15313 15314 15315 15316 15317 15318 15319 15320 15321 15322 15323 15324 15325 15326 15327 15328 15329 15330 15331 15332 15333 15334 15335 15336 15337 15338 15339 15340 15341 15342 15343 15344 15345 15346 15347 15348 15349 15350 15351 15352 15353 15354 15355 15356 15357 15358 15359 15360 15361 15362 15363 15364 15365 15366 15367 15368 15369 15370 15371 15372 15373 15374 15375 15376 15377 15378 15379 15380 15381 15382 15383 15384 15385 15386 15387 15388 15389 15390 15391 15392 15393 15394 15395 15396 15397 15398 15399 15400 15401 15402 15403 15404 15405 15406 15407 15408 15409 15410 15411 15412 15413 15414 15415 15416 15417 15418 15419 15420 15421 15422 15423 15424 15425 15426 15427 15428 15429 15430 15431 15432 15433 15434 15435 15436 15437 15438 15439 15440 15441 15442 15443 15444 15445 15446 15447 15448 15449 15450 15451 15452 15453 15454 15455 15456 15457 15458 15459 15460 15461 15462 15463 15464 15465 15466 15467 15468 15469 15470 15471 15472 15473 15474 15475 15476 15477 15478 15479 15480 15481 15482 15483 15484 15485 15486 15487 15488 15489 15490 15491 15492 15493 15494 15495 15496 15497 15498 15499 15500 15501 15502 15503 15504 15505 15506 15507 15508 15509 15510 15511 15512 15513 15514 15515 15516 15517 15518 15519 15520 15521 15522 15523 15524 15525 15526 15527 15528 15529 15530 15531 15532 15533 15534 15535 15536 15537 15538 15539 15540 15541 15542 15543 15544 15545 15546 15547 15548 15549 15550 15551 15552 15553 15554 15555 15556 15557 15558 15559 15560 15561 15562 15563 15564 15565 15566 15567 15568 15569 15570 15571 15572 15573 15574 15575 15576 15577 15578 15579 15580 15581 15582 15583 15584 15585 15586 15587 15588 15589 15590 15591 15592 15593 15594 15595 15596 15597 15598 15599 15600 15601 15602 15603 15604 15605 15606 15607 15608 15609 15610 15611 15612 15613 15614 15615 15616 15617 15618 15619 15620 15621 15622 15623 15624 15625 15626 15627 15628 15629 15630 15631 15632 15633 15634 15635 15636 15637 15638 15639 15640 15641 15642 15643 15644 15645 15646 15647 15648 15649 15650 15651 15652 15653 15654 15655 15656 15657 15658 15659 15660 15661 15662 15663 15664 15665 15666 15667 15668 15669 15670 15671 15672 15673 15674 15675 15676 15677 15678 15679 15680 15681 15682 15683 15684 15685 15686 15687 15688 15689 15690 15691 15692 15693 15694 15695 15696 15697 15698 15699 15700 15701 15702 15703 15704 15705 15706 15707 15708 15709 15710 15711 15712 15713 15714 15715 15716 15717 15718 15719 15720 15721 15722 15723 15724 15725 15726 15727 15728 15729 15730 15731 15732 15733 15734 15735 15736 15737 15738 15739 15740 15741 15742 15743 15744 15745 15746 15747 15748 15749 15750 15751 15752 15753 15754 15755 15756 15757 15758 15759 15760 15761 15762 15763 15764 15765 15766 15767 15768 15769 15770 15771 15772 15773 15774 15775 15776 15777 15778 15779 15780 15781 15782 15783 15784 15785 15786 15787 15788 15789 15790 15791 15792 15793 15794 15795 15796 15797 15798 15799 15800 15801 15802 15803 15804 15805 15806 15807 15808 15809 15810 15811 15812 15813 15814 15815 15816 15817 15818 15819 15820 15821 15822 15823 15824 15825 15826 15827 15828 15829 15830 15831 15832 15833 15834 15835 15836 15837 15838 15839 15840 15841 15842 15843 15844 15845 15846 15847 15848 15849 15850 15851 15852 15853 15854 15855 15856 15857 15858 15859 15860 15861 15862 15863 15864 15865 15866 15867 15868 15869 15870 15871 15872 15873 15874 15875 15876 15877 15878 15879 15880 15881 15882 15883 15884 15885 15886 15887 15888 15889 15890 15891 15892 15893 15894 15895 15896 15897 15898 15899 15900 15901 15902 15903 15904 15905 15906 15907 15908 15909 15910 15911 15912 15913 15914 15915 15916 15917 15918 15919 15920 15921 15922 15923 15924 15925 15926 15927 15928 15929 15930 15931 15932 15933 15934 15935 15936 15937 15938 15939 15940 15941 15942 15943 15944 15945 15946 15947 15948 15949 15950 15951 15952 15953 15954 15955 15956 15957 15958 15959 15960 15961 15962 15963 15964 15965 15966 15967 15968 15969 15970 15971 15972 15973 15974 15975 15976 15977 15978 15979 15980 15981 15982 15983 15984 15985 15986 15987 15988 15989 15990 15991 15992 15993 15994 15995 15996 15997 15998 15999 16000 16001 16002 16003 16004 16005 16006 16007 16008 16009 16010 16011 16012 16013 16014 16015 16016 16017 16018 16019 16020 16021 16022 16023 16024 16025 16026 16027 16028 16029 16030 16031 16032 16033 16034 16035 16036 16037 16038 16039 16040 16041 16042 16043 16044 16045 16046 16047 16048 16049 16050 16051 16052 16053 16054 16055 16056 16057 16058 16059 16060 16061 16062 16063 16064 16065 16066 16067 16068 16069 16070 16071 16072 16073 16074 16075 16076 16077 16078 16079 16080 16081 16082 16083 16084 16085 16086 16087 16088 16089 16090 16091 16092 16093 16094 16095 16096 16097 16098 16099 16100 16101 16102 16103 16104 16105 16106 16107 16108 16109 16110 16111 16112 16113 16114 16115 16116 16117 16118 16119 16120 16121 16122 16123 16124 16125 16126 16127 16128 16129 16130 16131 16132 16133 16134 16135 16136 16137 16138 16139 16140 16141 16142 16143 16144 16145 16146 16147 16148 16149 16150 16151 16152 16153 16154 16155 16156 16157 16158 16159 16160 16161 16162 16163 16164 16165 16166 16167 16168 16169 16170 16171 16172 16173 16174 16175 16176 16177 16178 16179 16180 16181 16182 16183 16184 16185 16186 16187 16188 16189 16190 16191 16192 16193 16194 16195 16196 16197 16198 16199 16200 16201 16202 16203 16204 16205 16206 16207 16208 16209 16210 16211 16212 16213 16214 16215 16216 16217 16218 16219 16220 16221 16222 16223 16224 16225 16226 16227 16228 16229 16230 16231 16232 16233 16234 16235 16236 16237 16238 16239 16240 16241 16242 16243 16244 16245 16246 16247 16248 16249 16250 16251 16252 16253 16254 16255 16256 16257 16258 16259 16260 16261 16262 16263 16264 16265 16266 16267 16268 16269 16270 16271 16272 16273 16274 16275 16276 16277 16278 16279 16280 16281 16282 16283 16284 16285 16286 16287 16288 16289 16290 16291 16292 16293 16294 16295 16296 16297 16298 16299 16300 16301 16302 16303 16304 16305 16306 16307 16308 16309 16310 16311 16312 16313 16314 16315 16316 16317 16318 16319 16320 16321 16322 16323 16324 16325 16326 16327 16328 16329 16330 16331 16332 16333 16334 16335 16336 16337 16338 16339 16340 16341 16342 16343 16344 16345 16346 16347 16348 16349 16350 16351 16352 16353 16354 16355 16356 16357 16358 16359 16360 16361 16362 16363 16364 16365 16366 16367 16368 16369 16370 16371 16372 16373 16374 16375 16376 16377 16378 16379 16380 16381 16382 16383 16384 16385 16386 16387 16388 16389 16390 16391 16392 16393 16394 16395 16396 16397 16398 16399 16400 16401 16402 16403 16404 16405 16406 16407 16408 16409 16410 16411 16412 16413 16414 16415 16416 16417 16418 16419 16420 16421 16422 16423 16424 16425 16426 16427 16428 16429 16430 16431 16432 16433 16434 16435 16436 16437 16438 16439 16440 16441 16442 16443 16444 16445 16446 16447 16448 16449 16450 16451 16452 16453 16454 16455 16456 16457 16458 16459 16460 16461 16462 16463 16464 16465 16466 16467 16468 16469 16470 16471 16472 16473 16474 16475 16476 16477 16478 16479 16480 16481 16482 16483 16484 16485 16486 16487 16488 16489 16490 16491 16492 16493 16494 16495 16496 16497 16498 16499 16500 16501 16502 16503 16504 16505 16506 16507 16508 16509 16510 16511 16512 16513 16514 16515 16516 16517 16518 16519 16520 16521 16522 16523 16524 16525 16526 16527 16528 16529 16530 16531 16532 16533 16534 16535 16536 16537 16538 16539 16540 16541 16542 16543 16544 16545 16546 16547 16548 16549 16550 16551 16552 16553 16554 16555 16556 16557 16558 16559 16560 16561 16562 16563 16564 16565 16566 16567 16568 16569 16570 16571 16572 16573 16574 16575 16576 16577 16578 16579 16580 16581 16582 16583 16584 16585 16586 16587 16588 16589 16590 16591 16592 16593 16594 16595 16596 16597 16598 16599 16600 16601 16602 16603 16604 16605 16606 16607 16608 16609 16610 16611 16612 16613 16614 16615 16616 16617 16618 16619 16620 16621 16622 16623 16624 16625 16626 16627 16628 16629 16630 16631 16632 16633 16634 16635 16636 16637 16638 16639 16640 16641 16642 16643 16644 16645 16646 16647 16648 16649 16650 16651 16652 16653 16654 16655 16656 16657 16658 16659 16660 16661 16662 16663 16664 16665 16666 16667 16668 16669 16670 16671 16672 16673 16674 16675 16676 16677 16678 16679 16680 16681 16682 16683 16684 16685 16686 16687 16688 16689 16690 16691 16692 16693 16694 16695 16696 16697 16698 16699 16700 16701 16702 16703 16704 16705 16706 16707 16708 16709 16710 16711 16712 16713 16714 16715 16716 16717 16718 16719 16720 16721 16722 16723 16724 16725 16726 16727 16728 16729 16730 16731 16732 16733 16734 16735 16736 16737 16738 16739 16740 16741 16742 16743 16744 16745 16746 16747 16748 16749 16750 16751 16752 16753 16754 16755 16756 16757 16758 16759 16760 16761 16762 16763 16764 16765 16766 16767 16768 16769 16770 16771 16772 16773 16774 16775 16776 16777 16778 16779 16780 16781 16782 16783 16784 16785 16786 16787 16788 16789 16790 16791 16792 16793 16794 16795 16796 16797 16798 16799 16800 16801 16802 16803 16804 16805 16806 16807 16808 16809 16810 16811 16812 16813 16814 16815 16816 16817 16818 16819 16820 16821 16822 16823 16824 16825 16826 16827 16828 16829 16830 16831 16832 16833 16834 16835 16836 16837 16838 16839 16840 16841 16842 16843 16844 16845 16846 16847 16848 16849 16850 16851 16852 16853 16854 16855 16856 16857 16858 16859 16860 16861 16862 16863 16864 16865 16866 16867 16868 16869 16870 16871 16872 16873 16874 16875 16876 16877 16878 16879 16880 16881 16882 16883 16884 16885 16886 16887 16888 16889 16890 16891 16892 16893 16894 16895 16896 16897 16898 16899 16900 16901 16902 16903 16904 16905 16906 16907 16908 16909 16910 16911 16912 16913 16914 16915 16916 16917 16918 16919 16920 16921 16922 16923 16924 16925 16926 16927 16928 16929 16930 16931 16932 16933 16934 16935 16936 16937 16938 16939 16940 16941 16942 16943 16944 16945 16946 16947 16948 16949 16950 16951 16952 16953 16954 16955 16956 16957 16958 16959 16960 16961 16962 16963 16964 16965 16966 16967 16968 16969 16970 16971 16972 16973 16974 16975 16976 16977 16978 16979 16980 16981 16982 16983 16984 16985 16986 16987 16988 16989 16990 16991 16992 16993 16994 16995 16996 16997 16998 16999 17000 17001 17002 17003 17004 17005 17006 17007 17008 17009 17010 17011 17012 17013 17014 17015 17016 17017 17018 17019 17020 17021 17022 17023 17024 17025 17026 17027 17028 17029 17030 17031 17032 17033 17034 17035 17036 17037 17038 17039 17040 17041 17042 17043 17044 17045 17046 17047 17048 17049 17050 17051 17052 17053 17054 17055 17056 17057 17058 17059 17060 17061 17062 17063 17064 17065 17066 17067 17068 17069 17070 17071 17072 17073 17074 17075 17076 17077 17078 17079 17080 17081 17082 17083 17084 17085 17086 17087 17088 17089 17090 17091 17092 17093 17094 17095 17096 17097 17098 17099 17100 17101 17102 17103 17104 17105 17106 17107 17108 17109 17110 17111 17112 17113 17114 17115 17116 17117 17118 17119 17120 17121 17122 17123 17124 17125 17126 17127 17128 17129 17130 17131 17132 17133 17134 17135 17136 17137 17138 17139 17140 17141 17142 17143 17144 17145 17146 17147 17148 17149 17150 17151 17152 17153 17154 17155 17156 17157 17158 17159 17160 17161 17162 17163 17164 17165 17166 17167 17168 17169 17170 17171 17172 17173 17174 17175 17176 17177 17178 17179 17180 17181 17182 17183 17184 17185 17186 17187 17188 17189 17190 17191 17192 17193 17194 17195 17196 17197 17198 17199 17200 17201 17202 17203 17204 17205 17206 17207 17208 17209 17210 17211 17212 17213 17214 17215 17216 17217 17218 17219 17220 17221 17222 17223 17224 17225 17226 17227 17228 17229 17230 17231 17232 17233 17234 17235 17236 17237 17238 17239 17240 17241 17242 17243 17244 17245 17246 17247 17248 17249 17250 17251 17252 17253 17254 17255 17256 17257 17258 17259 17260 17261 17262 17263 17264 17265 17266 17267 17268 17269 17270 17271 17272 17273 17274 17275 17276 17277 17278 17279 17280 17281 17282 17283 17284 17285 17286 17287 17288 17289 17290 17291 17292 17293 17294 17295 17296 17297 17298 17299 17300 17301 17302 17303 17304 17305 17306 17307 17308 17309 17310 17311 17312 17313 17314 17315 17316 17317 17318 17319 17320 17321 17322 17323 17324 17325 17326 17327 17328 17329 17330 17331 17332 17333 17334 17335 17336 17337 17338 17339 17340 17341 17342 17343 17344 17345 17346 17347 17348 17349 17350 17351 17352 17353 17354 17355 17356 17357 17358 17359 17360 17361 17362 17363 17364 17365 17366 17367 17368 17369 17370 17371 17372 17373 17374 17375 17376 17377 17378 17379 17380 17381 17382 17383 17384 17385 17386 17387 17388 17389 17390 17391 17392 17393 17394 17395 17396 17397 17398 17399 17400 17401 17402 17403 17404 17405 17406 17407 17408 17409 17410 17411 17412 17413 17414 17415 17416 17417 17418 17419 17420 17421 17422 17423 17424 17425 17426 17427 17428 17429 17430 17431 17432 17433 17434 17435 17436 17437 17438 17439 17440 17441 17442 17443 17444 17445 17446 17447 17448 17449 17450 17451 17452 17453 17454 17455 17456 17457 17458 17459 17460 17461 17462 17463 17464 17465 17466 17467 17468 17469 17470 17471 17472 17473 17474 17475 17476 17477 17478 17479 17480 17481 17482 17483 17484 17485 17486 17487 17488 17489 17490 17491 17492 17493 17494 17495 17496 17497 17498 17499 17500 17501 17502 17503 17504 17505 17506 17507 17508 17509 17510 17511 17512 17513 17514 17515 17516 17517 17518 17519 17520 17521 17522 17523 17524 17525 17526 17527 17528 17529 17530 17531 17532 17533 17534 17535 17536 17537 17538 17539 17540 17541 17542 17543 17544 17545 17546 17547 17548 17549 17550 17551 17552 17553 17554 17555 17556 17557 17558 17559 17560 17561 17562 17563 17564 17565 17566 17567 17568 17569 17570 17571 17572 17573 17574 17575 17576 17577 17578 17579 17580 17581 17582 17583 17584 17585 17586 17587 17588 17589 17590 17591 17592 17593 17594 17595 17596 17597 17598 17599 17600 17601 17602 17603 17604 17605 17606 17607 17608 17609 17610 17611 17612 17613 17614 17615 17616 17617 17618 17619 17620 17621 17622 17623 17624 17625 17626 17627 17628 17629 17630 17631 17632 17633 17634 17635 17636 17637 17638 17639 17640 17641 17642 17643 17644 17645 17646 17647 17648 17649 17650 17651 17652 17653 17654 17655 17656 17657 17658 17659 17660 17661 17662 17663 17664 17665 17666 17667 17668 17669 17670 17671 17672 17673 17674 17675 17676 17677 17678 17679 17680 17681 17682 17683 17684 17685 17686 17687 17688 17689 17690 17691 17692 17693 17694 17695 17696 17697 17698 17699 17700 17701 17702 17703 17704 17705 17706 17707 17708 17709 17710 17711 17712 17713 17714 17715 17716 17717 17718 17719 17720 17721 17722 17723 17724 17725 17726 17727 17728 17729 17730 17731 17732 17733 17734 17735 17736 17737 17738 17739 17740 17741 17742 17743 17744 17745 17746 17747 17748 17749 17750 17751 17752 17753 17754 17755 17756 17757 17758 17759 17760 17761 17762 17763 17764 17765 17766 17767 17768 17769 17770 17771 17772 17773 17774 17775 17776 17777 17778 17779 17780 17781 17782 17783 17784 17785 17786 17787 17788 17789 17790 17791 17792 17793 17794 17795 17796 17797 17798 17799 17800 17801 17802 17803 17804 17805 17806 17807 17808 17809 17810 17811 17812 17813 17814 17815 17816 17817 17818 17819 17820 17821 17822 17823 17824 17825 17826 17827 17828 17829 17830 17831 17832 17833 17834 17835 17836 17837 17838 17839 17840 17841 17842 17843 17844 17845 17846 17847 17848 17849 17850 17851 17852 17853 17854 17855 17856 17857 17858 17859 17860 17861 17862 17863 17864 17865 17866 17867 17868 17869 17870 17871 17872 17873 17874 17875 17876 17877 17878 17879 17880 17881 17882 17883 17884 17885 17886 17887 17888 17889 17890 17891 17892 17893 17894 17895 17896 17897 17898 17899 17900 17901 17902 17903 17904 17905 17906 17907 17908 17909 17910 17911 17912 17913 17914 17915 17916 17917 17918 17919 17920 17921 17922 17923 17924 17925 17926 17927 17928 17929 17930 17931 17932 17933 17934 17935 17936 17937 17938 17939 17940 17941 17942 17943 17944 17945 17946 17947 17948 17949 17950 17951 17952 17953 17954 17955 17956 17957 17958 17959 17960 17961 17962 17963 17964 17965 17966 17967 17968 17969 17970 17971 17972 17973 17974 17975 17976 17977 17978 17979 17980 17981 17982 17983 17984 17985 17986 17987 17988 17989 17990 17991 17992 17993 17994 17995 17996 17997 17998 17999 18000 18001 18002 18003 18004 18005 18006 18007 18008 18009 18010 18011 18012 18013 18014 18015 18016 18017 18018 18019 18020 18021 18022 18023 18024 18025 18026 18027 18028 18029 18030 18031 18032 18033 18034 18035 18036 18037 18038 18039 18040 18041 18042 18043 18044 18045 18046 18047 18048 18049 18050 18051 18052 18053 18054 18055 18056 18057 18058 18059 18060 18061 18062 18063 18064 18065 18066 18067 18068 18069 18070 18071 18072 18073 18074 18075 18076 18077 18078 18079 18080 18081 18082 18083 18084 18085 18086 18087 18088 18089 18090 18091 18092 18093 18094 18095 18096 18097 18098 18099 18100 18101 18102 18103 18104 18105 18106 18107 18108 18109 18110 18111 18112 18113 18114 18115 18116 18117 18118 18119 18120 18121 18122 18123 18124 18125 18126 18127 18128 18129 18130 18131 18132 18133 18134 18135 18136 18137 18138 18139 18140 18141 18142 18143 18144 18145 18146 18147 18148 18149 18150 18151 18152 18153 18154 18155 18156 18157 18158 18159 18160 18161 18162 18163 18164 18165 18166 18167 18168 18169 18170 18171 18172 18173 18174 18175 18176 18177 18178 18179 18180 18181 18182 18183 18184 18185 18186 18187 18188 18189 18190 18191 18192 18193 18194 18195 18196 18197 18198 18199 18200 18201 18202 18203 18204 18205 18206 18207 18208 18209 18210 18211 18212 18213 18214 18215 18216 18217 18218 18219 18220 18221 18222 18223 18224 18225 18226 18227 18228 18229 18230 18231 18232 18233 18234 18235 18236 18237 18238 18239 18240 18241 18242 18243 18244 18245 18246 18247 18248 18249 18250 18251 18252 18253 18254 18255 18256 18257 18258 18259 18260 18261 18262 18263 18264 18265 18266 18267 18268 18269 18270 18271 18272 18273 18274 18275 18276 18277 18278 18279 18280 18281 18282 18283 18284 18285 18286 18287 18288 18289 18290 18291 18292 18293 18294 18295 18296 18297 18298 18299 18300 18301 18302 18303 18304 18305 18306 18307 18308 18309 18310 18311 18312 18313 18314 18315 18316 18317 18318 18319 18320 18321 18322 18323 18324 18325 18326 18327 18328 18329 18330 18331 18332 18333 18334 18335 18336 18337 18338 18339 18340 18341 18342 18343 18344 18345 18346 18347 18348 18349 18350 18351 18352 18353 18354 18355 18356 18357 18358 18359 18360 18361 18362 18363 18364 18365 18366 18367 18368 18369 18370 18371 18372 18373 18374 18375 18376 18377 18378 18379 18380 18381 18382 18383 18384 18385 18386 18387 18388 18389 18390 18391 18392 18393 18394 18395 18396 18397 18398 18399 18400 18401 18402 18403 18404 18405 18406 18407 18408 18409 18410 18411 18412 18413 18414 18415 18416 18417 18418 18419 18420 18421 18422 18423 18424 18425 18426 18427 18428 18429 18430 18431 18432 18433 18434 18435 18436 18437 18438 18439 18440 18441 18442 18443 18444 18445 18446 18447 18448 18449 18450 18451 18452 18453 18454 18455 18456 18457 18458 18459 18460 18461 18462 18463 18464 18465 18466 18467 18468 18469 18470 18471 18472 18473 18474 18475 18476 18477 18478 18479 18480 18481 18482 18483 18484 18485 18486 18487 18488 18489 18490 18491 18492 18493 18494 18495 18496 18497 18498 18499 18500 18501 18502 18503 18504 18505 18506 18507 18508 18509 18510 18511 18512 18513 18514 18515 18516 18517 18518 18519 18520 18521 18522 18523 18524 18525 18526 18527 18528 18529 18530 18531 18532 18533 18534 18535 18536 18537 18538 18539 18540 18541 18542 18543 18544 18545 18546 18547 18548 18549 18550 18551 18552 18553 18554 18555 18556 18557 18558 18559 18560 18561 18562 18563 18564 18565 18566 18567 18568 18569 18570 18571 18572 18573 18574 18575 18576 18577 18578 18579 18580 18581 18582 18583 18584 18585 18586 18587 18588 18589 18590 18591 18592 18593 18594 18595 18596 18597 18598 18599 18600 18601 18602 18603 18604 18605 18606 18607 18608 18609 18610 18611 18612 18613 18614 18615 18616 18617 18618 18619 18620 18621 18622 18623 18624 18625 18626 18627 18628 18629 18630 18631 18632 18633 18634 18635 18636 18637 18638 18639 18640 18641 18642 18643 18644 18645 18646 18647 18648 18649 18650 18651 18652 18653 18654 18655 18656 18657 18658 18659 18660 18661 18662 18663 18664 18665 18666 18667 18668 18669 18670 18671 18672 18673 18674 18675 18676 18677 18678 18679 18680 18681 18682 18683 18684 18685 18686 18687 18688 18689 18690 18691 18692 18693 18694 18695 18696 18697 18698 18699 18700 18701 18702 18703 18704 18705 18706 18707 18708 18709 18710 18711 18712 18713 18714 18715 18716 18717 18718 18719 18720 18721 18722 18723 18724 18725 18726 18727 18728 18729 18730 18731 18732 18733 18734 18735 18736 18737 18738 18739 18740 18741 18742 18743 18744 18745 18746 18747 18748 18749 18750 18751 18752 18753 18754 18755 18756 18757 18758 18759 18760 18761 18762 18763 18764 18765 18766 18767 18768 18769 18770 18771 18772 18773 18774 18775 18776 18777 18778 18779 18780 18781 18782 18783 18784 18785 18786 18787 18788 18789 18790 18791 18792 18793 18794 18795 18796 18797 18798 18799 18800 18801 18802 18803 18804 18805 18806 18807 18808 18809 18810 18811 18812 18813 18814 18815 18816 18817 18818 18819 18820 18821 18822 18823 18824 18825 18826 18827 18828 18829 18830 18831 18832 18833 18834 18835 18836 18837 18838 18839 18840 18841 18842 18843 18844 18845 18846 18847 18848 18849 18850 18851 18852 18853 18854 18855 18856 18857 18858 18859 18860 18861 18862 18863 18864 18865 18866 18867 18868 18869 18870 18871 18872 18873 18874 18875 18876 18877 18878 18879 18880 18881 18882 18883 18884 18885 18886 18887 18888 18889 18890 18891 18892 18893 18894 18895 18896 18897 18898 18899 18900 18901 18902 18903 18904 18905 18906 18907 18908 18909 18910 18911 18912 18913 18914 18915 18916 18917 18918 18919 18920 18921 18922 18923 18924 18925 18926 18927 18928 18929 18930 18931 18932 18933 18934 18935 18936 18937 18938 18939 18940 18941 18942 18943 18944 18945 18946 18947 18948 18949 18950 18951 18952 18953 18954 18955 18956 18957 18958 18959 18960 18961 18962 18963 18964 18965 18966 18967 18968 18969 18970 18971 18972 18973 18974 18975 18976 18977 18978 18979 18980 18981 18982 18983 18984 18985 18986 18987 18988 18989 18990 18991 18992 18993 18994 18995 18996 18997 18998 18999 19000 19001 19002 19003 19004 19005 19006 19007 19008 19009 19010 19011 19012 19013 19014 19015 19016 19017 19018 19019 19020 19021 19022 19023 19024 19025 19026 19027 19028 19029 19030 19031 19032 19033 19034 19035 19036 19037 19038 19039 19040 19041 19042 19043 19044 19045 19046 19047 19048 19049 19050 19051 19052 19053 19054 19055 19056 19057 19058 19059 19060 19061 19062 19063 19064 19065 19066 19067 19068 19069 19070 19071 19072 19073 19074 19075 19076 19077 19078 19079 19080 19081 19082 19083 19084 19085 19086 19087 19088 19089 19090 19091 19092 19093 19094 19095 19096 19097 19098 19099 19100 19101 19102 19103 19104 19105 19106 19107 19108 19109 19110 19111 19112 19113 19114 19115 19116 19117 19118 19119 19120 19121 19122 19123 19124 19125 19126 19127 19128 19129 19130 19131 19132 19133 19134 19135 19136 19137 19138 19139 19140 19141 19142 19143 19144 19145 19146 19147 19148 19149 19150 19151 19152 19153 19154 19155 19156 19157 19158 19159 19160 19161 19162 19163 19164 19165 19166 19167 19168 19169 19170 19171 19172 19173 19174 19175 19176 19177 19178 19179 19180 19181 19182 19183 19184 19185 19186 19187 19188 19189 19190 19191 19192 19193 19194 19195 19196 19197 19198 19199 19200 19201 19202 19203 19204 19205 19206 19207 19208 19209 19210 19211 19212 19213 19214 19215 19216 19217 19218 19219 19220 19221 19222 19223 19224 19225 19226 19227 19228 19229 19230 19231 19232 19233 19234 19235 19236 19237 19238 19239 19240 19241 19242 19243 19244 19245 19246 19247 19248 19249 19250 19251 19252 19253 19254 19255 19256 19257 19258 19259 19260 19261 19262 19263 19264 19265 19266 19267 19268 19269 19270 19271 19272 19273 19274 19275 19276 19277 19278 19279 19280 19281 19282 19283 19284 19285 19286 19287 19288 19289 19290 19291 19292 19293 19294 19295 19296 19297 19298 19299 19300 19301 19302 19303 19304 19305 19306 19307 19308 19309 19310 19311 19312 19313 19314 19315 19316 19317 19318 19319 19320 19321 19322 19323 19324 19325 19326 19327 19328 19329 19330 19331 19332 19333 19334 19335 19336 19337 19338 19339 19340 19341 19342 19343 19344 19345 19346 19347 19348 19349 19350 19351 19352 19353 19354 19355 19356 19357 19358 19359 19360 19361 19362 19363 19364 19365 19366 19367 19368 19369 19370 19371 19372 19373 19374 19375 19376 19377 19378 19379 19380 19381 19382 19383 19384 19385 19386 19387 19388 19389 19390 19391 19392 19393 19394 19395 19396 19397 19398 19399 19400 19401 19402 19403 19404 19405 19406 19407 19408 19409 19410 19411 19412 19413 19414 19415 19416 19417 19418 19419 19420 19421 19422 19423 19424 19425 19426 19427 19428 19429 19430 19431 19432 19433 19434 19435 19436 19437 19438 19439 19440 19441 19442 19443 19444 19445 19446 19447 19448 19449 19450 19451 19452 19453 19454 19455 19456 19457 19458 19459 19460 19461 19462 19463 19464 19465 19466 19467 19468 19469 19470 19471 19472 19473 19474 19475 19476 19477 19478 19479 19480 19481 19482 19483 19484 19485 19486 19487 19488 19489 19490 19491 19492 19493 19494 19495 19496 19497 19498 19499 19500 19501 19502 19503 19504 19505 19506 19507 19508 19509 19510 19511 19512 19513 19514 19515 19516 19517 19518 19519 19520 19521 19522 19523 19524 19525 19526 19527 19528 19529 19530 19531 19532 19533 19534 19535 19536 19537 19538 19539 19540 19541 19542 19543 19544 19545 19546 19547 19548 19549 19550 19551 19552 19553 19554 19555 19556 19557 19558 19559 19560 19561 19562 19563 19564 19565 19566 19567 19568 19569 19570 19571 19572 19573 19574 19575 19576 19577 19578 19579 19580 19581 19582 19583 19584 19585 19586 19587 19588 19589 19590 19591 19592 19593 19594 19595 19596 19597 19598 19599 19600 19601 19602 19603 19604 19605 19606 19607 19608 19609 19610 19611 19612 19613 19614 19615 19616 19617 19618 19619 19620 19621 19622 19623 19624 19625 19626 19627 19628 19629 19630 19631 19632 19633 19634 19635 19636 19637 19638 19639 19640 19641 19642 19643 19644 19645 19646 19647 19648 19649 19650 19651 19652 19653 19654 19655 19656 19657 19658 19659 19660 19661 19662 19663 19664 19665 19666 19667 19668 19669 19670 19671 19672 19673 19674 19675 19676 19677 19678 19679 19680 19681 19682 19683 19684 19685 19686 19687 19688 19689 19690 19691 19692 19693 19694 19695 19696 19697 19698 19699 19700 19701 19702 19703 19704 19705 19706 19707 19708 19709 19710 19711 19712 19713 19714 19715 19716 19717 19718 19719 19720 19721 19722 19723 19724 19725 19726 19727 19728 19729 19730 19731 19732 19733 19734 19735 19736 19737 19738 19739 19740 19741 19742 19743 19744 19745 19746 19747 19748 19749 19750 19751 19752 19753 19754 19755 19756 19757 19758 19759 19760 19761 19762 19763 19764 19765 19766 19767 19768 19769 19770 19771 19772 19773 19774 19775 19776 19777 19778 19779 19780 19781 19782 19783 19784 19785 19786 19787 19788 19789 19790 19791 19792 19793 19794 19795 19796 19797 19798 19799 19800 19801 19802 19803 19804 19805 19806 19807 19808 19809 19810 19811 19812 19813 19814 19815 19816 19817 19818 19819 19820 19821 19822 19823 19824 19825 19826 19827 19828 19829 19830 19831 19832 19833 19834 19835 19836 19837 19838 19839 19840 19841 19842 19843 19844 19845 19846 19847 19848 19849 19850 19851 19852 19853 19854 19855 19856 19857 19858 19859 19860 19861 19862 19863 19864 19865 19866 19867 19868 19869 19870 19871 19872 19873 19874 19875 19876 19877 19878 19879 19880 19881 19882 19883 19884 19885 19886 19887 19888 19889 19890 19891 19892 19893 19894 19895 19896 19897 19898 19899 19900 19901 19902 19903 19904 19905 19906 19907 19908 19909 19910 19911 19912 19913 19914 19915 19916 19917 19918 19919 19920 19921 19922 19923 19924 19925 19926 19927 19928 19929 19930 19931 19932 19933 19934 19935 19936 19937 19938 19939 19940 19941 19942 19943 19944 19945 19946 19947 19948 19949 19950 19951 19952 19953 19954 19955 19956 19957 19958 19959 19960 19961 19962 19963 19964 19965 19966 19967 19968 19969 19970 19971 19972 19973 19974 19975 19976 19977 19978 19979 19980 19981 19982 19983 19984 19985 19986 19987 19988 19989 19990 19991 19992 19993 19994 19995 19996 19997 19998 19999 20000 20001 20002 20003 20004 20005 20006 20007 20008 20009 20010 20011 20012 20013 20014 20015 20016 20017 20018 20019 20020 20021 20022 20023 20024 20025 20026 20027 20028 20029 20030 20031 20032 20033 20034 20035 20036 20037 20038 20039 20040 20041 20042 20043 20044 20045 20046 20047 20048 20049 20050 20051 20052 20053 20054 20055 20056 20057 20058 20059 20060 20061 20062 20063 20064 20065 20066 20067 20068 20069 20070 20071 20072 20073 20074 20075 20076 20077 20078 20079 20080 20081 20082 20083 20084 20085 20086 20087 20088 20089 20090 20091 20092 20093 20094 20095 20096 20097 20098 20099 20100 20101 20102 20103 20104 20105 20106 20107 20108 20109 20110 20111 20112 20113 20114 20115 20116 20117 20118 20119 20120 20121 20122 20123 20124 20125 20126 20127 20128 20129 20130 20131 20132 20133 20134 20135 20136 20137 20138 20139 20140 20141 20142 20143 20144 20145 20146 20147 20148 20149 20150 20151 20152 20153 20154 20155 20156 20157 20158 20159 20160 20161 20162 20163 20164 20165 20166 20167 20168 20169 20170 20171 20172 20173 20174 20175 20176 20177 20178 20179 20180 20181 20182 20183 20184 20185 20186 20187 20188 20189 20190 20191 20192 20193 20194 20195 20196 20197 20198 20199 20200 20201 20202 20203 20204 20205 20206 20207 20208 20209 20210 20211 20212 20213 20214 20215 20216 20217 20218 20219 20220 20221 20222 20223 20224 20225 20226 20227 20228 20229 20230 20231 20232 20233 20234 20235 20236 20237 20238 20239 20240 20241 20242 20243 20244 20245 20246 20247 20248 20249 20250 20251 20252 20253 20254 20255 20256 20257 20258 20259 20260 20261 20262 20263 20264 20265 20266 20267 20268 20269 20270 20271 20272 20273 20274 20275 20276 20277 20278 20279 20280 20281 20282 20283 20284 20285 20286 20287 20288 20289 20290 20291 20292 20293 20294 20295 20296 20297 20298 20299 20300 20301 20302 20303 20304 20305 20306 20307 20308 20309 20310 20311 20312 20313 20314 20315 20316 20317 20318 20319 20320 20321 20322 20323 20324 20325 20326 20327 20328 20329 20330 20331 20332 20333 20334 20335 20336 20337 20338 20339 20340 20341 20342 20343 20344 20345 20346 20347 20348 20349 20350 20351 20352 20353 20354 20355 20356 20357 20358 20359 20360 20361 20362 20363 20364 20365 20366 20367 20368 20369 20370 20371 20372 20373 20374 20375 20376 20377 20378 20379 20380 20381 20382 20383 20384 20385 20386 20387 20388 20389 20390 20391 20392 20393 20394 20395 20396 20397 20398 20399 20400 20401 20402 20403 20404 20405 20406 20407 20408 20409 20410 20411 20412 20413 20414 20415 20416 20417 20418 20419 20420 20421 20422 20423 20424 20425 20426 20427 20428 20429 20430 20431 20432 20433 20434 20435 20436 20437 20438 20439 20440 20441 20442 20443 20444 20445 20446 20447 20448 20449 20450 20451 20452 20453 20454 20455 20456 20457 20458 20459 20460 20461 20462 20463 20464 20465 20466 20467 20468 20469 20470 20471 20472 20473 20474 20475 20476 20477 20478 20479 20480 20481 20482 20483 20484 20485 20486 20487 20488 20489 20490 20491 20492 20493 20494 20495 20496 20497 20498 20499 20500 20501 20502 20503 20504 20505 20506 20507 20508 20509 20510 20511 20512 20513 20514 20515 20516 20517 20518 20519 20520 20521 20522 20523 20524 20525 20526 20527 20528 20529 20530 20531 20532 20533 20534 20535 20536 20537 20538 20539 20540 20541 20542 20543 20544 20545 20546 20547 20548 20549 20550 20551 20552 20553 20554 20555 20556 20557 20558 20559 20560 20561 20562 20563 20564 20565 20566 20567 20568 20569 20570 20571 20572 20573 20574 20575 20576 20577 20578 20579 20580 20581 20582 20583 20584 20585 20586 20587 20588 20589 20590 20591 20592 20593 20594 20595 20596 20597 20598 20599 20600 20601 20602 20603 20604 20605 20606 20607 20608 20609 20610 20611 20612 20613 20614 20615 20616 20617 20618 20619 20620 20621 20622 20623 20624 20625 20626 20627 20628 20629 20630 20631 20632 20633 20634 20635 20636 20637 20638 20639 20640 20641 20642 20643 20644 20645 20646 20647 20648 20649 20650 20651 20652 20653 20654 20655 20656 20657 20658 20659 20660 20661 20662 20663 20664 20665 20666 20667 20668 20669 20670 20671 20672 20673 20674 20675 20676 20677 20678 20679 20680 20681 20682 20683 20684 20685 20686 20687 20688 20689 20690 20691 20692 20693 20694 20695 20696 20697 20698 20699 20700 20701 20702 20703 20704 20705 20706 20707 20708 20709 20710 20711 20712 20713 20714 20715 20716 20717 20718 20719 20720 20721 20722 20723 20724 20725 20726 20727 20728 20729 20730 20731 20732 20733 20734 20735 20736 20737 20738 20739 20740 20741 20742 20743 20744 20745 20746 20747 20748 20749 20750 20751 20752 20753 20754 20755 20756 20757 20758 20759 20760 20761 20762 20763 20764 20765 20766 20767 20768 20769 20770 20771 20772 20773 20774 20775 20776 20777 20778 20779 20780 20781 20782 20783 20784 20785 20786 20787 20788 20789 20790 20791 20792 20793 20794 20795 20796 20797 20798 20799 20800 20801 20802 20803 20804 20805 20806 20807 20808 20809 20810 20811 20812 20813 20814 20815 20816 20817 20818 20819 20820 20821 20822 20823 20824 20825 20826 20827 20828 20829 20830 20831 20832 20833 20834 20835 20836 20837 20838 20839 20840 20841 20842 20843 20844 20845 20846 20847 20848 20849 20850 20851 20852 20853 20854 20855 20856 20857 20858 20859 20860 20861 20862 20863 20864 20865 20866 20867 20868 20869 20870 20871 20872 20873 20874 20875 20876 20877 20878 20879 20880 20881 20882 20883 20884 20885 20886 20887 20888 20889 20890 20891 20892 20893 20894 20895 20896 20897 20898 20899 20900 20901 20902 20903 20904 20905 20906 20907 20908 20909 20910 20911 20912 20913 20914 20915 20916 20917 20918 20919 20920 20921 20922 20923 20924 20925 20926 20927 20928 20929 20930 20931 20932 20933 20934 20935 20936 20937 20938 20939 20940 20941 20942 20943 20944 20945 20946 20947 20948 20949 20950 20951 20952 20953 20954 20955 20956 20957 20958 20959 20960 20961 20962 20963 20964 20965 20966 20967 20968 20969 20970 20971 20972 20973 20974 20975 20976 20977 20978 20979 20980 20981 20982 20983 20984 20985 20986 20987 20988 20989 20990 20991 20992 20993 20994 20995 20996 20997 20998 20999 21000 21001 21002 21003 21004 21005 21006 21007 21008 21009 21010 21011 21012 21013 21014 21015 21016 21017 21018 21019 21020 21021 21022 21023 21024 21025 21026 21027 21028 21029 21030 21031 21032 21033 21034 21035 21036 21037 21038 21039 21040 21041 21042 21043 21044 21045 21046 21047 21048 21049 21050 21051 21052 21053 21054 21055 21056 21057 21058 21059 21060 21061 21062 21063 21064 21065 21066 21067 21068 21069 21070 21071 21072 21073 21074 21075 21076 21077 21078 21079 21080 21081 21082 21083 21084 21085 21086 21087 21088 21089 21090 21091 21092 21093 21094 21095 21096 21097 21098 21099 21100 21101 21102 21103 21104 21105 21106 21107 21108 21109 21110 21111 21112 21113 21114 21115 21116 21117 21118 21119 21120 21121 21122 21123 21124 21125 21126 21127 21128 21129 21130 21131 21132 21133 21134 21135 21136 21137 21138 21139 21140 21141 21142 21143 21144 21145 21146 21147 21148 21149 21150 21151 21152 21153 21154 21155 21156 21157 21158 21159 21160 21161 21162 21163 21164 21165 21166 21167 21168 21169 21170 21171 21172 21173 21174 21175 21176 21177 21178 21179 21180 21181 21182 21183 21184 21185 21186 21187 21188 21189 21190 21191 21192 21193 21194 21195 21196 21197 21198 21199 21200 21201 21202 21203 21204 21205 21206 21207 21208 21209 21210 21211 21212 21213 21214 21215 21216 21217 21218 21219 21220 21221 21222 21223 21224 21225 21226 21227 21228 21229 21230 21231 21232 21233 21234 21235 21236 21237 21238 21239 21240 21241 21242 21243 21244 21245 21246 21247 21248 21249 21250 21251 21252 21253 21254 21255 21256 21257 21258 21259 21260 21261 21262 21263 21264 21265 21266 21267 21268 21269 21270 21271 21272 21273 21274 21275 21276 21277 21278 21279 21280 21281 21282 21283 21284 21285 21286 21287 21288 21289 21290 21291 21292 21293 21294 21295 21296 21297 21298 21299 21300 21301 21302 21303 21304 21305 21306 21307 21308 21309 21310 21311 21312 21313 21314 21315 21316 21317 21318 21319 21320 21321 21322 21323 21324 21325 21326 21327 21328 21329 21330 21331 21332 21333 21334 21335 21336 21337 21338 21339 21340 21341 21342 21343 21344 21345 21346 21347 21348 21349 21350 21351 21352 21353 21354 21355 21356 21357 21358 21359 21360 21361 21362 21363 21364 21365 21366 21367 21368 21369 21370 21371 21372 21373 21374 21375 21376 21377 21378 21379 21380 21381 21382 21383 21384 21385 21386 21387 21388 21389 21390 21391 21392 21393 21394 21395 21396 21397 21398 21399 21400 21401 21402 21403 21404 21405 21406 21407 21408 21409 21410 21411 21412 21413 21414 21415 21416 21417 21418 21419 21420 21421 21422 21423 21424 21425 21426 21427 21428 21429 21430 21431 21432 21433 21434 21435 21436 21437 21438 21439 21440 21441 21442 21443 21444 21445 21446 21447 21448 21449 21450 21451 21452 21453 21454 21455 21456 21457 21458 21459 21460 21461 21462 21463 21464 21465 21466 21467 21468 21469 21470 21471 21472 21473 21474 21475 21476 21477 21478 21479 21480 21481 21482 21483 21484 21485 21486 21487 21488 21489 21490 21491 21492 21493 21494 21495 21496 21497 21498 21499 21500 21501 21502 21503 21504 21505 21506 21507 21508 21509 21510 21511 21512 21513 21514 21515 21516 21517 21518 21519 21520 21521 21522 21523 21524 21525 21526 21527 21528 21529 21530 21531 21532 21533 21534 21535 21536 21537 21538 21539 21540 21541 21542 21543 21544 21545 21546 21547 21548 21549 21550 21551 21552 21553 21554 21555 21556 21557 21558 21559 21560 21561 21562 21563 21564 21565 21566 21567 21568 21569 21570 21571 21572 21573 21574 21575 21576 21577 21578 21579 21580 21581 21582 21583 21584 21585 21586 21587 21588 21589 21590 21591 21592 21593 21594 21595 21596 21597 21598 21599 21600 21601 21602 21603 21604 21605 21606 21607 21608 21609 21610 21611 21612 21613 21614 21615 21616 21617 21618 21619 21620 21621 21622 21623 21624 21625 21626 21627 21628 21629 21630 21631 21632 21633 21634 21635 21636 21637 21638 21639 21640 21641 21642 21643 21644 21645 21646 21647 21648 21649 21650 21651 21652 21653 21654 21655 21656 21657 21658 21659 21660 21661 21662 21663 21664 21665 21666 21667 21668 21669 21670 21671 21672 21673 21674 21675 21676 21677 21678 21679 21680 21681 21682 21683 21684 21685 21686 21687 21688 21689 21690 21691 21692 21693 21694 21695 21696 21697 21698 21699 21700 21701 21702 21703 21704 21705 21706 21707 21708 21709 21710 21711 21712 21713 21714 21715 21716 21717 21718 21719 21720 21721 21722 21723 21724 21725 21726 21727 21728 21729 21730 21731 21732 21733 21734 21735 21736 21737 21738 21739 21740 21741 21742 21743 21744 21745 21746 21747 21748 21749 21750 21751 21752 21753 21754 21755 21756 21757 21758 21759 21760 21761 21762 21763 21764 21765 21766 21767 21768 21769 21770 21771 21772 21773 21774 21775 21776 21777 21778 21779 21780 21781 21782 21783 21784 21785 21786 21787 21788 21789 21790 21791 21792 21793 21794 21795 21796 21797 21798 21799 21800 21801 21802 21803 21804 21805 21806 21807 21808 21809 21810 21811 21812 21813 21814 21815 21816 21817 21818 21819 21820 21821 21822 21823 21824 21825 21826 21827 21828 21829 21830 21831 21832 21833 21834 21835 21836 21837 21838 21839 21840 21841 21842 21843 21844 21845 21846 21847 21848 21849 21850 21851 21852 21853 21854 21855 21856 21857 21858 21859 21860 21861 21862 21863 21864 21865 21866 21867 21868 21869 21870 21871 21872 21873 21874 21875 21876 21877 21878 21879 21880 21881 21882 21883 21884 21885 21886 21887 21888 21889 21890 21891 21892 21893 21894 21895 21896 21897 21898 21899 21900 21901 21902 21903 21904 21905 21906 21907 21908 21909 21910 21911 21912 21913 21914 21915 21916 21917 21918 21919 21920 21921 21922 21923 21924 21925 21926 21927 21928 21929 21930 21931 21932 21933 21934 21935 21936 21937 21938 21939 21940 21941 21942 21943 21944 21945 21946 21947 21948 21949 21950 21951 21952 21953 21954 21955 21956 21957 21958 21959 21960 21961 21962 21963 21964 21965 21966 21967 21968 21969 21970 21971 21972 21973 21974 21975 21976 21977 21978 21979 21980 21981 21982 21983 21984 21985 21986 21987 21988 21989 21990 21991 21992 21993 21994 21995 21996 21997 21998 21999 22000 22001 22002 22003 22004 22005 22006 22007 22008 22009 22010 22011 22012 22013 22014 22015 22016 22017 22018 22019 22020 22021 22022 22023 22024 22025 22026 22027 22028 22029 22030 22031 22032 22033 22034 22035 22036 22037 22038 22039 22040 22041 22042 22043 22044 22045 22046 22047 22048 22049 22050 22051 22052 22053 22054 22055 22056 22057 22058 22059 22060 22061 22062 22063 22064 22065 22066 22067 22068 22069 22070 22071 22072 22073 22074 22075 22076 22077 22078 22079 22080 22081 22082 22083 22084 22085 22086 22087 22088 22089 22090 22091 22092 22093 22094 22095 22096 22097 22098 22099 22100 22101 22102 22103 22104 22105 22106 22107 22108 22109 22110 22111 22112 22113 22114 22115 22116 22117 22118 22119 22120 22121 22122 22123 22124 22125 22126 22127 22128 22129 22130 22131 22132 22133 22134 22135 22136 22137 22138 22139 22140 22141 22142 22143 22144 22145 22146 22147 22148 22149 22150 22151 22152 22153 22154 22155 22156 22157 22158 22159 22160 22161 22162 22163 22164 22165 22166 22167 22168 22169 22170 22171 22172 22173 22174 22175 22176 22177 22178 22179 22180 22181 22182 22183 22184 22185 22186 22187 22188 22189 22190 22191 22192 22193 22194 22195 22196 22197 22198 22199 22200 22201 22202 22203 22204 22205 22206 22207 22208 22209 22210 22211 22212 22213 22214 22215 22216 22217 22218 22219 22220 22221 22222 22223 22224 22225 22226 22227 22228 22229 22230 22231 22232 22233 22234 22235 22236 22237 22238 22239 22240 22241 22242 22243 22244 22245 22246 22247 22248 22249 22250 22251 22252 22253 22254 22255 22256 22257 22258 22259 22260 22261 22262 22263 22264 22265 22266 22267 22268 22269 22270 22271 22272 22273 22274 22275 22276 22277 22278 22279 22280 22281 22282 22283 22284 22285 22286 22287 22288 22289 22290 22291 22292 22293 22294 22295 22296 22297 22298 22299 22300 22301 22302 22303 22304 22305 22306 22307 22308 22309 22310 22311 22312 22313 22314 22315 22316 22317 22318 22319 22320 22321 22322 22323 22324 22325 22326 22327 22328 22329 22330 22331 22332 22333 22334 22335 22336 22337 22338 22339 22340 22341 22342 22343 22344 22345 22346 22347 22348 22349 22350 22351 22352 22353 22354 22355 22356 22357 22358 22359 22360 22361 22362 22363 22364 22365 22366 22367 22368 22369 22370 22371 22372 22373 22374 22375 22376 22377 22378 22379 22380 22381 22382 22383 22384 22385 22386 22387 22388 22389 22390 22391 22392 22393 22394 22395 22396 22397 22398 22399 22400 22401 22402 22403 22404 22405 22406 22407 22408 22409 22410 22411 22412 22413 22414 22415 22416 22417 22418 22419 22420 22421 22422 22423 22424 22425 22426 22427 22428 22429 22430 22431 22432 22433 22434 22435 22436 22437 22438 22439 22440 22441 22442 22443 22444 22445 22446 22447 22448 22449 22450 22451 22452 22453 22454 22455 22456 22457 22458 22459 22460 22461 22462 22463 22464 22465 22466 22467 22468 22469 22470 22471 22472 22473 22474 22475 22476 22477 22478 22479 22480 22481 22482 22483 22484 22485 22486 22487 22488 22489 22490 22491 22492 22493 22494 22495 22496 22497 22498 22499 22500 22501 22502 22503 22504 22505 22506 22507 22508 22509 22510 22511 22512 22513 22514 22515 22516 22517 22518 22519 22520 22521 22522 22523 22524 22525 22526 22527 22528 22529 22530 22531 22532 22533 22534 22535 22536 22537 22538 22539 22540 22541 22542 22543 22544 22545 22546 22547 22548 22549 22550 22551 22552 22553 22554 22555 22556 22557 22558 22559 22560 22561 22562 22563 22564 22565 22566 22567 22568 22569 22570 22571 22572 22573 22574 22575 22576 22577 22578 22579 22580 22581 22582 22583 22584 22585 22586 22587 22588 22589 22590 22591 22592 22593 22594 22595 22596 22597 22598 22599 22600 22601 22602 22603 22604 22605 22606 22607 22608 22609 22610 22611 22612 22613 22614 22615 22616 22617 22618 22619 22620 22621 22622 22623 22624 22625 22626 22627 22628 22629 22630 22631 22632 22633 22634 22635 22636 22637 22638 22639 22640 22641 22642 22643 22644 22645 22646 22647 22648 22649 22650 22651 22652 22653 22654 22655 22656 22657 22658 22659 22660 22661 22662 22663 22664 22665 22666 22667 22668 22669 22670 22671 22672 22673 22674 22675 22676 22677 22678 22679 22680 22681 22682 22683 22684 22685 22686 22687 22688 22689 22690 22691 22692 22693 22694 22695 22696 22697 22698 22699 22700 22701 22702 22703 22704 22705 22706 22707 22708 22709 22710 22711 22712 22713 22714 22715 22716 22717 22718 22719 22720 22721 22722 22723 22724 22725 22726 22727 22728 22729 22730 22731 22732 22733 22734 22735 22736 22737 22738 22739 22740 22741 22742 22743 22744 22745 22746 22747 22748 22749 22750 22751 22752 22753 22754 22755 22756 22757 22758 22759 22760 22761 22762 22763 22764 22765 22766 22767 22768 22769 22770 22771 22772 22773 22774 22775 22776 22777 22778 22779 22780 22781 22782 22783 22784 22785 22786 22787 22788 22789 22790 22791 22792 22793 22794 22795 22796 22797 22798 22799 22800 22801 22802 22803 22804 22805 22806 22807 22808 22809 22810 22811 22812 22813 22814 22815 22816 22817 22818 22819 22820 22821 22822 22823 22824 22825 22826 22827 22828 22829 22830 22831 22832 22833 22834 22835 22836 22837 22838 22839 22840 22841 22842 22843 22844 22845 22846 22847 22848 22849 22850 22851 22852 22853 22854 22855 22856 22857 22858 22859 22860 22861 22862 22863 22864 22865 22866 22867 22868 22869 22870 22871 22872 22873 22874 22875 22876 22877 22878 22879 22880 22881 22882 22883 22884 22885 22886 22887 22888 22889 22890 22891 22892 22893 22894 22895 22896 22897 22898 22899 22900 22901 22902 22903 22904 22905 22906 22907 22908 22909 22910 22911 22912 22913 22914 22915 22916 22917 22918 22919 22920 22921 22922 22923 22924 22925 22926 22927 22928 22929 22930 22931 22932 22933 22934 22935 22936 22937 22938 22939 22940 22941 22942 22943 22944 22945 22946 22947 22948 22949 22950 22951 22952 22953 22954 22955 22956 22957 22958 22959 22960 22961 22962 22963 22964 22965 22966 22967 22968 22969 22970 22971 22972 22973 22974 22975 22976 22977 22978 22979 22980 22981 22982 22983 22984 22985 22986 22987 22988 22989 22990 22991 22992 22993 22994 22995 22996 22997 22998 22999 23000 23001 23002 23003 23004 23005 23006 23007 23008 23009 23010 23011 23012 23013 23014 23015 23016 23017 23018 23019 23020 23021 23022 23023 23024 23025 23026 23027 23028 23029 23030 23031 23032 23033 23034 23035 23036 23037 23038 23039 23040 23041 23042 23043 23044 23045 23046 23047 23048 23049 23050 23051 23052 23053 23054 23055 23056 23057 23058 23059 23060 23061 23062 23063 23064 23065 23066 23067 23068 23069 23070 23071 23072 23073 23074 23075 23076 23077 23078 23079 23080 23081 23082 23083 23084 23085 23086 23087 23088 23089 23090 23091 23092 23093 23094 23095 23096 23097 23098 23099 23100 23101 23102 23103 23104 23105 23106 23107 23108 23109 23110 23111 23112 23113 23114 23115 23116 23117 23118 23119 23120 23121 23122 23123 23124 23125 23126 23127 23128 23129 23130 23131 23132 23133 23134 23135 23136 23137 23138 23139 23140 23141 23142 23143 23144 23145 23146 23147 23148 23149 23150 23151 23152 23153 23154 23155 23156 23157 23158 23159 23160 23161 23162 23163 23164 23165 23166 23167 23168 23169 23170 23171 23172 23173 23174 23175 23176 23177 23178 23179 23180 23181 23182 23183 23184 23185 23186 23187 23188 23189 23190 23191 23192 23193 23194 23195 23196 23197 23198 23199 23200 23201 23202 23203 23204 23205 23206 23207 23208 23209 23210 23211 23212 23213 23214 23215 23216 23217 23218 23219 23220 23221 23222 23223 23224 23225 23226 23227 23228 23229 23230 23231 23232 23233 23234 23235 23236 23237 23238 23239 23240 23241 23242 23243 23244 23245 23246 23247 23248 23249 23250 23251 23252 23253 23254 23255 23256 23257 23258 23259 23260 23261 23262 23263 23264 23265 23266 23267 23268 23269 23270 23271 23272 23273 23274 23275 23276 23277 23278 23279 23280 23281 23282 23283 23284 23285 23286 23287 23288 23289 23290 23291 23292 23293 23294 23295 23296 23297 23298 23299 23300 23301 23302 23303 23304 23305 23306 23307 23308 23309 23310 23311 23312 23313 23314 23315 23316 23317 23318 23319 23320 23321 23322 23323 23324 23325 23326 23327 23328 23329 23330 23331 23332 23333 23334 23335 23336 23337 23338 23339 23340 23341 23342 23343 23344 23345 23346 23347 23348 23349 23350 23351 23352 23353 23354 23355 23356 23357 23358 23359 23360 23361 23362 23363 23364 23365 23366 23367 23368 23369 23370 23371 23372 23373 23374 23375 23376 23377 23378 23379 23380 23381 23382 23383 23384 23385 23386 23387 23388 23389 23390 23391 23392 23393 23394 23395 23396 23397 23398 23399 23400 23401 23402 23403 23404 23405 23406 23407 23408 23409 23410 23411 23412 23413 23414 23415 23416 23417 23418 23419 23420 23421 23422 23423 23424 23425 23426 23427 23428 23429 23430 23431 23432 23433 23434 23435 23436 23437 23438 23439 23440 23441 23442 23443 23444 23445 23446 23447 23448 23449 23450 23451 23452 23453 23454 23455 23456 23457 23458 23459 23460 23461 23462 23463 23464 23465 23466 23467 23468 23469 23470 23471 23472 23473 23474 23475 23476 23477 23478 23479 23480 23481 23482 23483 23484 23485 23486 23487 23488 23489 23490 23491 23492 23493 23494 23495 23496 23497 23498 23499 23500 23501 23502 23503 23504 23505 23506 23507 23508 23509 23510 23511 23512 23513 23514 23515 23516 23517 23518 23519 23520 23521 23522 23523 23524 23525 23526 23527 23528 23529 23530 23531 23532 23533 23534 23535 23536 23537 23538 23539 23540 23541 23542 23543 23544 23545 23546 23547 23548 23549 23550 23551 23552 23553 23554 23555 23556 23557 23558 23559 23560 23561 23562 23563 23564 23565 23566 23567 23568 23569 23570 23571 23572 23573 23574 23575 23576 23577 23578 23579 23580 23581 23582 23583 23584 23585 23586 23587 23588 23589 23590 23591 23592 23593 23594 23595 23596 23597 23598 23599 23600 23601 23602 23603 23604 23605 23606 23607 23608 23609 23610 23611 23612 23613 23614 23615 23616 23617 23618 23619 23620 23621 23622 23623 23624 23625 23626 23627 23628 23629 23630 23631 23632 23633 23634 23635 23636 23637 23638 23639 23640 23641 23642 23643 23644 23645 23646 23647 23648 23649 23650 23651 23652 23653 23654 23655 23656 23657 23658 23659 23660 23661 23662 23663 23664 23665 23666 23667 23668 23669 23670 23671 23672 23673 23674 23675 23676 23677 23678 23679 23680 23681 23682 23683 23684 23685 23686 23687 23688 23689 23690 23691 23692 23693 23694 23695 23696 23697 23698 23699 23700 23701 23702 23703 23704 23705 23706 23707 23708 23709 23710 23711 23712 23713 23714 23715 23716 23717 23718 23719 23720 23721 23722 23723 23724 23725 23726 23727 23728 23729 23730 23731 23732 23733 23734 23735 23736 23737 23738 23739 23740 23741 23742 23743 23744 23745 23746 23747 23748 23749 23750 23751 23752 23753 23754 23755 23756 23757 23758 23759 23760 23761 23762 23763 23764 23765 23766 23767 23768 23769 23770 23771 23772 23773 23774 23775 23776 23777 23778 23779 23780 23781 23782 23783 23784 23785 23786 23787 23788 23789 23790 23791 23792 23793 23794 23795 23796 23797 23798 23799 23800 23801 23802 23803 23804 23805 23806 23807 23808 23809 23810 23811 23812 23813 23814 23815 23816 23817 23818 23819 23820 23821 23822 23823 23824 23825 23826 23827 23828 23829 23830 23831 23832 23833 23834 23835 23836 23837 23838 23839 23840 23841 23842 23843 23844 23845 23846 23847 23848 23849 23850 23851 23852 23853 23854 23855 23856 23857 23858 23859 23860 23861 23862 23863 23864 23865 23866 23867 23868 23869 23870 23871 23872 23873 23874 23875 23876 23877 23878 23879 23880 23881 23882 23883 23884 23885 23886 23887 23888 23889 23890 23891 23892 23893 23894 23895 23896 23897 23898 23899 23900 23901 23902 23903 23904 23905 23906 23907 23908 23909 23910 23911 23912 23913 23914 23915 23916 23917 23918 23919 23920 23921 23922 23923 23924 23925 23926
#
#
#            Nimrod's Runtime Library
#        (c) Copyright 2010 Andreas Rumpf
#
#    See the file "copying.txt", included in this
#    distribution, for details about the copyright.
#

## Define ``winUnicode`` before importing this module for the
## Unicode version.

{.deadCodeElim: on.}

type
  WideChar* = uint16
  PWideChar* = ptr uint16

type  # WinNT.h -- Defines the 32-Bit Windows types and constants
  SHORT* = int16
  LONG* = int32
  # UNICODE (Wide Character) types
  PWCHAR* = PWideChar
  LPWCH* = PWideChar
  PWCH* = PWideChar
  LPCWCH* = PWideChar
  PCWCH* = PWideChar
  NWPSTR* = PWideChar
  LPWSTR* = PWideChar
  LPCWSTR* = PWideChar
  PCWSTR* = PWideChar
  # ANSI (Multi-byte Character) types
  LPCH* = cstring
  PCH* = cstring
  LPCCH* = cstring
  PCCH* = cstring
  LPSTR* = cstring
  PSTR* = cstring
  LPCSTR* = cstring
  PCSTR* = cstring

type  # BaseTsd.h -- Type definitions for the basic sized types
      # Give here only the bare minimum, to be expanded as needs arise
  LONG32* = int32
  ULONG32* = int32
  DWORD32* = int32
  LONG64* = int64
  ULONG64* = int64
  DWORD64* = int64
  PDWORD64* = ptr DWORD64
  # int32 on Win32, int64 on Win64
  INT_PTR* = TAddress
  UINT_PTR* = TAddress
  LONG_PTR* = TAddress
  ULONG_PTR* = TAddress
  SIZE_T* = TAddress
  SSIZE_T* = TAddress
  DWORD_PTR* = TAddress
  # Thread affinity
  KAFFINITY* = TAddress
  PKAFFINITY* = ptr KAFFINITY

type  # WinDef.h -- Basic Windows Type Definitions
  # BaseTypes
  UINT = int32
  ULONG* = int
  PULONG* = ptr int
  USHORT* = int16
  PUSHORT* = ptr int16
  UCHAR* = int8
  PUCHAR* = ptr int8
  PSZ* = cstring

  DWORD* = int32
  WINBOOL* = int32
  WORD* = int16
  # FLOAT* = float
  PFLOAT* = ptr FLOAT
  PWINBOOL* = ptr WINBOOL
  LPWINBOOL* = ptr WINBOOL
  PBYTE* = ptr int8
  LPBYTE* = ptr int8
  PINT* = ptr int32
  LPINT* = ptr int32
  PWORD* = ptr int16
  LPWORD* = ptr int16
  LPLONG* = ptr int32
  PDWORD* = ptr DWORD
  LPDWORD* = ptr DWORD
  LPVOID* = pointer
  LPCVOID* = pointer

  # INT* = int  # Cannot work and not necessary anyway
  PUINT* = ptr int

  WPARAM* = LONG_PTR
  LPARAM* = LONG_PTR
  LRESULT* = LONG_PTR

  ATOM* = int16
  TAtom* = ATOM
  HANDLE* = int
  THandle* = HANDLE
  PHANDLE* = ptr HANDLE
  LPHANDLE* = ptr HANDLE
  HWND* = HANDLE
  HHOOK* = HANDLE
  HEVENT* = HANDLE
  HGLOBAL* = HANDLE
  HLOCAL* = HANDLE
  HGDIOBJ* = HANDLE
  HKEY* = HANDLE
  PHKEY* = ptr HKEY
  HACCEL* = HANDLE
  HBITMAP* = HANDLE
  HBRUSH* = HANDLE
  HCOLORSPACE* = HANDLE
  HDC* = HANDLE
  HGLRC* = HANDLE
  HDESK* = HANDLE
  HENHMETAFILE* = HANDLE
  HFONT* = HANDLE
  HICON* = HANDLE
  HMETAFILE* = HANDLE
  HINST* = HANDLE  # Not HINSTANCE, else it has problems with the var HInstance
  HMODULE* = HANDLE
  HPALETTE* = HANDLE
  HPEN* = HANDLE
  HRGN* = HANDLE
  HRSRC* = HANDLE
  HTASK* = HANDLE
  HWINSTA* = HANDLE
  HKL* = HANDLE
  HMONITOR* = HANDLE
  HWINEVENTHOOK* = HANDLE
  HUMPD* = HANDLE

  HFILE* = HANDLE
  HCURSOR* = HANDLE # = HICON
  COLORREF* = int
  LPCOLORREF* = ptr COLORREF

  POINT* {.final, pure.} = object
    x*: LONG
    y*: LONG
  PPOINT* = ptr POINT
  LPPOINT* = ptr POINT
  POINTL* {.final, pure.} = object
    x*: LONG
    y*: LONG
  PPOINTL* = ptr POINTL

  TPOINT* = POINT
  TPOINTL* = POINTL

  RECT* {.final, pure.} = object
    TopLeft*, BottomRight*: TPoint
  PRECT* = ptr RECT
  LPRECT* = ptr RECT

  RECTL* {.final, pure.} = object
    left*: LONG
    top*: LONG
    right*: LONG
    bottom*: LONG
  PRECTL* = ptr RECTL

  SIZE* {.final, pure.} = object
    cx*: LONG
    cy*: LONG
  PSIZE* = ptr SIZE
  LPSIZE* = ptr SIZE
  SIZEL* = SIZE
  PSIZEL* = ptr SIZE
  LPSIZEL* = ptr SIZE

  POINTS* {.final, pure.} = object
    x*: SHORT
    y*: SHORT
  PPOINTS* = ptr POINTS

  TRECT* = RECT
  TRECTL* = RECTL
  TSIZE* = SIZE
  TSIZEL* = SIZE
  TPOINTS* = POINTS

  FILETIME* {.final, pure.} = object
    dwLowDateTime*: DWORD
    dwHighDateTime*: DWORD
  PFILETIME* = ptr FILETIME
  LPFILETIME* = ptr FILETIME

  TFILETIME* = FILETIME

const
  MAX_PATH* = 260
  HFILE_ERROR* = HFILE(-1)

  # mode selections for the device mode function
  # DocumentProperties
  DM_UPDATE* = 1
  DM_COPY* = 2
  DM_PROMPT* = 4
  DM_MODIFY* = 8

  DM_IN_BUFFER* = DM_MODIFY
  DM_IN_PROMPT* = DM_PROMPT
  DM_OUT_BUFFER* = DM_COPY
  DM_OUT_DEFAULT* = DM_UPDATE

  # device capabilities indices
  DC_FIELDS* = 1
  DC_PAPERS* = 2
  DC_PAPERSIZE* = 3
  DC_MINEXTENT* = 4
  DC_MAXEXTENT* = 5
  DC_BINS* = 6
  DC_DUPLEX* = 7
  DC_SIZE* = 8
  DC_EXTRA* = 9
  DC_VERSION* = 10
  DC_DRIVER* = 11
  DC_BINNAMES* = 12
  DC_ENUMRESOLUTIONS* = 13
  DC_FILEDEPENDENCIES* = 14
  DC_TRUETYPE* = 15
  DC_PAPERNAMES* = 16
  DC_ORIENTATION* = 17
  DC_COPIES* = 18

  DC_BINADJUST* = 19
  DC_EMF_COMPLIANT* = 20
  DC_DATATYPE_PRODUCED* = 21

type
  WORDBOOL* = int16  # XXX: not a bool
  CALTYPE* = int
  CALID* = int
  CCHAR* = char
  TCOLORREF* = int
  WINT* = int32
  PINTEGER* = ptr int32
  PBOOL* = ptr WINBOOL
  LONGLONG* = int64
  PLONGLONG* = ptr LONGLONG
  LPLONGLONG* = ptr LONGLONG
  ULONGLONG* = int64          # used in AMD64 CONTEXT
  PULONGLONG* = ptr ULONGLONG #
  DWORDLONG* = int64          # was unsigned long
  PDWORDLONG* = ptr DWORDLONG
  HRESULT* = int
  PHRESULT* = ptr HRESULT
  HCONV* = HANDLE
  HCONVLIST* = HANDLE
  HDBC* = HANDLE
  HDDEDATA* = HANDLE
  HDROP* = HANDLE
  HDWP* = HANDLE
  HENV* = HANDLE
  HIMAGELIST* = HANDLE
  HMENU* = HANDLE
  HRASCONN* = HANDLE
  HSTMT* = HANDLE
  HSTR* = HANDLE
  HSZ* = HANDLE
  LANGID* = int16
  LCID* = DWORD
  LCTYPE* = DWORD
  LP* = ptr int16
  LPBOOL* = ptr WINBOOL

when defined(winUnicode):
  type
    LPCTSTR* = PWideChar
else:
  type
    LPCTSTR* = cstring
type
  LPPCSTR* = ptr LPCSTR
  LPPCTSTR* = ptr LPCTSTR
  LPPCWSTR* = ptr LPCWSTR

when defined(winUnicode):
  type
    LPTCH* = PWideChar
    LPTSTR* = PWideChar
else:
  type
    LPTCH* = cstring
    LPTSTR* = cstring
type
  PBOOLEAN* = ptr int8
  PLONG* = ptr int32
  PSHORT* = ptr SHORT

when defined(winUnicode):
  type
    PTBYTE* = ptr uint16
    PTCH* = PWideChar
    PTCHAR* = PWideChar
    PTSTR* = PWideChar
else:
  type
    PTBYTE* = ptr byte
    PTCH* = cstring
    PTCHAR* = cstring
    PTSTR* = cstring
type
  PVOID* = pointer
  RETCODE* = SHORT
  SC_HANDLE* = HANDLE
  SC_LOCK* = LPVOID
  LPSC_HANDLE* = ptr SC_HANDLE
  SERVICE_STATUS_HANDLE* = DWORD

when defined(winUnicode):
  type
    TBYTE* = uint16
    TCHAR* = widechar
    BCHAR* = int16
else:
  type
    TBYTE* = uint8
    TCHAR* = char
    BCHAR* = int8
type
  WCHAR* = WideChar
  PLPSTR* = ptr LPSTR
  PLPWStr* = ptr LPWStr
  ACL_INFORMATION_CLASS* = enum
    AclRevisionInformation = 1, AclSizeInformation
  MEDIA_TYPE* = enum
    Unknown, F5_1Pt2_512, F3_1Pt44_512, F3_2Pt88_512, F3_20Pt8_512, F3_720_512,
    F5_360_512, F5_320_512, F5_320_1024, F5_180_512, F5_160_512, RemovableMedia,
    FixedMedia

const
  RASCS_DONE* = 0x00002000
  RASCS_PAUSED* = 0x00001000

type
  RASCONNSTATE* = enum
    RASCS_OpenPort = 0, RASCS_PortOpened, RASCS_ConnectDevice,
    RASCS_DeviceConnected, RASCS_AllDevicesConnected, RASCS_Authenticate,
    RASCS_AuthNotify, RASCS_AuthRetry, RASCS_AuthCallback,
    RASCS_AuthChangePassword, RASCS_AuthProject, RASCS_AuthLinkSpeed,
    RASCS_AuthAck, RASCS_ReAuthenticate, RASCS_Authenticated,
    RASCS_PrepareForCallback, RASCS_WaitForModemReset, RASCS_WaitForCallback,
    RASCS_Projected, RASCS_StartAuthentication, RASCS_CallbackComplete,
    RASCS_LogonNetwork, RASCS_Interactive = RASCS_PAUSED,
    RASCS_RetryAuthentication, RASCS_CallbackSetByCaller, RASCS_PasswordExpired,
    RASCS_Connected = RASCS_DONE, RASCS_Disconnected
  RASPROJECTION* = enum
    RASP_PppIp = 0x00008021, RASP_PppIpx = 0x0000802B, RASP_PppNbf = 0x0000803F,
    RASP_Amb = 0x00010000
  SECURITY_IMPERSONATION_LEVEL* = enum


    SecurityAnonymous, SecurityIdentification, SecurityImpersonation,
    SecurityDelegation
  SID_NAME_USE* = enum
    SidTypeUser = 1, SidTypeGroup, SidTypeDomain, SidTypeAlias,
    SidTypeWellKnownGroup, SidTypeDeletedAccount, SidTypeInvalid, SidTypeUnknown
  PSID_NAME_USE* = ptr SID_NAME_USE
  TOKEN_INFORMATION_CLASS* = enum
    TokenUser = 1, TokenGroups, TokenPrivileges, TokenOwner, TokenPrimaryGroup,
    TokenDefaultDacl, TokenSource, TokenType, TokenImpersonationLevel,
    TokenStatistics
  TTOKEN_TYPE* = enum
    TokenPrimary = 1, TokenImpersonation
  MakeIntResourceA* = cstring
  MakeIntResourceW* = PWideChar
  MakeIntResource* = MakeIntResourceA

#
#    Definitions for callback procedures
#
type
  BFFCALLBACK* = proc (para1: HWND, para2: UINT, para3: LPARAM, para4: LPARAM): int32{.
      stdcall.}
  LPCCHOOKPROC* = proc (para1: HWND, para2: UINT, para3: WPARAM, para4: LPARAM): UINT{.
      stdcall.}
  LPCFHOOKPROC* = proc (para1: HWND, para2: UINT, para3: WPARAM, para4: LPARAM): UINT{.
      stdcall.}
  PTHREAD_START_ROUTINE* = Pointer
  LPTHREAD_START_ROUTINE* = PTHREAD_START_ROUTINE
  EDITSTREAMCALLBACK* = proc (para1: DWORD, para2: LPBYTE, para3: LONG,
                              para4: LONG): DWORD{.stdcall.}
  LPFRHOOKPROC* = proc (para1: HWND, para2: UINT, para3: WPARAM, para4: LPARAM): UINT{.
      stdcall.}
  LPOFNHOOKPROC* = proc (para1: HWND, para2: UINT, para3: WPARAM, para4: LPARAM): UINT{.
      stdcall.}
  LPPRINTHOOKPROC* = proc (para1: HWND, para2: UINT, para3: WPARAM,
                           para4: LPARAM): UINT{.stdcall.}
  LPSETUPHOOKPROC* = proc (para1: HWND, para2: UINT, para3: WPARAM,
                           para4: LPARAM): UINT{.stdcall.}
  DLGPROC* = proc (para1: HWND, para2: UINT, para3: WPARAM, para4: LPARAM): LRESULT{.
      stdcall.}
  PFNPROPSHEETCALLBACK* = proc (para1: HWND, para2: UINT, para3: LPARAM): int32{.
      stdcall.}
  LPSERVICE_MAIN_FUNCTION* = proc (para1: DWORD, para2: LPTSTR){.stdcall.}
  PFNTVCOMPARE* = proc (para1: LPARAM, para2: LPARAM, para3: LPARAM): int32{.
      stdcall.}
  WNDPROC* = proc (para1: HWND, para2: UINT, para3: WPARAM, para4: LPARAM): LRESULT{.
      stdcall.}
  FARPROC* = pointer
  TFarProc* = FARPROC
  TProc* = pointer
  ENUMRESTYPEPROC* = proc (para1: HANDLE, para2: LPTSTR, para3: LONG): WINBOOL{.
      stdcall.}
  ENUMRESNAMEPROC* = proc (para1: HANDLE, para2: LPCTSTR, para3: LPTSTR,
                           para4: LONG): WINBOOL{.stdcall.}
  ENUMRESLANGPROC* = proc (para1: HANDLE, para2: LPCTSTR, para3: LPCTSTR,
                           para4: int16, para5: LONG): WINBOOL{.stdcall.}
  DESKTOPENUMPROC* = FARPROC
  ENUMWINDOWSPROC* = proc (para1: HWND, para2: LPARAM): WINBOOL{.stdcall.}
  ENUMWINDOWSTATIONPROC* = proc (para1: LPTSTR, para2: LPARAM): WINBOOL{.stdcall.}
  SENDASYNCPROC* = proc (para1: HWND, para2: UINT, para3: DWORD, para4: LRESULT){.
      stdcall.}
  TIMERPROC* = proc (para1: HWND, para2: UINT, para3: UINT, para4: DWORD){.
      stdcall.}
  GRAYSTRINGPROC* = FARPROC
  DRAWSTATEPROC* = proc (para1: HDC, para2: LPARAM, para3: WPARAM, para4: int32,
                         para5: int32): WINBOOL{.stdcall.}
  PROPENUMPROCEX* = proc (para1: HWND, para2: LPCTSTR, para3: HANDLE,
                          para4: DWORD): WINBOOL{.stdcall.}
  PROPENUMPROC* = proc (para1: HWND, para2: LPCTSTR, para3: HANDLE): WINBOOL{.
      stdcall.}
  HOOKPROC* = proc (para1: int32, para2: WPARAM, para3: LPARAM): LRESULT{.
      stdcall.}
  ENUMOBJECTSPROC* = proc (para1: LPVOID, para2: LPARAM){.stdcall.}
  LINEDDAPROC* = proc (para1: int32, para2: int32, para3: LPARAM){.stdcall.}
  TABORTPROC* = proc (para1: HDC, para2: int32): WINBOOL{.stdcall.}
  LPPAGEPAINTHOOK* = proc (para1: HWND, para2: UINT, para3: WPARAM,
                           para4: LPARAM): UINT{.stdcall.}
  LPPAGESETUPHOOK* = proc (para1: HWND, para2: UINT, para3: WPARAM,
                           para4: LPARAM): UINT{.stdcall.}
  ICMENUMPROC* = proc (para1: LPTSTR, para2: LPARAM): int32{.stdcall.}
  EDITWORDBREAKPROCEX* = proc (para1: cstring, para2: LONG, para3: int8,
                               para4: WINT): LONG{.stdcall.}
  PFNLVCOMPARE* = proc (para1: LPARAM, para2: LPARAM, para3: LPARAM): int32{.
      stdcall.}
  LOCALE_ENUMPROC* = proc (para1: LPTSTR): WINBOOL{.stdcall.}
  CODEPAGE_ENUMPROC* = proc (para1: LPTSTR): WINBOOL{.stdcall.}
  DATEFMT_ENUMPROC* = proc (para1: LPTSTR): WINBOOL{.stdcall.}
  TIMEFMT_ENUMPROC* = proc (para1: LPTSTR): WINBOOL{.stdcall.}
  CALINFO_ENUMPROC* = proc (para1: LPTSTR): WINBOOL{.stdcall.}
  PHANDLER_ROUTINE* = proc (para1: DWORD): WINBOOL{.stdcall.}
  LPHANDLER_FUNCTION* = proc (para1: DWORD): WINBOOL{.stdcall.}
  PFNGETPROFILEPATH* = proc (para1: LPCTSTR, para2: LPSTR, para3: UINT): UINT{.
      stdcall.}
  PFNRECONCILEPROFILE* = proc (para1: LPCTSTR, para2: LPCTSTR, para3: DWORD): UINT{.
      stdcall.}
  PFNPROCESSPOLICIES* = proc (para1: HWND, para2: LPCTSTR, para3: LPCTSTR,
                              para4: LPCTSTR, para5: DWORD): WINBOOL{.stdcall.}

const
  SE_CREATE_TOKEN_NAME* = "SeCreateTokenPrivilege"
  SE_ASSIGNPRIMARYTOKEN_NAME* = "SeAssignPrimaryTokenPrivilege"
  SE_LOCK_MEMORY_NAME* = "SeLockMemoryPrivilege"
  SE_INCREASE_QUOTA_NAME* = "SeIncreaseQuotaPrivilege"
  SE_UNSOLICITED_INPUT_NAME* = "SeUnsolicitedInputPrivilege"
  SE_MACHINE_ACCOUNT_NAME* = "SeMachineAccountPrivilege"
  SE_TCB_NAME* = "SeTcbPrivilege"
  SE_SECURITY_NAME* = "SeSecurityPrivilege"
  SE_TAKE_OWNERSHIP_NAME* = "SeTakeOwnershipPrivilege"
  SE_LOAD_DRIVER_NAME* = "SeLoadDriverPrivilege"
  SE_SYSTEM_PROFILE_NAME* = "SeSystemProfilePrivilege"
  SE_SYSTEMTIME_NAME* = "SeSystemtimePrivilege"
  SE_PROF_SINGLE_PROCESS_NAME* = "SeProfileSingleProcessPrivilege"
  SE_INC_BASE_PRIORITY_NAME* = "SeIncreaseBasePriorityPrivilege"
  SE_CREATE_PAGEFILE_NAME* = "SeCreatePagefilePrivilege"
  SE_CREATE_PERMANENT_NAME* = "SeCreatePermanentPrivilege"
  SE_BACKUP_NAME* = "SeBackupPrivilege"
  SE_RESTORE_NAME* = "SeRestorePrivilege"
  SE_SHUTDOWN_NAME* = "SeShutdownPrivilege"
  SE_DEBUG_NAME* = "SeDebugPrivilege"
  SE_AUDIT_NAME* = "SeAuditPrivilege"
  SE_SYSTEM_ENVIRONMENT_NAME* = "SeSystemEnvironmentPrivilege"
  SE_CHANGE_NOTIFY_NAME* = "SeChangeNotifyPrivilege"
  SE_REMOTE_SHUTDOWN_NAME* = "SeRemoteShutdownPrivilege"
  SERVICES_ACTIVE_DATABASEW* = "ServicesActive"
  SERVICES_FAILED_DATABASEW* = "ServicesFailed"
  SERVICES_ACTIVE_DATABASEA* = "ServicesActive"
  SERVICES_FAILED_DATABASEA* = "ServicesFailed"
  SC_GROUP_IDENTIFIERW* = "+"
  SC_GROUP_IDENTIFIERA* = "+"

when defined(winUnicode):
  const
    SERVICES_ACTIVE_DATABASE* = SERVICES_ACTIVE_DATABASEW
    SERVICES_FAILED_DATABASE* = SERVICES_FAILED_DATABASEW
    SC_GROUP_IDENTIFIER* = SC_GROUP_IDENTIFIERW
else:
  const
    SERVICES_ACTIVE_DATABASE* = SERVICES_ACTIVE_DATABASEA
    SERVICES_FAILED_DATABASE* = SERVICES_FAILED_DATABASEA
    SC_GROUP_IDENTIFIER* = SC_GROUP_IDENTIFIERA
type
  PFNCALLBACK* = proc (para1, para2: UINT, para3: HCONV, para4, para5: HSZ,
                       para6: HDDEDATA, para7, para8: DWORD): HDDEData{.stdcall.}
  CALLB* = PFNCALLBACK
  SECURITY_CONTEXT_TRACKING_MODE* = WINBOOL
  # End of stuff from ddeml.h in old Cygnus headers

  WNDENUMPROC* = FARPROC
  ENHMFENUMPROC* = FARPROC
  CCSTYLE* = DWORD
  PCCSTYLE* = ptr CCSTYLE
  LPCCSTYLE* = ptr CCSTYLE
  CCSTYLEFLAGA* = DWORD
  PCCSTYLEFLAGA* = ptr CCSTYLEFLAGA
  LPCCSTYLEFLAGA* = ptr CCSTYLEFLAGA

const
  LZERROR_UNKNOWNALG* = -8
  LZERROR_BADVALUE* = -7
  LZERROR_GLOBLOCK* = -6
  LZERROR_GLOBALLOC* = -5
  LZERROR_WRITE* = -4
  LZERROR_READ* = -3
  LZERROR_BADOUTHANDLE* = -2
  LZERROR_BADINHANDLE* = -1
  NO_ERROR* = 0
  ERROR_SUCCESS* = 0
  ERROR_INVALID_FUNCTION* = 1
  ERROR_FILE_NOT_FOUND* = 2
  ERROR_PATH_NOT_FOUND* = 3
  ERROR_TOO_MANY_OPEN_FILES* = 4
  ERROR_ACCESS_DENIED* = 5
  ERROR_INVALID_HANDLE* = 6
  ERROR_ARENA_TRASHED* = 7
  ERROR_NOT_ENOUGH_MEMORY* = 8
  ERROR_INVALID_BLOCK* = 9
  ERROR_BAD_ENVIRONMENT* = 10
  ERROR_BAD_FORMAT* = 11
  ERROR_INVALID_ACCESS* = 12
  ERROR_INVALID_DATA* = 13
  ERROR_OUTOFMEMORY* = 14
  ERROR_INVALID_DRIVE* = 15
  ERROR_CURRENT_DIRECTORY* = 16
  ERROR_NOT_SAME_DEVICE* = 17
  ERROR_NO_MORE_FILES* = 18
  ERROR_WRITE_PROTECT* = 19
  ERROR_BAD_UNIT* = 20
  ERROR_NOT_READY* = 21
  ERROR_BAD_COMMAND* = 22
  ERROR_CRC* = 23
  ERROR_BAD_LENGTH* = 24
  ERROR_SEEK* = 25
  ERROR_NOT_DOS_DISK* = 26
  ERROR_SECTOR_NOT_FOUND* = 27
  ERROR_OUT_OF_PAPER* = 28
  ERROR_WRITE_FAULT* = 29
  ERROR_READ_FAULT* = 30
  ERROR_GEN_FAILURE* = 31
  ERROR_SHARING_VIOLATION* = 32
  ERROR_LOCK_VIOLATION* = 33
  ERROR_WRONG_DISK* = 34
  ERROR_SHARING_BUFFER_EXCEEDED* = 36
  ERROR_HANDLE_EOF* = 38
  ERROR_HANDLE_DISK_FULL* = 39
  ERROR_NOT_SUPPORTED* = 50
  ERROR_REM_NOT_LIST* = 51
  ERROR_DUP_NAME* = 52
  ERROR_BAD_NETPATH* = 53
  ERROR_NETWORK_BUSY* = 54
  ERROR_DEV_NOT_EXIST* = 55
  ERROR_TOO_MANY_CMDS* = 56
  ERROR_ADAP_HDW_ERR* = 57
  ERROR_BAD_NET_RESP* = 58
  ERROR_UNEXP_NET_ERR* = 59
  ERROR_BAD_REM_ADAP* = 60
  ERROR_PRINTQ_FULL* = 61
  ERROR_NO_SPOOL_SPACE* = 62
  ERROR_PRINT_CANCELLED* = 63
  ERROR_NETNAME_DELETED* = 64
  ERROR_NETWORK_ACCESS_DENIED* = 65
  ERROR_BAD_DEV_TYPE* = 66
  ERROR_BAD_NET_NAME* = 67
  ERROR_TOO_MANY_NAMES* = 68
  ERROR_TOO_MANY_SESS* = 69
  ERROR_SHARING_PAUSED* = 70
  ERROR_REQ_NOT_ACCEP* = 71
  ERROR_REDIR_PAUSED* = 72
  ERROR_FILE_EXISTS* = 80
  ERROR_CANNOT_MAKE* = 82
  ERROR_FAIL_I24* = 83
  ERROR_OUT_OF_STRUCTURES* = 84
  ERROR_ALREADY_ASSIGNED* = 85
  ERROR_INVALID_PASSWORD* = 86
  ERROR_INVALID_PARAMETER* = 87
  ERROR_NET_WRITE_FAULT* = 88
  ERROR_NO_PROC_SLOTS* = 89
  ERROR_TOO_MANY_SEMAPHORES* = 100
  ERROR_EXCL_SEM_ALREADY_OWNED* = 101
  ERROR_SEM_IS_SET* = 102
  ERROR_TOO_MANY_SEM_REQUESTS* = 103
  ERROR_INVALID_AT_INTERRUPT_TIME* = 104
  ERROR_SEM_OWNER_DIED* = 105
  ERROR_SEM_USER_LIMIT* = 106
  ERROR_DISK_CHANGE* = 107
  ERROR_DRIVE_LOCKED* = 108
  ERROR_BROKEN_PIPE* = 109
  ERROR_OPEN_FAILED* = 110
  ERROR_BUFFER_OVERFLOW* = 111
  ERROR_DISK_FULL* = 112
  ERROR_NO_MORE_SEARCH_HANDLES* = 113
  ERROR_INVALID_TARGET_HANDLE* = 114
  ERROR_INVALID_CATEGORY* = 117
  ERROR_INVALID_VERIFY_SWITCH* = 118
  ERROR_BAD_DRIVER_LEVEL* = 119
  ERROR_CALL_NOT_IMPLEMENTED* = 120
  ERROR_SEM_TIMEOUT* = 121
  ERROR_INSUFFICIENT_BUFFER* = 122
  ERROR_INVALID_NAME* = 123
  ERROR_INVALID_LEVEL* = 124
  ERROR_NO_VOLUME_LABEL* = 125
  ERROR_MOD_NOT_FOUND* = 126
  ERROR_PROC_NOT_FOUND* = 127
  ERROR_WAIT_NO_CHILDREN* = 128
  ERROR_CHILD_NOT_COMPLETE* = 129
  ERROR_DIRECT_ACCESS_HANDLE* = 130
  ERROR_NEGATIVE_SEEK* = 131
  ERROR_SEEK_ON_DEVICE* = 132
  ERROR_IS_JOIN_TARGET* = 133
  ERROR_IS_JOINED* = 134
  ERROR_IS_SUBSTED* = 135
  ERROR_NOT_JOINED* = 136
  ERROR_NOT_SUBSTED* = 137
  ERROR_JOIN_TO_JOIN* = 138
  ERROR_SUBST_TO_SUBST* = 139
  ERROR_JOIN_TO_SUBST* = 140
  ERROR_SUBST_TO_JOIN* = 141
  ERROR_BUSY_DRIVE* = 142
  ERROR_SAME_DRIVE* = 143
  ERROR_DIR_NOT_ROOT* = 144
  ERROR_DIR_NOT_EMPTY* = 145
  ERROR_IS_SUBST_PATH* = 146
  ERROR_IS_JOIN_PATH* = 147
  ERROR_PATH_BUSY* = 148
  ERROR_IS_SUBST_TARGET* = 149
  ERROR_SYSTEM_TRACE* = 150
  ERROR_INVALID_EVENT_COUNT* = 151
  ERROR_TOO_MANY_MUXWAITERS* = 152
  ERROR_INVALID_LIST_FORMAT* = 153
  ERROR_LABEL_TOO_LONG* = 154
  ERROR_TOO_MANY_TCBS* = 155
  ERROR_SIGNAL_REFUSED* = 156
  ERROR_DISCARDED* = 157
  ERROR_NOT_LOCKED* = 158
  ERROR_BAD_THREADID_ADDR* = 159
  ERROR_BAD_ARGUMENTS* = 160
  ERROR_BAD_PATHNAME* = 161
  ERROR_SIGNAL_PENDING* = 162
  ERROR_MAX_THRDS_REACHED* = 164
  ERROR_LOCK_FAILED* = 167
  ERROR_BUSY* = 170
  ERROR_CANCEL_VIOLATION* = 173
  ERROR_ATOMIC_LOCKS_NOT_SUPPORTED* = 174
  ERROR_INVALID_SEGMENT_NUMBER* = 180
  ERROR_INVALID_ORDINAL* = 182
  ERROR_ALREADY_EXISTS* = 183
  ERROR_INVALID_FLAG_NUMBER* = 186
  ERROR_SEM_NOT_FOUND* = 187
  ERROR_INVALID_STARTING_CODESEG* = 188
  ERROR_INVALID_STACKSEG* = 189
  ERROR_INVALID_MODULETYPE* = 190
  ERROR_INVALID_EXE_SIGNATURE* = 191
  ERROR_EXE_MARKED_INVALID* = 192
  ERROR_BAD_EXE_FORMAT* = 193
  ERROR_ITERATED_DATA_EXCEEDS_64k* = 194
  ERROR_INVALID_MINALLOCSIZE* = 195
  ERROR_DYNLINK_FROM_INVALID_RING* = 196
  ERROR_IOPL_NOT_ENABLED* = 197
  ERROR_INVALID_SEGDPL* = 198
  ERROR_AUTODATASEG_EXCEEDS_64k* = 199
  ERROR_RING2SEG_MUST_BE_MOVABLE* = 200
  ERROR_RELOC_CHAIN_XEEDS_SEGLIM* = 201
  ERROR_INFLOOP_IN_RELOC_CHAIN* = 202
  ERROR_ENVVAR_NOT_FOUND* = 203
  ERROR_NO_SIGNAL_SENT* = 205
  ERROR_FILENAME_EXCED_RANGE* = 206
  ERROR_RING2_STACK_IN_USE* = 207
  ERROR_META_EXPANSION_TOO_LONG* = 208
  ERROR_INVALID_SIGNAL_NUMBER* = 209
  ERROR_THREAD_1_INACTIVE* = 210
  ERROR_LOCKED* = 212
  ERROR_TOO_MANY_MODULES* = 214
  ERROR_NESTING_NOT_ALLOWED* = 215
  ERROR_BAD_PIPE* = 230
  ERROR_PIPE_BUSY* = 231
  ERROR_NO_DATA* = 232
  ERROR_PIPE_NOT_CONNECTED* = 233
  ERROR_MORE_DATA* = 234
  ERROR_VC_DISCONNECTED* = 240
  ERROR_INVALID_EA_NAME* = 254
  ERROR_EA_LIST_INCONSISTENT* = 255
  ERROR_NO_MORE_ITEMS* = 259
  ERROR_CANNOT_COPY* = 266
  ERROR_DIRECTORY* = 267
  ERROR_EAS_DIDNT_FIT* = 275
  ERROR_EA_FILE_CORRUPT* = 276
  ERROR_EA_TABLE_FULL* = 277
  ERROR_INVALID_EA_HANDLE* = 278
  ERROR_EAS_NOT_SUPPORTED* = 282
  ERROR_NOT_OWNER* = 288
  ERROR_TOO_MANY_POSTS* = 298
  ERROR_PARTIAL_COPY* = 299
  ERROR_MR_MID_NOT_FOUND* = 317
  ERROR_INVALID_ADDRESS* = 487
  ERROR_ARITHMETIC_OVERFLOW* = 534
  ERROR_PIPE_CONNECTED* = 535
  ERROR_PIPE_LISTENING* = 536
  ERROR_EA_ACCESS_DENIED* = 994
  ERROR_OPERATION_ABORTED* = 995
  ERROR_IO_INCOMPLETE* = 996
  ERROR_IO_PENDING* = 997
  ERROR_NOACCESS* = 998
  ERROR_SWAPERROR* = 999
  ERROR_STACK_OVERFLOW* = 1001
  ERROR_INVALID_MESSAGE* = 1002
  ERROR_CAN_NOT_COMPLETE* = 1003
  ERROR_INVALID_FLAGS* = 1004
  ERROR_UNRECOGNIZED_VOLUME* = 1005
  ERROR_FILE_INVALID* = 1006
  ERROR_FULLSCREEN_MODE* = 1007
  ERROR_NO_TOKEN* = 1008
  ERROR_BADDB* = 1009
  ERROR_BADKEY* = 1010
  ERROR_CANTOPEN* = 1011
  ERROR_CANTREAD* = 1012
  ERROR_CANTWRITE* = 1013
  ERROR_REGISTRY_RECOVERED* = 1014
  ERROR_REGISTRY_CORRUPT* = 1015
  ERROR_REGISTRY_IO_FAILED* = 1016
  ERROR_NOT_REGISTRY_FILE* = 1017
  ERROR_KEY_DELETED* = 1018
  ERROR_NO_LOG_SPACE* = 1019
  ERROR_KEY_HAS_CHILDREN* = 1020
  ERROR_CHILD_MUST_BE_VOLATILE* = 1021
  ERROR_NOTIFY_ENUM_DIR* = 1022
  ERROR_DEPENDENT_SERVICES_RUNNING* = 1051
  ERROR_INVALID_SERVICE_CONTROL* = 1052
  ERROR_SERVICE_REQUEST_TIMEOUT* = 1053
  ERROR_SERVICE_NO_THREAD* = 1054
  ERROR_SERVICE_DATABASE_LOCKED* = 1055
  ERROR_SERVICE_ALREADY_RUNNING* = 1056
  ERROR_INVALID_SERVICE_ACCOUNT* = 1057
  ERROR_SERVICE_DISABLED* = 1058
  ERROR_CIRCULAR_DEPENDENCY* = 1059
  ERROR_SERVICE_DOES_NOT_EXIST* = 1060
  ERROR_SERVICE_CANNOT_ACCEPT_CTRL* = 1061
  ERROR_SERVICE_NOT_ACTIVE* = 1062
  ERROR_FAILED_SERVICE_CONTROLLER_CONNECT* = 1063
  ERROR_EXCEPTION_IN_SERVICE* = 1064
  ERROR_DATABASE_DOES_NOT_EXIST* = 1065
  ERROR_SERVICE_SPECIFIC_ERROR* = 1066
  ERROR_PROCESS_ABORTED* = 1067
  ERROR_SERVICE_DEPENDENCY_FAIL* = 1068
  ERROR_SERVICE_LOGON_FAILED* = 1069
  ERROR_SERVICE_START_HANG* = 1070
  ERROR_INVALID_SERVICE_LOCK* = 1071
  ERROR_SERVICE_MARKED_FOR_DELETE* = 1072
  ERROR_SERVICE_EXISTS* = 1073
  ERROR_ALREADY_RUNNING_LKG* = 1074
  ERROR_SERVICE_DEPENDENCY_DELETED* = 1075
  ERROR_BOOT_ALREADY_ACCEPTED* = 1076
  ERROR_SERVICE_NEVER_STARTED* = 1077
  ERROR_DUPLICATE_SERVICE_NAME* = 1078
  ERROR_END_OF_MEDIA* = 1100
  ERROR_FILEMARK_DETECTED* = 1101
  ERROR_BEGINNING_OF_MEDIA* = 1102
  ERROR_SETMARK_DETECTED* = 1103
  ERROR_NO_DATA_DETECTED* = 1104
  ERROR_PARTITION_FAILURE* = 1105
  ERROR_INVALID_BLOCK_LENGTH* = 1106
  ERROR_DEVICE_NOT_PARTITIONED* = 1107
  ERROR_UNABLE_TO_LOCK_MEDIA* = 1108
  ERROR_UNABLE_TO_UNLOAD_MEDIA* = 1109
  ERROR_MEDIA_CHANGED* = 1110
  ERROR_BUS_RESET* = 1111
  ERROR_NO_MEDIA_IN_DRIVE* = 1112
  ERROR_NO_UNICODE_TRANSLATION* = 1113
  ERROR_DLL_INIT_FAILED* = 1114
  ERROR_SHUTDOWN_IN_PROGRESS* = 1115
  ERROR_NO_SHUTDOWN_IN_PROGRESS* = 1116
  ERROR_IO_DEVICE* = 1117
  ERROR_SERIAL_NO_DEVICE* = 1118
  ERROR_IRQ_BUSY* = 1119
  ERROR_MORE_WRITES* = 1120
  ERROR_COUNTER_TIMEOUT* = 1121
  ERROR_FLOPPY_ID_MARK_NOT_FOUND* = 1122
  ERROR_FLOPPY_WRONG_CYLINDER* = 1123
  ERROR_FLOPPY_UNKNOWN_ERROR* = 1124
  ERROR_FLOPPY_BAD_REGISTERS* = 1125
  ERROR_DISK_RECALIBRATE_FAILED* = 1126
  ERROR_DISK_OPERATION_FAILED* = 1127
  ERROR_DISK_RESET_FAILED* = 1128
  ERROR_EOM_OVERFLOW* = 1129
  ERROR_NOT_ENOUGH_SERVER_MEMORY* = 1130
  ERROR_POSSIBLE_DEADLOCK* = 1131
  ERROR_MAPPED_ALIGNMENT* = 1132
  ERROR_SET_POWER_STATE_VETOED* = 1140
  ERROR_SET_POWER_STATE_FAILED* = 1141
  ERROR_OLD_WIN_VERSION* = 1150
  ERROR_APP_WRONG_OS* = 1151
  ERROR_SINGLE_INSTANCE_APP* = 1152
  ERROR_RMODE_APP* = 1153
  ERROR_INVALID_DLL* = 1154
  ERROR_NO_ASSOCIATION* = 1155
  ERROR_DDE_FAIL* = 1156
  ERROR_DLL_NOT_FOUND* = 1157
  ERROR_BAD_USERNAME* = 2202
  ERROR_NOT_CONNECTED* = 2250
  ERROR_OPEN_FILES* = 2401
  ERROR_ACTIVE_CONNECTIONS* = 2402
  ERROR_DEVICE_IN_USE* = 2404
  ERROR_BAD_DEVICE* = 1200
  ERROR_CONNECTION_UNAVAIL* = 1201
  ERROR_DEVICE_ALREADY_REMEMBERED* = 1202
  ERROR_NO_NET_OR_BAD_PATH* = 1203
  ERROR_BAD_PROVIDER* = 1204
  ERROR_CANNOT_OPEN_PROFILE* = 1205
  ERROR_BAD_PROFILE* = 1206
  ERROR_NOT_CONTAINER* = 1207
  ERROR_EXTENDED_ERROR* = 1208
  ERROR_INVALID_GROUPNAME* = 1209
  ERROR_INVALID_COMPUTERNAME* = 1210
  ERROR_INVALID_EVENTNAME* = 1211
  ERROR_INVALID_DOMAINNAME* = 1212
  ERROR_INVALID_SERVICENAME* = 1213
  ERROR_INVALID_NETNAME* = 1214
  ERROR_INVALID_SHARENAME* = 1215
  ERROR_INVALID_PASSWORDNAME* = 1216
  ERROR_INVALID_MESSAGENAME* = 1217
  ERROR_INVALID_MESSAGEDEST* = 1218
  ERROR_SESSION_CREDENTIAL_CONFLICT* = 1219
  ERROR_REMOTE_SESSION_LIMIT_EXCEEDED* = 1220
  ERROR_DUP_DOMAINNAME* = 1221
  ERROR_NO_NETWORK* = 1222
  ERROR_CANCELLED* = 1223
  ERROR_USER_MAPPED_FILE* = 1224
  ERROR_CONNECTION_REFUSED* = 1225
  ERROR_GRACEFUL_DISCONNECT* = 1226
  ERROR_ADDRESS_ALREADY_ASSOCIATED* = 1227
  ERROR_ADDRESS_NOT_ASSOCIATED* = 1228
  ERROR_CONNECTION_INVALID* = 1229
  ERROR_CONNECTION_ACTIVE* = 1230
  ERROR_NETWORK_UNREACHABLE* = 1231
  ERROR_HOST_UNREACHABLE* = 1232
  ERROR_PROTOCOL_UNREACHABLE* = 1233
  ERROR_PORT_UNREACHABLE* = 1234
  ERROR_REQUEST_ABORTED* = 1235
  ERROR_CONNECTION_ABORTED* = 1236
  ERROR_RETRY* = 1237
  ERROR_CONNECTION_COUNT_LIMIT* = 1238
  ERROR_LOGIN_TIME_RESTRICTION* = 1239
  ERROR_LOGIN_WKSTA_RESTRICTION* = 1240
  ERROR_INCORRECT_ADDRESS* = 1241
  ERROR_ALREADY_REGISTERED* = 1242
  ERROR_SERVICE_NOT_FOUND* = 1243
  ERROR_NOT_AUTHENTICATED* = 1244
  ERROR_NOT_LOGGED_ON* = 1245
  ERROR_CONTINUE* = 1246
  ERROR_ALREADY_INITIALIZED* = 1247
  ERROR_NO_MORE_DEVICES* = 1248
  ERROR_NOT_ALL_ASSIGNED* = 1300
  ERROR_SOME_NOT_MAPPED* = 1301
  ERROR_NO_QUOTAS_FOR_ACCOUNT* = 1302
  ERROR_LOCAL_USER_SESSION_KEY* = 1303
  ERROR_NULL_LM_PASSWORD* = 1304
  ERROR_UNKNOWN_REVISION* = 1305
  ERROR_REVISION_MISMATCH* = 1306
  ERROR_INVALID_OWNER* = 1307
  ERROR_INVALID_PRIMARY_GROUP* = 1308
  ERROR_NO_IMPERSONATION_TOKEN* = 1309
  ERROR_CANT_DISABLE_MANDATORY* = 1310
  ERROR_NO_LOGON_SERVERS* = 1311
  ERROR_NO_SUCH_LOGON_SESSION* = 1312
  ERROR_NO_SUCH_PRIVILEGE* = 1313
  ERROR_PRIVILEGE_NOT_HELD* = 1314
  ERROR_INVALID_ACCOUNT_NAME* = 1315
  ERROR_USER_EXISTS* = 1316
  ERROR_NO_SUCH_USER* = 1317
  ERROR_GROUP_EXISTS* = 1318
  ERROR_NO_SUCH_GROUP* = 1319
  ERROR_MEMBER_IN_GROUP* = 1320
  ERROR_MEMBER_NOT_IN_GROUP* = 1321
  ERROR_LAST_ADMIN* = 1322
  ERROR_WRONG_PASSWORD* = 1323
  ERROR_ILL_FORMED_PASSWORD* = 1324
  ERROR_PASSWORD_RESTRICTION* = 1325
  ERROR_LOGON_FAILURE* = 1326
  ERROR_ACCOUNT_RESTRICTION* = 1327
  ERROR_INVALID_LOGON_HOURS* = 1328
  ERROR_INVALID_WORKSTATION* = 1329
  ERROR_PASSWORD_EXPIRED* = 1330
  ERROR_ACCOUNT_DISABLED* = 1331
  ERROR_NONE_MAPPED* = 1332
  ERROR_TOO_MANY_LUIDS_REQUESTED* = 1333
  ERROR_LUIDS_EXHAUSTED* = 1334
  ERROR_INVALID_SUB_AUTHORITY* = 1335
  ERROR_INVALID_ACL* = 1336
  ERROR_INVALID_SID* = 1337
  ERROR_INVALID_SECURITY_DESCR* = 1338
  ERROR_BAD_INHERITANCE_ACL* = 1340
  ERROR_SERVER_DISABLED* = 1341
  ERROR_SERVER_NOT_DISABLED* = 1342
  ERROR_INVALID_ID_AUTHORITY* = 1343
  ERROR_ALLOTTED_SPACE_EXCEEDED* = 1344
  ERROR_INVALID_GROUP_ATTRIBUTES* = 1345
  ERROR_BAD_IMPERSONATION_LEVEL* = 1346
  ERROR_CANT_OPEN_ANONYMOUS* = 1347
  ERROR_BAD_VALIDATION_CLASS* = 1348
  ERROR_BAD_TOKEN_TYPE* = 1349
  ERROR_NO_SECURITY_ON_OBJECT* = 1350
  ERROR_CANT_ACCESS_DOMAIN_INFO* = 1351
  ERROR_INVALID_SERVER_STATE* = 1352
  ERROR_INVALID_DOMAIN_STATE* = 1353
  ERROR_INVALID_DOMAIN_ROLE* = 1354
  ERROR_NO_SUCH_DOMAIN* = 1355
  ERROR_DOMAIN_EXISTS* = 1356
  ERROR_DOMAIN_LIMIT_EXCEEDED* = 1357
  ERROR_INTERNAL_DB_CORRUPTION* = 1358
  ERROR_INTERNAL_ERROR* = 1359
  ERROR_GENERIC_NOT_MAPPED* = 1360
  ERROR_BAD_DESCRIPTOR_FORMAT* = 1361
  ERROR_NOT_LOGON_PROCESS* = 1362
  ERROR_LOGON_SESSION_EXISTS* = 1363
  ERROR_NO_SUCH_PACKAGE* = 1364
  ERROR_BAD_LOGON_SESSION_STATE* = 1365
  ERROR_LOGON_SESSION_COLLISION* = 1366
  ERROR_INVALID_LOGON_TYPE* = 1367
  ERROR_CANNOT_IMPERSONATE* = 1368
  ERROR_RXACT_INVALID_STATE* = 1369
  ERROR_RXACT_COMMIT_FAILURE* = 1370
  ERROR_SPECIAL_ACCOUNT* = 1371
  ERROR_SPECIAL_GROUP* = 1372
  ERROR_SPECIAL_USER* = 1373
  ERROR_MEMBERS_PRIMARY_GROUP* = 1374
  ERROR_TOKEN_ALREADY_IN_USE* = 1375
  ERROR_NO_SUCH_ALIAS* = 1376
  ERROR_MEMBER_NOT_IN_ALIAS* = 1377
  ERROR_MEMBER_IN_ALIAS* = 1378
  ERROR_ALIAS_EXISTS* = 1379
  ERROR_LOGON_NOT_GRANTED* = 1380
  ERROR_TOO_MANY_SECRETS* = 1381
  ERROR_SECRET_TOO_LONG* = 1382
  ERROR_INTERNAL_DB_ERROR* = 1383
  ERROR_TOO_MANY_CONTEXT_IDS* = 1384
  ERROR_LOGON_TYPE_NOT_GRANTED* = 1385
  ERROR_NT_CROSS_ENCRYPTION_REQUIRED* = 1386
  ERROR_NO_SUCH_MEMBER* = 1387
  ERROR_INVALID_MEMBER* = 1388
  ERROR_TOO_MANY_SIDS* = 1389
  ERROR_LM_CROSS_ENCRYPTION_REQUIRED* = 1390
  ERROR_NO_INHERITANCE* = 1391
  ERROR_FILE_CORRUPT* = 1392
  ERROR_DISK_CORRUPT* = 1393
  ERROR_NO_USER_SESSION_KEY* = 1394
  ERROR_LICENSE_QUOTA_EXCEEDED* = 1395
  ERROR_INVALID_WINDOW_HANDLE* = 1400
  ERROR_INVALID_MENU_HANDLE* = 1401
  ERROR_INVALID_CURSOR_HANDLE* = 1402
  ERROR_INVALID_ACCEL_HANDLE* = 1403
  ERROR_INVALID_HOOK_HANDLE* = 1404
  ERROR_INVALID_DWP_HANDLE* = 1405
  ERROR_TLW_WITH_WSCHILD* = 1406
  ERROR_CANNOT_FIND_WND_CLASS* = 1407
  ERROR_WINDOW_OF_OTHER_THREAD* = 1408
  ERROR_HOTKEY_ALREADY_REGISTERED* = 1409
  ERROR_CLASS_ALREADY_EXISTS* = 1410
  ERROR_CLASS_DOES_NOT_EXIST* = 1411
  ERROR_CLASS_HAS_WINDOWS* = 1412
  ERROR_INVALID_INDEX* = 1413
  ERROR_INVALID_ICON_HANDLE* = 1414
  ERROR_PRIVATE_DIALOG_INDEX* = 1415
  ERROR_LISTBOX_ID_NOT_FOUND* = 1416
  ERROR_NO_WILDCARD_CHARACTERS* = 1417
  ERROR_CLIPBOARD_NOT_OPEN* = 1418
  ERROR_HOTKEY_NOT_REGISTERED* = 1419
  ERROR_WINDOW_NOT_DIALOG* = 1420
  ERROR_CONTROL_ID_NOT_FOUND* = 1421
  ERROR_INVALID_COMBOBOX_MESSAGE* = 1422
  ERROR_WINDOW_NOT_COMBOBOX* = 1423
  ERROR_INVALID_EDIT_HEIGHT* = 1424
  ERROR_DC_NOT_FOUND* = 1425
  ERROR_INVALID_HOOK_FILTER* = 1426
  ERROR_INVALID_FILTER_PROC* = 1427
  ERROR_HOOK_NEEDS_HMOD* = 1428
  ERROR_GLOBAL_ONLY_HOOK* = 1429
  ERROR_JOURNAL_HOOK_SET* = 1430
  ERROR_HOOK_NOT_INSTALLED* = 1431
  ERROR_INVALID_LB_MESSAGE* = 1432
  ERROR_SETCOUNT_ON_BAD_LB* = 1433
  ERROR_LB_WITHOUT_TABSTOPS* = 1434
  ERROR_DESTROY_OBJECT_OF_OTHER_THREAD* = 1435
  ERROR_CHILD_WINDOW_MENU* = 1436
  ERROR_NO_SYSTEM_MENU* = 1437
  ERROR_INVALID_MSGBOX_STYLE* = 1438
  ERROR_INVALID_SPI_VALUE* = 1439
  ERROR_SCREEN_ALREADY_LOCKED* = 1440
  ERROR_HWNDS_HAVE_DIFF_PARENT* = 1441
  ERROR_NOT_CHILD_WINDOW* = 1442
  ERROR_INVALID_GW_COMMAND* = 1443
  ERROR_INVALID_THREAD_ID* = 1444
  ERROR_NON_MDICHILD_WINDOW* = 1445
  ERROR_POPUP_ALREADY_ACTIVE* = 1446
  ERROR_NO_SCROLLBARS* = 1447
  ERROR_INVALID_SCROLLBAR_RANGE* = 1448
  ERROR_INVALID_SHOWWIN_COMMAND* = 1449
  ERROR_NO_SYSTEM_RESOURCES* = 1450
  ERROR_NONPAGED_SYSTEM_RESOURCES* = 1451
  ERROR_PAGED_SYSTEM_RESOURCES* = 1452
  ERROR_WORKING_SET_QUOTA* = 1453
  ERROR_PAGEFILE_QUOTA* = 1454
  ERROR_COMMITMENT_LIMIT* = 1455
  ERROR_MENU_ITEM_NOT_FOUND* = 1456
  ERROR_INVALID_KEYBOARD_HANDLE* = 1457
  ERROR_HOOK_TYPE_NOT_ALLOWED* = 1458
  ERROR_REQUIRES_INTERACTIVE_WINDOWSTATION* = 1459
  ERROR_TIMEOUT* = 1460
  ERROR_EVENTLOG_FILE_CORRUPT* = 1500
  ERROR_EVENTLOG_CANT_START* = 1501
  ERROR_LOG_FILE_FULL* = 1502
  ERROR_EVENTLOG_FILE_CHANGED* = 1503
  RPC_S_INVALID_STRING_BINDING* = 1700
  RPC_S_WRONG_KIND_OF_BINDING* = 1701
  RPC_S_INVALID_BINDING* = 1702
  RPC_S_PROTSEQ_NOT_SUPPORTED* = 1703
  RPC_S_INVALID_RPC_PROTSEQ* = 1704
  RPC_S_INVALID_STRING_UUID* = 1705
  RPC_S_INVALID_ENDPOINT_FORMAT* = 1706
  RPC_S_INVALID_NET_ADDR* = 1707
  RPC_S_NO_ENDPOINT_FOUND* = 1708
  RPC_S_INVALID_TIMEOUT* = 1709
  RPC_S_OBJECT_NOT_FOUND* = 1710
  RPC_S_ALREADY_REGISTERED* = 1711
  RPC_S_TYPE_ALREADY_REGISTERED* = 1712
  RPC_S_ALREADY_LISTENING* = 1713
  RPC_S_NO_PROTSEQS_REGISTERED* = 1714
  RPC_S_NOT_LISTENING* = 1715
  RPC_S_UNKNOWN_MGR_TYPE* = 1716
  RPC_S_UNKNOWN_IF* = 1717
  RPC_S_NO_BINDINGS* = 1718
  RPC_S_NO_PROTSEQS* = 1719
  RPC_S_CANT_CREATE_ENDPOINT* = 1720
  RPC_S_OUT_OF_RESOURCES* = 1721
  RPC_S_SERVER_UNAVAILABLE* = 1722
  RPC_S_SERVER_TOO_BUSY* = 1723
  RPC_S_INVALID_NETWORK_OPTIONS* = 1724
  RPC_S_NO_CALL_ACTIVE* = 1725
  RPC_S_CALL_FAILED* = 1726
  RPC_S_CALL_FAILED_DNE* = 1727
  RPC_S_PROTOCOL_ERROR* = 1728
  RPC_S_UNSUPPORTED_TRANS_SYN* = 1730
  RPC_S_UNSUPPORTED_TYPE* = 1732
  RPC_S_INVALID_TAG* = 1733
  RPC_S_INVALID_BOUND* = 1734
  RPC_S_NO_ENTRY_NAME* = 1735
  RPC_S_INVALID_NAME_SYNTAX* = 1736
  RPC_S_UNSUPPORTED_NAME_SYNTAX* = 1737
  RPC_S_UUID_NO_ADDRESS* = 1739
  RPC_S_DUPLICATE_ENDPOINT* = 1740
  RPC_S_UNKNOWN_AUTHN_TYPE* = 1741
  RPC_S_MAX_CALLS_TOO_SMALL* = 1742
  RPC_S_STRING_TOO_LONG* = 1743
  RPC_S_PROTSEQ_NOT_FOUND* = 1744
  RPC_S_PROCNUM_OUT_OF_RANGE* = 1745
  RPC_S_BINDING_HAS_NO_AUTH* = 1746
  RPC_S_UNKNOWN_AUTHN_SERVICE* = 1747
  RPC_S_UNKNOWN_AUTHN_LEVEL* = 1748
  RPC_S_INVALID_AUTH_IDENTITY* = 1749
  RPC_S_UNKNOWN_AUTHZ_SERVICE* = 1750
  EPT_S_INVALID_ENTRY* = 1751
  EPT_S_CANT_PERFORM_OP* = 1752
  EPT_S_NOT_REGISTERED* = 1753
  RPC_S_NOTHING_TO_EXPORT* = 1754
  RPC_S_INCOMPLETE_NAME* = 1755
  RPC_S_INVALID_VERS_OPTION* = 1756
  RPC_S_NO_MORE_MEMBERS* = 1757
  RPC_S_NOT_ALL_OBJS_UNEXPORTED* = 1758
  RPC_S_INTERFACE_NOT_FOUND* = 1759
  RPC_S_ENTRY_ALREADY_EXISTS* = 1760
  RPC_S_ENTRY_NOT_FOUND* = 1761
  RPC_S_NAME_SERVICE_UNAVAILABLE* = 1762
  RPC_S_INVALID_NAF_ID* = 1763
  RPC_S_CANNOT_SUPPORT* = 1764
  RPC_S_NO_CONTEXT_AVAILABLE* = 1765
  RPC_S_INTERNAL_ERROR* = 1766
  RPC_S_ZERO_DIVIDE* = 1767
  RPC_S_ADDRESS_ERROR* = 1768
  RPC_S_FP_DIV_ZERO* = 1769
  RPC_S_FP_UNDERFLOW* = 1770
  RPC_S_FP_OVERFLOW* = 1771
  RPC_X_NO_MORE_ENTRIES* = 1772
  RPC_X_SS_CHAR_TRANS_OPEN_FAIL* = 1773
  RPC_X_SS_CHAR_TRANS_SHORT_FILE* = 1774
  RPC_X_SS_IN_NULL_CONTEXT* = 1775
  RPC_X_SS_CONTEXT_DAMAGED* = 1777
  RPC_X_SS_HANDLES_MISMATCH* = 1778
  RPC_X_SS_CANNOT_GET_CALL_HANDLE* = 1779
  RPC_X_NULL_REF_POINTER* = 1780
  RPC_X_ENUM_VALUE_OUT_OF_RANGE* = 1781
  RPC_X_BYTE_COUNT_TOO_SMALL* = 1782
  RPC_X_BAD_STUB_DATA* = 1783
  ERROR_INVALID_USER_BUFFER* = 1784
  ERROR_UNRECOGNIZED_MEDIA* = 1785
  ERROR_NO_TRUST_LSA_SECRET* = 1786
  ERROR_NO_TRUST_SAM_ACCOUNT* = 1787
  ERROR_TRUSTED_DOMAIN_FAILURE* = 1788
  ERROR_TRUSTED_RELATIONSHIP_FAILURE* = 1789
  ERROR_TRUST_FAILURE* = 1790
  RPC_S_CALL_IN_PROGRESS* = 1791
  ERROR_NETLOGON_NOT_STARTED* = 1792
  ERROR_ACCOUNT_EXPIRED* = 1793
  ERROR_REDIRECTOR_HAS_OPEN_HANDLES* = 1794
  ERROR_PRINTER_DRIVER_ALREADY_INSTALLED* = 1795
  ERROR_UNKNOWN_PORT* = 1796
  ERROR_UNKNOWN_PRINTER_DRIVER* = 1797
  ERROR_UNKNOWN_PRINTPROCESSOR* = 1798
  ERROR_INVALID_SEPARATOR_FILE* = 1799
  ERROR_INVALID_PRIORITY* = 1800
  ERROR_INVALID_PRINTER_NAME* = 1801
  ERROR_PRINTER_ALREADY_EXISTS* = 1802
  ERROR_INVALID_PRINTER_COMMAND* = 1803
  ERROR_INVALID_DATATYPE* = 1804
  ERROR_INVALID_ENVIRONMENT* = 1805
  RPC_S_NO_MORE_BINDINGS* = 1806
  ERROR_NOLOGON_INTERDOMAIN_TRUST_ACCOUNT* = 1807
  ERROR_NOLOGON_WORKSTATION_TRUST_ACCOUNT* = 1808
  ERROR_NOLOGON_SERVER_TRUST_ACCOUNT* = 1809
  ERROR_DOMAIN_TRUST_INCONSISTENT* = 1810
  ERROR_SERVER_HAS_OPEN_HANDLES* = 1811
  ERROR_RESOURCE_DATA_NOT_FOUND* = 1812
  ERROR_RESOURCE_TYPE_NOT_FOUND* = 1813
  ERROR_RESOURCE_NAME_NOT_FOUND* = 1814
  ERROR_RESOURCE_LANG_NOT_FOUND* = 1815
  ERROR_NOT_ENOUGH_QUOTA* = 1816
  RPC_S_NO_INTERFACES* = 1817
  RPC_S_CALL_CANCELLED* = 1818
  RPC_S_BINDING_INCOMPLETE* = 1819
  RPC_S_COMM_FAILURE* = 1820
  RPC_S_UNSUPPORTED_AUTHN_LEVEL* = 1821
  RPC_S_NO_PRINC_NAME* = 1822
  RPC_S_NOT_RPC_ERROR* = 1823
  RPC_S_UUID_LOCAL_ONLY* = 1824
  RPC_S_SEC_PKG_ERROR* = 1825
  RPC_S_NOT_CANCELLED* = 1826
  RPC_X_INVALID_ES_ACTION* = 1827
  RPC_X_WRONG_ES_VERSION* = 1828
  RPC_X_WRONG_STUB_VERSION* = 1829
  RPC_X_INVALID_PIPE_OBJECT* = 1830
  RPC_X_INVALID_PIPE_OPERATION* = 1831
  RPC_S_GROUP_MEMBER_NOT_FOUND* = 1898
  EPT_S_CANT_CREATE* = 1899
  RPC_S_INVALID_OBJECT* = 1900
  ERROR_INVALID_TIME* = 1901
  ERROR_INVALID_FORM_NAME* = 1902
  ERROR_INVALID_FORM_SIZE* = 1903
  ERROR_ALREADY_WAITING* = 1904
  ERROR_PRINTER_DELETED* = 1905
  ERROR_INVALID_PRINTER_STATE* = 1906
  ERROR_PASSWORD_MUST_CHANGE* = 1907
  ERROR_DOMAIN_CONTROLLER_NOT_FOUND* = 1908
  ERROR_ACCOUNT_LOCKED_OUT* = 1909
  OR_INVALID_OXID* = 1910
  OR_INVALID_OID* = 1911
  OR_INVALID_SET* = 1912
  RPC_S_SEND_INCOMPLETE* = 1913
  ERROR_NO_BROWSER_SERVERS_FOUND* = 6118
  ERROR_INVALID_PIXEL_FORMAT* = 2000
  ERROR_BAD_DRIVER* = 2001
  ERROR_INVALID_WINDOW_STYLE* = 2002
  ERROR_METAFILE_NOT_SUPPORTED* = 2003
  ERROR_TRANSFORM_NOT_SUPPORTED* = 2004
  ERROR_CLIPPING_NOT_SUPPORTED* = 2005
  ERROR_UNKNOWN_PRINT_MONITOR* = 3000
  ERROR_PRINTER_DRIVER_IN_USE* = 3001
  ERROR_SPOOL_FILE_NOT_FOUND* = 3002
  ERROR_SPL_NO_STARTDOC* = 3003
  ERROR_SPL_NO_ADDJOB* = 3004
  ERROR_PRINT_PROCESSOR_ALREADY_INSTALLED* = 3005
  ERROR_PRINT_MONITOR_ALREADY_INSTALLED* = 3006
  ERROR_INVALID_PRINT_MONITOR* = 3007
  ERROR_PRINT_MONITOR_IN_USE* = 3008
  ERROR_PRINTER_HAS_JOBS_QUEUED* = 3009
  ERROR_SUCCESS_REBOOT_REQUIRED* = 3010
  ERROR_SUCCESS_RESTART_REQUIRED* = 3011
  ERROR_WINS_INTERNAL* = 4000
  ERROR_CAN_NOT_DEL_LOCAL_WINS* = 4001
  ERROR_STATIC_INIT* = 4002
  ERROR_INC_BACKUP* = 4003
  ERROR_FULL_BACKUP* = 4004
  ERROR_REC_NON_EXISTENT* = 4005
  ERROR_RPL_NOT_ALLOWED* = 4006
  E_UNEXPECTED* = HRESULT(0x8000FFFF)
  E_NOTIMPL* = HRESULT(0x80004001)
  E_OUTOFMEMORY* = HRESULT(0x8007000E)
  E_INVALIDARG* = HRESULT(0x80070057)
  E_NOINTERFACE* = HRESULT(0x80004002)
  E_POINTER* = HRESULT(0x80004003)
  E_HANDLE* = HRESULT(0x80070006)
  E_ABORT* = HRESULT(0x80004004)
  E_FAIL* = HRESULT(0x80004005)
  E_ACCESSDENIED* = HRESULT(0x80070005)
  E_PENDING* = HRESULT(0x8000000A)
  CO_E_INIT_TLS* = HRESULT(0x80004006)
  CO_E_INIT_SHARED_ALLOCATOR* = HRESULT(0x80004007)
  CO_E_INIT_MEMORY_ALLOCATOR* = HRESULT(0x80004008)
  CO_E_INIT_CLASS_CACHE* = HRESULT(0x80004009)
  CO_E_INIT_RPC_CHANNEL* = HRESULT(0x8000400A)
  CO_E_INIT_TLS_SET_CHANNEL_CONTROL* = HRESULT(0x8000400B)
  CO_E_INIT_TLS_CHANNEL_CONTROL* = HRESULT(0x8000400C)
  CO_E_INIT_UNACCEPTED_USER_ALLOCATOR* = HRESULT(0x8000400D)
  CO_E_INIT_SCM_MUTEX_EXISTS* = HRESULT(0x8000400E)
  CO_E_INIT_SCM_FILE_MAPPING_EXISTS* = HRESULT(0x8000400F)
  CO_E_INIT_SCM_MAP_VIEW_OF_FILE* = HRESULT(0x80004010)
  CO_E_INIT_SCM_EXEC_FAILURE* = HRESULT(0x80004011)
  CO_E_INIT_ONLY_SINGLE_THREADED* = HRESULT(0x80004012)
  CO_E_CANT_REMOTE* = HRESULT(0x80004013)
  CO_E_BAD_SERVER_NAME* = HRESULT(0x80004014)
  CO_E_WRONG_SERVER_IDENTITY* = HRESULT(0x80004015)
  CO_E_OLE1DDE_DISABLED* = HRESULT(0x80004016)
  CO_E_RUNAS_SYNTAX* = HRESULT(0x80004017)
  CO_E_CREATEPROCESS_FAILURE* = HRESULT(0x80004018)
  CO_E_RUNAS_CREATEPROCESS_FAILURE* = HRESULT(0x80004019)
  CO_E_RUNAS_LOGON_FAILURE* = HRESULT(0x8000401A)
  CO_E_LAUNCH_PERMSSION_DENIED* = HRESULT(0x8000401B)
  CO_E_START_SERVICE_FAILURE* = HRESULT(0x8000401C)
  CO_E_REMOTE_COMMUNICATION_FAILURE* = HRESULT(0x8000401D)
  CO_E_SERVER_START_TIMEOUT* = HRESULT(0x8000401E)
  CO_E_CLSREG_INCONSISTENT* = HRESULT(0x8000401F)
  CO_E_IIDREG_INCONSISTENT* = HRESULT(0x80004020)
  CO_E_NOT_SUPPORTED* = HRESULT(0x80004021)
  CO_E_FIRST* = DWORD(0x800401F0)
  CO_E_LAST* = DWORD(0x800401FF)
  CO_S_FIRST* = DWORD(0x000401F0)
  CO_S_LAST* = DWORD(0x000401FF)
  S_OK* = HRESULT(0x00000000)
  S_FALSE* = HRESULT(0x00000001)
  CO_E_NOTINITIALIZED* = HRESULT(0x800401F0)
  CO_E_ALREADYINITIALIZED* = HRESULT(0x800401F1)
  CO_E_CANTDETERMINECLASS* = HRESULT(0x800401F2)
  CO_E_CLASSSTRING* = HRESULT(0x800401F3)
  CO_E_IIDSTRING* = HRESULT(0x800401F4)
  CO_E_APPNOTFOUND* = HRESULT(0x800401F5)
  CO_E_APPSINGLEUSE* = HRESULT(0x800401F6)
  CO_E_ERRORINAPP* = HRESULT(0x800401F7)
  CO_E_DLLNOTFOUND* = HRESULT(0x800401F8)
  CO_E_ERRORINDLL* = HRESULT(0x800401F9)
  CO_E_WRONGOSFORAPP* = HRESULT(0x800401FA)
  CO_E_OBJNOTREG* = HRESULT(0x800401FB)
  CO_E_OBJISREG* = HRESULT(0x800401FC)
  CO_E_OBJNOTCONNECTED* = HRESULT(0x800401FD)
  CO_E_APPDIDNTREG* = HRESULT(0x800401FE)
  CO_E_RELEASED* = HRESULT(0x800401FF)
  OLE_E_FIRST* = HRESULT(0x80040000)
  OLE_E_LAST* = HRESULT(0x800400FF)
  OLE_S_FIRST* = HRESULT(0x00040000)
  OLE_S_LAST* = HRESULT(0x000400FF)
  OLE_E_OLEVERB* = HRESULT(0x80040000)
  OLE_E_ADVF* = HRESULT(0x80040001)
  OLE_E_ENUM_NOMORE* = HRESULT(0x80040002)
  OLE_E_ADVISENOTSUPPORTED* = HRESULT(0x80040003)
  OLE_E_NOCONNECTION* = HRESULT(0x80040004)
  OLE_E_NOTRUNNING* = HRESULT(0x80040005)
  OLE_E_NOCACHE* = HRESULT(0x80040006)
  OLE_E_BLANK* = HRESULT(0x80040007)
  OLE_E_CLASSDIFF* = HRESULT(0x80040008)
  OLE_E_CANT_GETMONIKER* = HRESULT(0x80040009)
  OLE_E_CANT_BINDTOSOURCE* = HRESULT(0x8004000A)
  OLE_E_STATIC* = HRESULT(0x8004000B)
  OLE_E_PROMPTSAVECANCELLED* = HRESULT(0x8004000C)
  OLE_E_INVALIDRECT* = HRESULT(0x8004000D)
  OLE_E_WRONGCOMPOBJ* = HRESULT(0x8004000E)
  OLE_E_INVALIDHWND* = HRESULT(0x8004000F)
  OLE_E_NOT_INPLACEACTIVE* = HRESULT(0x80040010)
  OLE_E_CANTCONVERT* = HRESULT(0x80040011)
  OLE_E_NOSTORAGE* = HRESULT(0x80040012)
  DV_E_FORMATETC* = HRESULT(0x80040064)
  DV_E_DVTARGETDEVICE* = HRESULT(0x80040065)
  DV_E_STGMEDIUM* = HRESULT(0x80040066)
  DV_E_STATDATA* = HRESULT(0x80040067)
  DV_E_LINDEX* = HRESULT(0x80040068)
  DV_E_TYMED* = HRESULT(0x80040069)
  DV_E_CLIPFORMAT* = HRESULT(0x8004006A)
  DV_E_DVASPECT* = HRESULT(0x8004006B)
  DV_E_DVTARGETDEVICE_SIZE* = HRESULT(0x8004006C)
  DV_E_NOIVIEWOBJECT* = HRESULT(0x8004006D)
  DRAGDROP_E_FIRST* = DWORD(0x80040100)
  DRAGDROP_E_LAST* = DWORD(0x8004010F)
  DRAGDROP_S_FIRST* = DWORD(0x00040100)
  DRAGDROP_S_LAST* = DWORD(0x0004010F)
  DRAGDROP_E_NOTREGISTERED* = HRESULT(0x80040100)
  DRAGDROP_E_ALREADYREGISTERED* = HRESULT(0x80040101)
  DRAGDROP_E_INVALIDHWND* = HRESULT(0x80040102)
  CLASSFACTORY_E_FIRST* = DWORD(0x80040110)
  CLASSFACTORY_E_LAST* = DWORD(0x8004011F)
  CLASSFACTORY_S_FIRST* = DWORD(0x00040110)
  CLASSFACTORY_S_LAST* = DWORD(0x0004011F)
  CLASS_E_NOAGGREGATION* = HRESULT(0x80040110)
  CLASS_E_CLASSNOTAVAILABLE* = HRESULT(0x80040111)
  MARSHAL_E_FIRST* = DWORD(0x80040120)
  MARSHAL_E_LAST* = DWORD(0x8004012F)
  MARSHAL_S_FIRST* = DWORD(0x00040120)
  MARSHAL_S_LAST* = DWORD(0x0004012F)
  DATA_E_FIRST* = DWORD(0x80040130)
  DATA_E_LAST* = DWORD(0x8004013F)
  DATA_S_FIRST* = DWORD(0x00040130)
  DATA_S_LAST* = DWORD(0x0004013F)
  VIEW_E_FIRST* = DWORD(0x80040140)
  VIEW_E_LAST* = DWORD(0x8004014F)
  VIEW_S_FIRST* = DWORD(0x00040140)
  VIEW_S_LAST* = DWORD(0x0004014F)
  VIEW_E_DRAW* = HRESULT(0x80040140)
  REGDB_E_FIRST* = DWORD(0x80040150)
  REGDB_E_LAST* = DWORD(0x8004015F)
  REGDB_S_FIRST* = DWORD(0x00040150)
  REGDB_S_LAST* = DWORD(0x0004015F)
  REGDB_E_READREGDB* = HRESULT(0x80040150)
  REGDB_E_WRITEREGDB* = HRESULT(0x80040151)
  REGDB_E_KEYMISSING* = HRESULT(0x80040152)
  REGDB_E_INVALIDVALUE* = HRESULT(0x80040153)
  REGDB_E_CLASSNOTREG* = HRESULT(0x80040154)
  REGDB_E_IIDNOTREG* = HRESULT(0x80040155)
  CACHE_E_FIRST* = DWORD(0x80040170)
  CACHE_E_LAST* = DWORD(0x8004017F)
  CACHE_S_FIRST* = DWORD(0x00040170)
  CACHE_S_LAST* = DWORD(0x0004017F)
  CACHE_E_NOCACHE_UPDATED* = HRESULT(0x80040170)
  OLEOBJ_E_FIRST* = DWORD(0x80040180)
  OLEOBJ_E_LAST* = DWORD(0x8004018F)
  OLEOBJ_S_FIRST* = DWORD(0x00040180)
  OLEOBJ_S_LAST* = DWORD(0x0004018F)
  OLEOBJ_E_NOVERBS* = HRESULT(0x80040180)
  OLEOBJ_E_INVALIDVERB* = HRESULT(0x80040181)
  CLIENTSITE_E_FIRST* = DWORD(0x80040190)
  CLIENTSITE_E_LAST* = DWORD(0x8004019F)
  CLIENTSITE_S_FIRST* = DWORD(0x00040190)
  CLIENTSITE_S_LAST* = DWORD(0x0004019F)
  INPLACE_E_NOTUNDOABLE* = HRESULT(0x800401A0)
  INPLACE_E_NOTOOLSPACE* = HRESULT(0x800401A1)
  INPLACE_E_FIRST* = DWORD(0x800401A0)
  INPLACE_E_LAST* = DWORD(0x800401AF)
  INPLACE_S_FIRST* = DWORD(0x000401A0)
  INPLACE_S_LAST* = DWORD(0x000401AF)
  ENUM_E_FIRST* = DWORD(0x800401B0)
  ENUM_E_LAST* = DWORD(0x800401BF)
  ENUM_S_FIRST* = DWORD(0x000401B0)
  ENUM_S_LAST* = DWORD(0x000401BF)
  CONVERT10_E_FIRST* = DWORD(0x800401C0)
  CONVERT10_E_LAST* = DWORD(0x800401CF)
  CONVERT10_S_FIRST* = DWORD(0x000401C0)
  CONVERT10_S_LAST* = DWORD(0x000401CF)
  CONVERT10_E_OLESTREAM_GET* = HRESULT(0x800401C0)
  CONVERT10_E_OLESTREAM_PUT* = HRESULT(0x800401C1)
  CONVERT10_E_OLESTREAM_FMT* = HRESULT(0x800401C2)
  CONVERT10_E_OLESTREAM_BITMAP_TO_DIB* = HRESULT(0x800401C3)
  CONVERT10_E_STG_FMT* = HRESULT(0x800401C4)
  CONVERT10_E_STG_NO_STD_STREAM* = HRESULT(0x800401C5)
  CONVERT10_E_STG_DIB_TO_BITMAP* = HRESULT(0x800401C6)
  CLIPBRD_E_FIRST* = DWORD(0x800401D0)
  CLIPBRD_E_LAST* = DWORD(0x800401DF)
  CLIPBRD_S_FIRST* = DWORD(0x000401D0)
  CLIPBRD_S_LAST* = DWORD(0x000401DF)
  CLIPBRD_E_CANT_OPEN* = HRESULT(0x800401D0)
  CLIPBRD_E_CANT_EMPTY* = HRESULT(0x800401D1)
  CLIPBRD_E_CANT_SET* = HRESULT(0x800401D2)
  CLIPBRD_E_BAD_DATA* = HRESULT(0x800401D3)
  CLIPBRD_E_CANT_CLOSE* = HRESULT(0x800401D4)
  MK_E_FIRST* = DWORD(0x800401E0)
  MK_E_LAST* = DWORD(0x800401EF)
  MK_S_FIRST* = DWORD(0x000401E0)
  MK_S_LAST* = DWORD(0x000401EF)
  MK_E_CONNECTMANUALLY* = HRESULT(0x800401E0)
  MK_E_EXCEEDEDDEADLINE* = HRESULT(0x800401E1)
  MK_E_NEEDGENERIC* = HRESULT(0x800401E2)
  MK_E_UNAVAILABLE* = HRESULT(0x800401E3)
  MK_E_SYNTAX* = HRESULT(0x800401E4)
  MK_E_NOOBJECT* = HRESULT(0x800401E5)
  MK_E_INVALIDEXTENSION* = HRESULT(0x800401E6)
  MK_E_INTERMEDIATEINTERFACENOTSUPPORTED* = HRESULT(0x800401E7)
  MK_E_NOTBINDABLE* = HRESULT(0x800401E8)
  MK_E_NOTBOUND* = HRESULT(0x800401E9)
  MK_E_CANTOPENFILE* = HRESULT(0x800401EA)
  MK_E_MUSTBOTHERUSER* = HRESULT(0x800401EB)
  MK_E_NOINVERSE* = HRESULT(0x800401EC)
  MK_E_NOSTORAGE* = HRESULT(0x800401ED)
  MK_E_NOPREFIX* = HRESULT(0x800401EE)
  MK_E_ENUMERATION_FAILED* = HRESULT(0x800401EF)
  OLE_S_USEREG* = HRESULT(0x00040000)
  OLE_S_STATIC* = HRESULT(0x00040001)
  OLE_S_MAC_CLIPFORMAT* = HRESULT(0x00040002)
  DRAGDROP_S_DROP* = HRESULT(0x00040100)
  DRAGDROP_S_CANCEL* = HRESULT(0x00040101)
  DRAGDROP_S_USEDEFAULTCURSORS* = HRESULT(0x00040102)
  DATA_S_SAMEFORMATETC* = HRESULT(0x00040130)
  VIEW_S_ALREADY_FROZEN* = HRESULT(0x00040140)
  CACHE_S_FORMATETC_NOTSUPPORTED* = HRESULT(0x00040170)
  CACHE_S_SAMECACHE* = HRESULT(0x00040171)
  CACHE_S_SOMECACHES_NOTUPDATED* = HRESULT(0x00040172)
  OLEOBJ_S_INVALIDVERB* = HRESULT(0x00040180)
  OLEOBJ_S_CANNOT_DOVERB_NOW* = HRESULT(0x00040181)
  OLEOBJ_S_INVALIDHWND* = HRESULT(0x00040182)
  INPLACE_S_TRUNCATED* = HRESULT(0x000401A0)
  CONVERT10_S_NO_PRESENTATION* = HRESULT(0x000401C0)
  MK_S_REDUCED_TO_SELF* = HRESULT(0x000401E2)
  MK_S_ME* = HRESULT(0x000401E4)
  MK_S_HIM* = HRESULT(0x000401E5)
  MK_S_US* = HRESULT(0x000401E6)
  MK_S_MONIKERALREADYREGISTERED* = HRESULT(0x000401E7)
  CO_E_CLASS_CREATE_FAILED* = HRESULT(0x80080001)
  CO_E_SCM_ERROR* = HRESULT(0x80080002)
  CO_E_SCM_RPC_FAILURE* = HRESULT(0x80080003)
  CO_E_BAD_PATH* = HRESULT(0x80080004)
  CO_E_SERVER_EXEC_FAILURE* = HRESULT(0x80080005)
  CO_E_OBJSRV_RPC_FAILURE* = HRESULT(0x80080006)
  MK_E_NO_NORMALIZED* = HRESULT(0x80080007)
  CO_E_SERVER_STOPPING* = HRESULT(0x80080008)
  MEM_E_INVALID_ROOT* = HRESULT(0x80080009)
  MEM_E_INVALID_LINK* = HRESULT(0x80080010)
  MEM_E_INVALID_SIZE* = HRESULT(0x80080011)
  CO_S_NOTALLINTERFACES* = HRESULT(0x00080012)
  DISP_E_UNKNOWNINTERFACE* = HRESULT(0x80020001)
  DISP_E_MEMBERNOTFOUND* = HRESULT(0x80020003)
  DISP_E_PARAMNOTFOUND* = HRESULT(0x80020004)
  DISP_E_TYPEMISMATCH* = HRESULT(0x80020005)
  DISP_E_UNKNOWNNAME* = HRESULT(0x80020006)
  DISP_E_NONAMEDARGS* = HRESULT(0x80020007)
  DISP_E_BADVARTYPE* = HRESULT(0x80020008)
  DISP_E_EXCEPTION* = HRESULT(0x80020009)
  DISP_E_OVERFLOW* = HRESULT(0x8002000A)
  DISP_E_BADINDEX* = HRESULT(0x8002000B)
  DISP_E_UNKNOWNLCID* = HRESULT(0x8002000C)
  DISP_E_ARRAYISLOCKED* = HRESULT(0x8002000D)
  DISP_E_BADPARAMCOUNT* = HRESULT(0x8002000E)
  DISP_E_PARAMNOTOPTIONAL* = HRESULT(0x8002000F)
  DISP_E_BADCALLEE* = HRESULT(0x80020010)
  DISP_E_NOTACOLLECTION* = HRESULT(0x80020011)
  TYPE_E_BUFFERTOOSMALL* = HRESULT(0x80028016)
  TYPE_E_INVDATAREAD* = HRESULT(0x80028018)
  TYPE_E_UNSUPFORMAT* = HRESULT(0x80028019)
  TYPE_E_REGISTRYACCESS* = HRESULT(0x8002801C)
  TYPE_E_LIBNOTREGISTERED* = HRESULT(0x8002801D)
  TYPE_E_UNDEFINEDTYPE* = HRESULT(0x80028027)
  TYPE_E_QUALIFIEDNAMEDISALLOWED* = HRESULT(0x80028028)
  TYPE_E_INVALIDSTATE* = HRESULT(0x80028029)
  TYPE_E_WRONGTYPEKIND* = HRESULT(0x8002802A)
  TYPE_E_ELEMENTNOTFOUND* = HRESULT(0x8002802B)
  TYPE_E_AMBIGUOUSNAME* = HRESULT(0x8002802C)
  TYPE_E_NAMECONFLICT* = HRESULT(0x8002802D)
  TYPE_E_UNKNOWNLCID* = HRESULT(0x8002802E)
  TYPE_E_DLLFUNCTIONNOTFOUND* = HRESULT(0x8002802F)
  TYPE_E_BADMODULEKIND* = HRESULT(0x800288BD)
  TYPE_E_SIZETOOBIG* = HRESULT(0x800288C5)
  TYPE_E_DUPLICATEID* = HRESULT(0x800288C6)
  TYPE_E_INVALIDID* = HRESULT(0x800288CF)
  TYPE_E_TYPEMISMATCH* = HRESULT(0x80028CA0)
  TYPE_E_OUTOFBOUNDS* = HRESULT(0x80028CA1)
  TYPE_E_IOERROR* = HRESULT(0x80028CA2)
  TYPE_E_CANTCREATETMPFILE* = HRESULT(0x80028CA3)
  TYPE_E_CANTLOADLIBRARY* = HRESULT(0x80029C4A)
  TYPE_E_INCONSISTENTPROPFUNCS* = HRESULT(0x80029C83)
  TYPE_E_CIRCULARTYPE* = HRESULT(0x80029C84)
  STG_E_INVALIDFUNCTION* = HRESULT(0x80030001)
  STG_E_FILENOTFOUND* = HRESULT(0x80030002)
  STG_E_PATHNOTFOUND* = HRESULT(0x80030003)
  STG_E_TOOMANYOPENFILES* = HRESULT(0x80030004)
  STG_E_ACCESSDENIED* = HRESULT(0x80030005)
  STG_E_INVALIDHANDLE* = HRESULT(0x80030006)
  STG_E_INSUFFICIENTMEMORY* = HRESULT(0x80030008)
  STG_E_INVALIDPOINTER* = HRESULT(0x80030009)
  STG_E_NOMOREFILES* = HRESULT(0x80030012)
  STG_E_DISKISWRITEPROTECTED* = HRESULT(0x80030013)
  STG_E_SEEKERROR* = HRESULT(0x80030019)
  STG_E_WRITEFAULT* = HRESULT(0x8003001D)
  STG_E_READFAULT* = HRESULT(0x8003001E)
  STG_E_SHAREVIOLATION* = HRESULT(0x80030020)
  STG_E_LOCKVIOLATION* = HRESULT(0x80030021)
  STG_E_FILEALREADYEXISTS* = HRESULT(0x80030050)
  STG_E_INVALIDPARAMETER* = HRESULT(0x80030057)
  STG_E_MEDIUMFULL* = HRESULT(0x80030070)
  STG_E_PROPSETMISMATCHED* = HRESULT(0x800300F0)
  STG_E_ABNORMALAPIEXIT* = HRESULT(0x800300FA)
  STG_E_INVALIDHEADER* = HRESULT(0x800300FB)
  STG_E_INVALIDNAME* = HRESULT(0x800300FC)
  STG_E_UNKNOWN* = HRESULT(0x800300FD)
  STG_E_UNIMPLEMENTEDFUNCTION* = HRESULT(0x800300FE)
  STG_E_INVALIDFLAG* = HRESULT(0x800300FF)
  STG_E_INUSE* = HRESULT(0x80030100)
  STG_E_NOTCURRENT* = HRESULT(0x80030101)
  STG_E_REVERTED* = HRESULT(0x80030102)
  STG_E_CANTSAVE* = HRESULT(0x80030103)
  STG_E_OLDFORMAT* = HRESULT(0x80030104)
  STG_E_OLDDLL* = HRESULT(0x80030105)
  STG_E_SHAREREQUIRED* = HRESULT(0x80030106)
  STG_E_NOTFILEBASEDSTORAGE* = HRESULT(0x80030107)
  STG_E_EXTANTMARSHALLINGS* = HRESULT(0x80030108)
  STG_E_DOCFILECORRUPT* = HRESULT(0x80030109)
  STG_E_BADBASEADDRESS* = HRESULT(0x80030110)
  STG_E_INCOMPLETE* = HRESULT(0x80030201)
  STG_E_TERMINATED* = HRESULT(0x80030202)
  STG_S_CONVERTED* = HRESULT(0x00030200)
  STG_S_BLOCK* = HRESULT(0x00030201)
  STG_S_RETRYNOW* = HRESULT(0x00030202)
  STG_S_MONITORING* = HRESULT(0x00030203)
  RPC_E_CALL_REJECTED* = HRESULT(0x80010001)
  RPC_E_CALL_CANCELED* = HRESULT(0x80010002)
  RPC_E_CANTPOST_INSENDCALL* = HRESULT(0x80010003)
  RPC_E_CANTCALLOUT_INASYNCCALL* = HRESULT(0x80010004)
  RPC_E_CANTCALLOUT_INEXTERNALCALL* = HRESULT(0x80010005)
  RPC_E_CONNECTION_TERMINATED* = HRESULT(0x80010006)
  RPC_E_SERVER_DIED* = HRESULT(0x80010007)
  RPC_E_CLIENT_DIED* = HRESULT(0x80010008)
  RPC_E_INVALID_DATAPACKET* = HRESULT(0x80010009)
  RPC_E_CANTTRANSMIT_CALL* = HRESULT(0x8001000A)
  RPC_E_CLIENT_CANTMARSHAL_DATA* = HRESULT(0x8001000B)
  RPC_E_CLIENT_CANTUNMARSHAL_DATA* = HRESULT(0x8001000C)
  RPC_E_SERVER_CANTMARSHAL_DATA* = HRESULT(0x8001000D)
  RPC_E_SERVER_CANTUNMARSHAL_DATA* = HRESULT(0x8001000E)
  RPC_E_INVALID_DATA* = HRESULT(0x8001000F)
  RPC_E_INVALID_PARAMETER* = HRESULT(0x80010010)
  RPC_E_CANTCALLOUT_AGAIN* = HRESULT(0x80010011)
  RPC_E_SERVER_DIED_DNE* = HRESULT(0x80010012)
  RPC_E_SYS_CALL_FAILED* = HRESULT(0x80010100)
  RPC_E_OUT_OF_RESOURCES* = HRESULT(0x80010101)
  RPC_E_ATTEMPTED_MULTITHREAD* = HRESULT(0x80010102)
  RPC_E_NOT_REGISTERED* = HRESULT(0x80010103)
  RPC_E_FAULT* = HRESULT(0x80010104)
  RPC_E_SERVERFAULT* = HRESULT(0x80010105)
  RPC_E_CHANGED_MODE* = HRESULT(0x80010106)
  RPC_E_INVALIDMETHOD* = HRESULT(0x80010107)
  RPC_E_DISCONNECTED* = HRESULT(0x80010108)
  RPC_E_RETRY* = HRESULT(0x80010109)
  RPC_E_SERVERCALL_RETRYLATER* = HRESULT(0x8001010A)
  RPC_E_SERVERCALL_REJECTED* = HRESULT(0x8001010B)
  RPC_E_INVALID_CALLDATA* = HRESULT(0x8001010C)
  RPC_E_CANTCALLOUT_ININPUTSYNCCALL* = HRESULT(0x8001010D)
  RPC_E_WRONG_THREAD* = HRESULT(0x8001010E)
  RPC_E_THREAD_NOT_INIT* = HRESULT(0x8001010F)
  RPC_E_VERSION_MISMATCH* = HRESULT(0x80010110)
  RPC_E_INVALID_HEADER* = HRESULT(0x80010111)
  RPC_E_INVALID_EXTENSION* = HRESULT(0x80010112)
  RPC_E_INVALID_IPID* = HRESULT(0x80010113)
  RPC_E_INVALID_OBJECT* = HRESULT(0x80010114)
  RPC_S_CALLPENDING* = HRESULT(0x80010115)
  RPC_S_WAITONTIMER* = HRESULT(0x80010116)
  RPC_E_CALL_COMPLETE* = HRESULT(0x80010117)
  RPC_E_UNSECURE_CALL* = HRESULT(0x80010118)
  RPC_E_TOO_LATE* = HRESULT(0x80010119)
  RPC_E_NO_GOOD_SECURITY_PACKAGES* = HRESULT(0x8001011A)
  RPC_E_ACCESS_DENIED* = HRESULT(0x8001011B)
  RPC_E_REMOTE_DISABLED* = HRESULT(0x8001011C)
  RPC_E_INVALID_OBJREF* = HRESULT(0x8001011D)
  RPC_E_UNEXPECTED* = HRESULT(0x8001FFFF)
  NTE_BAD_UID* = HRESULT(0x80090001)
  NTE_BAD_HASH* = HRESULT(0x80090002)
  NTE_BAD_KEY* = HRESULT(0x80090003)
  NTE_BAD_LEN* = HRESULT(0x80090004)
  NTE_BAD_DATA* = HRESULT(0x80090005)
  NTE_BAD_SIGNATURE* = HRESULT(0x80090006)
  NTE_BAD_VER* = HRESULT(0x80090007)
  NTE_BAD_ALGID* = HRESULT(0x80090008)
  NTE_BAD_FLAGS* = HRESULT(0x80090009)
  NTE_BAD_TYPE* = HRESULT(0x8009000A)
  NTE_BAD_KEY_STATE* = HRESULT(0x8009000B)
  NTE_BAD_HASH_STATE* = HRESULT(0x8009000C)
  NTE_NO_KEY* = HRESULT(0x8009000D)
  NTE_NO_MEMORY* = HRESULT(0x8009000E)
  NTE_EXISTS* = HRESULT(0x8009000F)
  NTE_PERM* = HRESULT(0x80090010)
  NTE_NOT_FOUND* = HRESULT(0x80090011)
  NTE_DOUBLE_ENCRYPT* = HRESULT(0x80090012)
  NTE_BAD_PROVIDER* = HRESULT(0x80090013)
  NTE_BAD_PROV_TYPE* = HRESULT(0x80090014)
  NTE_BAD_PUBLIC_KEY* = HRESULT(0x80090015)
  NTE_BAD_KEYSET* = HRESULT(0x80090016)
  NTE_PROV_TYPE_NOT_DEF* = HRESULT(0x80090017)
  NTE_PROV_TYPE_ENTRY_BAD* = HRESULT(0x80090018)
  NTE_KEYSET_NOT_DEF* = HRESULT(0x80090019)
  NTE_KEYSET_ENTRY_BAD* = HRESULT(0x8009001A)
  NTE_PROV_TYPE_NO_MATCH* = HRESULT(0x8009001B)
  NTE_SIGNATURE_FILE_BAD* = HRESULT(0x8009001C)
  NTE_PROVIDER_DLL_FAIL* = HRESULT(0x8009001D)
  NTE_PROV_DLL_NOT_FOUND* = HRESULT(0x8009001E)
  NTE_BAD_KEYSET_PARAM* = HRESULT(0x8009001F)
  NTE_FAIL* = HRESULT(0x80090020)
  NTE_SYS_ERR* = HRESULT(0x80090021)
  NTE_OP_OK* = HRESULT(0)
  TRUST_E_PROVIDER_UNKNOWN* = HRESULT(0x800B0001)
  TRUST_E_ACTION_UNKNOWN* = HRESULT(0x800B0002)
  TRUST_E_SUBJECT_FORM_UNKNOWN* = HRESULT(0x800B0003)
  TRUST_E_SUBJECT_NOT_TRUSTED* = HRESULT(0x800B0004)
  DIGSIG_E_ENCODE* = HRESULT(0x800B0005)
  DIGSIG_E_DECODE* = HRESULT(0x800B0006)
  DIGSIG_E_EXTENSIBILITY* = HRESULT(0x800B0007)
  DIGSIG_E_CRYPTO* = HRESULT(0x800B0008)
  PERSIST_E_SIZEDEFINITE* = HRESULT(0x800B0009)
  PERSIST_E_SIZEINDEFINITE* = HRESULT(0x800B000A)
  PERSIST_E_NOTSELFSIZING* = HRESULT(0x800B000B)
  TRUST_E_NOSIGNATURE* = HRESULT(0x800B0100)
  CERT_E_EXPIRED* = HRESULT(0x800B0101)
  CERT_E_VALIDIYPERIODNESTING* = HRESULT(0x800B0102)
  CERT_E_ROLE* = HRESULT(0x800B0103)
  CERT_E_PATHLENCONST* = HRESULT(0x800B0104)
  CERT_E_CRITICAL* = HRESULT(0x800B0105)
  CERT_E_PURPOSE* = HRESULT(0x800B0106)
  CERT_E_ISSUERCHAINING* = HRESULT(0x800B0107)
  CERT_E_MALFORMED* = HRESULT(0x800B0108)
  CERT_E_UNTRUSTEDROOT* = HRESULT(0x800B0109)
  CERT_E_CHAINING* = HRESULT(0x800B010A)

proc UNICODE_NULL*(): WCHAR
const
  LF_FACESIZE* = 32
  LF_FULLFACESIZE* = 64
  ELF_VENDOR_SIZE* = 4
  SECURITY_STATIC_TRACKING* = 0
  SECURITY_DYNAMIC_TRACKING* = 1
  MAX_DEFAULTCHAR* = 2
  MAX_LEADBYTES* = 12
  EXCEPTION_MAXIMUM_PARAMETERS* = 15
  CCHDEVICENAME* = 32
  CCHFORMNAME* = 32
  MENU_TEXT_LEN* = 40
  MAX_LANA* = 254
  NCBNAMSZ* = 16
  NETBIOS_NAME_LEN* = 16
  OFS_MAXPATHNAME* = 128
  MAX_TAB_STOPS* = 32
  ANYSIZE_ARRAY* = 1
  RAS_MaxCallbackNumber* = 128
  RAS_MaxDeviceName* = 128
  RAS_MaxDeviceType* = 16
  RAS_MaxEntryName* = 256
  RAS_MaxIpAddress* = 15
  RAS_MaxIpxAddress* = 21
  RAS_MaxPhoneNumber* = 128
  UNLEN* = 256
  PWLEN* = 256
  CNLEN* = 15
  DNLEN* = 15
  # Unsigned types max
  MAXDWORD* = 0xFFFFFFFF
  MAXWORD* = 0x0000FFFF
  MAXBYTE* = 0x000000FF
  # Signed types max/min
  MINCHAR* = 0x00000080
  MAXCHAR* = 0x0000007F
  MINSHORT* = 0x00008000
  MAXSHORT* = 0x00007FFF
  MINLONG* = 0x80000000
  MAXLONG* = 0x7FFFFFFF
  # _llseek
  FILE_BEGIN* = 0
  FILE_CURRENT* = 1
  FILE_END* = 2
  # _lopen, LZOpenFile, OpenFile
  OF_READ* = 0
  OF_READWRITE* = 2
  OF_WRITE* = 1
  OF_SHARE_COMPAT* = 0
  OF_SHARE_DENY_NONE* = 64
  OF_SHARE_DENY_READ* = 48
  OF_SHARE_DENY_WRITE* = 32
  OF_SHARE_EXCLUSIVE* = 16
  OF_CANCEL* = 2048
  OF_CREATE* = 4096
  OF_DELETE* = 512
  OF_EXIST* = 16384
  OF_PARSE* = 256
  OF_PROMPT* = 8192
  OF_REOPEN* = 32768
  OF_VERIFY* = 1024
  # ActivateKeyboardLayout, LoadKeyboardLayout
  HKL_NEXT* = 1
  HKL_PREV* = 0
  KLF_REORDER* = 8
  KLF_UNLOADPREVIOUS* = 4
  KLF_ACTIVATE* = 1
  KLF_NOTELLSHELL* = 128
  KLF_REPLACELANG* = 16
  KLF_SUBSTITUTE_OK* = 2
  # AppendMenu
  MF_BITMAP* = 0x00000004
  MF_DISABLED* = 0x00000002
  MF_ENABLED* = 0
  MF_GRAYED* = 0x00000001
  MF_HELP* = 0x00004000
  MF_MENUBARBREAK* = 0x00000020
  MF_MENUBREAK* = 0x00000040
  MF_MOUSESELECT* = 0x00008000
  MF_OWNERDRAW* = 0x00000100
  MF_POPUP* = 0x00000010
  MF_SEPARATOR* = 0x00000800
  MF_STRING* = 0
  MF_SYSMENU* = 0x00002000
  MF_USECHECKBITMAPS* = 0x00000200
  # Ternary Raster Operations - BitBlt
  BLACKNESS* = 0x00000042
  NOTSRCERASE* = 0x001100A6
  NOTSRCCOPY* = 0x00330008
  SRCERASE* = 0x00440328
  DSTINVERT* = 0x00550009
  PATINVERT* = 0x005A0049
  SRCINVERT* = 0x00660046
  SRCAND* = 0x008800C6
  MERGEPAINT* = 0x00BB0226
  MERGECOPY* = 0x00C000CA
  SRCCOPY* = 0x00CC0020
  SRCPAINT* = 0x00EE0086
  PATCOPY* = 0x00F00021
  PATPAINT* = 0x00FB0A09
  WHITENESS* = 0x00FF0062
  # Binary Raster Operations
  R2_BLACK* = 1
  R2_COPYPEN* = 13
  R2_MASKNOTPEN* = 3
  R2_MASKPEN* = 9
  R2_MASKPENNOT* = 5
  R2_MERGENOTPEN* = 12
  R2_MERGEPEN* = 15
  R2_MERGEPENNOT* = 14
  R2_NOP* = 11
  R2_NOT* = 6
  R2_NOTCOPYPEN* = 4
  R2_NOTMASKPEN* = 8
  R2_NOTMERGEPEN* = 2
  R2_NOTXORPEN* = 10
  R2_WHITE* = 16
  R2_XORPEN* = 7
  # BroadcastSystemMessage
  BSF_FLUSHDISK* = 4
  BSF_FORCEIFHUNG* = 32
  BSF_IGNORECURRENTTASK* = 2
  BSF_NOHANG* = 8
  BSF_POSTMESSAGE* = 16
  BSF_QUERY* = 1
  BSM_ALLCOMPONENTS* = 0
  BSM_APPLICATIONS* = 8
  BSM_INSTALLABLEDRIVERS* = 4
  BSM_NETDRIVER* = 2
  BSM_VXDS* = 1
  BROADCAST_QUERY_DENY* = 1112363332
                                     # CallNamedPipe
  NMPWAIT_NOWAIT* = 1
  NMPWAIT_WAIT_FOREVER* = -1
  NMPWAIT_USE_DEFAULT_WAIT* = 0
  # CascadeWindows, TileWindows
  MDITILE_SKIPDISABLED* = 2
  MDITILE_HORIZONTAL* = 1
  MDITILE_VERTICAL* = 0
  # CBTProc
  HCBT_ACTIVATE* = 5
  HCBT_CLICKSKIPPED* = 6
  HCBT_CREATEWND* = 3
  HCBT_DESTROYWND* = 4
  HCBT_KEYSKIPPED* = 7
  HCBT_MINMAX* = 1
  HCBT_MOVESIZE* = 0
  HCBT_QS* = 2
  HCBT_SETFOCUS* = 9
  HCBT_SYSCOMMAND* = 8

  CDS_UPDATEREGISTRY* = 1
  CDS_TEST* = 2
  CDS_FULLSCREEN* = 4
  CDS_GLOBAL* = 8
  CDS_SET_PRIMARY* = 0x00000010
  CDS_RESET* = 0x40000000
  CDS_SETRECT* = 0x20000000
  CDS_NORESET* = 0x10000000
  DISP_CHANGE_SUCCESSFUL* = 0
  DISP_CHANGE_RESTART* = 1
  DISP_CHANGE_BADFLAGS* = -4
  DISP_CHANGE_FAILED* = -1
  DISP_CHANGE_BADMODE* = -2
  DISP_CHANGE_NOTUPDATED* = -3
  # ChangeServiceConfig
  SERVICE_NO_CHANGE* = -1
  SERVICE_WIN32_OWN_PROCESS* = 16
  SERVICE_WIN32_SHARE_PROCESS* = 32
  SERVICE_KERNEL_DRIVER* = 1
  SERVICE_FILE_SYSTEM_DRIVER* = 2
  SERVICE_INTERACTIVE_PROCESS* = 256
  SERVICE_BOOT_START* = 0
  SERVICE_SYSTEM_START* = 1
  SERVICE_AUTO_START* = 2
  SERVICE_DEMAND_START* = 3
  SERVICE_DISABLED* = 4
  SERVICE_STOPPED* = 1
  SERVICE_START_PENDING* = 2
  SERVICE_STOP_PENDING* = 3
  SERVICE_RUNNING* = 4
  SERVICE_CONTINUE_PENDING* = 5
  SERVICE_PAUSE_PENDING* = 6
  SERVICE_PAUSED* = 7
  SERVICE_ACCEPT_STOP* = 1
  SERVICE_ACCEPT_PAUSE_CONTINUE* = 2
  SERVICE_ACCEPT_SHUTDOWN* = 4
  # CheckDlgButton
  BST_CHECKED* = 1
  BST_INDETERMINATE* = 2
  BST_UNCHECKED* = 0
  BST_FOCUS* = 8
  BST_PUSHED* = 4
  # CheckMenuItem, HiliteMenuItem
  MF_BYCOMMAND* = 0
  MF_BYPOSITION* = 0x00000400
  MF_CHECKED* = 0x00000008
  MF_UNCHECKED* = 0
  MF_HILITE* = 0x00000080
  MF_UNHILITE* = 0
  # ChildWindowFromPointEx
  CWP_ALL* = 0
  CWP_SKIPINVISIBLE* = 1
  CWP_SKIPDISABLED* = 2
  CWP_SKIPTRANSPARENT* = 4
  # ClearCommError
  CE_BREAK* = 16
  CE_DNS* = 2048
  CE_FRAME* = 8
  CE_IOE* = 1024
  CE_MODE* = 32768
  CE_OOP* = 4096
  CE_OVERRUN* = 2
  CE_PTO* = 512
  CE_RXOVER* = 1
  CE_RXPARITY* = 4
  CE_TXFULL* = 256
                              # CombineRgn
  RGN_AND* = 1
  RGN_COPY* = 5
  RGN_DIFF* = 4
  RGN_OR* = 2
  RGN_XOR* = 3
  NULLREGION* = 1
  SIMPLEREGION* = 2
  COMPLEXREGION* = 3
  ERROR* = 0
  # CommonDlgExtendedError
  CDERR_DIALOGFAILURE* = 0x0000FFFF
  CDERR_FINDRESFAILURE* = 6
  CDERR_INITIALIZATION* = 2
  CDERR_LOADRESFAILURE* = 7
  CDERR_LOADSTRFAILURE* = 5
  CDERR_LOCKRESFAILURE* = 8
  CDERR_MEMALLOCFAILURE* = 9
  CDERR_MEMLOCKFAILURE* = 10
  CDERR_NOHINSTANCE* = 4
  CDERR_NOHOOK* = 11
  CDERR_NOTEMPLATE* = 3
  CDERR_REGISTERMSGFAIL* = 12
  CDERR_STRUCTSIZE* = 1
  PDERR_CREATEICFAILURE* = 0x00001000 + 10
  PDERR_DEFAULTDIFFERENT* = 0x00001000 + 12
  PDERR_DNDMMISMATCH* = 0x00001000 + 9
  PDERR_GETDEVMODEFAIL* = 0x00001000 + 5
  PDERR_INITFAILURE* = 0x00001000 + 6
  PDERR_LOADDRVFAILURE* = 0x00001000 + 4
  PDERR_NODEFAULTPRN* = 0x00001000 + 8
  PDERR_NODEVICES* = 0x00001000 + 7
  PDERR_PARSEFAILURE* = 0x00001000 + 2
  PDERR_PRINTERNOTFOUND* = 0x00001000 + 11
  PDERR_RETDEFFAILURE* = 0x00001000 + 3
  PDERR_SETUPFAILURE* = 0x00001000 + 1
  CFERR_MAXLESSTHANMIN* = 0x00002000 + 2
  CFERR_NOFONTS* = 0x00002000 + 1
  FNERR_BUFFERTOOSMALL* = 0x00003000 + 3
  FNERR_INVALIDFILENAME* = 0x00003000 + 2
  FNERR_SUBCLASSFAILURE* = 0x00003000 + 1
  FRERR_BUFFERLENGTHZERO* = 0x00004000 + 1
  # CompareString, LCMapString
  LOCALE_SYSTEM_DEFAULT* = 0x00000800
  LOCALE_USER_DEFAULT* = 0x00000400
  NORM_IGNORECASE* = 1
  NORM_IGNOREKANATYPE* = 65536
  NORM_IGNORENONSPACE* = 2
  NORM_IGNORESYMBOLS* = 4
  NORM_IGNOREWIDTH* = 131072
  SORT_STRINGSORT* = 4096
  LCMAP_BYTEREV* = 2048
  LCMAP_FULLWIDTH* = 8388608
  LCMAP_HALFWIDTH* = 4194304
  LCMAP_HIRAGANA* = 1048576
  LCMAP_KATAKANA* = 2097152
  LCMAP_LOWERCASE* = 256
  LCMAP_SORTKEY* = 1024
  LCMAP_UPPERCASE* = 512
  # ContinueDebugEvent
  DBG_CONTINUE* = 0x00010002
  DBG_CONTROL_BREAK* = 0x40010008
  DBG_CONTROL_C* = 0x40010005
  DBG_EXCEPTION_NOT_HANDLED* = 0x80010001
  DBG_TERMINATE_THREAD* = 0x40010003
  DBG_TERMINATE_PROCESS* = 0x40010004
  # ControlService
  SERVICE_CONTROL_STOP* = 1
  SERVICE_CONTROL_PAUSE* = 2
  SERVICE_CONTROL_CONTINUE* = 3
  SERVICE_CONTROL_INTERROGATE* = 4
  SERVICE_CONTROL_SHUTDOWN* = 5
  # CopyImage, LoadImage
  IMAGE_BITMAP* = 0
  IMAGE_CURSOR* = 2
  IMAGE_ENHMETAFILE* = 1
  IMAGE_ICON* = 1
  LR_MONOCHROME* = 1
  LR_COLOR* = 2
  LR_COPYRETURNORG* = 4
  LR_COPYDELETEORG* = 8
  LR_DEFAULTSIZE* = 64
  LR_CREATEDIBSECTION* = 8192
  LR_COPYFROMRESOURCE* = 0x00004000
  LR_SHARED* = 0x00008000
  # CreateDesktop
  DF_ALLOWOTHERACCOUNTHOOK* = 0x00000001
  DESKTOP_CREATEMENU* = 0x00000004
  DESKTOP_CREATEWINDOW* = 0x00000002
  DESKTOP_ENUMERATE* = 0x00000040
  DESKTOP_HOOKCONTROL* = 0x00000008
  DESKTOP_JOURNALPLAYBACK* = 0x00000020
  DESKTOP_JOURNALRECORD* = 0x00000010
  DESKTOP_READOBJECTS* = 0x00000001
  DESKTOP_SWITCHDESKTOP* = 0x00000100
  DESKTOP_WRITEOBJECTS* = 0x00000080
  WSF_VISIBLE* = 0x00000001
  # CreateDIBitmap
  CBM_INIT* = 0x00000004
  DIB_PAL_COLORS* = 1
  DIB_RGB_COLORS* = 0
  # CreateFile, GetFileAttributes, SetFileAttributes
  GENERIC_READ* = 0x80000000
  GENERIC_WRITE* = 0x40000000
  FILE_READ_DATA* = 0x00000001 # file & pipe
  FILE_LIST_DIRECTORY* = 0x00000001 # directory
  FILE_WRITE_DATA* = 0x00000002 # file & pipe
  FILE_ADD_FILE* = 0x00000002 # directory
  FILE_APPEND_DATA* = 0x00000004 # file
  FILE_ADD_SUBDIRECTORY* = 0x00000004 # directory
  FILE_CREATE_PIPE_INSTANCE* = 0x00000004 # named pipe
  FILE_READ_EA* = 0x00000008 # file & directory
  FILE_READ_PROPERTIES* = FILE_READ_EA
  FILE_WRITE_EA* = 0x00000010 # file & directory
  FILE_WRITE_PROPERTIES* = FILE_WRITE_EA
  FILE_EXECUTE* = 0x00000020 # file
  FILE_TRAVERSE* = 0x00000020 # directory
  FILE_DELETE_CHILD* = 0x00000040 # directory
  FILE_READ_ATTRIBUTES* = 0x00000080 # all
  FILE_WRITE_ATTRIBUTES* = 0x00000100 # all
  FILE_SHARE_DELETE* = 4
  FILE_SHARE_READ* = 1
  FILE_SHARE_WRITE* = 2
  CONSOLE_TEXTMODE_BUFFER* = 1
  CREATE_NEW* = 1
  CREATE_ALWAYS* = 2
  OPEN_EXISTING* = 3
  OPEN_ALWAYS* = 4
  TRUNCATE_EXISTING* = 5
  FILE_ATTRIBUTE_ARCHIVE* = 32
  FILE_ATTRIBUTE_COMPRESSED* = 2048
  FILE_ATTRIBUTE_NORMAL* = 128
  FILE_ATTRIBUTE_DIRECTORY* = 16
  FILE_ATTRIBUTE_HIDDEN* = 2
  FILE_ATTRIBUTE_READONLY* = 1
  FILE_ATTRIBUTE_SYSTEM* = 4
  FILE_ATTRIBUTE_TEMPORARY* = 256
  FILE_FLAG_WRITE_THROUGH* = 0x80000000
  FILE_FLAG_OVERLAPPED* = 1073741824
  FILE_FLAG_NO_BUFFERING* = 536870912
  FILE_FLAG_RANDOM_ACCESS* = 268435456
  FILE_FLAG_SEQUENTIAL_SCAN* = 134217728
  FILE_FLAG_DELETE_ON_CLOSE* = 67108864
  FILE_FLAG_BACKUP_SEMANTICS* = 33554432
  FILE_FLAG_POSIX_SEMANTICS* = 16777216
  cSECURITY_ANONYMOUS* = 0
  cSECURITY_IDENTIFICATION* = 65536
  cSECURITY_IMPERSONATION* = 131072
  cSECURITY_DELEGATION* = 196608
  cSECURITY_CONTEXT_TRACKING* = 262144
  cSECURITY_EFFECTIVE_ONLY* = 524288
  cSECURITY_SQOS_PRESENT* = 1048576
  # CreateFileMapping, VirtualAlloc, VirtualFree, VirtualProtect
  SEC_COMMIT* = 134217728
  SEC_IMAGE* = 16777216
  SEC_NOCACHE* = 268435456
  SEC_RESERVE* = 67108864
  PAGE_READONLY* = 2
  PAGE_READWRITE* = 4
  PAGE_WRITECOPY* = 8
  PAGE_EXECUTE* = 16
  PAGE_EXECUTE_READ* = 32
  PAGE_EXECUTE_READWRITE* = 64
  PAGE_EXECUTE_WRITECOPY* = 128
  PAGE_GUARD* = 256
  PAGE_NOACCESS* = 1
  PAGE_NOCACHE* = 512
  MEM_COMMIT* = 4096
  MEM_FREE* = 65536
  MEM_RESERVE* = 8192
  MEM_IMAGE* = 16777216
  MEM_MAPPED* = 262144
  MEM_PRIVATE* = 131072
  MEM_DECOMMIT* = 16384
  MEM_RELEASE* = 32768
  MEM_TOP_DOWN* = 1048576
  EXCEPTION_GUARD_PAGE* = 0x80000001
  SECTION_EXTEND_SIZE* = 0x00000010
  SECTION_MAP_READ* = 0x00000004
  SECTION_MAP_WRITE* = 0x00000002
  SECTION_QUERY* = 0x00000001
  SECTION_ALL_ACCESS* = 0x000F001F
  # CreateFont
  FW_DONTCARE* = 0
  FW_THIN* = 100
  FW_EXTRALIGHT* = 200
  FW_LIGHT* = 300
  FW_NORMAL* = 400
  FW_REGULAR* = FW_NORMAL
  FW_MEDIUM* = 500
  FW_SEMIBOLD* = 600
  FW_BOLD* = 700
  FW_EXTRABOLD* = 800
  FW_HEAVY* = 900
  ANSI_CHARSET* = 0
  DEFAULT_CHARSET* = 1
  SYMBOL_CHARSET* = 2
  SHIFTJIS_CHARSET* = 128
  HANGEUL_CHARSET* = 129
  GB2312_CHARSET* = 134
  CHINESEBIG5_CHARSET* = 136
  GREEK_CHARSET* = 161
  TURKISH_CHARSET* = 162
  HEBREW_CHARSET* = 177
  ARABIC_CHARSET* = 178
  BALTIC_CHARSET* = 186
  RUSSIAN_CHARSET* = 204
  THAI_CHARSET* = 222
  EASTEUROPE_CHARSET* = 238
  OEM_CHARSET* = 255
  OUT_DEFAULT_PRECIS* = 0
  OUT_STRING_PRECIS* = 1
  OUT_CHARACTER_PRECIS* = 2
  OUT_STROKE_PRECIS* = 3
  OUT_TT_PRECIS* = 4
  OUT_DEVICE_PRECIS* = 5
  OUT_RASTER_PRECIS* = 6
  OUT_TT_ONLY_PRECIS* = 7
  OUT_OUTLINE_PRECIS* = 8
  CLIP_DEFAULT_PRECIS* = 0
  CLIP_CHARACTER_PRECIS* = 1
  CLIP_STROKE_PRECIS* = 2
  CLIP_MASK* = 15
  CLIP_LH_ANGLES* = 16
  CLIP_TT_ALWAYS* = 32
  CLIP_EMBEDDED* = 128
  DEFAULT_QUALITY* = 0
  DRAFT_QUALITY* = 1
  PROOF_QUALITY* = 2
  NONANTIALIASED_QUALITY* = 3
  ANTIALIASED_QUALITY* = 4
  DEFAULT_PITCH* = 0
  FIXED_PITCH* = 1
  VARIABLE_PITCH* = 2
  MONO_FONT* = 8
  FF_DECORATIVE* = 80
  FF_DONTCARE* = 0
  FF_MODERN* = 48
  FF_ROMAN* = 16
  FF_SCRIPT* = 64
  FF_SWISS* = 32
  # CreateHatchBrush
  HS_BDIAGONAL* = 3
  HS_CROSS* = 4
  HS_DIAGCROSS* = 5
  HS_FDIAGONAL* = 2
  HS_HORIZONTAL* = 0
  HS_VERTICAL* = 1
  # CreateIconFromResourceEx
  LR_DEFAULTCOLOR* = 0
  LR_LOADREALSIZE* = 128
                              # CreateMailslot, GetMailslotInfo
  MAILSLOT_WAIT_FOREVER* = 0xFFFFFFFF
  MAILSLOT_NO_MESSAGE* = 0xFFFFFFFF
  # CreateMappedBitmap
  CMB_MASKED* = 2
  # CreateNamedPipe
  PIPE_ACCESS_DUPLEX* = 3
  PIPE_ACCESS_INBOUND* = 1
  PIPE_ACCESS_OUTBOUND* = 2
  WRITE_DAC* = 0x00040000
  WRITE_OWNER* = 0x00080000
  ACCESS_SYSTEM_SECURITY* = 0x01000000
  PIPE_TYPE_BYTE* = 0
  PIPE_TYPE_MESSAGE* = 4
  PIPE_READMODE_BYTE* = 0
  PIPE_READMODE_MESSAGE* = 2
  PIPE_WAIT* = 0
  PIPE_NOWAIT* = 1
  # CreatePen, ExtCreatePen
  PS_GEOMETRIC* = 65536
  PS_COSMETIC* = 0
  PS_ALTERNATE* = 8
  PS_SOLID* = 0
  PS_DASH* = 1
  PS_DOT* = 2
  PS_DASHDOT* = 3
  PS_DASHDOTDOT* = 4
  PS_NULL* = 5
  PS_USERSTYLE* = 7
  PS_INSIDEFRAME* = 6
  PS_ENDCAP_ROUND* = 0
  PS_ENDCAP_SQUARE* = 256
  PS_ENDCAP_FLAT* = 512
  PS_JOIN_BEVEL* = 4096
  PS_JOIN_MITER* = 8192
  PS_JOIN_ROUND* = 0
  PS_STYLE_MASK* = 15
  PS_ENDCAP_MASK* = 3840
  PS_TYPE_MASK* = 983040
  # CreatePolygonRgn
  ALTERNATE* = 1
  WINDING* = 2
  # CreateProcess
  CREATE_DEFAULT_ERROR_MODE* = 67108864
  CREATE_NEW_CONSOLE* = 16
  CREATE_NEW_PROCESS_GROUP* = 512
  CREATE_SEPARATE_WOW_VDM* = 2048
  CREATE_SUSPENDED* = 4
  CREATE_UNICODE_ENVIRONMENT* = 1024
  DEBUG_PROCESS* = 1
  DEBUG_ONLY_THIS_PROCESS* = 2
  DETACHED_PROCESS* = 8
  HIGH_PRIORITY_CLASS* = 128
  IDLE_PRIORITY_CLASS* = 64
  NORMAL_PRIORITY_CLASS* = 32
  REALTIME_PRIORITY_CLASS* = 256
  # CreateService
  SERVICE_ALL_ACCESS* = 0x000F01FF
  SERVICE_CHANGE_CONFIG* = 2
  SERVICE_ENUMERATE_DEPENDENTS* = 8
  SERVICE_INTERROGATE* = 128
  SERVICE_PAUSE_CONTINUE* = 64
  SERVICE_QUERY_CONFIG* = 1
  SERVICE_QUERY_STATUS* = 4
  SERVICE_START* = 16
  SERVICE_STOP* = 32
  SERVICE_USER_DEFINED_CONTROL* = 256
  SERVICE_DELETE* = 0x00010000
  SERVICE_READ_CONTROL* = 0x00020000
  SERVICE_GENERIC_EXECUTE* = 0x20000000
  SERVICE_ERROR_IGNORE* = 0
  SERVICE_ERROR_NORMAL* = 1
  SERVICE_ERROR_SEVERE* = 2
  SERVICE_ERROR_CRITICAL* = 3
  # CreateTapePartition, WriteTapemark
  TAPE_FIXED_PARTITIONS* = 0
  TAPE_INITIATOR_PARTITIONS* = 0x00000002
  TAPE_SELECT_PARTITIONS* = 0x00000001
  TAPE_FILEMARKS* = 0x00000001
  TAPE_LONG_FILEMARKS* = 0x00000003
  TAPE_SETMARKS* = 0
  TAPE_SHORT_FILEMARKS* = 0x00000002
  # CreateWindow
  CW_USEDEFAULT* = int32(0x80000000)
  WS_BORDER* = 0x00800000
  WS_CAPTION* = 0x00C00000
  WS_CHILD* = 0x40000000
  WS_CHILDWINDOW* = 0x40000000
  WS_CLIPCHILDREN* = 0x02000000
  WS_CLIPSIBLINGS* = 0x04000000
  WS_DISABLED* = 0x08000000
  WS_DLGFRAME* = 0x00400000
  WS_GROUP* = 0x00020000
  WS_HSCROLL* = 0x00100000
  WS_ICONIC* = 0x20000000
  WS_MAXIMIZE* = 0x01000000
  WS_MAXIMIZEBOX* = 0x00010000
  WS_MINIMIZE* = 0x20000000
  WS_MINIMIZEBOX* = 0x00020000
  WS_OVERLAPPED* = 0
  WS_OVERLAPPEDWINDOW* = 0x00CF0000
  WS_POPUP* = LONG(0x80000000)
  WS_POPUPWINDOW* = LONG(0x80880000)
  WS_SIZEBOX* = 0x00040000
  WS_SYSMENU* = 0x00080000
  WS_TABSTOP* = 0x00010000
  WS_THICKFRAME* = 0x00040000

  WS_TILED* = 0
  WS_TILEDWINDOW* = 0x00CF0000
  WS_VISIBLE* = 0x10000000
  WS_VSCROLL* = 0x00200000
  MDIS_ALLCHILDSTYLES* = 0x00000001
  BS_3STATE* = 0x00000005
  BS_AUTO3STATE* = 0x00000006
  BS_AUTOCHECKBOX* = 0x00000003
  BS_AUTORADIOBUTTON* = 0x00000009
  BS_BITMAP* = 0x00000080
  BS_BOTTOM* = 0x00000800
  BS_CENTER* = 0x00000300
  BS_CHECKBOX* = 0x00000002
  BS_DEFPUSHBUTTON* = 0x00000001
  BS_GROUPBOX* = 0x00000007
  BS_ICON* = 0x00000040
  BS_LEFT* = 0x00000100
  BS_LEFTTEXT* = 0x00000020
  BS_MULTILINE* = 0x00002000
  BS_NOTIFY* = 0x00004000
  BS_OWNERDRAW* = 0x0000000B
  BS_PUSHBUTTON* = 0
  BS_PUSHLIKE* = 0x00001000
  BS_RADIOBUTTON* = 0x00000004
  BS_RIGHT* = 0x00000200
  BS_RIGHTBUTTON* = 0x00000020
  BS_TEXT* = 0
  BS_TOP* = 0x00000400
  BS_USERBUTTON* = 0x00000008
  BS_VCENTER* = 0x00000C00
  BS_FLAT* = 0x00008000
  CBS_AUTOHSCROLL* = 0x00000040
  CBS_DISABLENOSCROLL* = 0x00000800
  CBS_DROPDOWN* = 0x00000002
  CBS_DROPDOWNLIST* = 0x00000003
  CBS_HASSTRINGS* = 0x00000200
  CBS_LOWERCASE* = 0x00004000
  CBS_NOINTEGRALHEIGHT* = 0x00000400
  CBS_OEMCONVERT* = 0x00000080
  CBS_OWNERDRAWFIXED* = 0x00000010
  CBS_OWNERDRAWVARIABLE* = 0x00000020
  CBS_SIMPLE* = 0x00000001
  CBS_SORT* = 0x00000100
  CBS_UPPERCASE* = 0x00002000
  ES_AUTOHSCROLL* = 0x00000080
  ES_AUTOVSCROLL* = 0x00000040
  ES_CENTER* = 0x00000001
  ES_LEFT* = 0
  ES_LOWERCASE* = 0x00000010
  ES_MULTILINE* = 0x00000004
  ES_NOHIDESEL* = 0x00000100
  ES_NUMBER* = 0x00002000
  ES_OEMCONVERT* = 0x00000400
  ES_PASSWORD* = 0x00000020
  ES_READONLY* = 0x00000800
  ES_RIGHT* = 0x00000002
  ES_UPPERCASE* = 0x00000008
  ES_WANTRETURN* = 0x00001000
  LBS_DISABLENOSCROLL* = 0x00001000
  LBS_EXTENDEDSEL* = 0x00000800
  LBS_HASSTRINGS* = 0x00000040
  LBS_MULTICOLUMN* = 0x00000200
  LBS_MULTIPLESEL* = 0x00000008
  LBS_NODATA* = 0x00002000
  LBS_NOINTEGRALHEIGHT* = 0x00000100
  LBS_NOREDRAW* = 0x00000004
  LBS_NOSEL* = 0x00004000
  LBS_NOTIFY* = 0x00000001
  LBS_OWNERDRAWFIXED* = 0x00000010
  LBS_OWNERDRAWVARIABLE* = 0x00000020
  LBS_SORT* = 0x00000002
  LBS_STANDARD* = 0x00A00003
  LBS_USETABSTOPS* = 0x00000080
  LBS_WANTKEYBOARDINPUT* = 0x00000400
  SBS_BOTTOMALIGN* = 0x00000004
  SBS_HORZ* = 0
  SBS_LEFTALIGN* = 0x00000002
  SBS_RIGHTALIGN* = 0x00000004
  SBS_SIZEBOX* = 0x00000008
  SBS_SIZEBOXBOTTOMRIGHTALIGN* = 0x00000004
  SBS_SIZEBOXTOPLEFTALIGN* = 0x00000002
  SBS_SIZEGRIP* = 0x00000010
  SBS_TOPALIGN* = 0x00000002
  SBS_VERT* = 0x00000001
  SS_BITMAP* = 0x0000000E
  SS_BLACKFRAME* = 0x00000007
  SS_BLACKRECT* = 0x00000004
  SS_CENTER* = 0x00000001
  SS_CENTERIMAGE* = 0x00000200
  SS_ENHMETAFILE* = 0x0000000F
  SS_ETCHEDFRAME* = 0x00000012
  SS_ETCHEDHORZ* = 0x00000010
  SS_ETCHEDVERT* = 0x00000011
  SS_GRAYFRAME* = 0x00000008
  SS_GRAYRECT* = 0x00000005
  SS_ICON* = 0x00000003
  SS_LEFT* = 0
  SS_LEFTNOWORDWRAP* = 0x0000000C
  SS_NOPREFIX* = 0x00000080
  SS_NOTIFY* = 0x00000100
  SS_OWNERDRAW* = 0x0000000D
  SS_REALSIZEIMAGE* = 0x00000800
  SS_RIGHT* = 0x00000002
  SS_RIGHTJUST* = 0x00000400
  SS_SIMPLE* = 0x0000000B
  SS_SUNKEN* = 0x00001000
  SS_USERITEM* = 0x0000000A
  SS_WHITEFRAME* = 0x00000009
  SS_WHITERECT* = 0x00000006
  DS_3DLOOK* = 0x00000004
  DS_ABSALIGN* = 0x00000001
  DS_CENTER* = 0x00000800
  DS_CENTERMOUSE* = 0x00001000
  DS_CONTEXTHELP* = 0x00002000
  DS_CONTROL* = 0x00000400
  DS_FIXEDSYS* = 0x00000008
  DS_LOCALEDIT* = 0x00000020
  DS_MODALFRAME* = 0x00000080
  DS_NOFAILCREATE* = 0x00000010
  DS_NOIDLEMSG* = 0x00000100
  DS_SETFONT* = 0x00000040
  DS_SETFOREGROUND* = 0x00000200
  DS_SYSMODAL* = 0x00000002
  # CreateWindowEx
  WS_EX_ACCEPTFILES* = 0x00000010
  WS_EX_APPWINDOW* = 0x00040000
  WS_EX_CLIENTEDGE* = 0x00000200
  WS_EX_CONTEXTHELP* = 0x00000400
  WS_EX_CONTROLPARENT* = 0x00010000
  WS_EX_DLGMODALFRAME* = 0x00000001
  WS_EX_LEFT* = 0
  WS_EX_LEFTSCROLLBAR* = 0x00004000
  WS_EX_LTRREADING* = 0
  WS_EX_MDICHILD* = 0x00000040
  WS_EX_NOPARENTNOTIFY* = 0x00000004
  WS_EX_OVERLAPPEDWINDOW* = 0x00000300
  WS_EX_PALETTEWINDOW* = 0x00000188
  WS_EX_RIGHT* = 0x00001000
  WS_EX_RIGHTSCROLLBAR* = 0
  WS_EX_RTLREADING* = 0x00002000
  WS_EX_STATICEDGE* = 0x00020000
  WS_EX_TOOLWINDOW* = 0x00000080
  WS_EX_TOPMOST* = 0x00000008
  WS_EX_TRANSPARENT* = 0x00000020
  WS_EX_WINDOWEDGE* = 0x00000100
  # CreateWindowStation
  WINSTA_ACCESSCLIPBOARD* = 0x00000004
  WINSTA_ACCESSGLOBALATOMS* = 0x00000020
  WINSTA_CREATEDESKTOP* = 0x00000008
  WINSTA_ENUMDESKTOPS* = 0x00000001
  WINSTA_ENUMERATE* = 0x00000100
  WINSTA_EXITWINDOWS* = 0x00000040
  WINSTA_READATTRIBUTES* = 0x00000002
  WINSTA_READSCREEN* = 0x00000200
  WINSTA_WRITEATTRIBUTES* = 0x00000010
  # DdeCallback
  # DdeClientTransaction
  # DdeEnableCallback
  # DdeGetLastError
  # DdeInitialize
  # DdeNameService
  # DebugProc
  WH_CALLWNDPROC* = 4
  WH_CALLWNDPROCRET* = 12
  WH_CBT* = 5
  WH_DEBUG* = 9
  WH_GETMESSAGE* = 3
  WH_JOURNALPLAYBACK* = 1
  WH_JOURNALRECORD* = 0
  WH_KEYBOARD* = 2
  WH_MOUSE* = 7
  WH_MSGFILTER* = -1
  WH_SHELL* = 10
  WH_SYSMSGFILTER* = 6
  WH_FOREGROUNDIDLE* = 11
  # DefineDosDevice
  DDD_RAW_TARGET_PATH* = 1
  DDD_REMOVE_DEFINITION* = 2
  DDD_EXACT_MATCH_ON_REMOVE* = 4
  # DeviceCapbilities
  DCTT_BITMAP* = 0x00000001
  DCTT_DOWNLOAD* = 0x00000002
  DCTT_SUBDEV* = 0x00000004
                              # DlgDirList
  DDL_ARCHIVE* = 32
  DDL_DIRECTORY* = 16
  DDL_DRIVES* = 16384
  DDL_EXCLUSIVE* = 32768
  DDL_HIDDEN* = 2
  DDL_READONLY* = 1
  DDL_READWRITE* = 0
  DDL_SYSTEM* = 4
  DDL_POSTMSGS* = 8192
  # DllEntryPoint
  DLL_PROCESS_ATTACH* = 1
  DLL_THREAD_ATTACH* = 2
  DLL_PROCESS_DETACH* = 0
  DLL_THREAD_DETACH* = 3
  # DrawAnimatedRects
  IDANI_OPEN* = 1
  IDANI_CLOSE* = 2
  # DrawCaption
  DC_ACTIVE* = 1
  DC_SMALLCAP* = 2
  # DrawEdge
  BDR_RAISEDINNER* = 4
  BDR_SUNKENINNER* = 8
  BDR_RAISEDOUTER* = 1
  BDR_SUNKENOUTER* = 2
  BDR_OUTER* = BDR_RAISEDOUTER or BDR_SUNKENOUTER
  BDR_INNER* = BDR_RAISEDINNER or BDR_SUNKENINNER
  BDR_RAISED* = BDR_RAISEDOUTER or BDR_RAISEDINNER
  BDR_SUNKEN* = BDR_SUNKENOUTER or BDR_SUNKENINNER
  EDGE_BUMP* = 9
  EDGE_ETCHED* = 6
  EDGE_RAISED* = 5
  EDGE_SUNKEN* = 10
  BF_ADJUST* = 8192
  BF_BOTTOM* = 8
  BF_BOTTOMLEFT* = 9
  BF_BOTTOMRIGHT* = 12
  BF_DIAGONAL* = 16
  BF_DIAGONAL_ENDBOTTOMLEFT* = 25
  BF_DIAGONAL_ENDBOTTOMRIGHT* = 28
  BF_DIAGONAL_ENDTOPLEFT* = 19
  BF_DIAGONAL_ENDTOPRIGHT* = 22
  BF_FLAT* = 16384
  BF_LEFT* = 1
  BF_MIDDLE* = 2048
  BF_MONO* = 32768
  BF_RECT* = 15
  BF_RIGHT* = 4
  BF_SOFT* = 4096
  BF_TOP* = 2
  BF_TOPLEFT* = 3
  BF_TOPRIGHT* = 6
  # DrawFrameControl
  DFC_BUTTON* = 4
  DFC_CAPTION* = 1
  DFC_MENU* = 2
  DFC_SCROLL* = 3
  DFCS_BUTTON3STATE* = 8
  DFCS_BUTTONCHECK* = 0
  DFCS_BUTTONPUSH* = 16
  DFCS_BUTTONRADIO* = 4
  DFCS_BUTTONRADIOIMAGE* = 1
  DFCS_BUTTONRADIOMASK* = 2
  DFCS_CAPTIONCLOSE* = 0
  DFCS_CAPTIONHELP* = 4
  DFCS_CAPTIONMAX* = 2
  DFCS_CAPTIONMIN* = 1
  DFCS_CAPTIONRESTORE* = 3
  DFCS_MENUARROW* = 0
  DFCS_MENUBULLET* = 2
  DFCS_MENUCHECK* = 1
  DFCS_SCROLLCOMBOBOX* = 5
  DFCS_SCROLLDOWN* = 1
  DFCS_SCROLLLEFT* = 2
  DFCS_SCROLLRIGHT* = 3
  DFCS_SCROLLSIZEGRIP* = 8
  DFCS_SCROLLUP* = 0
  DFCS_ADJUSTRECT* = 8192
  DFCS_CHECKED* = 1024
  DFCS_FLAT* = 16384
  DFCS_INACTIVE* = 256
  DFCS_MONO* = 32768
  DFCS_PUSHED* = 512
  # DrawIconEx
  DI_COMPAT* = 4
  DI_DEFAULTSIZE* = 8
  DI_IMAGE* = 2
  DI_MASK* = 1
  DI_NORMAL* = 3
  # DrawState
  DST_BITMAP* = 4
  DST_COMPLEX* = 0
  DST_ICON* = 3
  DST_PREFIXTEXT* = 2
  DST_TEXT* = 1
  DSS_NORMAL* = 0
  DSS_UNION* = 16
  DSS_DISABLED* = 32
  DSS_MONO* = 128
  # DrawStatusText
  SBT_NOBORDERS* = 256
  SBT_OWNERDRAW* = 4096
  SBT_POPOUT* = 512
  SBT_RTLREADING* = 1024
  # DrawText, DrawTextEx
  DT_BOTTOM* = 8
  DT_CALCRECT* = 1024
  DT_CENTER* = 1
  DT_EDITCONTROL* = 8192
  DT_END_ELLIPSIS* = 32768
  DT_PATH_ELLIPSIS* = 16384
  DT_EXPANDTABS* = 64
  DT_EXTERNALLEADING* = 512
  DT_LEFT* = 0
  DT_MODIFYSTRING* = 65536
  DT_NOCLIP* = 256
  DT_NOPREFIX* = 2048
  DT_RIGHT* = 2
  DT_RTLREADING* = 131072
  DT_SINGLELINE* = 32
  DT_TABSTOP* = 128
  DT_TOP* = 0
  DT_VCENTER* = 4
  DT_WORDBREAK* = 16
  DT_INTERNAL* = 4096
  DT_WORD_ELLIPSIS* = 0x00040000
  DT_HIDEPREFIX* = 0x00100000
  DT_PREFIXONLY* = 0x00200000
  # DuplicateHandle, MapViewOfFile
  DUPLICATE_CLOSE_SOURCE* = 1
  DUPLICATE_SAME_ACCESS* = 2
  FILE_MAP_ALL_ACCESS* = 0x000F001F
  FILE_MAP_READ* = 4
  FILE_MAP_WRITE* = 2
  FILE_MAP_COPY* = 1
  MUTEX_ALL_ACCESS* = 0x001F0001
  MUTEX_MODIFY_STATE* = 1
  SYNCHRONIZE* = 0x00100000
  SEMAPHORE_ALL_ACCESS* = 0x001F0003
  SEMAPHORE_MODIFY_STATE* = 2
  EVENT_ALL_ACCESS* = 0x001F0003
  EVENT_MODIFY_STATE* = 2
  KEY_ALL_ACCESS* = 0x000F003F
  KEY_CREATE_LINK* = 32
  KEY_CREATE_SUB_KEY* = 4
  KEY_ENUMERATE_SUB_KEYS* = 8
  KEY_EXECUTE* = 0x00020019
  KEY_NOTIFY* = 16
  KEY_QUERY_VALUE* = 1
  KEY_READ* = 0x00020019
  KEY_SET_VALUE* = 2
  KEY_WRITE* = 0x00020006
  PROCESS_ALL_ACCESS* = 0x001F0FFF
  PROCESS_CREATE_PROCESS* = 128
  PROCESS_CREATE_THREAD* = 2
  PROCESS_DUP_HANDLE* = 64
  PROCESS_QUERY_INFORMATION* = 1024
  PROCESS_SET_INFORMATION* = 512
  PROCESS_TERMINATE* = 1
  PROCESS_VM_OPERATION* = 8
  PROCESS_VM_READ* = 16
  PROCESS_VM_WRITE* = 32
  THREAD_ALL_ACCESS* = 0x001F03FF
  THREAD_DIRECT_IMPERSONATION* = 512
  THREAD_GET_CONTEXT* = 8
  THREAD_IMPERSONATE* = 256
  THREAD_QUERY_INFORMATION* = 64
  THREAD_SET_CONTEXT* = 16
  THREAD_SET_INFORMATION* = 32
  THREAD_SET_THREAD_TOKEN* = 128
  THREAD_SUSPEND_RESUME* = 2
  THREAD_TERMINATE* = 1
  # EditWordBreakProc
  WB_ISDELIMITER* = 2
  WB_LEFT* = 0
  WB_RIGHT* = 1
  # EnableScrollBar
  SB_BOTH* = 3
  SB_CTL* = 2
  SB_HORZ* = 0
  SB_VERT* = 1
  ESB_DISABLE_BOTH* = 3
  ESB_DISABLE_DOWN* = 2
  ESB_DISABLE_LEFT* = 1
  ESB_DISABLE_LTUP* = 1
  ESB_DISABLE_RIGHT* = 2
  ESB_DISABLE_RTDN* = 2
  ESB_DISABLE_UP* = 1
  ESB_ENABLE_BOTH* = 0
  # Scroll Bar notifications
  SB_LINEUP* = 0
  SB_LINEDOWN* = 1
  SB_LINELEFT* = 0
  SB_LINERIGHT* = 1
  SB_PAGEUP* = 2
  SB_PAGEDOWN* = 3
  SB_PAGELEFT* = 2
  SB_PAGERIGHT* = 3
  SB_THUMBPOSITION* = 4
  SB_THUMBTRACK* = 5
  SB_ENDSCROLL* = 8
  SB_LEFT* = 6
  SB_RIGHT* = 7
  SB_BOTTOM* = 7
  SB_TOP* = 6
  # EnumCalendarInfo
  ENUM_ALL_CALENDARS* = -1
  # EnumDateFormats
  # GetDateFormat
  DATE_SHORTDATE* = 1
  DATE_LONGDATE* = 2
  DATE_USE_ALT_CALENDAR* = 4
  # EnumDependentServices
  SERVICE_ACTIVE* = 1
  SERVICE_INACTIVE* = 2
  # EnumFontFamExProc
  DEVICE_FONTTYPE* = 2
  RASTER_FONTTYPE* = 1
  TRUETYPE_FONTTYPE* = 4
  # EnumObjects, GetCurrentObject, GetObjectType
  OBJ_BRUSH* = 2
  OBJ_PEN* = 1
  OBJ_PAL* = 5
  OBJ_FONT* = 6
  OBJ_BITMAP* = 7
  OBJ_EXTPEN* = 11
  OBJ_REGION* = 8
  OBJ_DC* = 3
  OBJ_MEMDC* = 10
  OBJ_METAFILE* = 9
  OBJ_METADC* = 4
  OBJ_ENHMETAFILE* = 13
  OBJ_ENHMETADC* = 12

                              #
                              # Predefined Resource Types
                              #
const
  RT_CURSOR* = cast[MAKEINTRESOURCE](1)
  RT_BITMAP* = cast[MAKEINTRESOURCE](2)
  RT_ICON* = cast[MAKEINTRESOURCE](3)
  RT_MENU* = cast[MAKEINTRESOURCE](4)
  RT_DIALOG* = cast[MAKEINTRESOURCE](5)
  RT_STRING* = cast[MAKEINTRESOURCE](6)
  RT_FONTDIR* = cast[MAKEINTRESOURCE](7)
  RT_FONT* = cast[MAKEINTRESOURCE](8)
  RT_ACCELERATOR* = cast[MAKEINTRESOURCE](9)
  RT_RCDATA* = cast[MAKEINTRESOURCE](10)
  RT_MESSAGETABLE* = cast[MAKEINTRESOURCE](11)
  DIFFERENCE* = 11
  RT_GROUP_CURSOR* = cast[MAKEINTRESOURCE](12)
  RT_GROUP_ICON* = cast[MAKEINTRESOURCE](14)
  RT_VERSION* = cast[MAKEINTRESOURCE](16)
  RT_DLGINCLUDE* = cast[MAKEINTRESOURCE](17)
  RT_PLUGPLAY* = cast[MAKEINTRESOURCE](19)
  RT_VXD* = cast[MAKEINTRESOURCE](20)
  RT_ANICURSOR* = cast[MAKEINTRESOURCE](21)
  RT_ANIICON* = cast[MAKEINTRESOURCE](22)
  RT_HTML* = cast[MAKEINTRESOURCE](23)
  RT_MANIFEST* = cast[MAKEINTRESOURCE](24)

const
  # EnumServicesStatus
  SERVICE_WIN32* = 48
  SERVICE_DRIVER* = 11
  # EnumSystemCodePages
  CP_INSTALLED* = 1
  CP_SUPPORTED* = 2
  # EnumSystemLocales
  LCID_INSTALLED* = 1
  LCID_SUPPORTED* = 2
  # EraseTape
  TAPE_ERASE_LONG* = 0x00000001
  TAPE_ERASE_SHORT* = 0
  # Escape
  SP_ERROR* = -1
  SP_OUTOFDISK* = -4
  SP_OUTOFMEMORY* = -5
  SP_USERABORT* = -3
  PHYSICALWIDTH* = 110
  PHYSICALHEIGHT* = 111
  PHYSICALOFFSETX* = 112
  PHYSICALOFFSETY* = 113
  SCALINGFACTORX* = 114
  SCALINGFACTORY* = 115
  QUERYESCSUPPORT* = 8
  #ABORTDOC = 2; conflicts with AbortDoc function
  cABORTDOC* = 2
  #ENDDOC = 11; conflicts with AbortDoc function
  cENDDOC* = 11
  GETPHYSPAGESIZE* = 12
  GETPRINTINGOFFSET* = 13
  GETSCALINGFACTOR* = 14
  NEWFRAME* = 1
  NEXTBAND* = 3
  PASSTHROUGH* = 19
  #SETABORTPROC = 9; conflicts with AbortDoc function
  cSETABORTPROC* = 9
  #STARTDOC = 10; conflicts with AbortDoc function
  cSTARTDOC* = 10
  # EscapeCommFunction
  CLRDTR* = 6
  CLRRTS* = 4
  SETDTR* = 5
  SETRTS* = 3
  SETXOFF* = 1
  SETXON* = 2
  SETBREAK* = 8
  CLRBREAK* = 9
  # ExitWindowsEx
  EWX_FORCE* = 4
  EWX_LOGOFF* = 0
  EWX_POWEROFF* = 8
  EWX_REBOOT* = 2
  EWX_SHUTDOWN* = 1
  # ExtFloodFill
  FLOODFILLBORDER* = 0
  FLOODFILLSURFACE* = 1
  # ExtTextOut
  ETO_CLIPPED* = 4
  ETO_GLYPH_INDEX* = 16
  ETO_OPAQUE* = 2
  ETO_RTLREADING* = 128
  # FillConsoleOutputAttribute
  FOREGROUND_BLUE* = 1
  FOREGROUND_GREEN* = 2
  FOREGROUND_RED* = 4
  FOREGROUND_INTENSITY* = 8
  BACKGROUND_BLUE* = 16
  BACKGROUND_GREEN* = 32
  BACKGROUND_RED* = 64
  BACKGROUND_INTENSITY* = 128
  # FindFirstChangeNotification
  FILE_NOTIFY_CHANGE_FILE_NAME* = 1
  FILE_NOTIFY_CHANGE_DIR_NAME* = 2
  FILE_NOTIFY_CHANGE_ATTRIBUTES* = 4
  FILE_NOTIFY_CHANGE_SIZE* = 8
  FILE_NOTIFY_CHANGE_LAST_WRITE* = 16
  FILE_NOTIFY_CHANGE_SECURITY* = 256
  # FindFirstPrinterChangeNotification
  # FindNextPrinterNotification
  # FMExtensionProc
  # FoldString
  MAP_FOLDCZONE* = 16
  MAP_FOLDDIGITS* = 128
  MAP_PRECOMPOSED* = 32
  MAP_COMPOSITE* = 64
  # ForegroundIdleProc
  HC_ACTION* = 0
  # FormatMessage
  FORMAT_MESSAGE_ALLOCATE_BUFFER* = 256
  FORMAT_MESSAGE_IGNORE_INSERTS* = 512
  FORMAT_MESSAGE_FROM_STRING* = 1024
  FORMAT_MESSAGE_FROM_HMODULE* = 2048
  FORMAT_MESSAGE_FROM_SYSTEM* = 4096
  FORMAT_MESSAGE_ARGUMENT_ARRAY* = 8192
  FORMAT_MESSAGE_MAX_WIDTH_MASK* = 255
  # GdiComment
  GDICOMMENT_WINDOWS_METAFILE* = -2147483647
  GDICOMMENT_BEGINGROUP* = 2
  GDICOMMENT_ENDGROUP* = 3
  GDICOMMENT_MULTIFORMATS* = 1073741828
  GDICOMMENT_IDENTIFIER* = 1128875079
  # GenerateConsoleCtrlEvent, HandlerRoutine
  CTRL_C_EVENT* = 0
  CTRL_BREAK_EVENT* = 1
  CTRL_CLOSE_EVENT* = 2
  CTRL_LOGOFF_EVENT* = 5
  CTRL_SHUTDOWN_EVENT* = 6
  # GetAddressByName
  # GetArcDirection
  AD_COUNTERCLOCKWISE* = 1
  AD_CLOCKWISE* = 2
  # GetBinaryTypes
  SCS_32BIT_BINARY* = 0
  SCS_DOS_BINARY* = 1
  SCS_OS216_BINARY* = 5
  SCS_PIF_BINARY* = 3
  SCS_POSIX_BINARY* = 4
  SCS_WOW_BINARY* = 2
  # GetBoundsRect, SetBoundsRect
  DCB_DISABLE* = 8
  DCB_ENABLE* = 4
  DCB_RESET* = 1
  DCB_SET* = 3
  DCB_ACCUMULATE* = 2
  # GetCharacterPlacement, GetFontLanguageInfo
  GCP_DBCS* = 1
  GCP_ERROR* = 0x00008000
  GCP_CLASSIN* = 0x00080000
  GCP_DIACRITIC* = 256
  GCP_DISPLAYZWG* = 0x00400000
  GCP_GLYPHSHAPE* = 16
  GCP_JUSTIFY* = 0x00010000
  GCP_JUSTIFYIN* = 0x00200000
  GCP_KASHIDA* = 1024
  GCP_LIGATE* = 32
  GCP_MAXEXTENT* = 0x00100000
  GCP_NEUTRALOVERRIDE* = 0x02000000
  GCP_NUMERICOVERRIDE* = 0x01000000
  GCP_NUMERICSLATIN* = 0x04000000
  GCP_NUMERICSLOCAL* = 0x08000000
  GCP_REORDER* = 2
  GCP_SYMSWAPOFF* = 0x00800000
  GCP_USEKERNING* = 8
  FLI_GLYPHS* = 0x00040000
  FLI_MASK* = 0x0000103B
  # GetClassLong, GetClassWord
  GCW_ATOM* = -32
  GCL_CBCLSEXTRA* = -20
  GCL_CBWNDEXTRA* = -18
  GCL_HBRBACKGROUND* = -10
  GCL_HCURSOR* = -12
  GCL_HICON* = -14
  GCL_HICONSM* = -34
  GCL_HMODULE* = -16
  GCL_MENUNAME* = -8
  GCL_STYLE* = -26
  GCL_WNDPROC* = -24
  # GetClipboardFormat, SetClipboardData
  CF_BITMAP* = 2
  CF_DIB* = 8
  CF_PALETTE* = 9
  CF_ENHMETAFILE* = 14
  CF_METAFILEPICT* = 3
  CF_OEMTEXT* = 7
  CF_TEXT* = 1
  CF_UNICODETEXT* = 13
  CF_DIF* = 5
  CF_DSPBITMAP* = 130
  CF_DSPENHMETAFILE* = 142
  CF_DSPMETAFILEPICT* = 131
  CF_DSPTEXT* = 129
  CF_GDIOBJFIRST* = 768
  CF_GDIOBJLAST* = 1023
  CF_HDROP* = 15
  CF_LOCALE* = 16
  CF_OWNERDISPLAY* = 128
  CF_PENDATA* = 10
  CF_PRIVATEFIRST* = 512
  CF_PRIVATELAST* = 767
  CF_RIFF* = 11
  CF_SYLK* = 4
  CF_WAVE* = 12
  CF_TIFF* = 6
  # GetCommMask
  EV_BREAK* = 64
  EV_CTS* = 8
  EV_DSR* = 16
  EV_ERR* = 128
  EV_EVENT1* = 2048
  EV_EVENT2* = 4096
  EV_PERR* = 512
  EV_RING* = 256
  EV_RLSD* = 32
  EV_RX80FULL* = 1024
  EV_RXCHAR* = 1
  EV_RXFLAG* = 2
  EV_TXEMPTY* = 4
  # GetCommModemStatus
  MS_CTS_ON* = 0x00000010
  MS_DSR_ON* = 0x00000020
  MS_RING_ON* = 0x00000040
  MS_RLSD_ON* = 0x00000080
  # GetComputerName
  MAX_COMPUTERNAME_LENGTH* = 15
  # GetConsoleMode
  ENABLE_LINE_INPUT* = 2
  ENABLE_ECHO_INPUT* = 4
  ENABLE_PROCESSED_INPUT* = 1
  ENABLE_WINDOW_INPUT* = 8
  ENABLE_MOUSE_INPUT* = 16
  ENABLE_PROCESSED_OUTPUT* = 1
  ENABLE_WRAP_AT_EOL_OUTPUT* = 2
  # GetCPInfo
  CP_ACP* = 0
  CP_MACCP* = 2
  CP_OEMCP* = 1
  # GetDCEx
  DCX_WINDOW* = 0x00000001
  DCX_CACHE* = 0x00000002
  DCX_PARENTCLIP* = 0x00000020
  DCX_CLIPSIBLINGS* = 0x00000010
  DCX_CLIPCHILDREN* = 0x00000008
  DCX_NORESETATTRS* = 0x00000004
  DCX_LOCKWINDOWUPDATE* = 0x00000400
  DCX_EXCLUDERGN* = 0x00000040
  DCX_INTERSECTRGN* = 0x00000080
  DCX_VALIDATE* = 0x00200000
  # GetDeviceCaps
  DRIVERVERSION* = 0
  TECHNOLOGY* = 2
  DT_PLOTTER* = 0
  DT_RASDISPLAY* = 1
  DT_RASPRINTER* = 2
  DT_RASCAMERA* = 3
  DT_CHARSTREAM* = 4
  DT_METAFILE* = 5
  DT_DISPFILE* = 6
  HORZSIZE* = 4
  VERTSIZE* = 6
  HORZRES* = 8
  VERTRES* = 10
  LOGPIXELSX* = 88
  LOGPIXELSY* = 90
  BITSPIXEL* = 12
  PLANES* = 14
  NUMBRUSHES* = 16
  NUMPENS* = 18
  NUMFONTS* = 22
  NUMCOLORS* = 24
  ASPECTX* = 40
  ASPECTY* = 42
  ASPECTXY* = 44
  PDEVICESIZE* = 26
  CLIPCAPS* = 36
  SIZEPALETTE* = 104
  NUMRESERVED* = 106
  COLORRES* = 108
  VREFRESH* = 116
  DESKTOPHORZRES* = 118
  DESKTOPVERTRES* = 117
  BLTALIGNMENT* = 119
  RASTERCAPS* = 38
  RC_BANDING* = 2
  RC_BITBLT* = 1
  RC_BITMAP64* = 8
  RC_DI_BITMAP* = 128
  RC_DIBTODEV* = 512
  RC_FLOODFILL* = 4096
  RC_GDI20_OUTPUT* = 16
  RC_PALETTE* = 256
  RC_SCALING* = 4
  RC_STRETCHBLT* = 2048
  RC_STRETCHDIB* = 8192
  CURVECAPS* = 28
  CC_NONE* = 0
  CC_CIRCLES* = 1
  CC_PIE* = 2
  CC_CHORD* = 4
  CC_ELLIPSES* = 8
  CC_WIDE* = 16
  CC_STYLED* = 32
  CC_WIDESTYLED* = 64
  CC_INTERIORS* = 128
  CC_ROUNDRECT* = 256
  LINECAPS* = 30
  LC_NONE* = 0
  LC_POLYLINE* = 2
  LC_MARKER* = 4
  LC_POLYMARKER* = 8
  LC_WIDE* = 16
  LC_STYLED* = 32
  LC_WIDESTYLED* = 64
  LC_INTERIORS* = 128
  POLYGONALCAPS* = 32
  PC_NONE* = 0
  PC_POLYGON* = 1
  PC_RECTANGLE* = 2
  PC_WINDPOLYGON* = 4
  PC_SCANLINE* = 8
  PC_WIDE* = 16
  PC_STYLED* = 32
  PC_WIDESTYLED* = 64
  PC_INTERIORS* = 128
  TEXTCAPS* = 34
  TC_OP_CHARACTER* = 1
  TC_OP_STROKE* = 2
  TC_CP_STROKE* = 4
  TC_CR_90* = 8
  TC_CR_ANY* = 16
  TC_SF_X_YINDEP* = 32
  TC_SA_DOUBLE* = 64
  TC_SA_INTEGER* = 128
  TC_SA_CONTIN* = 256
  TC_EA_DOUBLE* = 512
  TC_IA_ABLE* = 1024
  TC_UA_ABLE* = 2048
  TC_SO_ABLE* = 4096
  TC_RA_ABLE* = 8192
  TC_VA_ABLE* = 16384
  TC_RESERVED* = 32768
  TC_SCROLLBLT* = 65536
  PC_PATHS* = 512
  # GetDriveType
  DRIVE_REMOVABLE* = 2
  DRIVE_FIXED* = 3
  DRIVE_REMOTE* = 4
  DRIVE_CDROM* = 5
  DRIVE_RAMDISK* = 6
  DRIVE_UNKNOWN* = 0
  DRIVE_NO_ROOT_DIR* = 1
  # GetExceptionCode
  EXCEPTION_ACCESS_VIOLATION* = 0xC0000005
  EXCEPTION_BREAKPOINT* = 0x80000003
  EXCEPTION_DATATYPE_MISALIGNMENT* = 0x80000002
  EXCEPTION_SINGLE_STEP* = 0x80000004
  EXCEPTION_ARRAY_BOUNDS_EXCEEDED* = 0xC000008C
  EXCEPTION_FLT_DENORMAL_OPERAND* = 0xC000008D
  EXCEPTION_FLT_DIVIDE_BY_ZERO* = 0xC000008E
  EXCEPTION_FLT_INEXACT_RESULT* = 0xC000008F
  EXCEPTION_FLT_INVALID_OPERATION* = 0xC0000090
  EXCEPTION_FLT_OVERFLOW* = 0xC0000091
  EXCEPTION_FLT_STACK_CHECK* = 0xC0000092
  EXCEPTION_FLT_UNDERFLOW* = 0xC0000093
  EXCEPTION_INT_DIVIDE_BY_ZERO* = 0xC0000094
  EXCEPTION_INT_OVERFLOW* = 0xC0000095
  EXCEPTION_INVALID_HANDLE* = 0xC0000008
  EXCEPTION_PRIV_INSTRUCTION* = 0xC0000096
  EXCEPTION_NONCONTINUABLE_EXCEPTION* = 0xC0000025
  EXCEPTION_NONCONTINUABLE* = 0x00000001
  EXCEPTION_STACK_OVERFLOW* = 0xC00000FD
  EXCEPTION_INVALID_DISPOSITION* = 0xC0000026
  EXCEPTION_IN_PAGE_ERROR* = 0xC0000006
  EXCEPTION_ILLEGAL_INSTRUCTION* = 0xC000001D
  EXCEPTION_POSSIBLE_DEADLOCK* = 0xC0000194
  # GetFileType
  FILE_TYPE_UNKNOWN* = 0
  FILE_TYPE_DISK* = 1
  FILE_TYPE_CHAR* = 2
  FILE_TYPE_PIPE* = 3
  # GetGlyphOutline
  GGO_BITMAP* = 1
  GGO_NATIVE* = 2
  GGO_METRICS* = 0
  GGO_GRAY2_BITMAP* = 4
  GGO_GRAY4_BITMAP* = 5
  GGO_GRAY8_BITMAP* = 6
  GDI_ERROR* = 0xFFFFFFFF
  # GetGraphicsMode
  GM_COMPATIBLE* = 1
  GM_ADVANCED* = 2
  # GetHandleInformation
  HANDLE_FLAG_INHERIT* = 1
  HANDLE_FLAG_PROTECT_FROM_CLOSE* = 2
  # GetIconInfo
  IDC_ARROW* =       cast[MAKEINTRESOURCE](32512)
  IDC_IBEAM* =       cast[MAKEINTRESOURCE](32513)
  IDC_WAIT* =        cast[MAKEINTRESOURCE](32514)
  IDC_CROSS* =       cast[MAKEINTRESOURCE](32515)
  IDC_UPARROW* =     cast[MAKEINTRESOURCE](32516)
  IDC_SIZE* =        cast[MAKEINTRESOURCE](32640)  # OBSOLETE: use IDC_SIZEALL
  IDC_ICON* =        cast[MAKEINTRESOURCE](32641)  # OBSOLETE: use IDC_ARROW
  IDC_SIZENWSE* =    cast[MAKEINTRESOURCE](32642)
  IDC_SIZENESW* =    cast[MAKEINTRESOURCE](32643)
  IDC_SIZEWE* =      cast[MAKEINTRESOURCE](32644)
  IDC_SIZENS* =      cast[MAKEINTRESOURCE](32645)
  IDC_SIZEALL* =     cast[MAKEINTRESOURCE](32646)
  IDC_NO* =          cast[MAKEINTRESOURCE](32648)
  IDC_HAND* =        cast[MAKEINTRESOURCE](32649)
  IDC_APPSTARTING* = cast[MAKEINTRESOURCE](32650)
  IDC_HELP* =        cast[MAKEINTRESOURCE](32651)

  IDI_APPLICATION* = cast[MAKEINTRESOURCE](32512)
  IDI_HAND* =        cast[MAKEINTRESOURCE](32513)
  IDI_QUESTION* =    cast[MAKEINTRESOURCE](32514)
  IDI_EXCLAMATION* = cast[MAKEINTRESOURCE](32515)
  IDI_ASTERISK* =    cast[MAKEINTRESOURCE](32516)
  IDI_WINLOGO* =     cast[MAKEINTRESOURCE](32517)
  IDI_WARNING* =     IDI_EXCLAMATION
  IDI_ERROR* =       IDI_HAND
  IDI_INFORMATION* = IDI_ASTERISK

const
  # GetMapMode
  MM_ANISOTROPIC* = 8
  MM_HIENGLISH* = 5
  MM_HIMETRIC* = 3
  MM_ISOTROPIC* = 7
  MM_LOENGLISH* = 4
  MM_LOMETRIC* = 2
  MM_TEXT* = 1
  MM_TWIPS* = 6
  # GetMenuDefaultItem
  GMDI_GOINTOPOPUPS* = 0x00000002
  GMDI_USEDISABLED* = 0x00000001
  # PeekMessage
  PM_NOREMOVE* = 0
  PM_REMOVE* = 1
  PM_NOYIELD* = 2
  # GetNamedPipeHandleState
  #   PIPE_NOWAIT = 1; already above
  #   PIPE_READMODE_MESSAGE = 2;already above
  # GetNamedPipeInfo
  PIPE_CLIENT_END* = 0
  PIPE_SERVER_END* = 1
  #   PIPE_TYPE_MESSAGE = 4;already above
  # GetNextWindow, GetWindow
  GW_HWNDNEXT* = 2
  GW_HWNDPREV* = 3
  GW_CHILD* = 5
  GW_HWNDFIRST* = 0
  GW_HWNDLAST* = 1
  GW_OWNER* = 4
  # GetPath
  PT_MOVETO* = 6
  PT_LINETO* = 2
  PT_BEZIERTO* = 4
  PT_CLOSEFIGURE* = 1
  # GetProcessShutdownParameters
  SHUTDOWN_NORETRY* = 1
  # GetQueueStatus
  QS_ALLEVENTS* = 191
  QS_ALLINPUT* = 255
  QS_HOTKEY* = 128
  QS_INPUT* = 7
  QS_KEY* = 1
  QS_MOUSE* = 6
  QS_MOUSEBUTTON* = 4
  QS_MOUSEMOVE* = 2
  QS_PAINT* = 32
  QS_POSTMESSAGE* = 8
  QS_SENDMESSAGE* = 64
  QS_TIMER* = 16
  # GetScrollInfo, SetScrollInfo
  SIF_ALL* = 23
  SIF_PAGE* = 2
  SIF_POS* = 4
  SIF_RANGE* = 1
  SIF_DISABLENOSCROLL* = 8

  # GetStdHandle
  STD_INPUT_HANDLE* =  DWORD(-10)
  STD_OUTPUT_HANDLE* = DWORD(-11)
  STD_ERROR_HANDLE* =  DWORD(-12)

  INVALID_HANDLE_VALUE* = HANDLE(-1)
  INVALID_SET_FILE_POINTER* = ULONG(-1)
  INVALID_FILE_SIZE* = ULONG(-1)
  INVALID_FILE_ATTRIBUTES* = ULONG(-1)

const
  # GetStockObject
  BLACK_BRUSH* = 4
  DKGRAY_BRUSH* = 3
  GRAY_BRUSH* = 2
  HOLLOW_BRUSH* = 5
  LTGRAY_BRUSH* = 1
  NULL_BRUSH* = 5
  WHITE_BRUSH* = 0
  BLACK_PEN* = 7
  NULL_PEN* = 8
  WHITE_PEN* = 6
  ANSI_FIXED_FONT* = 11
  ANSI_VAR_FONT* = 12
  DEVICE_DEFAULT_FONT* = 14
  DEFAULT_GUI_FONT* = 17
  OEM_FIXED_FONT* = 10
  SYSTEM_FONT* = 13
  SYSTEM_FIXED_FONT* = 16
  DEFAULT_PALETTE* = 15
  # GetStringTypeA
  CT_CTYPE1* = 1
  CT_CTYPE2* = 2
  CT_CTYPE3* = 4
  C1_UPPER* = 1
  C1_LOWER* = 2
  C1_DIGIT* = 4
  C1_SPACE* = 8
  C1_PUNCT* = 16
  C1_CNTRL* = 32
  C1_BLANK* = 64
  C1_XDIGIT* = 128
  C1_ALPHA* = 256
  C2_LEFTTORIGHT* = 1
  C2_RIGHTTOLEFT* = 2
  C2_EUROPENUMBER* = 3
  C2_EUROPESEPARATOR* = 4
  C2_EUROPETERMINATOR* = 5
  C2_ARABICNUMBER* = 6
  C2_COMMONSEPARATOR* = 7
  C2_BLOCKSEPARATOR* = 8
  C2_SEGMENTSEPARATOR* = 9
  C2_WHITESPACE* = 10
  C2_OTHERNEUTRAL* = 11
  C2_NOTAPPLICABLE* = 0
  C3_NONSPACING* = 1
  C3_DIACRITIC* = 2
  C3_VOWELMARK* = 4
  C3_SYMBOL* = 8
  C3_KATAKANA* = 16
  C3_HIRAGANA* = 32
  C3_HALFWIDTH* = 64
  C3_FULLWIDTH* = 128
  C3_IDEOGRAPH* = 256
  C3_KASHIDA* = 512
  C3_ALPHA* = 32768
  C3_NOTAPPLICABLE* = 0
  # GetSysColor
  COLOR_3DDKSHADOW* = 21
  COLOR_3DFACE* = 15
  COLOR_3DHILIGHT* = 20
  COLOR_3DLIGHT* = 22
  COLOR_BTNHILIGHT* = 20
  COLOR_3DSHADOW* = 16
  COLOR_ACTIVEBORDER* = 10
  COLOR_ACTIVECAPTION* = 2
  COLOR_APPWORKSPACE* = 12
  COLOR_BACKGROUND* = 1
  COLOR_DESKTOP* = 1
  COLOR_BTNFACE* = 15
  COLOR_BTNHIGHLIGHT* = 20
  COLOR_BTNSHADOW* = 16
  COLOR_BTNTEXT* = 18
  COLOR_CAPTIONTEXT* = 9
  COLOR_GRAYTEXT* = 17
  COLOR_HIGHLIGHT* = 13
  COLOR_HIGHLIGHTTEXT* = 14
  COLOR_INACTIVEBORDER* = 11
  COLOR_INACTIVECAPTION* = 3
  COLOR_INACTIVECAPTIONTEXT* = 19
  COLOR_INFOBK* = 24
  COLOR_INFOTEXT* = 23
  COLOR_MENU* = 4
  COLOR_MENUTEXT* = 7
  COLOR_SCROLLBAR* = 0
  COLOR_WINDOW* = 5
  COLOR_WINDOWFRAME* = 6
  COLOR_WINDOWTEXT* = 8
  # GetSystemMetrics
  SM_CYMIN* = 29
  SM_CXMIN* = 28
  SM_ARRANGE* = 56
  SM_CLEANBOOT* = 67
  # The right value for SM_CEMETRICS for NT 3.5 is 75.  For Windows 95
  #     and NT 4.0, it is 76.  The meaning is undocumented, anyhow.
  SM_CMETRICS* = 76
  SM_CMOUSEBUTTONS* = 43
  SM_CXBORDER* = 5
  SM_CYBORDER* = 6
  SM_CXCURSOR* = 13
  SM_CYCURSOR* = 14
  SM_CXDLGFRAME* = 7
  SM_CYDLGFRAME* = 8
  SM_CXDOUBLECLK* = 36
  SM_CYDOUBLECLK* = 37
  SM_CXDRAG* = 68
  SM_CYDRAG* = 69
  SM_CXEDGE* = 45
  SM_CYEDGE* = 46
  SM_CXFIXEDFRAME* = 7
  SM_CYFIXEDFRAME* = 8
  SM_CXFRAME* = 32
  SM_CYFRAME* = 33
  SM_CXFULLSCREEN* = 16
  SM_CYFULLSCREEN* = 17
  SM_CXHSCROLL* = 21
  SM_CYHSCROLL* = 3
  SM_CXHTHUMB* = 10
  SM_CXICON* = 11
  SM_CYICON* = 12
  SM_CXICONSPACING* = 38
  SM_CYICONSPACING* = 39
  SM_CXMAXIMIZED* = 61
  SM_CYMAXIMIZED* = 62
  SM_CXMAXTRACK* = 59
  SM_CYMAXTRACK* = 60
  SM_CXMENUCHECK* = 71
  SM_CYMENUCHECK* = 72
  SM_CXMENUSIZE* = 54
  SM_CYMENUSIZE* = 55
  SM_CXMINIMIZED* = 57
  SM_CYMINIMIZED* = 58
  SM_CXMINSPACING* = 47
  SM_CYMINSPACING* = 48
  SM_CXMINTRACK* = 34
  SM_CYMINTRACK* = 35
  SM_CXSCREEN* = 0
  SM_CYSCREEN* = 1
  SM_CXSIZE* = 30
  SM_CYSIZE* = 31
  SM_CXSIZEFRAME* = 32
  SM_CYSIZEFRAME* = 33
  SM_CXSMICON* = 49
  SM_CYSMICON* = 50
  SM_CXSMSIZE* = 52
  SM_CYSMSIZE* = 53
  SM_CXVSCROLL* = 2
  #SM_CYHSCROLL = 3;already above
  #SM_CXHSCROLL = 21;already above
  SM_CYVSCROLL* = 20
  SM_CYVTHUMB* = 9
  SM_CYCAPTION* = 4
  SM_CYKANJIWINDOW* = 18
  SM_CYMENU* = 15
  SM_CYSMCAPTION* = 51
  SM_DBCSENABLED* = 42
  SM_DEBUG* = 22
  SM_MENUDROPALIGNMENT* = 40
  SM_MIDEASTENABLED* = 74
  SM_MOUSEPRESENT* = 19
  SM_MOUSEWHEELPRESENT* = 75
  SM_NETWORK* = 63
  SM_PENWINDOWS* = 41
  SM_SECURE* = 44
  SM_SHOWSOUNDS* = 70
  SM_SLOWMACHINE* = 73
  SM_SWAPBUTTON* = 23
  ARW_BOTTOMLEFT* = 0
  ARW_BOTTOMRIGHT* = 0x00000001
  ARW_HIDE* = 0x00000008
  ARW_TOPLEFT* = 0x00000002
  ARW_TOPRIGHT* = 0x00000003
  ARW_DOWN* = 0x00000004
  ARW_LEFT* = 0
  ARW_RIGHT* = 0
  ARW_UP* = 0x00000004
  # GetSystemPaletteUse
  SYSPAL_NOSTATIC* = 2
  SYSPAL_STATIC* = 1
  SYSPAL_ERROR* = 0
  # GetTapeParameters, SetTapeParameters
  GET_TAPE_MEDIA_INFORMATION* = 0
  GET_TAPE_DRIVE_INFORMATION* = 1
  SET_TAPE_MEDIA_INFORMATION* = 0
  SET_TAPE_DRIVE_INFORMATION* = 1
  # GetTapePosition
  TAPE_ABSOLUTE_POSITION* = 0
  TAPE_LOGICAL_POSITION* = 0x00000001
  # GetTextAlign
  TA_BASELINE* = 24
  TA_BOTTOM* = 8
  TA_TOP* = 0
  TA_CENTER* = 6
  TA_LEFT* = 0
  TA_RIGHT* = 2
  TA_RTLREADING* = 256
  TA_NOUPDATECP* = 0
  TA_UPDATECP* = 1
  VTA_BASELINE* = 24
  VTA_CENTER* = 6
  # GetThreadPriority
  THREAD_PRIORITY_ABOVE_NORMAL* = 1
  THREAD_PRIORITY_BELOW_NORMAL* = -1
  THREAD_PRIORITY_HIGHEST* = 2
  THREAD_PRIORITY_IDLE* = -15
  THREAD_PRIORITY_LOWEST* = -2
  THREAD_PRIORITY_NORMAL* = 0
  THREAD_PRIORITY_TIME_CRITICAL* = 15
  THREAD_PRIORITY_ERROR_RETURN* = 2147483647
  TLS_MINIMUM_AVAILABLE* = 64
  # GetTimeFormat
  TIME_NOMINUTESORSECONDS* = 1
  TIME_NOSECONDS* = 2
  TIME_NOTIMEMARKER* = 4
  TIME_FORCE24HOURFORMAT* = 8

const
  # GetTimeZoneInformation
  TIME_ZONE_ID_INVALID* = DWORD(- 1)
  TIME_ZONE_ID_UNKNOWN* = 0
  TIME_ZONE_ID_STANDARD* = 1
  TIME_ZONE_ID_DAYLIGHT* = 2
  # GetUserObjectInformation
  UOI_FLAGS* = 1
  UOI_NAME* = 2
  UOI_TYPE* = 3
  # GetVolumeInformation
  FS_CASE_IS_PRESERVED* = 2
  FS_CASE_SENSITIVE* = 1
  FS_UNICODE_STORED_ON_DISK* = 4
  FS_PERSISTENT_ACLS* = 8
  FS_FILE_COMPRESSION* = 16
  FS_VOL_IS_COMPRESSED* = 32768
  # GetWindowLong
  GWL_EXSTYLE* = -20
  GWL_STYLE* = -16
  GWL_WNDPROC* = -4
  GWL_HINSTANCE* = -6
  GWL_HWNDPARENT* = -8
  GWL_ID* = -12
  GWL_USERDATA* = -21
  DWL_DLGPROC* = 4
  DWL_MSGRESULT* = 0
  DWL_USER* = 8
  # GlobalAlloc, GlobalFlags
  GMEM_FIXED* = 0
  GMEM_MOVEABLE* = 2
  GPTR* = 64
  GHND* = 66
  GMEM_DDESHARE* = 8192
  GMEM_DISCARDABLE* = 256
  GMEM_LOWER* = 4096
  GMEM_NOCOMPACT* = 16
  GMEM_NODISCARD* = 32
  GMEM_NOT_BANKED* = 4096
  GMEM_NOTIFY* = 16384
  GMEM_SHARE* = 8192
  GMEM_ZEROINIT* = 64
  GMEM_DISCARDED* = 16384
  GMEM_INVALID_HANDLE* = 32768
  GMEM_LOCKCOUNT* = 255
  # HeapAlloc, HeapReAlloc
  HEAP_GENERATE_EXCEPTIONS* = 4
  HEAP_NO_SERIALIZE* = 1
  HEAP_ZERO_MEMORY* = 8
  STATUS_NO_MEMORY* = 0xC0000017
  STATUS_ACCESS_VIOLATION* = 0xC0000005
  HEAP_REALLOC_IN_PLACE_ONLY* = 16
  # ImageList_Create
  ILC_COLOR* = 0
  ILC_COLOR4* = 4
  ILC_COLOR8* = 8
  ILC_COLOR16* = 16
  ILC_COLOR24* = 24
  ILC_COLOR32* = 32
  ILC_COLORDDB* = 254
  ILC_MASK* = 1
  ILC_PALETTE* = 2048
  # ImageList_Draw, ImageList_DrawEx
  ILD_BLEND25* = 2
  ILD_BLEND50* = 4
  ILD_SELECTED* = 4
  ILD_BLEND* = 4
  ILD_FOCUS* = 2
  ILD_MASK* = 16
  ILD_NORMAL* = 0
  ILD_TRANSPARENT* = 1
  CLR_NONE* = 0xFFFFFFFF
  CLR_DEFAULT* = 0xFF000000
  CLR_INVALID* = 0xFFFFFFFF
  # ImageList_LoadImage
  #LR_DEFAULTCOLOR = 0;already above
  LR_LOADFROMFILE* = 16
  LR_LOADMAP3DCOLORS* = 4096
  LR_LOADTRANSPARENT* = 32
  # ImmConfigureIME
  IME_CONFIG_GENERAL* = 1
  IME_CONFIG_REGISTERWORD* = 2
  IME_CONFIG_SELECTDICTIONARY* = 3
  # ImmGetConversionList
  GCL_CONVERSION* = 1
  GCL_REVERSECONVERSION* = 2
  GCL_REVERSE_LENGTH* = 3
  # ImmGetGuideLine
  GGL_LEVEL* = 1
  GGL_INDEX* = 2
  GGL_STRING* = 3
  GGL_PRIVATE* = 4
  GL_LEVEL_ERROR* = 2
  GL_LEVEL_FATAL* = 1
  GL_LEVEL_INFORMATION* = 4
  GL_LEVEL_NOGUIDELINE* = 0
  GL_LEVEL_WARNING* = 3
  GL_ID_CANNOTSAVE* = 17
  GL_ID_NOCONVERT* = 32
  GL_ID_NODICTIONARY* = 16
  GL_ID_NOMODULE* = 1
  GL_ID_READINGCONFLICT* = 35
  GL_ID_TOOMANYSTROKE* = 34
  GL_ID_TYPINGERROR* = 33
  GL_ID_UNKNOWN* = 0
  GL_ID_INPUTREADING* = 36
  GL_ID_INPUTRADICAL* = 37
  GL_ID_INPUTCODE* = 38
  GL_ID_CHOOSECANDIDATE* = 40
  GL_ID_REVERSECONVERSION* = 41
  # ImmGetProperty
  IGP_PROPERTY* = 4
  IGP_CONVERSION* = 8
  IGP_SENTENCE* = 12
  IGP_UI* = 16
  IGP_SETCOMPSTR* = 20
  IGP_SELECT* = 24
  IME_PROP_AT_CARET* = 65536
  IME_PROP_SPECIAL_UI* = 131072
  IME_PROP_CANDLIST_START_FROM_1* = 262144
  IME_PROP_UNICODE* = 524288
  UI_CAP_2700* = 1
  UI_CAP_ROT90* = 2
  UI_CAP_ROTANY* = 4
  SCS_CAP_COMPSTR* = 1
  SCS_CAP_MAKEREAD* = 2
  SELECT_CAP_CONVERSION* = 1
  SELECT_CAP_SENTENCE* = 2
  # ImmNotifyIME
  NI_CHANGECANDIDATELIST* = 19
  NI_CLOSECANDIDATE* = 17
  NI_COMPOSITIONSTR* = 21
  NI_OPENCANDIDATE* = 16
  NI_SELECTCANDIDATESTR* = 18
  NI_SETCANDIDATE_PAGESIZE* = 23
  NI_SETCANDIDATE_PAGESTART* = 22
  CPS_CANCEL* = 4
  CPS_COMPLETE* = 1
  CPS_CONVERT* = 2
  CPS_REVERT* = 3
  # ImmSetCompositionString
  SCS_SETSTR* = 9
  SCS_CHANGEATTR* = 18
  SCS_CHANGECLAUSE* = 36
  # ImmUnregisterWord
  IME_REGWORD_STYLE_EUDC* = 1
  IME_REGWORD_STYLE_USER_FIRST* = 0x80000000
  IME_REGWORD_STYLE_USER_LAST* = -1
  # InitializeSecurityDescriptor
  SECURITY_DESCRIPTOR_REVISION* = 1
  # IsTextUnicode
  IS_TEXT_UNICODE_ASCII16* = 1
  IS_TEXT_UNICODE_REVERSE_ASCII16* = 16
  IS_TEXT_UNICODE_STATISTICS* = 2
  IS_TEXT_UNICODE_REVERSE_STATISTICS* = 32
  IS_TEXT_UNICODE_CONTROLS* = 4
  IS_TEXT_UNICODE_REVERSE_CONTROLS* = 64
  IS_TEXT_UNICODE_SIGNATURE* = 8
  IS_TEXT_UNICODE_REVERSE_SIGNATURE* = 128
  IS_TEXT_UNICODE_ILLEGAL_CHARS* = 256
  IS_TEXT_UNICODE_ODD_LENGTH* = 512
  IS_TEXT_UNICODE_NULL_BYTES* = 4096
  IS_TEXT_UNICODE_UNICODE_MASK* = 15
  IS_TEXT_UNICODE_REVERSE_MASK* = 240
  IS_TEXT_UNICODE_NOT_UNICODE_MASK* = 3840
  IS_TEXT_UNICODE_NOT_ASCII_MASK* = 61440
  # JournalPlaybackProc, KeyboardProc
  HC_GETNEXT* = 1
  HC_SKIP* = 2
  HC_SYSMODALOFF* = 5
  HC_SYSMODALON* = 4
  HC_NOREMOVE* = 3
  # keybd_event
  KEYEVENTF_EXTENDEDKEY* = 1
  KEYEVENTF_KEYUP* = 2
  # LoadBitmap
  OBM_BTNCORNERS* = 32758
  OBM_BTSIZE* = 32761
  OBM_CHECK* = 32760
  OBM_CHECKBOXES* = 32759
  OBM_CLOSE* = 32754
  OBM_COMBO* = 32738
  OBM_DNARROW* = 32752
  OBM_DNARROWD* = 32742
  OBM_DNARROWI* = 32736
  OBM_LFARROW* = 32750
  OBM_LFARROWI* = 32734
  OBM_LFARROWD* = 32740
  OBM_MNARROW* = 32739
  OBM_OLD_CLOSE* = 32767
  OBM_OLD_DNARROW* = 32764
  OBM_OLD_LFARROW* = 32762
  OBM_OLD_REDUCE* = 32757
  OBM_OLD_RESTORE* = 32755
  OBM_OLD_RGARROW* = 32763
  OBM_OLD_UPARROW* = 32765
  OBM_OLD_ZOOM* = 32756
  OBM_REDUCE* = 32749
  OBM_REDUCED* = 32746
  OBM_RESTORE* = 32747
  OBM_RESTORED* = 32744
  OBM_RGARROW* = 32751
  OBM_RGARROWD* = 32741
  OBM_RGARROWI* = 32735
  OBM_SIZE* = 32766
  OBM_UPARROW* = 32753
  OBM_UPARROWD* = 32743
  OBM_UPARROWI* = 32737
  OBM_ZOOM* = 32748
  OBM_ZOOMD* = 32745
  # LoadLibraryEx
  DONT_RESOLVE_DLL_REFERENCES* = 1
  LOAD_LIBRARY_AS_DATAFILE* = 2
  LOAD_WITH_ALTERED_SEARCH_PATH* = 8
  # LocalAlloc, LocalFlags
  LPTR* = 64
  LHND* = 66
  NONZEROLHND* = 2
  NONZEROLPTR* = 0
  LMEM_NONZEROLHND* = 2
  LMEM_NONZEROLPTR* = 0
  LMEM_FIXED* = 0
  LMEM_MOVEABLE* = 2
  LMEM_NOCOMPACT* = 16
  LMEM_NODISCARD* = 32
  LMEM_ZEROINIT* = 64
  LMEM_MODIFY* = 128
  LMEM_LOCKCOUNT* = 255
  LMEM_DISCARDABLE* = 3840
  LMEM_DISCARDED* = 16384
  LMEM_INVALID_HANDLE* = 32768
  # LockFileEx
  LOCKFILE_FAIL_IMMEDIATELY* = 1
  LOCKFILE_EXCLUSIVE_LOCK* = 2
  # LogonUser
  # LZCopy, LZInit, LZRead
  # MessageBeep, MessageBox
  MB_USERICON* = 0x00000080
  MB_ICONASTERISK* = 0x00000040
  MB_ICONEXCLAMATION* = 0x00000030
  MB_ICONWARNING* = 0x00000030
  MB_ICONERROR* = 0x00000010
  MB_ICONHAND* = 0x00000010
  MB_ICONQUESTION* = 0x00000020
  MB_OK* = 0
  MB_ABORTRETRYIGNORE* = 0x00000002
  MB_APPLMODAL* = 0
  MB_DEFAULT_DESKTOP_ONLY* = 0x00020000
  MB_HELP* = 0x00004000
  MB_RIGHT* = 0x00080000
  MB_RTLREADING* = 0x00100000
  MB_TOPMOST* = 0x00040000
  MB_DEFBUTTON1* = 0
  MB_DEFBUTTON2* = 0x00000100
  MB_DEFBUTTON3* = 0x00000200
  MB_DEFBUTTON4* = 0x00000300
  MB_ICONINFORMATION* = 0x00000040
  MB_ICONSTOP* = 0x00000010
  MB_OKCANCEL* = 0x00000001
  MB_RETRYCANCEL* = 0x00000005
  MB_SERVICE_NOTIFICATION* = 0x00040000
  MB_SETFOREGROUND* = 0x00010000
  MB_SYSTEMMODAL* = 0x00001000
  MB_TASKMODAL* = 0x00002000
  MB_YESNO* = 0x00000004
  MB_YESNOCANCEL* = 0x00000003
  IDABORT* = 3
  IDCANCEL* = 2
  IDCLOSE* = 8
  IDHELP* = 9
  IDIGNORE* = 5
  IDNO* = 7
  IDOK* = 1
  IDRETRY* = 4
  IDYES* = 6
  # MessageProc
  MSGF_DIALOGBOX* = 0
  MSGF_MENU* = 2
  MSGF_NEXTWINDOW* = 6
  MSGF_SCROLLBAR* = 5
  MSGF_MAINLOOP* = 8
  MSGF_USER* = 4096
  # ModifyWorldTransform
  MWT_IDENTITY* = 1
  MWT_LEFTMULTIPLY* = 2
  MWT_RIGHTMULTIPLY* = 3
  # mouse_event
  MOUSEEVENTF_ABSOLUTE* = 32768
  MOUSEEVENTF_MOVE* = 1
  MOUSEEVENTF_LEFTDOWN* = 2
  MOUSEEVENTF_LEFTUP* = 4
  MOUSEEVENTF_RIGHTDOWN* = 8
  MOUSEEVENTF_RIGHTUP* = 16
  MOUSEEVENTF_MIDDLEDOWN* = 32
  MOUSEEVENTF_MIDDLEUP* = 64
  # MoveFileEx
  MOVEFILE_REPLACE_EXISTING* = 1
  MOVEFILE_COPY_ALLOWED* = 2
  MOVEFILE_DELAY_UNTIL_REBOOT* = 4
  # MsgWaitForMultipleObjects, WaitForMultipleObjectsEx
  WAIT_OBJECT_0* = 0
  WAIT_ABANDONED_0* = 0x00000080
  WAIT_TIMEOUT* = 0x00000102
  WAIT_IO_COMPLETION* = 0x000000C0
  WAIT_ABANDONED* = 0x00000080
  WAIT_FAILED* = 0xFFFFFFFF
  MAXIMUM_WAIT_OBJECTS* = 0x00000040
  MAXIMUM_SUSPEND_COUNT* = 0x0000007F
  # MultiByteToWideChar
  MB_PRECOMPOSED* = 1
  MB_COMPOSITE* = 2
  MB_ERR_INVALID_CHARS* = 8
  MB_USEGLYPHCHARS* = 4
  # NDdeSetTrustedShare
  # NetAccessCheck
  # NetServerEnum
  # NetServiceControl
  # NetUserEnum
  # OpenProcessToken
  TOKEN_ADJUST_DEFAULT* = 128
  TOKEN_ADJUST_GROUPS* = 64
  TOKEN_ADJUST_PRIVILEGES* = 32
  TOKEN_ALL_ACCESS* = 0x000F00FF
  TOKEN_ASSIGN_PRIMARY* = 1
  TOKEN_DUPLICATE* = 2
  TOKEN_EXECUTE* = 0x00020000
  TOKEN_IMPERSONATE* = 4
  TOKEN_QUERY* = 8
  TOKEN_QUERY_SOURCE* = 16
  TOKEN_READ* = 0x00020008
  TOKEN_WRITE* = 0x000200E0
  # OpenSCManager
  SC_MANAGER_ALL_ACCESS* = 0x000F003F
  SC_MANAGER_CONNECT* = 1
  SC_MANAGER_CREATE_SERVICE* = 2
  SC_MANAGER_ENUMERATE_SERVICE* = 4
  SC_MANAGER_LOCK* = 8
  SC_MANAGER_QUERY_LOCK_STATUS* = 16
  SC_MANAGER_MODIFY_BOOT_CONFIG* = 32
  # PostMessage
  HWND_BROADCAST* = HWND(0xffff)

const
  # PrepareTape
  TAPE_FORMAT* = 0x00000005
  TAPE_LOAD* = 0
  TAPE_LOCK* = 0x00000003
  TAPE_TENSION* = 0x00000002
  TAPE_UNLOAD* = 0x00000001
  TAPE_UNLOCK* = 0x00000004
  # PropertySheet
  IS_PSREBOOTSYSTEM* = 3
  IS_PSRESTARTWINDOWS* = 2
  # PropSheetPageProc
  PSPCB_CREATE* = 2
  PSPCB_RELEASE* = 1
  # PurgeComm
  PURGE_TXABORT* = 1
  PURGE_RXABORT* = 2
  PURGE_TXCLEAR* = 4
  PURGE_RXCLEAR* = 8
  # QueryServiceObjectSecurity
  OWNER_SECURITY_INFORMATION* = 0x00000001
  GROUP_SECURITY_INFORMATION* = 0x00000002
  DACL_SECURITY_INFORMATION* = 0x00000004
  SACL_SECURITY_INFORMATION* = 0x00000008
  # ReadEventLog, ReportEvent
  EVENTLOG_FORWARDS_READ* = 4
  EVENTLOG_BACKWARDS_READ* = 8
  EVENTLOG_SEEK_READ* = 2
  EVENTLOG_SEQUENTIAL_READ* = 1
  EVENTLOG_ERROR_TYPE* = 1
  EVENTLOG_WARNING_TYPE* = 2
  EVENTLOG_INFORMATION_TYPE* = 4
  EVENTLOG_AUDIT_SUCCESS* = 8

  EVENTLOG_AUDIT_FAILURE* = 16
  # RedrawWindow
  RDW_ERASE* = 4
  RDW_FRAME* = 1024
  RDW_INTERNALPAINT* = 2
  RDW_INVALIDATE* = 1
  RDW_NOERASE* = 32
  RDW_NOFRAME* = 2048
  RDW_NOINTERNALPAINT* = 16
  RDW_VALIDATE* = 8
  RDW_ERASENOW* = 512
  RDW_UPDATENOW* = 256
  RDW_ALLCHILDREN* = 128
  RDW_NOCHILDREN* = 64

  # RegCreateKey
  HKEY_CLASSES_ROOT* =     HKEY(0x80000000)
  HKEY_CURRENT_USER* =     HKEY(0x80000001)
  HKEY_LOCAL_MACHINE* =    HKEY(0x80000002)
  HKEY_USERS* =            HKEY(0x80000003)
  HKEY_PERFORMANCE_DATA* = HKEY(0x80000004)
  HKEY_CURRENT_CONFIG* =   HKEY(0x80000005)
  HKEY_DYN_DATA* =         HKEY(0x80000006)

const
  # RegCreateKeyEx
  REG_OPTION_VOLATILE* = 0x00000001
  REG_OPTION_NON_VOLATILE* = 0
  REG_CREATED_NEW_KEY* = 0x00000001
  REG_OPENED_EXISTING_KEY* = 0x00000002
  # RegEnumValue
  REG_BINARY* = 3
  REG_DWORD* = 4
  REG_DWORD_LITTLE_ENDIAN* = 4
  REG_DWORD_BIG_ENDIAN* = 5
  REG_EXPAND_SZ* = 2
  REG_FULL_RESOURCE_DESCRIPTOR* = 9
  REG_LINK* = 6
  REG_MULTI_SZ* = 7
  REG_NONE* = 0
  REG_RESOURCE_LIST* = 8
  REG_RESOURCE_REQUIREMENTS_LIST* = 10
  REG_SZ* = 1
  # RegisterHotKey
  MOD_ALT* = 1
  MOD_CONTROL* = 2
  MOD_SHIFT* = 4
  MOD_WIN* = 8
  IDHOT_SNAPDESKTOP* = -2
  IDHOT_SNAPWINDOW* = -1
  # RegNotifyChangeKeyValue
  REG_NOTIFY_CHANGE_NAME* = 0x00000001
  REG_NOTIFY_CHANGE_ATTRIBUTES* = 0x00000002
  REG_NOTIFY_CHANGE_LAST_SET* = 0x00000004
  REG_NOTIFY_CHANGE_SECURITY* = 0x00000008
  # ScrollWindowEx
  SW_ERASE* = 4
  SW_INVALIDATE* = 2
  SW_SCROLLCHILDREN* = 1
  # SendMessageTimeout
  SMTO_ABORTIFHUNG* = 2
  SMTO_BLOCK* = 1
  SMTO_NORMAL* = 0
  # SetBkMode
  OPAQUE* = 2

  TRANSPARENT* = 1
  # SetDebugErrorLevel
  SLE_ERROR* = 1
  SLE_MINORERROR* = 2
  SLE_WARNING* = 3
  # SetErrorMode
  SEM_FAILCRITICALERRORS* = 1
  SEM_NOALIGNMENTFAULTEXCEPT* = 4
  SEM_NOGPFAULTERRORBOX* = 2
  SEM_NOOPENFILEERRORBOX* = 32768
  # SetICMMode
  ICM_ON* = 2
  ICM_OFF* = 1
  ICM_QUERY* = 3
  # SetJob
  # Locale Information
  LOCALE_ILANGUAGE* = 1
  LOCALE_SLANGUAGE* = 2
  LOCALE_SENGLANGUAGE* = 4097
  LOCALE_SABBREVLANGNAME* = 3
  LOCALE_SNATIVELANGNAME* = 4
  LOCALE_ICOUNTRY* = 5
  LOCALE_SCOUNTRY* = 6
  LOCALE_SENGCOUNTRY* = 4098
  LOCALE_SABBREVCTRYNAME* = 7
  LOCALE_SNATIVECTRYNAME* = 8
  LOCALE_IDEFAULTLANGUAGE* = 9
  LOCALE_IDEFAULTCOUNTRY* = 10
  LOCALE_IDEFAULTANSICODEPAGE* = 4100
  LOCALE_IDEFAULTCODEPAGE* = 11
  LOCALE_SLIST* = 12
  LOCALE_IMEASURE* = 13
  LOCALE_SDECIMAL* = 14
  LOCALE_STHOUSAND* = 15
  LOCALE_SGROUPING* = 16
  LOCALE_IDIGITS* = 17
  LOCALE_ILZERO* = 18
  LOCALE_INEGNUMBER* = 4112
  LOCALE_SCURRENCY* = 20
  LOCALE_SMONDECIMALSEP* = 22
  LOCALE_SMONTHOUSANDSEP* = 23
  LOCALE_SMONGROUPING* = 24
  LOCALE_ICURRDIGITS* = 25
  LOCALE_ICURRENCY* = 27
  LOCALE_INEGCURR* = 28
  LOCALE_SDATE* = 29
  LOCALE_STIME* = 30
  LOCALE_STIMEFORMAT* = 4099
  LOCALE_SSHORTDATE* = 31
  LOCALE_SLONGDATE* = 32
  LOCALE_IDATE* = 33
  LOCALE_ILDATE* = 34
  LOCALE_ITIME* = 35
  LOCALE_ITLZERO* = 37
  LOCALE_IDAYLZERO* = 38
  LOCALE_IMONLZERO* = 39
  LOCALE_S1159* = 40
  LOCALE_S2359* = 41
  LOCALE_ICALENDARTYPE* = 4105
  LOCALE_IOPTIONALCALENDAR* = 4107
  LOCALE_IFIRSTDAYOFWEEK* = 4108
  LOCALE_IFIRSTWEEKOFYEAR* = 4109
  LOCALE_SDAYNAME1* = 42
  LOCALE_SDAYNAME2* = 43
  LOCALE_SDAYNAME3* = 44
  LOCALE_SDAYNAME4* = 45
  LOCALE_SDAYNAME5* = 46
  LOCALE_SDAYNAME6* = 47
  LOCALE_SDAYNAME7* = 48
  LOCALE_SABBREVDAYNAME1* = 49
  LOCALE_SABBREVDAYNAME2* = 50
  LOCALE_SABBREVDAYNAME3* = 51
  LOCALE_SABBREVDAYNAME4* = 52
  LOCALE_SABBREVDAYNAME5* = 53
  LOCALE_SABBREVDAYNAME6* = 54
  LOCALE_SABBREVDAYNAME7* = 55
  LOCALE_SMONTHNAME1* = 56
  LOCALE_SMONTHNAME2* = 57
  LOCALE_SMONTHNAME3* = 58
  LOCALE_SMONTHNAME4* = 59
  LOCALE_SMONTHNAME5* = 60
  LOCALE_SMONTHNAME6* = 61
  LOCALE_SMONTHNAME7* = 62
  LOCALE_SMONTHNAME8* = 63
  LOCALE_SMONTHNAME9* = 64
  LOCALE_SMONTHNAME10* = 65
  LOCALE_SMONTHNAME11* = 66
  LOCALE_SMONTHNAME12* = 67
  LOCALE_SMONTHNAME13* = 4110
  LOCALE_SABBREVMONTHNAME1* = 68
  LOCALE_SABBREVMONTHNAME2* = 69
  LOCALE_SABBREVMONTHNAME3* = 70
  LOCALE_SABBREVMONTHNAME4* = 71
  LOCALE_SABBREVMONTHNAME5* = 72
  LOCALE_SABBREVMONTHNAME6* = 73
  LOCALE_SABBREVMONTHNAME7* = 74
  LOCALE_SABBREVMONTHNAME8* = 75
  LOCALE_SABBREVMONTHNAME9* = 76
  LOCALE_SABBREVMONTHNAME10* = 77
  LOCALE_SABBREVMONTHNAME11* = 78
  LOCALE_SABBREVMONTHNAME12* = 79
  LOCALE_SABBREVMONTHNAME13* = 4111
  LOCALE_SPOSITIVESIGN* = 80
  LOCALE_SNEGATIVESIGN* = 81
  LOCALE_IPOSSIGNPOSN* = 82
  LOCALE_INEGSIGNPOSN* = 83
  LOCALE_IPOSSYMPRECEDES* = 84
  LOCALE_IPOSSEPBYSPACE* = 85
  LOCALE_INEGSYMPRECEDES* = 86
  LOCALE_INEGSEPBYSPACE* = 87
  LOCALE_NOUSEROVERRIDE* = 0x80000000
  LOCALE_USE_CP_ACP* = 0x40000000 # use the system ACP
  LOCALE_RETURN_NUMBER* = 0x20000000 # return number instead
  LOCALE_SISO639LANGNAME* = 0x00000059
  LOCALE_SISO3166CTRYNAME* = 0x0000005A
  # Calendar Type Information
  CAL_ICALINTVALUE* = 1
  CAL_IYEAROFFSETRANGE* = 3
  CAL_SABBREVDAYNAME1* = 14
  CAL_SABBREVDAYNAME2* = 15
  CAL_SABBREVDAYNAME3* = 16
  CAL_SABBREVDAYNAME4* = 17
  CAL_SABBREVDAYNAME5* = 18
  CAL_SABBREVDAYNAME6* = 19
  CAL_SABBREVDAYNAME7* = 20
  CAL_SABBREVMONTHNAME1* = 34
  CAL_SABBREVMONTHNAME2* = 35
  CAL_SABBREVMONTHNAME3* = 36
  CAL_SABBREVMONTHNAME4* = 37
  CAL_SABBREVMONTHNAME5* = 38
  CAL_SABBREVMONTHNAME6* = 39
  CAL_SABBREVMONTHNAME7* = 40
  CAL_SABBREVMONTHNAME8* = 41
  CAL_SABBREVMONTHNAME9* = 42
  CAL_SABBREVMONTHNAME10* = 43
  CAL_SABBREVMONTHNAME11* = 44
  CAL_SABBREVMONTHNAME12* = 45
  CAL_SABBREVMONTHNAME13* = 46
  CAL_SCALNAME* = 2
  CAL_SDAYNAME1* = 7
  CAL_SDAYNAME2* = 8
  CAL_SDAYNAME3* = 9
  CAL_SDAYNAME4* = 10
  CAL_SDAYNAME5* = 11
  CAL_SDAYNAME6* = 12
  CAL_SDAYNAME7* = 13
  CAL_SERASTRING* = 4
  CAL_SLONGDATE* = 6
  CAL_SMONTHNAME1* = 21
  CAL_SMONTHNAME2* = 22
  CAL_SMONTHNAME3* = 23
  CAL_SMONTHNAME4* = 24
  CAL_SMONTHNAME5* = 25
  CAL_SMONTHNAME6* = 26
  CAL_SMONTHNAME7* = 27
  CAL_SMONTHNAME8* = 28
  CAL_SMONTHNAME9* = 29
  CAL_SMONTHNAME10* = 30
  CAL_SMONTHNAME11* = 31
  CAL_SMONTHNAME12* = 32
  CAL_SMONTHNAME13* = 33
  CAL_SSHORTDATE* = 5
  # SetProcessWorkingSetSize
  PROCESS_SET_QUOTA* = 256
  # SetPrinter
  # SetService
  # SetStretchBltMode
  BLACKONWHITE* = 1
  COLORONCOLOR* = 3
  HALFTONE* = 4
  STRETCH_ANDSCANS* = 1
  STRETCH_DELETESCANS* = 3
  STRETCH_HALFTONE* = 4
  STRETCH_ORSCANS* = 2
  WHITEONBLACK* = 2
  # SetSystemCursor
  OCR_NORMAL* = 32512
  OCR_IBEAM* = 32513
  OCR_WAIT* = 32514
  OCR_CROSS* = 32515
  OCR_UP* = 32516
  OCR_SIZE* = 32640
  OCR_ICON* = 32641
  OCR_SIZENWSE* = 32642
  OCR_SIZENESW* = 32643
  OCR_SIZEWE* = 32644
  OCR_SIZENS* = 32645
  OCR_SIZEALL* = 32646
  OCR_NO* = 32648
  OCR_APPSTARTING* = 32650
  # SetTapePosition
  TAPE_ABSOLUTE_BLOCK* = 0x00000001
  TAPE_LOGICAL_BLOCK* = 0x00000002
  TAPE_REWIND* = 0
  TAPE_SPACE_END_OF_DATA* = 0x00000004
  TAPE_SPACE_FILEMARKS* = 0x00000006
  TAPE_SPACE_RELATIVE_BLOCKS* = 0x00000005
  TAPE_SPACE_SEQUENTIAL_FMKS* = 0x00000007
  TAPE_SPACE_SEQUENTIAL_SMKS* = 0x00000009
  TAPE_SPACE_SETMARKS* = 0x00000008
  # SetUnhandledExceptionFilter
  EXCEPTION_EXECUTE_HANDLER* = 1
  EXCEPTION_CONTINUE_EXECUTION* = -1
  EXCEPTION_CONTINUE_SEARCH* = 0

  # SetWindowPos, DeferWindowPos
  HWND_BOTTOM* =    HWND(1)
  HWND_NOTOPMOST* = HWND(-2)
  HWND_TOP* =       HWND(0)
  HWND_TOPMOST* =   HWND(-1)

const
  SWP_DRAWFRAME* = 32
  SWP_FRAMECHANGED* = 32
  SWP_HIDEWINDOW* = 128
  SWP_NOACTIVATE* = 16
  SWP_NOCOPYBITS* = 256
  SWP_NOMOVE* = 2
  SWP_NOSIZE* = 1
  SWP_NOREDRAW* = 8
  SWP_NOZORDER* = 4
  SWP_SHOWWINDOW* = 64
  SWP_NOOWNERZORDER* = 512
  SWP_NOREPOSITION* = 512
  SWP_NOSENDCHANGING* = 1024
  # SHAddToRecentDocs
  # SHAppBarMessage
  # SHChangeNotify
  # ShellProc
  HSHELL_ACTIVATESHELLWINDOW* = 3
  HSHELL_GETMINRECT* = 5
  HSHELL_LANGUAGE* = 8
  HSHELL_REDRAW* = 6
  HSHELL_TASKMAN* = 7
  HSHELL_WINDOWACTIVATED* = 4
  HSHELL_WINDOWCREATED* = 1
  HSHELL_WINDOWDESTROYED* = 2
  # SHGetFileInfo
  # SHGetSpecialFolderLocation
  # ShowWindow
  SW_HIDE* = 0
  SW_MAXIMIZE* = 3
  SW_MINIMIZE* = 6
  SW_NORMAL* = 1
  SW_RESTORE* = 9
  SW_SHOW* = 5
  SW_SHOWDEFAULT* = 10
  SW_SHOWMAXIMIZED* = 3
  SW_SHOWMINIMIZED* = 2
  SW_SHOWMINNOACTIVE* = 7
  SW_SHOWNA* = 8
  SW_SHOWNOACTIVATE* = 4
  SW_SHOWNORMAL* = 1
  WPF_RESTORETOMAXIMIZED* = 2
  WPF_SETMINPOSITION* = 1
  # Sleep
  INFINITE* = -1'i32
  # SystemParametersInfo
  SPI_GETBEEP* = 1
  SPI_SETBEEP* = 2
  SPI_GETMOUSE* = 3
  SPI_SETMOUSE* = 4
  SPI_GETBORDER* = 5
  SPI_SETBORDER* = 6
  SPI_GETKEYBOARDSPEED* = 10
  SPI_SETKEYBOARDSPEED* = 11
  SPI_LANGDRIVER* = 12
  SPI_ICONHORIZONTALSPACING* = 13
  SPI_GETSCREENSAVETIMEOUT* = 14
  SPI_SETSCREENSAVETIMEOUT* = 15
  SPI_GETSCREENSAVEACTIVE* = 16
  SPI_SETSCREENSAVEACTIVE* = 17
  SPI_GETGRIDGRANULARITY* = 18
  SPI_SETGRIDGRANULARITY* = 19
  SPI_SETDESKWALLPAPER* = 20
  SPI_SETDESKPATTERN* = 21
  SPI_GETKEYBOARDDELAY* = 22
  SPI_SETKEYBOARDDELAY* = 23
  SPI_ICONVERTICALSPACING* = 24
  SPI_GETICONTITLEWRAP* = 25
  SPI_SETICONTITLEWRAP* = 26
  SPI_GETMENUDROPALIGNMENT* = 27
  SPI_SETMENUDROPALIGNMENT* = 28
  SPI_SETDOUBLECLKWIDTH* = 29
  SPI_SETDOUBLECLKHEIGHT* = 30
  SPI_GETICONTITLELOGFONT* = 31
  SPI_SETDOUBLECLICKTIME* = 32
  SPI_SETMOUSEBUTTONSWAP* = 33
  SPI_SETICONTITLELOGFONT* = 34
  SPI_GETFASTTASKSWITCH* = 35
  SPI_SETFASTTASKSWITCH* = 36
  SPI_SETDRAGFULLWINDOWS* = 37
  SPI_GETDRAGFULLWINDOWS* = 38
  SPI_GETNONCLIENTMETRICS* = 41
  SPI_SETNONCLIENTMETRICS* = 42

  SPI_GETMINIMIZEDMETRICS* = 43
  SPI_SETMINIMIZEDMETRICS* = 44
  SPI_GETICONMETRICS* = 45
  SPI_SETICONMETRICS* = 46
  SPI_SETWORKAREA* = 47
  SPI_GETWORKAREA* = 48
  SPI_SETPENWINDOWS* = 49
  SPI_GETFILTERKEYS* = 50
  SPI_SETFILTERKEYS* = 51
  SPI_GETTOGGLEKEYS* = 52
  SPI_SETTOGGLEKEYS* = 53
  SPI_GETMOUSEKEYS* = 54
  SPI_SETMOUSEKEYS* = 55
  SPI_GETSHOWSOUNDS* = 56
  SPI_SETSHOWSOUNDS* = 57
  SPI_GETSTICKYKEYS* = 58
  SPI_SETSTICKYKEYS* = 59
  SPI_GETACCESSTIMEOUT* = 60
  SPI_SETACCESSTIMEOUT* = 61
  SPI_GETSERIALKEYS* = 62
  SPI_SETSERIALKEYS* = 63
  SPI_GETSOUNDSENTRY* = 64
  SPI_SETSOUNDSENTRY* = 65
  SPI_GETHIGHCONTRAST* = 66
  SPI_SETHIGHCONTRAST* = 67
  SPI_GETKEYBOARDPREF* = 68
  SPI_SETKEYBOARDPREF* = 69
  SPI_GETSCREENREADER* = 70
  SPI_SETSCREENREADER* = 71
  SPI_GETANIMATION* = 72
  SPI_SETANIMATION* = 73
  SPI_GETFONTSMOOTHING* = 74
  SPI_SETFONTSMOOTHING* = 75
  SPI_SETDRAGWIDTH* = 76
  SPI_SETDRAGHEIGHT* = 77
  SPI_SETHANDHELD* = 78
  SPI_GETLOWPOWERTIMEOUT* = 79
  SPI_GETPOWEROFFTIMEOUT* = 80
  SPI_SETLOWPOWERTIMEOUT* = 81
  SPI_SETPOWEROFFTIMEOUT* = 82
  SPI_GETLOWPOWERACTIVE* = 83
  SPI_GETPOWEROFFACTIVE* = 84
  SPI_SETLOWPOWERACTIVE* = 85
  SPI_SETPOWEROFFACTIVE* = 86
  SPI_SETCURSORS* = 87
  SPI_SETICONS* = 88
  SPI_GETDEFAULTINPUTLANG* = 89
  SPI_SETDEFAULTINPUTLANG* = 90
  SPI_SETLANGTOGGLE* = 91
  SPI_GETWINDOWSEXTENSION* = 92
  SPI_SETMOUSETRAILS* = 93
  SPI_GETMOUSETRAILS* = 94
  SPI_GETSNAPTODEFBUTTON* = 95
  SPI_SETSNAPTODEFBUTTON* = 96
  SPI_SCREENSAVERRUNNING* = 97
  SPI_SETSCREENSAVERRUNNING* = 97
  SPI_GETMOUSEHOVERWIDTH* = 98
  SPI_SETMOUSEHOVERWIDTH* = 99
  SPI_GETMOUSEHOVERHEIGHT* = 100
  SPI_SETMOUSEHOVERHEIGHT* = 101
  SPI_GETMOUSEHOVERTIME* = 102
  SPI_SETMOUSEHOVERTIME* = 103
  SPI_GETWHEELSCROLLLINES* = 104
  SPI_SETWHEELSCROLLLINES* = 105
  SPI_GETMENUSHOWDELAY* = 106
  SPI_SETMENUSHOWDELAY* = 107
  SPI_GETSHOWIMEUI* = 110
  SPI_SETSHOWIMEUI* = 111
  # Windows Me/2000 and higher
  SPI_GETMOUSESPEED* = 112
  SPI_SETMOUSESPEED* = 113
  SPI_GETSCREENSAVERRUNNING* = 114
  SPI_GETDESKWALLPAPER* = 115
  SPI_GETACTIVEWINDOWTRACKING* = 4096
  SPI_SETACTIVEWINDOWTRACKING* = 4097
  SPI_GETMENUANIMATION* = 4098
  SPI_SETMENUANIMATION* = 4099
  SPI_GETCOMBOBOXANIMATION* = 4100
  SPI_SETCOMBOBOXANIMATION* = 4101
  SPI_GETLISTBOXSMOOTHSCROLLING* = 4102
  SPI_SETLISTBOXSMOOTHSCROLLING* = 4103
  SPI_GETGRADIENTCAPTIONS* = 4104
  SPI_SETGRADIENTCAPTIONS* = 4105
  SPI_GETKEYBOARDCUES* = 4106
  SPI_SETKEYBOARDCUES* = 4107
  SPI_GETMENUUNDERLINES* = 4106
  SPI_SETMENUUNDERLINES* = 4107
  SPI_GETACTIVEWNDTRKZORDER* = 4108
  SPI_SETACTIVEWNDTRKZORDER* = 4109
  SPI_GETHOTTRACKING* = 4110
  SPI_SETHOTTRACKING* = 4111
  SPI_GETMENUFADE* = 4114
  SPI_SETMENUFADE* = 4115
  SPI_GETSELECTIONFADE* = 4116
  SPI_SETSELECTIONFADE* = 4117
  SPI_GETTOOLTIPANIMATION* = 4118
  SPI_SETTOOLTIPANIMATION* = 4119
  SPI_GETTOOLTIPFADE* = 4120
  SPI_SETTOOLTIPFADE* = 4121
  SPI_GETCURSORSHADOW* = 4122
  SPI_SETCURSORSHADOW* = 4123
  SPI_GETUIEFFECTS* = 4158
  SPI_SETUIEFFECTS* = 4159
  SPI_GETFOREGROUNDLOCKTIMEOUT* = 8192
  SPI_SETFOREGROUNDLOCKTIMEOUT* = 8193
  SPI_GETACTIVEWNDTRKTIMEOUT* = 8194
  SPI_SETACTIVEWNDTRKTIMEOUT* = 8195
  SPI_GETFOREGROUNDFLASHCOUNT* = 8196
  SPI_SETFOREGROUNDFLASHCOUNT* = 8197
  SPI_GETCARETWIDTH* = 8198
  SPI_SETCARETWIDTH* = 8199
  # Windows XP and higher
  SPI_GETMOUSESONAR* = 4124
  SPI_SETMOUSESONAR* = 4125
  SPI_GETMOUSECLICKLOCK* = 4126
  SPI_SETMOUSECLICKLOCK* = 4127
  SPI_GETMOUSEVANISH* = 4128
  SPI_SETMOUSEVANISH* = 4129
  SPI_GETFLATMENU* = 4130
  SPI_SETFLATMENU* = 4131
  SPI_GETDROPSHADOW* = 4132
  SPI_SETDROPSHADOW* = 4133
  SPI_GETBLOCKSENDINPUTRESETS* = 4134
  SPI_SETBLOCKSENDINPUTRESETS* = 4135
  SPI_GETMOUSECLICKLOCKTIME* = 8200
  SPI_SETMOUSECLICKLOCKTIME* = 8201
  SPI_GETFONTSMOOTHINGTYPE* = 8202
  SPI_SETFONTSMOOTHINGTYPE* = 8203
  SPI_GETFONTSMOOTHINGCONTRAST* = 8204
  SPI_SETFONTSMOOTHINGCONTRAST* = 8205
  SPI_GETFOCUSBORDERWIDTH* = 8206
  SPI_SETFOCUSBORDERWIDTH* = 8207
  SPI_GETFOCUSBORDERHEIGHT* = 8208
  SPI_SETFOCUSBORDERHEIGHT* = 8209
  SPI_GETFONTSMOOTHINGORIENTATION* = 8210
  SPI_SETFONTSMOOTHINGORIENTATION* = 8211
  # constants for SPI_GETFONTSMOOTHINGTYPE and SPI_SETFONTSMOOTHINGTYPE:
  FE_FONTSMOOTHINGSTANDARD* = 1
  FE_FONTSMOOTHINGCLEARTYPE* = 2
  FE_FONTSMOOTHINGDOCKING* = 32768
  # constants for SPI_GETFONTSMOOTHINGORIENTATION and SPI_SETFONTSMOOTHINGORIENTATION:
  FE_FONTSMOOTHINGORIENTATIONBGR* = 0
  FE_FONTSMOOTHINGORIENTATIONRGB* = 1
  # Flags
  SPIF_UPDATEINIFILE* = 1
  SPIF_SENDWININICHANGE* = 2
  SPIF_SENDCHANGE* = 2
  # TrackPopupMenu, TrackPopMenuEx
  TPM_CENTERALIGN* = 0x00000004
  TPM_LEFTALIGN* = 0
  TPM_RIGHTALIGN* = 0x00000008
  TPM_LEFTBUTTON* = 0
  TPM_RIGHTBUTTON* = 0x00000002
  TPM_HORIZONTAL* = 0
  TPM_VERTICAL* = 0x00000040
  # TranslateCharsetInfo
  TCI_SRCCHARSET* = 1
  TCI_SRCCODEPAGE* = 2
  TCI_SRCFONTSIG* = 3
  # VerFindFile
  VFFF_ISSHAREDFILE* = 1
  VFF_CURNEDEST* = 1
  VFF_FILEINUSE* = 2
  VFF_BUFFTOOSMALL* = 4
  # VerInstallFile
  VIFF_FORCEINSTALL* = 1
  VIFF_DONTDELETEOLD* = 2
  VIF_TEMPFILE* = 0x00000001
  VIF_MISMATCH* = 0x00000002
  VIF_SRCOLD* = 0x00000004
  VIF_DIFFLANG* = 0x00000008
  VIF_DIFFCODEPG* = 0x00000010
  VIF_DIFFTYPE* = 0x00000020
  VIF_WRITEPROT* = 0x00000040
  VIF_FILEINUSE* = 0x00000080
  VIF_OUTOFSPACE* = 0x00000100
  VIF_ACCESSVIOLATION* = 0x00000200
  VIF_SHARINGVIOLATION* = 0x00000400
  VIF_CANNOTCREATE* = 0x00000800
  VIF_CANNOTDELETE* = 0x00001000
  VIF_CANNOTDELETECUR* = 0x00004000
  VIF_CANNOTRENAME* = 0x00002000
  VIF_OUTOFMEMORY* = 0x00008000
  VIF_CANNOTREADSRC* = 0x00010000
  VIF_CANNOTREADDST* = 0x00020000
  VIF_BUFFTOOSMALL* = 0x00040000
  # WideCharToMultiByte
  WC_COMPOSITECHECK* = 512
  WC_DISCARDNS* = 16
  WC_SEPCHARS* = 32
  WC_DEFAULTCHAR* = 64
  # WinHelp
  HELP_COMMAND* = 0x00000102
  HELP_CONTENTS* = 0x00000003
  HELP_CONTEXT* = 0x00000001
  HELP_CONTEXTPOPUP* = 0x00000008
  HELP_FORCEFILE* = 0x00000009
  HELP_HELPONHELP* = 0x00000004
  HELP_INDEX* = 0x00000003
  HELP_KEY* = 0x00000101
  HELP_MULTIKEY* = 0x00000201
  HELP_PARTIALKEY* = 0x00000105
  HELP_QUIT* = 0x00000002
  HELP_SETCONTENTS* = 0x00000005
  HELP_SETINDEX* = 0x00000005
  HELP_CONTEXTMENU* = 0x0000000A
  HELP_FINDER* = 0x0000000B
  HELP_WM_HELP* = 0x0000000C
  HELP_TCARD* = 0x00008000
  HELP_TCARD_DATA* = 0x00000010
  HELP_TCARD_OTHER_CALLER* = 0x00000011
  # WNetAddConnectino2
  CONNECT_UPDATE_PROFILE* = 1
  # WNetConnectionDialog, WNetDisconnectDialog, WNetOpenEnum
  RESOURCETYPE_DISK* = 1
  RESOURCETYPE_PRINT* = 2
  RESOURCETYPE_ANY* = 0
  RESOURCE_CONNECTED* = 1
  RESOURCE_GLOBALNET* = 2
  RESOURCE_REMEMBERED* = 3
  RESOURCEUSAGE_CONNECTABLE* = 1
  RESOURCEUSAGE_CONTAINER* = 2
  # WNetGetResourceInformation, WNetGetResourceParent
  WN_BAD_NETNAME* = 0x00000043
  WN_EXTENDED_ERROR* = 0x000004B8
  WN_MORE_DATA* = 0x000000EA
  WN_NO_NETWORK* = 0x000004C6
  WN_SUCCESS* = 0
  WN_ACCESS_DENIED* = 0x00000005
  WN_BAD_PROVIDER* = 0x000004B4
  WN_NOT_AUTHENTICATED* = 0x000004DC
  # WNetGetUniversalName
  UNIVERSAL_NAME_INFO_LEVEL* = 1
  REMOTE_NAME_INFO_LEVEL* = 2
  # GetExitCodeThread
  STILL_ACTIVE* = 0x00000103
  # COMMPROP structure
  SP_SERIALCOMM* = 0x00000001
  BAUD_075* = 0x00000001
  BAUD_110* = 0x00000002
  BAUD_134_5* = 0x00000004
  BAUD_150* = 0x00000008
  BAUD_300* = 0x00000010
  BAUD_600* = 0x00000020
  BAUD_1200* = 0x00000040
  BAUD_1800* = 0x00000080
  BAUD_2400* = 0x00000100
  BAUD_4800* = 0x00000200
  BAUD_7200* = 0x00000400
  BAUD_9600* = 0x00000800
  BAUD_14400* = 0x00001000
  BAUD_19200* = 0x00002000
  BAUD_38400* = 0x00004000
  BAUD_56K* = 0x00008000
  BAUD_57600* = 0x00040000
  BAUD_115200* = 0x00020000
  BAUD_128K* = 0x00010000
  BAUD_USER* = 0x10000000
  PST_FAX* = 0x00000021
  PST_LAT* = 0x00000101
  PST_MODEM* = 0x00000006
  PST_NETWORK_BRIDGE* = 0x00000100
  PST_PARALLELPORT* = 0x00000002
  PST_RS232* = 0x00000001
  PST_RS422* = 0x00000003
  PST_RS423* = 0x00000004
  PST_RS449* = 0x00000005
  PST_SCANNER* = 0x00000022
  PST_TCPIP_TELNET* = 0x00000102
  PST_UNSPECIFIED* = 0
  PST_X25* = 0x00000103
  PCF_16BITMODE* = 0x00000200
  PCF_DTRDSR* = 0x00000001
  PCF_INTTIMEOUTS* = 0x00000080
  PCF_PARITY_CHECK* = 0x00000008
  PCF_RLSD* = 0x00000004
  PCF_RTSCTS* = 0x00000002
  PCF_SETXCHAR* = 0x00000020
  PCF_SPECIALCHARS* = 0x00000100
  PCF_TOTALTIMEOUTS* = 0x00000040
  PCF_XONXOFF* = 0x00000010
  SP_BAUD* = 0x00000002
  SP_DATABITS* = 0x00000004
  SP_HANDSHAKING* = 0x00000010
  SP_PARITY* = 0x00000001
  SP_PARITY_CHECK* = 0x00000020
  SP_RLSD* = 0x00000040
  SP_STOPBITS* = 0x00000008
  DATABITS_5* = 1
  DATABITS_6* = 2
  DATABITS_7* = 4
  DATABITS_8* = 8
  DATABITS_16* = 16
  DATABITS_16X* = 32
  STOPBITS_10* = 1
  STOPBITS_15* = 2
  STOPBITS_20* = 4
  PARITY_NONE* = 256
  PARITY_ODD* = 512
  PARITY_EVEN* = 1024
  PARITY_MARK* = 2048
  PARITY_SPACE* = 4096
  COMMPROP_INITIALIZED* = 0xE73CF52E
  # DCB structure
  CBR_110* = 110
  CBR_300* = 300
  CBR_600* = 600
  CBR_1200* = 1200
  CBR_2400* = 2400
  CBR_4800* = 4800
  CBR_9600* = 9600
  CBR_14400* = 14400
  CBR_19200* = 19200
  CBR_38400* = 38400
  CBR_56000* = 56000
  CBR_57600* = 57600
  CBR_115200* = 115200
  CBR_128000* = 128000
  CBR_256000* = 256000
  DTR_CONTROL_DISABLE* = 0
  DTR_CONTROL_ENABLE* = 1
  DTR_CONTROL_HANDSHAKE* = 2
  RTS_CONTROL_DISABLE* = 0
  RTS_CONTROL_ENABLE* = 1
  RTS_CONTROL_HANDSHAKE* = 2
  RTS_CONTROL_TOGGLE* = 3
  EVENPARITY* = 2
  MARKPARITY* = 3
  NOPARITY* = 0
  ODDPARITY* = 1
  SPACEPARITY* = 4
  ONESTOPBIT* = 0
  ONE5STOPBITS* = 1
  TWOSTOPBITS* = 2
  # Debugging events
  CREATE_PROCESS_DEBUG_EVENT* = 3
  CREATE_THREAD_DEBUG_EVENT* = 2
  EXCEPTION_DEBUG_EVENT* = 1
  EXIT_PROCESS_DEBUG_EVENT* = 5
  EXIT_THREAD_DEBUG_EVENT* = 4
  LOAD_DLL_DEBUG_EVENT* = 6
  OUTPUT_DEBUG_STRING_EVENT* = 8
  UNLOAD_DLL_DEBUG_EVENT* = 7
  RIP_EVENT* = 9
  # PROCESS_HEAP_ENTRY structure
  PROCESS_HEAP_REGION* = 1
  PROCESS_HEAP_UNCOMMITTED_RANGE* = 2
  PROCESS_HEAP_ENTRY_BUSY* = 4
  PROCESS_HEAP_ENTRY_MOVEABLE* = 16
  PROCESS_HEAP_ENTRY_DDESHARE* = 32
  # Win32s
  HINSTANCE_ERROR* = 32
  # WIN32_STREAM_ID structure
  BACKUP_DATA* = 1
  BACKUP_EA_DATA* = 2
  BACKUP_SECURITY_DATA* = 3
  BACKUP_ALTERNATE_DATA* = 4
  BACKUP_LINK* = 5
  STREAM_MODIFIED_WHEN_READ* = 1
  STREAM_CONTAINS_SECURITY* = 2
  # STARTUPINFO structure
  STARTF_USESHOWWINDOW* = 1
  STARTF_USEPOSITION* = 4
  STARTF_USESIZE* = 2
  STARTF_USECOUNTCHARS* = 8
  STARTF_USEFILLATTRIBUTE* = 16
  STARTF_RUNFULLSCREEN* = 32
  STARTF_FORCEONFEEDBACK* = 64
  STARTF_FORCEOFFFEEDBACK* = 128
  STARTF_USESTDHANDLES* = 256
  STARTF_USEHOTKEY* = 512
  # OSVERSIONINFO structure
  VER_PLATFORM_WIN32s* = 0
  VER_PLATFORM_WIN32_WINDOWS* = 1
  VER_PLATFORM_WIN32_NT* = 2
  # More versions
  VER_SERVER_NT* = 0x80000000
  VER_WORKSTATION_NT* = 0x40000000
  VER_SUITE_SMALLBUSINESS* = 0x00000001
  VER_SUITE_ENTERPRISE* = 0x00000002
  VER_SUITE_BACKOFFICE* = 0x00000004
  VER_SUITE_COMMUNICATIONS* = 0x00000008
  VER_SUITE_TERMINAL* = 0x00000010
  VER_SUITE_SMALLBUSINESS_RESTRICTED* = 0x00000020
  VER_SUITE_EMBEDDEDNT* = 0x00000040
  VER_SUITE_DATACENTER* = 0x00000080
  VER_SUITE_SINGLEUSERTS* = 0x00000100
  VER_SUITE_PERSONAL* = 0x00000200
  VER_SUITE_BLADE* = 0x00000400
  VER_SUITE_EMBEDDED_RESTRICTED* = 0x00000800
  # PROPSHEETPAGE structure
  MAXPROPPAGES* = 100
  PSP_DEFAULT* = 0
  PSP_DLGINDIRECT* = 1
  PSP_HASHELP* = 32
  PSP_USECALLBACK* = 128
  PSP_USEHICON* = 2
  PSP_USEICONID* = 4
  PSP_USEREFPARENT* = 64
  PSP_USETITLE* = 8
  PSP_RTLREADING* = 16
  # PROPSHEETHEADER structure
  PSH_DEFAULT* = 0
  PSH_HASHELP* = 512
  PSH_MODELESS* = 1024
  PSH_NOAPPLYNOW* = 128
  PSH_PROPSHEETPAGE* = 8
  PSH_PROPTITLE* = 1
  PSH_USECALLBACK* = 256
  PSH_USEHICON* = 2
  PSH_USEICONID* = 4
  PSH_USEPSTARTPAGE* = 64
  PSH_WIZARD* = 32
  PSH_RTLREADING* = 2048
  PSCB_INITIALIZED* = 1
  PSCB_PRECREATE* = 2
  # PSN_APPLY message
  PSNRET_NOERROR* = 0
  PSNRET_INVALID_NOCHANGEPAGE* = 2
  # Property Sheet
  PSBTN_APPLYNOW* = 4
  PSBTN_BACK* = 0
  PSBTN_CANCEL* = 5
  PSBTN_FINISH* = 2
  PSBTN_HELP* = 6
  PSBTN_NEXT* = 1
  PSBTN_OK* = 3
  PSWIZB_BACK* = 1
  PSWIZB_NEXT* = 2
  PSWIZB_FINISH* = 4
  PSWIZB_DISABLEDFINISH* = 8
  ID_PSREBOOTSYSTEM* = 3
  ID_PSRESTARTWINDOWS* = 2
  WIZ_BODYCX* = 184
  WIZ_BODYX* = 92
  WIZ_CXBMP* = 80
  WIZ_CXDLG* = 276
  WIZ_CYDLG* = 140

  # VX_FIXEDFILEINFO structure
  VS_FILE_INFO* = cast[MAKEINTRESOURCE](16)

const
  VS_VERSION_INFO* = 1
  VS_FF_DEBUG* = 0x00000001
  VS_FF_INFOINFERRED* = 0x00000010
  VS_FF_PATCHED* = 0x00000004
  VS_FF_PRERELEASE* = 0x00000002
  VS_FF_PRIVATEBUILD* = 0x00000008
  VS_FF_SPECIALBUILD* = 0x00000020
  VOS_UNKNOWN* = 0
  VOS_DOS* = 0x00010000
  VOS_OS216* = 0x00020000
  VOS_OS232* = 0x00030000
  VOS_NT* = 0x00040000
  VOS_DOS_WINDOWS16* = 0x00010001
  VOS_DOS_WINDOWS32* = 0x00010004
  VOS_OS216_PM16* = 0x00020002
  VOS_OS232_PM32* = 0x00030003
  VOS_NT_WINDOWS32* = 0x00040004
  VFT_UNKNOWN* = 0
  VFT_APP* = 0x00000001
  VFT_DLL* = 0x00000002
  VFT_DRV* = 0x00000003
  VFT_FONT* = 0x00000004
  VFT_VXD* = 0x00000005
  VFT_STATIC_LIB* = 0x00000007
  VFT2_UNKNOWN* = 0
  VFT2_DRV_PRINTER* = 0x00000001
  VFT2_DRV_KEYBOARD* = 0x00000002
  VFT2_DRV_LANGUAGE* = 0x00000003
  VFT2_DRV_DISPLAY* = 0x00000004
  VFT2_DRV_MOUSE* = 0x00000005
  VFT2_DRV_NETWORK* = 0x00000006
  VFT2_DRV_SYSTEM* = 0x00000007
  VFT2_DRV_INSTALLABLE* = 0x00000008
  VFT2_DRV_SOUND* = 0x00000009
  VFT2_FONT_RASTER* = 0x00000001
  VFT2_FONT_VECTOR* = 0x00000002
  VFT2_FONT_TRUETYPE* = 0x00000003
  # PANOSE structure
  PAN_ANY* = 0
  PAN_NO_FIT* = 1
  PAN_FAMILY_TEXT_DISPLAY* = 2
  PAN_FAMILY_SCRIPT* = 3
  PAN_FAMILY_DECORATIVE* = 4
  PAN_FAMILY_PICTORIAL* = 5
  PAN_SERIF_COVE* = 2
  PAN_SERIF_OBTUSE_COVE* = 3
  PAN_SERIF_SQUARE_COVE* = 4
  PAN_SERIF_OBTUSE_SQUARE_COVE* = 5
  PAN_SERIF_SQUARE* = 6
  PAN_SERIF_THIN* = 7
  PAN_SERIF_BONE* = 8
  PAN_SERIF_EXAGGERATED* = 9
  PAN_SERIF_TRIANGLE* = 10
  PAN_SERIF_NORMAL_SANS* = 11
  PAN_SERIF_OBTUSE_SANS* = 12
  PAN_SERIF_PERP_SANS* = 13
  PAN_SERIF_FLARED* = 14
  PAN_SERIF_ROUNDED* = 15
  PAN_WEIGHT_VERY_LIGHT* = 2
  PAN_WEIGHT_LIGHT* = 3
  PAN_WEIGHT_THIN* = 4
  PAN_WEIGHT_BOOK* = 5
  PAN_WEIGHT_MEDIUM* = 6
  PAN_WEIGHT_DEMI* = 7
  PAN_WEIGHT_BOLD* = 8
  PAN_WEIGHT_HEAVY* = 9
  PAN_WEIGHT_BLACK* = 10
  PAN_WEIGHT_NORD* = 11
  PAN_PROP_OLD_STYLE* = 2
  PAN_PROP_MODERN* = 3
  PAN_PROP_EVEN_WIDTH* = 4
  PAN_PROP_EXPANDED* = 5
  PAN_PROP_CONDENSED* = 6
  PAN_PROP_VERY_EXPANDED* = 7
  PAN_PROP_VERY_CONDENSED* = 8
  PAN_PROP_MONOSPACED* = 9
  PAN_CONTRAST_NONE* = 2
  PAN_CONTRAST_VERY_LOW* = 3
  PAN_CONTRAST_LOW* = 4
  PAN_CONTRAST_MEDIUM_LOW* = 5
  PAN_CONTRAST_MEDIUM* = 6
  PAN_CONTRAST_MEDIUM_HIGH* = 7
  PAN_CONTRAST_HIGH* = 8
  PAN_CONTRAST_VERY_HIGH* = 9
  PAN_STROKE_GRADUAL_DIAG* = 2
  PAN_STROKE_GRADUAL_TRAN* = 3
  PAN_STROKE_GRADUAL_VERT* = 4
  PAN_STROKE_GRADUAL_HORZ* = 5
  PAN_STROKE_RAPID_VERT* = 6
  PAN_STROKE_RAPID_HORZ* = 7
  PAN_STROKE_INSTANT_VERT* = 8
  PAN_STRAIGHT_ARMS_HORZ* = 2
  PAN_STRAIGHT_ARMS_WEDGE* = 3
  PAN_STRAIGHT_ARMS_VERT* = 4
  PAN_STRAIGHT_ARMS_SINGLE_SERIF* = 5
  PAN_STRAIGHT_ARMS_DOUBLE_SERIF* = 6
  PAN_BENT_ARMS_HORZ* = 7
  PAN_BENT_ARMS_VERT* = 9
  PAN_BENT_ARMS_WEDGE* = 8
  PAN_BENT_ARMS_SINGLE_SERIF* = 10
  PAN_BENT_ARMS_DOUBLE_SERIF* = 11
  PAN_LETT_NORMAL_CONTACT* = 2
  PAN_LETT_NORMAL_WEIGHTED* = 3
  PAN_LETT_NORMAL_BOXED* = 4
  PAN_LETT_NORMAL_FLATTENED* = 5
  PAN_LETT_NORMAL_ROUNDED* = 6
  PAN_LETT_NORMAL_OFF_CENTER* = 7
  PAN_LETT_NORMAL_SQUARE* = 8
  PAN_LETT_OBLIQUE_CONTACT* = 9
  PAN_LETT_OBLIQUE_WEIGHTED* = 10
  PAN_LETT_OBLIQUE_BOXED* = 11
  PAN_LETT_OBLIQUE_FLATTENED* = 12
  PAN_LETT_OBLIQUE_ROUNDED* = 13
  PAN_LETT_OBLIQUE_OFF_CENTER* = 14
  PAN_LETT_OBLIQUE_SQUARE* = 15
  PAN_MIDLINE_STANDARD_TRIMMED* = 2
  PAN_MIDLINE_STANDARD_POINTED* = 3
  PAN_MIDLINE_STANDARD_SERIFED* = 4
  PAN_MIDLINE_HIGH_TRIMMED* = 5
  PAN_MIDLINE_HIGH_POINTED* = 6
  PAN_MIDLINE_HIGH_SERIFED* = 7
  PAN_MIDLINE_CONSTANT_TRIMMED* = 8
  PAN_MIDLINE_CONSTANT_POINTED* = 9
  PAN_MIDLINE_CONSTANT_SERIFED* = 10
  PAN_MIDLINE_LOW_TRIMMED* = 11
  PAN_MIDLINE_LOW_POINTED* = 12
  PAN_MIDLINE_LOW_SERIFED* = 13
  PAN_XHEIGHT_CONSTANT_SMALL* = 2
  PAN_XHEIGHT_CONSTANT_STD* = 3
  PAN_XHEIGHT_CONSTANT_LARGE* = 4
  PAN_XHEIGHT_DUCKING_SMALL* = 5
  PAN_XHEIGHT_DUCKING_STD* = 6
  PAN_XHEIGHT_DUCKING_LARGE* = 7
  # PALETTENTRY structure
  PC_EXPLICIT* = 2
  PC_NOCOLLAPSE* = 4
  PC_RESERVED* = 1
  # LOGBRUSH structure
  BS_DIBPATTERN* = 5
  BS_DIBPATTERN8X8* = 8
  BS_DIBPATTERNPT* = 6
  BS_HATCHED* = 2
  BS_HOLLOW* = 1
  BS_NULL* = 1
  BS_PATTERN* = 3
  BS_PATTERN8X8* = 7
  BS_SOLID* = 0
  # DEVMODE structure, field selection bits
  DM_ORIENTATION* = 0x00000001
  DM_PAPERSIZE* = 0x00000002
  DM_PAPERLENGTH* = 0x00000004
  DM_PAPERWIDTH* = 0x00000008
  DM_SCALE* = 0x00000010
  DM_POSITION* = 0x00000020
  DM_NUP* = 0x00000040
  DM_DISPLAYORIENTATION* = 0x00000080
  DM_COPIES* = 0x00000100
  DM_DEFAULTSOURCE* = 0x00000200
  DM_PRINTQUALITY* = 0x00000400
  DM_COLOR* = 0x00000800
  DM_DUPLEX* = 0x00001000
  DM_YRESOLUTION* = 0x00002000
  DM_TTOPTION* = 0x00004000
  DM_COLLATE* = 0x00008000
  DM_FORMNAME* = 0x00010000
  DM_LOGPIXELS* = 0x00020000
  DM_BITSPERPEL* = 0x00040000
  DM_PELSWIDTH* = 0x00080000
  DM_PELSHEIGHT* = 0x00100000
  DM_DISPLAYFLAGS* = 0x00200000
  DM_DISPLAYFREQUENCY* = 0x00400000
  DM_ICMMETHOD* = 0x00800000
  DM_ICMINTENT* = 0x01000000
  DM_MEDIATYPE* = 0x02000000
  DM_DITHERTYPE* = 0x04000000
  DM_PANNINGWIDTH* = 0x08000000
  DM_PANNINGHEIGHT* = 0x10000000
  DM_DISPLAYFIXEDOUTPUT* = 0x20000000
  # orientation selections
  DMORIENT_LANDSCAPE* = 2
  DMORIENT_PORTRAIT* = 1
  # paper selections
  DMPAPER_LETTER* = 1
  DMPAPER_LEGAL* = 5
  DMPAPER_A4* = 9
  DMPAPER_CSHEET* = 24
  DMPAPER_DSHEET* = 25
  DMPAPER_ESHEET* = 26
  DMPAPER_LETTERSMALL* = 2
  DMPAPER_TABLOID* = 3
  DMPAPER_LEDGER* = 4
  DMPAPER_STATEMENT* = 6
  DMPAPER_EXECUTIVE* = 7
  DMPAPER_A3* = 8
  DMPAPER_A4SMALL* = 10
  DMPAPER_A5* = 11
  DMPAPER_B4* = 12
  DMPAPER_B5* = 13
  DMPAPER_FOLIO* = 14
  DMPAPER_QUARTO* = 15
  DMPAPER_10X14* = 16
  DMPAPER_11X17* = 17
  DMPAPER_NOTE* = 18
  DMPAPER_ENV_9* = 19
  DMPAPER_ENV_10* = 20
  DMPAPER_ENV_11* = 21
  DMPAPER_ENV_12* = 22
  DMPAPER_ENV_14* = 23
  DMPAPER_ENV_DL* = 27
  DMPAPER_ENV_C5* = 28
  DMPAPER_ENV_C3* = 29
  DMPAPER_ENV_C4* = 30
  DMPAPER_ENV_C6* = 31
  DMPAPER_ENV_C65* = 32
  DMPAPER_ENV_B4* = 33
  DMPAPER_ENV_B5* = 34
  DMPAPER_ENV_B6* = 35
  DMPAPER_ENV_ITALY* = 36
  DMPAPER_ENV_MONARCH* = 37
  DMPAPER_ENV_PERSONAL* = 38
  DMPAPER_FANFOLD_US* = 39
  DMPAPER_FANFOLD_STD_GERMAN* = 40
  DMPAPER_FANFOLD_LGL_GERMAN* = 41
  DMPAPER_ISO_B4* = 42
  DMPAPER_JAPANESE_POSTCARD* = 43
  DMPAPER_9X11* = 44
  DMPAPER_10X11* = 45
  DMPAPER_15X11* = 46
  DMPAPER_ENV_INVITE* = 47
  DMPAPER_RESERVED_48* = 48
  DMPAPER_RESERVED_49* = 49
  DMPAPER_LETTER_EXTRA* = 50
  DMPAPER_LEGAL_EXTRA* = 51
  DMPAPER_TABLOID_EXTRA* = 52
  DMPAPER_A4_EXTRA* = 53
  DMPAPER_LETTER_TRANSVERSE* = 54
  DMPAPER_A4_TRANSVERSE* = 55
  DMPAPER_LETTER_EXTRA_TRANSVERSE* = 56
  DMPAPER_A_PLUS* = 57
  DMPAPER_B_PLUS* = 58
  DMPAPER_LETTER_PLUS* = 59
  DMPAPER_A4_PLUS* = 60
  DMPAPER_A5_TRANSVERSE* = 61
  DMPAPER_B5_TRANSVERSE* = 62
  DMPAPER_A3_EXTRA* = 63
  DMPAPER_A5_EXTRA* = 64
  DMPAPER_B5_EXTRA* = 65
  DMPAPER_A2* = 66
  DMPAPER_A3_TRANSVERSE* = 67
  DMPAPER_A3_EXTRA_TRANSVERSE* = 68
  DMPAPER_DBL_JAPANESE_POSTCARD* = 69
  DMPAPER_A6* = 70
  DMPAPER_JENV_KAKU2* = 71
  DMPAPER_JENV_KAKU3* = 72
  DMPAPER_JENV_CHOU3* = 73
  DMPAPER_JENV_CHOU4* = 74
  DMPAPER_LETTER_ROTATED* = 75
  DMPAPER_A3_ROTATED* = 76
  DMPAPER_A4_ROTATED* = 77
  DMPAPER_A5_ROTATED* = 78
  DMPAPER_B4_JIS_ROTATED* = 79
  DMPAPER_B5_JIS_ROTATED* = 80
  DMPAPER_JAPANESE_POSTCARD_ROTATED* = 81
  DMPAPER_DBL_JAPANESE_POSTCARD_ROTATED* = 82
  DMPAPER_A6_ROTATED* = 83
  DMPAPER_JENV_KAKU2_ROTATED* = 84
  DMPAPER_JENV_KAKU3_ROTATED* = 85
  DMPAPER_JENV_CHOU3_ROTATED* = 86
  DMPAPER_JENV_CHOU4_ROTATED* = 87
  DMPAPER_B6_JIS* = 88
  DMPAPER_B6_JIS_ROTATED* = 89
  DMPAPER_12X11* = 90
  DMPAPER_JENV_YOU4* = 91
  DMPAPER_JENV_YOU4_ROTATED* = 92
  DMPAPER_P16K* = 93
  DMPAPER_P32K* = 94
  DMPAPER_P32KBIG* = 95
  DMPAPER_PENV_1* = 96
  DMPAPER_PENV_2* = 97
  DMPAPER_PENV_3* = 98
  DMPAPER_PENV_4* = 99
  DMPAPER_PENV_5* = 100
  DMPAPER_PENV_6* = 101
  DMPAPER_PENV_7* = 102
  DMPAPER_PENV_8* = 103
  DMPAPER_PENV_9* = 104
  DMPAPER_PENV_10* = 105
  DMPAPER_P16K_ROTATED* = 106
  DMPAPER_P32K_ROTATED* = 107
  DMPAPER_P32KBIG_ROTATED* = 108
  DMPAPER_PENV_1_ROTATED* = 109
  DMPAPER_PENV_2_ROTATED* = 110
  DMPAPER_PENV_3_ROTATED* = 111
  DMPAPER_PENV_4_ROTATED* = 112
  DMPAPER_PENV_5_ROTATED* = 113
  DMPAPER_PENV_6_ROTATED* = 114
  DMPAPER_PENV_7_ROTATED* = 115
  DMPAPER_PENV_8_ROTATED* = 116
  DMPAPER_PENV_9_ROTATED* = 117
  DMPAPER_PENV_10_ROTATED* = 118
  DMPAPER_USER* = 256
  # bin selections
  DMBIN_UPPER* = 1
  DMBIN_ONLYONE* = 1
  DMBIN_LOWER* = 2
  DMBIN_MIDDLE* = 3
  DMBIN_MANUAL* = 4
  DMBIN_ENVELOPE* = 5
  DMBIN_ENVMANUAL* = 6
  DMBIN_AUTO* = 7
  DMBIN_TRACTOR* = 8
  DMBIN_SMALLFMT* = 9
  DMBIN_LARGEFMT* = 10
  DMBIN_LARGECAPACITY* = 11
  DMBIN_CASSETTE* = 14
  DMBIN_FORMSOURCE* = 15
  DMBIN_USER* = 256
  # print qualities
  DMRES_DRAFT* = -1
  DMRES_LOW* = -2
  DMRES_MEDIUM* = -3
  DMRES_HIGH* = -4
  # color enable/disable for color printers
  DMCOLOR_MONOCHROME* = 1
  DMCOLOR_COLOR* = 2
  # duplex enable
  DMDUP_SIMPLEX* = 1
  DMDUP_VERTICAL* = 2
  DMDUP_HORIZONTAL* = 3
  # TrueType options
  DMTT_BITMAP* = 1
  DMTT_DOWNLOAD* = 2
  DMTT_SUBDEV* = 3
  # Collation selections
  DMCOLLATE_TRUE* = 1
  DMCOLLATE_FALSE* = 0
  # DEVMODE dmDisplayOrientation specifiations
  DMDO_DEFAULT* = 0
  DMDO_90* = 1
  DMDO_180* = 2
  DMDO_270* = 3
  # DEVMODE dmDisplayFixedOutput specifiations
  DMDFO_DEFAULT* = 0
  DMDFO_STRETCH* = 1
  DMDFO_CENTER* = 2
  # Deprecated
  #DM_GRAYSCALE* = 1
  #DM_INTERLACED* = 2
  DMDISPLAYFLAGS_TEXTMODE* = 0x00000004
  # dmNup , multiple logical page per physical page options
  DMNUP_SYSTEM* = 1
  DMNUP_ONEUP* = 2
  # ICM methods
  DMICMMETHOD_NONE* = 1
  DMICMMETHOD_SYSTEM* = 2
  DMICMMETHOD_DRIVER* = 3
  DMICMMETHOD_DEVICE* = 4
  DMICMMETHOD_USER* = 256
  # ICM Intents
  DMICM_SATURATE* = 1
  DMICM_CONTRAST* = 2
  DMICM_COLORMETRIC* = 3
  DMICM_USER* = 256
  # Media types
  DMMEDIA_STANDARD* = 1
  DMMEDIA_TRANSPARENCY* = 2
  DMMEDIA_GLOSSY* = 3
  DMMEDIA_USER* = 256
  # Dither types
  DMDITHER_NONE* = 1
  DMDITHER_COARSE* = 2
  DMDITHER_FINE* = 3
  DMDITHER_LINEART* = 4
  DMDITHER_GRAYSCALE* = 10
  DMDITHER_USER* = 256
  # RGNDATAHEADER structure
  RDH_RECTANGLES* = 1
  # TTPOLYGONHEADER structure
  TT_POLYGON_TYPE* = 24
  # TTPOLYCURVE structure
  TT_PRIM_LINE* = 1
  TT_PRIM_QSPLINE* = 2
  # GCP_RESULTS structure
  GCPCLASS_ARABIC* = 2
  GCPCLASS_HEBREW* = 2
  GCPCLASS_LATIN* = 1
  GCPCLASS_LATINNUMBER* = 5
  GCPCLASS_LOCALNUMBER* = 4
  GCPCLASS_LATINNUMERICSEPARATOR* = 7
  GCPCLASS_LATINNUMERICTERMINATOR* = 6
  GCPCLASS_NEUTRAL* = 3
  GCPCLASS_NUMERICSEPARATOR* = 8
  GCPCLASS_PREBOUNDLTR* = 128
  GCPCLASS_PREBOUNDRTL* = 64
  GCPCLASS_POSTBOUNDLTR* = 32
  GCPCLASS_POSTBOUNDRTL* = 16
  GCPGLYPH_LINKBEFORE* = 32768
  GCPGLYPH_LINKAFTER* = 16384
  # RASTERIZER_STATUS structure
  TT_AVAILABLE* = 1
  TT_ENABLED* = 2
  # COLORADJUSTMENT structure
  CA_NEGATIVE* = 1
  CA_LOG_FILTER* = 2
  ILLUMINANT_DEVICE_DEFAULT* = 0
  ILLUMINANT_A* = 1
  ILLUMINANT_B* = 2
  ILLUMINANT_C* = 3
  ILLUMINANT_D50* = 4
  ILLUMINANT_D55* = 5
  ILLUMINANT_D65* = 6
  ILLUMINANT_D75* = 7
  ILLUMINANT_F2* = 8
  ILLUMINANT_TUNGSTEN* = 1
  ILLUMINANT_DAYLIGHT* = 3
  ILLUMINANT_FLUORESCENT* = 8
  ILLUMINANT_NTSC* = 3
  # DOCINFO structure
  DI_APPBANDING* = 1
  # EMRMETAHEADER structure
  EMR_HEADER* = 1
  ENHMETA_SIGNATURE* = 1179469088
  # RTF event masks
  ENM_CHANGE* = 1
  ENM_CORRECTTEXT* = 4194304
  ENM_DROPFILES* = 1048576
  ENM_KEYEVENTS* = 65536
  ENM_MOUSEEVENTS* = 131072
  ENM_PROTECTED* = 2097152
  ENM_REQUESTRESIZE* = 262144
  ENM_SCROLL* = 4
  ENM_SELCHANGE* = 524288
  ENM_UPDATE* = 2
  ENM_NONE* = 0
  # RTF styles
  ES_DISABLENOSCROLL* = 8192
  ES_EX_NOCALLOLEINIT* = 16777216
  ES_NOIME* = 524288
  ES_SAVESEL* = 32768
  ES_SELFIME* = 262144
  ES_SUNKEN* = 16384
  ES_VERTICAL* = 4194304
  ES_SELECTIONBAR* = 16777216
  # EM_SETOPTIONS message
  ECOOP_SET* = 1
  ECOOP_OR* = 2
  ECOOP_AND* = 3
  ECOOP_XOR* = 4
  ECO_AUTOWORDSELECTION* = 1
  ECO_AUTOVSCROLL* = 64
  ECO_AUTOHSCROLL* = 128
  ECO_NOHIDESEL* = 256
  ECO_READONLY* = 2048
  ECO_WANTRETURN* = 4096
  ECO_SAVESEL* = 32768
  ECO_SELECTIONBAR* = 16777216
  ECO_VERTICAL* = 4194304
  # EM_SETCHARFORMAT message
  SCF_WORD* = 2
  SCF_SELECTION* = 1
  # EM_STREAMOUT message
  SF_TEXT* = 1
  SF_RTF* = 2
  SF_RTFNOOBJS* = 3
  SF_TEXTIZED* = 4
  SFF_SELECTION* = 32768
  SFF_PLAINRTF* = 16384
  # EM_FINDWORDBREAK message
  WB_CLASSIFY* = 3
  #WB_ISDELIMITER = 2;
  #     WB_LEFT = 0; already above
  WB_LEFTBREAK* = 6
  WB_PREVBREAK* = 6
  WB_MOVEWORDLEFT* = 4
  WB_MOVEWORDPREV* = 4
  WB_MOVEWORDRIGHT* = 5
  WB_MOVEWORDNEXT* = 5
  #WB_RIGHT = 1;already above
  WB_RIGHTBREAK* = 7
  WB_NEXTBREAK* = 7
  # EM_GETPUNCTUATION message
  PC_LEADING* = 2
  PC_FOLLOWING* = 1
  PC_DELIMITER* = 4
  PC_OVERFLOW* = 3
  # EM_SETWORDWRAPMODE message
  WBF_WORDWRAP* = 16
  WBF_WORDBREAK* = 32
  WBF_OVERFLOW* = 64
  WBF_LEVEL1* = 128
  WBF_LEVEL2* = 256
  WBF_CUSTOM* = 512
  WBF_BREAKAFTER* = 64
  WBF_BREAKLINE* = 32
  WBF_ISWHITE* = 16
  # CHARFORMAT structure
  CFM_BOLD* = 1
  CFM_COLOR* = 1073741824
  CFM_FACE* = 536870912
  CFM_ITALIC* = 2
  CFM_OFFSET* = 268435456
  CFM_PROTECTED* = 16
  CFM_SIZE* = 0x80000000
  CFM_STRIKEOUT* = 8
  CFM_UNDERLINE* = 4
  CFE_AUTOCOLOR* = 1073741824
  CFE_BOLD* = 1
  CFE_ITALIC* = 2
  CFE_STRIKEOUT* = 8
  CFE_UNDERLINE* = 4
  CFE_PROTECTED* = 16
  # PARAFORMAT structure
  PFM_ALIGNMENT* = 8
  PFM_NUMBERING* = 32
  PFM_OFFSET* = 4
  PFM_OFFSETINDENT* = 0x80000000
  PFM_RIGHTINDENT* = 2
  PFM_STARTINDENT* = 1
  PFM_TABSTOPS* = 16
  PFN_BULLET* = 1
  PFA_LEFT* = 1
  PFA_RIGHT* = 2
  PFA_CENTER* = 3
  # SELCHANGE structure
  SEL_EMPTY* = 0
  SEL_TEXT* = 1
  SEL_OBJECT* = 2
  SEL_MULTICHAR* = 4
  SEL_MULTIOBJECT* = 8
  # RTF clipboard formats
  CF_RTF* = "Rich Text Format"
  CF_RETEXTOBJ* = "RichEdit Text and Objects"
  # DRAWITEMSTRUCT structure
  ODT_BUTTON* = 4
  ODT_COMBOBOX* = 3
  ODT_LISTBOX* = 2
  ODT_LISTVIEW* = 102
  ODT_MENU* = 1
  ODT_STATIC* = 5
  ODT_TAB* = 101
  ODT_HEADER* = 100
  ODA_DRAWENTIRE* = 1
  ODA_FOCUS* = 4
  ODA_SELECT* = 2
  ODS_SELECTED* = 1
  ODS_GRAYED* = 2
  ODS_DISABLED* = 4
  ODS_CHECKED* = 8
  ODS_FOCUS* = 16
  ODS_DEFAULT* = 32
  ODS_HOTLIGHT* = 0x00000040
  ODS_INACTIVE* = 0x00000080
  ODS_NOACCEL* = 0x00000100
  ODS_NOFOCUSRECT* = 0x00000200
  ODS_COMBOBOXEDIT* = 0x00001000
  # Common control styles
  CCS_ADJUSTABLE* = 0x00000020
  CCS_BOTTOM* = 0x00000003
  CCS_NODIVIDER* = 0x00000040
  CCS_NOMOVEY* = 0x00000002
  CCS_NOPARENTALIGN* = 0x00000008
  CCS_NORESIZE* = 0x00000004
  CCS_TOP* = 0x00000001

  # Common control window classes
  ANIMATE_CLASSW* = "SysAnimate32"
  HOTKEY_CLASSW* = "msctls_hotkey32"
  PROGRESS_CLASSW* = "msctls_progress32"
  STATUSCLASSNAMEW* = "msctls_statusbar32"
  TOOLBARCLASSNAMEW* = "ToolbarWindow32"
  TOOLTIPS_CLASSW* = "tooltips_class32"
  TRACKBAR_CLASSW* = "msctls_trackbar32"
  UPDOWN_CLASSW* = "msctls_updown32"
  WC_HEADERW* = "SysHeader32"
  WC_LISTVIEWW* = "SysListView32"
  WC_TABCONTROLW* = "SysTabControl32"
  WC_TREEVIEWW* = "SysTreeView32"

  ANIMATE_CLASSA* = "SysAnimate32"
  HOTKEY_CLASSA* = "msctls_hotkey32"
  PROGRESS_CLASSA* = "msctls_progress32"
  STATUSCLASSNAMEA* = "msctls_statusbar32"
  TOOLBARCLASSNAMEA* = "ToolbarWindow32"
  TOOLTIPS_CLASSA* = "tooltips_class32"
  TRACKBAR_CLASSA* = "msctls_trackbar32"
  UPDOWN_CLASSA* = "msctls_updown32"
  WC_HEADERA* = "SysHeader32"
  WC_LISTVIEWA* = "SysListView32"
  WC_TABCONTROLA* = "SysTabControl32"
  WC_TREEVIEWA* = "SysTreeView32"

when defined(winUnicode):
  const
    ANIMATE_CLASS* = ANIMATE_CLASSW
    HOTKEY_CLASS* = HOTKEY_CLASSW
    PROGRESS_CLASS* = PROGRESS_CLASSW
    STATUSCLASSNAME* = STATUSCLASSNAMEW
    TOOLBARCLASSNAME* = TOOLBARCLASSNAMEW
    TOOLTIPS_CLASS* = TOOLTIPS_CLASSW
    TRACKBAR_CLASS* = TRACKBAR_CLASSW
    UPDOWN_CLASS* = UPDOWN_CLASSW
    WC_HEADER* = WC_HEADERW
    WC_LISTVIEW* = WC_LISTVIEWW
    WC_TABCONTROL* = WC_TABCONTROLW
    WC_TREEVIEW* = WC_TREEVIEWW
else:
  const
    ANIMATE_CLASS* = ANIMATE_CLASSA
    HOTKEY_CLASS* = HOTKEY_CLASSA
    PROGRESS_CLASS* = PROGRESS_CLASSA
    STATUSCLASSNAME* = STATUSCLASSNAMEA
    TOOLBARCLASSNAME* = TOOLBARCLASSNAMEA
    TOOLTIPS_CLASS* = TOOLTIPS_CLASSA
    TRACKBAR_CLASS* = TRACKBAR_CLASSA
    UPDOWN_CLASS* = UPDOWN_CLASSA
    WC_HEADER* = WC_HEADERA
    WC_LISTVIEW* = WC_LISTVIEWA
    WC_TABCONTROL* = WC_TABCONTROLA
    WC_TREEVIEW* = WC_TREEVIEWA
# UNICODE

const
  # Header control styles
  HDS_BUTTONS* = 2
  HDS_HIDDEN* = 8
  HDS_HORZ* = 0
  # HD_ITEM structure
  HDI_BITMAP* = 16
  HDI_FORMAT* = 4
  HDI_HEIGHT* = 1
  HDI_LPARAM* = 8
  HDI_TEXT* = 2
  HDI_WIDTH* = 1
  HDF_CENTER* = 2
  HDF_LEFT* = 0
  HDF_RIGHT* = 1
  HDF_RTLREADING* = 4
  HDF_BITMAP* = 8192
  HDF_OWNERDRAW* = 32768
  HDF_STRING* = 16384
  HDF_JUSTIFYMASK* = 3
  # HD_HITTESTINFO structure
  HHT_NOWHERE* = 1
  HHT_ONDIVIDER* = 4
  HHT_ONDIVOPEN* = 8
  HHT_ONHEADER* = 2
  HHT_TOLEFT* = 2048
  HHT_TORIGHT* = 1024
  # TBADDBITMAP structure
  HINST_COMMCTRL* = HINST(-1)

const
  IDB_STD_LARGE_COLOR* = 1
  IDB_STD_SMALL_COLOR* = 0
  IDB_VIEW_LARGE_COLOR* = 5
  IDB_VIEW_SMALL_COLOR* = 4
  STD_COPY* = 1
  STD_CUT* = 0
  STD_DELETE* = 5
  STD_FILENEW* = 6
  STD_FILEOPEN* = 7
  STD_FILESAVE* = 8
  STD_FIND* = 12
  STD_HELP* = 11
  STD_PASTE* = 2
  STD_PRINT* = 14
  STD_PRINTPRE* = 9
  STD_PROPERTIES* = 10
  STD_REDOW* = 4
  STD_REPLACE* = 13
  STD_UNDO* = 3
  VIEW_LARGEICONS* = 0
  VIEW_SMALLICONS* = 1
  VIEW_LIST* = 2
  VIEW_DETAILS* = 3
  VIEW_SORTNAME* = 4
  VIEW_SORTSIZE* = 5
  VIEW_SORTDATE* = 6
  VIEW_SORTTYPE* = 7
  # Toolbar styles
  TBSTYLE_ALTDRAG* = 1024
  TBSTYLE_TOOLTIPS* = 256
  TBSTYLE_WRAPABLE* = 512
  TBSTYLE_BUTTON* = 0
  TBSTYLE_CHECK* = 2
  TBSTYLE_CHECKGROUP* = 6
  TBSTYLE_GROUP* = 4
  TBSTYLE_SEP* = 1
  # Toolbar states
  TBSTATE_CHECKED* = 1
  TBSTATE_ENABLED* = 4
  TBSTATE_HIDDEN* = 8
  TBSTATE_INDETERMINATE* = 16
  TBSTATE_PRESSED* = 2
  TBSTATE_WRAP* = 32
  # Tooltip styles
  TTS_ALWAYSTIP* = 1
  TTS_NOPREFIX* = 2
  # TOOLINFO structure
  TTF_IDISHWND* = 1
  TTF_CENTERTIP* = 2
  TTF_RTLREADING* = 4
  TTF_SUBCLASS* = 16
  # TTM_SETDELAYTIME message
  TTDT_AUTOMATIC* = 0
  TTDT_AUTOPOP* = 2
  TTDT_INITIAL* = 3
  TTDT_RESHOW* = 1
  # Status window
  SBARS_SIZEGRIP* = 256
  #SBARS_SIZEGRIP = 256;already above
  # DL_DRAGGING message
  DL_MOVECURSOR* = 3
  DL_COPYCURSOR* = 2
  DL_STOPCURSOR* = 1
  # Up-down control styles
  UDS_ALIGNLEFT* = 8
  UDS_ALIGNRIGHT* = 4
  UDS_ARROWKEYS* = 32
  UDS_AUTOBUDDY* = 16
  UDS_HORZ* = 64
  UDS_NOTHOUSANDS* = 128
  UDS_SETBUDDYINT* = 2
  UDS_WRAP* = 1
  # UDM_SETRANGE message
  UD_MAXVAL* = 32767
  UD_MINVAL* = -32767
  # HKM_GETHOTKEY message
  HOTKEYF_ALT* = 4
  HOTKEYF_CONTROL* = 2
  HOTKEYF_EXT* = 8
  HOTKEYF_SHIFT* = 1
  # HKM_SETRULES message
  HKCOMB_A* = 8
  HKCOMB_C* = 4
  HKCOMB_CA* = 64
  HKCOMB_NONE* = 1
  HKCOMB_S* = 2
  HKCOMB_SA* = 32
  HKCOMB_SC* = 16
  HKCOMB_SCA* = 128
  # Trackbar styles
  TBS_HORZ* = 0
  TBS_VERT* = 2
  TBS_AUTOTICKS* = 1
  TBS_NOTICKS* = 16
  TBS_TOP* = 4
  TBS_BOTTOM* = 0
  TBS_LEFT* = 4
  TBS_RIGHT* = 0
  TBS_BOTH* = 8
  TBS_ENABLESELRANGE* = 32
  TBS_FIXEDLENGTH* = 64
  TBS_NOTHUMB* = 128
  TB_BOTTOM* = 7
  TB_ENDTRACK* = 8
  TB_LINEDOWN* = 1
  TB_LINEUP* = 0
  TB_PAGEDOWN* = 3
  TB_PAGEUP* = 2
  TB_THUMBPOSITION* = 4
  TB_THUMBTRACK* = 5
  TB_TOP* = 6
  # List view styles
  LVS_ALIGNLEFT* = 2048
  LVS_ALIGNTOP* = 0
  LVS_AUTOARRANGE* = 256
  LVS_EDITLABELS* = 512
  LVS_ICON* = 0
  LVS_LIST* = 3
  LVS_NOCOLUMNHEADER* = 16384
  LVS_NOLABELWRAP* = 128
  LVS_NOSCROLL* = 8192
  LVS_NOSORTHEADER* = 32768
  LVS_OWNERDRAWFIXED* = 1024
  LVS_REPORT* = 1
  LVS_SHAREIMAGELISTS* = 64
  LVS_SHOWSELALWAYS* = 8
  LVS_SINGLESEL* = 4
  LVS_SMALLICON* = 2
  LVS_SORTASCENDING* = 16
  LVS_SORTDESCENDING* = 32
  LVS_TYPESTYLEMASK* = 64512
  LVSIL_NORMAL* = 0
  LVSIL_SMALL* = 1
  LVSIL_STATE* = 2
  LVIS_CUT* = 4
  LVIS_DROPHILITED* = 8
  LVIS_FOCUSED* = 1
  LVIS_SELECTED* = 2
  LVIS_OVERLAYMASK* = 3840
  LVIS_STATEIMAGEMASK* = 61440

  LPSTR_TEXTCALLBACKW* = cast[LPWSTR](-1)
  LPSTR_TEXTCALLBACKA* = cast[LPSTR](-1)
when defined(winUnicode):
  const LPSTR_TEXTCALLBACK*  = cast[LPWSTR](-1)
else:
  const LPSTR_TEXTCALLBACK*  = cast[LPSTR](-1)

const
  LVIF_TEXT* = 1
  LVIF_IMAGE* = 2
  LVIF_PARAM* = 4
  LVIF_STATE* = 8
  LVIF_DI_SETITEM* = 4096
  # LVM_GETNEXTITEM structure
  LVNI_ABOVE* = 256
  LVNI_ALL* = 0
  LVNI_BELOW* = 512
  LVNI_TOLEFT* = 1024
  LVNI_TORIGHT* = 2048
  LVNI_CUT* = 4
  LVNI_DROPHILITED* = 8
  LVNI_FOCUSED* = 1
  LVNI_SELECTED* = 2
  # LV_FINDINFO structure
  LVFI_PARAM* = 1
  LVFI_PARTIAL* = 8
  LVFI_STRING* = 2
  LVFI_WRAP* = 32
  LVFI_NEARESTXY* = 64
  # LV_HITTESTINFO structure
  LVHT_ABOVE* = 8
  LVHT_BELOW* = 16
  LVHT_NOWHERE* = 1
  LVHT_ONITEMICON* = 2
  LVHT_ONITEMLABEL* = 4
  LVHT_ONITEMSTATEICON* = 8
  LVHT_TOLEFT* = 64
  LVHT_TORIGHT* = 32
  # LV_COLUMN structure
  LVCF_FMT* = 1
  LVCF_SUBITEM* = 8
  LVCF_TEXT* = 4
  LVCF_WIDTH* = 2
  LVCFMT_CENTER* = 2
  LVCFMT_LEFT* = 0
  LVCFMT_RIGHT* = 1
  # ListView_GetItemRect
  LVIR_BOUNDS* = 0
  LVIR_ICON* = 1
  LVIR_LABEL* = 2
  LVIR_SELECTBOUNDS* = 3
  # LVM_ARRANGE message
  LVA_ALIGNLEFT* = 1
  LVA_ALIGNTOP* = 2
  LVA_DEFAULT* = 0
  LVA_SNAPTOGRID* = 5
  # LVM_SETCOLUMNWIDTH message
  LVSCW_AUTOSIZE* = -1
  LVSCW_AUTOSIZE_USEHEADER* = -2
  # Tree View styles
  TVS_DISABLEDRAGDROP* = 16
  TVS_EDITLABELS* = 8
  TVS_HASBUTTONS* = 1
  TVS_HASLINES* = 2
  TVS_LINESATROOT* = 4
  TVS_SHOWSELALWAYS* = 32
  # Tree View states
  TVIS_BOLD* = 16
  TVIS_CUT* = 4
  TVIS_DROPHILITED* = 8
  TVIS_EXPANDED* = 32
  TVIS_EXPANDEDONCE* = 64
  TVIS_FOCUSED* = 1
  TVIS_OVERLAYMASK* = 3840
  TVIS_SELECTED* = 2
  TVIS_STATEIMAGEMASK* = 61440
  TVIS_USERMASK* = 61440
  # TV_ITEM structure
  TVIF_CHILDREN* = 64
  TVIF_HANDLE* = 16
  TVIF_IMAGE* = 2
  TVIF_PARAM* = 4
  TVIF_SELECTEDIMAGE* = 32
  TVIF_STATE* = 8
  TVIF_TEXT* = 1
  I_CHILDRENCALLBACK* = -1
  I_IMAGECALLBACK* = -1
  # TV_INSERTSTRUCT structure

type
  TTREEITEM* {.final, pure.} = object
  HTREEITEM* = ptr TTREEITEM
  PTREEITEM* = ptr TTREEITEM

const
  TVI_ROOT* =  cast[HTREEITEM](0xFFFF0000)
  TVI_FIRST* = cast[HTREEITEM](0xFFFF0001)
  TVI_LAST* =  cast[HTREEITEM](0xFFFF0002)
  TVI_SORT* =  cast[HTREEITEM](0xFFFF0003)

const
  # TV_HITTESTINFO structure
  TVHT_ABOVE* = 256
  TVHT_BELOW* = 512
  TVHT_NOWHERE* = 1
  TVHT_ONITEM* = 70
  TVHT_ONITEMBUTTON* = 16
  TVHT_ONITEMICON* = 2
  TVHT_ONITEMINDENT* = 8
  TVHT_ONITEMLABEL* = 4
  TVHT_ONITEMRIGHT* = 32
  TVHT_ONITEMSTATEICON* = 64
  TVHT_TOLEFT* = 2048
  TVHT_TORIGHT* = 1024
  # TVM_EXPAND message
  TVE_COLLAPSE* = 1
  TVE_COLLAPSERESET* = 32768
  TVE_EXPAND* = 2
  TVE_TOGGLE* = 3
  # TVM_GETIMAGELIST message
  TVSIL_NORMAL* = 0
  TVSIL_STATE* = 2
  # TVM_GETNEXTITEM message
  TVGN_CARET* = 9
  TVGN_CHILD* = 4
  TVGN_DROPHILITE* = 8
  TVGN_FIRSTVISIBLE* = 5
  TVGN_NEXT* = 1
  TVGN_NEXTVISIBLE* = 6
  TVGN_PARENT* = 3
  TVGN_PREVIOUS* = 2
  TVGN_PREVIOUSVISIBLE* = 7
  TVGN_ROOT* = 0
  # TVN_SELCHANGED message
  TVC_BYKEYBOARD* = 2
  TVC_BYMOUSE* = 1
  TVC_UNKNOWN* = 0
  # Tab control styles
  TCS_BUTTONS* = 256
  TCS_FIXEDWIDTH* = 1024
  TCS_FOCUSNEVER* = 32768
  TCS_FOCUSONBUTTONDOWN* = 4096
  TCS_FORCEICONLEFT* = 16
  TCS_FORCELABELLEFT* = 32
  TCS_MULTILINE* = 512
  TCS_OWNERDRAWFIXED* = 8192
  TCS_RAGGEDRIGHT* = 2048
  TCS_RIGHTJUSTIFY* = 0
  TCS_SINGLELINE* = 0
  TCS_TABS* = 0
  TCS_TOOLTIPS* = 16384
  # TC_ITEM structure
  TCIF_TEXT* = 1
  TCIF_IMAGE* = 2
  TCIF_PARAM* = 8
  TCIF_RTLREADING* = 4
  # TC_HITTESTINFO structure
  TCHT_NOWHERE* = 1
  TCHT_ONITEM* = 6
  TCHT_ONITEMICON* = 2
  TCHT_ONITEMLABEL* = 4
  # Animation control styles
  ACS_AUTOPLAY* = 4
  ACS_CENTER* = 1
  ACS_TRANSPARENT* = 2
  # MODEMDEVCAPS structure
  DIALOPTION_BILLING* = 64
  DIALOPTION_QUIET* = 128
  DIALOPTION_DIALTONE* = 256
  MDMVOLFLAG_LOW* = 1
  MDMVOLFLAG_MEDIUM* = 2
  MDMVOLFLAG_HIGH* = 4
  MDMVOL_LOW* = 0
  MDMVOL_MEDIUM* = 1
  MDMVOL_HIGH* = 2
  MDMSPKRFLAG_OFF* = 1
  MDMSPKRFLAG_DIAL* = 2
  MDMSPKRFLAG_ON* = 4
  MDMSPKRFLAG_CALLSETUP* = 8
  MDMSPKR_OFF* = 0
  MDMSPKR_DIAL* = 1
  MDMSPKR_ON* = 2
  MDMSPKR_CALLSETUP* = 3
  MDM_BLIND_DIAL* = 512
  MDM_CCITT_OVERRIDE* = 64
  MDM_CELLULAR* = 8
  MDM_COMPRESSION* = 1
  MDM_ERROR_CONTROL* = 2
  MDM_FLOWCONTROL_HARD* = 16
  MDM_FLOWCONTROL_SOFT* = 32
  MDM_FORCED_EC* = 4
  MDM_SPEED_ADJUST* = 128
  MDM_TONE_DIAL* = 256
  MDM_V23_OVERRIDE* = 1024

  # Languages
  #
  #  Language IDs.
  #
  #  The following two combinations of primary language ID and
  #  sublanguage ID have special semantics:
  #
  #    Primary Language ID   Sublanguage ID      Result
  #    -------------------   ---------------     ------------------------
  #    LANG_NEUTRAL          SUBLANG_NEUTRAL     Language neutral
  #    LANG_NEUTRAL          SUBLANG_DEFAULT     User default language
  #    LANG_NEUTRAL          SUBLANG_SYS_DEFAULT System default language
  #    LANG_INVARIANT        SUBLANG_NEUTRAL     Invariant locale
  #
  #
  #  Primary language IDs.
  #
  LANG_NEUTRAL* = 0x00000000
  LANG_INVARIANT* = 0x0000007F
  LANG_AFRIKAANS* = 0x00000036
  LANG_ALBANIAN* = 0x0000001C
  LANG_ARABIC* = 0x00000001
  LANG_ARMENIAN* = 0x0000002B
  LANG_ASSAMESE* = 0x0000004D
  LANG_AZERI* = 0x0000002C
  LANG_BASQUE* = 0x0000002D
  LANG_BELARUSIAN* = 0x00000023
  LANG_BENGALI* = 0x00000045
  LANG_BULGARIAN* = 0x00000002
  LANG_CATALAN* = 0x00000003
  LANG_CHINESE* = 0x00000004
  LANG_CROATIAN* = 0x0000001A
  LANG_CZECH* = 0x00000005
  LANG_DANISH* = 0x00000006
  LANG_DIVEHI* = 0x00000065
  LANG_DUTCH* = 0x00000013
  LANG_ENGLISH* = 0x00000009
  LANG_ESTONIAN* = 0x00000025
  LANG_FAEROESE* = 0x00000038
  LANG_FARSI* = 0x00000029
  LANG_FINNISH* = 0x0000000B
  LANG_FRENCH* = 0x0000000C
  LANG_GALICIAN* = 0x00000056
  LANG_GEORGIAN* = 0x00000037
  LANG_GERMAN* = 0x00000007
  LANG_GREEK* = 0x00000008
  LANG_GUJARATI* = 0x00000047
  LANG_HEBREW* = 0x0000000D
  LANG_HINDI* = 0x00000039
  LANG_HUNGARIAN* = 0x0000000E
  LANG_ICELANDIC* = 0x0000000F
  LANG_INDONESIAN* = 0x00000021
  LANG_ITALIAN* = 0x00000010
  LANG_JAPANESE* = 0x00000011
  LANG_KANNADA* = 0x0000004B
  LANG_KASHMIRI* = 0x00000060
  LANG_KAZAK* = 0x0000003F
  LANG_KONKANI* = 0x00000057
  LANG_KOREAN* = 0x00000012
  LANG_KYRGYZ* = 0x00000040
  LANG_LATVIAN* = 0x00000026
  LANG_LITHUANIAN* = 0x00000027
  LANG_MACEDONIAN* = 0x0000002F # the Former Yugoslav Republic of Macedonia
  LANG_MALAY* = 0x0000003E
  LANG_MALAYALAM* = 0x0000004C
  LANG_MANIPURI* = 0x00000058
  LANG_MARATHI* = 0x0000004E
  LANG_MONGOLIAN* = 0x00000050
  LANG_NEPALI* = 0x00000061
  LANG_NORWEGIAN* = 0x00000014
  LANG_ORIYA* = 0x00000048
  LANG_POLISH* = 0x00000015
  LANG_PORTUGUESE* = 0x00000016
  LANG_PUNJABI* = 0x00000046
  LANG_ROMANIAN* = 0x00000018
  LANG_RUSSIAN* = 0x00000019
  LANG_SANSKRIT* = 0x0000004F
  LANG_SERBIAN* = 0x0000001A
  LANG_SINDHI* = 0x00000059
  LANG_SLOVAK* = 0x0000001B
  LANG_SLOVENIAN* = 0x00000024
  LANG_SPANISH* = 0x0000000A
  LANG_SWAHILI* = 0x00000041
  LANG_SWEDISH* = 0x0000001D
  LANG_SYRIAC* = 0x0000005A
  LANG_TAMIL* = 0x00000049
  LANG_TATAR* = 0x00000044
  LANG_TELUGU* = 0x0000004A
  LANG_THAI* = 0x0000001E
  LANG_TURKISH* = 0x0000001F
  LANG_UKRAINIAN* = 0x00000022
  LANG_URDU* = 0x00000020
  LANG_UZBEK* = 0x00000043
  LANG_VIETNAMESE* = 0x0000002A
  #
  #  Sublanguage IDs.
  #
  #  The name immediately following SUBLANG_ dictates which primary
  #  language ID that sublanguage ID can be combined with to form a
  #  valid language ID.
  #
  SUBLANG_NEUTRAL* = 0x00000000 # language neutral
  SUBLANG_DEFAULT* = 0x00000001 # user default
  SUBLANG_SYS_DEFAULT* = 0x00000002 # system default
  SUBLANG_ARABIC_SAUDI_ARABIA* = 0x00000001 # Arabic (Saudi Arabia)
  SUBLANG_ARABIC_IRAQ* = 0x00000002 # Arabic (Iraq)
  SUBLANG_ARABIC_EGYPT* = 0x00000003 # Arabic (Egypt)
  SUBLANG_ARABIC_LIBYA* = 0x00000004 # Arabic (Libya)
  SUBLANG_ARABIC_ALGERIA* = 0x00000005 # Arabic (Algeria)
  SUBLANG_ARABIC_MOROCCO* = 0x00000006 # Arabic (Morocco)
  SUBLANG_ARABIC_TUNISIA* = 0x00000007 # Arabic (Tunisia)
  SUBLANG_ARABIC_OMAN* = 0x00000008 # Arabic (Oman)
  SUBLANG_ARABIC_YEMEN* = 0x00000009 # Arabic (Yemen)
  SUBLANG_ARABIC_SYRIA* = 0x0000000A # Arabic (Syria)
  SUBLANG_ARABIC_JORDAN* = 0x0000000B # Arabic (Jordan)
  SUBLANG_ARABIC_LEBANON* = 0x0000000C # Arabic (Lebanon)
  SUBLANG_ARABIC_KUWAIT* = 0x0000000D # Arabic (Kuwait)
  SUBLANG_ARABIC_UAE* = 0x0000000E # Arabic (U.A.E)
  SUBLANG_ARABIC_BAHRAIN* = 0x0000000F # Arabic (Bahrain)
  SUBLANG_ARABIC_QATAR* = 0x00000010 # Arabic (Qatar)
  SUBLANG_AZERI_LATIN* = 0x00000001 # Azeri (Latin)
  SUBLANG_AZERI_CYRILLIC* = 0x00000002 # Azeri (Cyrillic)
  SUBLANG_CHINESE_TRADITIONAL* = 0x00000001 # Chinese (Taiwan)
  SUBLANG_CHINESE_SIMPLIFIED* = 0x00000002 # Chinese (PR China)
  SUBLANG_CHINESE_HONGKONG* = 0x00000003 # Chinese (Hong Kong S.A.R., P.R.C.)
  SUBLANG_CHINESE_SINGAPORE* = 0x00000004 # Chinese (Singapore)
  SUBLANG_CHINESE_MACAU* = 0x00000005 # Chinese (Macau S.A.R.)
  SUBLANG_DUTCH* = 0x00000001 # Dutch
  SUBLANG_DUTCH_BELGIAN* = 0x00000002 # Dutch (Belgian)
  SUBLANG_ENGLISH_US* = 0x00000001 # English (USA)
  SUBLANG_ENGLISH_UK* = 0x00000002 # English (UK)
  SUBLANG_ENGLISH_AUS* = 0x00000003 # English (Australian)
  SUBLANG_ENGLISH_CAN* = 0x00000004 # English (Canadian)
  SUBLANG_ENGLISH_NZ* = 0x00000005 # English (New Zealand)
  SUBLANG_ENGLISH_EIRE* = 0x00000006 # English (Irish)
  SUBLANG_ENGLISH_SOUTH_AFRICA* = 0x00000007 # English (South Africa)
  SUBLANG_ENGLISH_JAMAICA* = 0x00000008 # English (Jamaica)
  SUBLANG_ENGLISH_CARIBBEAN* = 0x00000009 # English (Caribbean)
  SUBLANG_ENGLISH_BELIZE* = 0x0000000A # English (Belize)
  SUBLANG_ENGLISH_TRINIDAD* = 0x0000000B # English (Trinidad)
  SUBLANG_ENGLISH_ZIMBABWE* = 0x0000000C # English (Zimbabwe)
  SUBLANG_ENGLISH_PHILIPPINES* = 0x0000000D # English (Philippines)
  SUBLANG_FRENCH* = 0x00000001 # French
  SUBLANG_FRENCH_BELGIAN* = 0x00000002 # French (Belgian)
  SUBLANG_FRENCH_CANADIAN* = 0x00000003 # French (Canadian)
  SUBLANG_FRENCH_SWISS* = 0x00000004 # French (Swiss)
  SUBLANG_FRENCH_LUXEMBOURG* = 0x00000005 # French (Luxembourg)
  SUBLANG_FRENCH_MONACO* = 0x00000006 # French (Monaco)
  SUBLANG_GERMAN* = 0x00000001 # German
  SUBLANG_GERMAN_SWISS* = 0x00000002 # German (Swiss)
  SUBLANG_GERMAN_AUSTRIAN* = 0x00000003 # German (Austrian)
  SUBLANG_GERMAN_LUXEMBOURG* = 0x00000004 # German (Luxembourg)
  SUBLANG_GERMAN_LIECHTENSTEIN* = 0x00000005 # German (Liechtenstein)
  SUBLANG_ITALIAN* = 0x00000001 # Italian
  SUBLANG_ITALIAN_SWISS* = 0x00000002 # Italian (Swiss)
  SUBLANG_KASHMIRI_SASIA* = 0x00000002 # Kashmiri (South Asia)
  SUBLANG_KASHMIRI_INDIA* = 0x00000002 # For app compatibility only
  SUBLANG_KOREAN* = 0x00000001 # Korean (Extended Wansung)
  SUBLANG_LITHUANIAN* = 0x00000001 # Lithuanian
  SUBLANG_MALAY_MALAYSIA* = 0x00000001 # Malay (Malaysia)
  SUBLANG_MALAY_BRUNEI_DARUSSALAM* = 0x00000002 # Malay (Brunei Darussalam)
  SUBLANG_NEPALI_INDIA* = 0x00000002 # Nepali (India)
  SUBLANG_NORWEGIAN_BOKMAL* = 0x00000001 # Norwegian (Bokmal)
  SUBLANG_NORWEGIAN_NYNORSK* = 0x00000002 # Norwegian (Nynorsk)
  SUBLANG_PORTUGUESE* = 0x00000002 # Portuguese
  SUBLANG_PORTUGUESE_BRAZILIAN* = 0x00000001 # Portuguese (Brazilian)
  SUBLANG_SERBIAN_LATIN* = 0x00000002 # Serbian (Latin)
  SUBLANG_SERBIAN_CYRILLIC* = 0x00000003 # Serbian (Cyrillic)
  SUBLANG_SPANISH* = 0x00000001 # Spanish (Castilian)
  SUBLANG_SPANISH_MEXICAN* = 0x00000002 # Spanish (Mexican)
  SUBLANG_SPANISH_MODERN* = 0x00000003 # Spanish (Spain)
  SUBLANG_SPANISH_GUATEMALA* = 0x00000004 # Spanish (Guatemala)
  SUBLANG_SPANISH_COSTA_RICA* = 0x00000005 # Spanish (Costa Rica)
  SUBLANG_SPANISH_PANAMA* = 0x00000006 # Spanish (Panama)
  SUBLANG_SPANISH_DOMINICAN_REPUBLIC* = 0x00000007 # Spanish (Dominican Republic)
  SUBLANG_SPANISH_VENEZUELA* = 0x00000008 # Spanish (Venezuela)
  SUBLANG_SPANISH_COLOMBIA* = 0x00000009 # Spanish (Colombia)
  SUBLANG_SPANISH_PERU* = 0x0000000A # Spanish (Peru)
  SUBLANG_SPANISH_ARGENTINA* = 0x0000000B # Spanish (Argentina)
  SUBLANG_SPANISH_ECUADOR* = 0x0000000C # Spanish (Ecuador)
  SUBLANG_SPANISH_CHILE* = 0x0000000D # Spanish (Chile)
  SUBLANG_SPANISH_URUGUAY* = 0x0000000E # Spanish (Uruguay)
  SUBLANG_SPANISH_PARAGUAY* = 0x0000000F # Spanish (Paraguay)
  SUBLANG_SPANISH_BOLIVIA* = 0x00000010 # Spanish (Bolivia)
  SUBLANG_SPANISH_EL_SALVADOR* = 0x00000011 # Spanish (El Salvador)
  SUBLANG_SPANISH_HONDURAS* = 0x00000012 # Spanish (Honduras)
  SUBLANG_SPANISH_NICARAGUA* = 0x00000013 # Spanish (Nicaragua)
  SUBLANG_SPANISH_PUERTO_RICO* = 0x00000014 # Spanish (Puerto Rico)
  SUBLANG_SWEDISH* = 0x00000001 # Swedish
  SUBLANG_SWEDISH_FINLAND* = 0x00000002 # Swedish (Finland)
  SUBLANG_URDU_PAKISTAN* = 0x00000001 # Urdu (Pakistan)
  SUBLANG_URDU_INDIA* = 0x00000002 # Urdu (India)
  SUBLANG_UZBEK_LATIN* = 0x00000001 # Uzbek (Latin)
  SUBLANG_UZBEK_CYRILLIC* = 0x00000002 # Uzbek (Cyrillic)
                                       #
                                       #  Sorting IDs.
                                       #
  SORT_DEFAULT* = 0x00000000  # sorting default
  SORT_JAPANESE_XJIS* = 0x00000000 # Japanese XJIS order
  SORT_JAPANESE_UNICODE* = 0x00000001 # Japanese Unicode order
  SORT_CHINESE_BIG5* = 0x00000000 # Chinese BIG5 order
  SORT_CHINESE_PRCP* = 0x00000000 # PRC Chinese Phonetic order
  SORT_CHINESE_UNICODE* = 0x00000001 # Chinese Unicode order
  SORT_CHINESE_PRC* = 0x00000002 # PRC Chinese Stroke Count order
  SORT_CHINESE_BOPOMOFO* = 0x00000003 # Traditional Chinese Bopomofo order
  SORT_KOREAN_KSC* = 0x00000000 # Korean KSC order
  SORT_KOREAN_UNICODE* = 0x00000001 # Korean Unicode order
  SORT_GERMAN_PHONE_BOOK* = 0x00000001 # German Phone Book order
  SORT_HUNGARIAN_DEFAULT* = 0x00000000 # Hungarian Default order
  SORT_HUNGARIAN_TECHNICAL* = 0x00000001 # Hungarian Technical order
  SORT_GEORGIAN_TRADITIONAL* = 0x00000000 # Georgian Traditional order
  SORT_GEORGIAN_MODERN* = 0x00000001 # Georgian Modern order
                                     # SYSTEM_INFO structure
  PROCESSOR_INTEL_386* = 386
  PROCESSOR_INTEL_486* = 486
  PROCESSOR_INTEL_PENTIUM* = 586
  PROCESSOR_MIPS_R4000* = 4000
  PROCESSOR_ALPHA_21064* = 21064
  # FSCTL_SET_COMPRESSION
  COMPRESSION_FORMAT_NONE* = 0
  COMPRESSION_FORMAT_DEFAULT* = 1
  COMPRESSION_FORMAT_LZNT1* = 2
  # TAPE_GET_DRIVE_PARAMETERS structure
  TAPE_DRIVE_COMPRESSION* = 131072
  TAPE_DRIVE_ECC* = 65536
  TAPE_DRIVE_ERASE_BOP_ONLY* = 64
  TAPE_DRIVE_ERASE_LONG* = 32
  TAPE_DRIVE_ERASE_IMMEDIATE* = 128
  TAPE_DRIVE_ERASE_SHORT* = 16
  TAPE_DRIVE_FIXED* = 1
  TAPE_DRIVE_FIXED_BLOCK* = 1024
  TAPE_DRIVE_INITIATOR* = 4
  TAPE_DRIVE_PADDING* = 262144
  TAPE_DRIVE_GET_ABSOLUTE_BLK* = 1048576
  TAPE_DRIVE_GET_LOGICAL_BLK* = 2097152
  TAPE_DRIVE_REPORT_SMKS* = 524288
  TAPE_DRIVE_SELECT* = 2
  TAPE_DRIVE_SET_EOT_WZ_SIZE* = 4194304
  TAPE_DRIVE_TAPE_CAPACITY* = 256
  TAPE_DRIVE_TAPE_REMAINING* = 512
  TAPE_DRIVE_VARIABLE_BLOCK* = 2048
  TAPE_DRIVE_WRITE_PROTECT* = 4096
  TAPE_DRIVE_ABS_BLK_IMMED* = -2147475456
  TAPE_DRIVE_ABSOLUTE_BLK* = -2147479552
  TAPE_DRIVE_END_OF_DATA* = -2147418112
  TAPE_DRIVE_FILEMARKS* = -2147221504
  TAPE_DRIVE_LOAD_UNLOAD* = -2147483647
  TAPE_DRIVE_LOAD_UNLD_IMMED* = -2147483616
  TAPE_DRIVE_LOCK_UNLOCK* = -2147483644
  TAPE_DRIVE_LOCK_UNLK_IMMED* = -2147483520
  TAPE_DRIVE_LOG_BLK_IMMED* = -2147450880
  TAPE_DRIVE_LOGICAL_BLK* = -2147467264
  TAPE_DRIVE_RELATIVE_BLKS* = -2147352576
  TAPE_DRIVE_REVERSE_POSITION* = -2143289344
  TAPE_DRIVE_REWIND_IMMEDIATE* = -2147483640
  TAPE_DRIVE_SEQUENTIAL_FMKS* = -2146959360
  TAPE_DRIVE_SEQUENTIAL_SMKS* = -2145386496
  TAPE_DRIVE_SET_BLOCK_SIZE* = -2147483632
  TAPE_DRIVE_SET_COMPRESSION* = -2147483136
  TAPE_DRIVE_SET_ECC* = -2147483392
  TAPE_DRIVE_SET_PADDING* = -2147482624
  TAPE_DRIVE_SET_REPORT_SMKS* = -2147481600
  TAPE_DRIVE_SETMARKS* = -2146435072
  TAPE_DRIVE_SPACE_IMMEDIATE* = -2139095040
  TAPE_DRIVE_TENSION* = -2147483646
  TAPE_DRIVE_TENSION_IMMED* = -2147483584
  TAPE_DRIVE_WRITE_FILEMARKS* = -2113929216
  TAPE_DRIVE_WRITE_LONG_FMKS* = -2013265920
  TAPE_DRIVE_WRITE_MARK_IMMED* = -1879048192
  TAPE_DRIVE_WRITE_SETMARKS* = -2130706432
  TAPE_DRIVE_WRITE_SHORT_FMKS* = -2080374784
  # Standard rights
  STANDARD_RIGHTS_REQUIRED* = 0x000F0000
  STANDARD_RIGHTS_WRITE* = 0x00020000
  STANDARD_RIGHTS_READ* = 0x00020000
  STANDARD_RIGHTS_EXECUTE* = 0x00020000
  STANDARD_RIGHTS_ALL* = 0x001F0000
  SPECIFIC_RIGHTS_ALL* = 0x0000FFFF

  FILE_GENERIC_READ* = STANDARD_RIGHTS_READ or
      FILE_READ_DATA or
      FILE_READ_ATTRIBUTES or
      FILE_READ_EA or
      SYNCHRONIZE
  FILE_GENERIC_WRITE* = STANDARD_RIGHTS_WRITE or
      FILE_WRITE_DATA or
      FILE_WRITE_ATTRIBUTES or
      FILE_WRITE_EA or
      FILE_APPEND_DATA or
      SYNCHRONIZE
  FILE_GENERIC_EXECUTE* = STANDARD_RIGHTS_EXECUTE or
      FILE_READ_ATTRIBUTES or
      FILE_EXECUTE or
      SYNCHRONIZE
  FILE_ALL_ACCESS* = STANDARD_RIGHTS_REQUIRED or SYNCHRONIZE or 0x1FF

  # ACCESS_MASK
  MAXIMUM_ALLOWED* = 0x02000000
  GENERIC_ALL* = 0x10000000
  # SID
  SECURITY_NULL_RID* = 0
  SECURITY_WORLD_RID* = 0
  SECURITY_LOCAL_RID* = 0
  SECURITY_CREATOR_OWNER_RID* = 0
  SECURITY_CREATOR_GROUP_RID* = 0x00000001
  SECURITY_DIALUP_RID* = 0x00000001
  SECURITY_NETWORK_RID* = 0x00000002
  SECURITY_BATCH_RID* = 0x00000003
  SECURITY_INTERACTIVE_RID* = 0x00000004
  SECURITY_LOGON_IDS_RID* = 0x00000005
  SECURITY_LOGON_IDS_RID_COUNT* = 0x00000003
  SECURITY_SERVICE_RID* = 0x00000006
  SECURITY_LOCAL_SYSTEM_RID* = 0x00000012
  SECURITY_BUILTIN_DOMAIN_RID* = 0x00000020
  DOMAIN_USER_RID_ADMIN* = 0x000001F4
  DOMAIN_USER_RID_GUEST* = 0x000001F5
  DOMAIN_GROUP_RID_ADMINS* = 0x00000200
  DOMAIN_GROUP_RID_USERS* = 0x00000201
  DOMAIN_ALIAS_RID_ADMINS* = 0x00000220
  DOMAIN_ALIAS_RID_USERS* = 0x00000221
  DOMAIN_ALIAS_RID_GUESTS* = 0x00000222
  DOMAIN_ALIAS_RID_POWER_USERS* = 0x00000223
  DOMAIN_ALIAS_RID_ACCOUNT_OPS* = 0x00000224
  DOMAIN_ALIAS_RID_SYSTEM_OPS* = 0x00000225
  DOMAIN_ALIAS_RID_PRINT_OPS* = 0x00000226
  DOMAIN_ALIAS_RID_BACKUP_OPS* = 0x00000227
  DOMAIN_ALIAS_RID_REPLICATOR* = 0x00000228
  # TOKEN_GROUPS structure
  SE_GROUP_MANDATORY* = 0x00000001
  SE_GROUP_ENABLED_BY_DEFAULT* = 0x00000002
  SE_GROUP_ENABLED* = 0x00000004
  SE_GROUP_OWNER* = 0x00000008
  SE_GROUP_LOGON_ID* = 0xC0000000
  # ACL Defines
  ACL_REVISION* = 2
  # ACE_HEADER structure
  ACCESS_ALLOWED_ACE_TYPE* = 0x00000000
  ACCESS_DENIED_ACE_TYPE* = 0x00000001
  SYSTEM_AUDIT_ACE_TYPE* = 0x00000002
  SYSTEM_ALARM_ACE_TYPE* = 0x00000003
  # ACE flags in the ACE_HEADER structure
  OBJECT_INHERIT_ACE* = 0x00000001
  CONTAINER_INHERIT_ACE* = 0x00000002
  NO_PROPAGATE_INHERIT_ACE* = 0x00000004
  INHERIT_ONLY_ACE* = 0x00000008
  SUCCESSFUL_ACCESS_ACE_FLAG* = 0x00000040
  FAILED_ACCESS_ACE_FLAG* = 0x00000080
  # SECURITY_DESCRIPTOR_CONTROL
  #SECURITY_DESCRIPTOR_REVISION = 1;already defined above
  SECURITY_DESCRIPTOR_MIN_LENGTH* = 20
  SE_OWNER_DEFAULTED* = 1
  SE_GROUP_DEFAULTED* = 2
  SE_DACL_PRESENT* = 4
  SE_DACL_DEFAULTED* = 8
  SE_SACL_PRESENT* = 16
  SE_SACL_DEFAULTED* = 32
  SE_SELF_RELATIVE* = 32768
  # PRIVILEGE_SET
  SE_PRIVILEGE_ENABLED_BY_DEFAULT* = 0x00000001
  SE_PRIVILEGE_ENABLED* = 0x00000002
  SE_PRIVILEGE_USED_FOR_ACCESS* = 0x80000000
  PRIVILEGE_SET_ALL_NECESSARY* = 0x00000001
  # OPENFILENAME structure
  OFN_ALLOWMULTISELECT* = 0x00000200
  OFN_CREATEPROMPT* = 0x00002000
  OFN_ENABLEHOOK* = 0x00000020
  OFN_ENABLETEMPLATE* = 0x00000040
  OFN_ENABLETEMPLATEHANDLE* = 0x00000080
  OFN_EXPLORER* = 0x00080000
  OFN_EXTENSIONDIFFERENT* = 0x00000400
  OFN_FILEMUSTEXIST* = 0x00001000
  OFN_HIDEREADONLY* = 0x00000004
  OFN_LONGNAMES* = 0x00200000
  OFN_NOCHANGEDIR* = 0x00000008
  OFN_NODEREFERENCELINKS* = 0x00100000
  OFN_NOLONGNAMES* = 0x00040000
  OFN_NONETWORKBUTTON* = 0x00020000
  OFN_NOREADONLYRETURN* = 0x00008000
  OFN_NOTESTFILECREATE* = 0x00010000
  OFN_NOVALIDATE* = 0x00000100
  OFN_OVERWRITEPROMPT* = 0x00000002
  OFN_PATHMUSTEXIST* = 0x00000800
  OFN_READONLY* = 0x00000001
  OFN_SHAREAWARE* = 0x00004000
  OFN_SHOWHELP* = 0x00000010
  # SHAREVISTRING message
  OFN_SHAREFALLTHROUGH* = 0x00000002
  OFN_SHARENOWARN* = 0x00000001
  OFN_SHAREWARN* = 0
  # Open/Save notifications
  CDN_INITDONE* = 0xFFFFFDA7
  CDN_SELCHANGE* = 0xFFFFFDA6
  CDN_FOLDERCHANGE* = 0xFFFFFDA5
  CDN_SHAREVIOLATION* = 0xFFFFFDA4
  CDN_HELP* = 0xFFFFFDA3
  CDN_FILEOK* = 0xFFFFFDA2
  CDN_TYPECHANGE* = 0xFFFFFDA1
  # Open/Save messages
  CDM_GETFILEPATH* = 0x00000465
  CDM_GETFOLDERIDLIST* = 0x00000467
  CDM_GETFOLDERPATH* = 0x00000466
  CDM_GETSPEC* = 0x00000464
  CDM_HIDECONTROL* = 0x00000469
  CDM_SETCONTROLTEXT* = 0x00000468
  CDM_SETDEFEXT* = 0x0000046A
  # CHOOSECOLOR structure
  CC_ENABLEHOOK* = 0x00000010
  CC_ENABLETEMPLATE* = 0x00000020
  CC_ENABLETEMPLATEHANDLE* = 0x00000040
  CC_FULLOPEN* = 0x00000002
  CC_PREVENTFULLOPEN* = 0x00000004
  CC_RGBINIT* = 0x00000001
  CC_SHOWHELP* = 0x00000008
  CC_SOLIDCOLOR* = 0x00000080
  # FINDREPLACE structure
  FR_DIALOGTERM* = 0x00000040
  FR_DOWN* = 0x00000001
  FR_ENABLEHOOK* = 0x00000100
  FR_ENABLETEMPLATE* = 0x00000200
  FR_ENABLETEMPLATEHANDLE* = 0x00002000
  FR_FINDNEXT* = 0x00000008
  FR_HIDEUPDOWN* = 0x00004000
  FR_HIDEMATCHCASE* = 0x00008000
  FR_HIDEWHOLEWORD* = 0x00010000
  FR_MATCHCASE* = 0x00000004
  FR_NOMATCHCASE* = 0x00000800
  FR_NOUPDOWN* = 0x00000400
  FR_NOWHOLEWORD* = 0x00001000
  FR_REPLACE* = 0x00000010
  FR_REPLACEALL* = 0x00000020
  FR_SHOWHELP* = 0x00000080
  FR_WHOLEWORD* = 0x00000002
  # CHOOSEFONT structure
  CF_APPLY* = 0x00000200
  CF_ANSIONLY* = 0x00000400
  CF_BOTH* = 0x00000003
  CF_TTONLY* = 0x00040000
  CF_EFFECTS* = 0x00000100
  CF_ENABLEHOOK* = 0x00000008
  CF_ENABLETEMPLATE* = 0x00000010
  CF_ENABLETEMPLATEHANDLE* = 0x00000020
  CF_FIXEDPITCHONLY* = 0x00004000
  CF_FORCEFONTEXIST* = 0x00010000
  CF_INITTOLOGFONTSTRUCT* = 0x00000040
  CF_LIMITSIZE* = 0x00002000
  CF_NOOEMFONTS* = 0x00000800
  CF_NOFACESEL* = 0x00080000
  CF_NOSCRIPTSEL* = 0x00800000
  CF_NOSTYLESEL* = 0x00100000
  CF_NOSIZESEL* = 0x00200000
  CF_NOSIMULATIONS* = 0x00001000
  CF_NOVECTORFONTS* = 0x00000800
  CF_NOVERTFONTS* = 0x01000000
  CF_PRINTERFONTS* = 0x00000002
  CF_SCALABLEONLY* = 0x00020000
  CF_SCREENFONTS* = 0x00000001
  CF_SCRIPTSONLY* = 0x00000400
  CF_SELECTSCRIPT* = 0x00400000
  CF_SHOWHELP* = 0x00000004
  CF_USESTYLE* = 0x00000080
  CF_WYSIWYG* = 0x00008000
  BOLD_FONTTYPE* = 0x00000100
  ITALIC_FONTTYPE* = 0x00000200
  PRINTER_FONTTYPE* = 0x00004000
  REGULAR_FONTTYPE* = 0x00000400
  SCREEN_FONTTYPE* = 0x00002000
  SIMULATED_FONTTYPE* = 0x00008000
  # Common dialog messages
  COLOROKSTRINGW* = "commdlg_ColorOK"
  FILEOKSTRINGW* = "commdlg_FileNameOK"
  FINDMSGSTRINGW* = "commdlg_FindReplace"
  HELPMSGSTRINGW* = "commdlg_help"
  LBSELCHSTRINGW* = "commdlg_LBSelChangedNotify"
  SETRGBSTRINGW* = "commdlg_SetRGBColor"
  SHAREVISTRINGW* = "commdlg_ShareViolation"
  COLOROKSTRINGA* = "commdlg_ColorOK"
  FILEOKSTRINGA* = "commdlg_FileNameOK"
  FINDMSGSTRINGA* = "commdlg_FindReplace"
  HELPMSGSTRINGA* = "commdlg_help"
  LBSELCHSTRINGA* = "commdlg_LBSelChangedNotify"
  SETRGBSTRINGA* = "commdlg_SetRGBColor"
  SHAREVISTRINGA* = "commdlg_ShareViolation"

when defined(winUnicode):
  const
    COLOROKSTRING* = COLOROKSTRINGW
    FILEOKSTRING* = FILEOKSTRINGW
    FINDMSGSTRING* = FINDMSGSTRINGW
    HELPMSGSTRING* = HELPMSGSTRINGW
    LBSELCHSTRING* = LBSELCHSTRINGW
    SETRGBSTRING* = SETRGBSTRINGW
    SHAREVISTRING* = SHAREVISTRINGW
else:
  const
    COLOROKSTRING* = COLOROKSTRINGA
    FILEOKSTRING* = FILEOKSTRINGA
    FINDMSGSTRING* = FINDMSGSTRINGA
    HELPMSGSTRING* = HELPMSGSTRINGA
    LBSELCHSTRING* = LBSELCHSTRINGA
    SETRGBSTRING* = SETRGBSTRINGA
    SHAREVISTRING* = SHAREVISTRINGA

const
  # LBSELCHSTRING message
  CD_LBSELCHANGE* = 0
  CD_LBSELADD* = 2
  CD_LBSELSUB* = 1
  CD_LBSELNOITEMS* = -1
  # DEVNAMES structure
  DN_DEFAULTPRN* = 1
  # PRINTDLG structure
  PD_ALLPAGES* = 0
  PD_COLLATE* = 16
  PD_DISABLEPRINTTOFILE* = 524288
  PD_ENABLEPRINTHOOK* = 4096
  PD_ENABLEPRINTTEMPLATE* = 16384
  PD_ENABLEPRINTTEMPLATEHANDLE* = 65536
  PD_ENABLESETUPHOOK* = 8192
  PD_ENABLESETUPTEMPLATE* = 32768
  PD_ENABLESETUPTEMPLATEHANDLE* = 131072
  PD_HIDEPRINTTOFILE* = 1048576
  PD_NOPAGENUMS* = 8
  PD_NOSELECTION* = 4
  PD_NOWARNING* = 128
  PD_PAGENUMS* = 2
  PD_PRINTSETUP* = 64
  PD_PRINTTOFILE* = 32
  PD_RETURNDC* = 256
  PD_RETURNDEFAULT* = 1024
  PD_RETURNIC* = 512
  PD_SELECTION* = 1
  PD_SHOWHELP* = 2048
  PD_USEDEVMODECOPIES* = 262144
  PD_USEDEVMODECOPIESANDCOLLATE* = 262144
  # PAGESETUPDLG structure
  PSD_DEFAULTMINMARGINS* = 0
  PSD_DISABLEMARGINS* = 16
  PSD_DISABLEORIENTATION* = 256
  PSD_DISABLEPAGEPAINTING* = 524288
  PSD_DISABLEPAPER* = 512
  PSD_DISABLEPRINTER* = 32
  PSD_ENABLEPAGEPAINTHOOK* = 262144
  PSD_ENABLEPAGESETUPHOOK* = 8192
  PSD_ENABLEPAGESETUPTEMPLATE* = 32768
  PSD_ENABLEPAGESETUPTEMPLATEHANDLE* = 131072
  PSD_INHUNDREDTHSOFMILLIMETERS* = 8
  PSD_INTHOUSANDTHSOFINCHES* = 4
  PSD_INWININIINTLMEASURE* = 0
  PSD_MARGINS* = 2
  PSD_MINMARGINS* = 1
  PSD_NOWARNING* = 128
  PSD_RETURNDEFAULT* = 1024
  PSD_SHOWHELP* = 2048
  # WM_SHOWWINDOW message
  SW_OTHERUNZOOM* = 4
  SW_OTHERZOOM* = 2
  SW_PARENTCLOSING* = 1
  SW_PARENTOPENING* = 3
  # Virtual Key codes
  VK_LBUTTON* = 1
  VK_RBUTTON* = 2
  VK_CANCEL* = 3
  VK_MBUTTON* = 4
  VK_BACK* = 8
  VK_TAB* = 9
  VK_CLEAR* = 12
  VK_RETURN* = 13
  VK_SHIFT* = 16
  VK_CONTROL* = 17
  VK_MENU* = 18
  VK_PAUSE* = 19
  VK_CAPITAL* = 20
  VK_ESCAPE* = 27
  VK_SPACE* = 32
  VK_PRIOR* = 33
  VK_NEXT* = 34
  VK_END* = 35
  VK_HOME* = 36
  VK_LEFT* = 37
  VK_UP* = 38
  VK_RIGHT* = 39
  VK_DOWN* = 40
  VK_SELECT* = 41
  VK_PRINT* = 42
  VK_EXECUTE* = 43
  VK_SNAPSHOT* = 44
  VK_INSERT* = 45
  VK_DELETE* = 46
  VK_HELP* = 47
  VK_0* = 48
  VK_1* = 49
  VK_2* = 50
  VK_3* = 51
  VK_4* = 52
  VK_5* = 53
  VK_6* = 54
  VK_7* = 55
  VK_8* = 56
  VK_9* = 57
  VK_A* = 65
  VK_B* = 66
  VK_C* = 67
  VK_D* = 68
  VK_E* = 69
  VK_F* = 70
  VK_G* = 71
  VK_H* = 72
  VK_I* = 73
  VK_J* = 74
  VK_K* = 75
  VK_L* = 76
  VK_M* = 77
  VK_N* = 78
  VK_O* = 79
  VK_P* = 80
  VK_Q* = 81
  VK_R* = 82
  VK_S* = 83
  VK_T* = 84
  VK_U* = 85
  VK_V* = 86
  VK_W* = 87
  VK_X* = 88
  VK_Y* = 89
  VK_Z* = 90
  VK_LWIN* = 91
  VK_RWIN* = 92
  VK_APPS* = 93
  VK_NUMPAD0* = 96
  VK_NUMPAD1* = 97
  VK_NUMPAD2* = 98
  VK_NUMPAD3* = 99
  VK_NUMPAD4* = 100
  VK_NUMPAD5* = 101
  VK_NUMPAD6* = 102
  VK_NUMPAD7* = 103
  VK_NUMPAD8* = 104
  VK_NUMPAD9* = 105
  VK_MULTIPLY* = 106
  VK_ADD* = 107
  VK_SEPARATOR* = 108
  VK_SUBTRACT* = 109
  VK_DECIMAL* = 110
  VK_DIVIDE* = 111
  VK_F1* = 112
  VK_F2* = 113
  VK_F3* = 114
  VK_F4* = 115
  VK_F5* = 116
  VK_F6* = 117
  VK_F7* = 118
  VK_F8* = 119
  VK_F9* = 120
  VK_F10* = 121
  VK_F11* = 122
  VK_F12* = 123
  VK_F13* = 124
  VK_F14* = 125
  VK_F15* = 126
  VK_F16* = 127
  VK_F17* = 128
  VK_F18* = 129
  VK_F19* = 130
  VK_F20* = 131
  VK_F21* = 132
  VK_F22* = 133
  VK_F23* = 134
  VK_F24* = 135
  # GetAsyncKeyState
  VK_NUMLOCK* = 144
  VK_SCROLL* = 145
  VK_LSHIFT* = 160
  VK_LCONTROL* = 162
  VK_LMENU* = 164
  VK_RSHIFT* = 161
  VK_RCONTROL* = 163
  VK_RMENU* = 165
  # ImmGetVirtualKey
  VK_PROCESSKEY* = 229
  # Keystroke Message Flags
  KF_ALTDOWN* = 8192
  KF_DLGMODE* = 2048
  KF_EXTENDED* = 256
  KF_MENUMODE* = 4096
  KF_REPEAT* = 16384
  KF_UP* = 32768
  # GetKeyboardLayoutName
  KL_NAMELENGTH* = 9
  # WM_ACTIVATE message
  WA_ACTIVE* = 1
  WA_CLICKACTIVE* = 2
  WA_INACTIVE* = 0
  # WM_ACTIVATE message
  PWR_CRITICALRESUME* = 3
  PWR_SUSPENDREQUEST* = 1
  PWR_SUSPENDRESUME* = 2
  PWR_FAIL* = -1
  PWR_OK* = 1
  # WM_NOTIFYFORMAT message
  NF_QUERY* = 3
  NF_REQUERY* = 4
  NFR_ANSI* = 1
  NFR_UNICODE* = 2
  # WM_SIZING message
  WMSZ_BOTTOM* = 6
  WMSZ_BOTTOMLEFT* = 7
  WMSZ_BOTTOMRIGHT* = 8
  WMSZ_LEFT* = 1
  WMSZ_RIGHT* = 2
  WMSZ_TOP* = 3
  WMSZ_TOPLEFT* = 4
  WMSZ_TOPRIGHT* = 5
  # WM_MOUSEACTIVATE message
  MA_ACTIVATE* = 1
  MA_ACTIVATEANDEAT* = 2
  MA_NOACTIVATE* = 3
  MA_NOACTIVATEANDEAT* = 4
  # WM_SIZE message
  SIZE_MAXHIDE* = 4
  SIZE_MAXIMIZED* = 2
  SIZE_MAXSHOW* = 3
  SIZE_MINIMIZED* = 1
  SIZE_RESTORED* = 0
  # WM_NCCALCSIZE message
  WVR_ALIGNTOP* = 16
  WVR_ALIGNLEFT* = 32
  WVR_ALIGNBOTTOM* = 64
  WVR_ALIGNRIGHT* = 128
  WVR_HREDRAW* = 256
  WVR_VREDRAW* = 512
  WVR_REDRAW* = 768
  WVR_VALIDRECTS* = 1024
  # WM_NCHITTEST message
  HTBOTTOM* = 15
  HTBOTTOMLEFT* = 16
  HTBOTTOMRIGHT* = 17
  HTCAPTION* = 2
  HTCLIENT* = 1
  HTERROR* = -2
  HTGROWBOX* = 4
  HTHSCROLL* = 6
  HTLEFT* = 10
  HTMENU* = 5
  HTNOWHERE* = 0
  HTREDUCE* = 8

  HTRIGHT* = 11
  HTSIZE* = 4
  HTSYSMENU* = 3
  HTTOP* = 12
  HTTOPLEFT* = 13
  HTTOPRIGHT* = 14
  HTTRANSPARENT* = -1
  HTVSCROLL* = 7
  HTZOOM* = 9
  # Mouse messages
  MK_CONTROL* = 8
  MK_LBUTTON* = 1
  MK_MBUTTON* = 16
  MK_RBUTTON* = 2
  MK_SHIFT* = 4
  # WNDCLASS structure
  CS_BYTEALIGNCLIENT* = 4096
  CS_BYTEALIGNWINDOW* = 8192
  CS_CLASSDC* = 64
  CS_DBLCLKS* = 8
  CS_GLOBALCLASS* = 16384
  CS_HREDRAW* = 2
  CS_KEYCVTWINDOW* = 4
  CS_NOCLOSE* = 512
  CS_NOKEYCVT* = 256
  CS_OWNDC* = 32
  CS_PARENTDC* = 128
  CS_SAVEBITS* = 2048
  CS_VREDRAW* = 1
  DLGWINDOWEXTRA* = 30
  # ACCEL structure
  FALT* = 16
  FCONTROL* = 8
  FNOINVERT* = 2
  FSHIFT* = 4
  FVIRTKEY* = 1
  # WM_MENUCHAR return constants
  MNC_IGNORE* = 0
  MNC_CLOSE* = 1
  MNC_EXECUTE* = 2
  MNC_SELECT* = 3
  # MENUINFO structure
  MIM_MAXHEIGHT* = 1
  MIM_BACKGROUND* = 2
  MIM_HELPID* = 4
  MIM_MENUDATA* = 8
  MIM_STYLE* = 16
  MIM_APPLYTOSUBMENUS* = 0x80000000
  MNS_CHECKORBMP* = 0x04000000
  MNS_NOTIFYBYPOS* = 0x08000000
  MNS_AUTODISMISS* = 0x10000000
  MNS_DRAGDROP* = 0x20000000
  MNS_MODELESS* = 0x40000000
  MNS_NOCHECK* = 0x80000000
  # MENUITEMINFO structure
  MIIM_CHECKMARKS* = 8
  MIIM_DATA* = 32
  MIIM_ID* = 2
  MIIM_STATE* = 1
  MIIM_SUBMENU* = 4
  MIIM_TYPE* = 16
  MIIM_STRING* = 64
  MIIM_BITMAP* = 128
  MIIM_FTYPE* = 256
  MFT_BITMAP* = 0x00000004
  MFT_MENUBARBREAK* = 0x00000020
  MFT_MENUBREAK* = 0x00000040
  MFT_OWNERDRAW* = 0x00000100
  MFT_RADIOCHECK* = 0x00000200
  MFT_RIGHTJUSTIFY* = 0x00004000
  MFT_SEPARATOR* = 0x00000800
  MFT_RIGHTORDER* = 0x00002000
  MFT_STRING* = 0
  MFS_CHECKED* = 0x00000008
  MFS_DEFAULT* = 0x00001000
  MFS_DISABLED* = 0x00000003
  MFS_ENABLED* = 0
  MFS_GRAYED* = 0x00000003
  MFS_HILITE* = 0x00000080
  MFS_UNCHECKED* = 0
  MFS_UNHILITE* = 0
  HBMMENU_CALLBACK* = - 1
  HBMMENU_SYSTEM* = 1
  HBMMENU_MBAR_RESTORE* = 2
  HBMMENU_MBAR_MINIMIZE* = 3
  HBMMENU_MBAR_CLOSE* = 5
  HBMMENU_MBAR_CLOSE_D* = 6
  HBMMENU_MBAR_MINIMIZE_D* = 7
  HBMMENU_POPUP_CLOSE* = 8
  HBMMENU_POPUP_RESTORE* = 9
  HBMMENU_POPUP_MAXIMIZE* = 10
  HBMMENU_POPUP_MINIMIZE* = 11
  # SERIALKEYS structure
  SERKF_AVAILABLE* = 2
  SERKF_INDICATOR* = 4
  SERKF_SERIALKEYSON* = 1
  # FILTERKEYS structure
  FKF_AVAILABLE* = 2
  FKF_CLICKON* = 64
  FKF_FILTERKEYSON* = 1
  FKF_HOTKEYACTIVE* = 4
  FKF_HOTKEYSOUND* = 16
  FKF_CONFIRMHOTKEY* = 8
  FKF_INDICATOR* = 32
  # HELPINFO structure
  HELPINFO_MENUITEM* = 2
  HELPINFO_WINDOW* = 1
  # WM_PRINT message
  PRF_CHECKVISIBLE* = 0x00000001
  PRF_CHILDREN* = 0x00000010
  PRF_CLIENT* = 0x00000004
  PRF_ERASEBKGND* = 0x00000008
  PRF_NONCLIENT* = 0x00000002
  PRF_OWNED* = 0x00000020

  # MapWindowPoints
  HWND_DESKTOP* = HWND(0)

const
  # WM_SYSCOMMAND message
  SC_CLOSE* = 61536
  SC_CONTEXTHELP* = 61824
  SC_DEFAULT* = 61792
  SC_HOTKEY* = 61776
  SC_HSCROLL* = 61568
  SC_KEYMENU* = 61696
  SC_MAXIMIZE* = 61488
  SC_ZOOM* = 61488
  SC_MINIMIZE* = 61472
  SC_ICON* = 61472
  SC_MONITORPOWER* = 61808
  SC_MOUSEMENU* = 61584
  SC_MOVE* = 61456
  SC_NEXTWINDOW* = 61504
  SC_PREVWINDOW* = 61520
  SC_RESTORE* = 61728
  SC_SCREENSAVE* = 61760
  SC_SIZE* = 61440
  SC_TASKLIST* = 61744
  SC_VSCROLL* = 61552
  # DM_GETDEFID message
  DC_HASDEFID* = 21323
  # WM_GETDLGCODE message
  DLGC_BUTTON* = 8192
  DLGC_DEFPUSHBUTTON* = 16
  DLGC_HASSETSEL* = 8
  DLGC_RADIOBUTTON* = 64
  DLGC_STATIC* = 256
  DLGC_UNDEFPUSHBUTTON* = 32
  DLGC_WANTALLKEYS* = 4
  DLGC_WANTARROWS* = 1
  DLGC_WANTCHARS* = 128
  DLGC_WANTMESSAGE* = 4
  DLGC_WANTTAB* = 2
  # EM_SETMARGINS message
  EC_LEFTMARGIN* = 1
  EC_RIGHTMARGIN* = 2
  EC_USEFONTINFO* = 65535
  # LB_SETCOUNT message
  LB_ERR* = -1
  LB_ERRSPACE* = -2
  LB_OKAY* = 0
  # CB_DIR message
  CB_ERR* = -1
  CB_ERRSPACE* = -2
  # WM_IME_CONTROL message
  IMC_GETCANDIDATEPOS* = 7
  IMC_GETCOMPOSITIONFONT* = 9
  IMC_GETCOMPOSITIONWINDOW* = 11
  IMC_GETSTATUSWINDOWPOS* = 15
  IMC_CLOSESTATUSWINDOW* = 33
  IMC_OPENSTATUSWINDOW* = 34
  IMC_SETCANDIDATEPOS* = 8
  IMC_SETCOMPOSITIONFONT* = 10
  IMC_SETCOMPOSITIONWINDOW* = 12
  IMC_SETSTATUSWINDOWPOS* = 16
  # WM_IME_CONTROL message
  IMN_CHANGECANDIDATE* = 3
  IMN_CLOSECANDIDATE* = 4
  IMN_CLOSESTATUSWINDOW* = 1
  IMN_GUIDELINE* = 13
  IMN_OPENCANDIDATE* = 5
  IMN_OPENSTATUSWINDOW* = 2
  IMN_SETCANDIDATEPOS* = 9
  IMN_SETCOMPOSITIONFONT* = 10
  IMN_SETCOMPOSITIONWINDOW* = 11
  IMN_SETCONVERSIONMODE* = 6
  IMN_SETOPENSTATUS* = 8
  IMN_SETSENTENCEMODE* = 7
  IMN_SETSTATUSWINDOWPOS* = 12
  IMN_PRIVATE* = 14
  # STICKYKEYS structure
  SKF_AUDIBLEFEEDBACK* = 64
  SKF_AVAILABLE* = 2
  SKF_CONFIRMHOTKEY* = 8
  SKF_HOTKEYACTIVE* = 4
  SKF_HOTKEYSOUND* = 16
  SKF_INDICATOR* = 32
  SKF_STICKYKEYSON* = 1
  SKF_TRISTATE* = 128
  SKF_TWOKEYSOFF* = 256
  # MOUSEKEYS structure
  MKF_AVAILABLE* = 2
  MKF_CONFIRMHOTKEY* = 8
  MKF_HOTKEYACTIVE* = 4
  MKF_HOTKEYSOUND* = 16
  MKF_INDICATOR* = 32
  MKF_MOUSEKEYSON* = 1
  MKF_MODIFIERS* = 64
  MKF_REPLACENUMBERS* = 128
  # SOUNDSENTRY structure
  SSF_AVAILABLE* = 2
  SSF_SOUNDSENTRYON* = 1
  SSTF_BORDER* = 2
  SSTF_CHARS* = 1
  SSTF_DISPLAY* = 3
  SSTF_NONE* = 0
  SSGF_DISPLAY* = 3
  SSGF_NONE* = 0
  SSWF_CUSTOM* = 4
  SSWF_DISPLAY* = 3
  SSWF_NONE* = 0
  SSWF_TITLE* = 1
  SSWF_WINDOW* = 2
  # ACCESSTIMEOUT structure
  ATF_ONOFFFEEDBACK* = 2
  ATF_TIMEOUTON* = 1
  # HIGHCONTRAST structure
  HCF_AVAILABLE* = 2
  HCF_CONFIRMHOTKEY* = 8
  HCF_HIGHCONTRASTON* = 1
  HCF_HOTKEYACTIVE* = 4
  HCF_HOTKEYAVAILABLE* = 64
  HCF_HOTKEYSOUND* = 16
  HCF_INDICATOR* = 32
  # TOGGLEKEYS structure
  TKF_AVAILABLE* = 2
  TKF_CONFIRMHOTKEY* = 8
  TKF_HOTKEYACTIVE* = 4
  TKF_HOTKEYSOUND* = 16
  TKF_TOGGLEKEYSON* = 1
  # Installable Policy
  PP_DISPLAYERRORS* = 1
  # SERVICE_INFO structure
  RESOURCEDISPLAYTYPE_DOMAIN* = 1
  RESOURCEDISPLAYTYPE_FILE* = 4
  RESOURCEDISPLAYTYPE_GENERIC* = 0
  RESOURCEDISPLAYTYPE_GROUP* = 5
  RESOURCEDISPLAYTYPE_SERVER* = 2
  RESOURCEDISPLAYTYPE_SHARE* = 3
  # KEY_EVENT_RECORD structure
  CAPSLOCK_ON* = 128
  ENHANCED_KEY* = 256
  LEFT_ALT_PRESSED* = 2
  LEFT_CTRL_PRESSED* = 8
  NUMLOCK_ON* = 32
  RIGHT_ALT_PRESSED* = 1
  RIGHT_CTRL_PRESSED* = 4
  SCROLLLOCK_ON* = 64
  SHIFT_PRESSED* = 16
  # MOUSE_EVENT_RECORD structure
  FROM_LEFT_1ST_BUTTON_PRESSED* = 1
  RIGHTMOST_BUTTON_PRESSED* = 2
  FROM_LEFT_2ND_BUTTON_PRESSED* = 4
  FROM_LEFT_3RD_BUTTON_PRESSED* = 8
  FROM_LEFT_4TH_BUTTON_PRESSED* = 16
  DOUBLE_CLICK* = 2
  MOUSE_MOVED* = 1
  # INPUT_RECORD structure
  KEY_EVENT* = 1
  cMOUSE_EVENT* = 2
  WINDOW_BUFFER_SIZE_EVENT* = 4
  MENU_EVENT* = 8
  FOCUS_EVENT* = 16
  # BITMAPINFOHEADER structure
  BI_RGB* = 0
  BI_RLE8* = 1
  BI_RLE4* = 2
  BI_BITFIELDS* = 3
  # Extensions to OpenGL
  # ChoosePixelFormat
  PFD_DOUBLEBUFFER* = 0x00000001
  PFD_STEREO* = 0x00000002
  PFD_DRAW_TO_WINDOW* = 0x00000004
  PFD_DRAW_TO_BITMAP* = 0x00000008
  PFD_SUPPORT_GDI* = 0x00000010
  PFD_SUPPORT_OPENGL* = 0x00000020
  PFD_DEPTH_DONTCARE* = 0x20000000
  PFD_DOUBLEBUFFER_DONTCARE* = 0x40000000
  PFD_STEREO_DONTCARE* = 0x80000000
  PFD_TYPE_RGBA* = 0
  PFD_TYPE_COLORINDEX* = 1
  PFD_MAIN_PLANE* = 0
  PFD_OVERLAY_PLANE* = 1
  PFD_UNDERLAY_PLANE* = -1
  # wglUseFontOutlines
  WGL_FONT_LINES* = 0
  WGL_FONT_POLYGONS* = 1
  PFD_GENERIC_FORMAT* = 0x00000040
  PFD_NEED_PALETTE* = 0x00000080
  PFD_NEED_SYSTEM_PALETTE* = 0x00000100
  PFD_SWAP_EXCHANGE* = 0x00000200
  PFD_SWAP_COPY* = 0x00000400
  PFD_SWAP_LAYER_BUFFERS* = 0x00000800
  PFD_GENERIC_ACCELERATED* = 0x00001000
  PFD_SUPPORT_DIRECTDRAW* = 0x00002000
  TMPF_FIXED_PITCH* = 0x00000001
  TMPF_VECTOR* = 0x00000002
  TMPF_TRUETYPE* = 0x00000004
  TMPF_DEVICE* = 0x00000008
  WM_CTLCOLOR* = 25
  LWA_COLORKEY* = 0x00000001
  LWA_ALPHA* = 0x00000002
  ULW_COLORKEY* = 0x00000001
  ULW_ALPHA* = 0x00000002
  ULW_OPAQUE* = 0x00000004
  WS_EX_LAYERED* = 0x00080000
  WS_EX_NOINHERITLAYOUT* = 0x00100000
  WS_EX_LAYOUTRTL* = 0x00400000
  WS_EX_COMPOSITED* = 0x02000000
  WS_EX_NOACTIVATE* = 0x08000000
  C3_LEXICAL* = 1024

# --------------------- old stuff, need to organize! ---------------
# BEGINNING of windowsx.h stuff from old headers:

# was #define dname(params) def_expr
proc GetFirstChild*(h: HWND): HWND
  # was #define dname(params) def_expr
proc GetNextSibling*(h: HWND): HWND
  # was #define dname(params) def_expr
proc GetWindowID*(h: HWND): int32
  # was #define dname(params) def_expr
proc SubclassWindow*(h: HWND, p: LONG): LONG
  # was #define dname(params) def_expr
  # argument types are unknown
  # return type might be wrong
proc GET_WM_COMMAND_CMD*(w, L: int32): int32
  # return type might be wrong
  # was #define dname(params) def_expr
  # argument types are unknown
  # return type might be wrong
proc GET_WM_COMMAND_ID*(w, L: int32): int32
  # return type might be wrong
  # was #define dname(params) def_expr
  # argument types are unknown
proc GET_WM_CTLCOLOR_HDC*(w, L, msg: int32): HDC
  # was #define dname(params) def_expr
  # argument types are unknown
proc GET_WM_CTLCOLOR_HWND*(w, L, msg: int32): HWND
  # was #define dname(params) def_expr
  # argument types are unknown
  # return type might be wrong
proc GET_WM_HSCROLL_CODE*(w, L: int32): int32
  # return type might be wrong
  # was #define dname(params) def_expr
  # argument types are unknown
proc GET_WM_HSCROLL_HWND*(w, L: int32): HWND
  # was #define dname(params) def_expr
  # argument types are unknown
  # return type might be wrong
proc GET_WM_HSCROLL_POS*(w, L: int32): int32
  # return type might be wrong
  # was #define dname(params) def_expr
  # argument types are unknown
  # return type might be wrong
proc GET_WM_MDIACTIVATE_FACTIVATE*(h, a, b: int32): int32
  # return type might be wrong
  # was #define dname(params) def_expr
  # argument types are unknown
proc GET_WM_MDIACTIVATE_HWNDACTIVATE*(a, b: int32): HWND
  # was #define dname(params) def_expr
  # argument types are unknown
proc GET_WM_MDIACTIVATE_HWNDDEACT*(a, b: int32): HWND
  # was #define dname(params) def_expr
  # argument types are unknown
  # return type might be wrong
proc GET_WM_VSCROLL_CODE*(w, L: int32): int32
  # return type might be wrong
  # was #define dname(params) def_expr
  # argument types are unknown
proc GET_WM_VSCROLL_HWND*(w, L: int32): HWND
  # was #define dname(params) def_expr
  # argument types are unknown
  # return type might be wrong
proc GET_WM_VSCROLL_POS*(w, L: int32): int32
  # return type might be wrong
  #  Not convertable by H2PAS
  # END OF windowsx.h stuff from old headers
  # ------------------------------------------------------------------

const
  # BEGINNING of shellapi.h stuff from old headers
  SE_ERR_SHARE* = 26
  SE_ERR_ASSOCINCOMPLETE* = 27
  SE_ERR_DDETIMEOUT* = 28
  SE_ERR_DDEFAIL* = 29
  SE_ERR_DDEBUSY* = 30
  SE_ERR_NOASSOC* = 31
  # END OF shellapi.h stuff from old headers
  #
  # ------------------------------------------------------------------
  # From ddeml.h in old Cygnus headers
  XCLASS_BOOL* = 0x00001000
  XCLASS_DATA* = 0x00002000
  XCLASS_FLAGS* = 0x00004000
  XCLASS_MASK* = 0x0000FC00
  XCLASS_NOTIFICATION* = 0x00008000
  XTYPF_NOBLOCK* = 0x00000002
  XTYP_ADVDATA* = 0x00004010
  XTYP_ADVREQ* = 0x00002022
  XTYP_ADVSTART* = 0x00001030
  XTYP_ADVSTOP* = 0x00008040
  XTYP_CONNECT* = 0x00001062
  XTYP_CONNECT_CONFIRM* = 0x00008072
  XTYP_DISCONNECT* = 0x000080C2
  XTYP_EXECUTE* = 0x00004050
  XTYP_POKE* = 0x00004090
  XTYP_REQUEST* = 0x000020B0
  XTYP_WILDCONNECT* = 0x000020E2
  XTYP_REGISTER* = 0x000080A2
  XTYP_ERROR* = 0x00008002
  XTYP_XACT_COMPLETE* = 0x00008080
  XTYP_UNREGISTER* = 0x000080D2
  DMLERR_DLL_USAGE* = 0x00004004
  DMLERR_INVALIDPARAMETER* = 0x00004006
  DMLERR_NOTPROCESSED* = 0x00004009
  DMLERR_POSTMSG_FAILED* = 0x0000400C
  DMLERR_SERVER_DIED* = 0x0000400E
  DMLERR_SYS_ERROR* = 0x0000400F
  DMLERR_BUSY* = 0x00004001
  DMLERR_DATAACKTIMEOUT* = 0x00004002
  DMLERR_ADVACKTIMEOUT* = 0x00004000
  DMLERR_DLL_NOT_INITIALIZED* = 0x00004003
  DMLERR_LOW_MEMORY* = 0x00004007
  DMLERR_MEMORY_ERROR* = 0x00004008
  DMLERR_POKEACKTIMEOUT* = 0x0000400B
  DMLERR_NO_CONV_ESTABLISHED* = 0x0000400A
  DMLERR_REENTRANCY* = 0x0000400D
  DMLERR_UNFOUND_QUEUE_ID* = 0x00004011
  DMLERR_UNADVACKTIMEOUT* = 0x00004010
  DMLERR_EXECACKTIMEOUT* = 0x00004005
  DDE_FACK* = 0x00008000
  DDE_FNOTPROCESSED* = 0x00000000
  DNS_REGISTER* = 0x00000001
  DNS_UNREGISTER* = 0x00000002
  CP_WINANSI* = 1004
  CP_WINUNICODE* = 1200
  #  Not convertable by H2PAS
  #  #define EXPENTRY CALLBACK
  APPCLASS_STANDARD* = 0x00000000
  # End of stuff from ddeml.h in old Cygnus headers

  BKMODE_LAST* = 2
  CTLCOLOR_MSGBOX* = 0
  CTLCOLOR_EDIT* = 1
  CTLCOLOR_LISTBOX* = 2
  CTLCOLOR_BTN* = 3
  CTLCOLOR_DLG* = 4
  CTLCOLOR_SCROLLBAR* = 5
  CTLCOLOR_STATIC* = 6
  CTLCOLOR_MAX* = 7
  META_SETMAPMODE* = 0x00000103
  META_SETWINDOWORG* = 0x0000020B
  META_SETWINDOWEXT* = 0x0000020C
  POLYFILL_LAST* = 2
  STATUS_WAIT_0* = 0x00000000
  STATUS_ABANDONED_WAIT_0* = 0x00000080
  STATUS_USER_APC* = 0x000000C0
  STATUS_TIMEOUT* = 0x00000102
  STATUS_PENDING* = 0x00000103
  STATUS_GUARD_PAGE_VIOLATION* = 0x80000001
  STATUS_DATATYPE_MISALIGNMENT* = 0x80000002
  STATUS_BREAKPOINT* = 0x80000003
  STATUS_SINGLE_STEP* = 0x80000004
  STATUS_IN_PAGE_ERROR* = 0xC0000006
  STATUS_INVALID_HANDLE* = 0xC0000008
  STATUS_ILLEGAL_INSTRUCTION* = 0xC000001D
  STATUS_NONCONTINUABLE_EXCEPTION* = 0xC0000025
  STATUS_INVALID_DISPOSITION* = 0xC0000026
  STATUS_ARRAY_BOUNDS_EXCEEDED* = 0xC000008C
  STATUS_FLOAT_DENORMAL_OPERAND* = 0xC000008D
  STATUS_FLOAT_DIVIDE_BY_ZERO* = 0xC000008E
  STATUS_FLOAT_INEXACT_RESULT* = 0xC000008F
  STATUS_FLOAT_INVALID_OPERATION* = 0xC0000090
  STATUS_FLOAT_OVERFLOW* = 0xC0000091
  STATUS_FLOAT_STACK_CHECK* = 0xC0000092
  STATUS_FLOAT_UNDERFLOW* = 0xC0000093
  STATUS_INTEGER_DIVIDE_BY_ZERO* = 0xC0000094
  STATUS_INTEGER_OVERFLOW* = 0xC0000095
  STATUS_PRIVILEGED_INSTRUCTION* = 0xC0000096
  STATUS_STACK_OVERFLOW* = 0xC00000FD
  STATUS_CONTROL_C_EXIT* = 0xC000013A
  PROCESSOR_ARCHITECTURE_INTEL* = 0
  PROCESSOR_ARCHITECTURE_MIPS* = 1
  PROCESSOR_ARCHITECTURE_ALPHA* = 2
  PROCESSOR_ARCHITECTURE_PPC* = 3

const
  SIZEFULLSCREEN* = SIZE_MAXIMIZED
  SIZENORMAL* = SIZE_RESTORED
  SIZEICONIC* = SIZE_MINIMIZED

const
  EXCEPTION_READ_FAULT* = 0   # Access violation was caused by a read
  EXCEPTION_WRITE_FAULT* = 1  # Access violation was caused by a write

when defined(cpuia64):
  const
    EXCEPTION_EXECUTE_FAULT* = 2 # Access violation was caused by an instruction fetch
else:
  const
    EXCEPTION_EXECUTE_FAULT* = 8
when defined(cpupowerpc32):
  # ppc
  const
    CONTEXT_CONTROL* = 1
    CONTEXT_FLOATING_POINT* = 2
    CONTEXT_INTEGER* = 4
    CONTEXT_DEBUG_REGISTERS* = 8
    CONTEXT_FULL* = CONTEXT_CONTROL or CONTEXT_FLOATING_POINT or CONTEXT_INTEGER
    CONTEXT_DEBUGGER* = CONTEXT_FULL
when defined(cpui386):
  # x86
  # The doc refered me to winnt.h, so I had to look...
  const
    SIZE_OF_80387_REGISTERS* = 80 # Values for contextflags
    CONTEXT_i386* = 0x00010000 # this assumes that i386 and
    CONTEXT_i486* = 0x00010000 # i486 have identical context records
    CONTEXT_CONTROL* = CONTEXT_i386 or 1 # SS:SP, CS:IP, FLAGS, BP
    CONTEXT_INTEGER* = CONTEXT_i386 or 2 # AX, BX, CX, DX, SI, DI
    CONTEXT_SEGMENTS* = CONTEXT_i386 or 4 # DS, ES, FS, GS
    CONTEXT_FLOATING_POINT* = CONTEXT_i386 or 8 # 387 state
    CONTEXT_DEBUG_REGISTERS* = CONTEXT_i386 or 0x00000010 # DB 0-3,6,7
    CONTEXT_EXTENDED_REGISTERS* = CONTEXT_i386 or 0x00000020 # cpu specific extensions
    CONTEXT_FULL* = (CONTEXT_CONTROL or CONTEXT_INTEGER) or CONTEXT_SEGMENTS
    CONTEXT_ALL* = CONTEXT_FULL or CONTEXT_FLOATING_POINT or
        CONTEXT_DEBUG_REGISTERS or CONTEXT_EXTENDED_REGISTERS # our own invention
    FLAG_TRACE_BIT* = 0x00000100
    CONTEXT_DEBUGGER* = CONTEXT_FULL or CONTEXT_FLOATING_POINT
when defined(cpux86_64):
  const
    INITIAL_MXCSR* = 0x00001F80 # initial MXCSR value
    INITIAL_FPCSR* = 0x0000027F # initial FPCSR value
    CONTEXT_AMD64* = 0x00100000
    CONTEXT_CONTROL* = (CONTEXT_AMD64 or 0x00000001)
    CONTEXT_INTEGER* = (CONTEXT_AMD64 or 0x00000002)
    CONTEXT_SEGMENTS* = (CONTEXT_AMD64 or 0x00000004)
    CONTEXT_FLOATING_POINT* = (CONTEXT_AMD64 or 0x00000008)
    CONTEXT_DEBUG_REGISTERS* = (CONTEXT_AMD64 or 0x00000010)
    CONTEXT_FULL* = CONTEXT_CONTROL or CONTEXT_INTEGER or CONTEXT_FLOATING_POINT
    CONTEXT_ALL* = CONTEXT_CONTROL or CONTEXT_INTEGER or CONTEXT_SEGMENTS or
        CONTEXT_FLOATING_POINT or CONTEXT_DEBUG_REGISTERS
    CONTEXT_EXCEPTION_ACTIVE* = 0x08000000
    CONTEXT_SERVICE_ACTIVE* = 0x10000000
    CONTEXT_EXCEPTION_REQUEST* = 0x40000000
    CONTEXT_EXCEPTION_REPORTING* = 0x80000000

const
  FILTER_TEMP_DUPLICATE_ACCOUNT* = 0x00000001
  FILTER_NORMAL_ACCOUNT* = 0x00000002
  FILTER_INTERDOMAIN_TRUST_ACCOUNT* = 0x00000008
  FILTER_WORKSTATION_TRUST_ACCOUNT* = 0x00000010
  FILTER_SERVER_TRUST_ACCOUNT* = 0x00000020
  LOGON32_LOGON_INTERACTIVE* = 0x00000002
  LOGON32_LOGON_BATCH* = 0x00000004
  LOGON32_LOGON_SERVICE* = 0x00000005
  LOGON32_PROVIDER_DEFAULT* = 0x00000000
  LOGON32_PROVIDER_WINNT35* = 0x00000001
  QID_SYNC* = 0xFFFFFFFF
  # Magic numbers in PE executable header. # e_magic field
  IMAGE_DOS_SIGNATURE* = 0x00005A4D
  # nt_signature field
  IMAGE_NT_SIGNATURE* = 0x00004550
  # Severity values
  SEVERITY_SUCCESS* = 0
  SEVERITY_ERROR* = 1
  # Variant type codes (wtypes.h).
  #    Some, not all though
  VT_EMPTY* = 0
  VT_NULL* = 1
  VT_I2* = 2
  VT_I4* = 3
  VT_R4* = 4
  VT_R8* = 5
  VT_BSTR* = 8
  VT_ERROR* = 10
  VT_BOOL* = 11
  VT_UI1* = 17
  VT_BYREF* = 0x00004000
  VT_RESERVED* = 0x00008000

const
  # Define the facility codes
  FACILITY_WINDOWS* = 8
  FACILITY_STORAGE* = 3
  FACILITY_RPC* = 1
  FACILITY_SSPI* = 9
  FACILITY_WIN32* = 7
  FACILITY_CONTROL* = 10
  FACILITY_NULL* = 0
  FACILITY_INTERNET* = 12
  FACILITY_ITF* = 4
  FACILITY_DISPATCH* = 2
  FACILITY_CERT* = 11         # Manually added, bug 2672
  ICON_SMALL* = 0
  ICON_BIG* = 1
  # For the TrackMouseEvent
  TME_HOVER* = 0x00000001
  TME_LEAVE* = 0x00000002
  TME_QUERY* = 0x40000000
  TME_CANCEL* = DWORD(0x80000000)
  HOVER_DEFAULT* = DWORD(0xFFFFFFFF) # Manually added, bug 3270
  COLOR_HOTLIGHT* = 26
  COLOR_GRADIENTACTIVECAPTION* = 27
  COLOR_GRADIENTINACTIVECAPTION* = 28
  COLOR_MENUHILIGHT* = 29
  COLOR_MENUBAR* = 30
  WM_APP* = 0x00008000
  SYSRGN* = 4
  UIS_SET* = 1
  UIS_CLEAR* = 2
  UIS_INITIALIZE* = 3
  UISF_HIDEFOCUS* = 0x00000001
  UISF_HIDEACCEL* = 0x00000002
  UISF_ACTIVE* = 0x00000004

type
  # WARNING
  #      the variable argument list
  #      is not implemented for FPC
  #      va_list is just a dummy record
  #      MvdV: Nevertheless it should be a pointer type, not a record
  va_list* = cstring
  TABC* {.final, pure.} = object
    abcA*: int32
    abcB*: UINT
    abcC*: int32

  LPABC* = ptr TABC
  PABC* = ptr TABC
  TABCFLOAT* {.final, pure.} = object
    abcfA*: float32
    abcfB*: float32
    abcfC*: float32
  LPABCFLOAT* = ptr TABCFLOAT
  PABCFLOAT* = ptr TABCFLOAT

  TACCEL* {.final, pure.} = object
    fVirt*: int8
    key*: int16
    cmd*: int16
  LPACCEL* = ptr TACCEL
  PACCEL* = ptr TACCEL
  ACE_HEADER* {.final, pure.} = object
    AceType*: int8
    AceFlags*: int8
    AceSize*: int16

  TACE_HEADER* = ACE_HEADER
  PACE_HEADER* = ptr ACE_HEADER
  ACCESS_MASK* = DWORD
  REGSAM* = ACCESS_MASK
  ACCESS_ALLOWED_ACE* {.final, pure.} = object
    Header*: ACE_HEADER
    Mask*: ACCESS_MASK
    SidStart*: DWORD

  TACCESS_ALLOWED_ACE* = ACCESS_ALLOWED_ACE
  PACCESS_ALLOWED_ACE* = ptr ACCESS_ALLOWED_ACE
  ACCESS_DENIED_ACE* {.final, pure.} = object
    Header*: ACE_HEADER
    Mask*: ACCESS_MASK
    SidStart*: DWORD

  TACCESS_DENIED_ACE* = ACCESS_DENIED_ACE
  ACCESSTIMEOUT* {.final, pure.} = object
    cbSize*: UINT
    dwFlags*: DWORD
    iTimeOutMSec*: DWORD

  TACCESSTIMEOUT* = ACCESSTIMEOUT
  PACCESSTIMEOUT* = ptr ACCESSTIMEOUT
  ACL* {.final, pure.} = object
    AclRevision*: int8
    Sbz1*: int8
    AclSize*: int16
    AceCount*: int16
    Sbz2*: int16

  PACL* = ptr ACL
  TACL* = ACL
  TACL_REVISION_INFORMATION* {.final, pure.} = object
    AclRevision*: DWORD
  PACLREVISIONINFORMATION* = ptr TACL_REVISION_INFORMATION

  TACL_SIZE_INFORMATION* {.final, pure.} = object
    AceCount*: DWORD
    AclBytesInUse*: DWORD
    AclBytesFree*: DWORD
  PACLSIZEINFORMATION* = ptr TACL_SIZE_INFORMATION
  ACTION_HEADER* {.final, pure.} = object
    transport_id*: ULONG
    action_code*: USHORT
    reserved*: USHORT

  TACTIONHEADER* = ACTION_HEADER
  PACTIONHEADER* = ptr ACTION_HEADER
  ADAPTER_STATUS* {.final, pure.} = object
    adapter_address*: array[0..5, UCHAR]
    rev_major*: UCHAR
    reserved0*: UCHAR
    adapter_type*: UCHAR
    rev_minor*: UCHAR
    duration*: int16
    frmr_recv*: int16
    frmr_xmit*: int16
    iframe_recv_err*: int16
    xmit_aborts*: int16
    xmit_success*: DWORD
    recv_success*: DWORD
    iframe_xmit_err*: int16
    recv_buff_unavail*: int16
    t1_timeouts*: int16
    ti_timeouts*: int16
    reserved1*: DWORD
    free_ncbs*: int16
    max_cfg_ncbs*: int16
    max_ncbs*: int16
    xmit_buf_unavail*: int16
    max_dgram_size*: int16
    pending_sess*: int16
    max_cfg_sess*: int16
    max_sess*: int16
    max_sess_pkt_size*: int16
    name_count*: int16

  TADAPTERSTATUS* = ADAPTER_STATUS
  PADAPTERSTATUS* = ptr ADAPTER_STATUS
  ADDJOB_INFO_1* {.final, pure.} = object
    Path*: LPTSTR
    JobId*: DWORD

  TADDJOB_INFO_1* = ADDJOB_INFO_1
  PADDJOB_INFO_1* = ptr ADDJOB_INFO_1
  ANIMATIONINFO* {.final, pure.} = object
    cbSize*: UINT
    iMinAnimate*: int32

  LPANIMATIONINFO* = ptr ANIMATIONINFO
  TANIMATIONINFO* = ANIMATIONINFO
  PANIMATIONINFO* = ptr ANIMATIONINFO

  APPBARDATA* {.final, pure.} = object
    cbSize*: DWORD
    hWnd*: HWND
    uCallbackMessage*: UINT
    uEdge*: UINT
    rc*: RECT
    lParam*: LPARAM

  TAppBarData* = APPBARDATA
  PAppBarData* = ptr APPBARDATA
  BITMAP* {.final, pure.} = object
    bmType*: LONG
    bmWidth*: LONG
    bmHeight*: LONG
    bmWidthBytes*: LONG
    bmPlanes*: int16
    bmBitsPixel*: int16
    bmBits*: LPVOID

  PBITMAP* = ptr BITMAP
  NPBITMAP* = ptr BITMAP
  LPBITMAP* = ptr BITMAP
  TBITMAP* = BITMAP
  BITMAPCOREHEADER* {.final, pure.} = object
    bcSize*: DWORD
    bcWidth*: int16
    bcHeight*: int16
    bcPlanes*: int16
    bcBitCount*: int16

  TBITMAPCOREHEADER* = BITMAPCOREHEADER
  PBITMAPCOREHEADER* = ptr BITMAPCOREHEADER
  RGBTRIPLE* {.final, pure.} = object
    rgbtBlue*: int8
    rgbtGreen*: int8
    rgbtRed*: int8

  TRGBTRIPLE* = RGBTRIPLE
  PRGBTRIPLE* = ptr RGBTRIPLE
  BITMAPCOREINFO* {.final, pure.} = object
    bmciHeader*: BITMAPCOREHEADER
    bmciColors*: array[0..0, RGBTRIPLE]

  PBITMAPCOREINFO* = ptr BITMAPCOREINFO
  LPBITMAPCOREINFO* = ptr BITMAPCOREINFO
  TBITMAPCOREINFO* = BITMAPCOREINFO # error
                                    #  WORD    bfReserved1;
                                    #  WORD    bfReserved2;
                                    # in declarator_list
  BITMAPINFOHEADER* {.final, pure.} = object
    biSize*: DWORD
    biWidth*: LONG
    biHeight*: LONG
    biPlanes*: int16
    biBitCount*: int16
    biCompression*: DWORD
    biSizeImage*: DWORD
    biXPelsPerMeter*: LONG
    biYPelsPerMeter*: LONG
    biClrUsed*: DWORD
    biClrImportant*: DWORD

  LPBITMAPINFOHEADER* = ptr BITMAPINFOHEADER
  TBITMAPINFOHEADER* = BITMAPINFOHEADER
  PBITMAPINFOHEADER* = ptr BITMAPINFOHEADER
  RGBQUAD* {.final, pure.} = object
    rgbBlue*: int8
    rgbGreen*: int8
    rgbRed*: int8
    rgbReserved*: int8

  TRGBQUAD* = RGBQUAD
  PRGBQUAD* = ptr RGBQUAD
  BITMAPINFO* {.final, pure.} = object
    bmiHeader*: BITMAPINFOHEADER
    bmiColors*: array[0..0, RGBQUAD]

  LPBITMAPINFO* = ptr BITMAPINFO
  PBITMAPINFO* = ptr BITMAPINFO
  TBITMAPINFO* = BITMAPINFO
  FXPT2DOT30* = int32
  LPFXPT2DOT30* = ptr FXPT2DOT30
  TPFXPT2DOT30* = FXPT2DOT30
  PPFXPT2DOT30* = ptr FXPT2DOT30
  CIEXYZ* {.final, pure.} = object
    ciexyzX*: FXPT2DOT30
    ciexyzY*: FXPT2DOT30
    ciexyzZ*: FXPT2DOT30

  LPCIEXYZ* = ptr CIEXYZ
  TPCIEXYZ* = CIEXYZ
  PCIEXYZ* = ptr CIEXYZ
  CIEXYZTRIPLE* {.final, pure.} = object
    ciexyzRed*: CIEXYZ
    ciexyzGreen*: CIEXYZ
    ciexyzBlue*: CIEXYZ

  LPCIEXYZTRIPLE* = ptr CIEXYZTRIPLE
  TCIEXYZTRIPLE* = CIEXYZTRIPLE
  PCIEXYZTRIPLE* = ptr CIEXYZTRIPLE
  BITMAPV4HEADER* {.final, pure.} = object
    bV4Size*: DWORD
    bV4Width*: LONG
    bV4Height*: LONG
    bV4Planes*: int16
    bV4BitCount*: int16
    bV4V4Compression*: DWORD
    bV4SizeImage*: DWORD
    bV4XPelsPerMeter*: LONG
    bV4YPelsPerMeter*: LONG
    bV4ClrUsed*: DWORD
    bV4ClrImportant*: DWORD
    bV4RedMask*: DWORD
    bV4GreenMask*: DWORD
    bV4BlueMask*: DWORD
    bV4AlphaMask*: DWORD
    bV4CSType*: DWORD
    bV4Endpoints*: CIEXYZTRIPLE
    bV4GammaRed*: DWORD
    bV4GammaGreen*: DWORD
    bV4GammaBlue*: DWORD

  LPBITMAPV4HEADER* = ptr BITMAPV4HEADER
  TBITMAPV4HEADER* = BITMAPV4HEADER
  PBITMAPV4HEADER* = ptr BITMAPV4HEADER
  BITMAPFILEHEADER* {.final, pure.} = object
    bfType*: int16
    bfSize*: DWord
    bfReserved1*: int16
    bfReserved2*: int16
    bfOffBits*: DWord

  BLOB* {.final, pure.} = object
    cbSize*: ULONG
    pBlobData*: ptr int8

  TBLOB* = BLOB
  PBLOB* = ptr BLOB
  SHITEMID* {.final, pure.} = object
    cb*: USHORT
    abID*: array[0..0, int8]

  LPSHITEMID* = ptr SHITEMID
  LPCSHITEMID* = ptr SHITEMID
  TSHITEMID* = SHITEMID
  PSHITEMID* = ptr SHITEMID
  ITEMIDLIST* {.final, pure.} = object
    mkid*: SHITEMID

  LPITEMIDLIST* = ptr ITEMIDLIST
  LPCITEMIDLIST* = ptr ITEMIDLIST
  TITEMIDLIST* = ITEMIDLIST
  PITEMIDLIST* = ptr ITEMIDLIST
  BROWSEINFO* {.final, pure.} = object
    hwndOwner*: HWND
    pidlRoot*: LPCITEMIDLIST
    pszDisplayName*: LPSTR
    lpszTitle*: LPCSTR
    ulFlags*: UINT
    lpfn*: BFFCALLBACK
    lParam*: LPARAM
    iImage*: int32

  LPBROWSEINFO* = ptr BROWSEINFO
  Tbrowseinfo* = BROWSEINFO
  PBROWSEINFO* = ptr BROWSEINFO

  BY_HANDLE_FILE_INFORMATION* {.final, pure.} = object
    dwFileAttributes*: DWORD
    ftCreationTime*: FILETIME
    ftLastAccessTime*: FILETIME
    ftLastWriteTime*: FILETIME
    dwVolumeSerialNumber*: DWORD
    nFileSizeHigh*: DWORD
    nFileSizeLow*: DWORD
    nNumberOfLinks*: DWORD
    nFileIndexHigh*: DWORD
    nFileIndexLow*: DWORD

  LPBY_HANDLE_FILE_INFORMATION* = ptr BY_HANDLE_FILE_INFORMATION
  TBYHANDLEFILEINFORMATION* = BY_HANDLE_FILE_INFORMATION
  PBYHANDLEFILEINFORMATION* = ptr BY_HANDLE_FILE_INFORMATION
  FIXED* {.final, pure.} = object
    fract*: int16
    value*: SHORT

  TFIXED* = FIXED
  PFIXED* = ptr FIXED
  POINTFX* {.final, pure.} = object
    x*: FIXED
    y*: FIXED

  TPOINTFX* = POINTFX
  PPOINTFX* = ptr POINTFX

  TSmallPoint* {.final, pure.} = object
    X*, Y*: SHORT

  CANDIDATEFORM* {.final, pure.} = object
    dwIndex*: DWORD
    dwStyle*: DWORD
    ptCurrentPos*: POINT
    rcArea*: RECT

  LPCANDIDATEFORM* = ptr CANDIDATEFORM
  TCANDIDATEFORM* = CANDIDATEFORM
  PCANDIDATEFORM* = ptr CANDIDATEFORM
  CANDIDATELIST* {.final, pure.} = object
    dwSize*: DWORD
    dwStyle*: DWORD
    dwCount*: DWORD
    dwSelection*: DWORD
    dwPageStart*: DWORD
    dwPageSize*: DWORD
    dwOffset*: array[0..0, DWORD]

  LPCANDIDATELIST* = ptr CANDIDATELIST
  TCANDIDATELIST* = CANDIDATELIST
  PCANDIDATELIST* = ptr CANDIDATELIST
  CREATESTRUCT* {.final, pure.} = object
    lpCreateParams*: LPVOID
    hInstance*: HINST
    hMenu*: HMENU
    hwndParent*: HWND
    cy*: int32
    cx*: int32
    y*: int32
    x*: int32
    style*: LONG
    lpszName*: LPCTSTR
    lpszClass*: LPCTSTR
    dwExStyle*: DWORD

  LPCREATESTRUCT* = ptr CREATESTRUCT
  TCREATESTRUCT* = CREATESTRUCT
  PCREATESTRUCT* = ptr CREATESTRUCT
  CBT_CREATEWND* {.final, pure.} = object
    lpcs*: LPCREATESTRUCT
    hwndInsertAfter*: HWND

  TCBT_CREATEWND* = CBT_CREATEWND
  PCBT_CREATEWND* = ptr CBT_CREATEWND
  CBTACTIVATESTRUCT* {.final, pure.} = object
    fMouse*: WINBOOL
    hWndActive*: HWND

  TCBTACTIVATESTRUCT* = CBTACTIVATESTRUCT
  PCBTACTIVATESTRUCT* = ptr CBTACTIVATESTRUCT
  CHAR_INFO* {.final, pure.} = object
    UnicodeChar*: WCHAR
    Attributes*: int16        # other union part: AsciiChar : CHAR

  TCHAR_INFO* = CHAR_INFO
  PCHAR_INFO* = ptr CHAR_INFO
  CHARFORMAT* {.final, pure.} = object
    cbSize*: UINT
    dwMask*: DWORD
    dwEffects*: DWORD
    yHeight*: LONG
    yOffset*: LONG
    crTextColor*: COLORREF
    bCharSet*: int8
    bPitchAndFamily*: int8
    szFaceName*: array[0..(LF_FACESIZE) - 1, TCHAR]

  Tcharformat* = CHARFORMAT
  Pcharformat* = ptr CHARFORMAT
  CHARRANGE* {.final, pure.} = object
    cpMin*: LONG
    cpMax*: LONG

  Tcharrange* = CHARRANGE
  Pcharrange* = ptr CHARRANGE
  CHARSET* {.final, pure.} = object
    aflBlock*: array[0..2, DWORD]
    flLang*: DWORD

  TCHARSET* = CHARSET
  PCHARSET* = ptr CHARSET
  FONTSIGNATURE* {.final, pure.} = object
    fsUsb*: array[0..3, DWORD]
    fsCsb*: array[0..1, DWORD]

  LPFONTSIGNATURE* = ptr FONTSIGNATURE
  TFONTSIGNATURE* = FONTSIGNATURE
  PFONTSIGNATURE* = ptr FONTSIGNATURE
  CHARSETINFO* {.final, pure.} = object
    ciCharset*: UINT
    ciACP*: UINT
    fs*: FONTSIGNATURE

  LPCHARSETINFO* = ptr CHARSETINFO
  TCHARSETINFO* = CHARSETINFO
  PCHARSETINFO* = ptr CHARSETINFO
  #CHOOSECOLOR = record confilcts with function ChooseColor
  TCHOOSECOLOR* {.final, pure.} = object
    lStructSize*: DWORD
    hwndOwner*: HWND
    hInstance*: HWND
    rgbResult*: COLORREF
    lpCustColors*: ptr COLORREF
    Flags*: DWORD
    lCustData*: LPARAM
    lpfnHook*: LPCCHOOKPROC
    lpTemplateName*: LPCTSTR

  LPCHOOSECOLOR* = ptr TCHOOSECOLOR
  PCHOOSECOLOR* = ptr TCHOOSECOLOR
  LOGFONT* {.final, pure.} = object
    lfHeight*: LONG
    lfWidth*: LONG
    lfEscapement*: LONG
    lfOrientation*: LONG
    lfWeight*: LONG
    lfItalic*: int8
    lfUnderline*: int8
    lfStrikeOut*: int8
    lfCharSet*: int8
    lfOutPrecision*: int8
    lfClipPrecision*: int8
    lfQuality*: int8
    lfPitchAndFamily*: int8
    lfFaceName*: array[0..(LF_FACESIZE) - 1, TCHAR]

  LPLOGFONT* = ptr LOGFONT
  TLOGFONT* = LOGFONT
  TLOGFONTA* = LOGFONT
  PLOGFONT* = ptr LOGFONT
  PLOGFONTA* = PLOGFONT
  LOGFONTW* {.final, pure.} = object
    lfHeight*: LONG
    lfWidth*: LONG
    lfEscapement*: LONG
    lfOrientation*: LONG
    lfWeight*: LONG
    lfItalic*: int8
    lfUnderline*: int8
    lfStrikeOut*: int8
    lfCharSet*: int8
    lfOutPrecision*: int8
    lfClipPrecision*: int8
    lfQuality*: int8
    lfPitchAndFamily*: int8
    lfFaceName*: array[0..LF_FACESIZE - 1, WCHAR]

  LPLOGFONTW* = ptr LOGFONTW
  NPLOGFONTW* = ptr LOGFONTW
  TLogFontW* = LOGFONTW
  PLogFontW* = ptr TLogFontW
  TCHOOSEFONT* {.final, pure.} = object
    lStructSize*: DWORD
    hwndOwner*: HWND
    hDC*: HDC
    lpLogFont*: LPLOGFONT
    iPointSize*: WINT
    Flags*: DWORD
    rgbColors*: DWORD
    lCustData*: LPARAM
    lpfnHook*: LPCFHOOKPROC
    lpTemplateName*: LPCTSTR
    hInstance*: HINST
    lpszStyle*: LPTSTR
    nFontType*: int16
    MISSING_ALIGNMENT*: int16
    nSizeMin*: WINT
    nSizeMax*: WINT

  LPCHOOSEFONT* = ptr TCHOOSEFONT
  PCHOOSEFONT* = ptr TCHOOSEFONT
  CIDA* {.final, pure.} = object
    cidl*: UINT
    aoffset*: array[0..0, UINT]

  LPIDA* = ptr CIDA
  TIDA* = CIDA
  PIDA* = ptr CIDA
  CLIENTCREATESTRUCT* {.final, pure.} = object
    hWindowMenu*: HANDLE
    idFirstChild*: UINT

  LPCLIENTCREATESTRUCT* = ptr CLIENTCREATESTRUCT
  TCLIENTCREATESTRUCT* = CLIENTCREATESTRUCT
  PCLIENTCREATESTRUCT* = ptr CLIENTCREATESTRUCT
  CMINVOKECOMMANDINFO* {.final, pure.} = object
    cbSize*: DWORD
    fMask*: DWORD
    hwnd*: HWND
    lpVerb*: LPCSTR
    lpParameters*: LPCSTR
    lpDirectory*: LPCSTR
    nShow*: int32
    dwHotKey*: DWORD
    hIcon*: HANDLE

  LPCMINVOKECOMMANDINFO* = ptr CMINVOKECOMMANDINFO
  TCMInvokeCommandInfo* = CMINVOKECOMMANDINFO
  PCMInvokeCommandInfo* = ptr CMINVOKECOMMANDINFO
  COLORADJUSTMENT* {.final, pure.} = object
    caSize*: int16
    caFlags*: int16
    caIlluminantIndex*: int16
    caRedGamma*: int16
    caGreenGamma*: int16
    caBlueGamma*: int16
    caReferenceBlack*: int16
    caReferenceWhite*: int16
    caContrast*: SHORT
    caBrightness*: SHORT
    caColorfulness*: SHORT
    caRedGreenTint*: SHORT

  LPCOLORADJUSTMENT* = ptr COLORADJUSTMENT
  TCOLORADJUSTMENT* = COLORADJUSTMENT
  PCOLORADJUSTMENT* = ptr COLORADJUSTMENT
  COLORMAP* {.final, pure.} = object
    `from`*: COLORREF
    `to`*: COLORREF          # XXX!

  LPCOLORMAP* = ptr COLORMAP
  TCOLORMAP* = COLORMAP
  PCOLORMAP* = ptr COLORMAP
  DCB* {.final, pure.} = object
    DCBlength*: DWORD
    BaudRate*: DWORD
    flags*: DWORD
    wReserved*: int16
    XonLim*: int16
    XoffLim*: int16
    ByteSize*: int8
    Parity*: int8
    StopBits*: int8
    XonChar*: char
    XoffChar*: char
    ErrorChar*: char
    EofChar*: char
    EvtChar*: char
    wReserved1*: int16

  LPDCB* = ptr DCB
  TDCB* = DCB
  PDCB* = ptr DCB

const
  bm_DCB_fBinary* = 1
  bp_DCB_fBinary* = 0'i32
  bm_DCB_fParity* = 0x00000002
  bp_DCB_fParity* = 1'i32
  bm_DCB_fOutxCtsFlow* = 0x00000004
  bp_DCB_fOutxCtsFlow* = 2'i32
  bm_DCB_fOutxDsrFlow* = 0x00000008
  bp_DCB_fOutxDsrFlow* = 3'i32
  bm_DCB_fDtrControl* = 0x00000030
  bp_DCB_fDtrControl* = 4'i32
  bm_DCB_fDsrSensitivity* = 0x00000040
  bp_DCB_fDsrSensitivity* = 6'i32
  bm_DCB_fTXContinueOnXoff* = 0x00000080
  bp_DCB_fTXContinueOnXoff* = 7'i32
  bm_DCB_fOutX* = 0x00000100
  bp_DCB_fOutX* = 8'i32
  bm_DCB_fInX* = 0x00000200
  bp_DCB_fInX* = 9'i32
  bm_DCB_fErrorChar* = 0x00000400
  bp_DCB_fErrorChar* = 10'i32
  bm_DCB_fNull* = 0x00000800
  bp_DCB_fNull* = 11'i32
  bm_DCB_fRtsControl* = 0x00003000
  bp_DCB_fRtsControl* = 12'i32
  bm_DCB_fAbortOnError* = 0x00004000
  bp_DCB_fAbortOnError* = 14'i32
  bm_DCB_fDummy2* = 0xFFFF8000'i32
  bp_DCB_fDummy2* = 15'i32

proc fBinary*(a: var DCB): DWORD
proc set_fBinary*(a: var DCB, fBinary: DWORD)
proc fParity*(a: var DCB): DWORD
proc set_fParity*(a: var DCB, fParity: DWORD)
proc fOutxCtsFlow*(a: var DCB): DWORD
proc set_fOutxCtsFlow*(a: var DCB, fOutxCtsFlow: DWORD)
proc fOutxDsrFlow*(a: var DCB): DWORD
proc set_fOutxDsrFlow*(a: var DCB, fOutxDsrFlow: DWORD)
proc fDtrControl*(a: var DCB): DWORD
proc set_fDtrControl*(a: var DCB, fDtrControl: DWORD)
proc fDsrSensitivity*(a: var DCB): DWORD
proc set_fDsrSensitivity*(a: var DCB, fDsrSensitivity: DWORD)
proc fTXContinueOnXoff*(a: var DCB): DWORD
proc set_fTXContinueOnXoff*(a: var DCB, fTXContinueOnXoff: DWORD)
proc fOutX*(a: var DCB): DWORD
proc set_fOutX*(a: var DCB, fOutX: DWORD)
proc fInX*(a: var DCB): DWORD
proc set_fInX*(a: var DCB, fInX: DWORD)
proc fErrorChar*(a: var DCB): DWORD
proc set_fErrorChar*(a: var DCB, fErrorChar: DWORD)
proc fNull*(a: var DCB): DWORD
proc set_fNull*(a: var DCB, fNull: DWORD)
proc fRtsControl*(a: var DCB): DWORD
proc set_fRtsControl*(a: var DCB, fRtsControl: DWORD)
proc fAbortOnError*(a: var DCB): DWORD
proc set_fAbortOnError*(a: var DCB, fAbortOnError: DWORD)
proc fDummy2*(a: var DCB): DWORD
proc set_fDummy2*(a: var DCB, fDummy2: DWORD)
type
  COMMCONFIG* {.final, pure.} = object
    dwSize*: DWORD
    wVersion*: int16
    wReserved*: int16
    dcb*: DCB
    dwProviderSubType*: DWORD
    dwProviderOffset*: DWORD
    dwProviderSize*: DWORD
    wcProviderData*: array[0..0, WCHAR]

  LPCOMMCONFIG* = ptr COMMCONFIG
  TCOMMCONFIG* = COMMCONFIG
  PCOMMCONFIG* = ptr COMMCONFIG
  COMMPROP* {.final, pure.} = object
    wPacketLength*: int16
    wPacketVersion*: int16
    dwServiceMask*: DWORD
    dwReserved1*: DWORD
    dwMaxTxQueue*: DWORD
    dwMaxRxQueue*: DWORD
    dwMaxBaud*: DWORD
    dwProvSubType*: DWORD
    dwProvCapabilities*: DWORD
    dwSettableParams*: DWORD
    dwSettableBaud*: DWORD
    wSettableData*: int16
    wSettableStopParity*: int16
    dwCurrentTxQueue*: DWORD
    dwCurrentRxQueue*: DWORD
    dwProvSpec1*: DWORD
    dwProvSpec2*: DWORD
    wcProvChar*: array[0..0, WCHAR]

  LPCOMMPROP* = ptr COMMPROP
  TCOMMPROP* = COMMPROP
  PCOMMPROP* = ptr COMMPROP
  COMMTIMEOUTS* {.final, pure.} = object
    ReadIntervalTimeout*: DWORD
    ReadTotalTimeoutMultiplier*: DWORD
    ReadTotalTimeoutConstant*: DWORD
    WriteTotalTimeoutMultiplier*: DWORD
    WriteTotalTimeoutConstant*: DWORD

  LPCOMMTIMEOUTS* = ptr COMMTIMEOUTS
  TCOMMTIMEOUTS* = COMMTIMEOUTS
  PCOMMTIMEOUTS* = ptr COMMTIMEOUTS
  COMPAREITEMSTRUCT* {.final, pure.} = object
    CtlType*: UINT
    CtlID*: UINT
    hwndItem*: HWND
    itemID1*: UINT
    itemData1*: ULONG_PTR
    itemID2*: UINT
    itemData2*: ULONG_PTR

  TCOMPAREITEMSTRUCT* = COMPAREITEMSTRUCT
  PCOMPAREITEMSTRUCT* = ptr COMPAREITEMSTRUCT
  COMPCOLOR* {.final, pure.} = object
    crText*: COLORREF
    crBackground*: COLORREF
    dwEffects*: DWORD

  TCOMPCOLOR* = COMPCOLOR
  PCOMPCOLOR* = ptr COMPCOLOR
  COMPOSITIONFORM* {.final, pure.} = object
    dwStyle*: DWORD
    ptCurrentPos*: POINT
    rcArea*: RECT

  LPCOMPOSITIONFORM* = ptr COMPOSITIONFORM
  TCOMPOSITIONFORM* = COMPOSITIONFORM
  PCOMPOSITIONFORM* = ptr COMPOSITIONFORM #     TComStatFlags = set of (fCtsHold, fDsrHold, fRlsdHold , fXoffHold ,
                                          #                    fXoffSent , fEof ,  fTxim  , fReserved);
  COMSTAT* {.final, pure.} = object
    flag0*: DWORD             # can't use tcomstatflags, set packing issues
                              # and conflicts with macro's
    cbInQue*: DWORD
    cbOutQue*: DWORD

  LPCOMSTAT* = ptr COMSTAT
  TCOMSTAT* = COMSTAT
  PCOMSTAT* = ptr COMSTAT

const
  bm_COMSTAT_fCtsHold* = 0x00000001
  bp_COMSTAT_fCtsHold* = 0'i32
  bm_COMSTAT_fDsrHold* = 0x00000002
  bp_COMSTAT_fDsrHold* = 1'i32
  bm_COMSTAT_fRlsdHold* = 0x00000004
  bp_COMSTAT_fRlsdHold* = 2'i32
  bm_COMSTAT_fXoffHold* = 0x00000008
  bp_COMSTAT_fXoffHold* = 3'i32
  bm_COMSTAT_fXoffSent* = 0x00000010
  bp_COMSTAT_fXoffSent* = 4'i32
  bm_COMSTAT_fEof* = 0x00000020
  bp_COMSTAT_fEof* = 5'i32
  bm_COMSTAT_fTxim* = 0x00000040
  bp_COMSTAT_fTxim* = 6'i32
  bm_COMSTAT_fReserved* = 0xFFFFFF80'i32
  bp_COMSTAT_fReserved* = 7'i32

proc fCtsHold*(a: var COMSTAT): DWORD
  # should be renamed to get_<x>?
proc set_fCtsHold*(a: var COMSTAT, fCtsHold: DWORD)
proc fDsrHold*(a: var COMSTAT): DWORD
proc set_fDsrHold*(a: var COMSTAT, fDsrHold: DWORD)
proc fRlsdHold*(a: var COMSTAT): DWORD
proc set_fRlsdHold*(a: var COMSTAT, fRlsdHold: DWORD)
proc fXoffHold*(a: var COMSTAT): DWORD
proc set_fXoffHold*(a: var COMSTAT, fXoffHold: DWORD)
proc fXoffSent*(a: var COMSTAT): DWORD
proc set_fXoffSent*(a: var COMSTAT, fXoffSent: DWORD)
proc fEof*(a: var COMSTAT): DWORD
proc set_fEof*(a: var COMSTAT, fEof: DWORD)
proc fTxim*(a: var COMSTAT): DWORD
proc set_fTxim*(a: var COMSTAT, fTxim: DWORD)
proc fReserved*(a: var COMSTAT): DWORD
proc set_fReserved*(a: var COMSTAT, fReserved: DWORD)
type
  CONSOLE_CURSOR_INFO* {.final, pure.} = object
    dwSize*: DWORD
    bVisible*: WINBOOL

  PCONSOLE_CURSOR_INFO* = ptr CONSOLE_CURSOR_INFO
  TCONSOLECURSORINFO* = CONSOLE_CURSOR_INFO
  TCURSORINFO* = CONSOLE_CURSOR_INFO
  COORD* {.final, pure.} = object
    X*: SHORT
    Y*: SHORT

  TCOORD* = COORD
  PCOORD* = ptr COORD
  SMALL_RECT* {.final, pure.} = object
    Left*: SHORT
    Top*: SHORT
    Right*: SHORT
    Bottom*: SHORT

  TSMALL_RECT* = SMALL_RECT
  PSMALL_RECT* = ptr SMALL_RECT
  CONSOLE_SCREEN_BUFFER_INFO* {.final, pure.} = object
    dwSize*: COORD
    dwCursorPosition*: COORD
    wAttributes*: int16
    srWindow*: SMALL_RECT
    dwMaximumWindowSize*: COORD

  PCONSOLE_SCREEN_BUFFER_INFO* = ptr CONSOLE_SCREEN_BUFFER_INFO
  TCONSOLESCREENBUFFERINFO* = CONSOLE_SCREEN_BUFFER_INFO

when defined(i386):
  type
    FLOATING_SAVE_AREA* {.final, pure.} = object
      ControlWord*: DWORD
      StatusWord*: DWORD
      TagWord*: DWORD
      ErrorOffset*: DWORD
      ErrorSelector*: DWORD
      DataOffset*: DWORD
      DataSelector*: DWORD
      RegisterArea*: array[0..79, int8]
      Cr0NpxState*: DWORD

    TFLOATINGSAVEAREA* = FLOATING_SAVE_AREA
    PFLOATINGSAVEAREA* = ptr FLOATING_SAVE_AREA
    CONTEXT* {.final, pure.} = object
      ContextFlags*: DWORD
      Dr0*: DWORD
      Dr1*: DWORD
      Dr2*: DWORD
      Dr3*: DWORD
      Dr6*: DWORD
      Dr7*: DWORD
      FloatSave*: FLOATING_SAVE_AREA
      SegGs*: DWORD
      SegFs*: DWORD
      SegEs*: DWORD
      SegDs*: DWORD
      Edi*: DWORD
      Esi*: DWORD
      Ebx*: DWORD
      Edx*: DWORD
      Ecx*: DWORD
      Eax*: DWORD
      Ebp*: DWORD
      Eip*: DWORD
      SegCs*: DWORD
      EFlags*: DWORD
      Esp*: DWORD
      SegSs*: DWORD

elif defined(x86_64):
  #
  # Define 128-bit 16-byte aligned xmm register type.
  #
  type
    M128A* {.final, pure.} = object
      Low*: ULONGLONG
      High*: LONGLONG

    TM128A* = M128A
    PM128A* = TM128A #typedef struct _XMM_SAVE_AREA32 {
    XMM_SAVE_AREA32* {.final, pure.} = object
      ControlWord*: int16
      StatusWord*: int16
      TagWord*: int8
      Reserved1*: int8
      ErrorOpcode*: int16
      ErrorOffset*: DWORD
      ErrorSelector*: int16
      Reserved2*: int16
      DataOffset*: DWORD
      DataSelector*: int16
      Reserved3*: int16
      MxCsr*: DWORD
      MxCsr_Mask*: DWORD
      FloatRegisters*: array[0..7, M128A]
      XmmRegisters*: array[0..16, M128A]
      Reserved4*: array[0..95, int8]

    TXmmSaveArea* = XMM_SAVE_AREA32
    PXmmSaveArea* = ptr TXmmSaveArea
  type
    CONTEXT* {.final, pure.} = object
      P1Home*: DWORD64
      P2Home*: DWORD64
      P3Home*: DWORD64
      P4Home*: DWORD64
      P5Home*: DWORD64
      P6Home*: DWORD64        #
                              # Control flags.
                              #
      ContextFlags*: DWORD
      MxCsr*: DWORD           #
                              # Segment Registers and processor flags.
                              #
      SegCs*: int16
      SegDs*: int16
      SegEs*: int16
      SegFs*: int16
      SegGs*: int16
      SegSs*: int16
      EFlags*: DWORD          #
                              # Debug registers
                              #
      Dr0*: DWORD64
      Dr1*: DWORD64
      Dr2*: DWORD64
      Dr3*: DWORD64
      Dr6*: DWORD64
      Dr7*: DWORD64           #
                              # Integer registers.
                              #
      Rax*: DWORD64
      Rcx*: DWORD64
      Rdx*: DWORD64
      Rbx*: DWORD64
      Rsp*: DWORD64
      Rbp*: DWORD64
      Rsi*: DWORD64
      Rdi*: DWORD64
      R8*: DWORD64
      R9*: DWORD64
      R10*: DWORD64
      R11*: DWORD64
      R12*: DWORD64
      R13*: DWORD64
      R14*: DWORD64
      R15*: DWORD64           #
                              # Program counter.
                              #
      Rip*: DWORD64           #
                              # Floating point state.
                              #
      FltSave*: XMM_SAVE_AREA32 # MWE: only translated the FltSave part of the union
                                #
                                # Vector registers.
                                #
      VectorRegister*: array[0..25, M128A]
      VectorControl*: DWORD64 #
                              # Special debug control registers.
                              #
      DebugControl*: DWORD64
      LastBranchToRip*: DWORD64
      LastBranchFromRip*: DWORD64
      LastExceptionToRip*: DWORD64
      LastExceptionFromRip*: DWORD64

elif defined(powerpc32):
  # ppc
  # Floating point registers returned when CONTEXT_FLOATING_POINT is set
  # Integer registers returned when CONTEXT_INTEGER is set.
  # Condition register
  # Fixed point exception register
  # The following are set when CONTEXT_CONTROL is set.
  # Machine status register
  # Instruction address register
  # Link register
  # Control register
  # Control which context values are returned
  # Registers returned if CONTEXT_DEBUG_REGISTERS is set.
  # Breakpoint Register 1
  # Breakpoint Register 2
  # Breakpoint Register 3
  # Breakpoint Register 4
  # Breakpoint Register 5
  # Breakpoint Register 6
  # Debug Status Register
  # Debug Control Register
  type
    CONTEXT* {.final, pure.} = object
      Fpr0*: float64
      Fpr1*: float64
      Fpr2*: float64
      Fpr3*: float64
      Fpr4*: float64
      Fpr5*: float64
      Fpr6*: float64
      Fpr7*: float64
      Fpr8*: float64
      Fpr9*: float64
      Fpr10*: float64
      Fpr11*: float64
      Fpr12*: float64
      Fpr13*: float64
      Fpr14*: float64
      Fpr15*: float64
      Fpr16*: float64
      Fpr17*: float64
      Fpr18*: float64
      Fpr19*: float64
      Fpr20*: float64
      Fpr21*: float64
      Fpr22*: float64
      Fpr23*: float64
      Fpr24*: float64
      Fpr25*: float64
      Fpr26*: float64
      Fpr27*: float64
      Fpr28*: float64
      Fpr29*: float64
      Fpr30*: float64
      Fpr31*: float64
      Fpscr*: float64
      Gpr0*: DWORD
      Gpr1*: DWORD
      Gpr2*: DWORD
      Gpr3*: DWORD
      Gpr4*: DWORD
      Gpr5*: DWORD
      Gpr6*: DWORD
      Gpr7*: DWORD
      Gpr8*: DWORD
      Gpr9*: DWORD
      Gpr10*: DWORD
      Gpr11*: DWORD
      Gpr12*: DWORD
      Gpr13*: DWORD
      Gpr14*: DWORD
      Gpr15*: DWORD
      Gpr16*: DWORD
      Gpr17*: DWORD
      Gpr18*: DWORD
      Gpr19*: DWORD
      Gpr20*: DWORD
      Gpr21*: DWORD
      Gpr22*: DWORD
      Gpr23*: DWORD
      Gpr24*: DWORD
      Gpr25*: DWORD
      Gpr26*: DWORD
      Gpr27*: DWORD
      Gpr28*: DWORD
      Gpr29*: DWORD
      Gpr30*: DWORD
      Gpr31*: DWORD
      Cr*: DWORD
      Xer*: DWORD
      Msr*: DWORD
      Iar*: DWORD
      Lr*: DWORD
      Ctr*: DWORD
      ContextFlags*: DWORD
      Fill*: array[0..2, DWORD]
      Dr0*: DWORD
      Dr1*: DWORD
      Dr2*: DWORD
      Dr3*: DWORD
      Dr4*: DWORD
      Dr5*: DWORD
      Dr6*: DWORD
      Dr7*: DWORD

else:
  # dummy CONTEXT so that it compiles:
  type
    CONTEXT* {.final, pure.} = object
      data: array [0..255, float64]

type
  LPCONTEXT* = ptr CONTEXT
  TCONTEXT* = CONTEXT
  PCONTEXT* = ptr CONTEXT

type
  LIST_ENTRY* {.final, pure.} = object
    Flink*: ptr LIST_ENTRY
    Blink*: ptr LIST_ENTRY

  TLISTENTRY* = LIST_ENTRY
  PLISTENTRY* = ptr LIST_ENTRY
  CRITICAL_SECTION_DEBUG* {.final, pure.} = object
    `type`*: int16
    CreatorBackTraceIndex*: int16
    CriticalSection*: ptr TCRITICAL_SECTION
    ProcessLocksList*: LIST_ENTRY
    EntryCount*: DWORD
    ContentionCount*: DWORD
    Depth*: DWORD
    OwnerBackTrace*: array[0..4, PVOID]

  TRTL_CRITICAL_SECTION* {.final, pure.} = object
    DebugInfo*: ptr CRITICAL_SECTION_DEBUG
    LockCount*: int32
    RecursionCount*: int32
    OwningThread*: Handle
    LockSemaphore*: Handle
    Reserved*: DWORD

  PRTLCriticalSection* = ptr TRTLCriticalSection

  LPCRITICAL_SECTION_DEBUG* = ptr CRITICAL_SECTION_DEBUG
  PCRITICAL_SECTION_DEBUG* = ptr CRITICAL_SECTION_DEBUG
  TCRITICALSECTIONDEBUG* = CRITICAL_SECTION_DEBUG
  TCRITICAL_SECTION* = TRTLCriticalSection
  PCRITICAL_SECTION* = PRTLCriticalSection
  LPCRITICAL_SECTION* = PRTLCriticalSection
  SECURITY_QUALITY_OF_SERVICE* {.final, pure.} = object
    len*: DWORD
    ImpersonationLevel*: SECURITY_IMPERSONATION_LEVEL
    ContextTrackingMode*: WINBOOL
    EffectiveOnly*: bool

  PSECURITY_QUALITY_OF_SERVICE* = ptr SECURITY_QUALITY_OF_SERVICE
  TSECURITYQUALITYOFSERVICE* = SECURITY_QUALITY_OF_SERVICE
  CONVCONTEXT* {.final, pure.} = object
    cb*: UINT
    wFlags*: UINT
    wCountryID*: UINT
    iCodePage*: int32
    dwLangID*: DWORD
    dwSecurity*: DWORD
    qos*: SECURITY_QUALITY_OF_SERVICE

  TCONVCONTEXT* = CONVCONTEXT
  PCONVCONTEXT* = ptr CONVCONTEXT
  CONVINFO* {.final, pure.} = object
    cb*: DWORD
    hUser*: DWORD
    hConvPartner*: HCONV
    hszSvcPartner*: HSZ
    hszServiceReq*: HSZ
    hszTopic*: HSZ
    hszItem*: HSZ
    wFmt*: UINT
    wType*: UINT
    wStatus*: UINT
    wConvst*: UINT
    wLastError*: UINT
    hConvList*: HCONVLIST
    ConvCtxt*: CONVCONTEXT
    hwnd*: HWND
    hwndPartner*: HWND

  TCONVINFO* = CONVINFO
  PCONVINFO* = ptr CONVINFO
  COPYDATASTRUCT* {.final, pure.} = object
    dwData*: DWORD
    cbData*: DWORD
    lpData*: PVOID

  TCOPYDATASTRUCT* = COPYDATASTRUCT
  PCOPYDATASTRUCT* = ptr COPYDATASTRUCT
  CPINFO* {.final, pure.} = object
    MaxCharSize*: UINT
    DefaultChar*: array[0..(MAX_DEFAULTCHAR) - 1, int8]
    LeadByte*: array[0..(MAX_LEADBYTES) - 1, int8]

  LPCPINFO* = ptr CPINFO
  Tcpinfo* = CPINFO
  Pcpinfo* = ptr CPINFO
  CPLINFO* {.final, pure.} = object
    idIcon*: int32
    idName*: int32
    idInfo*: int32
    lData*: LONG

  TCPLINFO* = CPLINFO
  PCPLINFO* = ptr CPLINFO
  CREATE_PROCESS_DEBUG_INFO* {.final, pure.} = object
    hFile*: HANDLE
    hProcess*: HANDLE
    hThread*: HANDLE
    lpBaseOfImage*: LPVOID
    dwDebugInfoFileOffset*: DWORD
    nDebugInfoSize*: DWORD
    lpThreadLocalBase*: LPVOID
    lpStartAddress*: LPTHREAD_START_ROUTINE
    lpImageName*: LPVOID
    fUnicode*: int16

  TCREATEPROCESSDEBUGINFO* = CREATE_PROCESS_DEBUG_INFO
  PCREATEPROCESSDEBUGINFO* = ptr CREATE_PROCESS_DEBUG_INFO
  CREATE_THREAD_DEBUG_INFO* {.final, pure.} = object
    hThread*: HANDLE
    lpThreadLocalBase*: LPVOID
    lpStartAddress*: LPTHREAD_START_ROUTINE

  TCREATETHREADDEBUGINFO* = CREATE_THREAD_DEBUG_INFO
  PCREATETHREADDEBUGINFO* = ptr CREATE_THREAD_DEBUG_INFO

  CURRENCYFMT* {.final, pure.} = object
    NumDigits*: UINT
    LeadingZero*: UINT
    Grouping*: UINT
    lpDecimalSep*: LPTSTR
    lpThousandSep*: LPTSTR
    NegativeOrder*: UINT
    PositiveOrder*: UINT
    lpCurrencySymbol*: LPTSTR

  Tcurrencyfmt* = CURRENCYFMT
  Pcurrencyfmt* = ptr CURRENCYFMT
  CURSORSHAPE* {.final, pure.} = object
    xHotSpot*: int32
    yHotSpot*: int32
    cx*: int32
    cy*: int32
    cbWidth*: int32
    Planes*: int8
    BitsPixel*: int8

  LPCURSORSHAPE* = ptr CURSORSHAPE
  TCURSORSHAPE* = CURSORSHAPE
  PCURSORSHAPE* = ptr CURSORSHAPE
  CWPRETSTRUCT* {.final, pure.} = object
    lResult*: LRESULT
    lParam*: LPARAM
    wParam*: WPARAM
    message*: DWORD
    hwnd*: HWND

  TCWPRETSTRUCT* = CWPRETSTRUCT
  PCWPRETSTRUCT* = ptr CWPRETSTRUCT
  CWPSTRUCT* {.final, pure.} = object
    lParam*: LPARAM
    wParam*: WPARAM
    message*: UINT
    hwnd*: HWND

  TCWPSTRUCT* = CWPSTRUCT
  PCWPSTRUCT* = ptr CWPSTRUCT
  DATATYPES_INFO_1* {.final, pure.} = object
    pName*: LPTSTR

  TDATATYPESINFO1* = DATATYPES_INFO_1
  PDATATYPESINFO1* = ptr DATATYPES_INFO_1
  DDEACK* {.final, pure.} = object
    flag0*: int16

  TDDEACK* = DDEACK
  PDDEACK* = ptr DDEACK

const
  bm_DDEACK_bAppReturnCode* = 0x000000FF'i16
  bp_DDEACK_bAppReturnCode* = 0'i16
  bm_DDEACK_reserved* = 0x00003F00'i16
  bp_DDEACK_reserved* = 8'i16
  bm_DDEACK_fBusy* = 0x00004000'i16
  bp_DDEACK_fBusy* = 14'i16
  bm_DDEACK_fAck* = 0x00008000'i16
  bp_DDEACK_fAck* = 15'i16

proc bAppReturnCode*(a: var DDEACK): int16
proc set_bAppReturnCode*(a: var DDEACK, bAppReturnCode: int16)
proc reserved*(a: var DDEACK): int16
proc set_reserved*(a: var DDEACK, reserved: int16)
proc fBusy*(a: var DDEACK): int16
proc set_fBusy*(a: var DDEACK, fBusy: int16)
proc fAck*(a: var DDEACK): int16
proc set_fAck*(a: var DDEACK, fAck: int16)
type
  DDEADVISE* {.final, pure.} = object
    flag0*: int16
    cfFormat*: SHORT

  TDDEADVISE* = DDEADVISE
  PDDEADVISE* = ptr DDEADVISE

const
  bm_DDEADVISE_reserved* = 0x00003FFF'i16
  bp_DDEADVISE_reserved* = 0'i16
  bm_DDEADVISE_fDeferUpd* = 0x00004000'i16
  bp_DDEADVISE_fDeferUpd* = 14'i16
  bm_DDEADVISE_fAckReq* = 0x00008000'i16
  bp_DDEADVISE_fAckReq* = 15'i16

proc reserved*(a: var DDEADVISE): int16
proc set_reserved*(a: var DDEADVISE, reserved: int16)
proc fDeferUpd*(a: var DDEADVISE): int16
proc set_fDeferUpd*(a: var DDEADVISE, fDeferUpd: int16)
proc fAckReq*(a: var DDEADVISE): int16
proc set_fAckReq*(a: var DDEADVISE, fAckReq: int16)
type
  DDEDATA* {.final, pure.} = object
    flag0*: int16
    cfFormat*: SHORT
    Value*: array[0..0, int8]

  PDDEDATA* = ptr DDEDATA

const
  bm_DDEDATA_unused* = 0x00000FFF'i16
  bp_DDEDATA_unused* = 0'i16
  bm_DDEDATA_fResponse* = 0x00001000'i16
  bp_DDEDATA_fResponse* = 12'i16
  bm_DDEDATA_fRelease* = 0x00002000'i16
  bp_DDEDATA_fRelease* = 13'i16
  bm_DDEDATA_reserved* = 0x00004000'i16
  bp_DDEDATA_reserved* = 14'i16
  bm_DDEDATA_fAckReq* = 0x00008000'i16
  bp_DDEDATA_fAckReq* = 15'i16

proc unused*(a: var DDEDATA): int16
proc set_unused*(a: var DDEDATA, unused: int16)
proc fResponse*(a: var DDEDATA): int16
proc set_fResponse*(a: var DDEDATA, fResponse: int16)
proc fRelease*(a: var DDEDATA): int16
proc set_fRelease*(a: var DDEDATA, fRelease: int16)
proc reserved*(a: var DDEDATA): int16
proc set_reserved*(a: var DDEDATA, reserved: int16)
proc fAckReq*(a: var DDEDATA): int16
proc set_fAckReq*(a: var DDEDATA, fAckReq: int16)
type
  DDELN* {.final, pure.} = object
    flag0*: int16
    cfFormat*: SHORT

  TDDELN* = DDELN
  PDDELN* = ptr DDELN

const
  bm_DDELN_unused* = 0x00001FFF'i16
  bp_DDELN_unused* = 0'i16
  bm_DDELN_fRelease* = 0x00002000'i16
  bp_DDELN_fRelease* = 13'i16
  bm_DDELN_fDeferUpd* = 0x00004000'i16
  bp_DDELN_fDeferUpd* = 14'i16
  bm_DDELN_fAckReq* = 0x00008000'i16
  bp_DDELN_fAckReq* = 15'i16

proc unused*(a: var DDELN): int16
proc set_unused*(a: var DDELN, unused: int16)
proc fRelease*(a: var DDELN): int16
proc set_fRelease*(a: var DDELN, fRelease: int16)
proc fDeferUpd*(a: var DDELN): int16
proc set_fDeferUpd*(a: var DDELN, fDeferUpd: int16)
proc fAckReq*(a: var DDELN): int16
proc set_fAckReq*(a: var DDELN, fAckReq: int16)
type
  DDEML_MSG_HOOK_DATA* {.final, pure.} = object
    uiLo*: UINT
    uiHi*: UINT
    cbData*: DWORD
    Data*: array[0..7, DWORD]

  TDDEMLMSGHOOKDATA* = DDEML_MSG_HOOK_DATA
  PDDEMLMSGHOOKDATA* = ptr DDEML_MSG_HOOK_DATA
  DDEPOKE* {.final, pure.} = object
    flag0*: int16
    cfFormat*: SHORT
    Value*: array[0..0, int8]

  TDDEPOKE* = DDEPOKE
  PDDEPOKE* = ptr DDEPOKE

const
  bm_DDEPOKE_unused* = 0x00001FFF'i16
  bp_DDEPOKE_unused* = 0'i16
  bm_DDEPOKE_fRelease* = 0x00002000'i16
  bp_DDEPOKE_fRelease* = 13'i16
  bm_DDEPOKE_fReserved* = 0x0000C000'i16
  bp_DDEPOKE_fReserved* = 14'i16

proc unused*(a: var DDEPOKE): int16
proc set_unused*(a: var DDEPOKE, unused: int16)
proc fRelease*(a: var DDEPOKE): int16
proc set_fRelease*(a: var DDEPOKE, fRelease: int16)
proc fReserved*(a: var DDEPOKE): int16
proc set_fReserved*(a: var DDEPOKE, fReserved: int16)
type
  DDEUP* {.final, pure.} = object
    flag0*: int16
    cfFormat*: SHORT
    rgb*: array[0..0, int8]

  TDDEUP* = DDEUP
  PDDEUP* = ptr DDEUP

const
  bm_DDEUP_unused* = 0x00000FFF'i16
  bp_DDEUP_unused* = 0'i16
  bm_DDEUP_fAck* = 0x00001000'i16
  bp_DDEUP_fAck* = 12'i16
  bm_DDEUP_fRelease* = 0x00002000'i16
  bp_DDEUP_fRelease* = 13'i16
  bm_DDEUP_fReserved* = 0x00004000'i16
  bp_DDEUP_fReserved* = 14'i16
  bm_DDEUP_fAckReq* = 0x00008000'i16
  bp_DDEUP_fAckReq* = 15'i16

proc unused*(a: var DDEUP): int16
proc set_unused*(a: var DDEUP, unused: int16)
proc fAck*(a: var DDEUP): int16
proc set_fAck*(a: var DDEUP, fAck: int16)
proc fRelease*(a: var DDEUP): int16
proc set_fRelease*(a: var DDEUP, fRelease: int16)
proc fReserved*(a: var DDEUP): int16
proc set_fReserved*(a: var DDEUP, fReserved: int16)
proc fAckReq*(a: var DDEUP): int16
proc set_fAckReq*(a: var DDEUP, fAckReq: int16)
type
  EXCEPTION_RECORD* {.final, pure.} = object
    ExceptionCode*: DWORD
    ExceptionFlags*: DWORD
    ExceptionRecord*: ptr EXCEPTION_RECORD
    ExceptionAddress*: PVOID
    NumberParameters*: DWORD
    ExceptionInformation*: array[0..(EXCEPTION_MAXIMUM_PARAMETERS) - 1,
                                 ULONG_PTR]

  PEXCEPTION_RECORD* = ptr EXCEPTION_RECORD
  TEXCEPTIONRECORD* = EXCEPTION_RECORD
  EXCEPTION_DEBUG_INFO* {.final, pure.} = object
    ExceptionRecord*: EXCEPTION_RECORD
    dwFirstChance*: DWORD

  PEXCEPTION_DEBUG_INFO* = ptr EXCEPTION_DEBUG_INFO
  TEXCEPTIONDEBUGINFO* = EXCEPTION_DEBUG_INFO
  EXCEPTION_RECORD32* {.final, pure.} = object
    ExceptionCode*: DWORD
    ExceptionFlags*: DWORD
    ExceptionRecord*: DWORD
    ExceptionAddress*: DWORD
    NumberParameters*: DWORD
    ExceptionInformation*: array[0..(EXCEPTION_MAXIMUM_PARAMETERS) - 1, DWORD]

  PEXCEPTION_RECORD32* = ptr EXCEPTION_RECORD32
  TExceptionRecord32* = EXCEPTION_RECORD32
  EXCEPTION_DEBUG_INFO32* {.final, pure.} = object
    ExceptionRecord*: EXCEPTION_RECORD32
    dwFirstChance*: DWORD

  PEXCEPTION_DEBUG_INFO32* = ptr EXCEPTION_DEBUG_INFO32
  TExceptionDebugInfo32* = EXCEPTION_DEBUG_INFO32
  EXCEPTION_RECORD64* {.final, pure.} = object
    ExceptionCode*: DWORD
    ExceptionFlags*: DWORD
    ExceptionRecord*: DWORD64
    ExceptionAddress*: DWORD64
    NumberParameters*: DWORD
    unusedAlignment*: DWORD
    ExceptionInformation*: array[0..(EXCEPTION_MAXIMUM_PARAMETERS) - 1, DWORD64]

  PEXCEPTION_RECORD64* = ptr EXCEPTION_RECORD64
  TExceptionRecord64* = EXCEPTION_RECORD64
  EXCEPTION_DEBUG_INFO64* {.final, pure.} = object
    ExceptionRecord*: EXCEPTION_RECORD64
    dwFirstChance*: DWORD

  PEXCEPTION_DEBUG_INFO64* = ptr EXCEPTION_DEBUG_INFO64
  TExceptionDebugInfo64* = EXCEPTION_DEBUG_INFO64
  EXIT_PROCESS_DEBUG_INFO* {.final, pure.} = object
    dwExitCode*: DWORD

  TEXITPROCESSDEBUGINFO* = EXIT_PROCESS_DEBUG_INFO
  PEXITPROCESSDEBUGINFO* = ptr EXIT_PROCESS_DEBUG_INFO
  EXIT_THREAD_DEBUG_INFO* {.final, pure.} = object
    dwExitCode*: DWORD

  TEXITTHREADDEBUGINFO* = EXIT_THREAD_DEBUG_INFO
  PEXITTHREADDEBUGINFO* = ptr EXIT_THREAD_DEBUG_INFO
  LOAD_DLL_DEBUG_INFO* {.final, pure.} = object
    hFile*: HANDLE
    lpBaseOfDll*: LPVOID
    dwDebugInfoFileOffset*: DWORD
    nDebugInfoSize*: DWORD
    lpImageName*: LPVOID
    fUnicode*: int16

  TLOADDLLDEBUGINFO* = LOAD_DLL_DEBUG_INFO
  PLOADDLLDEBUGINFO* = ptr LOAD_DLL_DEBUG_INFO
  UNLOAD_DLL_DEBUG_INFO* {.final, pure.} = object
    lpBaseOfDll*: LPVOID

  TUNLOADDLLDEBUGINFO* = UNLOAD_DLL_DEBUG_INFO
  PUNLOADDLLDEBUGINFO* = ptr UNLOAD_DLL_DEBUG_INFO
  OUTPUT_DEBUG_STRING_INFO* {.final, pure.} = object
    lpDebugStringData*: LPSTR
    fUnicode*: int16
    nDebugStringLength*: int16

  TOUTPUTDEBUGSTRINGINFO* = OUTPUT_DEBUG_STRING_INFO
  POUTPUTDEBUGSTRINGINFO* = ptr OUTPUT_DEBUG_STRING_INFO
  RIP_INFO* {.final, pure.} = object
    dwError*: DWORD
    dwType*: DWORD

  TRIPINFO* = RIP_INFO
  PRIPINFO* = ptr RIP_INFO
  DEBUG_EVENT* {.final, pure.} = object
    dwDebugEventCode*: DWORD
    dwProcessId*: DWORD
    dwThreadId*: DWORD
    data*: array[0..15, DWORD]

  LPDEBUG_EVENT* = ptr DEBUG_EVENT
  TDEBUGEVENT* = DEBUG_EVENT
  PDEBUGEVENT* = ptr DEBUG_EVENT
  DEBUGHOOKINFO* {.final, pure.} = object
    idThread*: DWORD
    idThreadInstaller*: DWORD
    lParam*: LPARAM
    wParam*: WPARAM
    code*: int32

  TDEBUGHOOKINFO* = DEBUGHOOKINFO
  PDEBUGHOOKINFO* = ptr DEBUGHOOKINFO
  DELETEITEMSTRUCT* {.final, pure.} = object
    CtlType*: UINT
    CtlID*: UINT
    itemID*: UINT
    hwndItem*: HWND
    itemData*: ULONG_PTR

  TDELETEITEMSTRUCT* = DELETEITEMSTRUCT
  PDELETEITEMSTRUCT* = ptr DELETEITEMSTRUCT
  DEV_BROADCAST_HDR* {.final, pure.} = object
    dbch_size*: ULONG
    dbch_devicetype*: ULONG
    dbch_reserved*: ULONG

  PDEV_BROADCAST_HDR* = ptr DEV_BROADCAST_HDR
  TDEVBROADCASTHDR* = DEV_BROADCAST_HDR
  DEV_BROADCAST_OEM* {.final, pure.} = object
    dbco_size*: ULONG
    dbco_devicetype*: ULONG
    dbco_reserved*: ULONG
    dbco_identifier*: ULONG
    dbco_suppfunc*: ULONG

  PDEV_BROADCAST_OEM* = ptr DEV_BROADCAST_OEM
  TDEVBROADCASTOEM* = DEV_BROADCAST_OEM
  DEV_BROADCAST_PORT* {.final, pure.} = object
    dbcp_size*: ULONG
    dbcp_devicetype*: ULONG
    dbcp_reserved*: ULONG
    dbcp_name*: array[0..0, char]

  PDEV_BROADCAST_PORT* = ptr DEV_BROADCAST_PORT
  TDEVBROADCASTPORT* = DEV_BROADCAST_PORT
  DEV_BROADCAST_USERDEFINED* {.final, pure.} = object
    dbud_dbh*: DEV_BROADCAST_HDR
    dbud_szName*: array[0..0, char]
    dbud_rgbUserDefined*: array[0..0, int8]

  TDEVBROADCASTUSERDEFINED* = DEV_BROADCAST_USERDEFINED
  PDEVBROADCASTUSERDEFINED* = ptr DEV_BROADCAST_USERDEFINED
  DEV_BROADCAST_VOLUME* {.final, pure.} = object
    dbcv_size*: ULONG
    dbcv_devicetype*: ULONG
    dbcv_reserved*: ULONG
    dbcv_unitmask*: ULONG
    dbcv_flags*: USHORT

  PDEV_BROADCAST_VOLUME* = ptr DEV_BROADCAST_VOLUME
  TDEVBROADCASTVOLUME* = DEV_BROADCAST_VOLUME
  DEVMODE* {.final, pure.} = object
    dmDeviceName*: array[0..(CCHDEVICENAME) - 1, BCHAR]
    dmSpecVersion*: int16
    dmDriverVersion*: int16
    dmSize*: int16
    dmDriverExtra*: int16
    dmFields*: DWORD
    dmOrientation*: int16
    dmPaperSize*: int16
    dmPaperLength*: int16
    dmPaperWidth*: int16
    dmScale*: int16
    dmCopies*: int16
    dmDefaultSource*: int16
    dmPrintQuality*: int16
    dmColor*: int16
    dmDuplex*: int16
    dmYResolution*: int16
    dmTTOption*: int16
    dmCollate*: int16
    dmFormName*: array[0..(CCHFORMNAME) - 1, BCHAR]
    dmLogPixels*: int16
    dmBitsPerPel*: DWORD
    dmPelsWidth*: DWORD
    dmPelsHeight*: DWORD
    dmDisplayFlags*: DWORD
    dmDisplayFrequency*: DWORD
    dmICMMethod*: DWORD
    dmICMIntent*: DWORD
    dmMediaType*: DWORD
    dmDitherType*: DWORD
    dmICCManufacturer*: DWORD
    dmICCModel*: DWORD        # other union part:
                              # dmPosition: POINTL;
                              # dmDisplayOrientation: DWORD;
                              # dmDisplayFixedOutput: DWORD;

  LPDEVMODE* = ptr DEVMODE
  devicemode* = DEVMODE
  tdevicemode* = DEVMODE
  tdevicemodeA* = DEVMODE
  PDeviceModeA* = LPDEVMODE
  PDeviceMode* = LPDEVMODE
  TDEVMODE* = DEVMODE
  PDEVMODE* = LPDEVMODE
  devmodeW* {.final, pure.} = object
    dmDeviceName*: array[0..CCHDEVICENAME - 1, WCHAR]
    dmSpecVersion*: int16
    dmDriverVersion*: int16
    dmSize*: int16
    dmDriverExtra*: int16
    dmFields*: DWORD
    dmOrientation*: short
    dmPaperSize*: short
    dmPaperLength*: short
    dmPaperWidth*: short
    dmScale*: short
    dmCopies*: short
    dmDefaultSource*: short
    dmPrintQuality*: short
    dmColor*: short
    dmDuplex*: short
    dmYResolution*: short
    dmTTOption*: short
    dmCollate*: short
    dmFormName*: array[0..CCHFORMNAME - 1, wchar]
    dmLogPixels*: int16
    dmBitsPerPel*: DWORD
    dmPelsWidth*: DWORD
    dmPelsHeight*: DWORD
    dmDisplayFlags*: DWORD
    dmDisplayFrequency*: DWORD
    dmICMMethod*: DWORD
    dmICMIntent*: DWORD
    dmMediaType*: DWORD
    dmDitherType*: DWORD
    dmReserved1*: DWORD
    dmReserved2*: DWORD
    dmPanningWidth*: DWORD
    dmPanningHeight*: DWORD

  LPDEVMODEW* = ptr DEVMODEW
  devicemodeW* = DEVMODEW
  TDeviceModeW* = DEVMODEW
  PDeviceModeW* = LPDEVMODEW
  TDEVMODEW* = DEVMODEW
  PDEVMODEW* = LPDEVMODEW
  DEVNAMES* {.final, pure.} = object
    wDriverOffset*: int16
    wDeviceOffset*: int16
    wOutputOffset*: int16
    wDefault*: int16

  LPDEVNAMES* = ptr DEVNAMES
  TDEVNAMES* = DEVNAMES
  PDEVNAMES* = ptr DEVNAMES
  DIBSECTION* {.final, pure.} = object
    dsBm*: BITMAP
    dsBmih*: BITMAPINFOHEADER
    dsBitfields*: array[0..2, DWORD]
    dshSection*: HANDLE
    dsOffset*: DWORD

  TDIBSECTION* = DIBSECTION
  PDIBSECTION* = ptr DIBSECTION #
                                #     LARGE_INTEGER = record
                                #        case byte of
                                #          0: (LowPart : DWORD;
                                #              HighPart : LONG);
                                #          1: (QuadPart : LONGLONG);
                                #       end;     ULARGE_INTEGER = record
                                #        case byte of
                                #          0: (LowPart : DWORD;
                                #              HighPart : DWORD);
                                #          1: (QuadPart : LONGLONG);
                                #       end;
                                #
  LARGE_INTEGER* = int64
  ULARGE_INTEGER* = int64
  PLARGE_INTEGER* = ptr LARGE_INTEGER
  TLargeInteger* = Int64
  PULARGE_INTEGER* = ptr ULARGE_INTEGER
  TULargeInteger* = int64
  DISK_GEOMETRY* {.final, pure.} = object
    Cylinders*: LARGE_INTEGER
    MediaType*: MEDIA_TYPE
    TracksPerCylinder*: DWORD
    SectorsPerTrack*: DWORD
    BytesPerSector*: DWORD

  TDISKGEOMETRY* = DISK_GEOMETRY
  PDISKGEOMETRY* = ptr DISK_GEOMETRY
  DISK_PERFORMANCE* {.final, pure.} = object
    BytesRead*: LARGE_INTEGER
    BytesWritten*: LARGE_INTEGER
    ReadTime*: LARGE_INTEGER
    WriteTime*: LARGE_INTEGER
    ReadCount*: DWORD
    WriteCount*: DWORD
    QueueDepth*: DWORD

  TDISKPERFORMANCE* = DISK_PERFORMANCE
  PDISKPERFORMANCE* = ptr DISK_PERFORMANCE
  DLGITEMTEMPLATE* {.final, pure.} = object
    style*: DWORD
    dwExtendedStyle*: DWORD
    x*: int16
    y*: int16
    cx*: int16
    cy*: int16
    id*: int16

  LPDLGITEMTEMPLATE* = ptr DLGITEMTEMPLATE
  TDLGITEMTEMPLATE* = DLGITEMTEMPLATE
  PDLGITEMTEMPLATE* = ptr DLGITEMTEMPLATE
  DLGTEMPLATE* {.final, pure.} = object
    style*: DWORD
    dwExtendedStyle*: DWORD
    cdit*: int16
    x*: int16
    y*: int16
    cx*: int16
    cy*: int16

  LPDLGTEMPLATE* = ptr DLGTEMPLATE
  LPCDLGTEMPLATE* = ptr DLGTEMPLATE
  TDLGTEMPLATE* = DLGTEMPLATE
  PDLGTEMPLATE* = ptr DLGTEMPLATE
  DOC_INFO_1* {.final, pure.} = object
    pDocName*: LPTSTR
    pOutputFile*: LPTSTR
    pDatatype*: LPTSTR

  TDOCINFO1* = DOC_INFO_1
  PDOCINFO1* = ptr DOC_INFO_1
  DOC_INFO_2* {.final, pure.} = object
    pDocName*: LPTSTR
    pOutputFile*: LPTSTR
    pDatatype*: LPTSTR
    dwMode*: DWORD
    JobId*: DWORD

  TDOCINFO2* = DOC_INFO_2
  PDOCINFO2* = ptr DOC_INFO_2
  DOCINFO* {.final, pure.} = object
    cbSize*: int32
    lpszDocName*: LPCTSTR
    lpszOutput*: LPCTSTR
    lpszDatatype*: LPCTSTR
    fwType*: DWORD

  TDOCINFO* = DOCINFO
  TDOCINFOA* = DOCINFO
  PDOCINFO* = ptr DOCINFO
  DRAGLISTINFO* {.final, pure.} = object
    uNotification*: UINT
    hWnd*: HWND
    ptCursor*: POINT

  LPDRAGLISTINFO* = ptr DRAGLISTINFO
  TDRAGLISTINFO* = DRAGLISTINFO
  PDRAGLISTINFO* = ptr DRAGLISTINFO
  DRAWITEMSTRUCT* {.final, pure.} = object
    CtlType*: UINT
    CtlID*: UINT
    itemID*: UINT
    itemAction*: UINT
    itemState*: UINT
    hwndItem*: HWND
    hDC*: HDC
    rcItem*: RECT
    itemData*: ULONG_PTR

  LPDRAWITEMSTRUCT* = ptr DRAWITEMSTRUCT
  TDRAWITEMSTRUCT* = DRAWITEMSTRUCT
  PDRAWITEMSTRUCT* = ptr DRAWITEMSTRUCT
  DRAWTEXTPARAMS* {.final, pure.} = object
    cbSize*: UINT
    iTabLength*: int32
    iLeftMargin*: int32
    iRightMargin*: int32
    uiLengthDrawn*: UINT

  LPDRAWTEXTPARAMS* = ptr DRAWTEXTPARAMS
  TDRAWTEXTPARAMS* = DRAWTEXTPARAMS
  PDRAWTEXTPARAMS* = ptr DRAWTEXTPARAMS
  PARTITION_INFORMATION* {.final, pure.} = object
    PartitionType*: int8
    BootIndicator*: bool
    RecognizedPartition*: bool
    RewritePartition*: bool
    StartingOffset*: LARGE_INTEGER
    PartitionLength*: LARGE_INTEGER
    HiddenSectors*: LARGE_INTEGER

  TPARTITIONINFORMATION* = PARTITION_INFORMATION
  PPARTITIONINFORMATION* = ptr PARTITION_INFORMATION
  DRIVE_LAYOUT_INFORMATION* {.final, pure.} = object
    PartitionCount*: DWORD
    Signature*: DWORD
    PartitionEntry*: array[0..0, PARTITION_INFORMATION]

  TDRIVELAYOUTINFORMATION* = DRIVE_LAYOUT_INFORMATION
  PDRIVELAYOUTINFORMATION* = ptr DRIVE_LAYOUT_INFORMATION
  DRIVER_INFO_1* {.final, pure.} = object
    pName*: LPTSTR

  TDRIVERINFO1* = DRIVER_INFO_1
  PDRIVERINFO1* = ptr DRIVER_INFO_1
  DRIVER_INFO_2* {.final, pure.} = object
    cVersion*: DWORD
    pName*: LPTSTR
    pEnvironment*: LPTSTR
    pDriverPath*: LPTSTR
    pDataFile*: LPTSTR
    pConfigFile*: LPTSTR

  TDRIVERINFO2* = DRIVER_INFO_2
  PDRIVERINFO2* = ptr DRIVER_INFO_2
  DRIVER_INFO_3* {.final, pure.} = object
    cVersion*: DWORD
    pName*: LPTSTR
    pEnvironment*: LPTSTR
    pDriverPath*: LPTSTR
    pDataFile*: LPTSTR
    pConfigFile*: LPTSTR
    pHelpFile*: LPTSTR
    pDependentFiles*: LPTSTR
    pMonitorName*: LPTSTR
    pDefaultDataType*: LPTSTR

  TDRIVERINFO3* = DRIVER_INFO_3
  PDRIVERINFO3* = ptr DRIVER_INFO_3
  EDITSTREAM* {.final, pure.} = object
    dwCookie*: DWORD
    dwError*: DWORD
    pfnCallback*: EDITSTREAMCALLBACK

  Teditstream* = EDITSTREAM
  Peditstream* = ptr EDITSTREAM
  EMR* {.final, pure.} = object
    iType*: DWORD
    nSize*: DWORD

  TEMR* = EMR
  PEMR* = ptr EMR
  EMRANGLEARC* {.final, pure.} = object
    emr*: EMR
    ptlCenter*: POINTL
    nRadius*: DWORD
    eStartAngle*: float32
    eSweepAngle*: float32

  TEMRANGLEARC* = EMRANGLEARC
  PEMRANGLEARC* = ptr EMRANGLEARC
  EMRARC* {.final, pure.} = object
    emr*: EMR
    rclBox*: RECTL
    ptlStart*: POINTL
    ptlEnd*: POINTL

  TEMRARC* = EMRARC
  PEMRARC* = ptr EMRARC
  EMRARCTO* = EMRARC
  TEMRARCTO* = EMRARC
  PEMRARCTO* = ptr EMRARC
  EMRCHORD* = EMRARC
  TEMRCHORD* = EMRARC
  PEMRCHORD* = ptr EMRARC
  EMRPIE* = EMRARC
  TEMRPIE* = EMRARC
  PEMRPIE* = ptr EMRARC
  XFORM* {.final, pure.} = object
    eM11*: float32
    eM12*: float32
    eM21*: float32
    eM22*: float32
    eDx*: float32
    eDy*: float32

  LPXFORM* = ptr XFORM
  TXFORM* = XFORM
  PXFORM* = ptr XFORM
  EMRBITBLT* {.final, pure.} = object
    emr*: EMR
    rclBounds*: RECTL
    xDest*: LONG
    yDest*: LONG
    cxDest*: LONG
    cyDest*: LONG
    dwRop*: DWORD
    xSrc*: LONG
    ySrc*: LONG
    xformSrc*: XFORM
    crBkColorSrc*: COLORREF
    iUsageSrc*: DWORD
    offBmiSrc*: DWORD
    offBitsSrc*: DWORD
    cbBitsSrc*: DWORD

  TEMRBITBLT* = EMRBITBLT
  PEMRBITBLT* = ptr EMRBITBLT
  LOGBRUSH* {.final, pure.} = object
    lbStyle*: UINT
    lbColor*: COLORREF
    lbHatch*: LONG

  TLOGBRUSH* = LOGBRUSH
  PLOGBRUSH* = ptr LOGBRUSH
  EMRCREATEBRUSHINDIRECT* {.final, pure.} = object
    emr*: EMR
    ihBrush*: DWORD
    lb*: LOGBRUSH

  TEMRCREATEBRUSHINDIRECT* = EMRCREATEBRUSHINDIRECT
  PEMRCREATEBRUSHINDIRECT* = ptr EMRCREATEBRUSHINDIRECT
  LCSCSTYPE* = LONG
  LCSGAMUTMATCH* = LONG
  LOGCOLORSPACE* {.final, pure.} = object
    lcsSignature*: DWORD
    lcsVersion*: DWORD
    lcsSize*: DWORD
    lcsCSType*: LCSCSTYPE
    lcsIntent*: LCSGAMUTMATCH
    lcsEndpoints*: CIEXYZTRIPLE
    lcsGammaRed*: DWORD
    lcsGammaGreen*: DWORD
    lcsGammaBlue*: DWORD
    lcsFilename*: array[0..(MAX_PATH) - 1, TCHAR]

  LPLOGCOLORSPACE* = ptr LOGCOLORSPACE
  TLOGCOLORSPACE* = LOGCOLORSPACE
  TLOGCOLORSPACEA* = LOGCOLORSPACE
  PLOGCOLORSPACE* = ptr LOGCOLORSPACE
  EMRCREATECOLORSPACE* {.final, pure.} = object
    emr*: EMR
    ihCS*: DWORD
    lcs*: LOGCOLORSPACE

  TEMRCREATECOLORSPACE* = EMRCREATECOLORSPACE
  PEMRCREATECOLORSPACE* = ptr EMRCREATECOLORSPACE
  EMRCREATEDIBPATTERNBRUSHPT* {.final, pure.} = object
    emr*: EMR
    ihBrush*: DWORD
    iUsage*: DWORD
    offBmi*: DWORD
    cbBmi*: DWORD
    offBits*: DWORD
    cbBits*: DWORD

  TEMRCREATEDIBPATTERNBRUSHPT* = EMRCREATEDIBPATTERNBRUSHPT
  PEMRCREATEDIBPATTERNBRUSHPT* = EMRCREATEDIBPATTERNBRUSHPT
  EMRCREATEMONOBRUSH* {.final, pure.} = object
    emr*: EMR
    ihBrush*: DWORD
    iUsage*: DWORD
    offBmi*: DWORD
    cbBmi*: DWORD
    offBits*: DWORD
    cbBits*: DWORD

  TEMRCREATEMONOBRUSH* = EMRCREATEMONOBRUSH
  PEMRCREATEMONOBRUSH* = ptr EMRCREATEMONOBRUSH
  PALETTEENTRY* {.final, pure.} = object
    peRed*: int8
    peGreen*: int8
    peBlue*: int8
    peFlags*: int8

  LPPALETTEENTRY* = ptr PALETTEENTRY
  TPALETTEENTRY* = PALETTEENTRY
  PPALETTEENTRY* = ptr PALETTEENTRY
  LOGPALETTE* {.final, pure.} = object
    palVersion*: int16
    palNumEntries*: int16
    palPalEntry*: array[0..0, PALETTEENTRY]

  LPLOGPALETTE* = ptr LOGPALETTE
  NPLOGPALETTE* = ptr LOGPALETTE
  TLOGPALETTE* = LOGPALETTE
  PLOGPALETTE* = ptr LOGPALETTE
  EMRCREATEPALETTE* {.final, pure.} = object
    emr*: EMR
    ihPal*: DWORD
    lgpl*: LOGPALETTE

  TEMRCREATEPALETTE* = EMRCREATEPALETTE
  PEMRCREATEPALETTE* = ptr EMRCREATEPALETTE
  LOGPEN* {.final, pure.} = object
    lopnStyle*: UINT
    lopnWidth*: POINT
    lopnColor*: COLORREF

  TLOGPEN* = LOGPEN
  PLOGPEN* = ptr LOGPEN
  EMRCREATEPEN* {.final, pure.} = object
    emr*: EMR
    ihPen*: DWORD
    lopn*: LOGPEN

  TEMRCREATEPEN* = EMRCREATEPEN
  PEMRCREATEPEN* = ptr EMRCREATEPEN
  EMRELLIPSE* {.final, pure.} = object
    emr*: EMR
    rclBox*: RECTL

  TEMRELLIPSE* = EMRELLIPSE
  PEMRELLIPSE* = ptr EMRELLIPSE
  EMRRECTANGLE* = EMRELLIPSE
  TEMRRECTANGLE* = EMRELLIPSE
  PEMRRECTANGLE* = ptr EMRELLIPSE
  EMREOF* {.final, pure.} = object
    emr*: EMR
    nPalEntries*: DWORD
    offPalEntries*: DWORD
    nSizeLast*: DWORD

  TEMREOF* = EMREOF
  PEMREOF* = ptr EMREOF
  EMREXCLUDECLIPRECT* {.final, pure.} = object
    emr*: EMR
    rclClip*: RECTL

  TEMREXCLUDECLIPRECT* = EMREXCLUDECLIPRECT
  PEMREXCLUDECLIPRECT* = ptr EMREXCLUDECLIPRECT
  EMRINTERSECTCLIPRECT* = EMREXCLUDECLIPRECT
  TEMRINTERSECTCLIPRECT* = EMREXCLUDECLIPRECT
  PEMRINTERSECTCLIPRECT* = ptr EMREXCLUDECLIPRECT
  PANOSE* {.final, pure.} = object
    bFamilyType*: int8
    bSerifStyle*: int8
    bWeight*: int8
    bProportion*: int8
    bContrast*: int8
    bStrokeVariation*: int8
    bArmStyle*: int8
    bLetterform*: int8
    bMidline*: int8
    bXHeight*: int8

  TPANOSE* = PANOSE
  PPANOSE* = ptr PANOSE
  EXTLOGFONT* {.final, pure.} = object
    elfLogFont*: LOGFONT
    elfFullName*: array[0..(LF_FULLFACESIZE) - 1, BCHAR]
    elfStyle*: array[0..(LF_FACESIZE) - 1, BCHAR]
    elfVersion*: DWORD
    elfStyleSize*: DWORD
    elfMatch*: DWORD
    elfReserved*: DWORD
    elfVendorId*: array[0..(ELF_VENDOR_SIZE) - 1, int8]
    elfCulture*: DWORD
    elfPanose*: PANOSE

  TEXTLOGFONT* = EXTLOGFONT
  PEXTLOGFONT* = ptr EXTLOGFONT
  EMREXTCREATEFONTINDIRECTW* {.final, pure.} = object
    emr*: EMR
    ihFont*: DWORD
    elfw*: EXTLOGFONT

  TEMREXTCREATEFONTINDIRECTW* = EMREXTCREATEFONTINDIRECTW
  PEMREXTCREATEFONTINDIRECTW* = ptr EMREXTCREATEFONTINDIRECTW
  EXTLOGPEN* {.final, pure.} = object
    elpPenStyle*: UINT
    elpWidth*: UINT
    elpBrushStyle*: UINT
    elpColor*: COLORREF
    elpHatch*: LONG
    elpNumEntries*: DWORD
    elpStyleEntry*: array[0..0, DWORD]

  TEXTLOGPEN* = EXTLOGPEN
  PEXTLOGPEN* = ptr EXTLOGPEN
  EMREXTCREATEPEN* {.final, pure.} = object
    emr*: EMR
    ihPen*: DWORD
    offBmi*: DWORD
    cbBmi*: DWORD
    offBits*: DWORD
    cbBits*: DWORD
    elp*: EXTLOGPEN

  TEMREXTCREATEPEN* = EMREXTCREATEPEN
  PEMREXTCREATEPEN* = ptr EMREXTCREATEPEN
  EMREXTFLOODFILL* {.final, pure.} = object
    emr*: EMR
    ptlStart*: POINTL
    crColor*: COLORREF
    iMode*: DWORD

  TEMREXTFLOODFILL* = EMREXTFLOODFILL
  PEMREXTFLOODFILL* = ptr EMREXTFLOODFILL
  EMREXTSELECTCLIPRGN* {.final, pure.} = object
    emr*: EMR
    cbRgnData*: DWORD
    iMode*: DWORD
    RgnData*: array[0..0, int8]

  TEMREXTSELECTCLIPRGN* = EMREXTSELECTCLIPRGN
  PEMREXTSELECTCLIPRGN* = ptr EMREXTSELECTCLIPRGN
  EMRTEXT* {.final, pure.} = object
    ptlReference*: POINTL
    nChars*: DWORD
    offString*: DWORD
    fOptions*: DWORD
    rcl*: RECTL
    offDx*: DWORD

  TEMRTEXT* = EMRTEXT
  PEMRTEXT* = ptr EMRTEXT
  EMREXTTEXTOUTA* {.final, pure.} = object
    emr*: EMR
    rclBounds*: RECTL
    iGraphicsMode*: DWORD
    exScale*: float32
    eyScale*: float32
    emrtext*: EMRTEXT

  TEMREXTTEXTOUTA* = EMREXTTEXTOUTA
  PEMREXTTEXTOUTA* = ptr EMREXTTEXTOUTA
  EMREXTTEXTOUTW* = EMREXTTEXTOUTA
  TEMREXTTEXTOUTW* = EMREXTTEXTOUTA
  PEMREXTTEXTOUTW* = ptr EMREXTTEXTOUTA
  EMRFILLPATH* {.final, pure.} = object
    emr*: EMR
    rclBounds*: RECTL

  TEMRFILLPATH* = EMRFILLPATH
  PEMRFILLPATH* = ptr EMRFILLPATH
  EMRSTROKEANDFILLPATH* = EMRFILLPATH
  TEMRSTROKEANDFILLPATH* = EMRFILLPATH
  PEMRSTROKEANDFILLPATH* = ptr EMRFILLPATH
  EMRSTROKEPATH* = EMRFILLPATH
  TEMRSTROKEPATH* = EMRFILLPATH
  PEMRSTROKEPATH* = ptr EMRFILLPATH
  EMRFILLRGN* {.final, pure.} = object
    emr*: EMR
    rclBounds*: RECTL
    cbRgnData*: DWORD
    ihBrush*: DWORD
    RgnData*: array[0..0, int8]

  TEMRFILLRGN* = EMRFILLRGN
  PEMRFILLRGN* = ptr EMRFILLRGN
  EMRFORMAT* {.final, pure.} = object
    dSignature*: DWORD
    nVersion*: DWORD
    cbData*: DWORD
    offData*: DWORD

  TEMRFORMAT* = EMRFORMAT
  PEMRFORMAT* = ptr EMRFORMAT

  EMRFRAMERGN* {.final, pure.} = object
    emr*: EMR
    rclBounds*: RECTL
    cbRgnData*: DWORD
    ihBrush*: DWORD
    szlStroke*: SIZEL
    RgnData*: array[0..0, int8]

  TEMRFRAMERGN* = EMRFRAMERGN
  PEMRFRAMERGN* = ptr EMRFRAMERGN
  EMRGDICOMMENT* {.final, pure.} = object
    emr*: EMR
    cbData*: DWORD
    Data*: array[0..0, int8]

  TEMRGDICOMMENT* = EMRGDICOMMENT
  PEMRGDICOMMENT* = ptr EMRGDICOMMENT
  EMRINVERTRGN* {.final, pure.} = object
    emr*: EMR
    rclBounds*: RECTL
    cbRgnData*: DWORD
    RgnData*: array[0..0, int8]

  TEMRINVERTRGN* = EMRINVERTRGN
  PEMRINVERTRGN* = ptr EMRINVERTRGN
  EMRPAINTRGN* = EMRINVERTRGN
  TEMRPAINTRGN* = EMRINVERTRGN
  PEMRPAINTRGN* = ptr EMRINVERTRGN
  EMRLINETO* {.final, pure.} = object
    emr*: EMR
    ptl*: POINTL

  TEMRLINETO* = EMRLINETO
  PEMRLINETO* = ptr EMRLINETO
  EMRMOVETOEX* = EMRLINETO
  TEMRMOVETOEX* = EMRLINETO
  PEMRMOVETOEX* = ptr EMRLINETO
  EMRMASKBLT* {.final, pure.} = object
    emr*: EMR
    rclBounds*: RECTL
    xDest*: LONG
    yDest*: LONG
    cxDest*: LONG
    cyDest*: LONG
    dwRop*: DWORD
    xSrc*: LONG
    ySrc*: LONG
    xformSrc*: XFORM
    crBkColorSrc*: COLORREF
    iUsageSrc*: DWORD
    offBmiSrc*: DWORD
    cbBmiSrc*: DWORD
    offBitsSrc*: DWORD
    cbBitsSrc*: DWORD
    xMask*: LONG
    yMask*: LONG
    iUsageMask*: DWORD
    offBmiMask*: DWORD
    cbBmiMask*: DWORD
    offBitsMask*: DWORD
    cbBitsMask*: DWORD

  TEMRMASKBLT* = EMRMASKBLT
  PEMRMASKBLT* = ptr EMRMASKBLT
  EMRMODIFYWORLDTRANSFORM* {.final, pure.} = object
    emr*: EMR
    xform*: XFORM
    iMode*: DWORD

  TEMRMODIFYWORLDTRANSFORM* = EMRMODIFYWORLDTRANSFORM
  PEMRMODIFYWORLDTRANSFORM* = EMRMODIFYWORLDTRANSFORM
  EMROFFSETCLIPRGN* {.final, pure.} = object
    emr*: EMR
    ptlOffset*: POINTL

  TEMROFFSETCLIPRGN* = EMROFFSETCLIPRGN
  PEMROFFSETCLIPRGN* = ptr EMROFFSETCLIPRGN
  EMRPLGBLT* {.final, pure.} = object
    emr*: EMR
    rclBounds*: RECTL
    aptlDest*: array[0..2, POINTL]
    xSrc*: LONG
    ySrc*: LONG
    cxSrc*: LONG
    cySrc*: LONG
    xformSrc*: XFORM
    crBkColorSrc*: COLORREF
    iUsageSrc*: DWORD
    offBmiSrc*: DWORD
    cbBmiSrc*: DWORD
    offBitsSrc*: DWORD
    cbBitsSrc*: DWORD
    xMask*: LONG
    yMask*: LONG
    iUsageMask*: DWORD
    offBmiMask*: DWORD
    cbBmiMask*: DWORD
    offBitsMask*: DWORD
    cbBitsMask*: DWORD

  TEMRPLGBLT* = EMRPLGBLT
  PEMRPLGBLT* = ptr EMRPLGBLT
  EMRPOLYDRAW* {.final, pure.} = object
    emr*: EMR
    rclBounds*: RECTL
    cptl*: DWORD
    aptl*: array[0..0, POINTL]
    abTypes*: array[0..0, int8]

  TEMRPOLYDRAW* = EMRPOLYDRAW
  PEMRPOLYDRAW* = ptr EMRPOLYDRAW
  EMRPOLYDRAW16* {.final, pure.} = object
    emr*: EMR
    rclBounds*: RECTL
    cpts*: DWORD
    apts*: array[0..0, POINTS]
    abTypes*: array[0..0, int8]

  TEMRPOLYDRAW16* = EMRPOLYDRAW16
  PEMRPOLYDRAW16* = ptr EMRPOLYDRAW16
  EMRPOLYLINE* {.final, pure.} = object
    emr*: EMR
    rclBounds*: RECTL
    cptl*: DWORD
    aptl*: array[0..0, POINTL]

  TEMRPOLYLINE* = EMRPOLYLINE
  PEMRPOLYLINE* = ptr EMRPOLYLINE
  EMRPOLYBEZIER* = EMRPOLYLINE
  TEMRPOLYBEZIER* = EMRPOLYLINE
  PEMRPOLYBEZIER* = ptr EMRPOLYLINE
  EMRPOLYGON* = EMRPOLYLINE
  TEMRPOLYGON* = EMRPOLYLINE
  PEMRPOLYGON* = ptr EMRPOLYLINE
  EMRPOLYBEZIERTO* = EMRPOLYLINE
  TEMRPOLYBEZIERTO* = EMRPOLYLINE
  PEMRPOLYBEZIERTO* = ptr EMRPOLYLINE
  EMRPOLYLINETO* = EMRPOLYLINE
  TEMRPOLYLINETO* = EMRPOLYLINE
  PEMRPOLYLINETO* = ptr EMRPOLYLINE
  EMRPOLYLINE16* {.final, pure.} = object
    emr*: EMR
    rclBounds*: RECTL
    cpts*: DWORD
    apts*: array[0..0, POINTL]

  TEMRPOLYLINE16* = EMRPOLYLINE16
  PEMRPOLYLINE16* = ptr EMRPOLYLINE16
  EMRPOLYBEZIER16* = EMRPOLYLINE16
  TEMRPOLYBEZIER16* = EMRPOLYLINE16
  PEMRPOLYBEZIER16* = ptr EMRPOLYLINE16
  EMRPOLYGON16* = EMRPOLYLINE16
  TEMRPOLYGON16* = EMRPOLYLINE16
  PEMRPOLYGON16* = ptr EMRPOLYLINE16
  EMRPOLYBEZIERTO16* = EMRPOLYLINE16
  TEMRPOLYBEZIERTO16* = EMRPOLYLINE16
  PEMRPOLYBEZIERTO16* = ptr EMRPOLYLINE16
  EMRPOLYLINETO16* = EMRPOLYLINE16
  TEMRPOLYLINETO16* = EMRPOLYLINE16
  PEMRPOLYLINETO16* = ptr EMRPOLYLINE16
  EMRPOLYPOLYLINE* {.final, pure.} = object
    emr*: EMR
    rclBounds*: RECTL
    nPolys*: DWORD
    cptl*: DWORD
    aPolyCounts*: array[0..0, DWORD]
    aptl*: array[0..0, POINTL]

  TEMRPOLYPOLYLINE* = EMRPOLYPOLYLINE
  PEMRPOLYPOLYLINE* = ptr EMRPOLYPOLYLINE
  EMRPOLYPOLYGON* = EMRPOLYPOLYLINE
  TEMRPOLYPOLYGON* = EMRPOLYPOLYLINE
  PEMRPOLYPOLYGON* = ptr EMRPOLYPOLYLINE
  EMRPOLYPOLYLINE16* {.final, pure.} = object
    emr*: EMR
    rclBounds*: RECTL
    nPolys*: DWORD
    cpts*: DWORD
    aPolyCounts*: array[0..0, DWORD]
    apts*: array[0..0, POINTS]

  TEMRPOLYPOLYLINE16* = EMRPOLYPOLYLINE16
  PEMRPOLYPOLYLINE16* = ptr EMRPOLYPOLYLINE16
  EMRPOLYPOLYGON16* = EMRPOLYPOLYLINE16
  TEMRPOLYPOLYGON16* = EMRPOLYPOLYLINE16
  PEMRPOLYPOLYGON16* = ptr EMRPOLYPOLYLINE16
  EMRPOLYTEXTOUTA* {.final, pure.} = object
    emr*: EMR
    rclBounds*: RECTL
    iGraphicsMode*: DWORD
    exScale*: float32
    eyScale*: float32
    cStrings*: LONG
    aemrtext*: array[0..0, EMRTEXT]

  TEMRPOLYTEXTOUTA* = EMRPOLYTEXTOUTA
  PEMRPOLYTEXTOUTA* = ptr EMRPOLYTEXTOUTA
  EMRPOLYTEXTOUTW* = EMRPOLYTEXTOUTA
  TEMRPOLYTEXTOUTW* = EMRPOLYTEXTOUTA
  PEMRPOLYTEXTOUTW* = ptr EMRPOLYTEXTOUTA
  EMRRESIZEPALETTE* {.final, pure.} = object
    emr*: EMR
    ihPal*: DWORD
    cEntries*: DWORD

  TEMRRESIZEPALETTE* = EMRRESIZEPALETTE
  PEMRRESIZEPALETTE* = ptr EMRRESIZEPALETTE
  EMRRESTOREDC* {.final, pure.} = object
    emr*: EMR
    iRelative*: LONG

  TEMRRESTOREDC* = EMRRESTOREDC
  PEMRRESTOREDC* = ptr EMRRESTOREDC
  EMRROUNDRECT* {.final, pure.} = object
    emr*: EMR
    rclBox*: RECTL
    szlCorner*: SIZEL

  TEMRROUNDRECT* = EMRROUNDRECT
  PEMRROUNDRECT* = ptr EMRROUNDRECT
  EMRSCALEVIEWPORTEXTEX* {.final, pure.} = object
    emr*: EMR
    xNum*: LONG
    xDenom*: LONG
    yNum*: LONG
    yDenom*: LONG

  TEMRSCALEVIEWPORTEXTEX* = EMRSCALEVIEWPORTEXTEX
  PEMRSCALEVIEWPORTEXTEX* = ptr EMRSCALEVIEWPORTEXTEX
  EMRSCALEWINDOWEXTEX* = EMRSCALEVIEWPORTEXTEX
  TEMRSCALEWINDOWEXTEX* = EMRSCALEVIEWPORTEXTEX
  PEMRSCALEWINDOWEXTEX* = ptr EMRSCALEVIEWPORTEXTEX
  EMRSELECTCOLORSPACE* {.final, pure.} = object
    emr*: EMR

    ihCS*: DWORD

  TEMRSELECTCOLORSPACE* = EMRSELECTCOLORSPACE
  PEMRSELECTCOLORSPACE* = ptr EMRSELECTCOLORSPACE
  EMRDELETECOLORSPACE* = EMRSELECTCOLORSPACE
  TEMRDELETECOLORSPACE* = EMRSELECTCOLORSPACE
  PEMRDELETECOLORSPACE* = ptr EMRSELECTCOLORSPACE
  EMRSELECTOBJECT* {.final, pure.} = object
    emr*: EMR
    ihObject*: DWORD

  TEMRSELECTOBJECT* = EMRSELECTOBJECT
  PEMRSELECTOBJECT* = ptr EMRSELECTOBJECT
  EMRDELETEOBJECT* = EMRSELECTOBJECT
  TEMRDELETEOBJECT* = EMRSELECTOBJECT
  PEMRDELETEOBJECT* = ptr EMRSELECTOBJECT
  EMRSELECTPALETTE* {.final, pure.} = object
    emr*: EMR
    ihPal*: DWORD

  TEMRSELECTPALETTE* = EMRSELECTPALETTE
  PEMRSELECTPALETTE* = ptr EMRSELECTPALETTE
  EMRSETARCDIRECTION* {.final, pure.} = object
    emr*: EMR
    iArcDirection*: DWORD

  TEMRSETARCDIRECTION* = EMRSETARCDIRECTION
  PEMRSETARCDIRECTION* = ptr EMRSETARCDIRECTION
  EMRSETBKCOLOR* {.final, pure.} = object
    emr*: EMR
    crColor*: COLORREF

  TEMRSETBKCOLOR* = EMRSETBKCOLOR
  PEMRSETBKCOLOR* = ptr EMRSETBKCOLOR
  EMRSETTEXTCOLOR* = EMRSETBKCOLOR
  TEMRSETTEXTCOLOR* = EMRSETBKCOLOR
  PEMRSETTEXTCOLOR* = ptr EMRSETBKCOLOR
  EMRSETCOLORADJUSTMENT* {.final, pure.} = object
    emr*: EMR
    ColorAdjustment*: COLORADJUSTMENT

  TEMRSETCOLORADJUSTMENT* = EMRSETCOLORADJUSTMENT
  PEMRSETCOLORADJUSTMENT* = ptr EMRSETCOLORADJUSTMENT
  EMRSETDIBITSTODEVICE* {.final, pure.} = object
    emr*: EMR
    rclBounds*: RECTL
    xDest*: LONG
    yDest*: LONG
    xSrc*: LONG
    ySrc*: LONG
    cxSrc*: LONG
    cySrc*: LONG
    offBmiSrc*: DWORD
    cbBmiSrc*: DWORD
    offBitsSrc*: DWORD
    cbBitsSrc*: DWORD
    iUsageSrc*: DWORD
    iStartScan*: DWORD
    cScans*: DWORD

  TEMRSETDIBITSTODEVICE* = EMRSETDIBITSTODEVICE
  PEMRSETDIBITSTODEVICE* = ptr EMRSETDIBITSTODEVICE
  EMRSETMAPPERFLAGS* {.final, pure.} = object
    emr*: EMR
    dwFlags*: DWORD

  TEMRSETMAPPERFLAGS* = EMRSETMAPPERFLAGS
  PEMRSETMAPPERFLAGS* = ptr EMRSETMAPPERFLAGS
  EMRSETMITERLIMIT* {.final, pure.} = object
    emr*: EMR
    eMiterLimit*: float32

  TEMRSETMITERLIMIT* = EMRSETMITERLIMIT
  PEMRSETMITERLIMIT* = ptr EMRSETMITERLIMIT
  EMRSETPALETTEENTRIES* {.final, pure.} = object
    emr*: EMR
    ihPal*: DWORD
    iStart*: DWORD
    cEntries*: DWORD
    aPalEntries*: array[0..0, PALETTEENTRY]

  TEMRSETPALETTEENTRIES* = EMRSETPALETTEENTRIES
  PEMRSETPALETTEENTRIES* = ptr EMRSETPALETTEENTRIES
  EMRSETPIXELV* {.final, pure.} = object
    emr*: EMR
    ptlPixel*: POINTL
    crColor*: COLORREF

  TEMRSETPIXELV* = EMRSETPIXELV
  PEMRSETPIXELV* = ptr EMRSETPIXELV
  EMRSETVIEWPORTEXTEX* {.final, pure.} = object
    emr*: EMR
    szlExtent*: SIZEL

  TEMRSETVIEWPORTEXTEX* = EMRSETVIEWPORTEXTEX
  PEMRSETVIEWPORTEXTEX* = ptr EMRSETVIEWPORTEXTEX
  EMRSETWINDOWEXTEX* = EMRSETVIEWPORTEXTEX
  TEMRSETWINDOWEXTEX* = EMRSETVIEWPORTEXTEX
  PEMRSETWINDOWEXTEX* = ptr EMRSETVIEWPORTEXTEX
  EMRSETVIEWPORTORGEX* {.final, pure.} = object
    emr*: EMR
    ptlOrigin*: POINTL

  TEMRSETVIEWPORTORGEX* = EMRSETVIEWPORTORGEX
  PEMRSETVIEWPORTORGEX* = ptr EMRSETVIEWPORTORGEX
  EMRSETWINDOWORGEX* = EMRSETVIEWPORTORGEX
  TEMRSETWINDOWORGEX* = EMRSETVIEWPORTORGEX
  PEMRSETWINDOWORGEX* = ptr EMRSETVIEWPORTORGEX
  EMRSETBRUSHORGEX* = EMRSETVIEWPORTORGEX
  TEMRSETBRUSHORGEX* = EMRSETVIEWPORTORGEX
  PEMRSETBRUSHORGEX* = ptr EMRSETVIEWPORTORGEX
  EMRSETWORLDTRANSFORM* {.final, pure.} = object
    emr*: EMR
    xform*: XFORM

  TEMRSETWORLDTRANSFORM* = EMRSETWORLDTRANSFORM
  PEMRSETWORLDTRANSFORM* = ptr EMRSETWORLDTRANSFORM
  EMRSTRETCHBLT* {.final, pure.} = object
    emr*: EMR
    rclBounds*: RECTL
    xDest*: LONG
    yDest*: LONG
    cxDest*: LONG
    cyDest*: LONG
    dwRop*: DWORD
    xSrc*: LONG
    ySrc*: LONG
    xformSrc*: XFORM
    crBkColorSrc*: COLORREF
    iUsageSrc*: DWORD
    offBmiSrc*: DWORD
    cbBmiSrc*: DWORD
    offBitsSrc*: DWORD
    cbBitsSrc*: DWORD
    cxSrc*: LONG
    cySrc*: LONG

  TEMRSTRETCHBLT* = EMRSTRETCHBLT
  PEMRSTRETCHBLT* = ptr EMRSTRETCHBLT
  EMRSTRETCHDIBITS* {.final, pure.} = object
    emr*: EMR
    rclBounds*: RECTL
    xDest*: LONG
    yDest*: LONG
    xSrc*: LONG
    ySrc*: LONG
    cxSrc*: LONG
    cySrc*: LONG
    offBmiSrc*: DWORD
    cbBmiSrc*: DWORD
    offBitsSrc*: DWORD
    cbBitsSrc*: DWORD
    iUsageSrc*: DWORD
    dwRop*: DWORD
    cxDest*: LONG
    cyDest*: LONG

  TEMRSTRETCHDIBITS* = EMRSTRETCHDIBITS
  PEMRSTRETCHDIBITS* = ptr EMRSTRETCHDIBITS
  EMRABORTPATH* {.final, pure.} = object
    emr*: EMR

  TEMRABORTPATH* = EMRABORTPATH
  PEMRABORTPATH* = ptr EMRABORTPATH
  TABORTPATH* = EMRABORTPATH
  EMRBEGINPATH* = EMRABORTPATH
  TEMRBEGINPATH* = EMRABORTPATH
  PEMRBEGINPATH* = ptr EMRABORTPATH
  EMRENDPATH* = EMRABORTPATH
  TEMRENDPATH* = EMRABORTPATH
  PEMRENDPATH* = ptr EMRABORTPATH
  EMRCLOSEFIGURE* = EMRABORTPATH
  TEMRCLOSEFIGURE* = EMRABORTPATH
  PEMRCLOSEFIGURE* = ptr EMRABORTPATH
  EMRFLATTENPATH* = EMRABORTPATH
  TEMRFLATTENPATH* = EMRABORTPATH
  PEMRFLATTENPATH* = ptr EMRABORTPATH
  EMRWIDENPATH* = EMRABORTPATH
  TEMRWIDENPATH* = EMRABORTPATH
  PEMRWIDENPATH* = ptr EMRABORTPATH
  EMRSETMETARGN* = EMRABORTPATH
  TEMRSETMETARGN* = EMRABORTPATH
  PEMRSETMETARGN* = ptr EMRABORTPATH
  EMRSAVEDC* = EMRABORTPATH
  TEMRSAVEDC* = EMRABORTPATH
  PEMRSAVEDC* = ptr EMRABORTPATH
  EMRREALIZEPALETTE* = EMRABORTPATH
  TEMRREALIZEPALETTE* = EMRABORTPATH
  PEMRREALIZEPALETTE* = ptr EMRABORTPATH
  EMRSELECTCLIPPATH* {.final, pure.} = object
    emr*: EMR
    iMode*: DWORD

  TEMRSELECTCLIPPATH* = EMRSELECTCLIPPATH
  PEMRSELECTCLIPPATH* = ptr EMRSELECTCLIPPATH
  EMRSETBKMODE* = EMRSELECTCLIPPATH
  TEMRSETBKMODE* = EMRSELECTCLIPPATH
  PEMRSETBKMODE* = ptr EMRSELECTCLIPPATH
  EMRSETMAPMODE* = EMRSELECTCLIPPATH
  TEMRSETMAPMODE* = EMRSELECTCLIPPATH
  PEMRSETMAPMODE* = ptr EMRSELECTCLIPPATH
  EMRSETPOLYFILLMODE* = EMRSELECTCLIPPATH
  TEMRSETPOLYFILLMODE* = EMRSELECTCLIPPATH
  PEMRSETPOLYFILLMODE* = ptr EMRSELECTCLIPPATH
  EMRSETROP2* = EMRSELECTCLIPPATH
  TEMRSETROP2* = EMRSELECTCLIPPATH
  PEMRSETROP2* = ptr EMRSELECTCLIPPATH
  EMRSETSTRETCHBLTMODE* = EMRSELECTCLIPPATH
  TEMRSETSTRETCHBLTMODE* = EMRSELECTCLIPPATH
  PEMRSETSTRETCHBLTMODE* = ptr EMRSELECTCLIPPATH
  EMRSETTEXTALIGN* = EMRSELECTCLIPPATH
  TEMRSETTEXTALIGN* = EMRSELECTCLIPPATH
  PEMRSETTEXTALIGN* = ptr EMRSELECTCLIPPATH
  EMRENABLEICM* = EMRSELECTCLIPPATH
  TEMRENABLEICM* = EMRSELECTCLIPPATH
  PEMRENABLEICM* = ptr EMRSELECTCLIPPATH
  NMHDR* {.final, pure.} = object
    hwndFrom*: HWND
    idFrom*: UINT
    code*: UINT

  TNMHDR* = NMHDR
  PNMHDR* = ptr NMHDR
  TENCORRECTTEXT* {.final, pure.} = object
    nmhdr*: NMHDR
    chrg*: CHARRANGE
    seltyp*: int16

  Pencorrecttext* = ptr TENCORRECTTEXT
  TENDROPFILES* {.final, pure.} = object
    nmhdr*: NMHDR
    hDrop*: HANDLE
    cp*: LONG
    fProtected*: WINBOOL

  Pendropfiles* = ptr TENDROPFILES
  TENSAVECLIPBOARD* {.final, pure.} = object
    nmhdr*: NMHDR
    cObjectCount*: LONG
    cch*: LONG

  PENSAVECLIPBOARD* = ptr TENSAVECLIPBOARD
  TENOLEOPFAILED* {.final, pure.} = object
    nmhdr*: NMHDR
    iob*: LONG
    lOper*: LONG
    hr*: HRESULT

  PENOLEOPFAILED* = ptr TENOLEOPFAILED
  TENHMETAHEADER* {.final, pure.} = object
    iType*: DWORD
    nSize*: DWORD
    rclBounds*: RECTL
    rclFrame*: RECTL
    dSignature*: DWORD
    nVersion*: DWORD
    nBytes*: DWORD
    nRecords*: DWORD
    nHandles*: int16
    sReserved*: int16
    nDescription*: DWORD
    offDescription*: DWORD
    nPalEntries*: DWORD
    szlDevice*: SIZEL
    szlMillimeters*: SIZEL

  LPENHMETAHEADER* = ptr TENHMETAHEADER
  PENHMETAHEADER* = ptr TENHMETAHEADER
  TENHMETARECORD* {.final, pure.} = object
    iType*: DWORD
    nSize*: DWORD
    dParm*: array[0..0, DWORD]

  LPENHMETARECORD* = ptr TENHMETARECORD
  PENHMETARECORD* = ptr TENHMETARECORD
  TENPROTECTED* {.final, pure.} = object
    nmhdr*: NMHDR
    msg*: UINT
    wParam*: WPARAM
    lParam*: LPARAM
    chrg*: CHARRANGE

  Penprotected* = ptr TENPROTECTED
  SERVICE_STATUS* {.final, pure.} = object
    dwServiceType*: DWORD
    dwCurrentState*: DWORD
    dwControlsAccepted*: DWORD
    dwWin32ExitCode*: DWORD
    dwServiceSpecificExitCode*: DWORD
    dwCheckPoint*: DWORD
    dwWaitHint*: DWORD

  LPSERVICE_STATUS* = ptr SERVICE_STATUS
  TSERVICESTATUS* = SERVICE_STATUS
  PSERVICESTATUS* = ptr SERVICE_STATUS
  ENUM_SERVICE_STATUS* {.final, pure.} = object
    lpServiceName*: LPTSTR
    lpDisplayName*: LPTSTR
    ServiceStatus*: SERVICE_STATUS

  LPENUM_SERVICE_STATUS* = ptr ENUM_SERVICE_STATUS
  TENUMSERVICESTATUS* = ENUM_SERVICE_STATUS
  PENUMSERVICESTATUS* = ptr ENUM_SERVICE_STATUS
  ENUMLOGFONT* {.final, pure.} = object
    elfLogFont*: LOGFONT
    elfFullName*: array[0..(LF_FULLFACESIZE) - 1, BCHAR]
    elfStyle*: array[0..(LF_FACESIZE) - 1, BCHAR]

  TENUMLOGFONT* = ENUMLOGFONT
  PENUMLOGFONT* = ptr ENUMLOGFONT
  ENUMLOGFONTEX* {.final, pure.} = object
    elfLogFont*: LOGFONT
    elfFullName*: array[0..(LF_FULLFACESIZE) - 1, BCHAR]
    elfStyle*: array[0..(LF_FACESIZE) - 1, BCHAR]
    elfScript*: array[0..(LF_FACESIZE) - 1, BCHAR]

  TENUMLOGFONTEX* = ENUMLOGFONTEX
  PENUMLOGFONTEX* = ptr ENUMLOGFONTEX

  EVENTLOGRECORD* {.final, pure.} = object
    Length*: DWORD
    Reserved*: DWORD
    RecordNumber*: DWORD
    TimeGenerated*: DWORD
    TimeWritten*: DWORD
    EventID*: DWORD
    EventType*: int16
    NumStrings*: int16
    EventCategory*: int16
    ReservedFlags*: int16
    ClosingRecordNumber*: DWORD
    StringOffset*: DWORD
    UserSidLength*: DWORD
    UserSidOffset*: DWORD
    DataLength*: DWORD
    DataOffset*: DWORD

  TEVENTLOGRECORD* = EVENTLOGRECORD
  PEVENTLOGRECORD* = ptr EVENTLOGRECORD
  EVENTMSG* {.final, pure.} = object
    message*: UINT
    paramL*: UINT
    paramH*: UINT
    time*: DWORD
    hwnd*: HWND

  TEVENTMSG* = EVENTMSG
  PEVENTMSG* = ptr EVENTMSG
  EXCEPTION_POINTERS* {.final, pure.} = object
    ExceptionRecord*: PEXCEPTION_RECORD
    ContextRecord*: PCONTEXT

  LPEXCEPTION_POINTERS* = ptr EXCEPTION_POINTERS
  PEXCEPTION_POINTERS* = ptr EXCEPTION_POINTERS
  TEXCEPTIONPOINTERS* = EXCEPTION_POINTERS
  EXT_BUTTON* {.final, pure.} = object
    idCommand*: int16
    idsHelp*: int16
    fsStyle*: int16

  LPEXT_BUTTON* = ptr EXT_BUTTON
  TEXTBUTTON* = EXT_BUTTON
  PEXTBUTTON* = ptr EXT_BUTTON
  FILTERKEYS* {.final, pure.} = object
    cbSize*: UINT
    dwFlags*: DWORD
    iWaitMSec*: DWORD
    iDelayMSec*: DWORD
    iRepeatMSec*: DWORD
    iBounceMSec*: DWORD

  TFILTERKEYS* = FILTERKEYS
  PFILTERKEYS* = ptr FILTERKEYS
  FIND_NAME_BUFFER* {.final, pure.} = object
    len*: UCHAR
    access_control*: UCHAR
    frame_control*: UCHAR
    destination_addr*: array[0..5, UCHAR]
    source_addr*: array[0..5, UCHAR]
    routing_info*: array[0..17, UCHAR]

  TFINDNAMEBUFFER* = FIND_NAME_BUFFER
  PFINDNAMEBUFFER* = ptr FIND_NAME_BUFFER
  FIND_NAME_HEADER* {.final, pure.} = object
    node_count*: int16
    reserved*: UCHAR
    unique_group*: UCHAR

  TFINDNAMEHEADER* = FIND_NAME_HEADER
  PFINDNAMEHEADER* = ptr FIND_NAME_HEADER
  FINDREPLACE* {.final, pure.} = object
    lStructSize*: DWORD
    hwndOwner*: HWND
    hInstance*: HINST
    Flags*: DWORD
    lpstrFindWhat*: LPTSTR
    lpstrReplaceWith*: LPTSTR
    wFindWhatLen*: int16
    wReplaceWithLen*: int16
    lCustData*: LPARAM
    lpfnHook*: LPFRHOOKPROC
    lpTemplateName*: LPCTSTR

  LPFINDREPLACE* = ptr FINDREPLACE
  TFINDREPLACE* = FINDREPLACE
  PFINDREPLACE* = ptr FINDREPLACE
  #FINDTEXT = record conflicts with FindText function
  TFINDTEXT* {.final, pure.} = object
    chrg*: CHARRANGE
    lpstrText*: LPSTR

  Pfindtext* = ptr TFINDTEXT
  FINDTEXTEX* {.final, pure.} = object
    chrg*: CHARRANGE
    lpstrText*: LPSTR
    chrgText*: CHARRANGE

  Tfindtextex* = FINDTEXTEX
  Pfindtextex* = ptr FINDTEXTEX
  FMS_GETDRIVEINFO* {.final, pure.} = object
    dwTotalSpace*: DWORD
    dwFreeSpace*: DWORD
    szPath*: array[0..259, TCHAR]
    szVolume*: array[0..13, TCHAR]
    szShare*: array[0..127, TCHAR]

  TFMSGETDRIVEINFO* = FMS_GETDRIVEINFO
  PFMSGETDRIVEINFO* = ptr FMS_GETDRIVEINFO
  FMS_GETFILESEL* {.final, pure.} = object
    ftTime*: FILETIME
    dwSize*: DWORD
    bAttr*: int8
    szName*: array[0..259, TCHAR]

  TFMSGETFILESEL* = FMS_GETFILESEL
  PFMSGETFILESEL* = ptr FMS_GETFILESEL
  FMS_LOAD* {.final, pure.} = object
    dwSize*: DWORD
    szMenuName*: array[0..(MENU_TEXT_LEN) - 1, TCHAR]
    hMenu*: HMENU
    wMenuDelta*: UINT

  TFMSLOAD* = FMS_LOAD
  PFMSLOAD* = ptr FMS_LOAD
  FMS_TOOLBARLOAD* {.final, pure.} = object
    dwSize*: DWORD
    lpButtons*: LPEXT_BUTTON
    cButtons*: int16
    cBitmaps*: int16
    idBitmap*: int16
    hBitmap*: HBITMAP

  TFMSTOOLBARLOAD* = FMS_TOOLBARLOAD
  PFMSTOOLBARLOAD* = ptr FMS_TOOLBARLOAD
  FOCUS_EVENT_RECORD* {.final, pure.} = object
    bSetFocus*: WINBOOL

  TFOCUSEVENTRECORD* = FOCUS_EVENT_RECORD
  PFOCUSEVENTRECORD* = ptr FOCUS_EVENT_RECORD
  FORM_INFO_1* {.final, pure.} = object
    Flags*: DWORD
    pName*: LPTSTR
    Size*: SIZEL
    ImageableArea*: RECTL

  TFORMINFO1* = FORM_INFO_1
  PFORMINFO1* = ptr FORM_INFO_1
  FORMAT_PARAMETERS* {.final, pure.} = object
    MediaType*: MEDIA_TYPE
    StartCylinderNumber*: DWORD
    EndCylinderNumber*: DWORD
    StartHeadNumber*: DWORD
    EndHeadNumber*: DWORD

  TFORMATPARAMETERS* = FORMAT_PARAMETERS
  PFORMATPARAMETERS* = ptr FORMAT_PARAMETERS
  FORMATRANGE* {.final, pure.} = object
    hdc*: HDC
    hdcTarget*: HDC
    rc*: RECT
    rcPage*: RECT
    chrg*: CHARRANGE

  Tformatrange* = FORMATRANGE
  Pformatrange* = ptr FORMATRANGE
  GCP_RESULTS* {.final, pure.} = object
    lStructSize*: DWORD
    lpOutString*: LPTSTR
    lpOrder*: ptr UINT
    lpDx*: ptr WINT
    lpCaretPos*: ptr WINT
    lpClass*: LPTSTR
    lpGlyphs*: ptr UINT
    nGlyphs*: UINT
    nMaxFit*: UINT

  LPGCP_RESULTS* = ptr GCP_RESULTS
  TGCPRESULTS* = GCP_RESULTS
  PGCPRESULTS* = ptr GCP_RESULTS
  GENERIC_MAPPING* {.final, pure.} = object
    GenericRead*: ACCESS_MASK
    GenericWrite*: ACCESS_MASK
    GenericExecute*: ACCESS_MASK
    GenericAll*: ACCESS_MASK

  PGENERIC_MAPPING* = ptr GENERIC_MAPPING
  TGENERICMAPPING* = GENERIC_MAPPING
  GLYPHMETRICS* {.final, pure.} = object
    gmBlackBoxX*: UINT
    gmBlackBoxY*: UINT
    gmptGlyphOrigin*: POINT
    gmCellIncX*: SHORT
    gmCellIncY*: SHORT

  LPGLYPHMETRICS* = ptr GLYPHMETRICS
  TGLYPHMETRICS* = GLYPHMETRICS
  PGLYPHMETRICS* = ptr GLYPHMETRICS
  HANDLETABLE* {.final, pure.} = object
    objectHandle*: array[0..0, HGDIOBJ]

  THANDLETABLE* = HANDLETABLE
  LPHANDLETABLE* = ptr HANDLETABLE
  HD_HITTESTINFO* {.final, pure.} = object
    pt*: POINT
    flags*: UINT
    iItem*: int32

  THDHITTESTINFO* = HD_HITTESTINFO
  PHDHITTESTINFO* = ptr HD_HITTESTINFO
  HD_ITEM* {.final, pure.} = object
    mask*: UINT
    cxy*: int32
    pszText*: LPTSTR
    hbm*: HBITMAP
    cchTextMax*: int32
    fmt*: int32
    lParam*: LPARAM

  THDITEM* = HD_ITEM
  PHDITEM* = ptr HD_ITEM
  WINDOWPOS* {.final, pure.} = object
    hwnd*: HWND
    hwndInsertAfter*: HWND
    x*: int32
    y*: int32
    cx*: int32
    cy*: int32
    flags*: UINT

  LPWINDOWPOS* = ptr WINDOWPOS
  TWINDOWPOS* = WINDOWPOS
  PWINDOWPOS* = ptr WINDOWPOS
  HD_LAYOUT* {.final, pure.} = object
    prc*: ptr RECT
    pwpos*: ptr WINDOWPOS

  THDLAYOUT* = HD_LAYOUT
  PHDLAYOUT* = ptr HD_LAYOUT
  HD_NOTIFY* {.final, pure.} = object
    hdr*: NMHDR
    iItem*: int32
    iButton*: int32
    pitem*: ptr HD_ITEM

  THDNOTIFY* = HD_NOTIFY
  PHDNOTIFY* = ptr HD_NOTIFY
  HELPINFO* {.final, pure.} = object
    cbSize*: UINT
    iContextType*: int32
    iCtrlId*: int32
    hItemHandle*: HANDLE
    dwContextId*: DWORD
    MousePos*: POINT

  LPHELPINFO* = ptr HELPINFO
  THELPINFO* = HELPINFO
  PHELPINFO* = ptr HELPINFO
  HELPWININFO* {.final, pure.} = object
    wStructSize*: int32
    x*: int32
    y*: int32
    dx*: int32
    dy*: int32
    wMax*: int32
    rgchMember*: array[0..1, TCHAR]

  THELPWININFO* = HELPWININFO
  PHELPWININFO* = ptr HELPWININFO
  HIGHCONTRAST* {.final, pure.} = object
    cbSize*: UINT
    dwFlags*: DWORD
    lpszDefaultScheme*: LPTSTR

  LPHIGHCONTRAST* = ptr HIGHCONTRAST
  THIGHCONTRAST* = HIGHCONTRAST
  PHIGHCONTRAST* = ptr HIGHCONTRAST
  HSZPAIR* {.final, pure.} = object
    hszSvc*: HSZ
    hszTopic*: HSZ

  THSZPAIR* = HSZPAIR
  PHSZPAIR* = ptr HSZPAIR
  ICONINFO* {.final, pure.} = object
    fIcon*: WINBOOL
    xHotspot*: DWORD
    yHotspot*: DWORD
    hbmMask*: HBITMAP
    hbmColor*: HBITMAP

  TICONINFO* = ICONINFO
  PICONINFO* = ptr ICONINFO
  ICONMETRICS* {.final, pure.} = object
    cbSize*: UINT
    iHorzSpacing*: int32
    iVertSpacing*: int32
    iTitleWrap*: int32
    lfFont*: LOGFONT

  LPICONMETRICS* = ptr ICONMETRICS
  TICONMETRICS* = ICONMETRICS
  PICONMETRICS* = ptr ICONMETRICS
  IMAGEINFO* {.final, pure.} = object
    hbmImage*: HBITMAP
    hbmMask*: HBITMAP
    Unused1*: int32
    Unused2*: int32
    rcImage*: RECT

  TIMAGEINFO* = IMAGEINFO
  PIMAGEINFO* = ptr IMAGEINFO
  KEY_EVENT_RECORD* {.final, pure.} = object
    bKeyDown*: WINBOOL
    wRepeatCount*: int16
    wVirtualKeyCode*: int16
    wVirtualScanCode*: int16
    UnicodeChar*: WCHAR
    dwControlKeyState*: DWORD # other union part: AsciiChar: CHAR

  TKEYEVENTRECORD* = KEY_EVENT_RECORD
  PKEYEVENTRECORD* = ptr KEY_EVENT_RECORD
  MOUSE_EVENT_RECORD* {.final, pure.} = object
    dwMousePosition*: COORD
    dwButtonState*: DWORD
    dwControlKeyState*: DWORD
    dwEventFlags*: DWORD

  TMOUSEEVENTRECORD* = MOUSE_EVENT_RECORD
  PMOUSEEVENTRECORD* = ptr MOUSE_EVENT_RECORD
  WINDOW_BUFFER_SIZE_RECORD* {.final, pure.} = object
    dwSize*: COORD

  TWINDOWBUFFERSIZERECORD* = WINDOW_BUFFER_SIZE_RECORD
  PWINDOWBUFFERSIZERECORD* = ptr WINDOW_BUFFER_SIZE_RECORD
  MENU_EVENT_RECORD* {.final, pure.} = object
    dwCommandId*: UINT

  PMENU_EVENT_RECORD* = ptr MENU_EVENT_RECORD
  TMENUEVENTRECORD* = MENU_EVENT_RECORD
  INPUT_RECORD* {.final, pure.} = object
    EventType*: int16
    Reserved*: int16
    event*: array[0..5, DWORD]

  PINPUT_RECORD* = ptr INPUT_RECORD
  TINPUTRECORD* = INPUT_RECORD
  SYSTEMTIME* {.final, pure.} = object
    wYear*: int16
    wMonth*: int16
    wDayOfWeek*: int16
    wDay*: int16
    wHour*: int16
    wMinute*: int16
    wSecond*: int16
    wMilliseconds*: int16

  LPSYSTEMTIME* = ptr SYSTEMTIME
  TSYSTEMTIME* = SYSTEMTIME
  PSYSTEMTIME* = ptr SYSTEMTIME
  JOB_INFO_1* {.final, pure.} = object
    JobId*: DWORD
    pPrinterName*: LPTSTR
    pMachineName*: LPTSTR
    pUserName*: LPTSTR
    pDocument*: LPTSTR
    pDatatype*: LPTSTR
    pStatus*: LPTSTR
    Status*: DWORD
    Priority*: DWORD
    Position*: DWORD
    TotalPages*: DWORD
    PagesPrinted*: DWORD
    Submitted*: SYSTEMTIME

  TJOBINFO1* = JOB_INFO_1
  PJOBINFO1* = ptr JOB_INFO_1
  SID_IDENTIFIER_AUTHORITY* {.final, pure.} = object
    Value*: array[0..5, int8]

  LPSID_IDENTIFIER_AUTHORITY* = ptr SID_IDENTIFIER_AUTHORITY
  PSID_IDENTIFIER_AUTHORITY* = ptr SID_IDENTIFIER_AUTHORITY
  TSIDIDENTIFIERAUTHORITY* = SID_IDENTIFIER_AUTHORITY
  SID* {.final, pure.} = object
    Revision*: int8
    SubAuthorityCount*: int8
    IdentifierAuthority*: SID_IDENTIFIER_AUTHORITY
    SubAuthority*: array[0..(ANYSIZE_ARRAY) - 1, DWORD]

  TSID* = SID
  PSID* = ptr SID
  SECURITY_DESCRIPTOR_CONTROL* = int16
  PSECURITY_DESCRIPTOR_CONTROL* = ptr SECURITY_DESCRIPTOR_CONTROL
  TSECURITYDESCRIPTORCONTROL* = SECURITY_DESCRIPTOR_CONTROL
  SECURITY_DESCRIPTOR* {.final, pure.} = object
    Revision*: int8
    Sbz1*: int8
    Control*: SECURITY_DESCRIPTOR_CONTROL
    Owner*: PSID
    Group*: PSID
    Sacl*: PACL
    Dacl*: PACL

  PSECURITY_DESCRIPTOR* = ptr SECURITY_DESCRIPTOR
  TSECURITYDESCRIPTOR* = SECURITY_DESCRIPTOR
  JOB_INFO_2* {.final, pure.} = object
    JobId*: DWORD
    pPrinterName*: LPTSTR
    pMachineName*: LPTSTR
    pUserName*: LPTSTR
    pDocument*: LPTSTR
    pNotifyName*: LPTSTR
    pDatatype*: LPTSTR
    pPrintProcessor*: LPTSTR
    pParameters*: LPTSTR
    pDriverName*: LPTSTR
    pDevMode*: LPDEVMODE
    pStatus*: LPTSTR
    pSecurityDescriptor*: PSECURITY_DESCRIPTOR
    Status*: DWORD
    Priority*: DWORD
    Position*: DWORD
    StartTime*: DWORD
    UntilTime*: DWORD
    TotalPages*: DWORD
    Size*: DWORD
    Submitted*: SYSTEMTIME
    Time*: DWORD
    PagesPrinted*: DWORD

  TJOBINFO2* = JOB_INFO_2
  PJOBINFO2* = ptr JOB_INFO_2
  KERNINGPAIR* {.final, pure.} = object
    wFirst*: int16
    wSecond*: int16
    iKernAmount*: int32

  LPKERNINGPAIR* = ptr KERNINGPAIR
  TKERNINGPAIR* = KERNINGPAIR
  PKERNINGPAIR* = ptr KERNINGPAIR
  LANA_ENUM* {.final, pure.} = object
    len*: UCHAR
    lana*: array[0..(MAX_LANA) - 1, UCHAR]

  TLANAENUM* = LANA_ENUM
  PLANAENUM* = ptr LANA_ENUM
  LDT_ENTRY* {.final, pure.} = object
    LimitLow*: int16
    BaseLow*: int16
    BaseMid*: int8
    Flags1*: int8
    Flags2*: int8
    BaseHi*: int8

  LPLDT_ENTRY* = ptr LDT_ENTRY
  PLDT_ENTRY* = ptr LDT_ENTRY
  TLDTENTRY* = LDT_ENTRY

const
  bm_LDT_ENTRY_BaseMid* = 0x000000FF
  bp_LDT_ENTRY_BaseMid* = 0'i32
  bm_LDT_ENTRY_Type* = 0x00001F00
  bp_LDT_ENTRY_Type* = 8'i32
  bm_LDT_ENTRY_Dpl* = 0x00006000
  bp_LDT_ENTRY_Dpl* = 13'i32
  bm_LDT_ENTRY_Pres* = 0x00008000
  bp_LDT_ENTRY_Pres* = 15'i32
  bm_LDT_ENTRY_LimitHi* = 0x000F0000
  bp_LDT_ENTRY_LimitHi* = 16'i32
  bm_LDT_ENTRY_Sys* = 0x00100000
  bp_LDT_ENTRY_Sys* = 20'i32
  bm_LDT_ENTRY_Reserved_0* = 0x00200000
  bp_LDT_ENTRY_Reserved_0* = 21'i32
  bm_LDT_ENTRY_Default_Big* = 0x00400000
  bp_LDT_ENTRY_Default_Big* = 22'i32
  bm_LDT_ENTRY_Granularity* = 0x00800000
  bp_LDT_ENTRY_Granularity* = 23'i32
  bm_LDT_ENTRY_BaseHi* = 0xFF000000
  bp_LDT_ENTRY_BaseHi* = 24'i32

type
  LOCALESIGNATURE* {.final, pure.} = object
    lsUsb*: array[0..3, DWORD]
    lsCsbDefault*: array[0..1, DWORD]
    lsCsbSupported*: array[0..1, DWORD]

  TLOCALESIGNATURE* = LOCALESIGNATURE
  PLOCALESIGNATURE* = ptr LOCALESIGNATURE
  LOCALGROUP_MEMBERS_INFO_0* {.final, pure.} = object
    lgrmi0_sid*: PSID

  TLOCALGROUPMEMBERSINFO0* = LOCALGROUP_MEMBERS_INFO_0
  PLOCALGROUPMEMBERSINFO0* = ptr LOCALGROUP_MEMBERS_INFO_0
  LOCALGROUP_MEMBERS_INFO_3* {.final, pure.} = object
    lgrmi3_domainandname*: LPWSTR

  TLOCALGROUPMEMBERSINFO3* = LOCALGROUP_MEMBERS_INFO_3
  PLOCALGROUPMEMBERSINFO3* = ptr LOCALGROUP_MEMBERS_INFO_3
  FXPT16DOT16* = int32
  LPFXPT16DOT16* = ptr FXPT16DOT16
  TFXPT16DOT16* = FXPT16DOT16
  PFXPT16DOT16* = ptr FXPT16DOT16
  LUID* = TlargeInteger
  TLUID* = LUID
  PLUID* = ptr LUID
  LUID_AND_ATTRIBUTES* {.final, pure.} = object
    Luid*: LUID
    Attributes*: DWORD

  TLUIDANDATTRIBUTES* = LUID_AND_ATTRIBUTES
  PLUIDANDATTRIBUTES* = ptr LUID_AND_ATTRIBUTES
  LUID_AND_ATTRIBUTES_ARRAY* = array[0..(ANYSIZE_ARRAY) - 1, LUID_AND_ATTRIBUTES]
  PLUID_AND_ATTRIBUTES_ARRAY* = ptr LUID_AND_ATTRIBUTES_ARRAY
  TLUIDANDATTRIBUTESARRAY* = LUID_AND_ATTRIBUTES_ARRAY
  LV_COLUMN* {.final, pure.} = object
    mask*: UINT
    fmt*: int32
    cx*: int32
    pszText*: LPTSTR
    cchTextMax*: int32
    iSubItem*: int32

  TLVCOLUMN* = LV_COLUMN
  PLVCOLUMN* = ptr LV_COLUMN
  LV_ITEM* {.final, pure.} = object
    mask*: UINT
    iItem*: int32
    iSubItem*: int32
    state*: UINT
    stateMask*: UINT
    pszText*: LPTSTR
    cchTextMax*: int32
    iImage*: int32
    lParam*: LPARAM

  TLVITEM* = LV_ITEM
  PLVITEM* = ptr LV_ITEM
  LV_DISPINFO* {.final, pure.} = object
    hdr*: NMHDR
    item*: LV_ITEM

  TLVDISPINFO* = LV_DISPINFO
  PLVDISPINFO* = ptr LV_DISPINFO
  LV_FINDINFO* {.final, pure.} = object
    flags*: UINT
    psz*: LPCTSTR
    lParam*: LPARAM
    pt*: POINT
    vkDirection*: UINT

  TLVFINDINFO* = LV_FINDINFO
  PLVFINDINFO* = ptr LV_FINDINFO
  LV_HITTESTINFO* {.final, pure.} = object
    pt*: POINT
    flags*: UINT
    iItem*: int32

  TLVHITTESTINFO* = LV_HITTESTINFO
  PLVHITTESTINFO* = ptr LV_HITTESTINFO
  LV_KEYDOWN* {.final, pure.} = object
    hdr*: NMHDR
    wVKey*: int16
    flags*: UINT

  TLVKEYDOWN* = LV_KEYDOWN
  PLVKEYDOWN* = ptr LV_KEYDOWN
  MAT2* {.final, pure.} = object
    eM11*: FIXED
    eM12*: FIXED
    eM21*: FIXED
    eM22*: FIXED

  TMAT2* = MAT2
  PMAT2* = ptr MAT2
  MDICREATESTRUCT* {.final, pure.} = object
    szClass*: LPCTSTR
    szTitle*: LPCTSTR
    hOwner*: HANDLE
    x*: int32
    y*: int32
    cx*: int32
    cy*: int32
    style*: DWORD
    lParam*: LPARAM

  LPMDICREATESTRUCT* = ptr MDICREATESTRUCT
  TMDICREATESTRUCT* = MDICREATESTRUCT
  PMDICREATESTRUCT* = ptr MDICREATESTRUCT
  MEASUREITEMSTRUCT* {.final, pure.} = object
    CtlType*: UINT
    CtlID*: UINT
    itemID*: UINT
    itemWidth*: UINT
    itemHeight*: UINT
    itemData*: ULONG_PTR

  LPMEASUREITEMSTRUCT* = ptr MEASUREITEMSTRUCT
  TMEASUREITEMSTRUCT* = MEASUREITEMSTRUCT
  PMEASUREITEMSTRUCT* = ptr MEASUREITEMSTRUCT
  MEMORY_BASIC_INFORMATION* {.final, pure.} = object
    BaseAddress*: PVOID
    AllocationBase*: PVOID
    AllocationProtect*: DWORD
    RegionSize*: DWORD
    State*: DWORD
    Protect*: DWORD
    `type`*: DWORD

  PMEMORY_BASIC_INFORMATION* = ptr MEMORY_BASIC_INFORMATION
  TMEMORYBASICINFORMATION* = MEMORY_BASIC_INFORMATION
  MEMORYSTATUS* {.final, pure.} = object
    dwLength*: DWORD
    dwMemoryLoad*: DWORD
    dwTotalPhys*: int
    dwAvailPhys*: int
    dwTotalPageFile*: int
    dwAvailPageFile*: int
    dwTotalVirtual*: int
    dwAvailVirtual*: int

  TGUID* {.final, pure.} = object
    D1*: int32
    D2*: int16
    D3*: int16
    D4*: array [0..7, int8]

  LPMEMORYSTATUS* = ptr MEMORYSTATUS
  TMEMORYSTATUS* = MEMORYSTATUS
  PMEMORYSTATUS* = ptr MEMORYSTATUS
  MENUEX_TEMPLATE_HEADER* {.final, pure.} = object
    wVersion*: int16
    wOffset*: int16
    dwHelpId*: DWORD

  TMENUXTEMPLATEHEADER* = MENUEX_TEMPLATE_HEADER
  PMENUXTEMPLATEHEADER* = ptr MENUEX_TEMPLATE_HEADER
  MENUEX_TEMPLATE_ITEM* {.final, pure.} = object
    dwType*: DWORD
    dwState*: DWORD
    uId*: UINT
    bResInfo*: int8
    szText*: array[0..0, WCHAR]
    dwHelpId*: DWORD

  TMENUEXTEMPLATEITEM* = MENUEX_TEMPLATE_ITEM
  PMENUEXTEMPLATEITEM* = ptr MENUEX_TEMPLATE_ITEM
  MENUINFO* {.final, pure.} = object
    cbSize*: DWORD
    fMask*: DWORD
    dwStyle*: DWORD
    cyMax*: UINT
    hbrBack*: HBRUSH
    dwContextHelpID*: DWORD
    dwMenuData*: ULONG_PTR

  LPMENUINFO* = ptr MENUINFO
  LPCMENUINFO* = ptr MENUINFO
  TMENUINFO* = MENUINFO
  PMENUINFO* = ptr MENUINFO
  MENUITEMINFO* {.final, pure.} = object
    cbSize*: UINT
    fMask*: UINT
    fType*: UINT
    fState*: UINT
    wID*: UINT
    hSubMenu*: HMENU
    hbmpChecked*: HBITMAP
    hbmpUnchecked*: HBITMAP
    dwItemData*: ULONG_PTR
    dwTypeData*: LPTSTR
    cch*: UINT
    hbmpItem*: HBITMAP

  LPMENUITEMINFO* = ptr MENUITEMINFO
  LPCMENUITEMINFO* = ptr MENUITEMINFO
  TMENUITEMINFO* = MENUITEMINFO
  TMENUITEMINFOA* = MENUITEMINFO
  PMENUITEMINFO* = ptr MENUITEMINFO
  MENUITEMTEMPLATE* {.final, pure.} = object
    mtOption*: int16
    mtID*: int16
    mtString*: array[0..0, WCHAR]

  TMENUITEMTEMPLATE* = MENUITEMTEMPLATE
  PMENUITEMTEMPLATE* = ptr MENUITEMTEMPLATE
  MENUITEMTEMPLATEHEADER* {.final, pure.} = object
    versionNumber*: int16
    offset*: int16

  TMENUITEMTEMPLATEHEADER* = MENUITEMTEMPLATEHEADER
  PMENUITEMTEMPLATEHEADER* = ptr MENUITEMTEMPLATEHEADER
  MENUTEMPLATE* {.final, pure.} = object
  LPMENUTEMPLATE* = ptr MENUTEMPLATE
  TMENUTEMPLATE* = MENUTEMPLATE
  PMENUTEMPLATE* = ptr MENUTEMPLATE
  METAFILEPICT* {.final, pure.} = object
    mm*: LONG
    xExt*: LONG
    yExt*: LONG
    hMF*: HMETAFILE

  LPMETAFILEPICT* = ptr METAFILEPICT
  TMETAFILEPICT* = METAFILEPICT
  PMETAFILEPICT* = ptr METAFILEPICT
  METAHEADER* {.final, pure.} = object
    mtType*: int16
    mtHeaderSize*: int16
    mtVersion*: int16
    mtSize*: DWORD
    mtNoObjects*: int16
    mtMaxRecord*: DWORD
    mtNoParameters*: int16

  TMETAHEADER* = METAHEADER
  PMETAHEADER* = ptr METAHEADER
  METARECORD* {.final, pure.} = object
    rdSize*: DWORD
    rdFunction*: int16
    rdParm*: array[0..0, int16]

  LPMETARECORD* = ptr METARECORD
  TMETARECORD* = METARECORD
  PMETARECORD* = ptr METARECORD
  MINIMIZEDMETRICS* {.final, pure.} = object
    cbSize*: UINT
    iWidth*: int32
    iHorzGap*: int32
    iVertGap*: int32
    iArrange*: int32

  LPMINIMIZEDMETRICS* = ptr MINIMIZEDMETRICS
  TMINIMIZEDMETRICS* = MINIMIZEDMETRICS
  PMINIMIZEDMETRICS* = ptr MINIMIZEDMETRICS
  MINMAXINFO* {.final, pure.} = object
    ptReserved*: POINT
    ptMaxSize*: POINT
    ptMaxPosition*: POINT
    ptMinTrackSize*: POINT
    ptMaxTrackSize*: POINT

  TMINMAXINFO* = MINMAXINFO
  PMINMAXINFO* = ptr MINMAXINFO
  MODEMDEVCAPS* {.final, pure.} = object
    dwActualSize*: DWORD
    dwRequiredSize*: DWORD
    dwDevSpecificOffset*: DWORD
    dwDevSpecificSize*: DWORD
    dwModemProviderVersion*: DWORD
    dwModemManufacturerOffset*: DWORD
    dwModemManufacturerSize*: DWORD
    dwModemModelOffset*: DWORD
    dwModemModelSize*: DWORD
    dwModemVersionOffset*: DWORD
    dwModemVersionSize*: DWORD
    dwDialOptions*: DWORD
    dwCallSetupFailTimer*: DWORD
    dwInactivityTimeout*: DWORD
    dwSpeakerVolume*: DWORD
    dwSpeakerMode*: DWORD
    dwModemOptions*: DWORD
    dwMaxDTERate*: DWORD
    dwMaxDCERate*: DWORD
    abVariablePortion*: array[0..0, int8]

  LPMODEMDEVCAPS* = ptr MODEMDEVCAPS
  TMODEMDEVCAPS* = MODEMDEVCAPS
  PMODEMDEVCAPS* = ptr MODEMDEVCAPS
  MODEMSETTINGS* {.final, pure.} = object
    dwActualSize*: DWORD
    dwRequiredSize*: DWORD
    dwDevSpecificOffset*: DWORD
    dwDevSpecificSize*: DWORD
    dwCallSetupFailTimer*: DWORD
    dwInactivityTimeout*: DWORD
    dwSpeakerVolume*: DWORD
    dwSpeakerMode*: DWORD
    dwPreferredModemOptions*: DWORD
    dwNegotiatedModemOptions*: DWORD
    dwNegotiatedDCERate*: DWORD
    abVariablePortion*: array[0..0, int8]

  LPMODEMSETTINGS* = ptr MODEMSETTINGS
  TMODEMSETTINGS* = MODEMSETTINGS
  PMODEMSETTINGS* = ptr MODEMSETTINGS
  MONCBSTRUCT* {.final, pure.} = object
    cb*: UINT
    dwTime*: DWORD
    hTask*: HANDLE
    dwRet*: DWORD
    wType*: UINT
    wFmt*: UINT
    hConv*: HCONV
    hsz1*: HSZ
    hsz2*: HSZ
    hData*: HDDEDATA
    dwData1*: DWORD
    dwData2*: DWORD
    cc*: CONVCONTEXT
    cbData*: DWORD
    Data*: array[0..7, DWORD]

  TMONCBSTRUCT* = MONCBSTRUCT
  PMONCBSTRUCT* = ptr MONCBSTRUCT
  MONCONVSTRUCT* {.final, pure.} = object
    cb*: UINT
    fConnect*: WINBOOL
    dwTime*: DWORD
    hTask*: HANDLE
    hszSvc*: HSZ
    hszTopic*: HSZ
    hConvClient*: HCONV
    hConvServer*: HCONV

  TMONCONVSTRUCT* = MONCONVSTRUCT
  PMONCONVSTRUCT* = ptr MONCONVSTRUCT
  MONERRSTRUCT* {.final, pure.} = object
    cb*: UINT
    wLastError*: UINT
    dwTime*: DWORD
    hTask*: HANDLE

  TMONERRSTRUCT* = MONERRSTRUCT
  PMONERRSTRUCT* = ptr MONERRSTRUCT
  MONHSZSTRUCT* {.final, pure.} = object
    cb*: UINT
    fsAction*: WINBOOL
    dwTime*: DWORD
    hsz*: HSZ
    hTask*: HANDLE
    str*: array[0..0, TCHAR]

  TMONHSZSTRUCT* = MONHSZSTRUCT
  PMONHSZSTRUCT* = ptr MONHSZSTRUCT
  MONITOR_INFO_1* {.final, pure.} = object
    pName*: LPTSTR

  TMONITORINFO1* = MONITOR_INFO_1
  PMONITORINFO1* = ptr MONITOR_INFO_1
  MONITOR_INFO_2* {.final, pure.} = object
    pName*: LPTSTR
    pEnvironment*: LPTSTR
    pDLLName*: LPTSTR

  TMONITORINFO2* = MONITOR_INFO_2
  PMONITORINFO2* = ptr MONITOR_INFO_2
  MONLINKSTRUCT* {.final, pure.} = object
    cb*: UINT
    dwTime*: DWORD
    hTask*: HANDLE
    fEstablished*: WINBOOL
    fNoData*: WINBOOL
    hszSvc*: HSZ
    hszTopic*: HSZ
    hszItem*: HSZ
    wFmt*: UINT
    fServer*: WINBOOL
    hConvServer*: HCONV
    hConvClient*: HCONV

  TMONLINKSTRUCT* = MONLINKSTRUCT
  PMONLINKSTRUCT* = ptr MONLINKSTRUCT
  MONMSGSTRUCT* {.final, pure.} = object
    cb*: UINT
    hwndTo*: HWND
    dwTime*: DWORD
    hTask*: HANDLE
    wMsg*: UINT
    wParam*: WPARAM
    lParam*: LPARAM
    dmhd*: DDEML_MSG_HOOK_DATA

  TMONMSGSTRUCT* = MONMSGSTRUCT
  PMONMSGSTRUCT* = ptr MONMSGSTRUCT
  MOUSEHOOKSTRUCT* {.final, pure.} = object
    pt*: POINT
    hwnd*: HWND
    wHitTestCode*: UINT
    dwExtraInfo*: DWORD

  LPMOUSEHOOKSTRUCT* = ptr MOUSEHOOKSTRUCT
  TMOUSEHOOKSTRUCT* = MOUSEHOOKSTRUCT
  PMOUSEHOOKSTRUCT* = ptr MOUSEHOOKSTRUCT
  MOUSEKEYS* {.final, pure.} = object
    cbSize*: DWORD
    dwFlags*: DWORD
    iMaxSpeed*: DWORD
    iTimeToMaxSpeed*: DWORD
    iCtrlSpeed*: DWORD
    dwReserved1*: DWORD
    dwReserved2*: DWORD

  TMOUSEKEYS* = MOUSEKEYS
  PMOUSEKEYS* = ptr MOUSEKEYS
  MSGBOXCALLBACK* = proc (lpHelpInfo: LPHELPINFO){.stdcall.}
  TMSGBOXCALLBACK* = MSGBOXCALLBACK
  MSGBOXPARAMS* {.final, pure.} = object
    cbSize*: UINT
    hwndOwner*: HWND
    hInstance*: HINST
    lpszText*: LPCSTR
    lpszCaption*: LPCSTR
    dwStyle*: DWORD
    lpszIcon*: LPCSTR
    dwContextHelpId*: DWORD
    lpfnMsgBoxCallback*: MSGBOXCALLBACK
    dwLanguageId*: DWORD

  LPMSGBOXPARAMS* = ptr MSGBOXPARAMS
  TMSGBOXPARAMS* = MSGBOXPARAMS
  TMSGBOXPARAMSA* = MSGBOXPARAMS
  PMSGBOXPARAMS* = ptr MSGBOXPARAMS
  MSGFILTER* {.final, pure.} = object
    nmhdr*: NMHDR
    msg*: UINT
    wParam*: WPARAM
    lParam*: LPARAM

  Tmsgfilter* = MSGFILTER
  Pmsgfilter* = ptr MSGFILTER
  MULTIKEYHELP* {.final, pure.} = object
    mkSize*: DWORD
    mkKeylist*: TCHAR
    szKeyphrase*: array[0..0, TCHAR]

  TMULTIKEYHELP* = MULTIKEYHELP
  PMULTIKEYHELP* = ptr MULTIKEYHELP
  NAME_BUFFER* {.final, pure.} = object
    name*: array[0..(NCBNAMSZ) - 1, UCHAR]
    name_num*: UCHAR
    name_flags*: UCHAR

  TNAMEBUFFER* = NAME_BUFFER
  PNAMEBUFFER* = ptr NAME_BUFFER
  p_NCB* = ptr NCB
  NCB* {.final, pure.} = object
    ncb_command*: UCHAR
    ncb_retcode*: UCHAR
    ncb_lsn*: UCHAR
    ncb_num*: UCHAR
    ncb_buffer*: PUCHAR
    ncb_length*: int16
    ncb_callname*: array[0..(NCBNAMSZ) - 1, UCHAR]
    ncb_name*: array[0..(NCBNAMSZ) - 1, UCHAR]
    ncb_rto*: UCHAR
    ncb_sto*: UCHAR
    ncb_post*: proc (para1: p_NCB){.CDECL.}
    ncb_lana_num*: UCHAR
    ncb_cmd_cplt*: UCHAR
    ncb_reserve*: array[0..9, UCHAR]
    ncb_event*: HANDLE

  TNCB* = NCB
  NCCALCSIZE_PARAMS* {.final, pure.} = object
    rgrc*: array[0..2, RECT]
    lppos*: PWINDOWPOS

  TNCCALCSIZEPARAMS* = NCCALCSIZE_PARAMS
  PNCCALCSIZEPARAMS* = ptr NCCALCSIZE_PARAMS
  NDDESHAREINFO* {.final, pure.} = object
    lRevision*: LONG
    lpszShareName*: LPTSTR
    lShareType*: LONG
    lpszAppTopicList*: LPTSTR
    fSharedFlag*: LONG
    fService*: LONG
    fStartAppFlag*: LONG
    nCmdShow*: LONG
    qModifyId*: array[0..1, LONG]
    cNumItems*: LONG
    lpszItemList*: LPTSTR

  TNDDESHAREINFO* = NDDESHAREINFO
  PNDDESHAREINFO* = ptr NDDESHAREINFO
  NETRESOURCE* {.final, pure.} = object
    dwScope*: DWORD
    dwType*: DWORD
    dwDisplayType*: DWORD
    dwUsage*: DWORD
    lpLocalName*: LPTSTR
    lpRemoteName*: LPTSTR
    lpComment*: LPTSTR
    lpProvider*: LPTSTR

  LPNETRESOURCE* = ptr NETRESOURCE
  TNETRESOURCE* = NETRESOURCE
  TNETRESOURCEA* = NETRESOURCE
  PNETRESOURCE* = ptr NETRESOURCE
  PNETRESOURCEA* = ptr NETRESOURCE
  NEWCPLINFO* {.final, pure.} = object
    dwSize*: DWORD
    dwFlags*: DWORD
    dwHelpContext*: DWORD
    lData*: LONG
    hIcon*: HICON
    szName*: array[0..31, TCHAR]
    szInfo*: array[0..63, TCHAR]
    szHelpFile*: array[0..127, TCHAR]

  TNEWCPLINFO* = NEWCPLINFO
  PNEWCPLINFO* = ptr NEWCPLINFO
  NEWTEXTMETRIC* {.final, pure.} = object
    tmHeight*: LONG
    tmAscent*: LONG
    tmDescent*: LONG
    tmInternalLeading*: LONG
    tmExternalLeading*: LONG
    tmAveCharWidth*: LONG
    tmMaxCharWidth*: LONG
    tmWeight*: LONG
    tmOverhang*: LONG
    tmDigitizedAspectX*: LONG
    tmDigitizedAspectY*: LONG
    tmFirstChar*: BCHAR
    tmLastChar*: BCHAR
    tmDefaultChar*: BCHAR
    tmBreakChar*: BCHAR
    tmItalic*: int8
    tmUnderlined*: int8
    tmStruckOut*: int8
    tmPitchAndFamily*: int8
    tmCharSet*: int8
    ntmFlags*: DWORD
    ntmSizeEM*: UINT
    ntmCellHeight*: UINT
    ntmAvgWidth*: UINT

  TNEWTEXTMETRIC* = NEWTEXTMETRIC
  PNEWTEXTMETRIC* = ptr NEWTEXTMETRIC
  NEWTEXTMETRICEX* {.final, pure.} = object
    ntmentm*: NEWTEXTMETRIC
    ntmeFontSignature*: FONTSIGNATURE

  TNEWTEXTMETRICEX* = NEWTEXTMETRICEX
  PNEWTEXTMETRICEX* = ptr NEWTEXTMETRICEX
  NM_LISTVIEW* {.final, pure.} = object
    hdr*: NMHDR
    iItem*: int32
    iSubItem*: int32
    uNewState*: UINT
    uOldState*: UINT
    uChanged*: UINT
    ptAction*: POINT
    lParam*: LPARAM

  TNMLISTVIEW* = NM_LISTVIEW
  PNMLISTVIEW* = ptr NM_LISTVIEW
  TV_ITEM* {.final, pure.} = object
    mask*: UINT
    hItem*: HTREEITEM
    state*: UINT
    stateMask*: UINT
    pszText*: LPTSTR
    cchTextMax*: int32
    iImage*: int32
    iSelectedImage*: int32
    cChildren*: int32
    lParam*: LPARAM

  LPTV_ITEM* = ptr TV_ITEM
  TTVITEM* = TV_ITEM
  PTVITEM* = ptr TV_ITEM
  NM_TREEVIEW* {.final, pure.} = object
    hdr*: NMHDR
    action*: UINT
    itemOld*: TV_ITEM
    itemNew*: TV_ITEM
    ptDrag*: POINT

  LPNM_TREEVIEW* = ptr NM_TREEVIEW
  TNMTREEVIEW* = NM_TREEVIEW
  PNMTREEVIEW* = ptr NM_TREEVIEW
  NM_UPDOWNW* {.final, pure.} = object
    hdr*: NMHDR
    iPos*: int32
    iDelta*: int32

  TNMUPDOWN* = NM_UPDOWNW
  PNMUPDOWN* = ptr NM_UPDOWNW
  NONCLIENTMETRICS* {.final, pure.} = object
    cbSize*: UINT
    iBorderWidth*: int32
    iScrollWidth*: int32
    iScrollHeight*: int32
    iCaptionWidth*: int32
    iCaptionHeight*: int32
    lfCaptionFont*: LOGFONT
    iSmCaptionWidth*: int32
    iSmCaptionHeight*: int32
    lfSmCaptionFont*: LOGFONT
    iMenuWidth*: int32
    iMenuHeight*: int32
    lfMenuFont*: LOGFONT
    lfStatusFont*: LOGFONT
    lfMessageFont*: LOGFONT

  LPNONCLIENTMETRICS* = ptr NONCLIENTMETRICS
  TNONCLIENTMETRICS* = NONCLIENTMETRICS
  PNONCLIENTMETRICS* = ptr NONCLIENTMETRICS
  SERVICE_ADDRESS* {.final, pure.} = object
    dwAddressType*: DWORD
    dwAddressFlags*: DWORD
    dwAddressLength*: DWORD
    dwPrincipalLength*: DWORD
    lpAddress*: ptr int8
    lpPrincipal*: ptr int8

  TSERVICEADDRESS* = SERVICE_ADDRESS
  PSERVICEADDRESS* = ptr SERVICE_ADDRESS
  SERVICE_ADDRESSES* {.final, pure.} = object
    dwAddressCount*: DWORD
    Addresses*: array[0..0, SERVICE_ADDRESS]

  LPSERVICE_ADDRESSES* = ptr SERVICE_ADDRESSES
  TSERVICEADDRESSES* = SERVICE_ADDRESSES
  PSERVICEADDRESSES* = ptr SERVICE_ADDRESSES
  LPGUID* = ptr TGUID
  PGUID* = ptr TGUID
  CLSID* = TGUID
  LPCLSID* = ptr CLSID
  TCLSID* = CLSID
  PCLSID* = ptr CLSID
  SERVICE_INFO* {.final, pure.} = object
    lpServiceType*: LPGUID
    lpServiceName*: LPTSTR
    lpComment*: LPTSTR
    lpLocale*: LPTSTR
    dwDisplayHint*: DWORD
    dwVersion*: DWORD
    dwTime*: DWORD
    lpMachineName*: LPTSTR
    lpServiceAddress*: LPSERVICE_ADDRESSES
    ServiceSpecificInfo*: BLOB

  TSERVICEINFO* = SERVICE_INFO
  PSERVICEINFO* = ptr SERVICE_INFO
  NS_SERVICE_INFO* {.final, pure.} = object
    dwNameSpace*: DWORD
    ServiceInfo*: SERVICE_INFO

  TNSSERVICEINFO* = NS_SERVICE_INFO
  PNSSERVICEINFO* = ptr NS_SERVICE_INFO
  NUMBERFMT* {.final, pure.} = object
    NumDigits*: UINT
    LeadingZero*: UINT
    Grouping*: UINT
    lpDecimalSep*: LPTSTR
    lpThousandSep*: LPTSTR
    NegativeOrder*: UINT

  Tnumberfmt* = NUMBERFMT
  Pnumberfmt* = ptr NUMBERFMT
  OFSTRUCT* {.final, pure.} = object
    cBytes*: int8
    fFixedDisk*: int8
    nErrCode*: int16
    Reserved1*: int16
    Reserved2*: int16
    szPathName*: array[0..(OFS_MAXPATHNAME) - 1, CHAR]

  LPOFSTRUCT* = ptr OFSTRUCT
  TOFSTRUCT* = OFSTRUCT
  POFSTRUCT* = ptr OFSTRUCT
  OPENFILENAME_NT4* {.final, pure.} = object
    lStructSize*: DWORD
    hwndOwner*: HWND
    hInstance*: HINST
    lpstrFilter*: LPCTSTR
    lpstrCustomFilter*: LPTSTR
    nMaxCustFilter*: DWORD
    nFilterIndex*: DWORD
    lpstrFile*: LPTSTR
    nMaxFile*: DWORD
    lpstrFileTitle*: LPTSTR
    nMaxFileTitle*: DWORD
    lpstrInitialDir*: LPCTSTR
    lpstrTitle*: LPCTSTR
    Flags*: DWORD
    nFileOffset*: int16
    nFileExtension*: int16
    lpstrDefExt*: LPCTSTR
    lCustData*: LPARAM
    lpfnHook*: LPOFNHOOKPROC
    lpTemplateName*: LPCTSTR

  LPOPENFILENAME_NT4* = ptr OPENFILENAME_NT4
  TOPENFILENAME_NT4* = OPENFILENAME_NT4
  POPENFILENAME_NT4* = ptr OPENFILENAME_NT4
  TOPENFILENAME* {.final, pure.} = object
    lStructSize*: DWORD
    hwndOwner*: HWND
    hInstance*: HINST
    lpstrFilter*: LPCTSTR
    lpstrCustomFilter*: LPTSTR
    nMaxCustFilter*: DWORD
    nFilterIndex*: DWORD
    lpstrFile*: LPTSTR
    nMaxFile*: DWORD
    lpstrFileTitle*: LPTSTR
    nMaxFileTitle*: DWORD
    lpstrInitialDir*: LPCTSTR
    lpstrTitle*: LPCTSTR
    Flags*: DWORD
    nFileOffset*: int16
    nFileExtension*: int16
    lpstrDefExt*: LPCTSTR
    lCustData*: LPARAM
    lpfnHook*: LPOFNHOOKPROC
    lpTemplateName*: LPCTSTR
    pvReserved*: pointer
    dwreserved*: dword
    FlagsEx*: dword

  LPOPENFILENAME* = ptr TOPENFILENAME
  POPENFILENAME* = ptr TOPENFILENAME
  OFN* = TOPENFILENAME
  POFN* = ptr TOPENFILENAME
  OFNOTIFY* {.final, pure.} = object
    hdr*: NMHDR
    lpOFN*: LPOPENFILENAME
    pszFile*: LPTSTR

  LPOFNOTIFY* = ptr OFNOTIFY
  TOFNOTIFY* = OFNOTIFY
  POFNOTIFY* = ptr OFNOTIFY
  OSVERSIONINFO* {.final, pure.} = object
    dwOSVersionInfoSize*: DWORD
    dwMajorVersion*: DWORD
    dwMinorVersion*: DWORD
    dwBuildNumber*: DWORD
    dwPlatformId*: DWORD
    szCSDVersion*: array[0..127, TCHAR]

  LPOSVERSIONINFO* = ptr OSVERSIONINFO
  TOSVERSIONINFO* = OSVERSIONINFO
  POSVERSIONINFO* = ptr OSVERSIONINFO
  OSVERSIONINFOW* {.final, pure.} = object
    dwOSVersionInfoSize*: DWORD
    dwMajorVersion*: DWORD
    dwMinorVersion*: DWORD
    dwBuildNumber*: DWORD
    dwPlatformId*: DWORD
    szCSDVersion*: array[0..127, WCHAR]

  LPOSVERSIONINFOW* = ptr OSVERSIONINFOW
  TOSVERSIONINFOW* = OSVERSIONINFOW
  POSVERSIONINFOW* = ptr OSVERSIONINFOW
  TEXTMETRIC* {.final, pure.} = object
    tmHeight*: LONG
    tmAscent*: LONG
    tmDescent*: LONG
    tmInternalLeading*: LONG
    tmExternalLeading*: LONG
    tmAveCharWidth*: LONG
    tmMaxCharWidth*: LONG
    tmWeight*: LONG
    tmOverhang*: LONG
    tmDigitizedAspectX*: LONG
    tmDigitizedAspectY*: LONG
    tmFirstChar*: BCHAR
    tmLastChar*: BCHAR
    tmDefaultChar*: BCHAR
    tmBreakChar*: BCHAR
    tmItalic*: int8
    tmUnderlined*: int8
    tmStruckOut*: int8
    tmPitchAndFamily*: int8
    tmCharSet*: int8

  LPTEXTMETRIC* = ptr TEXTMETRIC
  TTEXTMETRIC* = TEXTMETRIC
  PTEXTMETRIC* = ptr TEXTMETRIC
  TEXTMETRICW* {.final, pure.} = object
    tmHeight*: LONG
    tmAscent*: LONG
    tmDescent*: LONG
    tmInternalLeading*: LONG
    tmExternalLeading*: LONG
    tmAveCharWidth*: LONG
    tmMaxCharWidth*: LONG
    tmWeight*: LONG
    tmOverhang*: LONG
    tmDigitizedAspectX*: LONG
    tmDigitizedAspectY*: LONG
    tmFirstChar*: WCHAR
    tmLastChar*: WCHAR
    tmDefaultChar*: WCHAR
    tmBreakChar*: WCHAR
    tmItalic*: int8
    tmUnderlined*: int8
    tmStruckOut*: int8
    tmPitchAndFamily*: int8
    tmCharSet*: int8

  LPTEXTMETRICW* = ptr TEXTMETRICW
  TTEXTMETRICW* = TEXTMETRICW
  PTEXTMETRICW* = ptr TEXTMETRICW
  OUTLINETEXTMETRIC* {.final, pure.} = object
    otmSize*: UINT
    otmTextMetrics*: TEXTMETRIC
    otmFiller*: int8
    otmPanoseNumber*: PANOSE
    otmfsSelection*: UINT
    otmfsType*: UINT
    otmsCharSlopeRise*: int32
    otmsCharSlopeRun*: int32
    otmItalicAngle*: int32
    otmEMSquare*: UINT
    otmAscent*: int32
    otmDescent*: int32
    otmLineGap*: UINT
    otmsCapEmHeight*: UINT
    otmsXHeight*: UINT
    otmrcFontBox*: RECT
    otmMacAscent*: int32
    otmMacDescent*: int32
    otmMacLineGap*: UINT
    otmusMinimumPPEM*: UINT
    otmptSubscriptSize*: POINT
    otmptSubscriptOffset*: POINT
    otmptSuperscriptSize*: POINT
    otmptSuperscriptOffset*: POINT
    otmsStrikeoutSize*: UINT
    otmsStrikeoutPosition*: int32
    otmsUnderscoreSize*: int32
    otmsUnderscorePosition*: int32
    otmpFamilyName*: PSTR
    otmpFaceName*: PSTR
    otmpStyleName*: PSTR
    otmpFullName*: PSTR

  LPOUTLINETEXTMETRIC* = ptr OUTLINETEXTMETRIC
  TOUTLINETEXTMETRIC* = OUTLINETEXTMETRIC
  POUTLINETEXTMETRIC* = ptr OUTLINETEXTMETRIC
  OVERLAPPED* {.final, pure.} = object
    Internal*: DWORD
    InternalHigh*: DWORD
    Offset*: DWORD
    OffsetHigh*: DWORD
    hEvent*: HANDLE

  LPOVERLAPPED* = ptr OVERLAPPED
  TOVERLAPPED* = OVERLAPPED
  POVERLAPPED* = ptr OVERLAPPED
  #PAGESETUPDLG = record conflicts with function PageSetupDlg
  TPAGESETUPDLG* {.final, pure.} = object
    lStructSize*: DWORD
    hwndOwner*: HWND
    hDevMode*: HGLOBAL
    hDevNames*: HGLOBAL
    Flags*: DWORD
    ptPaperSize*: POINT
    rtMinMargin*: RECT
    rtMargin*: RECT
    hInstance*: HINST
    lCustData*: LPARAM
    lpfnPageSetupHook*: LPPAGESETUPHOOK
    lpfnPagePaintHook*: LPPAGEPAINTHOOK
    lpPageSetupTemplateName*: LPCTSTR
    hPageSetupTemplate*: HGLOBAL

  LPPAGESETUPDLG* = ptr TPAGESETUPDLG
  PPAGESETUPDLG* = ptr TPAGESETUPDLG
  TPSD* = TPAGESETUPDLG
  PPSD* = ptr TPAGESETUPDLG
  PAINTSTRUCT* {.final, pure.} = object
    hdc*: HDC
    fErase*: WINBOOL
    rcPaint*: RECT
    fRestore*: WINBOOL
    fIncUpdate*: WINBOOL
    rgbReserved*: array[0..31, int8]

  LPPAINTSTRUCT* = ptr PAINTSTRUCT
  TPAINTSTRUCT* = PAINTSTRUCT
  PPAINTSTRUCT* = ptr PAINTSTRUCT
  PARAFORMAT* {.final, pure.} = object
    cbSize*: UINT
    dwMask*: DWORD
    wNumbering*: int16
    wReserved*: int16
    dxStartIndent*: LONG
    dxRightIndent*: LONG
    dxOffset*: LONG
    wAlignment*: int16
    cTabCount*: SHORT
    rgxTabs*: array[0..(MAX_TAB_STOPS) - 1, LONG]

  Tparaformat* = PARAFORMAT
  Pparaformat* = ptr PARAFORMAT
  PERF_COUNTER_BLOCK* {.final, pure.} = object
    ByteLength*: DWORD

  TPERFCOUNTERBLOCK* = PERF_COUNTER_BLOCK
  PPERFCOUNTERBLOCK* = ptr PERF_COUNTER_BLOCK
  PERF_COUNTER_DEFINITION* {.final, pure.} = object
    ByteLength*: DWORD
    CounterNameTitleIndex*: DWORD
    CounterNameTitle*: LPWSTR
    CounterHelpTitleIndex*: DWORD
    CounterHelpTitle*: LPWSTR
    DefaultScale*: DWORD
    DetailLevel*: DWORD
    CounterType*: DWORD
    CounterSize*: DWORD
    CounterOffset*: DWORD

  TPERFCOUNTERDEFINITION* = PERF_COUNTER_DEFINITION
  PPERFCOUNTERDEFINITION* = ptr PERF_COUNTER_DEFINITION
  PERF_DATA_BLOCK* {.final, pure.} = object
    Signature*: array[0..3, WCHAR]
    LittleEndian*: DWORD
    Version*: DWORD
    Revision*: DWORD
    TotalByteLength*: DWORD
    HeaderLength*: DWORD
    NumObjectTypes*: DWORD
    DefaultObject*: DWORD
    SystemTime*: SYSTEMTIME
    PerfTime*: LARGE_INTEGER
    PerfFreq*: LARGE_INTEGER
    PerfTime100nSec*: LARGE_INTEGER
    SystemNameLength*: DWORD
    SystemNameOffset*: DWORD

  TPERFDATABLOCK* = PERF_DATA_BLOCK
  PPERFDATABLOCK* = ptr PERF_DATA_BLOCK
  PERF_INSTANCE_DEFINITION* {.final, pure.} = object
    ByteLength*: DWORD
    ParentObjectTitleIndex*: DWORD
    ParentObjectInstance*: DWORD
    UniqueID*: DWORD
    NameOffset*: DWORD
    NameLength*: DWORD

  TPERFINSTANCEDEFINITION* = PERF_INSTANCE_DEFINITION
  PPERFINSTANCEDEFINITION* = PERF_INSTANCE_DEFINITION
  PERF_OBJECT_TYPE* {.final, pure.} = object
    TotalByteLength*: DWORD
    DefinitionLength*: DWORD
    HeaderLength*: DWORD
    ObjectNameTitleIndex*: DWORD
    ObjectNameTitle*: LPWSTR
    ObjectHelpTitleIndex*: DWORD
    ObjectHelpTitle*: LPWSTR
    DetailLevel*: DWORD
    NumCounters*: DWORD
    DefaultCounter*: DWORD
    NumInstances*: DWORD
    CodePage*: DWORD
    PerfTime*: LARGE_INTEGER
    PerfFreq*: LARGE_INTEGER

  TPERFOBJECTTYPE* = PERF_OBJECT_TYPE
  PPERFOBJECTTYPE* = ptr PERF_OBJECT_TYPE
  POLYTEXT* {.final, pure.} = object
    x*: int32
    y*: int32
    n*: UINT
    lpstr*: LPCTSTR
    uiFlags*: UINT
    rcl*: RECT
    pdx*: ptr int32

  TPOLYTEXT* = POLYTEXT
  PPOLYTEXT* = ptr POLYTEXT
  PORT_INFO_1* {.final, pure.} = object
    pName*: LPTSTR

  TPORTINFO1* = PORT_INFO_1
  PPORTINFO1* = ptr PORT_INFO_1
  PORT_INFO_2* {.final, pure.} = object
    pPortName*: LPSTR
    pMonitorName*: LPSTR
    pDescription*: LPSTR
    fPortType*: DWORD
    Reserved*: DWORD

  TPORTINFO2* = PORT_INFO_2
  PPORTINFO2* = ptr PORT_INFO_2
  PREVENT_MEDIA_REMOVAL* {.final, pure.} = object
    PreventMediaRemoval*: bool

  TPREVENTMEDIAREMOVAL* = PREVENT_MEDIA_REMOVAL
  PPREVENTMEDIAREMOVAL* = ptr PREVENT_MEDIA_REMOVAL
  #PRINTDLG = record conflicts with PrintDlg function
  TPRINTDLG* {.final, pure.} = object
    lStructSize*: DWORD
    hwndOwner*: HWND
    hDevMode*: HANDLE
    hDevNames*: HANDLE
    hDC*: HDC
    Flags*: DWORD
    nFromPage*: int16
    nToPage*: int16
    nMinPage*: int16
    nMaxPage*: int16
    nCopies*: int16
    hInstance*: HINST
    lCustData*: DWORD
    lpfnPrintHook*: LPPRINTHOOKPROC
    lpfnSetupHook*: LPSETUPHOOKPROC
    lpPrintTemplateName*: LPCTSTR
    lpSetupTemplateName*: LPCTSTR
    hPrintTemplate*: HANDLE
    hSetupTemplate*: HANDLE

  LPPRINTDLG* = ptr TPRINTDLG
  PPRINTDLG* = ptr TPRINTDLG
  TPD* = TPRINTDLG
  PPD* = ptr TPRINTDLG
  PRINTER_DEFAULTS* {.final, pure.} = object
    pDatatype*: LPTSTR
    pDevMode*: LPDEVMODE
    DesiredAccess*: ACCESS_MASK

  TPRINTERDEFAULTS* = PRINTER_DEFAULTS
  PPRINTERDEFAULTS* = ptr PRINTER_DEFAULTS
  PRINTER_INFO_1* {.final, pure.} = object
    Flags*: DWORD
    pDescription*: LPTSTR
    pName*: LPTSTR
    pComment*: LPTSTR

  LPPRINTER_INFO_1* = ptr PRINTER_INFO_1
  PPRINTER_INFO_1* = ptr PRINTER_INFO_1
  TPRINTERINFO1* = PRINTER_INFO_1
  PRINTER_INFO_2* {.final, pure.} = object
    pServerName*: LPTSTR
    pPrinterName*: LPTSTR
    pShareName*: LPTSTR
    pPortName*: LPTSTR
    pDriverName*: LPTSTR
    pComment*: LPTSTR
    pLocation*: LPTSTR
    pDevMode*: LPDEVMODE
    pSepFile*: LPTSTR
    pPrintProcessor*: LPTSTR
    pDatatype*: LPTSTR
    pParameters*: LPTSTR
    pSecurityDescriptor*: PSECURITY_DESCRIPTOR
    Attributes*: DWORD
    Priority*: DWORD
    DefaultPriority*: DWORD
    StartTime*: DWORD
    UntilTime*: DWORD
    Status*: DWORD
    cJobs*: DWORD
    AveragePPM*: DWORD

  TPRINTERINFO2* = PRINTER_INFO_2
  PPRINTERINFO2* = ptr PRINTER_INFO_2
  PRINTER_INFO_3* {.final, pure.} = object
    pSecurityDescriptor*: PSECURITY_DESCRIPTOR

  TPRINTERINFO3* = PRINTER_INFO_3
  PPRINTERINFO3* = ptr PRINTER_INFO_3
  PRINTER_INFO_4* {.final, pure.} = object
    pPrinterName*: LPTSTR
    pServerName*: LPTSTR
    Attributes*: DWORD

  TPRINTERINFO4* = PRINTER_INFO_4
  PPRINTERINFO4* = ptr PRINTER_INFO_4
  PRINTER_INFO_5* {.final, pure.} = object
    pPrinterName*: LPTSTR
    pPortName*: LPTSTR
    Attributes*: DWORD
    DeviceNotSelectedTimeout*: DWORD
    TransmissionRetryTimeout*: DWORD

  TPRINTERINFO5* = PRINTER_INFO_5
  PPRINTERINFO5* = ptr PRINTER_INFO_5
  PRINTER_NOTIFY_INFO_DATA* {.final, pure.} = object
    `type`*: int16
    Field*: int16
    Reserved*: DWORD
    Id*: DWORD
    cbBuf*: DWORD
    pBuf*: LPVOID

  TPRINTERNOTIFYINFODATA* = PRINTER_NOTIFY_INFO_DATA
  PPRINTERNOTIFYINFODATA* = ptr PRINTER_NOTIFY_INFO_DATA
  PRINTER_NOTIFY_INFO* {.final, pure.} = object
    Version*: DWORD
    Flags*: DWORD
    Count*: DWORD
    aData*: array[0..0, PRINTER_NOTIFY_INFO_DATA]

  TPRINTERNOTIFYINFO* = PRINTER_NOTIFY_INFO
  PPRINTERNOTIFYINFO* = ptr PRINTER_NOTIFY_INFO
  PRINTER_NOTIFY_OPTIONS_TYPE* {.final, pure.} = object
    `type`*: int16
    Reserved0*: int16
    Reserved1*: DWORD
    Reserved2*: DWORD
    Count*: DWORD
    pFields*: PWORD

  PPRINTER_NOTIFY_OPTIONS_TYPE* = ptr PRINTER_NOTIFY_OPTIONS_TYPE
  TPRINTERNOTIFYOPTIONSTYPE* = PRINTER_NOTIFY_OPTIONS_TYPE
  PRINTER_NOTIFY_OPTIONS* {.final, pure.} = object
    Version*: DWORD
    Flags*: DWORD
    Count*: DWORD
    pTypes*: PPRINTER_NOTIFY_OPTIONS_TYPE

  TPRINTERNOTIFYOPTIONS* = PRINTER_NOTIFY_OPTIONS
  PPRINTERNOTIFYOPTIONS* = ptr PRINTER_NOTIFY_OPTIONS
  PRINTPROCESSOR_INFO_1* {.final, pure.} = object
    pName*: LPTSTR

  TPRINTPROCESSORINFO1* = PRINTPROCESSOR_INFO_1
  PPRINTPROCESSORINFO1* = ptr PRINTPROCESSOR_INFO_1
  PRIVILEGE_SET* {.final, pure.} = object
    PrivilegeCount*: DWORD
    Control*: DWORD
    Privilege*: array[0..(ANYSIZE_ARRAY) - 1, LUID_AND_ATTRIBUTES]

  LPPRIVILEGE_SET* = ptr PRIVILEGE_SET
  PPRIVILEGE_SET* = ptr PRIVILEGE_SET
  TPRIVILEGESET* = PRIVILEGE_SET
  PROCESS_HEAPENTRY* {.final, pure.} = object
    lpData*: PVOID
    cbData*: DWORD
    cbOverhead*: int8
    iRegionIndex*: int8
    wFlags*: int16
    dwCommittedSize*: DWORD
    dwUnCommittedSize*: DWORD
    lpFirstBlock*: LPVOID
    lpLastBlock*: LPVOID
    hMem*: HANDLE

  LPPROCESS_HEAP_ENTRY* = ptr PROCESS_HEAPENTRY
  TPROCESSHEAPENTRY* = PROCESS_HEAPENTRY
  PPROCESSHEAPENTRY* = ptr PROCESS_HEAPENTRY
  PROCESS_INFORMATION* {.final, pure.} = object
    hProcess*: HANDLE
    hThread*: HANDLE
    dwProcessId*: DWORD
    dwThreadId*: DWORD

  LPPROCESS_INFORMATION* = ptr PROCESS_INFORMATION
  TPROCESSINFORMATION* = PROCESS_INFORMATION
  PPROCESSINFORMATION* = ptr PROCESS_INFORMATION
  LPFNPSPCALLBACK* = proc (para1: HWND, para2: UINT, para3: LPVOID): UINT{.
      stdcall.}
  TFNPSPCALLBACK* = LPFNPSPCALLBACK
  PROPSHEETPAGE* {.final, pure.} = object
    dwSize*: DWORD
    dwFlags*: DWORD
    hInstance*: HINST
    pszIcon*: LPCTSTR
    pszTitle*: LPCTSTR
    pfnDlgProc*: DLGPROC
    lParam*: LPARAM
    pfnCallback*: LPFNPSPCALLBACK
    pcRefParent*: ptr UINT

  LPPROPSHEETPAGE* = ptr PROPSHEETPAGE
  LPCPROPSHEETPAGE* = ptr PROPSHEETPAGE
  TPROPSHEETPAGE* = PROPSHEETPAGE
  PPROPSHEETPAGE* = ptr PROPSHEETPAGE
  emptyrecord* {.final, pure.} = object
  lpemptyrecord* = ptr emptyrecord
  HPROPSHEETPAGE* = ptr emptyrecord
  PROPSHEETHEADER* {.final, pure.} = object
    dwSize*: DWORD
    dwFlags*: DWORD
    hwndParent*: HWND
    hInstance*: HINST
    pszIcon*: LPCTSTR
    pszCaption*: LPCTSTR
    nPages*: UINT
    pStartPage*: LPCTSTR
    phpage*: ptr HPROPSHEETPAGE
    pfnCallback*: PFNPROPSHEETCALLBACK
    pszbmWatermark*: LPCTSTR
    hplWatermark*: HPALETTE
    pszbmHeader*: cstring

  LPPROPSHEETHEADER* = ptr PROPSHEETHEADER
  LPCPROPSHEETHEADER* = ptr PROPSHEETHEADER
  TPROPSHEETHEADER* = PROPSHEETHEADER
  PPROPSHEETHEADER* = ptr PROPSHEETHEADER
  # PropertySheet callbacks
  LPFNADDPROPSHEETPAGE* = proc (para1: HPROPSHEETPAGE, para2: LPARAM): WINBOOL{.
      stdcall.}
  TFNADDPROPSHEETPAGE* = LPFNADDPROPSHEETPAGE
  LPFNADDPROPSHEETPAGES* = proc (para1: LPVOID, para2: LPFNADDPROPSHEETPAGE,
                                 para3: LPARAM): WINBOOL{.stdcall.}
  TFNADDPROPSHEETPAGES* = LPFNADDPROPSHEETPAGES
  PROTOCOL_INFO* {.final, pure.} = object
    dwServiceFlags*: DWORD
    iAddressFamily*: WINT
    iMaxSockAddr*: WINT
    iMinSockAddr*: WINT
    iSocketType*: WINT
    iProtocol*: WINT
    dwMessageSize*: DWORD
    lpProtocol*: LPTSTR

  TPROTOCOLINFO* = PROTOCOL_INFO
  PPROTOCOLINFO* = ptr PROTOCOL_INFO
  PROVIDOR_INFO_1* {.final, pure.} = object
    pName*: LPTSTR
    pEnvironment*: LPTSTR
    pDLLName*: LPTSTR

  TPROVIDORINFO1* = PROVIDOR_INFO_1
  PPROVIDORINFO1* = ptr PROVIDOR_INFO_1
  PSHNOTIFY* {.final, pure.} = object
    hdr*: NMHDR
    lParam*: LPARAM

  LPPSHNOTIFY* = ptr PSHNOTIFY
  TPSHNOTIFY* = PSHNOTIFY
  PPSHNOTIFY* = ptr PSHNOTIFY
  PUNCTUATION* {.final, pure.} = object
    iSize*: UINT
    szPunctuation*: LPSTR

  Tpunctuation* = PUNCTUATION
  Ppunctuation* = ptr PUNCTUATION
  TQUERY_SERVICE_CONFIG* {.final, pure.} = object
    dwServiceType*: DWORD
    dwStartType*: DWORD
    dwErrorControl*: DWORD
    lpBinaryPathName*: LPTSTR
    lpLoadOrderGroup*: LPTSTR
    dwTagId*: DWORD
    lpDependencies*: LPTSTR
    lpServiceStartName*: LPTSTR
    lpDisplayName*: LPTSTR

  LPQUERY_SERVICE_CONFIG* = ptr TQUERY_SERVICE_CONFIG
  PQUERYSERVICECONFIG* = ptr TQUERY_SERVICE_CONFIG
  TQUERY_SERVICE_LOCK_STATUS* {.final, pure.} = object
    fIsLocked*: DWORD
    lpLockOwner*: LPTSTR
    dwLockDuration*: DWORD

  LPQUERY_SERVICE_LOCK_STATUS* = ptr TQUERY_SERVICE_LOCK_STATUS
  PQUERYSERVICELOCKSTATUS* = ptr TQUERY_SERVICE_LOCK_STATUS
  RASAMB* {.final, pure.} = object
    dwSize*: DWORD
    dwError*: DWORD
    szNetBiosError*: array[0..(NETBIOS_NAME_LEN + 1) - 1, TCHAR]
    bLana*: int8

  TRASAMB* = RASAMB
  PRASAMB* = ptr RASAMB
  RASCONN* {.final, pure.} = object
    dwSize*: DWORD
    hrasconn*: HRASCONN
    szEntryName*: array[0..(RAS_MaxEntryName + 1) - 1, TCHAR]
    szDeviceType*: array[0..(RAS_MaxDeviceType + 1) - 1, CHAR]
    szDeviceName*: array[0..(RAS_MaxDeviceName + 1) - 1, CHAR]

  TRASCONN* = RASCONN
  PRASCONN* = ptr RASCONN
  RASCONNSTATUS* {.final, pure.} = object
    dwSize*: DWORD
    rasconnstate*: RASCONNSTATE
    dwError*: DWORD
    szDeviceType*: array[0..(RAS_MaxDeviceType + 1) - 1, TCHAR]
    szDeviceName*: array[0..(RAS_MaxDeviceName + 1) - 1, TCHAR]

  TRASCONNSTATUS* = RASCONNSTATUS
  PRASCONNSTATUS* = ptr RASCONNSTATUS
  RASDIALEXTENSIONS* {.final, pure.} = object
    dwSize*: DWORD
    dwfOptions*: DWORD
    hwndParent*: HWND
    reserved*: DWORD

  TRASDIALEXTENSIONS* = RASDIALEXTENSIONS
  PRASDIALEXTENSIONS* = ptr RASDIALEXTENSIONS
  RASDIALPARAMS* {.final, pure.} = object
    dwSize*: DWORD
    szEntryName*: array[0..(RAS_MaxEntryName + 1) - 1, TCHAR]
    szPhoneNumber*: array[0..(RAS_MaxPhoneNumber + 1) - 1, TCHAR]
    szCallbackNumber*: array[0..(RAS_MaxCallbackNumber + 1) - 1, TCHAR]
    szUserName*: array[0..(UNLEN + 1) - 1, TCHAR]
    szPassword*: array[0..(PWLEN + 1) - 1, TCHAR]
    szDomain*: array[0..(DNLEN + 1) - 1, TCHAR]

  TRASDIALPARAMS* = RASDIALPARAMS
  PRASDIALPARAMS* = ptr RASDIALPARAMS
  RASENTRYNAME* {.final, pure.} = object
    dwSize*: DWORD
    szEntryName*: array[0..(RAS_MaxEntryName + 1) - 1, TCHAR]

  TRASENTRYNAME* = RASENTRYNAME
  PRASENTRYNAME* = ptr RASENTRYNAME
  RASPPPIP* {.final, pure.} = object
    dwSize*: DWORD
    dwError*: DWORD
    szIpAddress*: array[0..(RAS_MaxIpAddress + 1) - 1, TCHAR]

  TRASPPPIP* = RASPPPIP
  PRASPPPIP* = ptr RASPPPIP
  RASPPPIPX* {.final, pure.} = object
    dwSize*: DWORD
    dwError*: DWORD
    szIpxAddress*: array[0..(RAS_MaxIpxAddress + 1) - 1, TCHAR]

  TRASPPPIPX* = RASPPPIPX
  PRASPPPIPX* = ptr RASPPPIPX
  RASPPPNBF* {.final, pure.} = object
    dwSize*: DWORD
    dwError*: DWORD
    dwNetBiosError*: DWORD
    szNetBiosError*: array[0..(NETBIOS_NAME_LEN + 1) - 1, TCHAR]
    szWorkstationName*: array[0..(NETBIOS_NAME_LEN + 1) - 1, TCHAR]
    bLana*: int8

  TRASPPPNBF* = RASPPPNBF
  PRASPPPNBF* = ptr RASPPPNBF
  RASTERIZER_STATUS* {.final, pure.} = object
    nSize*: short
    wFlags*: short
    nLanguageID*: short

  LPRASTERIZER_STATUS* = ptr RASTERIZER_STATUS
  TRASTERIZERSTATUS* = RASTERIZER_STATUS
  PRASTERIZERSTATUS* = ptr RASTERIZER_STATUS
  REASSIGN_BLOCKS* {.final, pure.} = object
    Reserved*: int16
    Count*: int16
    BlockNumber*: array[0..0, DWORD]

  TREASSIGNBLOCKS* = REASSIGN_BLOCKS
  PREASSIGNBLOCKS* = ptr REASSIGN_BLOCKS
  REMOTE_NAME_INFO* {.final, pure.} = object
    lpUniversalName*: LPTSTR
    lpConnectionName*: LPTSTR
    lpRemainingPath*: LPTSTR

  TREMOTENAMEINFO* = REMOTE_NAME_INFO
  PREMOTENAMEINFO* = ptr REMOTE_NAME_INFO

  REPASTESPECIAL* {.final, pure.} = object
    dwAspect*: DWORD
    dwParam*: DWORD

  Trepastespecial* = REPASTESPECIAL
  Prepastespecial* = ptr REPASTESPECIAL
  REQRESIZE* {.final, pure.} = object
    nmhdr*: NMHDR
    rc*: RECT

  Treqresize* = REQRESIZE
  Preqresize* = ptr REQRESIZE
  RGNDATAHEADER* {.final, pure.} = object
    dwSize*: DWORD
    iType*: DWORD
    nCount*: DWORD
    nRgnSize*: DWORD
    rcBound*: RECT

  TRGNDATAHEADER* = RGNDATAHEADER
  PRGNDATAHEADER* = ptr RGNDATAHEADER
  RGNDATA* {.final, pure.} = object
    rdh*: RGNDATAHEADER
    Buffer*: array[0..0, char]

  LPRGNDATA* = ptr RGNDATA
  TRGNDATA* = RGNDATA
  PRGNDATA* = ptr RGNDATA
  SCROLLINFO* {.final, pure.} = object
    cbSize*: UINT
    fMask*: UINT
    nMin*: int32
    nMax*: int32
    nPage*: UINT
    nPos*: int32
    nTrackPos*: int32

  LPSCROLLINFO* = ptr SCROLLINFO
  LPCSCROLLINFO* = ptr SCROLLINFO
  TSCROLLINFO* = SCROLLINFO
  PSCROLLINFO* = ptr SCROLLINFO
  SECURITY_ATTRIBUTES* {.final, pure.} = object
    nLength*: DWORD
    lpSecurityDescriptor*: LPVOID
    bInheritHandle*: WINBOOL

  LPSECURITY_ATTRIBUTES* = ptr SECURITY_ATTRIBUTES
  TSECURITYATTRIBUTES* = SECURITY_ATTRIBUTES
  PSECURITYATTRIBUTES* = ptr SECURITY_ATTRIBUTES
  SECURITY_INFORMATION* = DWORD
  PSECURITY_INFORMATION* = ptr SECURITY_INFORMATION
  TSECURITYINFORMATION* = SECURITY_INFORMATION
  SELCHANGE* {.final, pure.} = object
    nmhdr*: NMHDR
    chrg*: CHARRANGE
    seltyp*: int16

  Tselchange* = SELCHANGE
  Pselchange* = ptr SELCHANGE
  SERIALKEYS* {.final, pure.} = object
    cbSize*: DWORD
    dwFlags*: DWORD
    lpszActivePort*: LPSTR
    lpszPort*: LPSTR
    iBaudRate*: DWORD
    iPortState*: DWORD

  LPSERIALKEYS* = ptr SERIALKEYS
  TSERIALKEYS* = SERIALKEYS
  PSERIALKEYS* = ptr SERIALKEYS
  SERVICE_TABLE_ENTRY* {.final, pure.} = object
    lpServiceName*: LPTSTR
    lpServiceProc*: LPSERVICE_MAIN_FUNCTION

  LPSERVICE_TABLE_ENTRY* = ptr SERVICE_TABLE_ENTRY
  TSERVICETABLEENTRY* = SERVICE_TABLE_ENTRY
  PSERVICETABLEENTRY* = ptr SERVICE_TABLE_ENTRY
  SERVICE_TYPE_VALUE_ABS* {.final, pure.} = object
    dwNameSpace*: DWORD
    dwValueType*: DWORD
    dwValueSize*: DWORD
    lpValueName*: LPTSTR
    lpValue*: PVOID

  TSERVICETYPEVALUEABS* = SERVICE_TYPE_VALUE_ABS
  PSERVICETYPEVALUEABS* = ptr SERVICE_TYPE_VALUE_ABS
  SERVICE_TYPE_INFO_ABS* {.final, pure.} = object
    lpTypeName*: LPTSTR
    dwValueCount*: DWORD
    Values*: array[0..0, SERVICE_TYPE_VALUE_ABS]

  TSERVICETYPEINFOABS* = SERVICE_TYPE_INFO_ABS
  PSERVICETYPEINFOABS* = ptr SERVICE_TYPE_INFO_ABS
  SESSION_BUFFER* {.final, pure.} = object
    lsn*: UCHAR
    state*: UCHAR
    local_name*: array[0..(NCBNAMSZ) - 1, UCHAR]
    remote_name*: array[0..(NCBNAMSZ) - 1, UCHAR]
    rcvs_outstanding*: UCHAR
    sends_outstanding*: UCHAR

  TSESSIONBUFFER* = SESSION_BUFFER
  PSESSIONBUFFER* = ptr SESSION_BUFFER
  SESSION_HEADER* {.final, pure.} = object
    sess_name*: UCHAR
    num_sess*: UCHAR
    rcv_dg_outstanding*: UCHAR
    rcv_any_outstanding*: UCHAR

  TSESSIONHEADER* = SESSION_HEADER
  PSESSIONHEADER* = ptr SESSION_HEADER
  SET_PARTITION_INFORMATION* {.final, pure.} = object
    PartitionType*: int8

  TSETPARTITIONINFORMATION* = SET_PARTITION_INFORMATION
  PSETPARTITIONINFORMATION* = ptr SET_PARTITION_INFORMATION
  SHCONTF* = enum
    SHCONTF_FOLDERS = 32, SHCONTF_NONFOLDERS = 64, SHCONTF_INCLUDEHIDDEN = 128
  TSHCONTF* = SHCONTF
  SHFILEINFO* {.final, pure.} = object
    hIcon*: HICON
    iIcon*: int32
    dwAttributes*: DWORD
    szDisplayName*: array[0..(MAX_PATH) - 1, char]
    szTypeName*: array[0..79, char]

  TSHFILEINFO* = SHFILEINFO
  PSHFILEINFO* = ptr SHFILEINFO
  FILEOP_FLAGS* = int16
  TFILEOPFLAGS* = FILEOP_FLAGS
  PFILEOPFLAGS* = ptr FILEOP_FLAGS
  SHFILEOPSTRUCT* {.final, pure.} = object
    hwnd*: HWND
    wFunc*: UINT
    pFrom*: LPCSTR
    pTo*: LPCSTR
    fFlags*: FILEOP_FLAGS
    fAnyOperationsAborted*: WINBOOL
    hNameMappings*: LPVOID
    lpszProgressTitle*: LPCSTR

  LPSHFILEOPSTRUCT* = ptr SHFILEOPSTRUCT
  TSHFILEOPSTRUCT* = SHFILEOPSTRUCT
  PSHFILEOPSTRUCT* = ptr SHFILEOPSTRUCT
  SHGNO* = enum
    SHGDN_NORMAL = 0, SHGDN_INFOLDER = 1, SHGDN_FORPARSING = 0x00008000
  TSHGDN* = SHGNO
  SHNAMEMAPPING* {.final, pure.} = object
    pszOldPath*: LPSTR
    pszNewPath*: LPSTR
    cchOldPath*: int32
    cchNewPath*: int32

  LPSHNAMEMAPPING* = ptr SHNAMEMAPPING
  TSHNAMEMAPPING* = SHNAMEMAPPING
  PSHNAMEMAPPING* = ptr SHNAMEMAPPING
  SID_AND_ATTRIBUTES* {.final, pure.} = object
    Sid*: PSID
    Attributes*: DWORD

  TSIDANDATTRIBUTES* = SID_AND_ATTRIBUTES
  PSIDANDATTRIBUTES* = ptr SID_AND_ATTRIBUTES
  SID_AND_ATTRIBUTES_ARRAY* = array[0..(ANYSIZE_ARRAY) - 1, SID_AND_ATTRIBUTES]
  PSID_AND_ATTRIBUTES_ARRAY* = ptr SID_AND_ATTRIBUTES_ARRAY
  TSIDANDATTRIBUTESARRAY* = SID_AND_ATTRIBUTES_ARRAY
  SINGLE_LIST_ENTRY* {.final, pure.} = object
    Next*: ptr SINGLE_LIST_ENTRY

  TSINGLELISTENTRY* = SINGLE_LIST_ENTRY
  PSINGLELISTENTRY* = ptr SINGLE_LIST_ENTRY
  SOUNDSENTRY* {.final, pure.} = object
    cbSize*: UINT
    dwFlags*: DWORD
    iFSTextEffect*: DWORD
    iFSTextEffectMSec*: DWORD
    iFSTextEffectColorBits*: DWORD
    iFSGrafEffect*: DWORD
    iFSGrafEffectMSec*: DWORD
    iFSGrafEffectColor*: DWORD
    iWindowsEffect*: DWORD
    iWindowsEffectMSec*: DWORD
    lpszWindowsEffectDLL*: LPTSTR
    iWindowsEffectOrdinal*: DWORD

  LPSOUNDSENTRY* = ptr SOUNDSENTRY
  TSOUNDSENTRY* = SOUNDSENTRY
  PSOUNDSENTRY* = ptr SOUNDSENTRY
  STARTUPINFO* {.final, pure.} = object
    cb*: DWORD
    lpReserved*: LPTSTR
    lpDesktop*: LPTSTR
    lpTitle*: LPTSTR
    dwX*: DWORD
    dwY*: DWORD
    dwXSize*: DWORD
    dwYSize*: DWORD
    dwXCountChars*: DWORD
    dwYCountChars*: DWORD
    dwFillAttribute*: DWORD
    dwFlags*: DWORD
    wShowWindow*: int16
    cbReserved2*: int16
    lpReserved2*: LPBYTE
    hStdInput*: HANDLE
    hStdOutput*: HANDLE
    hStdError*: HANDLE

  LPSTARTUPINFO* = ptr STARTUPINFO
  TSTARTUPINFO* = STARTUPINFO
  PSTARTUPINFO* = ptr STARTUPINFO
  STICKYKEYS* {.final, pure.} = object
    cbSize*: DWORD
    dwFlags*: DWORD

  LPSTICKYKEYS* = ptr STICKYKEYS
  TSTICKYKEYS* = STICKYKEYS
  PSTICKYKEYS* = ptr STICKYKEYS
  STRRET* {.final, pure.} = object
    uType*: UINT
    cStr*: array[0..(MAX_PATH) - 1, char]

  LPSTRRET* = ptr STRRET
  TSTRRET* = STRRET
  PSTRRET* = ptr STRRET
  STYLEBUF* {.final, pure.} = object
    dwStyle*: DWORD
    szDescription*: array[0..31, CHAR]

  LPSTYLEBUF* = ptr STYLEBUF
  TSTYLEBUF* = STYLEBUF
  PSTYLEBUF* = ptr STYLEBUF
  STYLESTRUCT* {.final, pure.} = object
    styleOld*: DWORD
    styleNew*: DWORD

  LPSTYLESTRUCT* = ptr STYLESTRUCT
  TSTYLESTRUCT* = STYLESTRUCT
  PSTYLESTRUCT* = ptr STYLESTRUCT
  SYSTEM_AUDIT_ACE* {.final, pure.} = object
    Header*: ACE_HEADER
    Mask*: ACCESS_MASK
    SidStart*: DWORD

  TSYSTEMAUDITACE* = SYSTEM_AUDIT_ACE
  PSYSTEMAUDITACE* = ptr SYSTEM_AUDIT_ACE
  SYSTEM_INFO* {.final, pure.} = object
    dwOemId*: DWORD
    dwPageSize*: DWORD
    lpMinimumApplicationAddress*: LPVOID
    lpMaximumApplicationAddress*: LPVOID
    dwActiveProcessorMask*: DWORD
    dwNumberOfProcessors*: DWORD
    dwProcessorType*: DWORD
    dwAllocationGranularity*: DWORD
    wProcessorLevel*: int16
    wProcessorRevision*: int16

  LPSYSTEM_INFO* = ptr SYSTEM_INFO
  TSYSTEMINFO* = SYSTEM_INFO
  PSYSTEMINFO* = ptr SYSTEM_INFO
  SYSTEM_POWER_STATUS* {.final, pure.} = object
    ACLineStatus*: int8
    BatteryFlag*: int8
    BatteryLifePercent*: int8
    Reserved1*: int8
    BatteryLifeTime*: DWORD
    BatteryFullLifeTime*: DWORD

  TSYSTEMPOWERSTATUS* = SYSTEM_POWER_STATUS
  PSYSTEMPOWERSTATUS* = ptr SYSTEM_POWER_STATUS
  LPSYSTEM_POWER_STATUS* = ptr emptyrecord
  TAPE_ERASE* {.final, pure.} = object
    `type`*: ULONG

  TTAPEERASE* = TAPE_ERASE
  PTAPEERASE* = ptr TAPE_ERASE
  TAPE_GET_DRIVE_PARAMETERS* {.final, pure.} = object
    ECC*: bool
    Compression*: bool
    DataPadding*: bool
    ReportSetmarks*: bool
    DefaultBlockSize*: ULONG
    MaximumBlockSize*: ULONG
    MinimumBlockSize*: ULONG
    MaximumPartitionCount*: ULONG
    FeaturesLow*: ULONG
    FeaturesHigh*: ULONG
    EOTWarningZoneSize*: ULONG

  TTAPEGETDRIVEPARAMETERS* = TAPE_GET_DRIVE_PARAMETERS
  PTAPEGETDRIVEPARAMETERS* = ptr TAPE_GET_DRIVE_PARAMETERS
  TAPE_GET_MEDIA_PARAMETERS* {.final, pure.} = object
    Capacity*: LARGE_INTEGER
    Remaining*: LARGE_INTEGER
    BlockSize*: DWORD
    PartitionCount*: DWORD
    WriteProtected*: bool

  TTAPEGETMEDIAPARAMETERS* = TAPE_GET_MEDIA_PARAMETERS
  PTAPEGETMEDIAPARAMETERS* = ptr TAPE_GET_MEDIA_PARAMETERS
  TAPE_GET_POSITION* {.final, pure.} = object
    `type`*: ULONG
    Partition*: ULONG
    OffsetLow*: ULONG
    OffsetHigh*: ULONG

  TTAPEGETPOSITION* = TAPE_GET_POSITION
  PTAPEGETPOSITION* = ptr TAPE_GET_POSITION
  TAPE_PREPARE* {.final, pure.} = object
    Operation*: ULONG

  TTAPEPREPARE* = TAPE_PREPARE
  PTAPEPREPARE* = ptr TAPE_PREPARE
  TAPE_SET_DRIVE_PARAMETERS* {.final, pure.} = object
    ECC*: bool
    Compression*: bool
    DataPadding*: bool
    ReportSetmarks*: bool
    EOTWarningZoneSize*: ULONG

  TTAPESETDRIVEPARAMETERS* = TAPE_SET_DRIVE_PARAMETERS
  PTAPESETDRIVEPARAMETERS* = ptr TAPE_SET_DRIVE_PARAMETERS
  TAPE_SET_MEDIA_PARAMETERS* {.final, pure.} = object
    BlockSize*: ULONG

  TTAPESETMEDIAPARAMETERS* = TAPE_SET_MEDIA_PARAMETERS
  PTAPESETMEDIAPARAMETERS* = ptr TAPE_SET_MEDIA_PARAMETERS
  TAPE_SET_POSITION* {.final, pure.} = object
    `Method`*: ULONG
    Partition*: ULONG
    OffsetLow*: ULONG
    OffsetHigh*: ULONG

  TTAPESETPOSITION* = TAPE_SET_POSITION
  PTAPESETPOSITION* = ptr TAPE_SET_POSITION
  TAPE_WRITE_MARKS* {.final, pure.} = object
    `type`*: ULONG
    Count*: ULONG

  TTAPEWRITEMARKS* = TAPE_WRITE_MARKS
  PTAPEWRITEMARKS* = ptr TAPE_WRITE_MARKS
  TTBADDBITMAP* {.final, pure.} = object
    hInst*: HINST
    nID*: UINT

  LPTBADDBITMAP* = ptr TTBADDBITMAP
  PTBADDBITMAP* = ptr TTBADDBITMAP
  TBBUTTON* {.final, pure.} = object
    iBitmap*: int32
    idCommand*: int32
    fsState*: int8
    fsStyle*: int8
    dwData*: DWORD
    iString*: int32

  LPTBBUTTON* = ptr TBBUTTON
  LPCTBBUTTON* = ptr TBBUTTON
  TTBBUTTON* = TBBUTTON
  PTBBUTTON* = ptr TBBUTTON
  TBNOTIFY* {.final, pure.} = object
    hdr*: NMHDR
    iItem*: int32
    tbButton*: TBBUTTON
    cchText*: int32
    pszText*: LPTSTR

  LPTBNOTIFY* = ptr TBNOTIFY
  TTBNOTIFY* = TBNOTIFY
  PTBNOTIFY* = ptr TBNOTIFY
  TBSAVEPARAMS* {.final, pure.} = object
    hkr*: HKEY
    pszSubKey*: LPCTSTR
    pszValueName*: LPCTSTR

  TTBSAVEPARAMS* = TBSAVEPARAMS
  PTBSAVEPARAMS* = ptr TBSAVEPARAMS
  TC_HITTESTINFO* {.final, pure.} = object
    pt*: POINT
    flags*: UINT

  TTCHITTESTINFO* = TC_HITTESTINFO
  PTCHITTESTINFO* = ptr TC_HITTESTINFO
  TC_ITEM* {.final, pure.} = object
    mask*: UINT
    lpReserved1*: UINT
    lpReserved2*: UINT
    pszText*: LPTSTR
    cchTextMax*: int32
    iImage*: int32
    lParam*: LPARAM

  TTCITEM* = TC_ITEM
  PTCITEM* = ptr TC_ITEM
  TC_ITEMHEADER* {.final, pure.} = object
    mask*: UINT
    lpReserved1*: UINT
    lpReserved2*: UINT
    pszText*: LPTSTR
    cchTextMax*: int32
    iImage*: int32

  TTCITEMHEADER* = TC_ITEMHEADER
  PTCITEMHEADER* = ptr TC_ITEMHEADER
  TC_KEYDOWN* {.final, pure.} = object
    hdr*: NMHDR
    wVKey*: int16
    flags*: UINT

  TTCKEYDOWN* = TC_KEYDOWN
  PTCKEYDOWN* = ptr TC_KEYDOWN
  TEXTRANGE* {.final, pure.} = object
    chrg*: CHARRANGE
    lpstrText*: LPSTR

  Ttextrange* = TEXTRANGE
  Ptextrange* = ptr TEXTRANGE
  TIME_ZONE_INFORMATION* {.final, pure.} = object
    Bias*: LONG
    StandardName*: array[0..31, WCHAR]
    StandardDate*: SYSTEMTIME
    StandardBias*: LONG
    DaylightName*: array[0..31, WCHAR]
    DaylightDate*: SYSTEMTIME
    DaylightBias*: LONG

  LPTIME_ZONE_INFORMATION* = ptr TIME_ZONE_INFORMATION
  TTIMEZONEINFORMATION* = TIME_ZONE_INFORMATION
  PTIMEZONEINFORMATION* = ptr TIME_ZONE_INFORMATION
  TOGGLEKEYS* {.final, pure.} = object
    cbSize*: DWORD
    dwFlags*: DWORD

  TTOGGLEKEYS* = TOGGLEKEYS
  PTOGGLEKEYS* = ptr TOGGLEKEYS
  TTOKEN_SOURCE* {.final, pure.} = object
    SourceName*: array[0..7, CHAR]
    SourceIdentifier*: LUID

  PTOKENSOURCE* = ptr TTOKEN_SOURCE
  TOKEN_CONTROL* {.final, pure.} = object
    TokenId*: LUID
    AuthenticationId*: LUID
    ModifiedId*: LUID
    TokenSource*: TTOKEN_SOURCE

  TTOKENCONTROL* = TOKEN_CONTROL
  PTOKENCONTROL* = ptr TOKEN_CONTROL
  TTOKEN_DEFAULT_DACL* {.final, pure.} = object
    DefaultDacl*: PACL

  PTOKENDEFAULTDACL* = ptr TTOKEN_DEFAULT_DACL
  TTOKEN_GROUPS* {.final, pure.} = object
    GroupCount*: DWORD
    Groups*: array[0..(ANYSIZE_ARRAY) - 1, SID_AND_ATTRIBUTES]

  LPTOKEN_GROUPS* = ptr TTOKEN_GROUPS
  PTOKENGROUPS* = ptr TTOKEN_GROUPS
  TTOKEN_OWNER* {.final, pure.} = object
    Owner*: PSID

  PTOKENOWNER* = ptr TTOKEN_OWNER
  TTOKEN_PRIMARY_GROUP* {.final, pure.} = object
    PrimaryGroup*: PSID

  PTOKENPRIMARYGROUP* = ptr TTOKEN_PRIMARY_GROUP
  TTOKEN_PRIVILEGES* {.final, pure.} = object
    PrivilegeCount*: DWORD
    Privileges*: array[0..(ANYSIZE_ARRAY) - 1, LUID_AND_ATTRIBUTES]

  PTOKEN_PRIVILEGES* = ptr TTOKEN_PRIVILEGES
  LPTOKEN_PRIVILEGES* = ptr TTOKEN_PRIVILEGES
  TTOKEN_STATISTICS* {.final, pure.} = object
    TokenId*: LUID
    AuthenticationId*: LUID
    ExpirationTime*: LARGE_INTEGER
    TokenType*: TTOKEN_TYPE
    ImpersonationLevel*: SECURITY_IMPERSONATION_LEVEL
    DynamicCharged*: DWORD
    DynamicAvailable*: DWORD
    GroupCount*: DWORD
    PrivilegeCount*: DWORD
    ModifiedId*: LUID

  PTOKENSTATISTICS* = ptr TTOKEN_STATISTICS
  TTOKEN_USER* {.final, pure.} = object
    User*: SID_AND_ATTRIBUTES

  PTOKENUSER* = ptr TTOKEN_USER
  TOOLINFO* {.final, pure.} = object
    cbSize*: UINT
    uFlags*: UINT
    hwnd*: HWND
    uId*: UINT
    rect*: RECT
    hinst*: HINST
    lpszText*: LPTSTR

  LPTOOLINFO* = ptr TOOLINFO
  TTOOLINFO* = TOOLINFO
  PTOOLINFO* = ptr TOOLINFO
  TOOLTIPTEXT* {.final, pure.} = object
    hdr*: NMHDR
    lpszText*: LPTSTR
    szText*: array[0..79, char]
    hinst*: HINST
    uFlags*: UINT

  LPTOOLTIPTEXT* = ptr TOOLTIPTEXT
  TTOOLTIPTEXT* = TOOLTIPTEXT
  PTOOLTIPTEXT* = ptr TOOLTIPTEXT
  TPMPARAMS* {.final, pure.} = object
    cbSize*: UINT
    rcExclude*: RECT

  LPTPMPARAMS* = ptr TPMPARAMS
  TTPMPARAMS* = TPMPARAMS
  PTPMPARAMS* = ptr TPMPARAMS
  TRANSMIT_FILE_BUFFERS* {.final, pure.} = object
    Head*: PVOID
    HeadLength*: DWORD
    Tail*: PVOID
    TailLength*: DWORD

  TTRANSMITFILEBUFFERS* = TRANSMIT_FILE_BUFFERS
  PTRANSMITFILEBUFFERS* = ptr TRANSMIT_FILE_BUFFERS
  TTHITTESTINFO* {.final, pure.} = object
    hwnd*: HWND
    pt*: POINT
    ti*: TOOLINFO

  LPHITTESTINFO* = ptr TTHITTESTINFO
  TTTHITTESTINFO* = TTHITTESTINFO
  PTTHITTESTINFO* = ptr TTHITTESTINFO
  TTPOLYCURVE* {.final, pure.} = object
    wType*: int16
    cpfx*: int16
    apfx*: array[0..0, POINTFX]

  LPTTPOLYCURVE* = ptr TTPOLYCURVE
  TTTPOLYCURVE* = TTPOLYCURVE
  PTTPOLYCURVE* = ptr TTPOLYCURVE
  TTPOLYGONHEADER* {.final, pure.} = object
    cb*: DWORD
    dwType*: DWORD
    pfxStart*: POINTFX

  LPTTPOLYGONHEADER* = ptr TTPOLYGONHEADER
  TTTPOLYGONHEADER* = TTPOLYGONHEADER
  PTTPOLYGONHEADER* = ptr TTPOLYGONHEADER
  TV_DISPINFO* {.final, pure.} = object
    hdr*: NMHDR
    item*: TV_ITEM

  TTVDISPINFO* = TV_DISPINFO
  PTVDISPINFO* = ptr TV_DISPINFO
  TV_HITTESTINFO* {.final, pure.} = object
    pt*: POINT
    flags*: UINT
    hItem*: HTREEITEM

  LPTV_HITTESTINFO* = ptr TV_HITTESTINFO
  TTVHITTESTINFO* = TV_HITTESTINFO
  PTVHITTESTINFO* = ptr TV_HITTESTINFO
  TV_INSERTSTRUCT* {.final, pure.} = object
    hParent*: HTREEITEM
    hInsertAfter*: HTREEITEM
    item*: TV_ITEM

  LPTV_INSERTSTRUCT* = ptr TV_INSERTSTRUCT
  TTVINSERTSTRUCT* = TV_INSERTSTRUCT
  PTVINSERTSTRUCT* = ptr TV_INSERTSTRUCT
  TV_KEYDOWN* {.final, pure.} = object
    hdr*: NMHDR
    wVKey*: int16
    flags*: UINT

  TTVKEYDOWN* = TV_KEYDOWN
  PTVKEYDOWN* = ptr TV_KEYDOWN
  TV_SORTCB* {.final, pure.} = object
    hParent*: HTREEITEM
    lpfnCompare*: PFNTVCOMPARE
    lParam*: LPARAM

  LPTV_SORTCB* = ptr TV_SORTCB
  TTVSORTCB* = TV_SORTCB
  PTVSORTCB* = ptr TV_SORTCB
  UDACCEL* {.final, pure.} = object
    nSec*: UINT
    nInc*: UINT

  TUDACCEL* = UDACCEL
  PUDACCEL* = ptr UDACCEL
  UNIVERSAL_NAME_INFO* {.final, pure.} = object
    lpUniversalName*: LPTSTR

  TUNIVERSALNAMEINFO* = UNIVERSAL_NAME_INFO
  PUNIVERSALNAMEINFO* = ptr UNIVERSAL_NAME_INFO
  USEROBJECTFLAGS* {.final, pure.} = object
    fInherit*: WINBOOL
    fReserved*: WINBOOL
    dwFlags*: DWORD

  TUSEROBJECTFLAGS* = USEROBJECTFLAGS
  PUSEROBJECTFLAGS* = ptr USEROBJECTFLAGS
  VALENT* {.final, pure.} = object
    ve_valuename*: LPTSTR
    ve_valuelen*: DWORD
    ve_valueptr*: DWORD
    ve_type*: DWORD

  TVALENT* = VALENT
  PVALENT* = ptr VALENT
  value_ent* = VALENT
  Tvalue_ent* = VALENT
  Pvalue_ent* = ptr VALENT
  VERIFY_INFORMATION* {.final, pure.} = object
    StartingOffset*: LARGE_INTEGER
    len*: DWORD

  TVERIFYINFORMATION* = VERIFY_INFORMATION
  PVERIFYINFORMATION* = ptr VERIFY_INFORMATION
  VS_FIXEDFILEINFO* {.final, pure.} = object
    dwSignature*: DWORD
    dwStrucVersion*: DWORD
    dwFileVersionMS*: DWORD
    dwFileVersionLS*: DWORD
    dwProductVersionMS*: DWORD
    dwProductVersionLS*: DWORD
    dwFileFlagsMask*: DWORD
    dwFileFlags*: DWORD
    dwFileOS*: DWORD
    dwFileType*: DWORD
    dwFileSubtype*: DWORD
    dwFileDateMS*: DWORD
    dwFileDateLS*: DWORD

  TVSFIXEDFILEINFO* = VS_FIXEDFILEINFO
  PVSFIXEDFILEINFO* = ptr VS_FIXEDFILEINFO
  WIN32_FIND_DATA* {.final, pure.} = object
    dwFileAttributes*: DWORD
    ftCreationTime*: FILETIME
    ftLastAccessTime*: FILETIME
    ftLastWriteTime*: FILETIME
    nFileSizeHigh*: DWORD
    nFileSizeLow*: DWORD
    dwReserved0*: DWORD
    dwReserved1*: DWORD
    cFileName*: array[0..(MAX_PATH) - 1, TCHAR]
    cAlternateFileName*: array[0..13, TCHAR]

  LPWIN32_FIND_DATA* = ptr WIN32_FIND_DATA
  PWIN32_FIND_DATA* = ptr WIN32_FIND_DATA
  TWIN32FINDDATA* = WIN32_FIND_DATA
  TWIN32FINDDATAA* = WIN32_FIND_DATA
  WIN32_FIND_DATAW* {.final, pure.} = object
    dwFileAttributes*: DWORD
    ftCreationTime*: FILETIME
    ftLastAccessTime*: FILETIME
    ftLastWriteTime*: FILETIME
    nFileSizeHigh*: DWORD
    nFileSizeLow*: DWORD
    dwReserved0*: DWORD
    dwReserved1*: DWORD
    cFileName*: array[0..(MAX_PATH) - 1, WCHAR]
    cAlternateFileName*: array[0..13, WCHAR]

  LPWIN32_FIND_DATAW* = ptr WIN32_FIND_DATAW
  PWIN32_FIND_DATAW* = ptr WIN32_FIND_DATAW
  TWIN32FINDDATAW* = WIN32_FIND_DATAW
  WIN32_STREAM_ID* {.final, pure.} = object
    dwStreamId*: DWORD
    dwStreamAttributes*: DWORD
    Size*: LARGE_INTEGER
    dwStreamNameSize*: DWORD
    cStreamName*: ptr WCHAR

  TWIN32STREAMID* = WIN32_STREAM_ID
  PWIN32STREAMID* = ptr WIN32_STREAM_ID
  WINDOWPLACEMENT* {.final, pure.} = object
    len*: UINT
    flags*: UINT
    showCmd*: UINT
    ptMinPosition*: POINT
    ptMaxPosition*: POINT
    rcNormalPosition*: RECT

  TWINDOWPLACEMENT* = WINDOWPLACEMENT
  PWINDOWPLACEMENT* = ptr WINDOWPLACEMENT
  WNDCLASS* {.final, pure.} = object
    style*: UINT
    lpfnWndProc*: WNDPROC
    cbClsExtra*: int32
    cbWndExtra*: int32
    hInstance*: HANDLE
    hIcon*: HICON
    hCursor*: HCURSOR
    hbrBackground*: HBRUSH
    lpszMenuName*: LPCTSTR
    lpszClassName*: LPCTSTR

  LPWNDCLASS* = ptr WNDCLASS
  TWNDCLASS* = WNDCLASS
  TWNDCLASSA* = WNDCLASS
  PWNDCLASS* = ptr WNDCLASS
  WNDCLASSW* {.final, pure.} = object
    style*: UINT
    lpfnWndProc*: WNDPROC
    cbClsExtra*: int32
    cbWndExtra*: int32
    hInstance*: HANDLE
    hIcon*: HICON
    hCursor*: HCURSOR
    hbrBackground*: HBRUSH
    lpszMenuName*: LPCWSTR
    lpszClassName*: LPCWSTR

  LPWNDCLASSW* = ptr WNDCLASSW
  TWNDCLASSW* = WNDCLASSW
  PWNDCLASSW* = ptr WNDCLASSW
  WNDCLASSEX* {.final, pure.} = object
    cbSize*: UINT
    style*: UINT
    lpfnWndProc*: WNDPROC
    cbClsExtra*: int32
    cbWndExtra*: int32
    hInstance*: HANDLE
    hIcon*: HICON
    hCursor*: HCURSOR
    hbrBackground*: HBRUSH
    lpszMenuName*: LPCTSTR
    lpszClassName*: LPCTSTR
    hIconSm*: HANDLE

  LPWNDCLASSEX* = ptr WNDCLASSEX
  TWNDCLASSEX* = WNDCLASSEX
  TWNDCLASSEXA* = WNDCLASSEX
  PWNDCLASSEX* = ptr WNDCLASSEX
  WNDCLASSEXW* {.final, pure.} = object
    cbSize*: UINT
    style*: UINT
    lpfnWndProc*: WNDPROC
    cbClsExtra*: int32
    cbWndExtra*: int32
    hInstance*: HANDLE
    hIcon*: HICON
    hCursor*: HCURSOR
    hbrBackground*: HBRUSH
    lpszMenuName*: LPCWSTR
    lpszClassName*: LPCWSTR
    hIconSm*: HANDLE

  LPWNDCLASSEXW* = ptr WNDCLASSEXW
  TWNDCLASSEXW* = WNDCLASSEXW
  PWNDCLASSEXW* = ptr WNDCLASSEXW
  CONNECTDLGSTRUCT* {.final, pure.} = object
    cbStructure*: DWORD
    hwndOwner*: HWND
    lpConnRes*: LPNETRESOURCE
    dwFlags*: DWORD
    dwDevNum*: DWORD

  LPCONNECTDLGSTRUCT* = ptr CONNECTDLGSTRUCT
  TCONNECTDLGSTRUCT* = CONNECTDLGSTRUCT
  PCONNECTDLGSTRUCT* = ptr CONNECTDLGSTRUCT
  DISCDLGSTRUCT* {.final, pure.} = object
    cbStructure*: DWORD
    hwndOwner*: HWND
    lpLocalName*: LPTSTR
    lpRemoteName*: LPTSTR
    dwFlags*: DWORD

  LPDISCDLGSTRUCT* = ptr DISCDLGSTRUCT
  TDISCDLGSTRUCT* = DISCDLGSTRUCT
  TDISCDLGSTRUCTA* = DISCDLGSTRUCT
  PDISCDLGSTRUCT* = ptr DISCDLGSTRUCT
  NETINFOSTRUCT* {.final, pure.} = object
    cbStructure*: DWORD
    dwProviderVersion*: DWORD
    dwStatus*: DWORD
    dwCharacteristics*: DWORD
    dwHandle*: DWORD
    wNetType*: int16
    dwPrinters*: DWORD
    dwDrives*: DWORD

  LPNETINFOSTRUCT* = ptr NETINFOSTRUCT
  TNETINFOSTRUCT* = NETINFOSTRUCT
  PNETINFOSTRUCT* = ptr NETINFOSTRUCT
  NETCONNECTINFOSTRUCT* {.final, pure.} = object
    cbStructure*: DWORD
    dwFlags*: DWORD
    dwSpeed*: DWORD
    dwDelay*: DWORD
    dwOptDataSize*: DWORD

  LPNETCONNECTINFOSTRUCT* = ptr NETCONNECTINFOSTRUCT
  TNETCONNECTINFOSTRUCT* = NETCONNECTINFOSTRUCT
  PNETCONNECTINFOSTRUCT* = ptr NETCONNECTINFOSTRUCT
  ENUMMETAFILEPROC* = proc (para1: HDC, para2: HANDLETABLE, para3: METARECORD,
                            para4: int32, para5: LPARAM): int32{.stdcall.}
  ENHMETAFILEPROC* = proc (para1: HDC, para2: HANDLETABLE, para3: TENHMETARECORD,
                           para4: int32, para5: LPARAM): int32{.stdcall.}
  ENUMFONTSPROC* = proc (para1: LPLOGFONT, para2: LPTEXTMETRIC, para3: DWORD,
                         para4: LPARAM): int32{.stdcall.}
  FONTENUMPROC* = proc (para1: var ENUMLOGFONT, para2: var NEWTEXTMETRIC,
                        para3: int32, para4: LPARAM): int32{.stdcall.}
  FONTENUMEXPROC* = proc (para1: var ENUMLOGFONTEX, para2: var NEWTEXTMETRICEX,
                          para3: int32, para4: LPARAM): int32{.stdcall.}
  LPOVERLAPPED_COMPLETION_ROUTINE* = proc (para1: DWORD, para2: DWORD,
      para3: LPOVERLAPPED){.stdcall.}
  # Structures for the extensions to OpenGL
  POINTFLOAT* {.final, pure.} = object
    x*: float32
    y*: float32

  TPOINTFLOAT* = POINTFLOAT
  PPOINTFLOAT* = ptr POINTFLOAT
  GLYPHMETRICSFLOAT* {.final, pure.} = object
    gmfBlackBoxX*: float32
    gmfBlackBoxY*: float32
    gmfptGlyphOrigin*: POINTFLOAT
    gmfCellIncX*: float32
    gmfCellIncY*: float32

  LPGLYPHMETRICSFLOAT* = ptr GLYPHMETRICSFLOAT
  TGLYPHMETRICSFLOAT* = GLYPHMETRICSFLOAT
  PGLYPHMETRICSFLOAT* = ptr GLYPHMETRICSFLOAT
  LAYERPLANEDESCRIPTOR* {.final, pure.} = object
    nSize*: int16
    nVersion*: int16
    dwFlags*: DWORD
    iPixelType*: int8
    cColorBits*: int8
    cRedBits*: int8
    cRedShift*: int8
    cGreenBits*: int8
    cGreenShift*: int8
    cBlueBits*: int8
    cBlueShift*: int8
    cAlphaBits*: int8
    cAlphaShift*: int8
    cAccumBits*: int8
    cAccumRedBits*: int8
    cAccumGreenBits*: int8
    cAccumBlueBits*: int8
    cAccumAlphaBits*: int8
    cDepthBits*: int8
    cStencilBits*: int8
    cAuxBuffers*: int8
    iLayerPlane*: int8
    bReserved*: int8
    crTransparent*: COLORREF

  LPLAYERPLANEDESCRIPTOR* = ptr LAYERPLANEDESCRIPTOR
  TLAYERPLANEDESCRIPTOR* = LAYERPLANEDESCRIPTOR
  PLAYERPLANEDESCRIPTOR* = ptr LAYERPLANEDESCRIPTOR
  PIXELFORMATDESCRIPTOR* {.final, pure.} = object
    nSize*: int16
    nVersion*: int16
    dwFlags*: DWORD
    iPixelType*: int8
    cColorBits*: int8
    cRedBits*: int8
    cRedShift*: int8
    cGreenBits*: int8
    cGreenShift*: int8
    cBlueBits*: int8
    cBlueShift*: int8
    cAlphaBits*: int8
    cAlphaShift*: int8
    cAccumBits*: int8
    cAccumRedBits*: int8
    cAccumGreenBits*: int8
    cAccumBlueBits*: int8
    cAccumAlphaBits*: int8
    cDepthBits*: int8
    cStencilBits*: int8
    cAuxBuffers*: int8
    iLayerType*: int8
    bReserved*: int8
    dwLayerMask*: DWORD
    dwVisibleMask*: DWORD
    dwDamageMask*: DWORD

  LPPIXELFORMATDESCRIPTOR* = ptr PIXELFORMATDESCRIPTOR
  TPIXELFORMATDESCRIPTOR* = PIXELFORMATDESCRIPTOR
  PPIXELFORMATDESCRIPTOR* = ptr PIXELFORMATDESCRIPTOR
  USER_INFO_2* {.final, pure.} = object
    usri2_name*: LPWSTR
    usri2_password*: LPWSTR
    usri2_password_age*: DWORD
    usri2_priv*: DWORD
    usri2_home_dir*: LPWSTR
    usri2_comment*: LPWSTR
    usri2_flags*: DWORD
    usri2_script_path*: LPWSTR
    usri2_auth_flags*: DWORD
    usri2_full_name*: LPWSTR
    usri2_usr_comment*: LPWSTR
    usri2_parms*: LPWSTR
    usri2_workstations*: LPWSTR
    usri2_last_logon*: DWORD
    usri2_last_logoff*: DWORD
    usri2_acct_expires*: DWORD
    usri2_max_storage*: DWORD
    usri2_units_per_week*: DWORD
    usri2_logon_hours*: PBYTE
    usri2_bad_pw_count*: DWORD
    usri2_num_logons*: DWORD
    usri2_logon_server*: LPWSTR
    usri2_country_code*: DWORD
    usri2_code_page*: DWORD

  PUSER_INFO_2* = ptr USER_INFO_2
  LPUSER_INFO_2* = ptr USER_INFO_2
  TUSERINFO2* = USER_INFO_2
  USER_INFO_0* {.final, pure.} = object
    usri0_name*: LPWSTR

  PUSER_INFO_0* = ptr USER_INFO_0
  LPUSER_INFO_0* = ptr USER_INFO_0
  TUSERINFO0* = USER_INFO_0
  USER_INFO_3* {.final, pure.} = object
    usri3_name*: LPWSTR
    usri3_password*: LPWSTR
    usri3_password_age*: DWORD
    usri3_priv*: DWORD
    usri3_home_dir*: LPWSTR
    usri3_comment*: LPWSTR
    usri3_flags*: DWORD
    usri3_script_path*: LPWSTR
    usri3_auth_flags*: DWORD
    usri3_full_name*: LPWSTR
    usri3_usr_comment*: LPWSTR
    usri3_parms*: LPWSTR
    usri3_workstations*: LPWSTR
    usri3_last_logon*: DWORD
    usri3_last_logoff*: DWORD
    usri3_acct_expires*: DWORD
    usri3_max_storage*: DWORD
    usri3_units_per_week*: DWORD
    usri3_logon_hours*: PBYTE
    usri3_bad_pw_count*: DWORD
    usri3_num_logons*: DWORD
    usri3_logon_server*: LPWSTR
    usri3_country_code*: DWORD
    usri3_code_page*: DWORD
    usri3_user_id*: DWORD
    usri3_primary_group_id*: DWORD
    usri3_profile*: LPWSTR
    usri3_home_dir_drive*: LPWSTR
    usri3_password_expired*: DWORD

  PUSER_INFO_3* = ptr USER_INFO_3
  LPUSER_INFO_3* = ptr USER_INFO_3
  TUSERINFO3* = USER_INFO_3
  GROUP_INFO_2* {.final, pure.} = object
    grpi2_name*: LPWSTR
    grpi2_comment*: LPWSTR
    grpi2_group_id*: DWORD
    grpi2_attributes*: DWORD

  PGROUP_INFO_2* = ptr GROUP_INFO_2
  TGROUPINFO2* = GROUP_INFO_2
  LOCALGROUP_INFO_0* {.final, pure.} = object
    lgrpi0_name*: LPWSTR

  PLOCALGROUP_INFO_0* = ptr LOCALGROUP_INFO_0
  LPLOCALGROUP_INFO_0* = ptr LOCALGROUP_INFO_0
  TLOCALGROUPINFO0* = LOCALGROUP_INFO_0
  IMAGE_DOS_HEADER* {.final, pure.} = object
    e_magic*: int16
    e_cblp*: int16
    e_cp*: int16
    e_crlc*: int16
    e_cparhdr*: int16
    e_minalloc*: int16
    e_maxalloc*: int16
    e_ss*: int16
    e_sp*: int16
    e_csum*: int16
    e_ip*: int16
    e_cs*: int16
    e_lfarlc*: int16
    e_ovno*: int16
    e_res*: array[0..3, int16]
    e_oemid*: int16
    e_oeminfo*: int16
    e_res2*: array[0..9, int16]
    e_lfanew*: LONG

  PIMAGE_DOS_HEADER* = ptr IMAGE_DOS_HEADER
  TIMAGEDOSHEADER* = IMAGE_DOS_HEADER
  NOTIFYICONDATAA* {.final, pure.} = object
    cbSize*: DWORD
    Wnd*: HWND
    uID*: UINT
    uFlags*: UINT
    uCallbackMessage*: UINT
    hIcon*: HICON
    szTip*: array[0..63, Char]

  NOTIFYICONDATA* = NOTIFYICONDATAA
  NOTIFYICONDATAW* {.final, pure.} = object
    cbSize*: DWORD
    Wnd*: HWND
    uID*: UINT
    uFlags*: UINT
    uCallbackMessage*: UINT
    hIcon*: HICON
    szTip*: array[0..63, int16]

  TNotifyIconDataA* = NOTIFYICONDATAA
  TNotifyIconDataW* = NOTIFYICONDATAW
  TNotifyIconData* = TNotifyIconDataA
  PNotifyIconDataA* = ptr TNotifyIconDataA
  PNotifyIconDataW* = ptr TNotifyIconDataW
  PNotifyIconData* = PNotifyIconDataA
  TWOHandleArray* = array[0..MAXIMUM_WAIT_OBJECTS - 1, HANDLE]
  PWOHandleArray* = ptr TWOHandleArray
  MMRESULT* = int32

type
  PWaveFormatEx* = ptr TWaveFormatEx
  TWaveFormatEx* {.final, pure.} = object
    wFormatTag*: int16        # format type
    nChannels*: int16         # number of channels (i.e. mono, stereo, etc.)
    nSamplesPerSec*: DWORD    # sample rate
    nAvgBytesPerSec*: DWORD   # for buffer estimation
    nBlockAlign*: int16       # block size of data
    wBitsPerSample*: int16    # number of bits per sample of mono data
    cbSize*: int16            # the count in bytes of the size of

  WIN32_FILE_ATTRIBUTE_DATA* {.final, pure.} = object
    dwFileAttributes*: DWORD
    ftCreationTime*: FILETIME
    ftLastAccessTime*: FILETIME
    ftLastWriteTime*: FILETIME
    nFileSizeHigh*: DWORD
    nFileSizeLow*: DWORD

  LPWIN32_FILE_ATTRIBUTE_DATA* = ptr WIN32_FILE_ATTRIBUTE_DATA
  TWIN32FILEATTRIBUTEDATA* = WIN32_FILE_ATTRIBUTE_DATA
  PWIN32FILEATTRIBUTEDATA* = ptr WIN32_FILE_ATTRIBUTE_DATA
  # TrackMouseEvent. NT or higher only.
  TTrackMouseEvent* {.final, pure.} = object
    cbSize*: DWORD
    dwFlags*: DWORD
    hwndTrack*: HWND
    dwHoverTime*: DWORD

  PTrackMouseEvent* = ptr TTrackMouseEvent

const
  ACM_OPENW* = 1127
  ACM_OPENA* = 1124

when defined(winUnicode):
  const
    ACM_OPEN* = ACM_OPENW
else:
  const
    ACM_OPEN* = ACM_OPENA
# UNICODE

const
  ACM_PLAY* = 1125
  ACM_STOP* = 1126
  ACN_START* = 1
  ACN_STOP* = 2
  # Buttons
  BM_CLICK* = 245
  BM_GETCHECK* = 240
  BM_GETIMAGE* = 246
  BM_GETSTATE* = 242
  BM_SETCHECK* = 241
  BM_SETIMAGE* = 247
  BM_SETSTATE* = 243
  BM_SETSTYLE* = 244
  BN_CLICKED* = 0
  BN_DBLCLK* = 5
  BN_DISABLE* = 4
  BN_DOUBLECLICKED* = 5
  BN_HILITE* = 2
  BN_KILLFOCUS* = 7
  BN_PAINT* = 1
  BN_PUSHED* = 2
  BN_SETFOCUS* = 6
  BN_UNHILITE* = 3
  BN_UNPUSHED* = 3
  # Combo Box
  CB_ADDSTRING* = 323
  CB_DELETESTRING* = 324
  CB_DIR* = 325
  CB_FINDSTRING* = 332
  CB_FINDSTRINGEXACT* = 344
  CB_GETCOUNT* = 326
  CB_GETCURSEL* = 327
  CB_GETDROPPEDCONTROLRECT* = 338
  CB_GETDROPPEDSTATE* = 343
  CB_GETDROPPEDWIDTH* = 351
  CB_GETEDITSEL* = 320
  CB_GETEXTENDEDUI* = 342
  CB_GETHORIZONTALEXTENT* = 349
  CB_GETITEMDATA* = 336
  CB_GETITEMHEIGHT* = 340
  CB_GETLBTEXT* = 328
  CB_GETLBTEXTLEN* = 329
  CB_GETLOCALE* = 346
  CB_GETTOPINDEX* = 347
  CB_INITSTORAGE* = 353
  CB_INSERTSTRING* = 330
  CB_LIMITTEXT* = 321
  CB_RESETCONTENT* = 331
  CB_SELECTSTRING* = 333
  CB_SETCURSEL* = 334
  CB_SETDROPPEDWIDTH* = 352
  CB_SETEDITSEL* = 322
  CB_SETEXTENDEDUI* = 341
  CB_SETHORIZONTALEXTENT* = 350
  CB_SETITEMDATA* = 337
  CB_SETITEMHEIGHT* = 339
  CB_SETLOCALE* = 345
  CB_SETTOPINDEX* = 348
  CB_SHOWDROPDOWN* = 335
  # Combo Box notifications
  CBN_CLOSEUP* = 8
  CBN_DBLCLK* = 2
  CBN_DROPDOWN* = 7
  CBN_EDITCHANGE* = 5
  CBN_EDITUPDATE* = 6
  CBN_ERRSPACE* = -1
  CBN_KILLFOCUS* = 4
  CBN_SELCHANGE* = 1
  CBN_SELENDCANCEL* = 10
  CBN_SELENDOK* = 9
  CBN_SETFOCUS* = 3
  # Control Panel
  # Device messages
  # Drag list box
  DL_BEGINDRAG* = 1157
  DL_CANCELDRAG* = 1160
  DL_DRAGGING* = 1158
  DL_DROPPED* = 1159
  # Default push button
  DM_GETDEFID* = 1024
  DM_REPOSITION* = 1026
  DM_SETDEFID* = 1025
  # RTF control
  EM_CANPASTE* = 1074
  EM_CANUNDO* = 198
  EM_CHARFROMPOS* = 215
  EM_DISPLAYBAND* = 1075
  EM_EMPTYUNDOBUFFER* = 205
  EM_EXGETSEL* = 1076
  EM_EXLIMITTEXT* = 1077
  EM_EXLINEFROMCHAR* = 1078
  EM_EXSETSEL* = 1079
  EM_FINDTEXT* = 1080
  EM_FINDTEXTEX* = 1103
  EM_FINDWORDBREAK* = 1100
  EM_FMTLINES* = 200
  EM_FORMATRANGE* = 1081
  EM_GETCHARFORMAT* = 1082
  EM_GETEVENTMASK* = 1083
  EM_GETFIRSTVISIBLELINE* = 206
  EM_GETHANDLE* = 189
  EM_GETLIMITTEXT* = 213
  EM_GETLINE* = 196
  EM_GETLINECOUNT* = 186
  EM_GETMARGINS* = 212
  EM_GETMODIFY* = 184
  EM_GETIMECOLOR* = 1129
  EM_GETIMEOPTIONS* = 1131
  EM_GETOPTIONS* = 1102
  EM_GETOLEINTERFACE* = 1084
  EM_GETPARAFORMAT* = 1085
  EM_GETPASSWORDCHAR* = 210
  EM_GETPUNCTUATION* = 1125
  EM_GETRECT* = 178
  EM_GETSEL* = 176
  EM_GETSELTEXT* = 1086
  EM_GETTEXTRANGE* = 1099
  EM_GETTHUMB* = 190
  EM_GETWORDBREAKPROC* = 209
  EM_GETWORDBREAKPROCEX* = 1104
  EM_GETWORDWRAPMODE* = 1127
  EM_HIDESELECTION* = 1087
  EM_LIMITTEXT* = 197
  EM_LINEFROMCHAR* = 201
  EM_LINEINDEX* = 187
  EM_LINELENGTH* = 193
  EM_LINESCROLL* = 182
  EM_PASTESPECIAL* = 1088
  EM_POSFROMCHAR* = 214
  EM_REPLACESEL* = 194
  EM_REQUESTRESIZE* = 1089
  EM_SCROLL* = 181
  EM_SCROLLCARET* = 183
  EM_SELECTIONTYPE* = 1090
  EM_SETBKGNDCOLOR* = 1091
  EM_SETCHARFORMAT* = 1092
  EM_SETEVENTMASK* = 1093
  EM_SETHANDLE* = 188
  EM_SETIMECOLOR* = 1128
  EM_SETIMEOPTIONS* = 1130
  EM_SETLIMITTEXT* = 197
  EM_SETMARGINS* = 211
  EM_SETMODIFY* = 185
  EM_SETOLECALLBACK* = 1094
  EM_SETOPTIONS* = 1101
  EM_SETPARAFORMAT* = 1095
  EM_SETPASSWORDCHAR* = 204
  EM_SETPUNCTUATION* = 1124
  EM_SETREADONLY* = 207
  EM_SETRECT* = 179
  EM_SETRECTNP* = 180
  EM_SETSEL* = 177
  EM_SETTABSTOPS* = 203
  EM_SETTARGETDEVICE* = 1096
  EM_SETWORDBREAKPROC* = 208
  EM_SETWORDBREAKPROCEX* = 1105
  EM_SETWORDWRAPMODE* = 1126
  EM_STREAMIN* = 1097
  EM_STREAMOUT* = 1098
  EM_UNDO* = 199
  # Edit control
  EN_CHANGE* = 768
  EN_CORRECTTEXT* = 1797
  EN_DROPFILES* = 1795
  EN_ERRSPACE* = 1280
  EN_HSCROLL* = 1537
  EN_IMECHANGE* = 1799
  EN_KILLFOCUS* = 512
  EN_MAXTEXT* = 1281
  EN_MSGFILTER* = 1792
  EN_OLEOPFAILED* = 1801
  EN_PROTECTED* = 1796
  EN_REQUESTRESIZE* = 1793
  EN_SAVECLIPBOARD* = 1800
  EN_SELCHANGE* = 1794
  EN_SETFOCUS* = 256
  EN_STOPNOUNDO* = 1798
  EN_UPDATE* = 1024
  EN_VSCROLL* = 1538
  # File Manager extensions
  # File Manager extensions DLL events
  # Header control
  HDM_DELETEITEM* = 4610
  HDM_GETITEMW* = 4619
  HDM_INSERTITEMW* = 4618
  HDM_SETITEMW* = 4620
  HDM_GETITEMA* = 4611
  HDM_INSERTITEMA* = 4609
  HDM_SETITEMA* = 4612

when defined(winUnicode):
  const
    HDM_GETITEM* = HDM_GETITEMW
    HDM_INSERTITEM* = HDM_INSERTITEMW
    HDM_SETITEM* = HDM_SETITEMW
else:
  const
    HDM_GETITEM* = HDM_GETITEMA
    HDM_INSERTITEM* = HDM_INSERTITEMA
    HDM_SETITEM* = HDM_SETITEMA
# UNICODE

const
  HDM_GETITEMCOUNT* = 4608
  HDM_HITTEST* = 4614
  HDM_LAYOUT* = 4613
  # Header control notifications
  HDN_BEGINTRACKW* = -326
  HDN_DIVIDERDBLCLICKW* = -325
  HDN_ENDTRACKW* = -327
  HDN_ITEMCHANGEDW* = -321
  HDN_ITEMCHANGINGW* = -320
  HDN_ITEMCLICKW* = -322
  HDN_ITEMDBLCLICKW* = -323
  HDN_TRACKW* = -328
  HDN_BEGINTRACKA* = -306
  HDN_DIVIDERDBLCLICKA* = -305
  HDN_ENDTRACKA* = -307
  HDN_ITEMCHANGEDA* = -301
  HDN_ITEMCHANGINGA* = -300
  HDN_ITEMCLICKA* = -302
  HDN_ITEMDBLCLICKA* = -303
  HDN_TRACKA* = -308

when defined(winUnicode):
  const
    HDN_BEGINTRACK* = HDN_BEGINTRACKW
    HDN_DIVIDERDBLCLICK* = HDN_DIVIDERDBLCLICKW
    HDN_ENDTRACK* = HDN_ENDTRACKW
    HDN_ITEMCHANGED* = HDN_ITEMCHANGEDW
    HDN_ITEMCHANGING* = HDN_ITEMCHANGINGW
    HDN_ITEMCLICK* = HDN_ITEMCLICKW
    HDN_ITEMDBLCLICK* = HDN_ITEMDBLCLICKW
    HDN_TRACK* = HDN_TRACKW
else:
  const
    HDN_BEGINTRACK* = HDN_BEGINTRACKA
    HDN_DIVIDERDBLCLICK* = HDN_DIVIDERDBLCLICKA
    HDN_ENDTRACK* = HDN_ENDTRACKA
    HDN_ITEMCHANGED* = HDN_ITEMCHANGEDA
    HDN_ITEMCHANGING* = HDN_ITEMCHANGINGA
    HDN_ITEMCLICK* = HDN_ITEMCLICKA
    HDN_ITEMDBLCLICK* = HDN_ITEMDBLCLICKA
    HDN_TRACK* = HDN_TRACKA
# UNICODE

const
  # Hot key control
  HKM_GETHOTKEY* = 1026
  HKM_SETHOTKEY* = 1025
  HKM_SETRULES* = 1027
  # List box
  LB_ADDFILE* = 406
  LB_ADDSTRING* = 384
  LB_DELETESTRING* = 386
  LB_DIR* = 397
  LB_FINDSTRING* = 399
  LB_FINDSTRINGEXACT* = 418
  LB_GETANCHORINDEX* = 413
  LB_GETCARETINDEX* = 415
  LB_GETCOUNT* = 395
  LB_GETCURSEL* = 392
  LB_GETHORIZONTALEXTENT* = 403
  LB_GETITEMDATA* = 409
  LB_GETITEMHEIGHT* = 417
  LB_GETITEMRECT* = 408
  LB_GETLOCALE* = 422
  LB_GETSEL* = 391
  LB_GETSELCOUNT* = 400
  LB_GETSELITEMS* = 401
  LB_GETTEXT* = 393
  LB_GETTEXTLEN* = 394
  LB_GETTOPINDEX* = 398
  LB_INITSTORAGE* = 424
  LB_INSERTSTRING* = 385
  LB_ITEMFROMPOINT* = 425
  LB_RESETCONTENT* = 388
  LB_SELECTSTRING* = 396
  LB_SELITEMRANGE* = 411
  LB_SELITEMRANGEEX* = 387
  LB_SETANCHORINDEX* = 412
  LB_SETCARETINDEX* = 414
  LB_SETCOLUMNWIDTH* = 405
  LB_SETCOUNT* = 423
  LB_SETCURSEL* = 390
  LB_SETHORIZONTALEXTENT* = 404
  LB_SETITEMDATA* = 410
  LB_SETITEMHEIGHT* = 416
  LB_SETLOCALE* = 421
  LB_SETSEL* = 389
  LB_SETTABSTOPS* = 402
  LB_SETTOPINDEX* = 407
  # List box notifications
  LBN_DBLCLK* = 2
  LBN_ERRSPACE* = -2
  LBN_KILLFOCUS* = 5
  LBN_SELCANCEL* = 3
  LBN_SELCHANGE* = 1
  LBN_SETFOCUS* = 4
  # List view control
  LVM_ARRANGE* = 4118
  LVM_CREATEDRAGIMAGE* = 4129
  LVM_DELETEALLITEMS* = 4105
  LVM_DELETECOLUMN* = 4124
  LVM_DELETEITEM* = 4104
  LVM_ENSUREVISIBLE* = 4115
  LVM_GETBKCOLOR* = 4096
  LVM_GETCALLBACKMASK* = 4106
  LVM_GETCOLUMNWIDTH* = 4125
  LVM_GETCOUNTPERPAGE* = 4136
  LVM_GETEDITCONTROL* = 4120
  LVM_GETIMAGELIST* = 4098
  LVM_EDITLABELW* = 4214
  LVM_FINDITEMW* = 4179
  LVM_GETCOLUMNW* = 4191
  LVM_GETISEARCHSTRINGW* = 4213
  LVM_GETITEMW* = 4171
  LVM_GETITEMTEXTW* = 4211
  LVM_GETSTRINGWIDTHW* = 4183
  LVM_INSERTCOLUMNW* = 4193
  LVM_INSERTITEMW* = 4173
  LVM_SETCOLUMNW* = 4192
  LVM_SETITEMW* = 4172
  LVM_SETITEMTEXTW* = 4212
  LVM_EDITLABELA* = 4119
  LVM_FINDITEMA* = 4109
  LVM_GETCOLUMNA* = 4121
  LVM_GETISEARCHSTRINGA* = 4148
  LVM_GETITEMA* = 4101
  LVM_GETITEMTEXTA* = 4141
  LVM_GETSTRINGWIDTHA* = 4113
  LVM_INSERTCOLUMNA* = 4123
  LVM_INSERTITEMA* = 4103
  LVM_SETCOLUMNA* = 4122
  LVM_SETITEMA* = 4102
  LVM_SETITEMTEXTA* = 4142

when defined(winUnicode):
  const
    LVM_EDITLABEL* = LVM_EDITLABELW
    LVM_FINDITEM* = LVM_FINDITEMW
    LVM_GETCOLUMN* = LVM_GETCOLUMNW
    LVM_GETISEARCHSTRING* = LVM_GETISEARCHSTRINGW
    LVM_GETITEM* = LVM_GETITEMW
    LVM_GETITEMTEXT* = LVM_GETITEMTEXTW
    LVM_GETSTRINGWIDTH* = LVM_GETSTRINGWIDTHW
    LVM_INSERTCOLUMN* = LVM_INSERTCOLUMNW
    LVM_INSERTITEM* = LVM_INSERTITEMW
    LVM_SETCOLUMN* = LVM_SETCOLUMNW
    LVM_SETITEM* = LVM_SETITEMW
    LVM_SETITEMTEXT* = LVM_SETITEMTEXTW
else:
  const
    LVM_EDITLABEL* = LVM_EDITLABELA
    LVM_FINDITEM* = LVM_FINDITEMA
    LVM_GETCOLUMN* = LVM_GETCOLUMNA
    LVM_GETISEARCHSTRING* = LVM_GETISEARCHSTRINGA
    LVM_GETITEM* = LVM_GETITEMA
    LVM_GETITEMTEXT* = LVM_GETITEMTEXTA
    LVM_GETSTRINGWIDTH* = LVM_GETSTRINGWIDTHA
    LVM_INSERTCOLUMN* = LVM_INSERTCOLUMNA
    LVM_INSERTITEM* = LVM_INSERTITEMA
    LVM_SETCOLUMN* = LVM_SETCOLUMNA
    LVM_SETITEM* = LVM_SETITEMA
    LVM_SETITEMTEXT* = LVM_SETITEMTEXTA
# UNICODE

const
  LVM_GETITEMCOUNT* = 4100
  LVM_GETITEMPOSITION* = 4112
  LVM_GETITEMRECT* = 4110
  LVM_GETITEMSPACING* = 4147
  LVM_GETITEMSTATE* = 4140
  LVM_GETNEXTITEM* = 4108
  LVM_GETORIGIN* = 4137
  LVM_GETSELECTEDCOUNT* = 4146
  LVM_GETTEXTBKCOLOR* = 4133
  LVM_GETTEXTCOLOR* = 4131
  LVM_GETTOPINDEX* = 4135
  LVM_GETVIEWRECT* = 4130
  LVM_HITTEST* = 4114
  LVM_REDRAWITEMS* = 4117
  LVM_SCROLL* = 4116
  LVM_SETBKCOLOR* = 4097
  LVM_SETCALLBACKMASK* = 4107
  LVM_SETCOLUMNWIDTH* = 4126
  LVM_SETIMAGELIST* = 4099
  LVM_SETITEMCOUNT* = 4143
  LVM_SETITEMPOSITION* = 4111
  LVM_SETITEMPOSITION32* = 4145
  LVM_SETITEMSTATE* = 4139
  LVM_SETTEXTBKCOLOR* = 4134
  LVM_SETTEXTCOLOR* = 4132
  LVM_SORTITEMS* = 4144
  LVM_UPDATE* = 4138
  # List view control notifications
  LVN_BEGINDRAG* = -109
  LVN_BEGINRDRAG* = -111
  LVN_COLUMNCLICK* = -108
  LVN_DELETEALLITEMS* = -104
  LVN_DELETEITEM* = -103
  LVN_BEGINLABELEDITW* = -175
  LVN_ENDLABELEDITW* = -176
  LVN_GETDISPINFOW* = -177
  LVN_SETDISPINFOW* = -178
  LVN_BEGINLABELEDITA* = -105
  LVN_ENDLABELEDITA* = -106
  LVN_GETDISPINFOA* = -150
  LVN_SETDISPINFOA* = -151

when defined(winUnicode):
  const
    LVN_BEGINLABELEDIT* = LVN_BEGINLABELEDITW
    LVN_ENDLABELEDIT* = LVN_ENDLABELEDITW
    LVN_GETDISPINFO* = LVN_GETDISPINFOW
    LVN_SETDISPINFO* = LVN_SETDISPINFOW
else:
  const
    LVN_BEGINLABELEDIT* = LVN_BEGINLABELEDITA
    LVN_ENDLABELEDIT* = LVN_ENDLABELEDITA
    LVN_GETDISPINFO* = LVN_GETDISPINFOA
    LVN_SETDISPINFO* = LVN_SETDISPINFOA
# UNICODE

const
  LVN_INSERTITEM* = -102
  LVN_ITEMCHANGED* = -101
  LVN_ITEMCHANGING* = -100
  LVN_KEYDOWN* = -155
  # Control notification
  NM_CLICK* = -2
  NM_DBLCLK* = -3
  NM_KILLFOCUS* = -8
  NM_OUTOFMEMORY* = -1
  NM_RCLICK* = -5
  NM_RDBLCLK* = -6
  NM_RETURN* = -4
  NM_SETFOCUS* = -7
  # Power status
  # Progress bar control
  PBM_DELTAPOS* = 1027
  PBM_SETPOS* = 1026
  PBM_SETRANGE* = 1025
  PBM_SETRANGE32* = 1030
  PBM_SETSTEP* = 1028
  PBM_STEPIT* = 1029
  # Property sheets
  PSM_ADDPAGE* = 1127
  PSM_APPLY* = 1134
  PSM_CANCELTOCLOSE* = 1131
  PSM_CHANGED* = 1128
  PSM_GETTABCONTROL* = 1140
  PSM_GETCURRENTPAGEHWND* = 1142
  PSM_ISDIALOGMESSAGE* = 1141
  PSM_PRESSBUTTON* = 1137
  PSM_QUERYSIBLINGS* = 1132
  PSM_REBOOTSYSTEM* = 1130
  PSM_REMOVEPAGE* = 1126
  PSM_RESTARTWINDOWS* = 1129
  PSM_SETCURSEL* = 1125
  PSM_SETCURSELID* = 1138
  PSM_SETFINISHTEXTW* = 1145
  PSM_SETTITLEW* = 1144
  PSM_SETFINISHTEXTA* = 1139
  PSM_SETTITLEA* = 1135

when defined(winUnicode):
  const
    PSM_SETFINISHTEXT* = PSM_SETFINISHTEXTW
    PSM_SETTITLE* = PSM_SETTITLEW
else:
  const
    PSM_SETFINISHTEXT* = PSM_SETFINISHTEXTA
    PSM_SETTITLE* = PSM_SETTITLEA
# UNICODE

const
  PSM_SETWIZBUTTONS* = 1136
  PSM_UNCHANGED* = 1133
  # Property sheet notifications
  PSN_APPLY* = -202
  PSN_HELP* = -205
  PSN_KILLACTIVE* = -201
  PSN_QUERYCANCEL* = -209
  PSN_RESET* = -203
  PSN_SETACTIVE* = -200
  PSN_WIZBACK* = -206
  PSN_WIZFINISH* = -208
  PSN_WIZNEXT* = -207
  # Status window
  SB_GETBORDERS* = 1031
  SB_GETPARTS* = 1030
  SB_GETRECT* = 1034
  SB_GETTEXTW* = 1037
  SB_GETTEXTLENGTHW* = 1036
  SB_SETTEXTW* = 1035
  SB_GETTEXTA* = 1026
  SB_GETTEXTLENGTHA* = 1027
  SB_SETTEXTA* = 1025

when defined(winUnicode):
  const
    SB_GETTEXT* = SB_GETTEXTW
    SB_GETTEXTLENGTH* = SB_GETTEXTLENGTHW
    SB_SETTEXT* = SB_SETTEXTW
else:
  const
    SB_GETTEXT* = SB_GETTEXTA
    SB_GETTEXTLENGTH* = SB_GETTEXTLENGTHA
    SB_SETTEXT* = SB_SETTEXTA
# UNICODE

const
  SB_SETMINHEIGHT* = 1032
  SB_SETPARTS* = 1028
  SB_SIMPLE* = 1033
  # Scroll bar control
  SBM_ENABLE_ARROWS* = 228
  SBM_GETPOS* = 225
  SBM_GETRANGE* = 227
  SBM_GETSCROLLINFO* = 234
  SBM_SETPOS* = 224
  SBM_SETRANGE* = 226
  SBM_SETRANGEREDRAW* = 230
  SBM_SETSCROLLINFO* = 233
  # Static control
  STM_GETICON* = 369
  STM_GETIMAGE* = 371
  STM_SETICON* = 368
  STM_SETIMAGE* = 370
  # Static control notifications
  STN_CLICKED* = 0
  STN_DBLCLK* = 1
  STN_DISABLE* = 3
  STN_ENABLE* = 2
  # Toolbar control
  TB_ADDBITMAP* = 1043
  TB_ADDBUTTONS* = 1044
  TB_AUTOSIZE* = 1057
  TB_BUTTONCOUNT* = 1048
  TB_BUTTONSTRUCTSIZE* = 1054
  TB_CHANGEBITMAP* = 1067
  TB_CHECKBUTTON* = 1026
  TB_COMMANDTOINDEX* = 1049
  TB_CUSTOMIZE* = 1051
  TB_DELETEBUTTON* = 1046
  TB_ENABLEBUTTON* = 1025
  TB_GETBITMAP* = 1068
  TB_GETBITMAPFLAGS* = 1065
  TB_GETBUTTON* = 1047
  TB_ADDSTRINGW* = 1101
  TB_GETBUTTONTEXTW* = 1099
  TB_SAVERESTOREW* = 1100
  TB_ADDSTRINGA* = 1052
  TB_GETBUTTONTEXTA* = 1069
  TB_SAVERESTOREA* = 1050

when defined(winUnicode):
  const
    TB_ADDSTRING* = TB_ADDSTRINGW
    TB_GETBUTTONTEXT* = TB_GETBUTTONTEXTW
    TB_SAVERESTORE* = TB_SAVERESTOREW
else:
  const
    TB_ADDSTRING* = TB_ADDSTRINGA
    TB_GETBUTTONTEXT* = TB_GETBUTTONTEXTA
    TB_SAVERESTORE* = TB_SAVERESTOREA
# UNICODE

const
  TB_GETITEMRECT* = 1053
  TB_GETROWS* = 1064
  TB_GETSTATE* = 1042
  TB_GETTOOLTIPS* = 1059
  TB_HIDEBUTTON* = 1028
  TB_INDETERMINATE* = 1029
  TB_INSERTBUTTON* = 1045
  TB_ISBUTTONCHECKED* = 1034
  TB_ISBUTTONENABLED* = 1033
  TB_ISBUTTONHIDDEN* = 1036
  TB_ISBUTTONINDETERMINATE* = 1037
  TB_ISBUTTONPRESSED* = 1035
  TB_PRESSBUTTON* = 1027
  TB_SETBITMAPSIZE* = 1056
  TB_SETBUTTONSIZE* = 1055
  TB_SETCMDID* = 1066
  TB_SETPARENT* = 1061
  TB_SETROWS* = 1063
  TB_SETSTATE* = 1041
  TB_SETTOOLTIPS* = 1060
  # Track bar control
  TBM_CLEARSEL* = 1043
  TBM_CLEARTICS* = 1033
  TBM_GETCHANNELRECT* = 1050
  TBM_GETLINESIZE* = 1048
  TBM_GETNUMTICS* = 1040
  TBM_GETPAGESIZE* = 1046
  TBM_GETPOS* = 1024
  TBM_GETPTICS* = 1038
  TBM_GETRANGEMAX* = 1026
  TBM_GETRANGEMIN* = 1025
  TBM_GETSELEND* = 1042
  TBM_GETSELSTART* = 1041
  TBM_GETTHUMBLENGTH* = 1052
  TBM_GETTHUMBRECT* = 1049
  TBM_GETTIC* = 1027
  TBM_GETTICPOS* = 1039
  TBM_SETLINESIZE* = 1047
  TBM_SETPAGESIZE* = 1045
  TBM_SETPOS* = 1029
  TBM_SETRANGE* = 1030
  TBM_SETRANGEMAX* = 1032
  TBM_SETRANGEMIN* = 1031
  TBM_SETSEL* = 1034
  TBM_SETSELEND* = 1036
  TBM_SETSELSTART* = 1035
  TBM_SETTHUMBLENGTH* = 1051
  TBM_SETTIC* = 1028
  TBM_SETTICFREQ* = 1044
  # Tool bar control notifications
  TBN_BEGINADJUST* = -703
  TBN_BEGINDRAG* = -701
  TBN_CUSTHELP* = -709
  TBN_ENDADJUST* = -704
  TBN_ENDDRAG* = -702
  TBN_GETBUTTONINFOW* = -720
  TBN_GETBUTTONINFOA* = -700

when defined(winUnicode):
  const
    TBN_GETBUTTONINFO* = TBN_GETBUTTONINFOW
else:
  const
    TBN_GETBUTTONINFO* = TBN_GETBUTTONINFOA
# UNICODE

const
  TBN_QUERYDELETE* = -707
  TBN_QUERYINSERT* = -706
  TBN_RESET* = -705
  TBN_TOOLBARCHANGE* = -708
  # Tab control
  TCM_ADJUSTRECT* = 4904
  TCM_DELETEALLITEMS* = 4873
  TCM_DELETEITEM* = 4872
  TCM_GETCURFOCUS* = 4911
  TCM_GETCURSEL* = 4875
  TCM_GETIMAGELIST* = 4866
  TCM_GETITEMW* = 4924
  TCM_INSERTITEMW* = 4926
  TCM_SETITEMW* = 4925
  TCM_GETITEMA* = 4869
  TCM_INSERTITEMA* = 4871
  TCM_SETITEMA* = 4870

when defined(winUnicode):
  const
    TCM_GETITEM* = TCM_GETITEM
    TCM_INSERTITEM* = TCM_INSERTITEMW
    TCM_SETITEM* = TCM_SETITEMW
else:
  const
    TCM_GETITEM* = TCM_GETITEMA
    TCM_INSERTITEM* = TCM_INSERTITEMA
    TCM_SETITEM* = TCM_SETITEMA
# UNICODE

const
  TCM_GETITEMCOUNT* = 4868
  TCM_GETITEMRECT* = 4874
  TCM_GETROWCOUNT* = 4908
  TCM_GETTOOLTIPS* = 4909
  TCM_HITTEST* = 4877
  TCM_REMOVEIMAGE* = 4906
  TCM_SETCURFOCUS* = 4912
  TCM_SETCURSEL* = 4876
  TCM_SETIMAGELIST* = 4867
  TCM_SETITEMEXTRA* = 4878
  TCM_SETITEMSIZE* = 4905
  TCM_SETPADDING* = 4907
  TCM_SETTOOLTIPS* = 4910
  # Tab control notifications
  TCN_KEYDOWN* = -550
  TCN_SELCHANGE* = -551
  TCN_SELCHANGING* = -552
  # Tool tip control
  TTM_ACTIVATE* = 1025
  TTM_ADDTOOLW* = 1074
  TTM_DELTOOLW* = 1075
  TTM_ENUMTOOLSW* = 1082
  TTM_GETCURRENTTOOLW* = 1083
  TTM_GETTEXTW* = 1080
  TTM_GETTOOLINFOW* = 1077
  TTM_HITTESTW* = 1079
  TTM_NEWTOOLRECTW* = 1076
  TTM_SETTOOLINFOW* = 1078
  TTM_UPDATETIPTEXTW* = 1081
  TTM_ADDTOOLA* = 1028
  TTM_DELTOOLA* = 1029
  TTM_ENUMTOOLSA* = 1038
  TTM_GETCURRENTTOOLA* = 1039
  TTM_GETTEXTA* = 1035
  TTM_GETTOOLINFOA* = 1032
  TTM_HITTESTA* = 1034
  TTM_NEWTOOLRECTA* = 1030
  TTM_SETTOOLINFOA* = 1033
  TTM_UPDATETIPTEXTA* = 1036

when defined(winUnicode):
  const
    TTM_ADDTOOL* = TTM_ADDTOOLW
    TTM_DELTOOL* = TTM_DELTOOLW
    TTM_ENUMTOOLS* = TTM_ENUMTOOLSW
    TTM_GETCURRENTTOOL* = TTM_GETCURRENTTOOLW
    TTM_GETTEXT* = TTM_GETTEXTW
    TTM_GETTOOLINFO* = TTM_GETTOOLINFOW
    TTM_HITTEST* = TTM_HITTESTW
    TTM_NEWTOOLRECT* = TTM_NEWTOOLRECTW
    TTM_SETTOOLINFO* = TTM_SETTOOLINFOW
    TTM_UPDATETIPTEXT* = TTM_UPDATETIPTEXTW
else:
  const
    TTM_ADDTOOL* = TTM_ADDTOOLA
    TTM_DELTOOL* = TTM_DELTOOLA
    TTM_ENUMTOOLS* = TTM_ENUMTOOLSA
    TTM_GETCURRENTTOOL* = TTM_GETCURRENTTOOLA
    TTM_GETTEXT* = TTM_GETTEXTA
    TTM_GETTOOLINFO* = TTM_GETTOOLINFOA
    TTM_HITTEST* = TTM_HITTESTA
    TTM_NEWTOOLRECT* = TTM_NEWTOOLRECTA
    TTM_SETTOOLINFO* = TTM_SETTOOLINFOA
    TTM_UPDATETIPTEXT* = TTM_UPDATETIPTEXTA
# UNICODE

const
  TTM_GETTOOLCOUNT* = 1037
  TTM_RELAYEVENT* = 1031
  TTM_SETDELAYTIME* = 1027
  TTM_WINDOWFROMPOINT* = 1040
  # Tool tip control notification
  TTN_NEEDTEXTW* = -530
  TTN_NEEDTEXTA* = -520

when defined(winUnicode):
  const
    TTN_NEEDTEXT* = TTN_NEEDTEXTW
else:
  const
    TTN_NEEDTEXT* = TTN_NEEDTEXTA
# UNICODE

const
  TTN_POP* = -522
  TTN_SHOW* = -521
  # Tree view control
  TVM_CREATEDRAGIMAGE* = 4370
  TVM_DELETEITEM* = 4353
  TVM_ENDEDITLABELNOW* = 4374
  TVM_ENSUREVISIBLE* = 4372
  TVM_EXPAND* = 4354
  TVM_GETCOUNT* = 4357
  TVM_GETEDITCONTROL* = 4367
  TVM_GETIMAGELIST* = 4360
  TVM_GETINDENT* = 4358
  TVM_GETITEMRECT* = 4356
  TVM_GETNEXTITEM* = 4362
  TVM_GETVISIBLECOUNT* = 4368
  TVM_HITTEST* = 4369
  TVM_EDITLABELW* = 4417
  TVM_GETISEARCHSTRINGW* = 4416
  TVM_GETITEMW* = 4414
  TVM_INSERTITEMW* = 4402
  TVM_SETITEMW* = 4415
  TVM_EDITLABELA* = 4366
  TVM_GETISEARCHSTRINGA* = 4375
  TVM_GETITEMA* = 4364
  TVM_INSERTITEMA* = 4352
  TVM_SETITEMA* = 4365

when defined(winUnicode):
  const
    TVM_EDITLABEL* = TVM_EDITLABELW
    TVM_GETISEARCHSTRING* = TVM_GETISEARCHSTRINGW
    TVM_GETITEM* = TVM_GETITEMW
    TVM_INSERTITEM* = TVM_INSERTITEMW
    TVM_SETITEM* = TVM_SETITEMW
else:
  const
    TVM_EDITLABEL* = TVM_EDITLABELA
    TVM_GETISEARCHSTRING* = TVM_GETISEARCHSTRINGA
    TVM_GETITEM* = TVM_GETITEMA
    TVM_INSERTITEM* = TVM_INSERTITEMA
    TVM_SETITEM* = TVM_SETITEMA
# UNICODE

const
  TVM_SELECTITEM* = 4363
  TVM_SETIMAGELIST* = 4361
  TVM_SETINDENT* = 4359
  TVM_SORTCHILDREN* = 4371
  TVM_SORTCHILDRENCB* = 4373
  # Tree view control notification
  TVN_KEYDOWN* = -412
  TVN_BEGINDRAGW* = -456
  TVN_BEGINLABELEDITW* = -459
  TVN_BEGINRDRAGW* = -457
  TVN_DELETEITEMW* = -458
  TVN_ENDLABELEDITW* = -460
  TVN_GETDISPINFOW* = -452
  TVN_ITEMEXPANDEDW* = -455
  TVN_ITEMEXPANDINGW* = -454
  TVN_SELCHANGEDW* = -451
  TVN_SELCHANGINGW* = -450
  TVN_SETDISPINFOW* = -453
  TVN_BEGINDRAGA* = -407
  TVN_BEGINLABELEDITA* = -410
  TVN_BEGINRDRAGA* = -408
  TVN_DELETEITEMA* = -409
  TVN_ENDLABELEDITA* = -411
  TVN_GETDISPINFOA* = -403
  TVN_ITEMEXPANDEDA* = -406
  TVN_ITEMEXPANDINGA* = -405
  TVN_SELCHANGEDA* = -402
  TVN_SELCHANGINGA* = -401
  TVN_SETDISPINFOA* = -404

when defined(winUnicode):
  const
    TVN_BEGINDRAG* = TVN_BEGINDRAGW
    TVN_BEGINLABELEDIT* = TVN_BEGINLABELEDITW
    TVN_BEGINRDRAG* = TVN_BEGINRDRAGW
    TVN_DELETEITEM* = TVN_DELETEITEMW
    TVN_ENDLABELEDIT* = TVN_ENDLABELEDITW
    TVN_GETDISPINFO* = TVN_GETDISPINFOW
    TVN_ITEMEXPANDED* = TVN_ITEMEXPANDEDW
    TVN_ITEMEXPANDING* = TVN_ITEMEXPANDINGW
    TVN_SELCHANGED* = TVN_SELCHANGEDW
    TVN_SELCHANGING* = TVN_SELCHANGINGW
    TVN_SETDISPINFO* = TVN_SETDISPINFOW
else:
  const
    TVN_BEGINDRAG* = TVN_BEGINDRAGA
    TVN_BEGINLABELEDIT* = TVN_BEGINLABELEDITA
    TVN_BEGINRDRAG* = TVN_BEGINRDRAGA
    TVN_DELETEITEM* = TVN_DELETEITEMA
    TVN_ENDLABELEDIT* = TVN_ENDLABELEDITA
    TVN_GETDISPINFO* = TVN_GETDISPINFOA
    TVN_ITEMEXPANDED* = TVN_ITEMEXPANDEDA
    TVN_ITEMEXPANDING* = TVN_ITEMEXPANDINGA
    TVN_SELCHANGED* = TVN_SELCHANGEDA
    TVN_SELCHANGING* = TVN_SELCHANGINGA
    TVN_SETDISPINFO* = TVN_SETDISPINFOA
# UNICODE

const
  # Up/down control
  UDM_GETACCEL* = 1132
  UDM_GETBASE* = 1134
  UDM_GETBUDDY* = 1130
  UDM_GETPOS* = 1128
  UDM_GETPOS32* = 1138
  UDM_GETRANGE* = 1126
  UDM_GETRANGE32* = 1136
  UDM_SETACCEL* = 1131
  UDM_SETBASE* = 1133
  UDM_SETBUDDY* = 1129
  UDM_SETPOS* = 1127
  UDM_SETPOS32* = 1137
  UDM_SETRANGE* = 1125
  UDM_SETRANGE32* = 1135
  # Up/down control notification
  UDN_DELTAPOS* = -722
  # Window messages
  WM_ACTIVATE* = 6
  WM_ACTIVATEAPP* = 28
  WM_ASKCBFORMATNAME* = 780
  WM_CANCELJOURNAL* = 75
  WM_CANCELMODE* = 31
  WM_CAPTURECHANGED* = 533
  WM_CHANGECBCHAIN* = 781
  WM_CHAR* = 258
  WM_CHARTOITEM* = 47
  WM_CHILDACTIVATE* = 34
  WM_CHOOSEFONT_GETLOGFONT* = 1025
  WM_CHOOSEFONT_SETLOGFONT* = 1125
  WM_CHOOSEFONT_SETFLAGS* = 1126
  WM_CLEAR* = 771
  WM_CLOSE* = 16
  WM_COMMAND* = 273
  WM_COMPACTING* = 65
  WM_COMPAREITEM* = 57
  WM_CONTEXTMENU* = 123
  WM_COPY* = 769
  WM_COPYDATA* = 74
  WM_CREATE* = 1
  WM_CTLCOLORBTN* = 309
  WM_CTLCOLORDLG* = 310
  WM_CTLCOLOREDIT* = 307
  WM_CTLCOLORLISTBOX* = 308
  WM_CTLCOLORMSGBOX* = 306
  WM_CTLCOLORSCROLLBAR* = 311
  WM_CTLCOLORSTATIC* = 312
  WM_CUT* = 768
  WM_DEADCHAR* = 259
  WM_DELETEITEM* = 45
  WM_DESTROY* = 2
  WM_DESTROYCLIPBOARD* = 775
  WM_DEVICECHANGE* = 537
  WM_DEVMODECHANGE* = 27
  WM_DISPLAYCHANGE* = 126
  WM_DRAWCLIPBOARD* = 776
  WM_DRAWITEM* = 43
  WM_DROPFILES* = 563
  WM_ENABLE* = 10
  WM_ENDSESSION* = 22
  WM_ENTERIDLE* = 289
  WM_ENTERMENULOOP* = 529
  WM_ENTERSIZEMOVE* = 561
  WM_ERASEBKGND* = 20
  WM_EXITMENULOOP* = 530
  WM_EXITSIZEMOVE* = 562
  WM_FONTCHANGE* = 29
  WM_GETDLGCODE* = 135
  WM_GETFONT* = 49
  WM_GETHOTKEY* = 51
  WM_GETICON* = 127
  WM_GETMINMAXINFO* = 36
  WM_GETTEXT* = 13
  WM_GETTEXTLENGTH* = 14
  WM_HELP* = 83
  WM_HOTKEY* = 786
  WM_HSCROLL* = 276
  WM_HSCROLLCLIPBOARD* = 782
  WM_ICONERASEBKGND* = 39
  WM_IME_CHAR* = 646
  WM_IME_COMPOSITION* = 271
  WM_IME_COMPOSITIONFULL* = 644
  WM_IME_CONTROL* = 643
  WM_IME_ENDCOMPOSITION* = 270
  WM_IME_KEYDOWN* = 656
  WM_IME_KEYUP* = 657
  WM_IME_NOTIFY* = 642
  WM_IME_SELECT* = 645
  WM_IME_SETCONTEXT* = 641
  WM_IME_STARTCOMPOSITION* = 269
  WM_INITDIALOG* = 272
  WM_INITMENU* = 278
  WM_INITMENUPOPUP* = 279
  WM_INPUTLANGCHANGE* = 81
  WM_INPUTLANGCHANGEREQUEST* = 80
  WM_KEYDOWN* = 256
  WM_KEYUP* = 257
  WM_KILLFOCUS* = 8
  WM_LBUTTONDBLCLK* = 515
  WM_LBUTTONDOWN* = 513
  WM_LBUTTONUP* = 514
  WM_MBUTTONDBLCLK* = 521
  WM_MBUTTONDOWN* = 519
  WM_MBUTTONUP* = 520
  WM_MDIACTIVATE* = 546
  WM_MDICASCADE* = 551
  WM_MDICREATE* = 544
  WM_MDIDESTROY* = 545
  WM_MDIGETACTIVE* = 553
  WM_MDIICONARRANGE* = 552
  WM_MDIMAXIMIZE* = 549
  WM_MDINEXT* = 548
  WM_MDIREFRESHMENU* = 564
  WM_MDIRESTORE* = 547
  WM_MDISETMENU* = 560
  WM_MDITILE* = 550
  WM_MEASUREITEM* = 44
  WM_MENUCHAR* = 288
  WM_MENUSELECT* = 287
  WM_MOUSEACTIVATE* = 33
  WM_MOUSEMOVE* = 512
  WM_MOUSEWHEEL* = 522
  WM_MOUSEHOVER* = 673
  WM_MOUSELEAVE* = 675
  WM_MOVE* = 3
  WM_MOVING* = 534
  WM_NCACTIVATE* = 134
  WM_NCCALCSIZE* = 131
  WM_NCCREATE* = 129
  WM_NCDESTROY* = 130
  WM_NCHITTEST* = 132
  WM_NCLBUTTONDBLCLK* = 163
  WM_NCLBUTTONDOWN* = 161
  WM_NCLBUTTONUP* = 162
  WM_NCMBUTTONDBLCLK* = 169
  WM_NCMBUTTONDOWN* = 167
  WM_NCMBUTTONUP* = 168
  WM_NCMOUSEMOVE* = 160
  WM_NCPAINT* = 133
  WM_NCRBUTTONDBLCLK* = 166
  WM_NCRBUTTONDOWN* = 164
  WM_NCRBUTTONUP* = 165
  WM_NEXTDLGCTL* = 40
  WM_NOTIFY* = 78
  WM_NOTIFYFORMAT* = 85
  WM_NULL* = 0
  WM_PAINT* = 15
  WM_PAINTCLIPBOARD* = 777
  WM_PAINTICON* = 38
  WM_PALETTECHANGED* = 785
  WM_PALETTEISCHANGING* = 784
  WM_PARENTNOTIFY* = 528
  WM_PASTE* = 770
  WM_PENWINFIRST* = 896
  WM_PENWINLAST* = 911
  WM_POWER* = 72
  WM_POWERBROADCAST* = 536
  WM_PRINT* = 791
  WM_PRINTCLIENT* = 792
  WM_PSD_ENVSTAMPRECT* = 1029
  WM_PSD_FULLPAGERECT* = 1025
  WM_PSD_GREEKTEXTRECT* = 1028
  WM_PSD_MARGINRECT* = 1027
  WM_PSD_MINMARGINRECT* = 1026
  WM_PSD_PAGESETUPDLG* = 1024
  WM_PSD_YAFULLPAGERECT* = 1030
  WM_QUERYDRAGICON* = 55
  WM_QUERYENDSESSION* = 17
  WM_QUERYNEWPALETTE* = 783
  WM_QUERYOPEN* = 19
  WM_QUEUESYNC* = 35
  WM_QUIT* = 18
  WM_RBUTTONDBLCLK* = 518
  WM_RBUTTONDOWN* = 516
  WM_RBUTTONUP* = 517
  WM_RENDERALLFORMATS* = 774
  WM_RENDERFORMAT* = 773
  WM_SETCURSOR* = 32
  WM_SETFOCUS* = 7
  WM_SETFONT* = 48
  WM_SETHOTKEY* = 50
  WM_SETICON* = 128
  WM_SETREDRAW* = 11
  WM_SETTEXT* = 12
  WM_SETTINGCHANGE* = 26
  WM_SHOWWINDOW* = 24
  WM_SIZE* = 5
  WM_SIZECLIPBOARD* = 779
  WM_SIZING* = 532
  WM_SPOOLERSTATUS* = 42
  WM_STYLECHANGED* = 125
  WM_STYLECHANGING* = 124
  WM_SYSCHAR* = 262
  WM_SYSCOLORCHANGE* = 21
  WM_SYSCOMMAND* = 274
  WM_SYSDEADCHAR* = 263
  WM_SYSKEYDOWN* = 260
  WM_SYSKEYUP* = 261
  WM_TCARD* = 82
  WM_TIMECHANGE* = 30
  WM_TIMER* = 275
  WM_UNDO* = 772
  WM_USER* = 1024
  WM_USERCHANGED* = 84
  WM_VKEYTOITEM* = 46
  WM_VSCROLL* = 277
  WM_VSCROLLCLIPBOARD* = 778
  WM_WINDOWPOSCHANGED* = 71
  WM_WINDOWPOSCHANGING* = 70
  WM_WININICHANGE* = 26
  # Window message ranges
  WM_KEYFIRST* = 256
  WM_KEYLAST* = 264
  WM_MOUSEFIRST* = 512
  WM_MOUSELAST* = 525
  WM_XBUTTONDOWN* = 523
  WM_XBUTTONUP* = 524
  WM_XBUTTONDBLCLK* = 525

when defined(cpu64):
  type
    HALFLRESULT* = DWORD
    HALFPARAM* = DWORD
    HALFPARAMBOOL* = WINBOOL
else:
  type
    HALFLRESULT* = int16
    HALFPARAM* = int16
    HALFPARAMBOOL* = WORDBOOL
type
  MSG* {.final, pure.} = object
    hwnd*: HWND
    message*: UINT
    wParam*: WPARAM
    lParam*: LPARAM
    time*: DWORD
    pt*: POINT

  LPMSG* = ptr MSG
  TMSG* = MSG
  PMSG* = ptr MSG
  PMessage* = ptr TMessage
  TMessage* {.final, pure.} = object          #fields according to ICS
    msg*: UINT
    wParam*: WPARAM
    lParam*: LPARAM
    Result*: LRESULT

  TWMSize* {.final, pure.} = object
    Msg*: UINT
    SizeType*: WPARAM
    Width*: HALFPARAM
    Height*: HALFPARAM
    Result*: LRESULT

  TWMNoParams* {.final, pure.} = object
    Msg*: UINT
    Unused*: array[0..3, HALFPARAM]
    Result*: LRESULT

  TWMCancelMode* = TWMNoParams
  TWMNCDestroy* = TWMNoParams
  TWMDestroy* = TWMNoParams
  TWMClose* = TWMNoParams
  TWMQueryUIState* = TWMNoParams
  TWMUIState* {.final, pure.} = object
    Msg*: UINT
    Action*: int16
    Flags*: int16
    Unused*: HRESULT

  TWMChangeUIState* = TWMUIState
  TWMUpdateUIState* = TWMUIState
  TWMKey* {.final, pure.} = object
    Msg*: UINT
    CharCode*: int16
    Unused*: int16
    KeyData*: int32
    Result*: LRESULT

  TWMKeyDown* = TWMKey
  TWMKeyUp* = TWMKey
  TWMChar* = TWMKey
  TWMSysChar* = TWMKey
  TWMSysKeyDown* = TWMKey
  TWMSysKeyUp* = TWMKey
  TWMMenuChar* {.final, pure.} = object
    Msg*: UINT
    User*: Char
    MenuFlag*: int16
    Menu*: HMENU
    Result*: LRESULT

  TWMGetDlgCode* = TWMNoParams
  TWMFontChange* = TWMNoParams
  TWMGetFont* = TWMNoParams
  TWMSysColorChange* = TWMNoParams
  TWMQueryDragIcon* = TWMNoParams
  TWMScroll* {.final, pure.} = object
    Msg*: UINT
    ScrollCode*: HALFPARAM
    Pos*: HALFPARAM
    ScrollBar*: HWND
    Result*: LRESULT

  TWMHScroll* = TWMScroll
  TWMVScroll* = TWMScroll
  TWMGetText* {.final, pure.} = object
    Msg*: UINT
    TextMax*: LPARAM
    Text*: cstring
    Result*: LRESULT

  TWMGetTextLength* = TWMNoParams
  TWMKillFocus* {.final, pure.} = object
    Msg*: UINT
    FocusedWnd*: HWND
    UnUsed*: WPARAM
    Result*: LRESULT

  TWMSetCursor* {.final, pure.} = object
    Msg*: UINT
    CursorWnd*: HWND
    HitTest*: HALFPARAM
    MouseMsg*: HALFPARAM
    Result*: LRESULT

  TWMSetFocus* {.final, pure.} = object
    Msg*: UINT
    FocusedWnd*: HWND
    Unused*: WPARAM
    Result*: LRESULT

  TWMSetFont* {.final, pure.} = object
    Msg*: UINT
    Font*: HFONT
    Redraw*: HALFPARAMBOOL
    Unused*: HALFPARAM
    Result*: LRESULT

  TWMShowWindow* {.final, pure.} = object
    Msg*: UINT
    Show*: HALFPARAMBOOL
    Unused*: HALFPARAM
    Status*: WPARAM
    Result*: LRESULT

  TWMEraseBkgnd* {.final, pure.} = object
    Msg*: UINT
    DC*: HDC
    Unused*: LPARAM
    Result*: LRESULT

  TWMNCHitTest* {.final, pure.} = object
    Msg*: UINT
    Unused*: int32
    Pos*: TSmallPoint
    Result*: LRESULT

  TWMMouse* {.final, pure.} = object
    Msg*: UINT
    Keys*: int32
    Pos*: TSmallPoint
    Result*: LRESULT

  TWMLButtonDblClk* = TWMMouse
  TWMLButtonDown* = TWMMouse
  TWMLButtonUp* = TWMMouse
  TWMMButtonDblClk* = TWMMouse
  TWMMButtonDown* = TWMMouse
  TWMMButtonUp* = TWMMouse
  TWMMouseWheel* {.final, pure.} = object
    Msg*: UINT
    Keys*: int16
    WheelDelta*: int16
    Pos*: TSmallPoint
    Result*: LRESULT

  TWMNCHitMessage* {.final, pure.} = object
    Msg*: UINT
    HitTest*: int32
    XCursor*: int16
    YCursor*: int16
    Result*: LRESULT

  TWMNCLButtonDblClk* = TWMNCHitMessage
  TWMNCLButtonDown* = TWMNCHitMessage
  TWMNCLButtonUp* = TWMNCHitMessage
  TWMNCMButtonDblClk* = TWMNCHitMessage
  TWMNCMButtonDown* = TWMNCHitMessage
  TWMNCMButtonUp* = TWMNCHitMessage
  TWMNCMouseMove* = TWMNCHitMessage
  TWMRButtonDblClk* = TWMMouse
  TWMRButtonDown* = TWMMouse
  TWMRButtonUp* = TWMMouse
  TWMMouseMove* = TWMMouse
  TWMPaint* {.final, pure.} = object
    Msg*: UINT
    DC*: HDC
    Unused*: int32
    Result*: LRESULT

  TWMCommand* {.final, pure.} = object
    Msg*: UINT
    ItemID*: int16
    NotifyCode*: int16
    Ctl*: HWND
    Result*: LRESULT

  TWMNotify* {.final, pure.} = object
    Msg*: UINT
    IDCtrl*: int32
    NMHdr*: PNMHdr
    Result*: LRESULT

  TWMPrint* {.final, pure.} = object
    Msg*: UINT
    DC*: HDC
    Flags*: int
    Result*: LRESULT

  TWMPrintClient* = TWMPrint
  TWMWinIniChange* {.final, pure.} = object
    Msg*: UINT
    Unused*: int
    Section*: cstring
    Result*: LRESULT

  TWMContextMenu* {.final, pure.} = object
    Msg*: UINT
    hWnd*: HWND
    Pos*: TSmallPoint
    Result*: LRESULT

  TWMNCCalcSize* {.final, pure.} = object
    Msg*: UINT
    CalcValidRects*: WINBOOL
    CalcSize_Params*: PNCCalcSizeParams
    Result*: LRESULT

  TWMCharToItem* {.final, pure.} = object
    Msg*: UINT
    Key*: int16
    CaretPos*: int16
    ListBox*: HWND
    Result*: LRESULT

  TWMVKeyToItem* = TWMCharToItem
  TMyEventRange = range[0'i16..16000'i16]
  TWMParentNotify* {.final, pure.} = object
    Msg*: UINT
    case Event*: TMyEventRange
    of TMyEventRange(WM_CREATE), TMyEventRange(WM_DESTROY):
        ChildID*: int16
        ChildWnd*: HWnd

    of TMyEventRange(WM_LBUTTONDOWN),
      TMyEventRange(WM_MBUTTONDOWN),
      TMyEventRange(WM_RBUTTONDOWN):
        Value*: int16
        XPos*: int16
        YPos*: int16

    else:
        Value1*: int16
        Value2*: int32
        Result*: LRESULT

  TWMSysCommand* {.final, pure.} = object
    Msg*: UINT
    CmdType*: int32
    XPos*: int16
    YPos*: int16
    Result*: LRESULT
  #  case CmdType*: int32
  #  of SC_HOTKEY:
  #      ActivateWnd*: HWND
  #  of SC_CLOSE, SC_HSCROLL, SC_MAXIMIZE, SC_MINIMIZE, SC_MOUSEMENU, SC_MOVE,
  #     SC_NEXTWINDOW, SC_PREVWINDOW, SC_RESTORE, SC_SCREENSAVE, SC_SIZE,
  #     SC_TASKLIST, SC_VSCROLL:
  #      XPos*: int16
  #      YPos*: int16
  #      Result*: LRESULT
  #  else: # of SC_KEYMENU:
  #      Key*: int16

  TWMMove* {.final, pure.} = object
    Msg*: UINT
    Unused*: int
    Pos*: TSmallPoint
    Result*: LRESULT

  TWMWindowPosMsg* {.final, pure.} = object
    Msg*: UINT
    Unused*: int
    WindowPos*: PWindowPos
    Result*: LRESULT

  TWMWindowPosChanged* = TWMWindowPosMsg
  TWMWindowPosChanging* = TWMWindowPosMsg
  TWMCompareItem* {.final, pure.} = object
    Msg*: UINT
    Ctl*: HWnd
    CompareItemStruct*: PCompareItemStruct
    Result*: LRESULT

  TWMDeleteItem* {.final, pure.} = object
    Msg*: UINT
    Ctl*: HWND
    DeleteItemStruct*: PDeleteItemStruct
    Result*: LRESULT

  TWMDrawItem* {.final, pure.} = object
    Msg*: UINT
    Ctl*: HWND
    DrawItemStruct*: PDrawItemStruct
    Result*: LRESULT

  TWMMeasureItem* {.final, pure.} = object
    Msg*: UINT
    IDCtl*: HWnd
    MeasureItemStruct*: PMeasureItemStruct
    Result*: LRESULT

  TWMNCCreate* {.final, pure.} = object
    Msg*: UINT
    Unused*: int
    CreateStruct*: PCreateStruct
    Result*: LRESULT

  TWMInitMenuPopup* {.final, pure.} = object
    Msg*: UINT
    MenuPopup*: HMENU
    Pos*: int16
    SystemMenu*: WordBool
    Result*: LRESULT

  TWMMenuSelect* {.final, pure.} = object
    Msg*: UINT
    IDItem*: int16
    MenuFlag*: int16
    Menu*: HMENU
    Result*: LRESULT

  TWMActivate* {.final, pure.} = object
    Msg*: UINT
    Active*: int16
    Minimized*: WordBool
    ActiveWindow*: HWND
    Result*: LRESULT

  TWMQueryEndSession* {.final, pure.} = object
    Msg*: UINT
    Source*: int32
    Unused*: int32
    Result*: LRESULT

  TWMMDIActivate* {.final, pure.} = object
    Msg*: UINT
    DeactiveWnd*: HWND
    ActiveWnd*: HWND
    Result*: LRESULT

  TWMNextDlgCtl* {.final, pure.} = object
    Msg*: UINT
    CtlFocus*: int32
    Handle*: WordBool
    Unused*: int16
    Result*: LRESULT

  TWMHelp* {.final, pure.} = object
    Msg*: UINT
    Unused*: int
    HelpInfo*: PHelpInfo
    Result*: LRESULT

  TWMGetMinMaxInfo* {.final, pure.} = object
    Msg*: UINT
    Unused*: int
    MinMaxInfo*: PMinMaxInfo
    Result*: LRESULT

  TWMSettingChange* {.final, pure.} = object
    Msg*: UINT
    Flag*: int
    Section*: cstring
    Result*: LRESULT

  TWMCreate* {.final, pure.} = object
    Msg*: UINT
    Unused*: int
    CreateStruct*: PCreateStruct
    Result*: LRESULT

  TWMCtlColor* {.final, pure.} = object
    Msg*: UINT
    ChildDC*: HDC
    ChildWnd*: HWND
    Result*: LRESULT

  TWMCtlColorScrollbar* = TWMCtlColor
  TWMCtlColorStatic* = TWMCtlColor
  TWMCtlColorBtn* = TWMCtlColor
  TWMCtlColorListbox* = TWMCtlColor
  TWMCtlColorMsgbox* = TWMCtlColor
  TWMCtlColorDlg* = TWMCtlColor
  TWMCtlColorEdit* = TWMCtlColor
  TWMInitDialog* {.final, pure.} = object
    Msg*: UINT
    Focus*: HWND
    InitParam*: int32
    Result*: LRESULT

  TWMNCPaint* {.final, pure.} = object
    Msg*: UINT
    RGN*: HRGN
    Unused*: int32
    Result*: LRESULT

  TWMSetText* {.final, pure.} = object
    Msg*: UINT
    Unused*: int32
    Text*: cstring
    Result*: LRESULT

  TWMSizeClipboard* {.final, pure.} = object
    Msg*: UINT
    Viewer*: HWND
    RC*: THandle
    Result*: LRESULT

  TWMSpoolerStatus* {.final, pure.} = object
    Msg*: UINT
    JobStatus*: LPARAM
    JobsLeft*: WPARAM
    Unused*: WPARAM
    Result*: LRESULT

  TWMStyleChange* {.final, pure.} = object
    Msg*: UINT
    StyleType*: LPARAM
    StyleStruct*: PStyleStruct
    Result*: LRESULT

  TWMStyleChanged* = TWMStyleChange
  TWMStyleChanging* = TWMStyleChange
  TWMSysDeadChar* {.final, pure.} = object
    Msg*: UINT
    CharCode*: WPARAM
    Unused*: WPARAM
    KeyData*: LPARAM
    Result*: LRESULT

  TWMSystemError* {.final, pure.} = object
    Msg*: UINT
    ErrSpec*: WPARAM
    Unused*: LPARAM
    Result*: LRESULT

  TWMTimeChange* = TWMNoParams
  TWMTimer* {.final, pure.} = object
    Msg*: UINT
    TimerID*: LPARAM
    TimerProc*: TFarProc
    Result*: LRESULT

  TWMUndo* = TWMNoParams
  TWMVScrollClipboard* {.final, pure.} = object
    Msg*: UINT
    Viewer*: HWND
    ScollCode*: WPARAM
    ThumbPos*: WPARAM
    Result*: LRESULT

  TWMDisplayChange* {.final, pure.} = object
    Msg*: UINT
    BitsPerPixel*: int
    Width*: WPARAM
    Height*: WPARAM
    Result*: LRESULT

  TWMDropFiles* {.final, pure.} = object
    Msg*: UINT
    Drop*: THANDLE
    Unused*: LPARAM
    Result*: LRESULT

  TWMEnable* {.final, pure.} = object
    Msg*: int
    Enabled*: WINBOOL
    Unused*: int32
    Result*: int32

  TWMMouseActivate* {.final, pure.} = object
    Msg*: int
    TopLevel*: HWND
    HitTestCode*: int16
    MouseMsg*: int16
    Result*: int32


proc GetBinaryTypeA*(lpApplicationName: LPCSTR, lpBinaryType: LPDWORD): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "GetBinaryTypeA".}

proc GetShortPathNameA*(lpszLongPath: LPCSTR, lpszShortPath: LPSTR,
                        cchBuffer: DWORD): DWORD{.stdcall,
                        dynlib: "kernel32", importc.}
proc GetEnvironmentStringsA*(): LPSTR{.stdcall, dynlib: "kernel32", importc.}
proc FreeEnvironmentStringsA*(para1: LPSTR): WINBOOL{.stdcall, dynlib: "kernel32", importc.}
proc FormatMessageA*(dwFlags: DWORD, lpSource: LPCVOID, dwMessageId: DWORD,
                     dwLanguageId: DWORD, lpBuffer: LPSTR, nSize: DWORD,
                     Arguments: va_list): DWORD{.stdcall,dynlib: "kernel32", importc.}
proc CreateMailslotA*(lpName: LPCSTR, nMaxMessageSize: DWORD,
                      lReadTimeout: DWORD,
                      lpSecurityAttributes: LPSECURITY_ATTRIBUTES): HANDLE{.
    stdcall, dynlib: "kernel32", importc.}
proc lstrcmpA*(lpString1: LPCSTR, lpString2: LPCSTR): int32{.stdcall,
  dynlib: "kernel32", importc.}
proc lstrcmpiA*(lpString1: LPCSTR, lpString2: LPCSTR): int32{.stdcall, dynlib: "kernel32", importc.}
proc lstrcpynA*(lpString1: LPSTR, lpString2: LPCSTR, iMaxLength: int32): LPSTR{.
    stdcall, dynlib: "kernel32", importc.}
proc CreateMutexA*(lpMutexAttributes: LPSECURITY_ATTRIBUTES,
                   bInitialOwner: WINBOOL, lpName: LPCSTR): HANDLE{.stdcall,
                   dynlib: "kernel32", importc.}
proc OpenMutexA*(dwDesiredAccess: DWORD, bInheritHandle: WINBOOL, lpName: LPCSTR): HANDLE{.
    stdcall, dynlib: "kernel32", importc.}
proc CreateEventA*(lpEventAttributes: LPSECURITY_ATTRIBUTES,
                   bManualReset: WINBOOL, bInitialState: WINBOOL, lpName: LPCSTR): HANDLE{.
    stdcall, dynlib: "kernel32", importc.}
proc OpenEventA*(dwDesiredAccess: DWORD, bInheritHandle: WINBOOL, lpName: LPCSTR): HANDLE{.
    stdcall, dynlib: "kernel32", importc.}
proc CreateSemaphoreA*(lpSemaphoreAttributes: LPSECURITY_ATTRIBUTES,
                       lInitialCount: LONG, lMaximumCount: LONG, lpName: LPCSTR): HANDLE{.
    stdcall, dynlib: "kernel32", importc.}
proc OpenSemaphoreA*(dwDesiredAccess: DWORD, bInheritHandle: WINBOOL,
                     lpName: LPCSTR): HANDLE{.stdcall,
                     dynlib: "kernel32", importc.}
proc CreateFileMappingA*(hFile: HANDLE,
                         lpFileMappingAttributes: LPSECURITY_ATTRIBUTES,
                         flProtect: DWORD, dwMaximumSizeHigh: DWORD,
                         dwMaximumSizeLow: DWORD, lpName: LPCSTR): HANDLE{.
    stdcall, dynlib: "kernel32", importc.}
proc OpenFileMappingA*(dwDesiredAccess: DWORD, bInheritHandle: WINBOOL,
                       lpName: LPCSTR): HANDLE{.stdcall,
                       dynlib: "kernel32", importc.}
proc GetLogicalDriveStringsA*(nBufferLength: DWORD, lpBuffer: LPSTR): DWORD{.
    stdcall, dynlib: "kernel32", importc.}
proc LoadLibraryA*(lpLibFileName: LPCSTR): HINST{.stdcall,
  dynlib: "kernel32", importc.}
proc LoadLibraryExA*(lpLibFileName: LPCSTR, hFile: HANDLE, dwFlags: DWORD): HINST{.
    stdcall, dynlib: "kernel32", importc.}
proc GetModuleFileNameA*(hModule: HINST, lpFilename: LPSTR, nSize: DWORD): DWORD{.
    stdcall, dynlib: "kernel32", importc.}
proc GetModuleHandleA*(lpModuleName: LPCSTR): HMODULE{.stdcall,
     dynlib: "kernel32", importc.}
proc FatalAppExitA*(uAction: UINT, lpMessageText: LPCSTR){.stdcall,
     dynlib: "kernel32", importc.}
proc GetCommandLineA*(): LPSTR{.stdcall, dynlib: "kernel32", importc.}
proc GetEnvironmentVariableA*(lpName: LPCSTR, lpBuffer: LPSTR, nSize: DWORD): DWORD{.
    stdcall, dynlib: "kernel32", importc.}
proc SetEnvironmentVariableA*(lpName: LPCSTR, lpValue: LPCSTR): WINBOOL{.stdcall,
  dynlib: "kernel32", importc.}
proc ExpandEnvironmentStringsA*(lpSrc: LPCSTR, lpDst: LPSTR, nSize: DWORD): DWORD{.
    stdcall, dynlib: "kernel32", importc.}
proc OutputDebugStringA*(lpOutputString: LPCSTR){.stdcall,
   dynlib: "kernel32", importc.}
proc FindResourceA*(hModule: HINST, lpName: LPCSTR, lpType: LPCSTR): HRSRC{.
    stdcall, dynlib: "kernel32", importc.}
proc FindResourceExA*(hModule: HINST, lpType: LPCSTR, lpName: LPCSTR,
                      wLanguage: int16): HRSRC{.stdcall,
                      dynlib: "kernel32", importc.}
proc EnumResourceTypesA*(hModule: HINST, lpEnumFunc: ENUMRESTYPEPROC,
                         lParam: LONG): WINBOOL{.stdcall,
                         dynlib: "kernel32", importc.}
proc EnumResourceNamesA*(hModule: HINST, lpType: LPCSTR,
                         lpEnumFunc: ENUMRESNAMEPROC, lParam: LONG): WINBOOL{.
    stdcall, dynlib: "kernel32", importc.}
proc EnumResourceLanguagesA*(hModule: HINST, lpType: LPCSTR, lpName: LPCSTR,
                             lpEnumFunc: ENUMRESLANGPROC, lParam: LONG): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "EnumResourceLanguagesA".}

proc BeginUpdateResourceA*(pFileName: LPCSTR, bDeleteExistingResources: WINBOOL): HANDLE{.
    stdcall, dynlib: "kernel32", importc: "BeginUpdateResourceA".}

proc UpdateResourceA*(hUpdate: HANDLE, lpType: LPCSTR, lpName: LPCSTR,
                      wLanguage: int16, lpData: LPVOID, cbData: DWORD): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "UpdateResourceA".}
proc EndUpdateResourceA*(hUpdate: HANDLE, fDiscard: WINBOOL): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "EndUpdateResourceA".}
proc GlobalAddAtomA*(lpString: LPCSTR): ATOM{.stdcall, dynlib: "kernel32",
    importc: "GlobalAddAtomA".}
proc GlobalFindAtomA*(lpString: LPCSTR): ATOM{.stdcall, dynlib: "kernel32",
    importc: "GlobalFindAtomA".}
proc GlobalGetAtomNameA*(nAtom: ATOM, lpBuffer: LPSTR, nSize: int32): UINT{.
    stdcall, dynlib: "kernel32", importc: "GlobalGetAtomNameA".}
proc AddAtomA*(lpString: LPCSTR): ATOM{.stdcall, dynlib: "kernel32",
                                        importc: "AddAtomA".}
proc FindAtomA*(lpString: LPCSTR): ATOM{.stdcall, dynlib: "kernel32",
    importc: "FindAtomA".}
proc GetAtomNameA*(nAtom: ATOM, lpBuffer: LPSTR, nSize: int32): UINT{.stdcall,
    dynlib: "kernel32", importc: "GetAtomNameA".}
proc GetProfileIntA*(lpAppName: LPCSTR, lpKeyName: LPCSTR, nDefault: WINT): UINT{.
    stdcall, dynlib: "kernel32", importc: "GetProfileIntA".}
proc GetProfileStringA*(lpAppName: LPCSTR, lpKeyName: LPCSTR, lpDefault: LPCSTR,
                        lpReturnedString: LPSTR, nSize: DWORD): DWORD{.stdcall,
    dynlib: "kernel32", importc: "GetProfileStringA".}
proc WriteProfileStringA*(lpAppName: LPCSTR, lpKeyName: LPCSTR, lpString: LPCSTR): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "WriteProfileStringA".}
proc GetProfileSectionA*(lpAppName: LPCSTR, lpReturnedString: LPSTR,
                         nSize: DWORD): DWORD{.stdcall, dynlib: "kernel32",
    importc: "GetProfileSectionA".}
proc WriteProfileSectionA*(lpAppName: LPCSTR, lpString: LPCSTR): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "WriteProfileSectionA".}
proc GetPrivateProfileIntA*(lpAppName: LPCSTR, lpKeyName: LPCSTR,
                            nDefault: WINT, lpFileName: LPCSTR): UINT{.stdcall,
    dynlib: "kernel32", importc: "GetPrivateProfileIntA".}
proc GetPrivateProfileStringA*(lpAppName: LPCSTR, lpKeyName: LPCSTR,
                               lpDefault: LPCSTR, lpReturnedString: LPSTR,
                               nSize: DWORD, lpFileName: LPCSTR): DWORD{.
    stdcall, dynlib: "kernel32", importc: "GetPrivateProfileStringA".}

proc WritePrivateProfileStringA*(lpAppName: LPCSTR, lpKeyName: LPCSTR,
                                 lpString: LPCSTR, lpFileName: LPCSTR): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "WritePrivateProfileStringA".}
proc GetPrivateProfileSectionA*(lpAppName: LPCSTR, lpReturnedString: LPSTR,
                                nSize: DWORD, lpFileName: LPCSTR): DWORD{.
    stdcall, dynlib: "kernel32", importc: "GetPrivateProfileSectionA".}
proc WritePrivateProfileSectionA*(lpAppName: LPCSTR, lpString: LPCSTR,
                                  lpFileName: LPCSTR): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "WritePrivateProfileSectionA".}
proc GetDriveTypeA*(lpRootPathName: LPCSTR): UINT{.stdcall, dynlib: "kernel32",
    importc: "GetDriveTypeA".}
proc GetSystemDirectoryA*(lpBuffer: LPSTR, uSize: UINT): UINT{.stdcall,
    dynlib: "kernel32", importc: "GetSystemDirectoryA".}
proc GetTempPathA*(nBufferLength: DWORD, lpBuffer: LPSTR): DWORD{.stdcall,
    dynlib: "kernel32", importc: "GetTempPathA".}
proc GetTempFileNameA*(lpPathName: LPCSTR, lpPrefixString: LPCSTR,
                       uUnique: UINT, lpTempFileName: LPSTR): UINT{.stdcall,
    dynlib: "kernel32", importc: "GetTempFileNameA".}
proc GetWindowsDirectoryA*(lpBuffer: LPSTR, uSize: UINT): UINT{.stdcall,
    dynlib: "kernel32", importc: "GetWindowsDirectoryA".}
proc SetCurrentDirectoryA*(lpPathName: LPCSTR): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "SetCurrentDirectoryA".}
proc GetCurrentDirectoryA*(nBufferLength: DWORD, lpBuffer: LPSTR): DWORD{.
    stdcall, dynlib: "kernel32", importc: "GetCurrentDirectoryA".}
proc GetDiskFreeSpaceA*(lpRootPathName: LPCSTR, lpSectorsPerCluster: LPDWORD,
                        lpBytesPerSector: LPDWORD,
                        lpNumberOfFreeClusters: LPDWORD,
                        lpTotalNumberOfClusters: LPDWORD): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "GetDiskFreeSpaceA".}
proc CreateDirectoryA*(lpPathName: LPCSTR,

                       lpSecurityAttributes: LPSECURITY_ATTRIBUTES): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "CreateDirectoryA".}
proc CreateDirectoryExA*(lpTemplateDirectory: LPCSTR, lpNewDirectory: LPCSTR,
                         lpSecurityAttributes: LPSECURITY_ATTRIBUTES): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "CreateDirectoryExA".}
proc RemoveDirectoryA*(lpPathName: LPCSTR): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "RemoveDirectoryA".}
proc GetFullPathNameA*(lpFileName: LPCSTR, nBufferLength: DWORD,
                       lpBuffer: LPSTR, lpFilePart: var LPSTR): DWORD{.stdcall,
    dynlib: "kernel32", importc: "GetFullPathNameA".}
proc DefineDosDeviceA*(dwFlags: DWORD, lpDeviceName: LPCSTR,
                       lpTargetPath: LPCSTR): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "DefineDosDeviceA".}
proc QueryDosDeviceA*(lpDeviceName: LPCSTR, lpTargetPath: LPSTR, ucchMax: DWORD): DWORD{.
    stdcall, dynlib: "kernel32", importc: "QueryDosDeviceA".}
proc CreateFileA*(lpFileName: LPCSTR, dwDesiredAccess: DWORD,
                  dwShareMode: DWORD,
                  lpSecurityAttributes: LPSECURITY_ATTRIBUTES,
                  dwCreationDisposition: DWORD, dwFlagsAndAttributes: DWORD,
                  hTemplateFile: HANDLE): HANDLE{.stdcall, dynlib: "kernel32",
    importc: "CreateFileA".}
proc SetFileAttributesA*(lpFileName: LPCSTR, dwFileAttributes: DWORD): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "SetFileAttributesA".}
proc GetFileAttributesA*(lpFileName: LPCSTR): DWORD{.stdcall,
    dynlib: "kernel32", importc: "GetFileAttributesA".}
proc GetCompressedFileSizeA*(lpFileName: LPCSTR, lpFileSizeHigh: LPDWORD): DWORD{.
    stdcall, dynlib: "kernel32", importc: "GetCompressedFileSizeA".}
proc DeleteFileA*(lpFileName: LPCSTR): WINBOOL{.stdcall, dynlib: "kernel32",
    importc: "DeleteFileA".}
proc SearchPathA*(lpPath: LPCSTR, lpFileName: LPCSTR, lpExtension: LPCSTR,
                  nBufferLength: DWORD, lpBuffer: LPSTR, lpFilePart: LPSTR): DWORD{.
    stdcall, dynlib: "kernel32", importc: "SearchPathA".}
proc CopyFileA*(lpExistingFileName: LPCSTR, lpNewFileName: LPCSTR,
                bFailIfExists: WINBOOL): WINBOOL{.stdcall, dynlib: "kernel32",
    importc: "CopyFileA".}
proc MoveFileA*(lpExistingFileName: LPCSTR, lpNewFileName: LPCSTR): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "MoveFileA".}
proc MoveFileExA*(lpExistingFileName: LPCSTR, lpNewFileName: LPCSTR,
                  dwFlags: DWORD): WINBOOL{.stdcall, dynlib: "kernel32",
    importc: "MoveFileExA".}
proc CreateNamedPipeA*(lpName: LPCSTR, dwOpenMode: DWORD, dwPipeMode: DWORD,
                       nMaxInstances: DWORD, nOutBufferSize: DWORD,
                       nInBufferSize: DWORD, nDefaultTimeOut: DWORD,
                       lpSecurityAttributes: LPSECURITY_ATTRIBUTES): HANDLE{.
    stdcall, dynlib: "kernel32", importc: "CreateNamedPipeA".}
proc GetNamedPipeHandleStateA*(hNamedPipe: HANDLE, lpState: LPDWORD,
                               lpCurInstances: LPDWORD,
                               lpMaxCollectionCount: LPDWORD,
                               lpCollectDataTimeout: LPDWORD, lpUserName: LPSTR,
                               nMaxUserNameSize: DWORD): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "GetNamedPipeHandleStateA".}
proc CallNamedPipeA*(lpNamedPipeName: LPCSTR, lpInBuffer: LPVOID,
                     nInBufferSize: DWORD, lpOutBuffer: LPVOID,
                     nOutBufferSize: DWORD, lpBytesRead: LPDWORD,
                     nTimeOut: DWORD): WINBOOL{.stdcall, dynlib: "kernel32",
    importc: "CallNamedPipeA".}
proc WaitNamedPipeA*(lpNamedPipeName: LPCSTR, nTimeOut: DWORD): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "WaitNamedPipeA".}
proc SetVolumeLabelA*(lpRootPathName: LPCSTR, lpVolumeName: LPCSTR): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "SetVolumeLabelA".}
proc GetVolumeInformationA*(lpRootPathName: LPCSTR, lpVolumeNameBuffer: LPSTR,
                            nVolumeNameSize: DWORD,
                            lpVolumeSerialNumber: LPDWORD,
                            lpMaximumComponentLength: LPDWORD,
                            lpFileSystemFlags: LPDWORD,
                            lpFileSystemNameBuffer: LPSTR,
                            nFileSystemNameSize: DWORD): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "GetVolumeInformationA".}
proc ClearEventLogA*(hEventLog: HANDLE, lpBackupFileName: LPCSTR): WINBOOL{.
    stdcall, dynlib: "advapi32", importc: "ClearEventLogA".}
proc BackupEventLogA*(hEventLog: HANDLE, lpBackupFileName: LPCSTR): WINBOOL{.
    stdcall, dynlib: "advapi32", importc: "BackupEventLogA".}
proc OpenEventLogA*(lpUNCServerName: LPCSTR, lpSourceName: LPCSTR): HANDLE{.
    stdcall, dynlib: "advapi32", importc: "OpenEventLogA".}
proc RegisterEventSourceA*(lpUNCServerName: LPCSTR, lpSourceName: LPCSTR): HANDLE{.
    stdcall, dynlib: "advapi32", importc: "RegisterEventSourceA".}
proc OpenBackupEventLogA*(lpUNCServerName: LPCSTR, lpFileName: LPCSTR): HANDLE{.
    stdcall, dynlib: "advapi32", importc: "OpenBackupEventLogA".}
proc ReadEventLogA*(hEventLog: HANDLE, dwReadFlags: DWORD,
                    dwRecordOffset: DWORD, lpBuffer: LPVOID,
                    nNumberOfBytesToRead: DWORD, pnBytesRead: LPDWORD,
                    pnMinNumberOfBytesNeeded: LPDWORD): WINBOOL{.stdcall,
    dynlib: "advapi32", importc: "ReadEventLogA".}
proc ReportEventA*(hEventLog: HANDLE, wType: int16, wCategory: int16,
                   dwEventID: DWORD, lpUserSid: PSID, wNumStrings: int16,
                   dwDataSize: DWORD, lpStrings: LPPCSTR, lpRawData: LPVOID): WINBOOL{.
    stdcall, dynlib: "advapi32", importc: "ReportEventA".}
proc AccessCheckAndAuditAlarmA*(SubsystemName: LPCSTR, HandleId: LPVOID,
                                ObjectTypeName: LPSTR, ObjectName: LPSTR,
                                SecurityDescriptor: PSECURITY_DESCRIPTOR,
                                DesiredAccess: DWORD,
                                GenericMapping: PGENERIC_MAPPING,
                                ObjectCreation: WINBOOL, GrantedAccess: LPDWORD,
                                AccessStatus: LPBOOL, pfGenerateOnClose: LPBOOL): WINBOOL{.
    stdcall, dynlib: "advapi32", importc: "AccessCheckAndAuditAlarmA".}
proc ObjectOpenAuditAlarmA*(SubsystemName: LPCSTR, HandleId: LPVOID,
                            ObjectTypeName: LPSTR, ObjectName: LPSTR,
                            pSecurityDescriptor: PSECURITY_DESCRIPTOR,
                            ClientToken: HANDLE, DesiredAccess: DWORD,
                            GrantedAccess: DWORD, Privileges: PPRIVILEGE_SET,
                            ObjectCreation: WINBOOL, AccessGranted: WINBOOL,
                            GenerateOnClose: LPBOOL): WINBOOL{.stdcall,
    dynlib: "advapi32", importc: "ObjectOpenAuditAlarmA".}
proc ObjectPrivilegeAuditAlarmA*(SubsystemName: LPCSTR, HandleId: LPVOID,
                                 ClientToken: HANDLE, DesiredAccess: DWORD,
                                 Privileges: PPRIVILEGE_SET,
                                 AccessGranted: WINBOOL): WINBOOL{.stdcall,
    dynlib: "advapi32", importc: "ObjectPrivilegeAuditAlarmA".}
proc ObjectCloseAuditAlarmA*(SubsystemName: LPCSTR, HandleId: LPVOID,
                             GenerateOnClose: WINBOOL): WINBOOL{.stdcall,
    dynlib: "advapi32", importc: "ObjectCloseAuditAlarmA".}
proc PrivilegedServiceAuditAlarmA*(SubsystemName: LPCSTR, ServiceName: LPCSTR,
                                   ClientToken: HANDLE,
                                   Privileges: PPRIVILEGE_SET,
                                   AccessGranted: WINBOOL): WINBOOL{.stdcall,
    dynlib: "advapi32", importc: "PrivilegedServiceAuditAlarmA".}
proc SetFileSecurityA*(lpFileName: LPCSTR,
                       SecurityInformation: SECURITY_INFORMATION,
                       pSecurityDescriptor: PSECURITY_DESCRIPTOR): WINBOOL{.
    stdcall, dynlib: "advapi32", importc: "SetFileSecurityA".}
proc GetFileSecurityA*(lpFileName: LPCSTR,
                       RequestedInformation: SECURITY_INFORMATION,
                       pSecurityDescriptor: PSECURITY_DESCRIPTOR,
                       nLength: DWORD, lpnLengthNeeded: LPDWORD): WINBOOL{.
    stdcall, dynlib: "advapi32", importc: "GetFileSecurityA".}
proc FindFirstChangeNotificationA*(lpPathName: LPCSTR, bWatchSubtree: WINBOOL,
                                   dwNotifyFilter: DWORD): HANDLE{.stdcall,
    dynlib: "kernel32", importc: "FindFirstChangeNotificationA".}
proc IsBadStringPtrA*(lpsz: LPCSTR, ucchMax: UINT): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "IsBadStringPtrA".}
proc LookupAccountSidA*(lpSystemName: LPCSTR, Sid: PSID, Name: LPSTR,
                        cbName: LPDWORD, ReferencedDomainName: LPSTR,
                        cbReferencedDomainName: LPDWORD, peUse: PSID_NAME_USE): WINBOOL{.
    stdcall, dynlib: "advapi32", importc: "LookupAccountSidA".}
proc LookupAccountNameA*(lpSystemName: LPCSTR, lpAccountName: LPCSTR, Sid: PSID,
                         cbSid: LPDWORD, ReferencedDomainName: LPSTR,
                         cbReferencedDomainName: LPDWORD, peUse: PSID_NAME_USE): WINBOOL{.
    stdcall, dynlib: "advapi32", importc: "LookupAccountNameA".}
proc LookupPrivilegeValueA*(lpSystemName: LPCSTR, lpName: LPCSTR, lpLuid: PLUID): WINBOOL{.
    stdcall, dynlib: "advapi32", importc: "LookupPrivilegeValueA".}
proc LookupPrivilegeNameA*(lpSystemName: LPCSTR, lpLuid: PLUID, lpName: LPSTR,
                           cbName: LPDWORD): WINBOOL{.stdcall,
    dynlib: "advapi32", importc: "LookupPrivilegeNameA".}
proc LookupPrivilegeDisplayNameA*(lpSystemName: LPCSTR, lpName: LPCSTR,
                                  lpDisplayName: LPSTR, cbDisplayName: LPDWORD,
                                  lpLanguageId: LPDWORD): WINBOOL{.stdcall,
    dynlib: "advapi32", importc: "LookupPrivilegeDisplayNameA".}
proc BuildCommDCBA*(lpDef: LPCSTR, lpDCB: LPDCB): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "BuildCommDCBA".}
proc BuildCommDCBAndTimeoutsA*(lpDef: LPCSTR, lpDCB: LPDCB,
                               lpCommTimeouts: LPCOMMTIMEOUTS): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "BuildCommDCBAndTimeoutsA".}
proc CommConfigDialogA*(lpszName: LPCSTR, wnd: HWND, lpCC: LPCOMMCONFIG): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "CommConfigDialogA".}
proc GetDefaultCommConfigA*(lpszName: LPCSTR, lpCC: LPCOMMCONFIG,
                            lpdwSize: LPDWORD): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "GetDefaultCommConfigA".}
proc SetDefaultCommConfigA*(lpszName: LPCSTR, lpCC: LPCOMMCONFIG, dwSize: DWORD): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "SetDefaultCommConfigA".}
proc GetComputerNameA*(lpBuffer: LPSTR, nSize: LPDWORD): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "GetComputerNameA".}
proc SetComputerNameA*(lpComputerName: LPCSTR): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "SetComputerNameA".}
proc GetUserNameA*(lpBuffer: LPSTR, nSize: LPDWORD): WINBOOL{.stdcall,
    dynlib: "advapi32", importc: "GetUserNameA".}
proc LoadKeyboardLayoutA*(pwszKLID: LPCSTR, Flags: UINT): HKL{.stdcall,
    dynlib: "user32", importc: "LoadKeyboardLayoutA".}
proc GetKeyboardLayoutNameA*(pwszKLID: LPSTR): WINBOOL{.stdcall,
    dynlib: "user32", importc: "GetKeyboardLayoutNameA".}
proc CreateDesktopA*(lpszDesktop: LPSTR, lpszDevice: LPSTR, pDevmode: LPDEVMODE,
                     dwFlags: DWORD, dwDesiredAccess: DWORD,
                     lpsa: LPSECURITY_ATTRIBUTES): HDESK{.stdcall,
    dynlib: "user32", importc: "CreateDesktopA".}
proc OpenDesktopA*(lpszDesktop: LPSTR, dwFlags: DWORD, fInherit: WINBOOL,
                   dwDesiredAccess: DWORD): HDESK{.stdcall, dynlib: "user32",
    importc: "OpenDesktopA".}
proc EnumDesktopsA*(hwinsta: HWINSTA, lpEnumFunc: DESKTOPENUMPROC,
                    lp: LPARAM): WINBOOL{.stdcall, dynlib: "user32",
    importc: "EnumDesktopsA".}
proc CreateWindowStationA*(lpwinsta: LPSTR, dwReserved: DWORD,
                           dwDesiredAccess: DWORD, lpsa: LPSECURITY_ATTRIBUTES): HWINSTA{.
    stdcall, dynlib: "user32", importc: "CreateWindowStationA".}
proc OpenWindowStationA*(lpszWinSta: LPSTR, fInherit: WINBOOL,
                         dwDesiredAccess: DWORD): HWINSTA{.stdcall,
    dynlib: "user32", importc: "OpenWindowStationA".}
proc EnumWindowStationsA*(lpEnumFunc: ENUMWINDOWSTATIONPROC, lp: LPARAM): WINBOOL{.
    stdcall, dynlib: "user32", importc: "EnumWindowStationsA".}
proc GetUserObjectInformationA*(hObj: HANDLE, nIndex: int32, pvInfo: PVOID,
                                nLength: DWORD, lpnLengthNeeded: LPDWORD): WINBOOL{.
    stdcall, dynlib: "user32", importc: "GetUserObjectInformationA".}
proc SetUserObjectInformationA*(hObj: HANDLE, nIndex: int32, pvInfo: PVOID,
                                nLength: DWORD): WINBOOL{.stdcall,
    dynlib: "user32", importc: "SetUserObjectInformationA".}
proc RegisterWindowMessageA*(lpString: LPCSTR): UINT{.stdcall, dynlib: "user32",
    importc: "RegisterWindowMessageA".}
proc GetMessageA*(lpMsg: LPMSG, wnd: HWND, wMsgFilterMin: UINT,
                  wMsgFilterMax: UINT): WINBOOL{.stdcall, dynlib: "user32",
    importc: "GetMessageA".}
proc DispatchMessageA*(lpMsg: LPMSG): LONG{.stdcall, dynlib: "user32",
    importc: "DispatchMessageA".}
proc PeekMessageA*(lpMsg: LPMSG, wnd: HWND, wMsgFilterMin: UINT,
                   wMsgFilterMax: UINT, wRemoveMsg: UINT): WINBOOL{.stdcall,
    dynlib: "user32", importc: "PeekMessageA".}
proc SendMessageA*(wnd: HWND, Msg: UINT, wp: WPARAM, lp: LPARAM): LRESULT{.
    stdcall, dynlib: "user32", importc: "SendMessageA".}
proc SendMessageTimeoutA*(wnd: HWND, Msg: UINT, wp: WPARAM, lp: LPARAM,
                          fuFlags: UINT, uTimeout: UINT, lpdwResult: LPDWORD): LRESULT{.
    stdcall, dynlib: "user32", importc: "SendMessageTimeoutA".}
proc SendNotifyMessageA*(wnd: HWND, Msg: UINT, wp: WPARAM, lp: LPARAM): WINBOOL{.
    stdcall, dynlib: "user32", importc: "SendNotifyMessageA".}
proc SendMessageCallbackA*(wnd: HWND, Msg: UINT, wp: WPARAM,
                           lp: LPARAM, lpResultCallBack: SENDASYNCPROC,
                           dwData: DWORD): WINBOOL{.stdcall, dynlib: "user32",
    importc: "SendMessageCallbackA".}
proc PostMessageA*(wnd: HWND, Msg: UINT, wp: WPARAM, lp: LPARAM): WINBOOL{.
    stdcall, dynlib: "user32", importc: "PostMessageA".}
proc PostThreadMessageA*(idThread: DWORD, Msg: UINT, wp: WPARAM,
                         lp: LPARAM): WINBOOL{.stdcall, dynlib: "user32",
    importc: "PostThreadMessageA".}
proc DefWindowProcA*(wnd: HWND, Msg: UINT, wp: WPARAM, lp: LPARAM): LRESULT{.
    stdcall, dynlib: "user32", importc: "DefWindowProcA".}
proc CallWindowProcA*(lpPrevWndFunc: WNDPROC, wnd: HWND, Msg: UINT,
                      wp: WPARAM, lp: LPARAM): LRESULT{.stdcall,
    dynlib: "user32", importc: "CallWindowProcA".}
proc RegisterClassA*(lpWndClass: LPWNDCLASS): ATOM{.stdcall, dynlib: "user32",
    importc: "RegisterClassA".}
proc UnregisterClassA*(lpClassName: LPCSTR, hInstance: HINST): WINBOOL{.stdcall,
    dynlib: "user32", importc: "UnregisterClassA".}
proc GetClassInfoA*(hInstance: HINST, lpClassName: LPCSTR,
                    lpWndClass: LPWNDCLASS): WINBOOL{.stdcall, dynlib: "user32",
    importc: "GetClassInfoA".}
proc RegisterClassExA*(para1: LPWNDCLASSEX): ATOM{.stdcall, dynlib: "user32",
    importc: "RegisterClassExA".}
proc GetClassInfoExA*(para1: HINST, para2: LPCSTR, para3: LPWNDCLASSEX): WINBOOL{.
    stdcall, dynlib: "user32", importc: "GetClassInfoExA".}
proc CreateWindowExA*(dwExStyle: DWORD, lpClassName: LPCSTR,
                      lpWindowName: LPCSTR, dwStyle: DWORD, X: int32, Y: int32,
                      nWidth: int32, nHeight: int32, hWndParent: HWND,
                      menu: HMENU, hInstance: HINST, lpParam: LPVOID): HWND{.
    stdcall, dynlib: "user32", importc: "CreateWindowExA".}
proc CreateDialogParamA*(hInstance: HINST, lpTemplateName: LPCSTR,
                         hWndParent: HWND, lpDialogFunc: DLGPROC,
                         dwInitParam: LPARAM): HWND{.stdcall, dynlib: "user32",
    importc: "CreateDialogParamA".}
proc CreateDialogIndirectParamA*(hInstance: HINST, lpTemplate: LPCDLGTEMPLATE,
                                 hWndParent: HWND, lpDialogFunc: DLGPROC,
                                 dwInitParam: LPARAM): HWND{.stdcall,
    dynlib: "user32", importc: "CreateDialogIndirectParamA".}
proc DialogBoxParamA*(hInstance: HINST, lpTemplateName: LPCSTR,
                      hWndParent: HWND, lpDialogFunc: DLGPROC,
                      dwInitParam: LPARAM): int32{.stdcall, dynlib: "user32",
    importc: "DialogBoxParamA".}
proc DialogBoxIndirectParamA*(hInstance: HINST, hDialogTemplate: LPCDLGTEMPLATE,
                              hWndParent: HWND, lpDialogFunc: DLGPROC,
                              dwInitParam: LPARAM): int32{.stdcall,
    dynlib: "user32", importc: "DialogBoxIndirectParamA".}
proc SetDlgItemTextA*(hDlg: HWND, nIDDlgItem: int32, lpString: LPCSTR): WINBOOL{.
    stdcall, dynlib: "user32", importc: "SetDlgItemTextA".}
proc GetDlgItemTextA*(hDlg: HWND, nIDDlgItem: int32, lpString: LPSTR,
                      nMaxCount: int32): UINT{.stdcall, dynlib: "user32",
    importc: "GetDlgItemTextA".}
proc SendDlgItemMessageA*(hDlg: HWND, nIDDlgItem: int32, Msg: UINT,
                          wp: WPARAM, lp: LPARAM): LONG{.stdcall,
    dynlib: "user32", importc: "SendDlgItemMessageA".}
proc DefDlgProcA*(hDlg: HWND, Msg: UINT, wp: WPARAM, lp: LPARAM): LRESULT{.
    stdcall, dynlib: "user32", importc: "DefDlgProcA".}
proc CallMsgFilterA*(lpMsg: LPMSG, nCode: int32): WINBOOL{.stdcall,
    dynlib: "user32", importc: "CallMsgFilterA".}
proc RegisterClipboardFormatA*(lpszFormat: LPCSTR): UINT{.stdcall,
    dynlib: "user32", importc: "RegisterClipboardFormatA".}
proc GetClipboardFormatNameA*(format: UINT, lpszFormatName: LPSTR,
                              cchMaxCount: int32): int32{.stdcall,
    dynlib: "user32", importc: "GetClipboardFormatNameA".}
proc CharToOemA*(lpszSrc: LPCSTR, lpszDst: LPSTR): WINBOOL{.stdcall,
    dynlib: "user32", importc: "CharToOemA".}
proc OemToCharA*(lpszSrc: LPCSTR, lpszDst: LPSTR): WINBOOL{.stdcall,
    dynlib: "user32", importc: "OemToCharA".}
proc CharToOemBuffA*(lpszSrc: LPCSTR, lpszDst: LPSTR, cchDstLength: DWORD): WINBOOL{.
    stdcall, dynlib: "user32", importc: "CharToOemBuffA".}
proc OemToCharBuffA*(lpszSrc: LPCSTR, lpszDst: LPSTR, cchDstLength: DWORD): WINBOOL{.
    stdcall, dynlib: "user32", importc: "OemToCharBuffA".}
proc CharUpperA*(lpsz: LPSTR): LPSTR{.stdcall, dynlib: "user32",
                                      importc: "CharUpperA".}
proc CharUpperBuffA*(lpsz: LPSTR, cchLength: DWORD): DWORD{.stdcall,
    dynlib: "user32", importc: "CharUpperBuffA".}
proc CharLowerA*(lpsz: LPSTR): LPSTR{.stdcall, dynlib: "user32",
                                      importc: "CharLowerA".}
proc CharLowerBuffA*(lpsz: LPSTR, cchLength: DWORD): DWORD{.stdcall,
    dynlib: "user32", importc: "CharLowerBuffA".}
proc CharNextA*(lpsz: LPCSTR): LPSTR{.stdcall, dynlib: "user32",
                                      importc: "CharNextA".}
proc CharPrevA*(lpszStart: LPCSTR, lpszCurrent: LPCSTR): LPSTR{.stdcall,
    dynlib: "user32", importc: "CharPrevA".}
proc IsCharAlphaA*(ch: CHAR): WINBOOL{.stdcall, dynlib: "user32",
                                       importc: "IsCharAlphaA".}
proc IsCharAlphaNumericA*(ch: CHAR): WINBOOL{.stdcall, dynlib: "user32",
    importc: "IsCharAlphaNumericA".}
proc IsCharUpperA*(ch: CHAR): WINBOOL{.stdcall, dynlib: "user32",
                                       importc: "IsCharUpperA".}
proc IsCharLowerA*(ch: CHAR): WINBOOL{.stdcall, dynlib: "user32",
                                       importc: "IsCharLowerA".}
proc GetKeyNameTextA*(lParam: LONG, lpString: LPSTR, nSize: int32): int32{.
    stdcall, dynlib: "user32", importc: "GetKeyNameTextA".}
proc VkKeyScanA*(ch: CHAR): SHORT{.stdcall, dynlib: "user32",
                                   importc: "VkKeyScanA".}
proc VkKeyScanExA*(ch: CHAR, dwhkl: HKL): SHORT{.stdcall, dynlib: "user32",
    importc: "VkKeyScanExA".}
proc MapVirtualKeyA*(uCode: UINT, uMapType: UINT): UINT{.stdcall,
    dynlib: "user32", importc: "MapVirtualKeyA".}
proc MapVirtualKeyExA*(uCode: UINT, uMapType: UINT, dwhkl: HKL): UINT{.stdcall,
    dynlib: "user32", importc: "MapVirtualKeyExA".}
proc LoadAcceleratorsA*(hInstance: HINST, lpTableName: LPCSTR): HACCEL{.stdcall,
    dynlib: "user32", importc: "LoadAcceleratorsA".}
proc CreateAcceleratorTableA*(para1: LPACCEL, para2: int32): HACCEL{.stdcall,
    dynlib: "user32", importc: "CreateAcceleratorTableA".}
proc CopyAcceleratorTableA*(hAccelSrc: HACCEL, lpAccelDst: LPACCEL,
                            cAccelEntries: int32): int32{.stdcall,
    dynlib: "user32", importc: "CopyAcceleratorTableA".}
proc TranslateAcceleratorA*(wnd: HWND, hAccTable: HACCEL, lpMsg: LPMSG): int32{.
    stdcall, dynlib: "user32", importc: "TranslateAcceleratorA".}
proc LoadMenuA*(hInstance: HINST, lpMenuName: LPCSTR): HMENU{.stdcall,
    dynlib: "user32", importc: "LoadMenuA".}
proc LoadMenuIndirectA*(lpMenuTemplate: LPMENUTEMPLATE): HMENU{.stdcall,
    dynlib: "user32", importc: "LoadMenuIndirectA".}
proc ChangeMenuA*(menu: HMENU, cmd: UINT, lpszNewItem: LPCSTR, cmdInsert: UINT,
                  flags: UINT): WINBOOL{.stdcall, dynlib: "user32",
    importc: "ChangeMenuA".}
proc GetMenuStringA*(menu: HMENU, uIDItem: UINT, lpString: LPSTR,
                     nMaxCount: int32, uFlag: UINT): int32{.stdcall,
    dynlib: "user32", importc: "GetMenuStringA".}
proc InsertMenuA*(menu: HMENU, uPosition: UINT, uFlags: UINT, uIDNewItem: UINT,
                  lpNewItem: LPCSTR): WINBOOL{.stdcall, dynlib: "user32",
    importc: "InsertMenuA".}
proc AppendMenuA*(menu: HMENU, uFlags: UINT, uIDNewItem: UINT,
                  lpNewItem: LPCSTR): WINBOOL{.stdcall, dynlib: "user32",
    importc: "AppendMenuA".}
proc ModifyMenuA*(hMnu: HMENU, uPosition: UINT, uFlags: UINT, uIDNewItem: UINT,
                  lpNewItem: LPCSTR): WINBOOL{.stdcall, dynlib: "user32",
    importc: "ModifyMenuA".}
proc InsertMenuItemA*(para1: HMENU, para2: UINT, para3: WINBOOL,
                      para4: LPCMENUITEMINFO): WINBOOL{.stdcall,
    dynlib: "user32", importc: "InsertMenuItemA".}
proc GetMenuItemInfoA*(para1: HMENU, para2: UINT, para3: WINBOOL,
                       para4: LPMENUITEMINFO): WINBOOL{.stdcall,
    dynlib: "user32", importc: "GetMenuItemInfoA".}
proc SetMenuItemInfoA*(para1: HMENU, para2: UINT, para3: WINBOOL,
                       para4: LPCMENUITEMINFO): WINBOOL{.stdcall,
    dynlib: "user32", importc: "SetMenuItemInfoA".}
proc DrawTextA*(hDC: HDC, lpString: LPCSTR, nCount: int32, lpRect: LPRECT,
                uFormat: UINT): int32{.stdcall, dynlib: "user32",
                                       importc: "DrawTextA".}
proc DrawTextExA*(para1: HDC, para2: LPSTR, para3: int32, para4: LPRECT,
                  para5: UINT, para6: LPDRAWTEXTPARAMS): int32{.stdcall,
    dynlib: "user32", importc: "DrawTextExA".}
proc GrayStringA*(hDC: HDC, hBrush: HBRUSH, lpOutputFunc: GRAYSTRINGPROC,
                  lpData: LPARAM, nCount: int32, X: int32, Y: int32,
                  nWidth: int32, nHeight: int32): WINBOOL{.stdcall,
    dynlib: "user32", importc: "GrayStringA".}
proc DrawStateA*(para1: HDC, para2: HBRUSH, para3: DRAWSTATEPROC, para4: LPARAM,
                 para5: WPARAM, para6: int32, para7: int32, para8: int32,
                 para9: int32, para10: UINT): WINBOOL{.stdcall,
    dynlib: "user32", importc: "DrawStateA".}
proc TabbedTextOutA*(hDC: HDC, X: int32, Y: int32, lpString: LPCSTR,
                     nCount: int32, nTabPositions: int32,
                     lpnTabStopPositions: LPINT, nTabOrigin: int32): LONG{.
    stdcall, dynlib: "user32", importc: "TabbedTextOutA".}
proc GetTabbedTextExtentA*(hDC: HDC, lpString: LPCSTR, nCount: int32,
                           nTabPositions: int32, lpnTabStopPositions: LPINT): DWORD{.
    stdcall, dynlib: "user32", importc: "GetTabbedTextExtentA".}
proc SetPropA*(wnd: HWND, lpString: LPCSTR, hData: HANDLE): WINBOOL{.stdcall,
    dynlib: "user32", importc: "SetPropA".}
proc GetPropA*(wnd: HWND, lpString: LPCSTR): HANDLE{.stdcall, dynlib: "user32",
    importc: "GetPropA".}
proc RemovePropA*(wnd: HWND, lpString: LPCSTR): HANDLE{.stdcall,
    dynlib: "user32", importc: "RemovePropA".}
proc EnumPropsExA*(wnd: HWND, lpEnumFunc: PROPENUMPROCEX, lp: LPARAM): int32{.
    stdcall, dynlib: "user32", importc: "EnumPropsExA".}
proc EnumPropsA*(wnd: HWND, lpEnumFunc: PROPENUMPROC): int32{.stdcall,
    dynlib: "user32", importc: "EnumPropsA".}
proc SetWindowTextA*(wnd: HWND, lpString: LPCSTR): WINBOOL{.stdcall,
    dynlib: "user32", importc: "SetWindowTextA".}
proc GetWindowTextA*(wnd: HWND, lpString: LPSTR, nMaxCount: int32): int32{.
    stdcall, dynlib: "user32", importc: "GetWindowTextA".}
proc GetWindowTextLengthA*(wnd: HWND): int32{.stdcall, dynlib: "user32",
    importc: "GetWindowTextLengthA".}
proc MessageBoxA*(wnd: HWND, lpText: LPCSTR, lpCaption: LPCSTR, uType: int): int32{.
    stdcall, dynlib: "user32", importc: "MessageBoxA".}
proc MessageBoxExA*(wnd: HWND, lpText: LPCSTR, lpCaption: LPCSTR, uType: UINT,
                    wLanguageId: int16): int32{.stdcall, dynlib: "user32",
    importc: "MessageBoxExA".}
proc MessageBoxIndirectA*(para1: LPMSGBOXPARAMS): int32{.stdcall,
    dynlib: "user32", importc: "MessageBoxIndirectA".}
proc GetWindowLongA*(wnd: HWND, nIndex: int32): LONG{.stdcall,
    dynlib: "user32", importc: "GetWindowLongA".}
proc SetWindowLongA*(wnd: HWND, nIndex: int32, dwNewLong: LONG): LONG{.stdcall,
    dynlib: "user32", importc: "SetWindowLongA".}
proc GetClassLongA*(wnd: HWND, nIndex: int32): DWORD{.stdcall,
    dynlib: "user32", importc: "GetClassLongA".}
proc SetClassLongA*(wnd: HWND, nIndex: int32, dwNewLong: LONG): DWORD{.stdcall,
    dynlib: "user32", importc: "SetClassLongA".}
when defined(cpu64):
  proc GetWindowLongPtrA*(wnd: HWND, nIndex: int32): LONG_PTR{.stdcall,
      dynlib: "user32", importc: "GetWindowLongPtrA".}
  proc SetWindowLongPtrA*(wnd: HWND, nIndex: int32, dwNewLong: LONG_PTR): LONG_PTR{.
      stdcall, dynlib: "user32", importc: "SetWindowLongPtrA".}
  proc GetClassLongPtrA*(wnd: HWND, nIndex: int32): LONG_PTR{.stdcall,
      dynlib: "user32", importc: "GetClassLongPtrA".}
  proc SetClassLongPtrA*(wnd: HWND, nIndex: int32, dwNewLong: LONG_PTR): LONG_PTR{.
      stdcall, dynlib: "user32", importc: "SetClassLongPtrA".}
else:
  proc GetWindowLongPtrA*(wnd: HWND, nIndex: int32): LONG_PTR{.stdcall,
      dynlib: "user32", importc: "GetWindowLongA".}
  proc SetWindowLongPtrA*(wnd: HWND, nIndex: int32, dwNewLong: LONG_PTR): LONG_PTR{.
      stdcall, dynlib: "user32", importc: "SetWindowLongA".}
  proc GetClassLongPtrA*(wnd: HWND, nIndex: int32): LONG_PTR{.stdcall,
      dynlib: "user32", importc: "GetClassLongA".}
  proc SetClassLongPtrA*(wnd: HWND, nIndex: int32, dwNewLong: LONG_PTR): LONG_PTR{.
      stdcall, dynlib: "user32", importc: "SetClassLongA".}
proc FindWindowA*(lpClassName: LPCSTR, lpWindowName: LPCSTR): HWND{.stdcall,
    dynlib: "user32", importc: "FindWindowA".}
proc FindWindowExA*(para1: HWND, para2: HWND, para3: LPCSTR, para4: LPCSTR): HWND{.
    stdcall, dynlib: "user32", importc: "FindWindowExA".}
proc GetClassNameA*(wnd: HWND, lpClassName: LPSTR, nMaxCount: int32): int32{.
    stdcall, dynlib: "user32", importc: "GetClassNameA".}
proc SetWindowsHookExA*(idHook: int32, lpfn: HOOKPROC, hmod: HINST,
                        dwThreadId: DWORD): HHOOK{.stdcall, dynlib: "user32",
    importc: "SetWindowsHookExA".}
proc LoadBitmapA*(hInstance: HINST, lpBitmapName: LPCSTR): HBITMAP{.stdcall,
    dynlib: "user32", importc: "LoadBitmapA".}
proc LoadCursorA*(hInstance: HINST, lpCursorName: LPCSTR): HCURSOR{.stdcall,
    dynlib: "user32", importc: "LoadCursorA".}
proc LoadCursorFromFileA*(lpFileName: LPCSTR): HCURSOR{.stdcall,
    dynlib: "user32", importc: "LoadCursorFromFileA".}
proc LoadIconA*(hInstance: HINST, lpIconName: LPCSTR): HICON{.stdcall,
    dynlib: "user32", importc: "LoadIconA".}
proc LoadImageA*(para1: HINST, para2: LPCSTR, para3: UINT, para4: int32,
                 para5: int32, para6: UINT): HANDLE{.stdcall, dynlib: "user32",
    importc: "LoadImageA".}
proc LoadStringA*(hInstance: HINST, uID: UINT, lpBuffer: LPSTR,
                  nBufferMax: int32): int32{.stdcall, dynlib: "user32",
    importc: "LoadStringA".}
proc IsDialogMessageA*(hDlg: HWND, lpMsg: LPMSG): WINBOOL{.stdcall,
    dynlib: "user32", importc: "IsDialogMessageA".}
proc DlgDirListA*(hDlg: HWND, lpPathSpec: LPSTR, nIDListBox: int32,
                  nIDStaticPath: int32, uFileType: UINT): int32{.stdcall,
    dynlib: "user32", importc: "DlgDirListA".}
proc DlgDirSelectExA*(hDlg: HWND, lpString: LPSTR, nCount: int32,
                      nIDListBox: int32): WINBOOL{.stdcall, dynlib: "user32",
    importc: "DlgDirSelectExA".}
proc DlgDirListComboBoxA*(hDlg: HWND, lpPathSpec: LPSTR, nIDComboBox: int32,
                          nIDStaticPath: int32, uFiletype: UINT): int32{.
    stdcall, dynlib: "user32", importc: "DlgDirListComboBoxA".}
proc DlgDirSelectComboBoxExA*(hDlg: HWND, lpString: LPSTR, nCount: int32,
                              nIDComboBox: int32): WINBOOL{.stdcall,
    dynlib: "user32", importc: "DlgDirSelectComboBoxExA".}
proc DefFrameProcA*(wnd: HWND, hWndMDIClient: HWND, uMsg: UINT, wp: WPARAM,
                    lp: LPARAM): LRESULT{.stdcall, dynlib: "user32",
    importc: "DefFrameProcA".}
proc DefMDIChildProcA*(wnd: HWND, uMsg: UINT, wp: WPARAM, lp: LPARAM): LRESULT{.
    stdcall, dynlib: "user32", importc: "DefMDIChildProcA".}
proc CreateMDIWindowA*(lpClassName: LPSTR, lpWindowName: LPSTR, dwStyle: DWORD,
                       X: int32, Y: int32, nWidth: int32, nHeight: int32,
                       hWndParent: HWND, hInstance: HINST, lp: LPARAM): HWND{.
    stdcall, dynlib: "user32", importc: "CreateMDIWindowA".}
proc WinHelpA*(hWndMain: HWND, lpszHelp: LPCSTR, uCommand: UINT, dwData: DWORD): WINBOOL{.
    stdcall, dynlib: "user32", importc: "WinHelpA".}
proc ChangeDisplaySettingsA*(lpDevMode: LPDEVMODE, dwFlags: DWORD): LONG{.
    stdcall, dynlib: "user32", importc: "ChangeDisplaySettingsA".}
proc EnumDisplaySettingsA*(lpszDeviceName: LPCSTR, iModeNum: DWORD,
                           lpDevMode: LPDEVMODE): WINBOOL{.stdcall,
    dynlib: "user32", importc: "EnumDisplaySettingsA".}
proc SystemParametersInfoA*(uiAction: UINT, uiParam: UINT, pvParam: PVOID,
                            fWinIni: UINT): WINBOOL{.stdcall, dynlib: "user32",
    importc: "SystemParametersInfoA".}
proc AddFontResourceA*(para1: LPCSTR): int32{.stdcall, dynlib: "gdi32",
    importc: "AddFontResourceA".}
proc CopyMetaFileA*(para1: HMETAFILE, para2: LPCSTR): HMETAFILE{.stdcall,
    dynlib: "gdi32", importc: "CopyMetaFileA".}
proc CreateFontA*(para1: int32, para2: int32, para3: int32, para4: int32,
                  para5: int32, para6: DWORD, para7: DWORD, para8: DWORD,
                  para9: DWORD, para10: DWORD, para11: DWORD, para12: DWORD,
                  para13: DWORD, para14: LPCSTR): HFONT{.stdcall,
    dynlib: "gdi32", importc: "CreateFontA".}
proc CreateFontIndirectA*(para1: LPLOGFONT): HFONT{.stdcall, dynlib: "gdi32",
    importc: "CreateFontIndirectA".}
proc CreateFontIndirectA*(para1: var LOGFONT): HFONT{.stdcall, dynlib: "gdi32",
    importc: "CreateFontIndirectA".}
proc CreateICA*(para1: LPCSTR, para2: LPCSTR, para3: LPCSTR, para4: LPDEVMODE): HDC{.
    stdcall, dynlib: "gdi32", importc: "CreateICA".}
proc CreateMetaFileA*(para1: LPCSTR): HDC{.stdcall, dynlib: "gdi32",
    importc: "CreateMetaFileA".}
proc CreateScalableFontResourceA*(para1: DWORD, para2: LPCSTR, para3: LPCSTR,
                                  para4: LPCSTR): WINBOOL{.stdcall,
    dynlib: "gdi32", importc: "CreateScalableFontResourceA".}
proc EnumFontFamiliesExA*(para1: HDC, para2: LPLOGFONT, para3: FONTENUMEXPROC,
                          para4: LPARAM, para5: DWORD): int32{.stdcall,
    dynlib: "gdi32", importc: "EnumFontFamiliesExA".}
proc EnumFontFamiliesA*(para1: HDC, para2: LPCSTR, para3: FONTENUMPROC,
                        para4: LPARAM): int32{.stdcall, dynlib: "gdi32",
    importc: "EnumFontFamiliesA".}
proc EnumFontsA*(para1: HDC, para2: LPCSTR, para3: ENUMFONTSPROC, para4: LPARAM): int32{.
    stdcall, dynlib: "gdi32", importc: "EnumFontsA".}
proc EnumFontsA*(para1: HDC, para2: LPCSTR, para3: ENUMFONTSPROC, para4: pointer): int32{.
    stdcall, dynlib: "gdi32", importc: "EnumFontsA".}
proc GetCharWidthA*(para1: HDC, para2: UINT, para3: UINT, para4: LPINT): WINBOOL{.
    stdcall, dynlib: "gdi32", importc: "GetCharWidthA".}
proc GetCharWidth32A*(para1: HDC, para2: UINT, para3: UINT, para4: LPINT): WINBOOL{.
    stdcall, dynlib: "gdi32", importc: "GetCharWidth32A".}
proc GetCharWidthFloatA*(para1: HDC, para2: UINT, para3: UINT, para4: ptr float32): WINBOOL{.
    stdcall, dynlib: "gdi32", importc: "GetCharWidthFloatA".}
proc GetCharABCWidthsA*(para1: HDC, para2: UINT, para3: UINT, para4: LPABC): WINBOOL{.
    stdcall, dynlib: "gdi32", importc: "GetCharABCWidthsA".}
proc GetCharABCWidthsFloatA*(para1: HDC, para2: UINT, para3: UINT,
                             para4: LPABCFLOAT): WINBOOL{.stdcall,
    dynlib: "gdi32", importc: "GetCharABCWidthsFloatA".}
proc GetGlyphOutlineA*(para1: HDC, para2: UINT, para3: UINT,
                       para4: LPGLYPHMETRICS, para5: DWORD, para6: LPVOID,
                       para7: PMAT2): DWORD{.stdcall, dynlib: "gdi32",
    importc: "GetGlyphOutlineA".}
proc GetMetaFileA*(para1: LPCSTR): HMETAFILE{.stdcall, dynlib: "gdi32",
    importc: "GetMetaFileA".}
proc GetOutlineTextMetricsA*(para1: HDC, para2: UINT, para3: LPOUTLINETEXTMETRIC): UINT{.
    stdcall, dynlib: "gdi32", importc: "GetOutlineTextMetricsA".}
proc GetTextExtentPointA*(para1: HDC, para2: LPCSTR, para3: int32, para4: LPSIZE): WINBOOL{.
    stdcall, dynlib: "gdi32", importc: "GetTextExtentPointA".}
proc GetTextExtentPoint32A*(para1: HDC, para2: LPCSTR, para3: int32,
                            para4: LPSIZE): WINBOOL{.stdcall, dynlib: "gdi32",
    importc: "GetTextExtentPoint32A".}
proc GetTextExtentExPointA*(para1: HDC, para2: LPCSTR, para3: int32,
                            para4: int32, para5: LPINT, para6: LPINT,
                            para7: LPSIZE): WINBOOL{.stdcall, dynlib: "gdi32",
    importc: "GetTextExtentExPointA".}
proc GetCharacterPlacementA*(para1: HDC, para2: LPCSTR, para3: int32,
                             para4: int32, para5: LPGCP_RESULTS, para6: DWORD): DWORD{.
    stdcall, dynlib: "gdi32", importc: "GetCharacterPlacementA".}
proc ResetDCA*(para1: HDC, para2: LPDEVMODE): HDC{.stdcall, dynlib: "gdi32",
    importc: "ResetDCA".}
proc RemoveFontResourceA*(para1: LPCSTR): WINBOOL{.stdcall, dynlib: "gdi32",
    importc: "RemoveFontResourceA".}
proc CopyEnhMetaFileA*(para1: HENHMETAFILE, para2: LPCSTR): HENHMETAFILE{.
    stdcall, dynlib: "gdi32", importc: "CopyEnhMetaFileA".}
proc CreateEnhMetaFileA*(para1: HDC, para2: LPCSTR, para3: LPRECT, para4: LPCSTR): HDC{.
    stdcall, dynlib: "gdi32", importc: "CreateEnhMetaFileA".}
proc GetEnhMetaFileA*(para1: LPCSTR): HENHMETAFILE{.stdcall, dynlib: "gdi32",
    importc: "GetEnhMetaFileA".}
proc GetEnhMetaFileDescriptionA*(para1: HENHMETAFILE, para2: UINT, para3: LPSTR): UINT{.
    stdcall, dynlib: "gdi32", importc: "GetEnhMetaFileDescriptionA".}
proc GetTextMetricsA*(para1: HDC, para2: LPTEXTMETRIC): WINBOOL{.stdcall,
    dynlib: "gdi32", importc: "GetTextMetricsA".}
proc StartDocA*(para1: HDC, para2: PDOCINFO): int32{.stdcall, dynlib: "gdi32",
    importc: "StartDocA".}
proc GetObjectA*(para1: HGDIOBJ, para2: int32, para3: LPVOID): int32{.stdcall,
    dynlib: "gdi32", importc: "GetObjectA".}
proc TextOutA*(para1: HDC, para2: int32, para3: int32, para4: LPCSTR,
               para5: int32): WINBOOL{.stdcall, dynlib: "gdi32",
                                       importc: "TextOutA".}
proc ExtTextOutA*(para1: HDC, para2: int32, para3: int32, para4: UINT,
                  para5: LPRECT, para6: LPCSTR, para7: UINT, para8: LPINT): WINBOOL{.
    stdcall, dynlib: "gdi32", importc: "ExtTextOutA".}
proc PolyTextOutA*(para1: HDC, para2: PPOLYTEXT, para3: int32): WINBOOL{.
    stdcall, dynlib: "gdi32", importc: "PolyTextOutA".}
proc GetTextFaceA*(para1: HDC, para2: int32, para3: LPSTR): int32{.stdcall,
    dynlib: "gdi32", importc: "GetTextFaceA".}
proc GetKerningPairsA*(para1: HDC, para2: DWORD, para3: LPKERNINGPAIR): DWORD{.
    stdcall, dynlib: "gdi32", importc: "GetKerningPairsA".}
proc CreateColorSpaceA*(para1: LPLOGCOLORSPACE): HCOLORSPACE{.stdcall,
    dynlib: "gdi32", importc: "CreateColorSpaceA".}
proc GetLogColorSpaceA*(para1: HCOLORSPACE, para2: LPLOGCOLORSPACE, para3: DWORD): WINBOOL{.
    stdcall, dynlib: "gdi32", importc: "GetLogColorSpaceA".}
proc GetICMProfileA*(para1: HDC, para2: DWORD, para3: LPSTR): WINBOOL{.stdcall,
    dynlib: "gdi32", importc: "GetICMProfileA".}
proc SetICMProfileA*(para1: HDC, para2: LPSTR): WINBOOL{.stdcall,
    dynlib: "gdi32", importc: "SetICMProfileA".}
proc UpdateICMRegKeyA*(para1: DWORD, para2: DWORD, para3: LPSTR, para4: UINT): WINBOOL{.
    stdcall, dynlib: "gdi32", importc: "UpdateICMRegKeyA".}
proc EnumICMProfilesA*(para1: HDC, para2: ICMENUMPROC, para3: LPARAM): int32{.
    stdcall, dynlib: "gdi32", importc: "EnumICMProfilesA".}
proc PropertySheetA*(lppsph: LPCPROPSHEETHEADER): int32{.stdcall,
    dynlib: "comctl32", importc: "PropertySheetA".}
proc ImageList_LoadImageA*(hi: HINST, lpbmp: LPCSTR, cx: int32, cGrow: int32,
                           crMask: COLORREF, uType: UINT, uFlags: UINT): HIMAGELIST{.
    stdcall, dynlib: "comctl32", importc: "ImageList_LoadImageA".}
proc CreateStatusWindowA*(style: LONG, lpszText: LPCSTR, hwndParent: HWND,
                          wID: UINT): HWND{.stdcall, dynlib: "comctl32",
    importc: "CreateStatusWindowA".}
proc DrawStatusTextA*(hDC: HDC, lprc: LPRECT, pszText: LPCSTR, uFlags: UINT){.
    stdcall, dynlib: "comctl32", importc: "DrawStatusTextA".}
proc GetOpenFileNameA*(para1: LPOPENFILENAME): WINBOOL{.stdcall,
    dynlib: "comdlg32", importc: "GetOpenFileNameA".}
proc GetSaveFileNameA*(para1: LPOPENFILENAME): WINBOOL{.stdcall,
    dynlib: "comdlg32", importc: "GetSaveFileNameA".}
proc GetFileTitleA*(para1: LPCSTR, para2: LPSTR, para3: int16): int{.stdcall,
    dynlib: "comdlg32", importc: "GetFileTitleA".}
proc ChooseColorA*(para1: LPCHOOSECOLOR): WINBOOL{.stdcall, dynlib: "comdlg32",
    importc: "ChooseColorA".}
proc FindTextA*(para1: LPFINDREPLACE): HWND{.stdcall, dynlib: "comdlg32",
    importc: "FindTextA".}
proc ReplaceTextA*(para1: LPFINDREPLACE): HWND{.stdcall, dynlib: "comdlg32",
    importc: "ReplaceTextA".}
proc ChooseFontA*(para1: LPCHOOSEFONT): WINBOOL{.stdcall, dynlib: "comdlg32",
    importc: "ChooseFontA".}
proc PrintDlgA*(para1: LPPRINTDLG): WINBOOL{.stdcall, dynlib: "comdlg32",
    importc: "PrintDlgA".}
proc PageSetupDlgA*(para1: LPPAGESETUPDLG): WINBOOL{.stdcall,
    dynlib: "comdlg32", importc: "PageSetupDlgA".}
proc CreateProcessA*(lpApplicationName: LPCSTR, lpCommandLine: LPSTR,
                     lpProcessAttributes: LPSECURITY_ATTRIBUTES,
                     lpThreadAttributes: LPSECURITY_ATTRIBUTES,
                     bInheritHandles: WINBOOL, dwCreationFlags: DWORD,
                     lpEnvironment: LPVOID, lpCurrentDirectory: LPCSTR,
                     lpStartupInfo: LPSTARTUPINFO,
                     lpProcessInformation: LPPROCESS_INFORMATION): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "CreateProcessA".}
proc GetStartupInfoA*(lpStartupInfo: LPSTARTUPINFO){.stdcall,
    dynlib: "kernel32", importc: "GetStartupInfoA".}
proc FindFirstFileA*(lpFileName: LPCSTR, lpFindFileData: LPWIN32_FIND_DATA): HANDLE{.
    stdcall, dynlib: "kernel32", importc: "FindFirstFileA".}
proc FindNextFileA*(hFindFile: HANDLE, lpFindFileData: LPWIN32_FIND_DATA): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "FindNextFileA".}
proc GetVersionExA*(VersionInformation: LPOSVERSIONINFO): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "GetVersionExA".}
proc CreateWindowA*(lpClassName: LPCSTR, lpWindowName: LPCSTR, dwStyle: DWORD,
                    X: int32, Y: int32, nWidth: int32, nHeight: int32,
                    hWndParent: HWND, menu: HMENU, hInstance: HINST,
                    lpParam: LPVOID): HWND
proc CreateDialogA*(hInstance: HINST, lpTemplateName: LPCSTR, hWndParent: HWND,
                    lpDialogFunc: DLGPROC): HWND
proc CreateDialogIndirectA*(hInstance: HINST, lpTemplate: LPCDLGTEMPLATE,
                            hWndParent: HWND, lpDialogFunc: DLGPROC): HWND
proc DialogBoxA*(hInstance: HINST, lpTemplateName: LPCSTR, hWndParent: HWND,
                 lpDialogFunc: DLGPROC): int32
proc DialogBoxIndirectA*(hInstance: HINST, hDialogTemplate: LPCDLGTEMPLATE,
                         hWndParent: HWND, lpDialogFunc: DLGPROC): int32
proc CreateDCA*(para1: LPCSTR, para2: LPCSTR, para3: LPCSTR, para4: pDEVMODE): HDC{.
    stdcall, dynlib: "gdi32", importc: "CreateDCA".}
proc VerInstallFileA*(uFlags: DWORD, szSrcFileName: LPSTR,
                      szDestFileName: LPSTR, szSrcDir: LPSTR, szDestDir: LPSTR,
                      szCurDir: LPSTR, szTmpFile: LPSTR, lpuTmpFileLen: PUINT): DWORD{.
    stdcall, dynlib: "version", importc: "VerInstallFileA".}
proc GetFileVersionInfoSizeA*(lptstrFilename: LPSTR, lpdwHandle: LPDWORD): DWORD{.
    stdcall, dynlib: "version", importc: "GetFileVersionInfoSizeA".}
proc GetFileVersionInfoA*(lptstrFilename: LPSTR, dwHandle: DWORD, dwLen: DWORD,
                          lpData: LPVOID): WINBOOL{.stdcall, dynlib: "version",
    importc: "GetFileVersionInfoA".}
proc VerLanguageNameA*(wLang: DWORD, szLang: LPSTR, nSize: DWORD): DWORD{.
    stdcall, dynlib: "kernel32", importc: "VerLanguageNameA".}
proc VerQueryValueA*(pBlock: LPVOID, lpSubBlock: LPSTR, lplpBuffer: LPVOID,
                     puLen: PUINT): WINBOOL{.stdcall, dynlib: "version",
    importc: "VerQueryValueA".}
proc VerFindFileA*(uFlags: DWORD, szFileName: LPSTR, szWinDir: LPSTR,
                   szAppDir: LPSTR, szCurDir: LPSTR, lpuCurDirLen: PUINT,
                   szDestDir: LPSTR, lpuDestDirLen: PUINT): DWORD{.stdcall,
    dynlib: "version", importc: "VerFindFileA".}
proc RegConnectRegistryA*(lpMachineName: LPSTR, key: HKEY, phkResult: PHKEY): LONG{.
    stdcall, dynlib: "advapi32", importc: "RegConnectRegistryA".}
proc RegCreateKeyA*(key: HKEY, lpSubKey: LPCSTR, phkResult: PHKEY): LONG{.
    stdcall, dynlib: "advapi32", importc: "RegCreateKeyA".}
proc RegCreateKeyExA*(key: HKEY, lpSubKey: LPCSTR, Reserved: DWORD,
                      lpClass: LPSTR, dwOptions: DWORD, samDesired: REGSAM,
                      lpSecurityAttributes: LPSECURITY_ATTRIBUTES,
                      phkResult: PHKEY, lpdwDisposition: LPDWORD): LONG{.
    stdcall, dynlib: "advapi32", importc: "RegCreateKeyExA".}
proc RegDeleteKeyA*(key: HKEY, lpSubKey: LPCSTR): LONG{.stdcall,
    dynlib: "advapi32", importc: "RegDeleteKeyA".}
proc RegDeleteValueA*(key: HKEY, lpValueName: LPCSTR): LONG{.stdcall,
    dynlib: "advapi32", importc: "RegDeleteValueA".}
proc RegEnumKeyA*(key: HKEY, dwIndex: DWORD, lpName: LPSTR, cbName: DWORD): LONG{.
    stdcall, dynlib: "advapi32", importc: "RegEnumKeyA".}
proc RegEnumKeyExA*(key: HKEY, dwIndex: DWORD, lpName: LPSTR,
                    lpcbName: LPDWORD, lpReserved: LPDWORD, lpClass: LPSTR,
                    lpcbClass: LPDWORD, lpftLastWriteTime: PFILETIME): LONG{.
    stdcall, dynlib: "advapi32", importc: "RegEnumKeyExA".}
proc RegEnumValueA*(key: HKEY, dwIndex: DWORD, lpValueName: LPSTR,
                    lpcbValueName: LPDWORD, lpReserved: LPDWORD,
                    lpType: LPDWORD, lpData: LPBYTE, lpcbData: LPDWORD): LONG{.
    stdcall, dynlib: "advapi32", importc: "RegEnumValueA".}
proc RegLoadKeyA*(key: HKEY, lpSubKey: LPCSTR, lpFile: LPCSTR): LONG{.stdcall,
    dynlib: "advapi32", importc: "RegLoadKeyA".}
proc RegOpenKeyA*(key: HKEY, lpSubKey: LPCSTR, phkResult: PHKEY): LONG{.
    stdcall, dynlib: "advapi32", importc: "RegOpenKeyA".}
proc RegOpenKeyExA*(key: HKEY, lpSubKey: LPCSTR, ulOptions: DWORD,
                    samDesired: REGSAM, phkResult: PHKEY): LONG{.stdcall,
    dynlib: "advapi32", importc: "RegOpenKeyExA".}
proc RegQueryInfoKeyA*(key: HKEY, lpClass: LPSTR, lpcbClass: LPDWORD,
                       lpReserved: LPDWORD, lpcSubKeys: LPDWORD,
                       lpcbMaxSubKeyLen: LPDWORD, lpcbMaxClassLen: LPDWORD,
                       lpcValues: LPDWORD, lpcbMaxValueNameLen: LPDWORD,
                       lpcbMaxValueLen: LPDWORD,
                       lpcbSecurityDescriptor: LPDWORD,
                       lpftLastWriteTime: PFILETIME): LONG{.stdcall,
    dynlib: "advapi32", importc: "RegQueryInfoKeyA".}
proc RegQueryValueA*(key: HKEY, lpSubKey: LPCSTR, lpValue: LPSTR,
                     lpcbValue: PLONG): LONG{.stdcall, dynlib: "advapi32",
    importc: "RegQueryValueA".}
proc RegQueryMultipleValuesA*(key: HKEY, val_list: PVALENT, num_vals: DWORD,
                              lpValueBuf: LPSTR, ldwTotsize: LPDWORD): LONG{.
    stdcall, dynlib: "advapi32", importc: "RegQueryMultipleValuesA".}
proc RegQueryValueExA*(key: HKEY, lpValueName: LPCSTR, lpReserved: LPDWORD,
                       lpType: LPDWORD, lpData: LPBYTE, lpcbData: LPDWORD): LONG{.
    stdcall, dynlib: "advapi32", importc: "RegQueryValueExA".}
proc RegReplaceKeyA*(key: HKEY, lpSubKey: LPCSTR, lpNewFile: LPCSTR,
                     lpOldFile: LPCSTR): LONG{.stdcall, dynlib: "advapi32",
    importc: "RegReplaceKeyA".}
proc RegRestoreKeyA*(key: HKEY, lpFile: LPCSTR, dwFlags: DWORD): LONG{.stdcall,
    dynlib: "advapi32", importc: "RegRestoreKeyA".}
proc RegSaveKeyA*(key: HKEY, lpFile: LPCSTR,
                  lpSecurityAttributes: LPSECURITY_ATTRIBUTES): LONG{.stdcall,
    dynlib: "advapi32", importc: "RegSaveKeyA".}
proc RegSetValueA*(key: HKEY, lpSubKey: LPCSTR, dwType: DWORD, lpData: LPCSTR,
                   cbData: DWORD): LONG{.stdcall, dynlib: "advapi32",
    importc: "RegSetValueA".}
proc RegSetValueExA*(key: HKEY, lpValueName: LPCSTR, Reserved: DWORD,
                     dwType: DWORD, lpData: LPBYTE, cbData: DWORD): LONG{.
    stdcall, dynlib: "advapi32", importc: "RegSetValueExA".}
proc RegUnLoadKeyA*(key: HKEY, lpSubKey: LPCSTR): LONG{.stdcall,
    dynlib: "advapi32", importc: "RegUnLoadKeyA".}
proc InitiateSystemShutdownA*(lpMachineName: LPSTR, lpMessage: LPSTR,
                              dwTimeout: DWORD, bForceAppsClosed: WINBOOL,
                              bRebootAfterShutdown: WINBOOL): WINBOOL{.stdcall,
    dynlib: "advapi32", importc: "InitiateSystemShutdownA".}
proc AbortSystemShutdownA*(lpMachineName: LPSTR): WINBOOL{.stdcall,
    dynlib: "advapi32", importc: "AbortSystemShutdownA".}
proc CompareStringA*(Locale: LCID, dwCmpFlags: DWORD, lpString1: LPCSTR,
                     cchCount1: int32, lpString2: LPCSTR, cchCount2: int32): int32{.
    stdcall, dynlib: "kernel32", importc: "CompareStringA".}
proc LCMapStringA*(Locale: LCID, dwMapFlags: DWORD, lpSrcStr: LPCSTR,
                   cchSrc: int32, lpDestStr: LPSTR, cchDest: int32): int32{.
    stdcall, dynlib: "kernel32", importc: "LCMapStringA".}
proc GetLocaleInfoA*(Locale: LCID, LCType: LCTYPE, lpLCData: LPSTR,
                     cchData: int32): int32{.stdcall, dynlib: "kernel32",
    importc: "GetLocaleInfoA".}
proc SetLocaleInfoA*(Locale: LCID, LCType: LCTYPE, lpLCData: LPCSTR): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "SetLocaleInfoA".}
proc GetTimeFormatA*(Locale: LCID, dwFlags: DWORD, lpTime: LPSYSTEMTIME,
                     lpFormat: LPCSTR, lpTimeStr: LPSTR, cchTime: int32): int32{.
    stdcall, dynlib: "kernel32", importc: "GetTimeFormatA".}
proc GetDateFormatA*(Locale: LCID, dwFlags: DWORD, lpDate: LPSYSTEMTIME,
                     lpFormat: LPCSTR, lpDateStr: LPSTR, cchDate: int32): int32{.
    stdcall, dynlib: "kernel32", importc: "GetDateFormatA".}
proc GetNumberFormatA*(Locale: LCID, dwFlags: DWORD, lpValue: LPCSTR,
                       lpFormat: PNUMBERFMT, lpNumberStr: LPSTR,
                       cchNumber: int32): int32{.stdcall, dynlib: "kernel32",
    importc: "GetNumberFormatA".}
proc GetCurrencyFormatA*(Locale: LCID, dwFlags: DWORD, lpValue: LPCSTR,
                         lpFormat: PCURRENCYFMT, lpCurrencyStr: LPSTR,
                         cchCurrency: int32): int32{.stdcall,
    dynlib: "kernel32", importc: "GetCurrencyFormatA".}
proc EnumCalendarInfoA*(lpCalInfoEnumProc: CALINFO_ENUMPROC, Locale: LCID,
                        Calendar: CALID, CalType: CALTYPE): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "EnumCalendarInfoA".}
proc EnumTimeFormatsA*(lpTimeFmtEnumProc: TIMEFMT_ENUMPROC, Locale: LCID,
                       dwFlags: DWORD): WINBOOL{.stdcall, dynlib: "kernel32",
    importc: "EnumTimeFormatsA".}
proc EnumDateFormatsA*(lpDateFmtEnumProc: DATEFMT_ENUMPROC, Locale: LCID,
                       dwFlags: DWORD): WINBOOL{.stdcall, dynlib: "kernel32",
    importc: "EnumDateFormatsA".}
proc GetStringTypeExA*(Locale: LCID, dwInfoType: DWORD, lpSrcStr: LPCSTR,
                       cchSrc: int32, lpCharType: LPWORD): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "GetStringTypeExA".}
proc GetStringTypeA*(Locale: LCID, dwInfoType: DWORD, lpSrcStr: LPCSTR,
                     cchSrc: int32, lpCharType: LPWORD): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "GetStringTypeA".}
proc FoldStringA*(dwMapFlags: DWORD, lpSrcStr: LPCSTR, cchSrc: int32,
                  lpDestStr: LPSTR, cchDest: int32): int32{.stdcall,
    dynlib: "kernel32", importc: "FoldStringA".}
proc EnumSystemLocalesA*(lpLocaleEnumProc: LOCALE_ENUMPROC, dwFlags: DWORD): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "EnumSystemLocalesA".}
proc EnumSystemCodePagesA*(lpCodePageEnumProc: CODEPAGE_ENUMPROC, dwFlags: DWORD): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "EnumSystemCodePagesA".}
proc PeekConsoleInputA*(hConsoleInput: HANDLE, lpBuffer: PINPUTRECORD,
                        nLength: DWORD, lpNumberOfEventsRead: LPDWORD): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "PeekConsoleInputA".}
proc ReadConsoleInputA*(hConsoleInput: HANDLE, lpBuffer: PINPUTRECORD,
                        nLength: DWORD, lpNumberOfEventsRead: LPDWORD): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "ReadConsoleInputA".}
proc WriteConsoleInputA*(hConsoleInput: HANDLE, lpBuffer: PINPUTRECORD,
                         nLength: DWORD, lpNumberOfEventsWritten: LPDWORD): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "WriteConsoleInputA".}
proc ReadConsoleOutputA*(hConsoleOutput: HANDLE, lpBuffer: PCHAR_INFO,
                         dwBufferSize: COORD, dwBufferCoord: COORD,
                         lpReadRegion: PSMALL_RECT): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "ReadConsoleOutputA".}
proc WriteConsoleOutputA*(hConsoleOutput: HANDLE, lpBuffer: PCHAR_INFO,
                          dwBufferSize: COORD, dwBufferCoord: COORD,
                          lpWriteRegion: PSMALL_RECT): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "WriteConsoleOutputA".}
proc ReadConsoleOutputCharacterA*(hConsoleOutput: HANDLE, lpCharacter: LPSTR,
                                  nLength: DWORD, dwReadCoord: COORD,
                                  lpNumberOfCharsRead: LPDWORD): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "ReadConsoleOutputCharacterA".}
proc WriteConsoleOutputCharacterA*(hConsoleOutput: HANDLE, lpCharacter: LPCSTR,
                                   nLength: DWORD, dwWriteCoord: COORD,
                                   lpNumberOfCharsWritten: LPDWORD): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "WriteConsoleOutputCharacterA".}
proc FillConsoleOutputCharacterA*(hConsoleOutput: HANDLE, cCharacter: CHAR,
                                  nLength: DWORD, dwWriteCoord: COORD,
                                  lpNumberOfCharsWritten: LPDWORD): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "FillConsoleOutputCharacterA".}
proc ScrollConsoleScreenBufferA*(hConsoleOutput: HANDLE,
                                 lpScrollRectangle: PSMALL_RECT,
                                 lpClipRectangle: PSMALL_RECT,
                                 dwDestinationOrigin: COORD, lpFill: PCHAR_INFO): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "ScrollConsoleScreenBufferA".}
proc GetConsoleTitleA*(lpConsoleTitle: LPSTR, nSize: DWORD): DWORD{.stdcall,
    dynlib: "kernel32", importc: "GetConsoleTitleA".}
proc SetConsoleTitleA*(lpConsoleTitle: LPCSTR): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "SetConsoleTitleA".}
proc ReadConsoleA*(hConsoleInput: HANDLE, lpBuffer: LPVOID,
                   nNumberOfCharsToRead: DWORD, lpNumberOfCharsRead: LPDWORD,
                   lpReserved: LPVOID): WINBOOL{.stdcall, dynlib: "kernel32",
    importc: "ReadConsoleA".}
proc WriteConsoleA*(hConsoleOutput: HANDLE, lpBuffer: pointer,
                    nNumberOfCharsToWrite: DWORD,
                    lpNumberOfCharsWritten: LPDWORD, lpReserved: LPVOID): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "WriteConsoleA".}
proc WNetAddConnectionA*(lpRemoteName: LPCSTR, lpPassword: LPCSTR,
                         lpLocalName: LPCSTR): DWORD{.stdcall, dynlib: "mpr",
    importc: "WNetAddConnectionA".}
proc WNetAddConnection2A*(lpNetResource: LPNETRESOURCE, lpPassword: LPCSTR,
                          lpUserName: LPCSTR, dwFlags: DWORD): DWORD{.stdcall,
    dynlib: "mpr", importc: "WNetAddConnection2A".}
proc WNetAddConnection3A*(hwndOwner: HWND, lpNetResource: LPNETRESOURCE,
                          lpPassword: LPCSTR, lpUserName: LPCSTR, dwFlags: DWORD): DWORD{.
    stdcall, dynlib: "mpr", importc: "WNetAddConnection3A".}
proc WNetCancelConnectionA*(lpName: LPCSTR, fForce: WINBOOL): DWORD{.stdcall,
    dynlib: "mpr", importc: "WNetCancelConnectionA".}
proc WNetCancelConnection2A*(lpName: LPCSTR, dwFlags: DWORD, fForce: WINBOOL): DWORD{.
    stdcall, dynlib: "mpr", importc: "WNetCancelConnection2A".}
proc WNetGetConnectionA*(lpLocalName: LPCSTR, lpRemoteName: LPSTR,
                         lpnLength: LPDWORD): DWORD{.stdcall, dynlib: "mpr",
    importc: "WNetGetConnectionA".}
proc WNetUseConnectionA*(hwndOwner: HWND, lpNetResource: LPNETRESOURCE,
                         lpUserID: LPCSTR, lpPassword: LPCSTR, dwFlags: DWORD,
                         lpAccessName: LPSTR, lpBufferSize: LPDWORD,
                         lpResult: LPDWORD): DWORD{.stdcall, dynlib: "mpr",
    importc: "WNetUseConnectionA".}
proc WNetSetConnectionA*(lpName: LPCSTR, dwProperties: DWORD, pvValues: LPVOID): DWORD{.
    stdcall, dynlib: "mpr", importc: "WNetSetConnectionA".}
proc WNetConnectionDialog1A*(lpConnDlgStruct: LPCONNECTDLGSTRUCT): DWORD{.
    stdcall, dynlib: "mpr", importc: "WNetConnectionDialog1A".}
proc WNetDisconnectDialog1A*(lpConnDlgStruct: LPDISCDLGSTRUCT): DWORD{.stdcall,
    dynlib: "mpr", importc: "WNetDisconnectDialog1A".}
proc WNetOpenEnumA*(dwScope: DWORD, dwType: DWORD, dwUsage: DWORD,
                    lpNetResource: LPNETRESOURCE, lphEnum: LPHANDLE): DWORD{.
    stdcall, dynlib: "mpr", importc: "WNetOpenEnumA".}
proc WNetEnumResourceA*(hEnum: HANDLE, lpcCount: LPDWORD, lpBuffer: LPVOID,
                        lpBufferSize: LPDWORD): DWORD{.stdcall, dynlib: "mpr",
    importc: "WNetEnumResourceA".}
proc WNetGetUniversalNameA*(lpLocalPath: LPCSTR, dwInfoLevel: DWORD,
                            lpBuffer: LPVOID, lpBufferSize: LPDWORD): DWORD{.
    stdcall, dynlib: "mpr", importc: "WNetGetUniversalNameA".}
proc WNetGetUserA*(lpName: LPCSTR, lpUserName: LPSTR, lpnLength: LPDWORD): DWORD{.
    stdcall, dynlib: "mpr", importc: "WNetGetUserA".}
proc WNetGetProviderNameA*(dwNetType: DWORD, lpProviderName: LPSTR,
                           lpBufferSize: LPDWORD): DWORD{.stdcall,
    dynlib: "mpr", importc: "WNetGetProviderNameA".}
proc WNetGetNetworkInformationA*(lpProvider: LPCSTR,
                                 lpNetInfoStruct: LPNETINFOSTRUCT): DWORD{.
    stdcall, dynlib: "mpr", importc: "WNetGetNetworkInformationA".}
proc WNetGetLastErrorA*(lpError: LPDWORD, lpErrorBuf: LPSTR,
                        nErrorBufSize: DWORD, lpNameBuf: LPSTR,
                        nNameBufSize: DWORD): DWORD{.stdcall, dynlib: "mpr",
    importc: "WNetGetLastErrorA".}
proc MultinetGetConnectionPerformanceA*(lpNetResource: LPNETRESOURCE,
    lpNetConnectInfoStruct: LPNETCONNECTINFOSTRUCT): DWORD{.stdcall,
    dynlib: "mpr", importc: "MultinetGetConnectionPerformanceA".}
proc ChangeServiceConfigA*(hService: SC_HANDLE, dwServiceType: DWORD,
                           dwStartType: DWORD, dwErrorControl: DWORD,
                           lpBinaryPathName: LPCSTR, lpLoadOrderGroup: LPCSTR,
                           lpdwTagId: LPDWORD, lpDependencies: LPCSTR,
                           lpServiceStartName: LPCSTR, lpPassword: LPCSTR,
                           lpDisplayName: LPCSTR): WINBOOL{.stdcall,
    dynlib: "advapi32", importc: "ChangeServiceConfigA".}
proc CreateServiceA*(hSCManager: SC_HANDLE, lpServiceName: LPCSTR,
                     lpDisplayName: LPCSTR, dwDesiredAccess: DWORD,
                     dwServiceType: DWORD, dwStartType: DWORD,
                     dwErrorControl: DWORD, lpBinaryPathName: LPCSTR,
                     lpLoadOrderGroup: LPCSTR, lpdwTagId: LPDWORD,
                     lpDependencies: LPCSTR, lpServiceStartName: LPCSTR,
                     lpPassword: LPCSTR): SC_HANDLE{.stdcall,
    dynlib: "advapi32", importc: "CreateServiceA".}
proc EnumDependentServicesA*(hService: SC_HANDLE, dwServiceState: DWORD,
                             lpServices: LPENUM_SERVICE_STATUS,
                             cbBufSize: DWORD, pcbBytesNeeded: LPDWORD,
                             lpServicesReturned: LPDWORD): WINBOOL{.stdcall,
    dynlib: "advapi32", importc: "EnumDependentServicesA".}
proc EnumServicesStatusA*(hSCManager: SC_HANDLE, dwServiceType: DWORD,
                          dwServiceState: DWORD,
                          lpServices: LPENUM_SERVICE_STATUS, cbBufSize: DWORD,
                          pcbBytesNeeded: LPDWORD, lpServicesReturned: LPDWORD,
                          lpResumeHandle: LPDWORD): WINBOOL{.stdcall,
    dynlib: "advapi32", importc: "EnumServicesStatusA".}
proc GetServiceKeyNameA*(hSCManager: SC_HANDLE, lpDisplayName: LPCSTR,
                         lpServiceName: LPSTR, lpcchBuffer: LPDWORD): WINBOOL{.
    stdcall, dynlib: "advapi32", importc: "GetServiceKeyNameA".}
proc GetServiceDisplayNameA*(hSCManager: SC_HANDLE, lpServiceName: LPCSTR,
                             lpDisplayName: LPSTR, lpcchBuffer: LPDWORD): WINBOOL{.
    stdcall, dynlib: "advapi32", importc: "GetServiceDisplayNameA".}
proc OpenSCManagerA*(lpMachineName: LPCSTR, lpDatabaseName: LPCSTR,
                     dwDesiredAccess: DWORD): SC_HANDLE{.stdcall,
    dynlib: "advapi32", importc: "OpenSCManagerA".}
proc OpenServiceA*(hSCManager: SC_HANDLE, lpServiceName: LPCSTR,
                   dwDesiredAccess: DWORD): SC_HANDLE{.stdcall,
    dynlib: "advapi32", importc: "OpenServiceA".}
proc QueryServiceConfigA*(hService: SC_HANDLE,
                          lpServiceConfig: LPQUERY_SERVICE_CONFIG,
                          cbBufSize: DWORD, pcbBytesNeeded: LPDWORD): WINBOOL{.
    stdcall, dynlib: "advapi32", importc: "QueryServiceConfigA".}
proc QueryServiceLockStatusA*(hSCManager: SC_HANDLE,
                              lpLockStatus: LPQUERY_SERVICE_LOCK_STATUS,
                              cbBufSize: DWORD, pcbBytesNeeded: LPDWORD): WINBOOL{.
    stdcall, dynlib: "advapi32", importc: "QueryServiceLockStatusA".}
proc RegisterServiceCtrlHandlerA*(lpServiceName: LPCSTR,
                                  lpHandlerProc: LPHANDLER_FUNCTION): SERVICE_STATUS_HANDLE{.
    stdcall, dynlib: "advapi32", importc: "RegisterServiceCtrlHandlerA".}
proc StartServiceCtrlDispatcherA*(lpServiceStartTable: LPSERVICE_TABLE_ENTRY): WINBOOL{.
    stdcall, dynlib: "advapi32", importc: "StartServiceCtrlDispatcherA".}
proc StartServiceA*(hService: SC_HANDLE, dwNumServiceArgs: DWORD,
                    lpServiceArgVectors: LPCSTR): WINBOOL{.stdcall,
    dynlib: "advapi32", importc: "StartServiceA".}
proc DragQueryFileA*(para1: HDROP, para2: int, para3: cstring, para4: int): int{.
    stdcall, dynlib: "shell32", importc: "DragQueryFileA".}
proc ExtractAssociatedIconA*(para1: HINST, para2: cstring, para3: LPWORD): HICON{.
    stdcall, dynlib: "shell32", importc: "ExtractAssociatedIconA".}
proc ExtractIconA*(para1: HINST, para2: cstring, para3: int): HICON{.stdcall,
    dynlib: "shell32", importc: "ExtractIconA".}
proc FindExecutableA*(para1: cstring, para2: cstring, para3: cstring): HINST{.
    stdcall, dynlib: "shell32", importc: "FindExecutableA".}
proc ShellAboutA*(para1: HWND, para2: cstring, para3: cstring, para4: HICON): int32{.
    stdcall, dynlib: "shell32", importc: "ShellAboutA".}
proc ShellExecuteA*(para1: HWND, para2: cstring, para3: cstring, para4: cstring,
                    para5: cstring, para6: int32): HINST{.stdcall,
    dynlib: "shell32", importc: "ShellExecuteA".}
proc Shell_NotifyIconA*(dwMessage: DWORD, lpData: PNotifyIconDataA): WINBOOL{.
    stdcall, dynlib: "shell32", importc: "Shell_NotifyIconA".}
proc DdeCreateStringHandleA*(para1: DWORD, para2: cstring, para3: int32): HSZ{.
    stdcall, dynlib: "user32", importc: "DdeCreateStringHandleA".}
proc DdeInitializeA*(para1: LPDWORD, para2: PFNCALLBACK, para3: DWORD,
                     para4: DWORD): UINT{.stdcall, dynlib: "user32",
    importc: "DdeInitializeA".}
proc DdeQueryStringA*(para1: DWORD, para2: HSZ, para3: cstring, para4: DWORD,
                      para5: int32): DWORD{.stdcall, dynlib: "user32",
    importc: "DdeQueryStringA".}
proc LogonUserA*(para1: LPSTR, para2: LPSTR, para3: LPSTR, para4: DWORD,
                 para5: DWORD, para6: PHANDLE): WINBOOL{.stdcall,
    dynlib: "advapi32", importc: "LogonUserA".}
proc CreateProcessAsUserA*(para1: HANDLE, para2: LPCTSTR, para3: LPTSTR,
                           para4: LPSECURITY_ATTRIBUTES,
                           para5: LPSECURITY_ATTRIBUTES, para6: WINBOOL,
                           para7: DWORD, para8: LPVOID, para9: LPCTSTR,
                           para10: LPSTARTUPINFO, para11: LPPROCESS_INFORMATION): WINBOOL{.
    stdcall, dynlib: "advapi32", importc: "CreateProcessAsUserA".}
proc GetBinaryTypeW*(lpApplicationName: LPCWSTR, lpBinaryType: LPDWORD): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "GetBinaryTypeW".}
proc GetShortPathNameW*(lpszLongPath: LPCWSTR, lpszShortPath: LPWSTR,
                        cchBuffer: DWORD): DWORD{.stdcall, dynlib: "kernel32",
    importc: "GetShortPathNameW".}
proc GetEnvironmentStringsW*(): LPWSTR{.stdcall, dynlib: "kernel32",
                                        importc: "GetEnvironmentStringsW".}
proc FreeEnvironmentStringsW*(para1: LPWSTR): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "FreeEnvironmentStringsW".}
proc FormatMessageW*(dwFlags: DWORD, lpSource: LPCVOID, dwMessageId: DWORD,
                     dwLanguageId: DWORD, lpBuffer: LPWSTR, nSize: DWORD,
                     Arguments: va_list): DWORD{.stdcall, dynlib: "kernel32",
    importc: "FormatMessageW".}
proc CreateMailslotW*(lpName: LPCWSTR, nMaxMessageSize: DWORD,
                      lReadTimeout: DWORD,
                      lpSecurityAttributes: LPSECURITY_ATTRIBUTES): HANDLE{.
    stdcall, dynlib: "kernel32", importc: "CreateMailslotW".}
proc lstrcmpW*(lpString1: LPCWSTR, lpString2: LPCWSTR): int32{.stdcall,
    dynlib: "kernel32", importc: "lstrcmpW".}
proc lstrcmpiW*(lpString1: LPCWSTR, lpString2: LPCWSTR): int32{.stdcall,
    dynlib: "kernel32", importc: "lstrcmpiW".}
proc lstrcpynW*(lpString1: LPWSTR, lpString2: LPCWSTR, iMaxLength: int32): LPWSTR{.
    stdcall, dynlib: "kernel32", importc: "lstrcpynW".}
proc lstrcpyW*(lpString1: LPWSTR, lpString2: LPCWSTR): LPWSTR{.stdcall,
    dynlib: "kernel32", importc: "lstrcpyW".}
proc lstrcatW*(lpString1: LPWSTR, lpString2: LPCWSTR): LPWSTR{.stdcall,
    dynlib: "kernel32", importc: "lstrcatW".}
proc lstrlenW*(lpString: LPCWSTR): int32{.stdcall, dynlib: "kernel32",
    importc: "lstrlenW".}
proc CreateMutexW*(lpMutexAttributes: LPSECURITY_ATTRIBUTES,
                   bInitialOwner: WINBOOL, lpName: LPCWSTR): HANDLE{.stdcall,
    dynlib: "kernel32", importc: "CreateMutexW".}
proc OpenMutexW*(dwDesiredAccess: DWORD, bInheritHandle: WINBOOL,
                 lpName: LPCWSTR): HANDLE{.stdcall, dynlib: "kernel32",
    importc: "OpenMutexW".}
proc CreateEventW*(lpEventAttributes: LPSECURITY_ATTRIBUTES,
                   bManualReset: WINBOOL, bInitialState: WINBOOL,
                   lpName: LPCWSTR): HANDLE{.stdcall, dynlib: "kernel32",
    importc: "CreateEventW".}
proc OpenEventW*(dwDesiredAccess: DWORD, bInheritHandle: WINBOOL,
                 lpName: LPCWSTR): HANDLE{.stdcall, dynlib: "kernel32",
    importc: "OpenEventW".}
proc CreateSemaphoreW*(lpSemaphoreAttributes: LPSECURITY_ATTRIBUTES,
                       lInitialCount: LONG, lMaximumCount: LONG, lpName: LPCWSTR): HANDLE{.
    stdcall, dynlib: "kernel32", importc: "CreateSemaphoreW".}
proc OpenSemaphoreW*(dwDesiredAccess: DWORD, bInheritHandle: WINBOOL,
                     lpName: LPCWSTR): HANDLE{.stdcall, dynlib: "kernel32",
    importc: "OpenSemaphoreW".}
proc CreateFileMappingW*(hFile: HANDLE,
                         lpFileMappingAttributes: LPSECURITY_ATTRIBUTES,
                         flProtect: DWORD, dwMaximumSizeHigh: DWORD,
                         dwMaximumSizeLow: DWORD, lpName: LPCWSTR): HANDLE{.
    stdcall, dynlib: "kernel32", importc: "CreateFileMappingW".}
proc OpenFileMappingW*(dwDesiredAccess: DWORD, bInheritHandle: WINBOOL,
                       lpName: LPCWSTR): HANDLE{.stdcall, dynlib: "kernel32",
    importc: "OpenFileMappingW".}
proc GetLogicalDriveStringsW*(nBufferLength: DWORD, lpBuffer: LPWSTR): DWORD{.
    stdcall, dynlib: "kernel32", importc: "GetLogicalDriveStringsW".}
proc LoadLibraryW*(lpLibFileName: LPCWSTR): HINST{.stdcall, dynlib: "kernel32",
    importc: "LoadLibraryW".}
proc LoadLibraryExW*(lpLibFileName: LPCWSTR, hFile: HANDLE, dwFlags: DWORD): HINST{.
    stdcall, dynlib: "kernel32", importc: "LoadLibraryExW".}
proc GetModuleFileNameW*(hModule: HINST, lpFilename: LPWSTR, nSize: DWORD): DWORD{.
    stdcall, dynlib: "kernel32", importc: "GetModuleFileNameW".}
proc GetModuleHandleW*(lpModuleName: LPCWSTR): HMODULE{.stdcall,
    dynlib: "kernel32", importc: "GetModuleHandleW".}
proc FatalAppExitW*(uAction: UINT, lpMessageText: LPCWSTR){.stdcall,
    dynlib: "kernel32", importc: "FatalAppExitW".}
proc GetCommandLineW*(): LPWSTR{.stdcall, dynlib: "kernel32",
                                 importc: "GetCommandLineW".}
proc GetEnvironmentVariableW*(lpName: LPCWSTR, lpBuffer: LPWSTR, nSize: DWORD): DWORD{.
    stdcall, dynlib: "kernel32", importc: "GetEnvironmentVariableW".}
proc SetEnvironmentVariableW*(lpName: LPCWSTR, lpValue: LPCWSTR): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "SetEnvironmentVariableW".}
proc ExpandEnvironmentStringsW*(lpSrc: LPCWSTR, lpDst: LPWSTR, nSize: DWORD): DWORD{.
    stdcall, dynlib: "kernel32", importc: "ExpandEnvironmentStringsW".}
proc OutputDebugStringW*(lpOutputString: LPCWSTR){.stdcall, dynlib: "kernel32",
    importc: "OutputDebugStringW".}
proc FindResourceW*(hModule: HINST, lpName: LPCWSTR, lpType: LPCWSTR): HRSRC{.
    stdcall, dynlib: "kernel32", importc: "FindResourceW".}
proc FindResourceExW*(hModule: HINST, lpType: LPCWSTR, lpName: LPCWSTR,
                      wLanguage: int16): HRSRC{.stdcall, dynlib: "kernel32",
    importc: "FindResourceExW".}
proc EnumResourceTypesW*(hModule: HINST, lpEnumFunc: ENUMRESTYPEPROC,
                         lParam: LONG): WINBOOL{.stdcall, dynlib: "kernel32",
    importc: "EnumResourceTypesW".}
proc EnumResourceNamesW*(hModule: HINST, lpType: LPCWSTR,
                         lpEnumFunc: ENUMRESNAMEPROC, lParam: LONG): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "EnumResourceNamesW".}
proc EnumResourceLanguagesW*(hModule: HINST, lpType: LPCWSTR, lpName: LPCWSTR,
                             lpEnumFunc: ENUMRESLANGPROC, lParam: LONG): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "EnumResourceLanguagesW".}
proc BeginUpdateResourceW*(pFileName: LPCWSTR, bDeleteExistingResources: WINBOOL): HANDLE{.
    stdcall, dynlib: "kernel32", importc: "BeginUpdateResourceW".}
proc UpdateResourceW*(hUpdate: HANDLE, lpType: LPCWSTR, lpName: LPCWSTR,
                      wLanguage: int16, lpData: LPVOID, cbData: DWORD): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "UpdateResourceW".}
proc EndUpdateResourceW*(hUpdate: HANDLE, fDiscard: WINBOOL): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "EndUpdateResourceW".}
proc GlobalAddAtomW*(lpString: LPCWSTR): ATOM{.stdcall, dynlib: "kernel32",
    importc: "GlobalAddAtomW".}
proc GlobalFindAtomW*(lpString: LPCWSTR): ATOM{.stdcall, dynlib: "kernel32",
    importc: "GlobalFindAtomW".}
proc GlobalGetAtomNameW*(nAtom: ATOM, lpBuffer: LPWSTR, nSize: int32): UINT{.
    stdcall, dynlib: "kernel32", importc: "GlobalGetAtomNameW".}
proc AddAtomW*(lpString: LPCWSTR): ATOM{.stdcall, dynlib: "kernel32",
    importc: "AddAtomW".}
proc FindAtomW*(lpString: LPCWSTR): ATOM{.stdcall, dynlib: "kernel32",
    importc: "FindAtomW".}
proc GetAtomNameW*(nAtom: ATOM, lpBuffer: LPWSTR, nSize: int32): UINT{.stdcall,
    dynlib: "kernel32", importc: "GetAtomNameW".}
proc GetProfileIntW*(lpAppName: LPCWSTR, lpKeyName: LPCWSTR, nDefault: WINT): UINT{.
    stdcall, dynlib: "kernel32", importc: "GetProfileIntW".}
proc GetProfileStringW*(lpAppName: LPCWSTR, lpKeyName: LPCWSTR,
                        lpDefault: LPCWSTR, lpReturnedString: LPWSTR,
                        nSize: DWORD): DWORD{.stdcall, dynlib: "kernel32",
    importc: "GetProfileStringW".}
proc WriteProfileStringW*(lpAppName: LPCWSTR, lpKeyName: LPCWSTR,
                          lpString: LPCWSTR): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "WriteProfileStringW".}
proc GetProfileSectionW*(lpAppName: LPCWSTR, lpReturnedString: LPWSTR,
                         nSize: DWORD): DWORD{.stdcall, dynlib: "kernel32",
    importc: "GetProfileSectionW".}
proc WriteProfileSectionW*(lpAppName: LPCWSTR, lpString: LPCWSTR): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "WriteProfileSectionW".}
proc GetPrivateProfileIntW*(lpAppName: LPCWSTR, lpKeyName: LPCWSTR,
                            nDefault: WINT, lpFileName: LPCWSTR): UINT{.stdcall,
    dynlib: "kernel32", importc: "GetPrivateProfileIntW".}
proc GetPrivateProfileStringW*(lpAppName: LPCWSTR, lpKeyName: LPCWSTR,
                               lpDefault: LPCWSTR, lpReturnedString: LPWSTR,
                               nSize: DWORD, lpFileName: LPCWSTR): DWORD{.
    stdcall, dynlib: "kernel32", importc: "GetPrivateProfileStringW".}
proc WritePrivateProfileStringW*(lpAppName: LPCWSTR, lpKeyName: LPCWSTR,
                                 lpString: LPCWSTR, lpFileName: LPCWSTR): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "WritePrivateProfileStringW".}
proc GetPrivateProfileSectionW*(lpAppName: LPCWSTR, lpReturnedString: LPWSTR,
                                nSize: DWORD, lpFileName: LPCWSTR): DWORD{.
    stdcall, dynlib: "kernel32", importc: "GetPrivateProfileSectionW".}
proc WritePrivateProfileSectionW*(lpAppName: LPCWSTR, lpString: LPCWSTR,
                                  lpFileName: LPCWSTR): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "WritePrivateProfileSectionW".}
proc GetDriveTypeW*(lpRootPathName: LPCWSTR): UINT{.stdcall, dynlib: "kernel32",
    importc: "GetDriveTypeW".}
proc GetSystemDirectoryW*(lpBuffer: LPWSTR, uSize: UINT): UINT{.stdcall,
    dynlib: "kernel32", importc: "GetSystemDirectoryW".}
proc GetTempPathW*(nBufferLength: DWORD, lpBuffer: LPWSTR): DWORD{.stdcall,
    dynlib: "kernel32", importc: "GetTempPathW".}
proc GetTempFileNameW*(lpPathName: LPCWSTR, lpPrefixString: LPCWSTR,
                       uUnique: UINT, lpTempFileName: LPWSTR): UINT{.stdcall,
    dynlib: "kernel32", importc: "GetTempFileNameW".}
proc GetWindowsDirectoryW*(lpBuffer: LPWSTR, uSize: UINT): UINT{.stdcall,
    dynlib: "kernel32", importc: "GetWindowsDirectoryW".}
proc SetCurrentDirectoryW*(lpPathName: LPCWSTR): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "SetCurrentDirectoryW".}
proc GetCurrentDirectoryW*(nBufferLength: DWORD, lpBuffer: LPWSTR): DWORD{.
    stdcall, dynlib: "kernel32", importc: "GetCurrentDirectoryW".}
proc GetDiskFreeSpaceW*(lpRootPathName: LPCWSTR, lpSectorsPerCluster: LPDWORD,
                        lpBytesPerSector: LPDWORD,
                        lpNumberOfFreeClusters: LPDWORD,
                        lpTotalNumberOfClusters: LPDWORD): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "GetDiskFreeSpaceW".}
proc CreateDirectoryW*(lpPathName: LPCWSTR,
                       lpSecurityAttributes: LPSECURITY_ATTRIBUTES): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "CreateDirectoryW".}
proc CreateDirectoryExW*(lpTemplateDirectory: LPCWSTR, lpNewDirectory: LPCWSTR,
                         lpSecurityAttributes: LPSECURITY_ATTRIBUTES): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "CreateDirectoryExW".}
proc RemoveDirectoryW*(lpPathName: LPCWSTR): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "RemoveDirectoryW".}
proc GetFullPathNameW*(lpFileName: LPCWSTR, nBufferLength: DWORD,
                       lpBuffer: LPWSTR, lpFilePart: var LPWSTR): DWORD{.
    stdcall, dynlib: "kernel32", importc: "GetFullPathNameW".}
proc DefineDosDeviceW*(dwFlags: DWORD, lpDeviceName: LPCWSTR,
                       lpTargetPath: LPCWSTR): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "DefineDosDeviceW".}
proc QueryDosDeviceW*(lpDeviceName: LPCWSTR, lpTargetPath: LPWSTR,
                      ucchMax: DWORD): DWORD{.stdcall, dynlib: "kernel32",
    importc: "QueryDosDeviceW".}
proc CreateFileW*(lpFileName: LPCWSTR, dwDesiredAccess: DWORD,
                  dwShareMode: DWORD,
                  lpSecurityAttributes: LPSECURITY_ATTRIBUTES,
                  dwCreationDisposition: DWORD, dwFlagsAndAttributes: DWORD,
                  hTemplateFile: HANDLE): HANDLE{.stdcall, dynlib: "kernel32",
    importc: "CreateFileW".}
proc SetFileAttributesW*(lpFileName: LPCWSTR, dwFileAttributes: DWORD): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "SetFileAttributesW".}
proc GetFileAttributesW*(lpFileName: LPCWSTR): DWORD{.stdcall,
    dynlib: "kernel32", importc: "GetFileAttributesW".}
proc GetCompressedFileSizeW*(lpFileName: LPCWSTR, lpFileSizeHigh: LPDWORD): DWORD{.
    stdcall, dynlib: "kernel32", importc: "GetCompressedFileSizeW".}
proc DeleteFileW*(lpFileName: LPCWSTR): WINBOOL{.stdcall, dynlib: "kernel32",
    importc: "DeleteFileW".}
proc SearchPathW*(lpPath: LPCWSTR, lpFileName: LPCWSTR, lpExtension: LPCWSTR,
                  nBufferLength: DWORD, lpBuffer: LPWSTR, lpFilePart: LPWSTR): DWORD{.
    stdcall, dynlib: "kernel32", importc: "SearchPathW".}
proc CopyFileW*(lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR,
                bFailIfExists: WINBOOL): WINBOOL{.stdcall, dynlib: "kernel32",
    importc: "CopyFileW".}
proc MoveFileW*(lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "MoveFileW".}
proc MoveFileExW*(lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR,
                  dwFlags: DWORD): WINBOOL{.stdcall, dynlib: "kernel32",
    importc: "MoveFileExW".}
proc CreateNamedPipeW*(lpName: LPCWSTR, dwOpenMode: DWORD, dwPipeMode: DWORD,
                       nMaxInstances: DWORD, nOutBufferSize: DWORD,
                       nInBufferSize: DWORD, nDefaultTimeOut: DWORD,
                       lpSecurityAttributes: LPSECURITY_ATTRIBUTES): HANDLE{.
    stdcall, dynlib: "kernel32", importc: "CreateNamedPipeW".}
proc GetNamedPipeHandleStateW*(hNamedPipe: HANDLE, lpState: LPDWORD,
                               lpCurInstances: LPDWORD,
                               lpMaxCollectionCount: LPDWORD,
                               lpCollectDataTimeout: LPDWORD,
                               lpUserName: LPWSTR, nMaxUserNameSize: DWORD): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "GetNamedPipeHandleStateW".}
proc CallNamedPipeW*(lpNamedPipeName: LPCWSTR, lpInBuffer: LPVOID,
                     nInBufferSize: DWORD, lpOutBuffer: LPVOID,
                     nOutBufferSize: DWORD, lpBytesRead: LPDWORD,
                     nTimeOut: DWORD): WINBOOL{.stdcall, dynlib: "kernel32",
    importc: "CallNamedPipeW".}
proc WaitNamedPipeW*(lpNamedPipeName: LPCWSTR, nTimeOut: DWORD): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "WaitNamedPipeW".}
proc SetVolumeLabelW*(lpRootPathName: LPCWSTR, lpVolumeName: LPCWSTR): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "SetVolumeLabelW".}
proc GetVolumeInformationW*(lpRootPathName: LPCWSTR, lpVolumeNameBuffer: LPWSTR,
                            nVolumeNameSize: DWORD,
                            lpVolumeSerialNumber: LPDWORD,
                            lpMaximumComponentLength: LPDWORD,
                            lpFileSystemFlags: LPDWORD,
                            lpFileSystemNameBuffer: LPWSTR,
                            nFileSystemNameSize: DWORD): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "GetVolumeInformationW".}
proc ClearEventLogW*(hEventLog: HANDLE, lpBackupFileName: LPCWSTR): WINBOOL{.
    stdcall, dynlib: "advapi32", importc: "ClearEventLogW".}
proc BackupEventLogW*(hEventLog: HANDLE, lpBackupFileName: LPCWSTR): WINBOOL{.
    stdcall, dynlib: "advapi32", importc: "BackupEventLogW".}
proc OpenEventLogW*(lpUNCServerName: LPCWSTR, lpSourceName: LPCWSTR): HANDLE{.
    stdcall, dynlib: "advapi32", importc: "OpenEventLogW".}
proc RegisterEventSourceW*(lpUNCServerName: LPCWSTR, lpSourceName: LPCWSTR): HANDLE{.
    stdcall, dynlib: "advapi32", importc: "RegisterEventSourceW".}
proc OpenBackupEventLogW*(lpUNCServerName: LPCWSTR, lpFileName: LPCWSTR): HANDLE{.
    stdcall, dynlib: "advapi32", importc: "OpenBackupEventLogW".}
proc ReadEventLogW*(hEventLog: HANDLE, dwReadFlags: DWORD,
                    dwRecordOffset: DWORD, lpBuffer: LPVOID,
                    nNumberOfBytesToRead: DWORD, pnBytesRead: LPDWORD,
                    pnMinNumberOfBytesNeeded: LPDWORD): WINBOOL{.stdcall,
    dynlib: "advapi32", importc: "ReadEventLogW".}
proc ReportEventW*(hEventLog: HANDLE, wType: int16, wCategory: int16,
                   dwEventID: DWORD, lpUserSid: PSID, wNumStrings: int16,
                   dwDataSize: DWORD, lpStrings: LPPCWSTR, lpRawData: LPVOID): WINBOOL{.
    stdcall, dynlib: "advapi32", importc: "ReportEventW".}
proc AccessCheckAndAuditAlarmW*(SubsystemName: LPCWSTR, HandleId: LPVOID,
                                ObjectTypeName: LPWSTR, ObjectName: LPWSTR,
                                SecurityDescriptor: PSECURITY_DESCRIPTOR,
                                DesiredAccess: DWORD,
                                GenericMapping: PGENERIC_MAPPING,
                                ObjectCreation: WINBOOL, GrantedAccess: LPDWORD,
                                AccessStatus: LPBOOL, pfGenerateOnClose: LPBOOL): WINBOOL{.
    stdcall, dynlib: "advapi32", importc: "AccessCheckAndAuditAlarmW".}
proc ObjectOpenAuditAlarmW*(SubsystemName: LPCWSTR, HandleId: LPVOID,
                            ObjectTypeName: LPWSTR, ObjectName: LPWSTR,
                            pSecurityDescriptor: PSECURITY_DESCRIPTOR,
                            ClientToken: HANDLE, DesiredAccess: DWORD,
                            GrantedAccess: DWORD, Privileges: PPRIVILEGE_SET,
                            ObjectCreation: WINBOOL, AccessGranted: WINBOOL,
                            GenerateOnClose: LPBOOL): WINBOOL{.stdcall,
    dynlib: "advapi32", importc: "ObjectOpenAuditAlarmW".}
proc ObjectPrivilegeAuditAlarmW*(SubsystemName: LPCWSTR, HandleId: LPVOID,
                                 ClientToken: HANDLE, DesiredAccess: DWORD,
                                 Privileges: PPRIVILEGE_SET,
                                 AccessGranted: WINBOOL): WINBOOL{.stdcall,
    dynlib: "advapi32", importc: "ObjectPrivilegeAuditAlarmW".}
proc ObjectCloseAuditAlarmW*(SubsystemName: LPCWSTR, HandleId: LPVOID,
                             GenerateOnClose: WINBOOL): WINBOOL{.stdcall,
    dynlib: "advapi32", importc: "ObjectCloseAuditAlarmW".}
proc PrivilegedServiceAuditAlarmW*(SubsystemName: LPCWSTR, ServiceName: LPCWSTR,
                                   ClientToken: HANDLE,
                                   Privileges: PPRIVILEGE_SET,
                                   AccessGranted: WINBOOL): WINBOOL{.stdcall,
    dynlib: "advapi32", importc: "PrivilegedServiceAuditAlarmW".}
proc SetFileSecurityW*(lpFileName: LPCWSTR,
                       SecurityInformation: SECURITY_INFORMATION,
                       pSecurityDescriptor: PSECURITY_DESCRIPTOR): WINBOOL{.
    stdcall, dynlib: "advapi32", importc: "SetFileSecurityW".}
proc GetFileSecurityW*(lpFileName: LPCWSTR,
                       RequestedInformation: SECURITY_INFORMATION,
                       pSecurityDescriptor: PSECURITY_DESCRIPTOR,
                       nLength: DWORD, lpnLengthNeeded: LPDWORD): WINBOOL{.
    stdcall, dynlib: "advapi32", importc: "GetFileSecurityW".}
proc FindFirstChangeNotificationW*(lpPathName: LPCWSTR, bWatchSubtree: WINBOOL,
                                   dwNotifyFilter: DWORD): HANDLE{.stdcall,
    dynlib: "kernel32", importc: "FindFirstChangeNotificationW".}
proc IsBadStringPtrW*(lpsz: LPCWSTR, ucchMax: UINT): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "IsBadStringPtrW".}
proc LookupAccountSidW*(lpSystemName: LPCWSTR, Sid: PSID, Name: LPWSTR,
                        cbName: LPDWORD, ReferencedDomainName: LPWSTR,
                        cbReferencedDomainName: LPDWORD, peUse: PSID_NAME_USE): WINBOOL{.
    stdcall, dynlib: "advapi32", importc: "LookupAccountSidW".}
proc LookupAccountNameW*(lpSystemName: LPCWSTR, lpAccountName: LPCWSTR,
                         Sid: PSID, cbSid: LPDWORD,
                         ReferencedDomainName: LPWSTR,
                         cbReferencedDomainName: LPDWORD, peUse: PSID_NAME_USE): WINBOOL{.
    stdcall, dynlib: "advapi32", importc: "LookupAccountNameW".}
proc LookupPrivilegeValueW*(lpSystemName: LPCWSTR, lpName: LPCWSTR,
                            lpLuid: PLUID): WINBOOL{.stdcall,
    dynlib: "advapi32", importc: "LookupPrivilegeValueW".}
proc LookupPrivilegeNameW*(lpSystemName: LPCWSTR, lpLuid: PLUID, lpName: LPWSTR,
                           cbName: LPDWORD): WINBOOL{.stdcall,
    dynlib: "advapi32", importc: "LookupPrivilegeNameW".}
proc LookupPrivilegeDisplayNameW*(lpSystemName: LPCWSTR, lpName: LPCWSTR,
                                  lpDisplayName: LPWSTR, cbDisplayName: LPDWORD,
                                  lpLanguageId: LPDWORD): WINBOOL{.stdcall,
    dynlib: "advapi32", importc: "LookupPrivilegeDisplayNameW".}
proc BuildCommDCBW*(lpDef: LPCWSTR, lpDCB: LPDCB): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "BuildCommDCBW".}
proc BuildCommDCBAndTimeoutsW*(lpDef: LPCWSTR, lpDCB: LPDCB,
                               lpCommTimeouts: LPCOMMTIMEOUTS): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "BuildCommDCBAndTimeoutsW".}
proc CommConfigDialogW*(lpszName: LPCWSTR, wnd: HWND, lpCC: LPCOMMCONFIG): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "CommConfigDialogW".}
proc GetDefaultCommConfigW*(lpszName: LPCWSTR, lpCC: LPCOMMCONFIG,
                            lpdwSize: LPDWORD): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "GetDefaultCommConfigW".}
proc SetDefaultCommConfigW*(lpszName: LPCWSTR, lpCC: LPCOMMCONFIG, dwSize: DWORD): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "SetDefaultCommConfigW".}
proc GetComputerNameW*(lpBuffer: LPWSTR, nSize: LPDWORD): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "GetComputerNameW".}
proc SetComputerNameW*(lpComputerName: LPCWSTR): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "SetComputerNameW".}
proc GetUserNameW*(lpBuffer: LPWSTR, nSize: LPDWORD): WINBOOL{.stdcall,
    dynlib: "advapi32", importc: "GetUserNameW".}
proc LoadKeyboardLayoutW*(pwszKLID: LPCWSTR, Flags: UINT): HKL{.stdcall,
    dynlib: "user32", importc: "LoadKeyboardLayoutW".}
proc GetKeyboardLayoutNameW*(pwszKLID: LPWSTR): WINBOOL{.stdcall,
    dynlib: "user32", importc: "GetKeyboardLayoutNameW".}
proc CreateDesktopW*(lpszDesktop: LPWSTR, lpszDevice: LPWSTR,
                     pDevmodew: LPDEVMODEw, dwFlags: DWORD,
                     dwDesiredAccess: DWORD, lpsa: LPSECURITY_ATTRIBUTES): HDESK{.
    stdcall, dynlib: "user32", importc: "CreateDesktopW".}
proc OpenDesktopW*(lpszDesktop: LPWSTR, dwFlags: DWORD, fInherit: WINBOOL,
                   dwDesiredAccess: DWORD): HDESK{.stdcall, dynlib: "user32",
    importc: "OpenDesktopW".}
proc EnumDesktopsW*(hwinsta: HWINSTA, lpEnumFunc: DESKTOPENUMPROC,
                    lp: LPARAM): WINBOOL{.stdcall, dynlib: "user32",
    importc: "EnumDesktopsW".}
proc CreateWindowStationW*(lpwinsta: LPWSTR, dwReserved: DWORD,
                           dwDesiredAccess: DWORD, lpsa: LPSECURITY_ATTRIBUTES): HWINSTA{.
    stdcall, dynlib: "user32", importc: "CreateWindowStationW".}
proc OpenWindowStationW*(lpszWinSta: LPWSTR, fInherit: WINBOOL,
                         dwDesiredAccess: DWORD): HWINSTA{.stdcall,
    dynlib: "user32", importc: "OpenWindowStationW".}
proc EnumWindowStationsW*(lpEnumFunc: ENUMWINDOWSTATIONPROC, lp: LPARAM): WINBOOL{.
    stdcall, dynlib: "user32", importc: "EnumWindowStationsW".}
proc GetUserObjectInformationW*(hObj: HANDLE, nIndex: int32, pvInfo: PVOID,
                                nLength: DWORD, lpnLengthNeeded: LPDWORD): WINBOOL{.
    stdcall, dynlib: "user32", importc: "GetUserObjectInformationW".}
proc SetUserObjectInformationW*(hObj: HANDLE, nIndex: int32, pvInfo: PVOID,
                                nLength: DWORD): WINBOOL{.stdcall,
    dynlib: "user32", importc: "SetUserObjectInformationW".}
proc RegisterWindowMessageW*(lpString: LPCWSTR): UINT{.stdcall,
    dynlib: "user32", importc: "RegisterWindowMessageW".}
proc GetMessageW*(lpMsg: LPMSG, wnd: HWND, wMsgFilterMin: UINT,
                  wMsgFilterMax: UINT): WINBOOL{.stdcall, dynlib: "user32",
    importc: "GetMessageW".}
proc DispatchMessageW*(lpMsg: LPMSG): LONG{.stdcall, dynlib: "user32",
    importc: "DispatchMessageW".}
proc PeekMessageW*(lpMsg: LPMSG, wnd: HWND, wMsgFilterMin: UINT,
                   wMsgFilterMax: UINT, wRemoveMsg: UINT): WINBOOL{.stdcall,
    dynlib: "user32", importc: "PeekMessageW".}
proc SendMessageW*(wnd: HWND, Msg: UINT, wp: WPARAM, lp: LPARAM): LRESULT{.
    stdcall, dynlib: "user32", importc: "SendMessageW".}
proc SendMessageTimeoutW*(wnd: HWND, Msg: UINT, wp: WPARAM, lp: LPARAM,
                          fuFlags: UINT, uTimeout: UINT, lpdwResult: LPDWORD): LRESULT{.
    stdcall, dynlib: "user32", importc: "SendMessageTimeoutW".}
proc SendNotifyMessageW*(wnd: HWND, Msg: UINT, wp: WPARAM, lp: LPARAM): WINBOOL{.
    stdcall, dynlib: "user32", importc: "SendNotifyMessageW".}
proc SendMessageCallbackW*(wnd: HWND, Msg: UINT, wp: WPARAM,
                           lp: LPARAM, lpResultCallBack: SENDASYNCPROC,
                           dwData: DWORD): WINBOOL{.stdcall, dynlib: "user32",
    importc: "SendMessageCallbackW".}
proc PostMessageW*(wnd: HWND, Msg: UINT, wp: WPARAM, lp: LPARAM): WINBOOL{.
    stdcall, dynlib: "user32", importc: "PostMessageW".}
proc PostThreadMessageW*(idThread: DWORD, Msg: UINT, wp: WPARAM,
                         lp: LPARAM): WINBOOL{.stdcall, dynlib: "user32",
    importc: "PostThreadMessageW".}
proc DefWindowProcW*(wnd: HWND, Msg: UINT, wp: WPARAM, lp: LPARAM): LRESULT{.
    stdcall, dynlib: "user32", importc: "DefWindowProcW".}
proc CallWindowProcW*(lpPrevWndFunc: WNDPROC, wnd: HWND, Msg: UINT,
                      wp: WPARAM, lp: LPARAM): LRESULT{.stdcall,
    dynlib: "user32", importc: "CallWindowProcW".}
proc RegisterClassW*(lpWndClass: LPWNDCLASSW): ATOM{.stdcall, dynlib: "user32",
    importc: "RegisterClassW".}
proc UnregisterClassW*(lpClassName: LPCWSTR, hInstance: HINST): WINBOOL{.
    stdcall, dynlib: "user32", importc: "UnregisterClassW".}
proc GetClassInfoW*(hInstance: HINST, lpClassName: LPCWSTR,
                    lpWndClass: LPWNDCLASS): WINBOOL{.stdcall, dynlib: "user32",
    importc: "GetClassInfoW".}
proc RegisterClassExW*(para1: LPWNDCLASSEXW): ATOM{.stdcall, dynlib: "user32",
    importc: "RegisterClassExW".}
proc GetClassInfoExW*(para1: HINST, para2: LPCWSTR, para3: LPWNDCLASSEX): WINBOOL{.
    stdcall, dynlib: "user32", importc: "GetClassInfoExW".}
proc CreateWindowExW*(dwExStyle: DWORD, lpClassName: LPCWSTR,
                      lpWindowName: LPCWSTR, dwStyle: DWORD, X: int32, Y: int32,
                      nWidth: int32, nHeight: int32, hWndParent: HWND,
                      menu: HMENU, hInstance: HINST, lpParam: LPVOID): HWND{.
    stdcall, dynlib: "user32", importc: "CreateWindowExW".}
proc CreateDialogParamW*(hInstance: HINST, lpTemplateName: LPCWSTR,
                         hWndParent: HWND, lpDialogFunc: DLGPROC,
                         dwInitParam: LPARAM): HWND{.stdcall, dynlib: "user32",
    importc: "CreateDialogParamW".}
proc CreateDialogIndirectParamW*(hInstance: HINST, lpTemplate: LPCDLGTEMPLATE,
                                 hWndParent: HWND, lpDialogFunc: DLGPROC,
                                 dwInitParam: LPARAM): HWND{.stdcall,
    dynlib: "user32", importc: "CreateDialogIndirectParamW".}
proc DialogBoxParamW*(hInstance: HINST, lpTemplateName: LPCWSTR,
                      hWndParent: HWND, lpDialogFunc: DLGPROC,
                      dwInitParam: LPARAM): int32{.stdcall, dynlib: "user32",
    importc: "DialogBoxParamW".}
proc DialogBoxIndirectParamW*(hInstance: HINST, hDialogTemplate: LPCDLGTEMPLATE,
                              hWndParent: HWND, lpDialogFunc: DLGPROC,
                              dwInitParam: LPARAM): int32{.stdcall,
    dynlib: "user32", importc: "DialogBoxIndirectParamW".}
proc SetDlgItemTextW*(hDlg: HWND, nIDDlgItem: int32, lpString: LPCWSTR): WINBOOL{.
    stdcall, dynlib: "user32", importc: "SetDlgItemTextW".}
proc GetDlgItemTextW*(hDlg: HWND, nIDDlgItem: int32, lpString: LPWSTR,
                      nMaxCount: int32): UINT{.stdcall, dynlib: "user32",
    importc: "GetDlgItemTextW".}
proc SendDlgItemMessageW*(hDlg: HWND, nIDDlgItem: int32, Msg: UINT,
                          wp: WPARAM, lp: LPARAM): LONG{.stdcall,
    dynlib: "user32", importc: "SendDlgItemMessageW".}
proc DefDlgProcW*(hDlg: HWND, Msg: UINT, wp: WPARAM, lp: LPARAM): LRESULT{.
    stdcall, dynlib: "user32", importc: "DefDlgProcW".}
proc CallMsgFilterW*(lpMsg: LPMSG, nCode: int32): WINBOOL{.stdcall,
    dynlib: "user32", importc: "CallMsgFilterW".}
proc RegisterClipboardFormatW*(lpszFormat: LPCWSTR): UINT{.stdcall,
    dynlib: "user32", importc: "RegisterClipboardFormatW".}
proc GetClipboardFormatNameW*(format: UINT, lpszFormatName: LPWSTR,
                              cchMaxCount: int32): int32{.stdcall,
    dynlib: "user32", importc: "GetClipboardFormatNameW".}
proc CharToOemW*(lpszSrc: LPCWSTR, lpszDst: LPSTR): WINBOOL{.stdcall,
    dynlib: "user32", importc: "CharToOemW".}
proc OemToCharW*(lpszSrc: LPCSTR, lpszDst: LPWSTR): WINBOOL{.stdcall,
    dynlib: "user32", importc: "OemToCharW".}
proc CharToOemBuffW*(lpszSrc: LPCWSTR, lpszDst: LPSTR, cchDstLength: DWORD): WINBOOL{.
    stdcall, dynlib: "user32", importc: "CharToOemBuffW".}
proc OemToCharBuffW*(lpszSrc: LPCSTR, lpszDst: LPWSTR, cchDstLength: DWORD): WINBOOL{.
    stdcall, dynlib: "user32", importc: "OemToCharBuffW".}
proc CharUpperW*(lpsz: LPWSTR): LPWSTR{.stdcall, dynlib: "user32",
                                        importc: "CharUpperW".}
proc CharUpperBuffW*(lpsz: LPWSTR, cchLength: DWORD): DWORD{.stdcall,
    dynlib: "user32", importc: "CharUpperBuffW".}
proc CharLowerW*(lpsz: LPWSTR): LPWSTR{.stdcall, dynlib: "user32",
                                        importc: "CharLowerW".}
proc CharLowerBuffW*(lpsz: LPWSTR, cchLength: DWORD): DWORD{.stdcall,
    dynlib: "user32", importc: "CharLowerBuffW".}
proc CharNextW*(lpsz: LPCWSTR): LPWSTR{.stdcall, dynlib: "user32",
                                        importc: "CharNextW".}
proc CharPrevW*(lpszStart: LPCWSTR, lpszCurrent: LPCWSTR): LPWSTR{.stdcall,
    dynlib: "user32", importc: "CharPrevW".}
proc IsCharAlphaW*(ch: WCHAR): WINBOOL{.stdcall, dynlib: "user32",
                                        importc: "IsCharAlphaW".}
proc IsCharAlphaNumericW*(ch: WCHAR): WINBOOL{.stdcall, dynlib: "user32",
    importc: "IsCharAlphaNumericW".}
proc IsCharUpperW*(ch: WCHAR): WINBOOL{.stdcall, dynlib: "user32",
                                        importc: "IsCharUpperW".}
proc IsCharLowerW*(ch: WCHAR): WINBOOL{.stdcall, dynlib: "user32",
                                        importc: "IsCharLowerW".}
proc GetKeyNameTextW*(lParam: LONG, lpString: LPWSTR, nSize: int32): int32{.
    stdcall, dynlib: "user32", importc: "GetKeyNameTextW".}
proc VkKeyScanW*(ch: WCHAR): SHORT{.stdcall, dynlib: "user32",
                                    importc: "VkKeyScanW".}
proc VkKeyScanExW*(ch: WCHAR, dwhkl: HKL): SHORT{.stdcall, dynlib: "user32",
    importc: "VkKeyScanExW".}
proc MapVirtualKeyW*(uCode: UINT, uMapType: UINT): UINT{.stdcall,
    dynlib: "user32", importc: "MapVirtualKeyW".}
proc MapVirtualKeyExW*(uCode: UINT, uMapType: UINT, dwhkl: HKL): UINT{.stdcall,
    dynlib: "user32", importc: "MapVirtualKeyExW".}
proc LoadAcceleratorsW*(hInstance: HINST, lpTableName: LPCWSTR): HACCEL{.
    stdcall, dynlib: "user32", importc: "LoadAcceleratorsW".}
proc CreateAcceleratorTableW*(para1: LPACCEL, para2: int32): HACCEL{.stdcall,
    dynlib: "user32", importc: "CreateAcceleratorTableW".}
proc CopyAcceleratorTableW*(hAccelSrc: HACCEL, lpAccelDst: LPACCEL,
                            cAccelEntries: int32): int32{.stdcall,
    dynlib: "user32", importc: "CopyAcceleratorTableW".}
proc TranslateAcceleratorW*(wnd: HWND, hAccTable: HACCEL, lpMsg: LPMSG): int32{.
    stdcall, dynlib: "user32", importc: "TranslateAcceleratorW".}
proc LoadMenuW*(hInstance: HINST, lpMenuName: LPCWSTR): HMENU{.stdcall,
    dynlib: "user32", importc: "LoadMenuW".}
proc LoadMenuIndirectW*(lpMenuTemplate: LPMENUTEMPLATE): HMENU{.stdcall,
    dynlib: "user32", importc: "LoadMenuIndirectW".}
proc ChangeMenuW*(menu: HMENU, cmd: UINT, lpszNewItem: LPCWSTR,
                  cmdInsert: UINT, flags: UINT): WINBOOL{.stdcall,
    dynlib: "user32", importc: "ChangeMenuW".}
proc GetMenuStringW*(menu: HMENU, uIDItem: UINT, lpString: LPWSTR,
                     nMaxCount: int32, uFlag: UINT): int32{.stdcall,
    dynlib: "user32", importc: "GetMenuStringW".}
proc InsertMenuW*(menu: HMENU, uPosition: UINT, uFlags: UINT, uIDNewItem: UINT,
                  lpNewItem: LPCWSTR): WINBOOL{.stdcall, dynlib: "user32",
    importc: "InsertMenuW".}
proc AppendMenuW*(menu: HMENU, uFlags: UINT, uIDNewItem: UINT,
                  lpNewItem: LPCWSTR): WINBOOL{.stdcall, dynlib: "user32",
    importc: "AppendMenuW".}
proc ModifyMenuW*(hMnu: HMENU, uPosition: UINT, uFlags: UINT, uIDNewItem: UINT,
                  lpNewItem: LPCWSTR): WINBOOL{.stdcall, dynlib: "user32",
    importc: "ModifyMenuW".}
proc InsertMenuItemW*(para1: HMENU, para2: UINT, para3: WINBOOL,
                      para4: LPCMENUITEMINFO): WINBOOL{.stdcall,
    dynlib: "user32", importc: "InsertMenuItemW".}
proc GetMenuItemInfoW*(para1: HMENU, para2: UINT, para3: WINBOOL,
                       para4: LPMENUITEMINFO): WINBOOL{.stdcall,
    dynlib: "user32", importc: "GetMenuItemInfoW".}
proc SetMenuItemInfoW*(para1: HMENU, para2: UINT, para3: WINBOOL,
                       para4: LPCMENUITEMINFO): WINBOOL{.stdcall,
    dynlib: "user32", importc: "SetMenuItemInfoW".}
proc DrawTextW*(hDC: HDC, lpString: LPCWSTR, nCount: int32, lpRect: LPRECT,
                uFormat: UINT): int32{.stdcall, dynlib: "user32",
                                       importc: "DrawTextW".}
proc DrawTextExW*(para1: HDC, para2: LPWSTR, para3: int32, para4: LPRECT,
                  para5: UINT, para6: LPDRAWTEXTPARAMS): int32{.stdcall,
    dynlib: "user32", importc: "DrawTextExW".}
proc GrayStringW*(hDC: HDC, hBrush: HBRUSH, lpOutputFunc: GRAYSTRINGPROC,
                  lpData: LPARAM, nCount: int32, X: int32, Y: int32,
                  nWidth: int32, nHeight: int32): WINBOOL{.stdcall,
    dynlib: "user32", importc: "GrayStringW".}
proc DrawStateW*(para1: HDC, para2: HBRUSH, para3: DRAWSTATEPROC, para4: LPARAM,
                 para5: WPARAM, para6: int32, para7: int32, para8: int32,
                 para9: int32, para10: UINT): WINBOOL{.stdcall,
    dynlib: "user32", importc: "DrawStateW".}
proc TabbedTextOutW*(hDC: HDC, X: int32, Y: int32, lpString: LPCWSTR,
                     nCount: int32, nTabPositions: int32,
                     lpnTabStopPositions: LPINT, nTabOrigin: int32): LONG{.
    stdcall, dynlib: "user32", importc: "TabbedTextOutW".}
proc GetTabbedTextExtentW*(hDC: HDC, lpString: LPCWSTR, nCount: int32,
                           nTabPositions: int32, lpnTabStopPositions: LPINT): DWORD{.
    stdcall, dynlib: "user32", importc: "GetTabbedTextExtentW".}
proc SetPropW*(wnd: HWND, lpString: LPCWSTR, hData: HANDLE): WINBOOL{.stdcall,
    dynlib: "user32", importc: "SetPropW".}
proc GetPropW*(wnd: HWND, lpString: LPCWSTR): HANDLE{.stdcall,
    dynlib: "user32", importc: "GetPropW".}
proc RemovePropW*(wnd: HWND, lpString: LPCWSTR): HANDLE{.stdcall,
    dynlib: "user32", importc: "RemovePropW".}
proc EnumPropsExW*(wnd: HWND, lpEnumFunc: PROPENUMPROCEX, lp: LPARAM): int32{.
    stdcall, dynlib: "user32", importc: "EnumPropsExW".}
proc EnumPropsW*(wnd: HWND, lpEnumFunc: PROPENUMPROC): int32{.stdcall,
    dynlib: "user32", importc: "EnumPropsW".}
proc SetWindowTextW*(wnd: HWND, lpString: LPCWSTR): WINBOOL{.stdcall,
    dynlib: "user32", importc: "SetWindowTextW".}
proc GetWindowTextW*(wnd: HWND, lpString: LPWSTR, nMaxCount: int32): int32{.
    stdcall, dynlib: "user32", importc: "GetWindowTextW".}
proc GetWindowTextLengthW*(wnd: HWND): int32{.stdcall, dynlib: "user32",
    importc: "GetWindowTextLengthW".}
proc MessageBoxW*(wnd: HWND, lpText: LPCWSTR, lpCaption: LPCWSTR, uType: UINT): int32{.
    stdcall, dynlib: "user32", importc: "MessageBoxW".}
proc MessageBoxExW*(wnd: HWND, lpText: LPCWSTR, lpCaption: LPCWSTR,
                    uType: UINT, wLanguageId: int16): int32{.stdcall,
    dynlib: "user32", importc: "MessageBoxExW".}
proc MessageBoxIndirectW*(para1: LPMSGBOXPARAMS): int32{.stdcall,
    dynlib: "user32", importc: "MessageBoxIndirectW".}
proc GetWindowLongW*(wnd: HWND, nIndex: int32): LONG{.stdcall,
    dynlib: "user32", importc: "GetWindowLongW".}
proc SetWindowLongW*(wnd: HWND, nIndex: int32, dwNewLong: LONG): LONG{.stdcall,
    dynlib: "user32", importc: "SetWindowLongW".}
proc GetClassLongW*(wnd: HWND, nIndex: int32): DWORD{.stdcall,
    dynlib: "user32", importc: "GetClassLongW".}
proc SetClassLongW*(wnd: HWND, nIndex: int32, dwNewLong: LONG): DWORD{.stdcall,
    dynlib: "user32", importc: "SetClassLongW".}
when defined(cpu64):
  proc GetWindowLongPtrW*(wnd: HWND, nIndex: int32): LONG_PTR{.stdcall,
      dynlib: "user32", importc: "GetWindowLongPtrW".}
  proc SetWindowLongPtrW*(wnd: HWND, nIndex: int32, dwNewLong: LONG_PTR): LONG_PTR{.
      stdcall, dynlib: "user32", importc: "SetWindowLongPtrW".}
  proc GetClassLongPtrW*(wnd: HWND, nIndex: int32): LONG_PTR{.stdcall,
      dynlib: "user32", importc: "GetClassLongPtrW".}
  proc SetClassLongPtrW*(wnd: HWND, nIndex: int32, dwNewLong: LONG_PTR): LONG_PTR{.
      stdcall, dynlib: "user32", importc: "SetClassLongPtrW".}
else:
  proc GetWindowLongPtrW*(wnd: HWND, nIndex: int32): LONG_PTR{.stdcall,
      dynlib: "user32", importc: "GetWindowLongW".}
  proc SetWindowLongPtrW*(wnd: HWND, nIndex: int32, dwNewLong: LONG_PTR): LONG_PTR{.
      stdcall, dynlib: "user32", importc: "SetWindowLongW".}
  proc GetClassLongPtrW*(wnd: HWND, nIndex: int32): LONG_PTR{.stdcall,
      dynlib: "user32", importc: "GetClassLongW".}
  proc SetClassLongPtrW*(wnd: HWND, nIndex: int32, dwNewLong: LONG_PTR): LONG_PTR{.
      stdcall, dynlib: "user32", importc: "SetClassLongW".}
proc FindWindowW*(lpClassName: LPCWSTR, lpWindowName: LPCWSTR): HWND{.stdcall,
    dynlib: "user32", importc: "FindWindowW".}
proc FindWindowExW*(para1: HWND, para2: HWND, para3: LPCWSTR, para4: LPCWSTR): HWND{.
    stdcall, dynlib: "user32", importc: "FindWindowExW".}
proc GetClassNameW*(wnd: HWND, lpClassName: LPWSTR, nMaxCount: int32): int32{.
    stdcall, dynlib: "user32", importc: "GetClassNameW".}
proc SetWindowsHookExW*(idHook: int32, lpfn: HOOKPROC, hmod: HINST,
                        dwThreadId: DWORD): HHOOK{.stdcall, dynlib: "user32",
    importc: "SetWindowsHookExW".}
proc LoadBitmapW*(hInstance: HINST, lpBitmapName: LPCWSTR): HBITMAP{.stdcall,
    dynlib: "user32", importc: "LoadBitmapW".}
proc LoadCursorW*(hInstance: HINST, lpCursorName: LPCWSTR): HCURSOR{.stdcall,
    dynlib: "user32", importc: "LoadCursorW".}
proc LoadCursorFromFileW*(lpFileName: LPCWSTR): HCURSOR{.stdcall,
    dynlib: "user32", importc: "LoadCursorFromFileW".}
proc LoadIconW*(hInstance: HINST, lpIconName: LPCWSTR): HICON{.stdcall,
    dynlib: "user32", importc: "LoadIconW".}
proc LoadImageW*(para1: HINST, para2: LPCWSTR, para3: UINT, para4: int32,
                 para5: int32, para6: UINT): HANDLE{.stdcall, dynlib: "user32",
    importc: "LoadImageW".}
proc LoadStringW*(hInstance: HINST, uID: UINT, lpBuffer: LPWSTR,
                  nBufferMax: int32): int32{.stdcall, dynlib: "user32",
    importc: "LoadStringW".}
proc IsDialogMessageW*(hDlg: HWND, lpMsg: LPMSG): WINBOOL{.stdcall,
    dynlib: "user32", importc: "IsDialogMessageW".}
proc DlgDirListW*(hDlg: HWND, lpPathSpec: LPWSTR, nIDListBox: int32,
                  nIDStaticPath: int32, uFileType: UINT): int32{.stdcall,
    dynlib: "user32", importc: "DlgDirListW".}
proc DlgDirSelectExW*(hDlg: HWND, lpString: LPWSTR, nCount: int32,
                      nIDListBox: int32): WINBOOL{.stdcall, dynlib: "user32",
    importc: "DlgDirSelectExW".}
proc DlgDirListComboBoxW*(hDlg: HWND, lpPathSpec: LPWSTR, nIDComboBox: int32,
                          nIDStaticPath: int32, uFiletype: UINT): int32{.
    stdcall, dynlib: "user32", importc: "DlgDirListComboBoxW".}
proc DlgDirSelectComboBoxExW*(hDlg: HWND, lpString: LPWSTR, nCount: int32,
                              nIDComboBox: int32): WINBOOL{.stdcall,
    dynlib: "user32", importc: "DlgDirSelectComboBoxExW".}
proc DefFrameProcW*(wnd: HWND, hWndMDIClient: HWND, uMsg: UINT, w: WPARAM,
                    lp: LPARAM): LRESULT{.stdcall, dynlib: "user32",
    importc: "DefFrameProcW".}
proc DefMDIChildProcW*(wnd: HWND, uMsg: UINT, wp: WPARAM, lp: LPARAM): LRESULT{.
    stdcall, dynlib: "user32", importc: "DefMDIChildProcW".}
proc CreateMDIWindowW*(lpClassName: LPWSTR, lpWindowName: LPWSTR,
                       dwStyle: DWORD, X: int32, Y: int32, nWidth: int32,
                       nHeight: int32, hWndParent: HWND, hInstance: HINST,
                       lp: LPARAM): HWND{.stdcall, dynlib: "user32",
    importc: "CreateMDIWindowW".}
proc WinHelpW*(hWndMain: HWND, lpszHelp: LPCWSTR, uCommand: UINT, dwData: DWORD): WINBOOL{.
    stdcall, dynlib: "user32", importc: "WinHelpW".}
proc ChangeDisplaySettingsW*(lpDevMode: LPDEVMODEW, dwFlags: DWORD): LONG{.
    stdcall, dynlib: "user32", importc: "ChangeDisplaySettingsW".}
proc EnumDisplaySettingsW*(lpszDeviceName: LPCWSTR, iModeNum: DWORD,
                           lpDevMode: LPDEVMODEW): WINBOOL{.stdcall,
    dynlib: "user32", importc: "EnumDisplaySettingsW".}
proc SystemParametersInfoW*(uiAction: UINT, uiParam: UINT, pvParam: PVOID,
                            fWinIni: UINT): WINBOOL{.stdcall, dynlib: "user32",
    importc: "SystemParametersInfoW".}
proc AddFontResourceW*(para1: LPCWSTR): int32{.stdcall, dynlib: "gdi32",
    importc: "AddFontResourceW".}
proc CopyMetaFileW*(para1: HMETAFILE, para2: LPCWSTR): HMETAFILE{.stdcall,
    dynlib: "gdi32", importc: "CopyMetaFileW".}
proc CreateFontIndirectW*(para1: PLOGFONT): HFONT{.stdcall, dynlib: "gdi32",
    importc: "CreateFontIndirectW".}
proc CreateFontIndirectW*(para1: var LOGFONT): HFONT{.stdcall, dynlib: "gdi32",
    importc: "CreateFontIndirectW".}
proc CreateFontW*(para1: int32, para2: int32, para3: int32, para4: int32,
                  para5: int32, para6: DWORD, para7: DWORD, para8: DWORD,
                  para9: DWORD, para10: DWORD, para11: DWORD, para12: DWORD,
                  para13: DWORD, para14: LPCWSTR): HFONT{.stdcall,
    dynlib: "gdi32", importc: "CreateFontW".}
proc CreateICW*(para1: LPCWSTR, para2: LPCWSTR, para3: LPCWSTR,
                para4: LPDEVMODEw): HDC{.stdcall, dynlib: "gdi32",
    importc: "CreateICW".}
proc CreateMetaFileW*(para1: LPCWSTR): HDC{.stdcall, dynlib: "gdi32",
    importc: "CreateMetaFileW".}
proc CreateScalableFontResourceW*(para1: DWORD, para2: LPCWSTR, para3: LPCWSTR,
                                  para4: LPCWSTR): WINBOOL{.stdcall,
    dynlib: "gdi32", importc: "CreateScalableFontResourceW".}
proc EnumFontFamiliesExW*(para1: HDC, para2: LPLOGFONT, para3: FONTENUMEXPROC,
                          para4: LPARAM, para5: DWORD): int32{.stdcall,
    dynlib: "gdi32", importc: "EnumFontFamiliesExW".}
proc EnumFontFamiliesW*(para1: HDC, para2: LPCWSTR, para3: FONTENUMPROC,
                        para4: LPARAM): int32{.stdcall, dynlib: "gdi32",
    importc: "EnumFontFamiliesW".}
proc EnumFontsW*(para1: HDC, para2: LPCWSTR, para3: ENUMFONTSPROC, para4: LPARAM): int32{.
    stdcall, dynlib: "gdi32", importc: "EnumFontsW".}
proc EnumFontsW*(para1: HDC, para2: LPCWSTR, para3: ENUMFONTSPROC,
                 para4: pointer): int32{.stdcall, dynlib: "gdi32",
    importc: "EnumFontsW".}
proc GetCharWidthW*(para1: HDC, para2: UINT, para3: UINT, para4: LPINT): WINBOOL{.
    stdcall, dynlib: "gdi32", importc: "GetCharWidthW".}
proc GetCharWidth32W*(para1: HDC, para2: UINT, para3: UINT, para4: LPINT): WINBOOL{.
    stdcall, dynlib: "gdi32", importc: "GetCharWidth32W".}
proc GetCharWidthFloatW*(para1: HDC, para2: UINT, para3: UINT, para4: ptr float32): WINBOOL{.
    stdcall, dynlib: "gdi32", importc: "GetCharWidthFloatW".}
proc GetCharABCWidthsW*(para1: HDC, para2: UINT, para3: UINT, para4: LPABC): WINBOOL{.
    stdcall, dynlib: "gdi32", importc: "GetCharABCWidthsW".}
proc GetCharABCWidthsFloatW*(para1: HDC, para2: UINT, para3: UINT,
                             para4: LPABCFLOAT): WINBOOL{.stdcall,
    dynlib: "gdi32", importc: "GetCharABCWidthsFloatW".}
proc GetGlyphOutlineW*(para1: HDC, para2: UINT, para3: UINT,
                       para4: LPGLYPHMETRICS, para5: DWORD, para6: LPVOID,
                       para7: PMAT2): DWORD{.stdcall, dynlib: "gdi32",
    importc: "GetGlyphOutlineW".}
proc GetMetaFileW*(para1: LPCWSTR): HMETAFILE{.stdcall, dynlib: "gdi32",
    importc: "GetMetaFileW".}
proc GetOutlineTextMetricsW*(para1: HDC, para2: UINT, para3: LPOUTLINETEXTMETRIC): UINT{.
    stdcall, dynlib: "gdi32", importc: "GetOutlineTextMetricsW".}
proc GetTextExtentPointW*(para1: HDC, para2: LPCWSTR, para3: int32,
                          para4: LPSIZE): WINBOOL{.stdcall, dynlib: "gdi32",
    importc: "GetTextExtentPointW".}
proc GetTextExtentPoint32W*(para1: HDC, para2: LPCWSTR, para3: int32,
                            para4: LPSIZE): WINBOOL{.stdcall, dynlib: "gdi32",
    importc: "GetTextExtentPoint32W".}
proc GetTextExtentExPointW*(para1: HDC, para2: LPCWSTR, para3: int32,
                            para4: int32, para5: LPINT, para6: LPINT,
                            para7: LPSIZE): WINBOOL{.stdcall, dynlib: "gdi32",
    importc: "GetTextExtentExPointW".}
proc GetCharacterPlacementW*(para1: HDC, para2: LPCWSTR, para3: int32,
                             para4: int32, para5: LPGCP_RESULTS, para6: DWORD): DWORD{.
    stdcall, dynlib: "gdi32", importc: "GetCharacterPlacementW".}
proc ResetDCW*(para1: HDC, para2: LPDEVMODEW): HDC{.stdcall, dynlib: "gdi32",
    importc: "ResetDCW".}
proc RemoveFontResourceW*(para1: LPCWSTR): WINBOOL{.stdcall, dynlib: "gdi32",
    importc: "RemoveFontResourceW".}
proc CopyEnhMetaFileW*(para1: HENHMETAFILE, para2: LPCWSTR): HENHMETAFILE{.
    stdcall, dynlib: "gdi32", importc: "CopyEnhMetaFileW".}
proc CreateEnhMetaFileW*(para1: HDC, para2: LPCWSTR, para3: LPRECT,
                         para4: LPCWSTR): HDC{.stdcall, dynlib: "gdi32",
    importc: "CreateEnhMetaFileW".}
proc GetEnhMetaFileW*(para1: LPCWSTR): HENHMETAFILE{.stdcall, dynlib: "gdi32",
    importc: "GetEnhMetaFileW".}
proc GetEnhMetaFileDescriptionW*(para1: HENHMETAFILE, para2: UINT, para3: LPWSTR): UINT{.
    stdcall, dynlib: "gdi32", importc: "GetEnhMetaFileDescriptionW".}
proc GetTextMetricsW*(para1: HDC, para2: LPTEXTMETRIC): WINBOOL{.stdcall,
    dynlib: "gdi32", importc: "GetTextMetricsW".}
proc StartDocW*(para1: HDC, para2: PDOCINFO): int32{.stdcall, dynlib: "gdi32",
    importc: "StartDocW".}
proc GetObjectW*(para1: HGDIOBJ, para2: int32, para3: LPVOID): int32{.stdcall,
    dynlib: "gdi32", importc: "GetObjectW".}
proc TextOutW*(para1: HDC, para2: int32, para3: int32, para4: LPCWSTR,
               para5: int32): WINBOOL{.stdcall, dynlib: "gdi32",
                                       importc: "TextOutW".}
proc ExtTextOutW*(para1: HDC, para2: int32, para3: int32, para4: UINT,
                  para5: LPRECT, para6: LPCWSTR, para7: UINT, para8: LPINT): WINBOOL{.
    stdcall, dynlib: "gdi32", importc: "ExtTextOutW".}
proc PolyTextOutW*(para1: HDC, para2: PPOLYTEXT, para3: int32): WINBOOL{.
    stdcall, dynlib: "gdi32", importc: "PolyTextOutW".}
proc GetTextFaceW*(para1: HDC, para2: int32, para3: LPWSTR): int32{.stdcall,
    dynlib: "gdi32", importc: "GetTextFaceW".}
proc GetKerningPairsW*(para1: HDC, para2: DWORD, para3: LPKERNINGPAIR): DWORD{.
    stdcall, dynlib: "gdi32", importc: "GetKerningPairsW".}
proc GetLogColorSpaceW*(para1: HCOLORSPACE, para2: LPLOGCOLORSPACE, para3: DWORD): WINBOOL{.
    stdcall, dynlib: "gdi32", importc: "GetLogColorSpaceW".}
proc CreateColorSpaceW*(para1: LPLOGCOLORSPACE): HCOLORSPACE{.stdcall,
    dynlib: "gdi32", importc: "CreateColorSpaceW".}
proc GetICMProfileW*(para1: HDC, para2: DWORD, para3: LPWSTR): WINBOOL{.stdcall,
    dynlib: "gdi32", importc: "GetICMProfileW".}
proc SetICMProfileW*(para1: HDC, para2: LPWSTR): WINBOOL{.stdcall,
    dynlib: "gdi32", importc: "SetICMProfileW".}
proc UpdateICMRegKeyW*(para1: DWORD, para2: DWORD, para3: LPWSTR, para4: UINT): WINBOOL{.
    stdcall, dynlib: "gdi32", importc: "UpdateICMRegKeyW".}
proc EnumICMProfilesW*(para1: HDC, para2: ICMENUMPROC, para3: LPARAM): int32{.
    stdcall, dynlib: "gdi32", importc: "EnumICMProfilesW".}
proc CreatePropertySheetPageW*(lppsp: LPCPROPSHEETPAGE): HPROPSHEETPAGE{.
    stdcall, dynlib: "comctl32", importc: "CreatePropertySheetPageW".}
proc PropertySheetW*(lppsph: LPCPROPSHEETHEADER): int32{.stdcall,
    dynlib: "comctl32", importc: "PropertySheetW".}
proc ImageList_LoadImageW*(hi: HINST, lpbmp: LPCWSTR, cx: int32, cGrow: int32,
                           crMask: COLORREF, uType: UINT, uFlags: UINT): HIMAGELIST{.
    stdcall, dynlib: "comctl32", importc: "ImageList_LoadImageW".}
proc CreateStatusWindowW*(style: LONG, lpszText: LPCWSTR, hwndParent: HWND,
                          wID: UINT): HWND{.stdcall, dynlib: "comctl32",
    importc: "CreateStatusWindowW".}
proc DrawStatusTextW*(hDC: HDC, lprc: LPRECT, pszText: LPCWSTR, uFlags: UINT){.
    stdcall, dynlib: "comctl32", importc: "DrawStatusTextW".}
proc GetOpenFileNameW*(para1: LPOPENFILENAME): WINBOOL{.stdcall,
    dynlib: "comdlg32", importc: "GetOpenFileNameW".}
proc GetSaveFileNameW*(para1: LPOPENFILENAME): WINBOOL{.stdcall,
    dynlib: "comdlg32", importc: "GetSaveFileNameW".}
proc GetFileTitleW*(para1: LPCWSTR, para2: LPWSTR, para3: int16): int{.stdcall,
    dynlib: "comdlg32", importc: "GetFileTitleW".}
proc ChooseColorW*(para1: LPCHOOSECOLOR): WINBOOL{.stdcall, dynlib: "comdlg32",
    importc: "ChooseColorW".}
proc ReplaceTextW*(para1: LPFINDREPLACE): HWND{.stdcall, dynlib: "comdlg32",
    importc: "ReplaceTextW".}
proc ChooseFontW*(para1: LPCHOOSEFONT): WINBOOL{.stdcall, dynlib: "comdlg32",
    importc: "ChooseFontW".}
proc FindTextW*(para1: LPFINDREPLACE): HWND{.stdcall, dynlib: "comdlg32",
    importc: "FindTextW".}
proc PrintDlgW*(para1: LPPRINTDLG): WINBOOL{.stdcall, dynlib: "comdlg32",
    importc: "PrintDlgW".}
proc PageSetupDlgW*(para1: LPPAGESETUPDLG): WINBOOL{.stdcall,
    dynlib: "comdlg32", importc: "PageSetupDlgW".}
proc CreateProcessW*(lpApplicationName: LPCWSTR, lpCommandLine: LPWSTR,
                     lpProcessAttributes: LPSECURITY_ATTRIBUTES,
                     lpThreadAttributes: LPSECURITY_ATTRIBUTES,
                     bInheritHandles: WINBOOL, dwCreationFlags: DWORD,
                     lpEnvironment: LPVOID, lpCurrentDirectory: LPCWSTR,
                     lpStartupInfo: LPSTARTUPINFO,
                     lpProcessInformation: LPPROCESS_INFORMATION): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "CreateProcessW".}
proc GetStartupInfoW*(lpStartupInfo: LPSTARTUPINFO){.stdcall,
    dynlib: "kernel32", importc: "GetStartupInfoW".}
proc FindFirstFileW*(lpFileName: LPCWSTR, lpFindFileData: LPWIN32_FIND_DATAW): HANDLE{.
    stdcall, dynlib: "kernel32", importc: "FindFirstFileW".}
proc FindNextFileW*(hFindFile: HANDLE, lpFindFileData: LPWIN32_FIND_DATAW): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "FindNextFileW".}
proc GetVersionExW*(VersionInformation: LPOSVERSIONINFOW): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "GetVersionExW".}
proc CreateWindowW*(lpClassName: LPCWSTR, lpWindowName: LPCWSTR, dwStyle: DWORD,
                    X: int32, Y: int32, nWidth: int32, nHeight: int32,
                    hWndParent: HWND, menu: HMENU, hInstance: HINST,
                    lpParam: LPVOID): HWND
proc CreateDialogW*(hInstance: HINST, lpName: LPCWSTR, hWndParent: HWND,
                    lpDialogFunc: DLGPROC): HWND
proc CreateDialogIndirectW*(hInstance: HINST, lpTemplate: LPCDLGTEMPLATE,
                            hWndParent: HWND, lpDialogFunc: DLGPROC): HWND
proc DialogBoxW*(hInstance: HINST, lpTemplate: LPCWSTR, hWndParent: HWND,
                 lpDialogFunc: DLGPROC): int32
proc DialogBoxIndirectW*(hInstance: HINST, lpTemplate: LPCDLGTEMPLATE,
                         hWndParent: HWND, lpDialogFunc: DLGPROC): int32
proc CreateDCW*(para1: LPCWSTR, para2: LPCWSTR, para3: LPCWSTR, para4: pDEVMODEW): HDC{.
    stdcall, dynlib: "gdi32", importc: "CreateDCW".}
proc VerInstallFileW*(uFlags: DWORD, szSrcFileName: LPWSTR,
                      szDestFileName: LPWSTR, szSrcDir: LPWSTR,
                      szDestDir: LPWSTR, szCurDir: LPWSTR, szTmpFile: LPWSTR,
                      lpuTmpFileLen: PUINT): DWORD{.stdcall, dynlib: "version",
    importc: "VerInstallFileW".}
proc GetFileVersionInfoSizeW*(lptstrFilename: LPWSTR, lpdwHandle: LPDWORD): DWORD{.
    stdcall, dynlib: "version", importc: "GetFileVersionInfoSizeW".}
proc GetFileVersionInfoW*(lptstrFilename: LPWSTR, dwHandle: DWORD, dwLen: DWORD,
                          lpData: LPVOID): WINBOOL{.stdcall, dynlib: "version",
    importc: "GetFileVersionInfoW".}
proc VerLanguageNameW*(wLang: DWORD, szLang: LPWSTR, nSize: DWORD): DWORD{.
    stdcall, dynlib: "kernel32", importc: "VerLanguageNameW".}
proc VerQueryValueW*(pBlock: LPVOID, lpSubBlock: LPWSTR, lplpBuffer: LPVOID,
                     puLen: PUINT): WINBOOL{.stdcall, dynlib: "version",
    importc: "VerQueryValueW".}
proc VerFindFileW*(uFlags: DWORD, szFileName: LPWSTR, szWinDir: LPWSTR,
                   szAppDir: LPWSTR, szCurDir: LPWSTR, lpuCurDirLen: PUINT,
                   szDestDir: LPWSTR, lpuDestDirLen: PUINT): DWORD{.stdcall,
    dynlib: "version", importc: "VerFindFileW".}
proc RegSetValueExW*(key: HKEY, lpValueName: LPCWSTR, Reserved: DWORD,
                     dwType: DWORD, lpData: LPBYTE, cbData: DWORD): LONG{.
    stdcall, dynlib: "advapi32", importc: "RegSetValueExW".}
proc RegUnLoadKeyW*(key: HKEY, lpSubKey: LPCWSTR): LONG{.stdcall,
    dynlib: "advapi32", importc: "RegUnLoadKeyW".}
proc InitiateSystemShutdownW*(lpMachineName: LPWSTR, lpMessage: LPWSTR,
                              dwTimeout: DWORD, bForceAppsClosed: WINBOOL,
                              bRebootAfterShutdown: WINBOOL): WINBOOL{.stdcall,
    dynlib: "advapi32", importc: "InitiateSystemShutdownW".}
proc AbortSystemShutdownW*(lpMachineName: LPWSTR): WINBOOL{.stdcall,
    dynlib: "advapi32", importc: "AbortSystemShutdownW".}
proc RegRestoreKeyW*(key: HKEY, lpFile: LPCWSTR, dwFlags: DWORD): LONG{.
    stdcall, dynlib: "advapi32", importc: "RegRestoreKeyW".}
proc RegSaveKeyW*(key: HKEY, lpFile: LPCWSTR,
                  lpSecurityAttributes: LPSECURITY_ATTRIBUTES): LONG{.stdcall,
    dynlib: "advapi32", importc: "RegSaveKeyW".}
proc RegSetValueW*(key: HKEY, lpSubKey: LPCWSTR, dwType: DWORD,
                   lpData: LPCWSTR, cbData: DWORD): LONG{.stdcall,
    dynlib: "advapi32", importc: "RegSetValueW".}
proc RegQueryValueW*(key: HKEY, lpSubKey: LPCWSTR, lpValue: LPWSTR,
                     lpcbValue: PLONG): LONG{.stdcall, dynlib: "advapi32",
    importc: "RegQueryValueW".}
proc RegQueryMultipleValuesW*(key: HKEY, val_list: PVALENT, num_vals: DWORD,
                              lpValueBuf: LPWSTR, ldwTotsize: LPDWORD): LONG{.
    stdcall, dynlib: "advapi32", importc: "RegQueryMultipleValuesW".}
proc RegQueryValueExW*(key: HKEY, lpValueName: LPCWSTR, lpReserved: LPDWORD,
                       lpType: LPDWORD, lpData: LPBYTE, lpcbData: LPDWORD): LONG{.
    stdcall, dynlib: "advapi32", importc: "RegQueryValueExW".}
proc RegReplaceKeyW*(key: HKEY, lpSubKey: LPCWSTR, lpNewFile: LPCWSTR,
                     lpOldFile: LPCWSTR): LONG{.stdcall, dynlib: "advapi32",
    importc: "RegReplaceKeyW".}
proc RegConnectRegistryW*(lpMachineName: LPWSTR, key: HKEY, phkResult: PHKEY): LONG{.
    stdcall, dynlib: "advapi32", importc: "RegConnectRegistryW".}
proc RegCreateKeyW*(key: HKEY, lpSubKey: LPCWSTR, phkResult: PHKEY): LONG{.
    stdcall, dynlib: "advapi32", importc: "RegCreateKeyW".}
proc RegCreateKeyExW*(key: HKEY, lpSubKey: LPCWSTR, Reserved: DWORD,
                      lpClass: LPWSTR, dwOptions: DWORD, samDesired: REGSAM,
                      lpSecurityAttributes: LPSECURITY_ATTRIBUTES,
                      phkResult: PHKEY, lpdwDisposition: LPDWORD): LONG{.
    stdcall, dynlib: "advapi32", importc: "RegCreateKeyExW".}
proc RegDeleteKeyW*(key: HKEY, lpSubKey: LPCWSTR): LONG{.stdcall,
    dynlib: "advapi32", importc: "RegDeleteKeyW".}
proc RegDeleteValueW*(key: HKEY, lpValueName: LPCWSTR): LONG{.stdcall,
    dynlib: "advapi32", importc: "RegDeleteValueW".}
proc RegEnumKeyW*(key: HKEY, dwIndex: DWORD, lpName: LPWSTR, cbName: DWORD): LONG{.
    stdcall, dynlib: "advapi32", importc: "RegEnumKeyW".}
proc RegEnumKeyExW*(key: HKEY, dwIndex: DWORD, lpName: LPWSTR,
                    lpcbName: LPDWORD, lpReserved: LPDWORD, lpClass: LPWSTR,
                    lpcbClass: LPDWORD, lpftLastWriteTime: PFILETIME): LONG{.
    stdcall, dynlib: "advapi32", importc: "RegEnumKeyExW".}
proc RegEnumValueW*(key: HKEY, dwIndex: DWORD, lpValueName: LPWSTR,
                    lpcbValueName: LPDWORD, lpReserved: LPDWORD,
                    lpType: LPDWORD, lpData: LPBYTE, lpcbData: LPDWORD): LONG{.
    stdcall, dynlib: "advapi32", importc: "RegEnumValueW".}
proc RegLoadKeyW*(key: HKEY, lpSubKey: LPCWSTR, lpFile: LPCWSTR): LONG{.
    stdcall, dynlib: "advapi32", importc: "RegLoadKeyW".}
proc RegOpenKeyW*(key: HKEY, lpSubKey: LPCWSTR, phkResult: PHKEY): LONG{.
    stdcall, dynlib: "advapi32", importc: "RegOpenKeyW".}
proc RegOpenKeyExW*(key: HKEY, lpSubKey: LPCWSTR, ulOptions: DWORD,
                    samDesired: REGSAM, phkResult: PHKEY): LONG{.stdcall,
    dynlib: "advapi32", importc: "RegOpenKeyExW".}
proc RegQueryInfoKeyW*(key: HKEY, lpClass: LPWSTR, lpcbClass: LPDWORD,
                       lpReserved: LPDWORD, lpcSubKeys: LPDWORD,
                       lpcbMaxSubKeyLen: LPDWORD, lpcbMaxClassLen: LPDWORD,
                       lpcValues: LPDWORD, lpcbMaxValueNameLen: LPDWORD,
                       lpcbMaxValueLen: LPDWORD,
                       lpcbSecurityDescriptor: LPDWORD,
                       lpftLastWriteTime: PFILETIME): LONG{.stdcall,
    dynlib: "advapi32", importc: "RegQueryInfoKeyW".}
proc CompareStringW*(Locale: LCID, dwCmpFlags: DWORD, lpString1: LPCWSTR,
                     cchCount1: int32, lpString2: LPCWSTR, cchCount2: int32): int32{.
    stdcall, dynlib: "kernel32", importc: "CompareStringW".}
proc LCMapStringW*(Locale: LCID, dwMapFlags: DWORD, lpSrcStr: LPCWSTR,
                   cchSrc: int32, lpDestStr: LPWSTR, cchDest: int32): int32{.
    stdcall, dynlib: "kernel32", importc: "LCMapStringW".}
proc GetLocaleInfoW*(Locale: LCID, LCType: LCTYPE, lpLCData: LPWSTR,
                     cchData: int32): int32{.stdcall, dynlib: "kernel32",
    importc: "GetLocaleInfoW".}
proc SetLocaleInfoW*(Locale: LCID, LCType: LCTYPE, lpLCData: LPCWSTR): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "SetLocaleInfoW".}
proc GetTimeFormatW*(Locale: LCID, dwFlags: DWORD, lpTime: LPSYSTEMTIME,
                     lpFormat: LPCWSTR, lpTimeStr: LPWSTR, cchTime: int32): int32{.
    stdcall, dynlib: "kernel32", importc: "GetTimeFormatW".}
proc GetDateFormatW*(Locale: LCID, dwFlags: DWORD, lpDate: LPSYSTEMTIME,
                     lpFormat: LPCWSTR, lpDateStr: LPWSTR, cchDate: int32): int32{.
    stdcall, dynlib: "kernel32", importc: "GetDateFormatW".}
proc GetNumberFormatW*(Locale: LCID, dwFlags: DWORD, lpValue: LPCWSTR,
                       lpFormat: PNUMBERFMT, lpNumberStr: LPWSTR,
                       cchNumber: int32): int32{.stdcall, dynlib: "kernel32",
    importc: "GetNumberFormatW".}
proc GetCurrencyFormatW*(Locale: LCID, dwFlags: DWORD, lpValue: LPCWSTR,
                         lpFormat: PCURRENCYFMT, lpCurrencyStr: LPWSTR,
                         cchCurrency: int32): int32{.stdcall,
    dynlib: "kernel32", importc: "GetCurrencyFormatW".}
proc EnumCalendarInfoW*(lpCalInfoEnumProc: CALINFO_ENUMPROC, Locale: LCID,
                        Calendar: CALID, CalType: CALTYPE): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "EnumCalendarInfoW".}
proc EnumTimeFormatsW*(lpTimeFmtEnumProc: TIMEFMT_ENUMPROC, Locale: LCID,
                       dwFlags: DWORD): WINBOOL{.stdcall, dynlib: "kernel32",
    importc: "EnumTimeFormatsW".}
proc EnumDateFormatsW*(lpDateFmtEnumProc: DATEFMT_ENUMPROC, Locale: LCID,
                       dwFlags: DWORD): WINBOOL{.stdcall, dynlib: "kernel32",
    importc: "EnumDateFormatsW".}
proc GetStringTypeExW*(Locale: LCID, dwInfoType: DWORD, lpSrcStr: LPCWSTR,
                       cchSrc: int32, lpCharType: LPWORD): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "GetStringTypeExW".}
proc GetStringTypeW*(dwInfoType: DWORD, lpSrcStr: LPCWSTR, cchSrc: int32,
                     lpCharType: LPWORD): WINBOOL{.stdcall, dynlib: "kernel32",
    importc: "GetStringTypeW".}
proc FoldStringW*(dwMapFlags: DWORD, lpSrcStr: LPCWSTR, cchSrc: int32,
                  lpDestStr: LPWSTR, cchDest: int32): int32{.stdcall,
    dynlib: "kernel32", importc: "FoldStringW".}
proc EnumSystemLocalesW*(lpLocaleEnumProc: LOCALE_ENUMPROC, dwFlags: DWORD): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "EnumSystemLocalesW".}
proc EnumSystemCodePagesW*(lpCodePageEnumProc: CODEPAGE_ENUMPROC, dwFlags: DWORD): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "EnumSystemCodePagesW".}
proc PeekConsoleInputW*(hConsoleInput: HANDLE, lpBuffer: PINPUTRECORD,
                        nLength: DWORD, lpNumberOfEventsRead: LPDWORD): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "PeekConsoleInputW".}
proc ReadConsoleInputW*(hConsoleInput: HANDLE, lpBuffer: PINPUTRECORD,
                        nLength: DWORD, lpNumberOfEventsRead: LPDWORD): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "ReadConsoleInputW".}
proc WriteConsoleInputW*(hConsoleInput: HANDLE, lpBuffer: PINPUTRECORD,
                         nLength: DWORD, lpNumberOfEventsWritten: LPDWORD): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "WriteConsoleInputW".}
proc ReadConsoleOutputW*(hConsoleOutput: HANDLE, lpBuffer: PCHAR_INFO,
                         dwBufferSize: COORD, dwBufferCoord: COORD,
                         lpReadRegion: PSMALL_RECT): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "ReadConsoleOutputW".}
proc WriteConsoleOutputW*(hConsoleOutput: HANDLE, lpBuffer: PCHAR_INFO,
                          dwBufferSize: COORD, dwBufferCoord: COORD,
                          lpWriteRegion: PSMALL_RECT): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "WriteConsoleOutputW".}
proc ReadConsoleOutputCharacterW*(hConsoleOutput: HANDLE, lpCharacter: LPWSTR,
                                  nLength: DWORD, dwReadCoord: COORD,
                                  lpNumberOfCharsRead: LPDWORD): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "ReadConsoleOutputCharacterW".}
proc WriteConsoleOutputCharacterW*(hConsoleOutput: HANDLE, lpCharacter: LPCWSTR,
                                   nLength: DWORD, dwWriteCoord: COORD,
                                   lpNumberOfCharsWritten: LPDWORD): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "WriteConsoleOutputCharacterW".}
proc FillConsoleOutputCharacterW*(hConsoleOutput: HANDLE, cCharacter: WCHAR,
                                  nLength: DWORD, dwWriteCoord: COORD,
                                  lpNumberOfCharsWritten: LPDWORD): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "FillConsoleOutputCharacterW".}
proc ScrollConsoleScreenBufferW*(hConsoleOutput: HANDLE,
                                 lpScrollRectangle: PSMALL_RECT,
                                 lpClipRectangle: PSMALL_RECT,
                                 dwDestinationOrigin: COORD, lpFill: PCHAR_INFO): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "ScrollConsoleScreenBufferW".}
proc GetConsoleTitleW*(lpConsoleTitle: LPWSTR, nSize: DWORD): DWORD{.stdcall,
    dynlib: "kernel32", importc: "GetConsoleTitleW".}
proc SetConsoleTitleW*(lpConsoleTitle: LPCWSTR): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "SetConsoleTitleW".}
proc ReadConsoleW*(hConsoleInput: HANDLE, lpBuffer: LPVOID,
                   nNumberOfCharsToRead: DWORD, lpNumberOfCharsRead: LPDWORD,
                   lpReserved: LPVOID): WINBOOL{.stdcall, dynlib: "kernel32",
    importc: "ReadConsoleW".}
proc WriteConsoleW*(hConsoleOutput: HANDLE, lpBuffer: pointer,
                    nNumberOfCharsToWrite: DWORD,
                    lpNumberOfCharsWritten: LPDWORD, lpReserved: LPVOID): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "WriteConsoleW".}
proc WNetAddConnectionW*(lpRemoteName: LPCWSTR, lpPassword: LPCWSTR,
                         lpLocalName: LPCWSTR): DWORD{.stdcall, dynlib: "mpr",
    importc: "WNetAddConnectionW".}
proc WNetAddConnection2W*(lpNetResource: LPNETRESOURCE, lpPassword: LPCWSTR,
                          lpUserName: LPCWSTR, dwFlags: DWORD): DWORD{.stdcall,
    dynlib: "mpr", importc: "WNetAddConnection2W".}
proc WNetAddConnection3W*(hwndOwner: HWND, lpNetResource: LPNETRESOURCE,
                          lpPassword: LPCWSTR, lpUserName: LPCWSTR,
                          dwFlags: DWORD): DWORD{.stdcall, dynlib: "mpr",
    importc: "WNetAddConnection3W".}
proc WNetCancelConnectionW*(lpName: LPCWSTR, fForce: WINBOOL): DWORD{.stdcall,
    dynlib: "mpr", importc: "WNetCancelConnectionW".}
proc WNetCancelConnection2W*(lpName: LPCWSTR, dwFlags: DWORD, fForce: WINBOOL): DWORD{.
    stdcall, dynlib: "mpr", importc: "WNetCancelConnection2W".}
proc WNetGetConnectionW*(lpLocalName: LPCWSTR, lpRemoteName: LPWSTR,
                         lpnLength: LPDWORD): DWORD{.stdcall, dynlib: "mpr",
    importc: "WNetGetConnectionW".}
proc WNetUseConnectionW*(hwndOwner: HWND, lpNetResource: LPNETRESOURCE,
                         lpUserID: LPCWSTR, lpPassword: LPCWSTR, dwFlags: DWORD,
                         lpAccessName: LPWSTR, lpBufferSize: LPDWORD,
                         lpResult: LPDWORD): DWORD{.stdcall, dynlib: "mpr",
    importc: "WNetUseConnectionW".}
proc WNetSetConnectionW*(lpName: LPCWSTR, dwProperties: DWORD, pvValues: LPVOID): DWORD{.
    stdcall, dynlib: "mpr", importc: "WNetSetConnectionW".}
proc WNetConnectionDialog1W*(lpConnDlgStruct: LPCONNECTDLGSTRUCT): DWORD{.
    stdcall, dynlib: "mpr", importc: "WNetConnectionDialog1W".}
proc WNetDisconnectDialog1W*(lpConnDlgStruct: LPDISCDLGSTRUCT): DWORD{.stdcall,
    dynlib: "mpr", importc: "WNetDisconnectDialog1W".}
proc WNetOpenEnumW*(dwScope: DWORD, dwType: DWORD, dwUsage: DWORD,
                    lpNetResource: LPNETRESOURCE, lphEnum: LPHANDLE): DWORD{.
    stdcall, dynlib: "mpr", importc: "WNetOpenEnumW".}
proc WNetEnumResourceW*(hEnum: HANDLE, lpcCount: LPDWORD, lpBuffer: LPVOID,
                        lpBufferSize: LPDWORD): DWORD{.stdcall, dynlib: "mpr",
    importc: "WNetEnumResourceW".}
proc WNetGetUniversalNameW*(lpLocalPath: LPCWSTR, dwInfoLevel: DWORD,
                            lpBuffer: LPVOID, lpBufferSize: LPDWORD): DWORD{.
    stdcall, dynlib: "mpr", importc: "WNetGetUniversalNameW".}
proc WNetGetUserW*(lpName: LPCWSTR, lpUserName: LPWSTR, lpnLength: LPDWORD): DWORD{.
    stdcall, dynlib: "mpr", importc: "WNetGetUserW".}
proc WNetGetProviderNameW*(dwNetType: DWORD, lpProviderName: LPWSTR,
                           lpBufferSize: LPDWORD): DWORD{.stdcall,
    dynlib: "mpr", importc: "WNetGetProviderNameW".}
proc WNetGetNetworkInformationW*(lpProvider: LPCWSTR,
                                 lpNetInfoStruct: LPNETINFOSTRUCT): DWORD{.
    stdcall, dynlib: "mpr", importc: "WNetGetNetworkInformationW".}
proc WNetGetLastErrorW*(lpError: LPDWORD, lpErrorBuf: LPWSTR,
                        nErrorBufSize: DWORD, lpNameBuf: LPWSTR,
                        nNameBufSize: DWORD): DWORD{.stdcall, dynlib: "mpr",
    importc: "WNetGetLastErrorW".}
proc MultinetGetConnectionPerformanceW*(lpNetResource: LPNETRESOURCE,
    lpNetConnectInfoStruct: LPNETCONNECTINFOSTRUCT): DWORD{.stdcall,
    dynlib: "mpr", importc: "MultinetGetConnectionPerformanceW".}
proc ChangeServiceConfigW*(hService: SC_HANDLE, dwServiceType: DWORD,
                           dwStartType: DWORD, dwErrorControl: DWORD,
                           lpBinaryPathName: LPCWSTR, lpLoadOrderGroup: LPCWSTR,
                           lpdwTagId: LPDWORD, lpDependencies: LPCWSTR,
                           lpServiceStartName: LPCWSTR, lpPassword: LPCWSTR,
                           lpDisplayName: LPCWSTR): WINBOOL{.stdcall,
    dynlib: "advapi32", importc: "ChangeServiceConfigW".}
proc CreateServiceW*(hSCManager: SC_HANDLE, lpServiceName: LPCWSTR,
                     lpDisplayName: LPCWSTR, dwDesiredAccess: DWORD,
                     dwServiceType: DWORD, dwStartType: DWORD,
                     dwErrorControl: DWORD, lpBinaryPathName: LPCWSTR,
                     lpLoadOrderGroup: LPCWSTR, lpdwTagId: LPDWORD,
                     lpDependencies: LPCWSTR, lpServiceStartName: LPCWSTR,
                     lpPassword: LPCWSTR): SC_HANDLE{.stdcall,
    dynlib: "advapi32", importc: "CreateServiceW".}
proc EnumDependentServicesW*(hService: SC_HANDLE, dwServiceState: DWORD,
                             lpServices: LPENUM_SERVICE_STATUS,
                             cbBufSize: DWORD, pcbBytesNeeded: LPDWORD,
                             lpServicesReturned: LPDWORD): WINBOOL{.stdcall,
    dynlib: "advapi32", importc: "EnumDependentServicesW".}
proc EnumServicesStatusW*(hSCManager: SC_HANDLE, dwServiceType: DWORD,
                          dwServiceState: DWORD,
                          lpServices: LPENUM_SERVICE_STATUS, cbBufSize: DWORD,
                          pcbBytesNeeded: LPDWORD, lpServicesReturned: LPDWORD,
                          lpResumeHandle: LPDWORD): WINBOOL{.stdcall,
    dynlib: "advapi32", importc: "EnumServicesStatusW".}
proc GetServiceKeyNameW*(hSCManager: SC_HANDLE, lpDisplayName: LPCWSTR,
                         lpServiceName: LPWSTR, lpcchBuffer: LPDWORD): WINBOOL{.
    stdcall, dynlib: "advapi32", importc: "GetServiceKeyNameW".}
proc GetServiceDisplayNameW*(hSCManager: SC_HANDLE, lpServiceName: LPCWSTR,
                             lpDisplayName: LPWSTR, lpcchBuffer: LPDWORD): WINBOOL{.
    stdcall, dynlib: "advapi32", importc: "GetServiceDisplayNameW".}
proc OpenSCManagerW*(lpMachineName: LPCWSTR, lpDatabaseName: LPCWSTR,
                     dwDesiredAccess: DWORD): SC_HANDLE{.stdcall,
    dynlib: "advapi32", importc: "OpenSCManagerW".}
proc OpenServiceW*(hSCManager: SC_HANDLE, lpServiceName: LPCWSTR,
                   dwDesiredAccess: DWORD): SC_HANDLE{.stdcall,
    dynlib: "advapi32", importc: "OpenServiceW".}
proc QueryServiceConfigW*(hService: SC_HANDLE,
                          lpServiceConfig: LPQUERY_SERVICE_CONFIG,
                          cbBufSize: DWORD, pcbBytesNeeded: LPDWORD): WINBOOL{.
    stdcall, dynlib: "advapi32", importc: "QueryServiceConfigW".}
proc QueryServiceLockStatusW*(hSCManager: SC_HANDLE,
                              lpLockStatus: LPQUERY_SERVICE_LOCK_STATUS,
                              cbBufSize: DWORD, pcbBytesNeeded: LPDWORD): WINBOOL{.
    stdcall, dynlib: "advapi32", importc: "QueryServiceLockStatusW".}
proc RegisterServiceCtrlHandlerW*(lpServiceName: LPCWSTR,
                                  lpHandlerProc: LPHANDLER_FUNCTION): SERVICE_STATUS_HANDLE{.
    stdcall, dynlib: "advapi32", importc: "RegisterServiceCtrlHandlerW".}
proc StartServiceCtrlDispatcherW*(lpServiceStartTable: LPSERVICE_TABLE_ENTRY): WINBOOL{.
    stdcall, dynlib: "advapi32", importc: "StartServiceCtrlDispatcherW".}
proc StartServiceW*(hService: SC_HANDLE, dwNumServiceArgs: DWORD,
                    lpServiceArgVectors: LPCWSTR): WINBOOL{.stdcall,
    dynlib: "advapi32", importc: "StartServiceW".}
proc DragQueryFileW*(para1: HDROP, para2: int, para3: LPCWSTR, para4: int): int{.
    stdcall, dynlib: "shell32", importc: "DragQueryFileW".}
proc ExtractAssociatedIconW*(para1: HINST, para2: LPCWSTR, para3: LPWORD): HICON{.
    stdcall, dynlib: "shell32", importc: "ExtractAssociatedIconW".}
proc ExtractIconW*(para1: HINST, para2: LPCWSTR, para3: int): HICON{.stdcall,
    dynlib: "shell32", importc: "ExtractIconW".}
proc FindExecutableW*(para1: LPCWSTR, para2: LPCWSTR, para3: LPCWSTR): HINST{.
    stdcall, dynlib: "shell32", importc: "FindExecutableW".}
proc ShellAboutW*(para1: HWND, para2: LPCWSTR, para3: LPCWSTR, para4: HICON): int32{.
    stdcall, dynlib: "shell32", importc: "ShellAboutW".}
proc ShellExecuteW*(para1: HWND, para2: LPCWSTR, para3: LPCWSTR, para4: LPCWSTR,
                    para5: LPCWSTR, para6: int32): HINST{.stdcall,
    dynlib: "shell32", importc: "ShellExecuteW".}
proc Shell_NotifyIconW*(dwMessage: DWORD, lpData: PNotifyIconDataA): WINBOOL{.
    stdcall, dynlib: "shell32", importc: "Shell_NotifyIconW".}
proc DdeCreateStringHandleW*(para1: DWORD, para2: LPCWSTR, para3: int32): HSZ{.
    stdcall, dynlib: "user32", importc: "DdeCreateStringHandleW".}
proc DdeInitializeW*(para1: LPDWORD, para2: PFNCALLBACK, para3: DWORD,
                     para4: DWORD): UINT{.stdcall, dynlib: "user32",
    importc: "DdeInitializeW".}
proc DdeQueryStringW*(para1: DWORD, para2: HSZ, para3: LPCWSTR, para4: DWORD,
                      para5: int32): DWORD{.stdcall, dynlib: "user32",
    importc: "DdeQueryStringW".}
proc LogonUserW*(para1: LPWSTR, para2: LPWSTR, para3: LPWSTR, para4: DWORD,
                 para5: DWORD, para6: PHANDLE): WINBOOL{.stdcall,
    dynlib: "advapi32", importc: "LogonUserW".}
proc CreateProcessAsUserW*(para1: HANDLE, para2: LPCWSTR, para3: LPWSTR,
                           para4: LPSECURITY_ATTRIBUTES,
                           para5: LPSECURITY_ATTRIBUTES, para6: WINBOOL,
                           para7: DWORD, para8: LPVOID, para9: LPCWSTR,
                           para10: LPSTARTUPINFO, para11: LPPROCESS_INFORMATION): WINBOOL{.
    stdcall, dynlib: "advapi32", importc: "CreateProcessAsUserW".}
when defined(winUnicode):
  proc GetBinaryType*(lpApplicationName: LPCWSTR, lpBinaryType: LPDWORD): WINBOOL{.
      stdcall, dynlib: "kernel32", importc: "GetBinaryTypeW".}
  proc GetShortPathName*(lpszLongPath: LPCWSTR, lpszShortPath: LPWSTR,
                         cchBuffer: DWORD): DWORD{.stdcall, dynlib: "kernel32",
      importc: "GetShortPathNameW".}
  proc GetEnvironmentStrings*(): LPWSTR{.stdcall, dynlib: "kernel32",
      importc: "GetEnvironmentStringsW".}
  proc FreeEnvironmentStrings*(para1: LPWSTR): WINBOOL{.stdcall,

      dynlib: "kernel32", importc: "FreeEnvironmentStringsW".}
  proc FormatMessage*(dwFlags: DWORD, lpSource: LPCVOID, dwMessageId: DWORD,
                      dwLanguageId: DWORD, lpBuffer: LPWSTR, nSize: DWORD,
                      Arguments: va_list): DWORD{.stdcall, dynlib: "kernel32",
      importc: "FormatMessageW".}
  proc CreateMailslot*(lpName: LPCWSTR, nMaxMessageSize: DWORD,
                       lReadTimeout: DWORD,
                       lpSecurityAttributes: LPSECURITY_ATTRIBUTES): HANDLE{.
      stdcall, dynlib: "kernel32", importc: "CreateMailslotW".}
  proc lstrcmp*(lpString1: LPCWSTR, lpString2: LPCWSTR): int32{.stdcall,
      dynlib: "kernel32", importc: "lstrcmpW".}
  proc lstrcmpi*(lpString1: LPCWSTR, lpString2: LPCWSTR): int32{.stdcall,
      dynlib: "kernel32", importc: "lstrcmpiW".}
  proc lstrcpyn*(lpString1: LPWSTR, lpString2: LPCWSTR, iMaxLength: int32): LPWSTR{.
      stdcall, dynlib: "kernel32", importc: "lstrcpynW".}
  proc lstrcpy*(lpString1: LPWSTR, lpString2: LPCWSTR): LPWSTR{.stdcall,
      dynlib: "kernel32", importc: "lstrcpyW".}
  proc lstrcat*(lpString1: LPWSTR, lpString2: LPCWSTR): LPWSTR{.stdcall,
      dynlib: "kernel32", importc: "lstrcatW".}
  proc lstrlen*(lpString: LPCWSTR): int32{.stdcall, dynlib: "kernel32",
      importc: "lstrlenW".}
  proc CreateMutex*(lpMutexAttributes: LPSECURITY_ATTRIBUTES,
                    bInitialOwner: WINBOOL, lpName: LPCWSTR): HANDLE{.stdcall,
      dynlib: "kernel32", importc: "CreateMutexW".}
  proc OpenMutex*(dwDesiredAccess: DWORD, bInheritHandle: WINBOOL,
                  lpName: LPCWSTR): HANDLE{.stdcall, dynlib: "kernel32",
      importc: "OpenMutexW".}
  proc CreateEvent*(lpEventAttributes: LPSECURITY_ATTRIBUTES,
                    bManualReset: WINBOOL, bInitialState: WINBOOL,
                    lpName: LPCWSTR): HANDLE{.stdcall, dynlib: "kernel32",
      importc: "CreateEventW".}
  proc OpenEvent*(dwDesiredAccess: DWORD, bInheritHandle: WINBOOL,
                  lpName: LPCWSTR): HANDLE{.stdcall, dynlib: "kernel32",
      importc: "OpenEventW".}
  proc CreateSemaphore*(lpSemaphoreAttributes: LPSECURITY_ATTRIBUTES,
                        lInitialCount: LONG, lMaximumCount: LONG,
                        lpName: LPCWSTR): HANDLE{.stdcall, dynlib: "kernel32",
      importc: "CreateSemaphoreW".}
  proc OpenSemaphore*(dwDesiredAccess: DWORD, bInheritHandle: WINBOOL,
                      lpName: LPCWSTR): HANDLE{.stdcall, dynlib: "kernel32",
      importc: "OpenSemaphoreW".}
  proc CreateFileMapping*(hFile: HANDLE,
                          lpFileMappingAttributes: LPSECURITY_ATTRIBUTES,
                          flProtect: DWORD, dwMaximumSizeHigh: DWORD,
                          dwMaximumSizeLow: DWORD, lpName: LPCWSTR): HANDLE{.
      stdcall, dynlib: "kernel32", importc: "CreateFileMappingW".}
  proc OpenFileMapping*(dwDesiredAccess: DWORD, bInheritHandle: WINBOOL,
                        lpName: LPCWSTR): HANDLE{.stdcall, dynlib: "kernel32",
      importc: "OpenFileMappingW".}
  proc GetLogicalDriveStrings*(nBufferLength: DWORD, lpBuffer: LPWSTR): DWORD{.
      stdcall, dynlib: "kernel32", importc: "GetLogicalDriveStringsW".}
  proc LoadLibrary*(lpLibFileName: LPCWSTR): HINST{.stdcall, dynlib: "kernel32",
      importc: "LoadLibraryW".}
  proc LoadLibraryEx*(lpLibFileName: LPCWSTR, hFile: HANDLE, dwFlags: DWORD): HINST{.
      stdcall, dynlib: "kernel32", importc: "LoadLibraryExW".}
  proc GetModuleFileName*(hModule: HINST, lpFilename: LPWSTR, nSize: DWORD): DWORD{.
      stdcall, dynlib: "kernel32", importc: "GetModuleFileNameW".}
  proc GetModuleHandle*(lpModuleName: LPCWSTR): HMODULE{.stdcall,
      dynlib: "kernel32", importc: "GetModuleHandleW".}
  proc FatalAppExit*(uAction: UINT, lpMessageText: LPCWSTR){.stdcall,
      dynlib: "kernel32", importc: "FatalAppExitW".}
  proc GetCommandLine*(): LPWSTR{.stdcall, dynlib: "kernel32",
                                  importc: "GetCommandLineW".}
  proc GetEnvironmentVariable*(lpName: LPCWSTR, lpBuffer: LPWSTR, nSize: DWORD): DWORD{.
      stdcall, dynlib: "kernel32", importc: "GetEnvironmentVariableW".}
  proc SetEnvironmentVariable*(lpName: LPCWSTR, lpValue: LPCWSTR): WINBOOL{.
      stdcall, dynlib: "kernel32", importc: "SetEnvironmentVariableW".}
  proc ExpandEnvironmentStrings*(lpSrc: LPCWSTR, lpDst: LPWSTR, nSize: DWORD): DWORD{.
      stdcall, dynlib: "kernel32", importc: "ExpandEnvironmentStringsW".}
  proc OutputDebugString*(lpOutputString: LPCWSTR){.stdcall, dynlib: "kernel32",
      importc: "OutputDebugStringW".}
  proc FindResource*(hModule: HINST, lpName: LPCWSTR, lpType: LPCWSTR): HRSRC{.
      stdcall, dynlib: "kernel32", importc: "FindResourceW".}
  proc FindResourceEx*(hModule: HINST, lpType: LPCWSTR, lpName: LPCWSTR,
                       wLanguage: int16): HRSRC{.stdcall, dynlib: "kernel32",
      importc: "FindResourceExW".}
  proc EnumResourceTypes*(hModule: HINST, lpEnumFunc: ENUMRESTYPEPROC,
                          lParam: LONG): WINBOOL{.stdcall, dynlib: "kernel32",
      importc: "EnumResourceTypesW".}
  proc EnumResourceNames*(hModule: HINST, lpType: LPCWSTR,
                          lpEnumFunc: ENUMRESNAMEPROC, lParam: LONG): WINBOOL{.
      stdcall, dynlib: "kernel32", importc: "EnumResourceNamesW".}
  proc EnumResourceLanguages*(hModule: HINST, lpType: LPCWSTR, lpName: LPCWSTR,
                              lpEnumFunc: ENUMRESLANGPROC, lParam: LONG): WINBOOL{.
      stdcall, dynlib: "kernel32", importc: "EnumResourceLanguagesW".}
  proc BeginUpdateResource*(pFileName: LPCWSTR,
                            bDeleteExistingResources: WINBOOL): HANDLE{.stdcall,
      dynlib: "kernel32", importc: "BeginUpdateResourceW".}
  proc UpdateResource*(hUpdate: HANDLE, lpType: LPCWSTR, lpName: LPCWSTR,
                       wLanguage: int16, lpData: LPVOID, cbData: DWORD): WINBOOL{.
      stdcall, dynlib: "kernel32", importc: "UpdateResourceW".}
  proc EndUpdateResource*(hUpdate: HANDLE, fDiscard: WINBOOL): WINBOOL{.stdcall,
      dynlib: "kernel32", importc: "EndUpdateResourceW".}
  proc GlobalAddAtom*(lpString: LPCWSTR): ATOM{.stdcall, dynlib: "kernel32",
      importc: "GlobalAddAtomW".}
  proc GlobalFindAtom*(lpString: LPCWSTR): ATOM{.stdcall, dynlib: "kernel32",
      importc: "GlobalFindAtomW".}
  proc GlobalGetAtomName*(nAtom: ATOM, lpBuffer: LPWSTR, nSize: int32): UINT{.
      stdcall, dynlib: "kernel32", importc: "GlobalGetAtomNameW".}
  proc AddAtom*(lpString: LPCWSTR): ATOM{.stdcall, dynlib: "kernel32",
      importc: "AddAtomW".}
  proc FindAtom*(lpString: LPCWSTR): ATOM{.stdcall, dynlib: "kernel32",
      importc: "FindAtomW".}
  proc GetAtomName*(nAtom: ATOM, lpBuffer: LPWSTR, nSize: int32): UINT{.stdcall,
      dynlib: "kernel32", importc: "GetAtomNameW".}
  proc GetProfileInt*(lpAppName: LPCWSTR, lpKeyName: LPCWSTR, nDefault: WINT): UINT{.
      stdcall, dynlib: "kernel32", importc: "GetProfileIntW".}
  proc GetProfileString*(lpAppName: LPCWSTR, lpKeyName: LPCWSTR,
                         lpDefault: LPCWSTR, lpReturnedString: LPWSTR,
                         nSize: DWORD): DWORD{.stdcall, dynlib: "kernel32",
      importc: "GetProfileStringW".}
  proc WriteProfileString*(lpAppName: LPCWSTR, lpKeyName: LPCWSTR,
                           lpString: LPCWSTR): WINBOOL{.stdcall,
      dynlib: "kernel32", importc: "WriteProfileStringW".}
  proc GetProfileSection*(lpAppName: LPCWSTR, lpReturnedString: LPWSTR,
                          nSize: DWORD): DWORD{.stdcall, dynlib: "kernel32",
      importc: "GetProfileSectionW".}
  proc WriteProfileSection*(lpAppName: LPCWSTR, lpString: LPCWSTR): WINBOOL{.
      stdcall, dynlib: "kernel32", importc: "WriteProfileSectionW".}
  proc GetPrivateProfileInt*(lpAppName: LPCWSTR, lpKeyName: LPCWSTR,
                             nDefault: WINT, lpFileName: LPCWSTR): UINT{.
      stdcall, dynlib: "kernel32", importc: "GetPrivateProfileIntW".}
  proc GetPrivateProfileString*(lpAppName: LPCWSTR, lpKeyName: LPCWSTR,
                                lpDefault: LPCWSTR, lpReturnedString: LPWSTR,
                                nSize: DWORD, lpFileName: LPCWSTR): DWORD{.
      stdcall, dynlib: "kernel32", importc: "GetPrivateProfileStringW".}
  proc WritePrivateProfileString*(lpAppName: LPCWSTR, lpKeyName: LPCWSTR,
                                  lpString: LPCWSTR, lpFileName: LPCWSTR): WINBOOL{.
      stdcall, dynlib: "kernel32", importc: "WritePrivateProfileStringW".}
  proc GetPrivateProfileSection*(lpAppName: LPCWSTR, lpReturnedString: LPWSTR,
                                 nSize: DWORD, lpFileName: LPCWSTR): DWORD{.
      stdcall, dynlib: "kernel32", importc: "GetPrivateProfileSectionW".}
  proc WritePrivateProfileSection*(lpAppName: LPCWSTR, lpString: LPCWSTR,
                                   lpFileName: LPCWSTR): WINBOOL{.stdcall,
      dynlib: "kernel32", importc: "WritePrivateProfileSectionW".}
  proc GetDriveType*(lpRootPathName: LPCWSTR): UINT{.stdcall,
      dynlib: "kernel32", importc: "GetDriveTypeW".}
  proc GetSystemDirectory*(lpBuffer: LPWSTR, uSize: UINT): UINT{.stdcall,
      dynlib: "kernel32", importc: "GetSystemDirectoryW".}
  proc GetTempPath*(nBufferLength: DWORD, lpBuffer: LPWSTR): DWORD{.stdcall,
      dynlib: "kernel32", importc: "GetTempPathW".}
  proc GetTempFileName*(lpPathName: LPCWSTR, lpPrefixString: LPCWSTR,
                        uUnique: UINT, lpTempFileName: LPWSTR): UINT{.stdcall,
      dynlib: "kernel32", importc: "GetTempFileNameW".}
  proc GetWindowsDirectory*(lpBuffer: LPWSTR, uSize: UINT): UINT{.stdcall,
      dynlib: "kernel32", importc: "GetWindowsDirectoryW".}
  proc SetCurrentDirectory*(lpPathName: LPCWSTR): WINBOOL{.stdcall,
      dynlib: "kernel32", importc: "SetCurrentDirectoryW".}
  proc GetCurrentDirectory*(nBufferLength: DWORD, lpBuffer: LPWSTR): DWORD{.
      stdcall, dynlib: "kernel32", importc: "GetCurrentDirectoryW".}
  proc GetDiskFreeSpace*(lpRootPathName: LPCWSTR, lpSectorsPerCluster: LPDWORD,
                         lpBytesPerSector: LPDWORD,
                         lpNumberOfFreeClusters: LPDWORD,
                         lpTotalNumberOfClusters: LPDWORD): WINBOOL{.stdcall,
      dynlib: "kernel32", importc: "GetDiskFreeSpaceW".}
  proc CreateDirectory*(lpPathName: LPCWSTR,
                        lpSecurityAttributes: LPSECURITY_ATTRIBUTES): WINBOOL{.
      stdcall, dynlib: "kernel32", importc: "CreateDirectoryW".}
  proc CreateDirectoryEx*(lpTemplateDirectory: LPCWSTR, lpNewDirectory: LPCWSTR,
                          lpSecurityAttributes: LPSECURITY_ATTRIBUTES): WINBOOL{.
      stdcall, dynlib: "kernel32", importc: "CreateDirectoryExW".}
  proc RemoveDirectory*(lpPathName: LPCWSTR): WINBOOL{.stdcall,
      dynlib: "kernel32", importc: "RemoveDirectoryW".}
  proc GetFullPathName*(lpFileName: LPCWSTR, nBufferLength: DWORD,
                        lpBuffer: LPWSTR, lpFilePart: var LPWSTR): DWORD{.
      stdcall, dynlib: "kernel32", importc: "GetFullPathNameW".}
  proc DefineDosDevice*(dwFlags: DWORD, lpDeviceName: LPCWSTR,
                        lpTargetPath: LPCWSTR): WINBOOL{.stdcall,
      dynlib: "kernel32", importc: "DefineDosDeviceW".}
  proc QueryDosDevice*(lpDeviceName: LPCWSTR, lpTargetPath: LPWSTR,
                       ucchMax: DWORD): DWORD{.stdcall, dynlib: "kernel32",
      importc: "QueryDosDeviceW".}
  proc CreateFile*(lpFileName: LPCWSTR, dwDesiredAccess: DWORD,
                   dwShareMode: DWORD,
                   lpSecurityAttributes: LPSECURITY_ATTRIBUTES,
                   dwCreationDisposition: DWORD, dwFlagsAndAttributes: DWORD,
                   hTemplateFile: HANDLE): HANDLE{.stdcall, dynlib: "kernel32",
      importc: "CreateFileW".}
  proc SetFileAttributes*(lpFileName: LPCWSTR, dwFileAttributes: DWORD): WINBOOL{.
      stdcall, dynlib: "kernel32", importc: "SetFileAttributesW".}
  proc GetFileAttributes*(lpFileName: LPCWSTR): DWORD{.stdcall,
      dynlib: "kernel32", importc: "GetFileAttributesW".}
  proc GetCompressedFileSize*(lpFileName: LPCWSTR, lpFileSizeHigh: LPDWORD): DWORD{.
      stdcall, dynlib: "kernel32", importc: "GetCompressedFileSizeW".}
  proc DeleteFile*(lpFileName: LPCWSTR): WINBOOL{.stdcall, dynlib: "kernel32",
      importc: "DeleteFileW".}
  proc SearchPath*(lpPath: LPCWSTR, lpFileName: LPCWSTR, lpExtension: LPCWSTR,
                   nBufferLength: DWORD, lpBuffer: LPWSTR, lpFilePart: LPWSTR): DWORD{.
      stdcall, dynlib: "kernel32", importc: "SearchPathW".}
  proc CopyFile*(lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR,
                 bFailIfExists: WINBOOL): WINBOOL{.stdcall, dynlib: "kernel32",
      importc: "CopyFileW".}
  proc MoveFile*(lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR): WINBOOL{.
      stdcall, dynlib: "kernel32", importc: "MoveFileW".}
  proc MoveFileEx*(lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR,
                   dwFlags: DWORD): WINBOOL{.stdcall, dynlib: "kernel32",
      importc: "MoveFileExW".}
  proc CreateNamedPipe*(lpName: LPCWSTR, dwOpenMode: DWORD, dwPipeMode: DWORD,
                        nMaxInstances: DWORD, nOutBufferSize: DWORD,
                        nInBufferSize: DWORD, nDefaultTimeOut: DWORD,
                        lpSecurityAttributes: LPSECURITY_ATTRIBUTES): HANDLE{.
      stdcall, dynlib: "kernel32", importc: "CreateNamedPipeW".}
  proc GetNamedPipeHandleState*(hNamedPipe: HANDLE, lpState: LPDWORD,
                                lpCurInstances: LPDWORD,
                                lpMaxCollectionCount: LPDWORD,
                                lpCollectDataTimeout: LPDWORD,
                                lpUserName: LPWSTR, nMaxUserNameSize: DWORD): WINBOOL{.
      stdcall, dynlib: "kernel32", importc: "GetNamedPipeHandleStateW".}
  proc CallNamedPipe*(lpNamedPipeName: LPCWSTR, lpInBuffer: LPVOID,
                      nInBufferSize: DWORD, lpOutBuffer: LPVOID,
                      nOutBufferSize: DWORD, lpBytesRead: LPDWORD,
                      nTimeOut: DWORD): WINBOOL{.stdcall, dynlib: "kernel32",
      importc: "CallNamedPipeW".}
  proc WaitNamedPipe*(lpNamedPipeName: LPCWSTR, nTimeOut: DWORD): WINBOOL{.
      stdcall, dynlib: "kernel32", importc: "WaitNamedPipeW".}
  proc SetVolumeLabel*(lpRootPathName: LPCWSTR, lpVolumeName: LPCWSTR): WINBOOL{.
      stdcall, dynlib: "kernel32", importc: "SetVolumeLabelW".}
  proc GetVolumeInformation*(lpRootPathName: LPCWSTR,
                             lpVolumeNameBuffer: LPWSTR, nVolumeNameSize: DWORD,
                             lpVolumeSerialNumber: LPDWORD,
                             lpMaximumComponentLength: LPDWORD,
                             lpFileSystemFlags: LPDWORD,
                             lpFileSystemNameBuffer: LPWSTR,
                             nFileSystemNameSize: DWORD): WINBOOL{.stdcall,
      dynlib: "kernel32", importc: "GetVolumeInformationW".}
  proc ClearEventLog*(hEventLog: HANDLE, lpBackupFileName: LPCWSTR): WINBOOL{.
      stdcall, dynlib: "advapi32", importc: "ClearEventLogW".}
  proc BackupEventLog*(hEventLog: HANDLE, lpBackupFileName: LPCWSTR): WINBOOL{.
      stdcall, dynlib: "advapi32", importc: "BackupEventLogW".}
  proc OpenEventLog*(lpUNCServerName: LPCWSTR, lpSourceName: LPCWSTR): HANDLE{.
      stdcall, dynlib: "advapi32", importc: "OpenEventLogW".}
  proc RegisterEventSource*(lpUNCServerName: LPCWSTR, lpSourceName: LPCWSTR): HANDLE{.
      stdcall, dynlib: "advapi32", importc: "RegisterEventSourceW".}
  proc OpenBackupEventLog*(lpUNCServerName: LPCWSTR, lpFileName: LPCWSTR): HANDLE{.
      stdcall, dynlib: "advapi32", importc: "OpenBackupEventLogW".}
  proc ReadEventLog*(hEventLog: HANDLE, dwReadFlags: DWORD,
                     dwRecordOffset: DWORD, lpBuffer: LPVOID,
                     nNumberOfBytesToRead: DWORD, pnBytesRead: LPDWORD,
                     pnMinNumberOfBytesNeeded: LPDWORD): WINBOOL{.stdcall,
      dynlib: "advapi32", importc: "ReadEventLogW".}
  proc ReportEvent*(hEventLog: HANDLE, wType: int16, wCategory: int16,
                    dwEventID: DWORD, lpUserSid: PSID, wNumStrings: int16,
                    dwDataSize: DWORD, lpStrings: LPPCWSTR, lpRawData: LPVOID): WINBOOL{.
      stdcall, dynlib: "advapi32", importc: "ReportEventW".}
  proc AccessCheckAndAuditAlarm*(SubsystemName: LPCWSTR, HandleId: LPVOID,
                                 ObjectTypeName: LPWSTR, ObjectName: LPWSTR,
                                 SecurityDescriptor: PSECURITY_DESCRIPTOR,
                                 DesiredAccess: DWORD,
                                 GenericMapping: PGENERIC_MAPPING,
                                 ObjectCreation: WINBOOL,
                                 GrantedAccess: LPDWORD, AccessStatus: LPBOOL,
                                 pfGenerateOnClose: LPBOOL): WINBOOL{.stdcall,
      dynlib: "advapi32", importc: "AccessCheckAndAuditAlarmW".}
  proc ObjectOpenAuditAlarm*(SubsystemName: LPCWSTR, HandleId: LPVOID,
                             ObjectTypeName: LPWSTR, ObjectName: LPWSTR,
                             pSecurityDescriptor: PSECURITY_DESCRIPTOR,
                             ClientToken: HANDLE, DesiredAccess: DWORD,
                             GrantedAccess: DWORD, Privileges: PPRIVILEGE_SET,
                             ObjectCreation: WINBOOL, AccessGranted: WINBOOL,
                             GenerateOnClose: LPBOOL): WINBOOL{.stdcall,
      dynlib: "advapi32", importc: "ObjectOpenAuditAlarmW".}
  proc ObjectPrivilegeAuditAlarm*(SubsystemName: LPCWSTR, HandleId: LPVOID,
                                  ClientToken: HANDLE, DesiredAccess: DWORD,
                                  Privileges: PPRIVILEGE_SET,
                                  AccessGranted: WINBOOL): WINBOOL{.stdcall,
      dynlib: "advapi32", importc: "ObjectPrivilegeAuditAlarmW".}
  proc ObjectCloseAuditAlarm*(SubsystemName: LPCWSTR, HandleId: LPVOID,
                              GenerateOnClose: WINBOOL): WINBOOL{.stdcall,
      dynlib: "advapi32", importc: "ObjectCloseAuditAlarmW".}
  proc PrivilegedServiceAuditAlarm*(SubsystemName: LPCWSTR,
                                    ServiceName: LPCWSTR, ClientToken: HANDLE,
                                    Privileges: PPRIVILEGE_SET,
                                    AccessGranted: WINBOOL): WINBOOL{.stdcall,
      dynlib: "advapi32", importc: "PrivilegedServiceAuditAlarmW".}
  proc SetFileSecurity*(lpFileName: LPCWSTR,
                        SecurityInformation: SECURITY_INFORMATION,
                        pSecurityDescriptor: PSECURITY_DESCRIPTOR): WINBOOL{.
      stdcall, dynlib: "advapi32", importc: "SetFileSecurityW".}
  proc GetFileSecurity*(lpFileName: LPCWSTR,
                        RequestedInformation: SECURITY_INFORMATION,
                        pSecurityDescriptor: PSECURITY_DESCRIPTOR,
                        nLength: DWORD, lpnLengthNeeded: LPDWORD): WINBOOL{.
      stdcall, dynlib: "advapi32", importc: "GetFileSecurityW".}
  proc FindFirstChangeNotification*(lpPathName: LPCWSTR, bWatchSubtree: WINBOOL,
                                    dwNotifyFilter: DWORD): HANDLE{.stdcall,
      dynlib: "kernel32", importc: "FindFirstChangeNotificationW".}
  proc IsBadStringPtr*(lpsz: LPCWSTR, ucchMax: UINT): WINBOOL{.stdcall,
      dynlib: "kernel32", importc: "IsBadStringPtrW".}
  proc LookupAccountSid*(lpSystemName: LPCWSTR, Sid: PSID, Name: LPWSTR,
                         cbName: LPDWORD, ReferencedDomainName: LPWSTR,
                         cbReferencedDomainName: LPDWORD, peUse: PSID_NAME_USE): WINBOOL{.
      stdcall, dynlib: "advapi32", importc: "LookupAccountSidW".}
  proc LookupAccountName*(lpSystemName: LPCWSTR, lpAccountName: LPCWSTR,
                          Sid: PSID, cbSid: LPDWORD,
                          ReferencedDomainName: LPWSTR,
                          cbReferencedDomainName: LPDWORD, peUse: PSID_NAME_USE): WINBOOL{.
      stdcall, dynlib: "advapi32", importc: "LookupAccountNameW".}
  proc LookupPrivilegeValue*(lpSystemName: LPCWSTR, lpName: LPCWSTR,
                             lpLuid: PLUID): WINBOOL{.stdcall,
      dynlib: "advapi32", importc: "LookupPrivilegeValueW".}
  proc LookupPrivilegeName*(lpSystemName: LPCWSTR, lpLuid: PLUID,
                            lpName: LPWSTR, cbName: LPDWORD): WINBOOL{.stdcall,
      dynlib: "advapi32", importc: "LookupPrivilegeNameW".}
  proc LookupPrivilegeDisplayName*(lpSystemName: LPCWSTR, lpName: LPCWSTR,
                                   lpDisplayName: LPWSTR,
                                   cbDisplayName: LPDWORD, lpLanguageId: LPDWORD): WINBOOL{.
      stdcall, dynlib: "advapi32", importc: "LookupPrivilegeDisplayNameW".}
  proc BuildCommDCB*(lpDef: LPCWSTR, lpDCB: LPDCB): WINBOOL{.stdcall,
      dynlib: "kernel32", importc: "BuildCommDCBW".}
  proc BuildCommDCBAndTimeouts*(lpDef: LPCWSTR, lpDCB: LPDCB,
                                lpCommTimeouts: LPCOMMTIMEOUTS): WINBOOL{.
      stdcall, dynlib: "kernel32", importc: "BuildCommDCBAndTimeoutsW".}
  proc CommConfigDialog*(lpszName: LPCWSTR, wnd: HWND, lpCC: LPCOMMCONFIG): WINBOOL{.
      stdcall, dynlib: "kernel32", importc: "CommConfigDialogW".}
  proc GetDefaultCommConfig*(lpszName: LPCWSTR, lpCC: LPCOMMCONFIG,
                             lpdwSize: LPDWORD): WINBOOL{.stdcall,
      dynlib: "kernel32", importc: "GetDefaultCommConfigW".}
  proc SetDefaultCommConfig*(lpszName: LPCWSTR, lpCC: LPCOMMCONFIG,
                             dwSize: DWORD): WINBOOL{.stdcall,
      dynlib: "kernel32", importc: "SetDefaultCommConfigW".}
  proc GetComputerName*(lpBuffer: LPWSTR, nSize: LPDWORD): WINBOOL{.stdcall,
      dynlib: "kernel32", importc: "GetComputerNameW".}
  proc SetComputerName*(lpComputerName: LPCWSTR): WINBOOL{.stdcall,
      dynlib: "kernel32", importc: "SetComputerNameW".}
  proc GetUserName*(lpBuffer: LPWSTR, nSize: LPDWORD): WINBOOL{.stdcall,
      dynlib: "advapi32", importc: "GetUserNameW".}
  proc LoadKeyboardLayout*(pwszKLID: LPCWSTR, Flags: UINT): HKL{.stdcall,
      dynlib: "user32", importc: "LoadKeyboardLayoutW".}
  proc GetKeyboardLayoutName*(pwszKLID: LPWSTR): WINBOOL{.stdcall,
      dynlib: "user32", importc: "GetKeyboardLayoutNameW".}
  proc CreateDesktop*(lpszDesktop: LPWSTR, lpszDevice: LPWSTR,
                      pDevmode: LPDEVMODE, dwFlags: DWORD,
                      dwDesiredAccess: DWORD, lpsa: LPSECURITY_ATTRIBUTES): HDESK{.
      stdcall, dynlib: "user32", importc: "CreateDesktopW".}
  proc OpenDesktop*(lpszDesktop: LPWSTR, dwFlags: DWORD, fInherit: WINBOOL,
                    dwDesiredAccess: DWORD): HDESK{.stdcall, dynlib: "user32",
      importc: "OpenDesktopW".}
  proc EnumDesktops*(hwinsta: HWINSTA, lpEnumFunc: DESKTOPENUMPROC,
                     lp: LPARAM): WINBOOL{.stdcall, dynlib: "user32",
      importc: "EnumDesktopsW".}
  proc CreateWindowStation*(lpwinsta: LPWSTR, dwReserved: DWORD,
                            dwDesiredAccess: DWORD, lpsa: LPSECURITY_ATTRIBUTES): HWINSTA{.
      stdcall, dynlib: "user32", importc: "CreateWindowStationW".}
  proc OpenWindowStation*(lpszWinSta: LPWSTR, fInherit: WINBOOL,
                          dwDesiredAccess: DWORD): HWINSTA{.stdcall,
      dynlib: "user32", importc: "OpenWindowStationW".}
  proc EnumWindowStations*(lpEnumFunc: ENUMWINDOWSTATIONPROC, lp: LPARAM): WINBOOL{.
      stdcall, dynlib: "user32", importc: "EnumWindowStationsW".}
  proc GetUserObjectInformation*(hObj: HANDLE, nIndex: int32, pvInfo: PVOID,
                                 nLength: DWORD, lpnLengthNeeded: LPDWORD): WINBOOL{.
      stdcall, dynlib: "user32", importc: "GetUserObjectInformationW".}
  proc SetUserObjectInformation*(hObj: HANDLE, nIndex: int32, pvInfo: PVOID,
                                 nLength: DWORD): WINBOOL{.stdcall,
      dynlib: "user32", importc: "SetUserObjectInformationW".}
  proc RegisterWindowMessage*(lpString: LPCWSTR): UINT{.stdcall,
      dynlib: "user32", importc: "RegisterWindowMessageW".}
  proc GetMessage*(lpMsg: LPMSG, wnd: HWND, wMsgFilterMin: UINT,
                   wMsgFilterMax: UINT): WINBOOL{.stdcall, dynlib: "user32",
      importc: "GetMessageW".}
  proc DispatchMessage*(lpMsg: LPMSG): LONG{.stdcall, dynlib: "user32",
      importc: "DispatchMessageW".}
  proc PeekMessage*(lpMsg: LPMSG, wnd: HWND, wMsgFilterMin: UINT,
                    wMsgFilterMax: UINT, wRemoveMsg: UINT): WINBOOL{.stdcall,
      dynlib: "user32", importc: "PeekMessageW".}
  proc SendMessage*(wnd: HWND, Msg: UINT, wp: WPARAM, lp: LPARAM): LRESULT{.
      stdcall, dynlib: "user32", importc: "SendMessageW".}
  proc SendMessageTimeout*(wnd: HWND, Msg: UINT, wp: WPARAM,
                           lp: LPARAM, fuFlags: UINT, uTimeout: UINT,
                           lpdwResult: LPDWORD): LRESULT{.stdcall,
      dynlib: "user32", importc: "SendMessageTimeoutW".}
  proc SendNotifyMessage*(wnd: HWND, Msg: UINT, wp: WPARAM, lp: LPARAM): WINBOOL{.
      stdcall, dynlib: "user32", importc: "SendNotifyMessageW".}
  proc SendMessageCallback*(wnd: HWND, Msg: UINT, wp: WPARAM,
                            lp: LPARAM, lpResultCallBack: SENDASYNCPROC,
                            dwData: DWORD): WINBOOL{.stdcall, dynlib: "user32",
      importc: "SendMessageCallbackW".}
  proc PostMessage*(wnd: HWND, Msg: UINT, wp: WPARAM, lp: LPARAM): WINBOOL{.
      stdcall, dynlib: "user32", importc: "PostMessageW".}
  proc PostThreadMessage*(idThread: DWORD, Msg: UINT, wp: WPARAM,
                          lp: LPARAM): WINBOOL{.stdcall, dynlib: "user32",
      importc: "PostThreadMessageW".}
  proc DefWindowProc*(wnd: HWND, Msg: UINT, wp: WPARAM, lp: LPARAM): LRESULT{.
      stdcall, dynlib: "user32", importc: "DefWindowProcW".}
  proc CallWindowProc*(lpPrevWndFunc: WNDPROC, wnd: HWND, Msg: UINT,
                       wp: WPARAM, lp: LPARAM): LRESULT{.stdcall,
      dynlib: "user32", importc: "CallWindowProcW".}
  proc RegisterClass*(lpWndClass: LPWNDCLASS): ATOM{.stdcall, dynlib: "user32",
      importc: "RegisterClassW".}
  proc UnregisterClass*(lpClassName: LPCWSTR, hInstance: HINST): WINBOOL{.
      stdcall, dynlib: "user32", importc: "UnregisterClassW".}
  proc GetClassInfo*(hInstance: HINST, lpClassName: LPCWSTR,
                     lpWndClass: LPWNDCLASS): WINBOOL{.stdcall,
      dynlib: "user32", importc: "GetClassInfoW".}
  proc RegisterClassEx*(para1: LPWNDCLASSEXW): ATOM{.stdcall, dynlib: "user32",
      importc: "RegisterClassExW".}
  proc GetClassInfoEx*(para1: HINST, para2: LPCWSTR, para3: LPWNDCLASSEX): WINBOOL{.
      stdcall, dynlib: "user32", importc: "GetClassInfoExW".}
  proc CreateWindowEx*(dwExStyle: DWORD, lpClassName: LPCWSTR,
                       lpWindowName: LPCWSTR, dwStyle: DWORD, X: int32,
                       Y: int32, nWidth: int32, nHeight: int32,
                       hWndParent: HWND, menu: HMENU, hInstance: HINST,
                       lpParam: LPVOID): HWND{.stdcall, dynlib: "user32",
      importc: "CreateWindowExW".}
  proc CreateDialogParam*(hInstance: HINST, lpTemplateName: LPCWSTR,
                          hWndParent: HWND, lpDialogFunc: DLGPROC,
                          dwInitParam: LPARAM): HWND{.stdcall, dynlib: "user32",
      importc: "CreateDialogParamW".}
  proc CreateDialogIndirectParam*(hInstance: HINST, lpTemplate: LPCDLGTEMPLATE,
                                  hWndParent: HWND, lpDialogFunc: DLGPROC,
                                  dwInitParam: LPARAM): HWND{.stdcall,
      dynlib: "user32", importc: "CreateDialogIndirectParamW".}
  proc DialogBoxParam*(hInstance: HINST, lpTemplateName: LPCWSTR,
                       hWndParent: HWND, lpDialogFunc: DLGPROC,
                       dwInitParam: LPARAM): int32{.stdcall, dynlib: "user32",
      importc: "DialogBoxParamW".}
  proc DialogBoxIndirectParam*(hInstance: HINST,
                               hDialogTemplate: LPCDLGTEMPLATE,
                               hWndParent: HWND, lpDialogFunc: DLGPROC,
                               dwInitParam: LPARAM): int32{.stdcall,
      dynlib: "user32", importc: "DialogBoxIndirectParamW".}
  proc SetDlgItemText*(hDlg: HWND, nIDDlgItem: int32, lpString: LPCWSTR): WINBOOL{.
      stdcall, dynlib: "user32", importc: "SetDlgItemTextW".}
  proc GetDlgItemText*(hDlg: HWND, nIDDlgItem: int32, lpString: LPWSTR,
                       nMaxCount: int32): UINT{.stdcall, dynlib: "user32",
      importc: "GetDlgItemTextW".}
  proc SendDlgItemMessage*(hDlg: HWND, nIDDlgItem: int32, Msg: UINT,
                           wp: WPARAM, lp: LPARAM): LONG{.stdcall,
      dynlib: "user32", importc: "SendDlgItemMessageW".}
  proc DefDlgProc*(hDlg: HWND, Msg: UINT, wp: WPARAM, lp: LPARAM): LRESULT{.
      stdcall, dynlib: "user32", importc: "DefDlgProcW".}
  proc CallMsgFilter*(lpMsg: LPMSG, nCode: int32): WINBOOL{.stdcall,
      dynlib: "user32", importc: "CallMsgFilterW".}
  proc RegisterClipboardFormat*(lpszFormat: LPCWSTR): UINT{.stdcall,
      dynlib: "user32", importc: "RegisterClipboardFormatW".}
  proc GetClipboardFormatName*(format: UINT, lpszFormatName: LPWSTR,
                               cchMaxCount: int32): int32{.stdcall,
      dynlib: "user32", importc: "GetClipboardFormatNameW".}
  proc CharToOem*(lpszSrc: LPCWSTR, lpszDst: LPSTR): WINBOOL{.stdcall,
      dynlib: "user32", importc: "CharToOemW".}
  proc OemToChar*(lpszSrc: LPCSTR, lpszDst: LPWSTR): WINBOOL{.stdcall,
      dynlib: "user32", importc: "OemToCharW".}
  proc CharToOemBuff*(lpszSrc: LPCWSTR, lpszDst: LPSTR, cchDstLength: DWORD): WINBOOL{.
      stdcall, dynlib: "user32", importc: "CharToOemBuffW".}
  proc OemToCharBuff*(lpszSrc: LPCSTR, lpszDst: LPWSTR, cchDstLength: DWORD): WINBOOL{.
      stdcall, dynlib: "user32", importc: "OemToCharBuffW".}
  proc CharUpper*(lpsz: LPWSTR): LPWSTR{.stdcall, dynlib: "user32",
      importc: "CharUpperW".}
  proc CharUpperBuff*(lpsz: LPWSTR, cchLength: DWORD): DWORD{.stdcall,
      dynlib: "user32", importc: "CharUpperBuffW".}
  proc CharLower*(lpsz: LPWSTR): LPWSTR{.stdcall, dynlib: "user32",
      importc: "CharLowerW".}
  proc CharLowerBuff*(lpsz: LPWSTR, cchLength: DWORD): DWORD{.stdcall,
      dynlib: "user32", importc: "CharLowerBuffW".}
  proc CharNext*(lpsz: LPCWSTR): LPWSTR{.stdcall, dynlib: "user32",
      importc: "CharNextW".}
  proc CharPrev*(lpszStart: LPCWSTR, lpszCurrent: LPCWSTR): LPWSTR{.stdcall,
      dynlib: "user32", importc: "CharPrevW".}
  proc IsCharAlpha*(ch: WCHAR): WINBOOL{.stdcall, dynlib: "user32",
      importc: "IsCharAlphaW".}
  proc IsCharAlphaNumeric*(ch: WCHAR): WINBOOL{.stdcall, dynlib: "user32",
      importc: "IsCharAlphaNumericW".}
  proc IsCharUpper*(ch: WCHAR): WINBOOL{.stdcall, dynlib: "user32",
      importc: "IsCharUpperW".}
  proc IsCharLower*(ch: WCHAR): WINBOOL{.stdcall, dynlib: "user32",
      importc: "IsCharLowerW".}
  proc GetKeyNameText*(lParam: LONG, lpString: LPWSTR, nSize: int32): int32{.
      stdcall, dynlib: "user32", importc: "GetKeyNameTextW".}
  proc VkKeyScan*(ch: WCHAR): SHORT{.stdcall, dynlib: "user32",
                                     importc: "VkKeyScanW".}
  proc VkKeyScanEx*(ch: WCHAR, dwhkl: HKL): SHORT{.stdcall, dynlib: "user32",
      importc: "VkKeyScanExW".}
  proc MapVirtualKey*(uCode: UINT, uMapType: UINT): UINT{.stdcall,
      dynlib: "user32", importc: "MapVirtualKeyW".}
  proc MapVirtualKeyEx*(uCode: UINT, uMapType: UINT, dwhkl: HKL): UINT{.stdcall,
      dynlib: "user32", importc: "MapVirtualKeyExW".}
  proc LoadAccelerators*(hInstance: HINST, lpTableName: LPCWSTR): HACCEL{.
      stdcall, dynlib: "user32", importc: "LoadAcceleratorsW".}
  proc CreateAcceleratorTable*(para1: LPACCEL, para2: int32): HACCEL{.stdcall,
      dynlib: "user32", importc: "CreateAcceleratorTableW".}
  proc CopyAcceleratorTable*(hAccelSrc: HACCEL, lpAccelDst: LPACCEL,
                             cAccelEntries: int32): int32{.stdcall,
      dynlib: "user32", importc: "CopyAcceleratorTableW".}
  proc TranslateAccelerator*(wnd: HWND, hAccTable: HACCEL, lpMsg: LPMSG): int32{.
      stdcall, dynlib: "user32", importc: "TranslateAcceleratorW".}
  proc LoadMenu*(hInstance: HINST, lpMenuName: LPCWSTR): HMENU{.stdcall,
      dynlib: "user32", importc: "LoadMenuW".}
  proc LoadMenuIndirect*(lpMenuTemplate: LPMENUTEMPLATE): HMENU{.stdcall,
      dynlib: "user32", importc: "LoadMenuIndirectW".}
  proc ChangeMenu*(menu: HMENU, cmd: UINT, lpszNewItem: LPCWSTR,
                   cmdInsert: UINT, flags: UINT): WINBOOL{.stdcall,
      dynlib: "user32", importc: "ChangeMenuW".}
  proc GetMenuString*(menu: HMENU, uIDItem: UINT, lpString: LPWSTR,
                      nMaxCount: int32, uFlag: UINT): int32{.stdcall,
      dynlib: "user32", importc: "GetMenuStringW".}
  proc InsertMenu*(menu: HMENU, uPosition: UINT, uFlags: UINT,
                   uIDNewItem: UINT, lpNewItem: LPCWSTR): WINBOOL{.stdcall,
      dynlib: "user32", importc: "InsertMenuW".}
  proc AppendMenu*(menu: HMENU, uFlags: UINT, uIDNewItem: UINT,
                   lpNewItem: LPCWSTR): WINBOOL{.stdcall, dynlib: "user32",
      importc: "AppendMenuW".}
  proc ModifyMenu*(hMnu: HMENU, uPosition: UINT, uFlags: UINT, uIDNewItem: UINT,
                   lpNewItem: LPCWSTR): WINBOOL{.stdcall, dynlib: "user32",
      importc: "ModifyMenuW".}
  proc InsertMenuItem*(para1: HMENU, para2: UINT, para3: WINBOOL,
                       para4: LPCMENUITEMINFO): WINBOOL{.stdcall,
      dynlib: "user32", importc: "InsertMenuItemW".}
  proc GetMenuItemInfo*(para1: HMENU, para2: UINT, para3: WINBOOL,
                        para4: LPMENUITEMINFO): WINBOOL{.stdcall,
      dynlib: "user32", importc: "GetMenuItemInfoW".}
  proc SetMenuItemInfo*(para1: HMENU, para2: UINT, para3: WINBOOL,
                        para4: LPCMENUITEMINFO): WINBOOL{.stdcall,
      dynlib: "user32", importc: "SetMenuItemInfoW".}
  proc DrawText*(hDC: HDC, lpString: LPCWSTR, nCount: int32, lpRect: LPRECT,
                 uFormat: UINT): int32{.stdcall, dynlib: "user32",
                                        importc: "DrawTextW".}
  proc DrawTextEx*(para1: HDC, para2: LPWSTR, para3: int32, para4: LPRECT,
                   para5: UINT, para6: LPDRAWTEXTPARAMS): int32{.stdcall,
      dynlib: "user32", importc: "DrawTextExW".}
  proc GrayString*(hDC: HDC, hBrush: HBRUSH, lpOutputFunc: GRAYSTRINGPROC,
                   lpData: LPARAM, nCount: int32, X: int32, Y: int32,
                   nWidth: int32, nHeight: int32): WINBOOL{.stdcall,
      dynlib: "user32", importc: "GrayStringW".}
  proc DrawState*(para1: HDC, para2: HBRUSH, para3: DRAWSTATEPROC,
                  para4: LPARAM, para5: WPARAM, para6: int32, para7: int32,
                  para8: int32, para9: int32, para10: UINT): WINBOOL{.stdcall,
      dynlib: "user32", importc: "DrawStateW".}
  proc TabbedTextOut*(hDC: HDC, X: int32, Y: int32, lpString: LPCWSTR,
                      nCount: int32, nTabPositions: int32,
                      lpnTabStopPositions: LPINT, nTabOrigin: int32): LONG{.
      stdcall, dynlib: "user32", importc: "TabbedTextOutW".}
  proc GetTabbedTextExtent*(hDC: HDC, lpString: LPCWSTR, nCount: int32,
                            nTabPositions: int32, lpnTabStopPositions: LPINT): DWORD{.
      stdcall, dynlib: "user32", importc: "GetTabbedTextExtentW".}
  proc SetProp*(wnd: HWND, lpString: LPCWSTR, hData: HANDLE): WINBOOL{.stdcall,
      dynlib: "user32", importc: "SetPropW".}
  proc GetProp*(wnd: HWND, lpString: LPCWSTR): HANDLE{.stdcall,
      dynlib: "user32", importc: "GetPropW".}
  proc RemoveProp*(wnd: HWND, lpString: LPCWSTR): HANDLE{.stdcall,
      dynlib: "user32", importc: "RemovePropW".}
  proc EnumPropsEx*(wnd: HWND, lpEnumFunc: PROPENUMPROCEX, lp: LPARAM): int32{.
      stdcall, dynlib: "user32", importc: "EnumPropsExW".}
  proc EnumProps*(wnd: HWND, lpEnumFunc: PROPENUMPROC): int32{.stdcall,
      dynlib: "user32", importc: "EnumPropsW".}
  proc SetWindowText*(wnd: HWND, lpString: LPCWSTR): WINBOOL{.stdcall,
      dynlib: "user32", importc: "SetWindowTextW".}
  proc GetWindowText*(wnd: HWND, lpString: LPWSTR, nMaxCount: int32): int32{.
      stdcall, dynlib: "user32", importc: "GetWindowTextW".}
  proc GetWindowTextLength*(wnd: HWND): int32{.stdcall, dynlib: "user32",
      importc: "GetWindowTextLengthW".}
  proc MessageBox*(wnd: HWND, lpText: LPCWSTR, lpCaption: LPCWSTR, uType: UINT): int32{.
      stdcall, dynlib: "user32", importc: "MessageBoxW".}
  proc MessageBoxEx*(wnd: HWND, lpText: LPCWSTR, lpCaption: LPCWSTR,
                     uType: UINT, wLanguageId: int16): int32{.stdcall,
      dynlib: "user32", importc: "MessageBoxExW".}
  proc MessageBoxIndirect*(para1: LPMSGBOXPARAMS): int32{.stdcall,
      dynlib: "user32", importc: "MessageBoxIndirectW".}
  proc GetWindowLong*(wnd: HWND, nIndex: int32): LONG{.stdcall,
      dynlib: "user32", importc: "GetWindowLongW".}
  proc SetWindowLong*(wnd: HWND, nIndex: int32, dwNewLong: LONG): LONG{.
      stdcall, dynlib: "user32", importc: "SetWindowLongW".}
  proc GetClassLong*(wnd: HWND, nIndex: int32): DWORD{.stdcall,
      dynlib: "user32", importc: "GetClassLongW".}
  proc SetClassLong*(wnd: HWND, nIndex: int32, dwNewLong: LONG): DWORD{.
      stdcall, dynlib: "user32", importc: "SetClassLongW".}
  when defined(cpu64):
    proc GetWindowLongPtr*(wnd: HWND, nIndex: int32): LONG_PTR{.stdcall,
        dynlib: "user32", importc: "GetWindowLongPtrW".}
    proc SetWindowLongPtr*(wnd: HWND, nIndex: int32, dwNewLong: LONG_PTR): LONG_PTR{.
        stdcall, dynlib: "user32", importc: "SetWindowLongPtrW".}
    proc GetClassLongPtr*(wnd: HWND, nIndex: int32): LONG_PTR{.stdcall,
        dynlib: "user32", importc: "GetClassLongPtrW".}
    proc SetClassLongPtr*(wnd: HWND, nIndex: int32, dwNewLong: LONG_PTR): LONG_PTR{.
        stdcall, dynlib: "user32", importc: "SetClassLongPtrW".}
  else:
    proc GetWindowLongPtr*(wnd: HWND, nIndex: int32): LONG_PTR{.stdcall,
        dynlib: "user32", importc: "GetWindowLongW".}
    proc SetWindowLongPtr*(wnd: HWND, nIndex: int32, dwNewLong: LONG_PTR): LONG_PTR{.
        stdcall, dynlib: "user32", importc: "SetWindowLongW".}
    proc GetClassLongPtr*(wnd: HWND, nIndex: int32): LONG_PTR{.stdcall,
        dynlib: "user32", importc: "GetClassLongW".}
    proc SetClassLongPtr*(wnd: HWND, nIndex: int32, dwNewLong: LONG_PTR): LONG_PTR{.
        stdcall, dynlib: "user32", importc: "SetClassLongW".}
  proc FindWindow*(lpClassName: LPCWSTR, lpWindowName: LPCWSTR): HWND{.stdcall,
      dynlib: "user32", importc: "FindWindowW".}
  proc FindWindowEx*(para1: HWND, para2: HWND, para3: LPCWSTR, para4: LPCWSTR): HWND{.
      stdcall, dynlib: "user32", importc: "FindWindowExW".}
  proc GetClassName*(wnd: HWND, lpClassName: LPWSTR, nMaxCount: int32): int32{.
      stdcall, dynlib: "user32", importc: "GetClassNameW".}
  proc SetWindowsHookEx*(idHook: int32, lpfn: HOOKPROC, hmod: HINST,
                         dwThreadId: DWORD): HHOOK{.stdcall, dynlib: "user32",
      importc: "SetWindowsHookExW".}
  proc LoadBitmap*(hInstance: HINST, lpBitmapName: LPCWSTR): HBITMAP{.stdcall,
      dynlib: "user32", importc: "LoadBitmapW".}
  proc LoadCursor*(hInstance: HINST, lpCursorName: LPCWSTR): HCURSOR{.stdcall,
      dynlib: "user32", importc: "LoadCursorW".}
  proc LoadCursorFromFile*(lpFileName: LPCWSTR): HCURSOR{.stdcall,
      dynlib: "user32", importc: "LoadCursorFromFileW".}
  proc LoadIcon*(hInstance: HINST, lpIconName: LPCWSTR): HICON{.stdcall,
      dynlib: "user32", importc: "LoadIconW".}
  proc LoadImage*(para1: HINST, para2: LPCWSTR, para3: UINT, para4: int32,
                  para5: int32, para6: UINT): HANDLE{.stdcall, dynlib: "user32",
      importc: "LoadImageW".}
  proc LoadString*(hInstance: HINST, uID: UINT, lpBuffer: LPWSTR,
                   nBufferMax: int32): int32{.stdcall, dynlib: "user32",
      importc: "LoadStringW".}
  proc IsDialogMessage*(hDlg: HWND, lpMsg: LPMSG): WINBOOL{.stdcall,
      dynlib: "user32", importc: "IsDialogMessageW".}
  proc DlgDirList*(hDlg: HWND, lpPathSpec: LPWSTR, nIDListBox: int32,
                   nIDStaticPath: int32, uFileType: UINT): int32{.stdcall,
      dynlib: "user32", importc: "DlgDirListW".}
  proc DlgDirSelectEx*(hDlg: HWND, lpString: LPWSTR, nCount: int32,
                       nIDListBox: int32): WINBOOL{.stdcall, dynlib: "user32",
      importc: "DlgDirSelectExW".}
  proc DlgDirListComboBox*(hDlg: HWND, lpPathSpec: LPWSTR, nIDComboBox: int32,
                           nIDStaticPath: int32, uFiletype: UINT): int32{.
      stdcall, dynlib: "user32", importc: "DlgDirListComboBoxW".}
  proc DlgDirSelectComboBoxEx*(hDlg: HWND, lpString: LPWSTR, nCount: int32,
                               nIDComboBox: int32): WINBOOL{.stdcall,
      dynlib: "user32", importc: "DlgDirSelectComboBoxExW".}
  proc DefFrameProc*(wnd: HWND, hWndMDIClient: HWND, uMsg: UINT,
                     wp: WPARAM, lp: LPARAM): LRESULT{.stdcall,
      dynlib: "user32", importc: "DefFrameProcW".}
  proc DefMDIChildProc*(wnd: HWND, uMsg: UINT, wp: WPARAM, lp: LPARAM): LRESULT{.
      stdcall, dynlib: "user32", importc: "DefMDIChildProcW".}
  proc CreateMDIWindow*(lpClassName: LPWSTR, lpWindowName: LPWSTR,
                        dwStyle: DWORD, X: int32, Y: int32, nWidth: int32,
                        nHeight: int32, hWndParent: HWND, hInstance: HINST,
                        lp: LPARAM): HWND{.stdcall, dynlib: "user32",
      importc: "CreateMDIWindowW".}
  proc WinHelp*(hWndMain: HWND, lpszHelp: LPCWSTR, uCommand: UINT, dwData: DWORD): WINBOOL{.
      stdcall, dynlib: "user32", importc: "WinHelpW".}
  proc ChangeDisplaySettings*(lpDevMode: LPDEVMODE, dwFlags: DWORD): LONG{.
      stdcall, dynlib: "user32", importc: "ChangeDisplaySettingsW".}
  proc EnumDisplaySettings*(lpszDeviceName: LPCWSTR, iModeNum: DWORD,
                            lpDevMode: LPDEVMODEW): WINBOOL{.stdcall,
      dynlib: "user32", importc: "EnumDisplaySettingsW".}
  proc SystemParametersInfo*(uiAction: UINT, uiParam: UINT, pvParam: PVOID,
                             fWinIni: UINT): WINBOOL{.stdcall, dynlib: "user32",
      importc: "SystemParametersInfoW".}
  proc AddFontResource*(para1: LPCWSTR): int32{.stdcall, dynlib: "gdi32",
      importc: "AddFontResourceW".}
  proc CopyMetaFile*(para1: HMETAFILE, para2: LPCWSTR): HMETAFILE{.stdcall,
      dynlib: "gdi32", importc: "CopyMetaFileW".}
  proc CreateFontIndirect*(para1: PLOGFONT): HFONT{.stdcall, dynlib: "gdi32",
      importc: "CreateFontIndirectW".}
  proc CreateFontIndirect*(para1: var LOGFONT): HFONT{.stdcall, dynlib: "gdi32",
      importc: "CreateFontIndirectW".}
  proc CreateFont*(para1: int32, para2: int32, para3: int32, para4: int32,
                   para5: int32, para6: DWORD, para7: DWORD, para8: DWORD,
                   para9: DWORD, para10: DWORD, para11: DWORD, para12: DWORD,
                   para13: DWORD, para14: LPCWSTR): HFONT{.stdcall,
      dynlib: "gdi32", importc: "CreateFontW".}
  proc CreateIC*(para1: LPCWSTR, para2: LPCWSTR, para3: LPCWSTR,
                 para4: LPDEVMODE): HDC{.stdcall, dynlib: "gdi32",
      importc: "CreateICW".}
  proc CreateMetaFile*(para1: LPCWSTR): HDC{.stdcall, dynlib: "gdi32",
      importc: "CreateMetaFileW".}
  proc CreateScalableFontResource*(para1: DWORD, para2: LPCWSTR, para3: LPCWSTR,
                                   para4: LPCWSTR): WINBOOL{.stdcall,
      dynlib: "gdi32", importc: "CreateScalableFontResourceW".}
  proc EnumFontFamiliesEx*(para1: HDC, para2: LPLOGFONT, para3: FONTENUMEXPROC,
                           para4: LPARAM, para5: DWORD): int32{.stdcall,
      dynlib: "gdi32", importc: "EnumFontFamiliesExW".}
  proc EnumFontFamilies*(para1: HDC, para2: LPCWSTR, para3: FONTENUMPROC,
                         para4: LPARAM): int32{.stdcall, dynlib: "gdi32",
      importc: "EnumFontFamiliesW".}
  proc EnumFonts*(para1: HDC, para2: LPCWSTR, para3: ENUMFONTSPROC,
                  para4: LPARAM): int32{.stdcall, dynlib: "gdi32",
      importc: "EnumFontsW".}
  proc EnumFonts*(para1: HDC, para2: LPCWSTR, para3: ENUMFONTSPROC,
                  para4: pointer): int32{.stdcall, dynlib: "gdi32",
      importc: "EnumFontsW".}
  proc GetCharWidth*(para1: HDC, para2: UINT, para3: UINT, para4: LPINT): WINBOOL{.
      stdcall, dynlib: "gdi32", importc: "GetCharWidthW".}
  proc GetCharWidth32*(para1: HDC, para2: UINT, para3: UINT, para4: LPINT): WINBOOL{.
      stdcall, dynlib: "gdi32", importc: "GetCharWidth32W".}
  proc GetCharWidthFloat*(para1: HDC, para2: UINT, para3: UINT, para4: ptr float32): WINBOOL{.
      stdcall, dynlib: "gdi32", importc: "GetCharWidthFloatW".}
  proc GetCharABCWidths*(para1: HDC, para2: UINT, para3: UINT, para4: LPABC): WINBOOL{.
      stdcall, dynlib: "gdi32", importc: "GetCharABCWidthsW".}
  proc GetCharABCWidthsFloat*(para1: HDC, para2: UINT, para3: UINT,
                              para4: LPABCFLOAT): WINBOOL{.stdcall,
      dynlib: "gdi32", importc: "GetCharABCWidthsFloatW".}
  proc GetGlyphOutline*(para1: HDC, para2: UINT, para3: UINT,
                        para4: LPGLYPHMETRICS, para5: DWORD, para6: LPVOID,
                        para7: PMAT2): DWORD{.stdcall, dynlib: "gdi32",
      importc: "GetGlyphOutlineW".}
  proc GetMetaFile*(para1: LPCWSTR): HMETAFILE{.stdcall, dynlib: "gdi32",
      importc: "GetMetaFileW".}
  proc GetOutlineTextMetrics*(para1: HDC, para2: UINT,
                              para3: LPOUTLINETEXTMETRIC): UINT{.stdcall,
      dynlib: "gdi32", importc: "GetOutlineTextMetricsW".}
  proc GetTextExtentPoint*(para1: HDC, para2: LPCWSTR, para3: int32,
                           para4: LPSIZE): WINBOOL{.stdcall, dynlib: "gdi32",
      importc: "GetTextExtentPointW".}
  proc GetTextExtentPoint32*(para1: HDC, para2: LPCWSTR, para3: int32,
                             para4: LPSIZE): WINBOOL{.stdcall, dynlib: "gdi32",
      importc: "GetTextExtentPoint32W".}
  proc GetTextExtentExPoint*(para1: HDC, para2: LPCWSTR, para3: int32,
                             para4: int32, para5: LPINT, para6: LPINT,
                             para7: LPSIZE): WINBOOL{.stdcall, dynlib: "gdi32",
      importc: "GetTextExtentExPointW".}
  proc GetCharacterPlacement*(para1: HDC, para2: LPCWSTR, para3: int32,
                              para4: int32, para5: LPGCP_RESULTS, para6: DWORD): DWORD{.
      stdcall, dynlib: "gdi32", importc: "GetCharacterPlacementW".}
  proc ResetDC*(para1: HDC, para2: LPDEVMODE): HDC{.stdcall, dynlib: "gdi32",
      importc: "ResetDCW".}
  proc RemoveFontResource*(para1: LPCWSTR): WINBOOL{.stdcall, dynlib: "gdi32",
      importc: "RemoveFontResourceW".}
  proc CopyEnhMetaFile*(para1: HENHMETAFILE, para2: LPCWSTR): HENHMETAFILE{.
      stdcall, dynlib: "gdi32", importc: "CopyEnhMetaFileW".}
  proc CreateEnhMetaFile*(para1: HDC, para2: LPCWSTR, para3: LPRECT,
                          para4: LPCWSTR): HDC{.stdcall, dynlib: "gdi32",
      importc: "CreateEnhMetaFileW".}
  proc GetEnhMetaFile*(para1: LPCWSTR): HENHMETAFILE{.stdcall, dynlib: "gdi32",
      importc: "GetEnhMetaFileW".}
  proc GetEnhMetaFileDescription*(para1: HENHMETAFILE, para2: UINT,
                                  para3: LPWSTR): UINT{.stdcall,
      dynlib: "gdi32", importc: "GetEnhMetaFileDescriptionW".}
  proc GetTextMetrics*(para1: HDC, para2: LPTEXTMETRIC): WINBOOL{.stdcall,
      dynlib: "gdi32", importc: "GetTextMetricsW".}
  proc StartDoc*(para1: HDC, para2: PDOCINFO): int32{.stdcall, dynlib: "gdi32",
      importc: "StartDocW".}
  proc GetObject*(para1: HGDIOBJ, para2: int32, para3: LPVOID): int32{.stdcall,
      dynlib: "gdi32", importc: "GetObjectW".}
  proc TextOut*(para1: HDC, para2: int32, para3: int32, para4: LPCWSTR,
                para5: int32): WINBOOL{.stdcall, dynlib: "gdi32",
                                        importc: "TextOutW".}
  proc ExtTextOut*(para1: HDC, para2: int32, para3: int32, para4: UINT,
                   para5: LPRECT, para6: LPCWSTR, para7: UINT, para8: LPINT): WINBOOL{.
      stdcall, dynlib: "gdi32", importc: "ExtTextOutW".}
  proc PolyTextOut*(para1: HDC, para2: PPOLYTEXT, para3: int32): WINBOOL{.
      stdcall, dynlib: "gdi32", importc: "PolyTextOutW".}
  proc GetTextFace*(para1: HDC, para2: int32, para3: LPWSTR): int32{.stdcall,
      dynlib: "gdi32", importc: "GetTextFaceW".}
  proc GetKerningPairs*(para1: HDC, para2: DWORD, para3: LPKERNINGPAIR): DWORD{.
      stdcall, dynlib: "gdi32", importc: "GetKerningPairsW".}
  proc GetLogColorSpace*(para1: HCOLORSPACE, para2: LPLOGCOLORSPACE,
                         para3: DWORD): WINBOOL{.stdcall, dynlib: "gdi32",
      importc: "GetLogColorSpaceW".}
  proc CreateColorSpace*(para1: LPLOGCOLORSPACE): HCOLORSPACE{.stdcall,
      dynlib: "gdi32", importc: "CreateColorSpaceW".}
  proc GetICMProfile*(para1: HDC, para2: DWORD, para3: LPWSTR): WINBOOL{.
      stdcall, dynlib: "gdi32", importc: "GetICMProfileW".}
  proc SetICMProfile*(para1: HDC, para2: LPWSTR): WINBOOL{.stdcall,

      dynlib: "gdi32", importc: "SetICMProfileW".}
  proc UpdateICMRegKey*(para1: DWORD, para2: DWORD, para3: LPWSTR, para4: UINT): WINBOOL{.
      stdcall, dynlib: "gdi32", importc: "UpdateICMRegKeyW".}
  proc EnumICMProfiles*(para1: HDC, para2: ICMENUMPROC, para3: LPARAM): int32{.
      stdcall, dynlib: "gdi32", importc: "EnumICMProfilesW".}
  proc CreatePropertySheetPage*(lppsp: LPCPROPSHEETPAGE): HPROPSHEETPAGE{.
      stdcall, dynlib: "comctl32", importc: "CreatePropertySheetPageW".}
  proc PropertySheet*(lppsph: LPCPROPSHEETHEADER): int32{.stdcall,
      dynlib: "comctl32", importc: "PropertySheetW".}
  proc ImageList_LoadImage*(hi: HINST, lpbmp: LPCWSTR, cx: int32, cGrow: int32,
                            crMask: COLORREF, uType: UINT, uFlags: UINT): HIMAGELIST{.
      stdcall, dynlib: "comctl32", importc: "ImageList_LoadImageW".}
  proc CreateStatusWindow*(style: LONG, lpszText: LPCWSTR, hwndParent: HWND,
                           wID: UINT): HWND{.stdcall, dynlib: "comctl32",
      importc: "CreateStatusWindowW".}
  proc DrawStatusText*(hDC: HDC, lprc: LPRECT, pszText: LPCWSTR, uFlags: UINT){.
      stdcall, dynlib: "comctl32", importc: "DrawStatusTextW".}
  proc GetOpenFileName*(para1: LPOPENFILENAME): WINBOOL{.stdcall,
      dynlib: "comdlg32", importc: "GetOpenFileNameW".}
  proc GetSaveFileName*(para1: LPOPENFILENAME): WINBOOL{.stdcall,
      dynlib: "comdlg32", importc: "GetSaveFileNameW".}
  proc GetFileTitle*(para1: LPCWSTR, para2: LPWSTR, para3: int16): int{.stdcall,
      dynlib: "comdlg32", importc: "GetFileTitleW".}
  proc ChooseColor*(para1: LPCHOOSECOLOR): WINBOOL{.stdcall, dynlib: "comdlg32",
      importc: "ChooseColorW".}
  proc ReplaceText*(para1: LPFINDREPLACE): HWND{.stdcall, dynlib: "comdlg32",
      importc: "ReplaceTextW".}
  proc ChooseFont*(para1: LPCHOOSEFONT): WINBOOL{.stdcall, dynlib: "comdlg32",
      importc: "ChooseFontW".}
  proc FindText*(para1: LPFINDREPLACE): HWND{.stdcall, dynlib: "comdlg32",
      importc: "FindTextW".}
  proc PrintDlg*(para1: LPPRINTDLG): WINBOOL{.stdcall, dynlib: "comdlg32",
      importc: "PrintDlgW".}
  proc PageSetupDlg*(para1: LPPAGESETUPDLG): WINBOOL{.stdcall,
      dynlib: "comdlg32", importc: "PageSetupDlgW".}
  proc CreateProcess*(lpApplicationName: LPCWSTR, lpCommandLine: LPWSTR,
                      lpProcessAttributes: LPSECURITY_ATTRIBUTES,
                      lpThreadAttributes: LPSECURITY_ATTRIBUTES,
                      bInheritHandles: WINBOOL, dwCreationFlags: DWORD,
                      lpEnvironment: LPVOID, lpCurrentDirectory: LPCWSTR,
                      lpStartupInfo: LPSTARTUPINFO,
                      lpProcessInformation: LPPROCESS_INFORMATION): WINBOOL{.
      stdcall, dynlib: "kernel32", importc: "CreateProcessW".}
  proc GetStartupInfo*(lpStartupInfo: LPSTARTUPINFO){.stdcall,
      dynlib: "kernel32", importc: "GetStartupInfoW".}
  proc FindFirstFile*(lpFileName: LPCWSTR, lpFindFileData: LPWIN32_FIND_DATA): HANDLE{.
      stdcall, dynlib: "kernel32", importc: "FindFirstFileW".}
  proc FindNextFile*(hFindFile: HANDLE, lpFindFileData: LPWIN32_FIND_DATA): WINBOOL{.
      stdcall, dynlib: "kernel32", importc: "FindNextFileW".}
  proc GetVersionEx*(VersionInformation: LPOSVERSIONINFOW): WINBOOL{.stdcall,
      dynlib: "kernel32", importc: "GetVersionExW".}
  proc GetVersionExW*(VersionInformation: LPOSVERSIONINFOW): WINBOOL{.stdcall,
      dynlib: "kernel32", importc: "GetVersionExW".}
  proc CreateWindow*(lpClassName: LPCWSTR, lpWindowName: LPCWSTR,
                     dwStyle: DWORD, X: int32, Y: int32, nWidth: int32,
                     nHeight: int32, hWndParent: HWND, menu: HMENU,
                     hInstance: HINST, lpParam: LPVOID): HWND
  proc CreateDialog*(hInstance: HINST, lpName: LPCWSTR, hWndParent: HWND,
                     lpDialogFunc: DLGPROC): HWND
  proc CreateDialogIndirect*(hInstance: HINST, lpTemplate: LPCDLGTEMPLATE,
                             hWndParent: HWND, lpDialogFunc: DLGPROC): HWND
  proc DialogBox*(hInstance: HINST, lpTemplate: LPCWSTR, hWndParent: HWND,
                  lpDialogFunc: DLGPROC): int32
  proc DialogBoxIndirect*(hInstance: HINST, lpTemplate: LPCDLGTEMPLATE,
                          hWndParent: HWND, lpDialogFunc: DLGPROC): int32
  proc CreateDC*(para1: LPCWSTR, para2: LPCWSTR, para3: LPCWSTR, para4: pDEVMODE): HDC{.
      stdcall, dynlib: "gdi32", importc: "CreateDCW".}
  proc VerInstallFile*(uFlags: DWORD, szSrcFileName: LPWSTR,
                       szDestFileName: LPWSTR, szSrcDir: LPWSTR,
                       szDestDir: LPWSTR, szCurDir: LPWSTR, szTmpFile: LPWSTR,
                       lpuTmpFileLen: PUINT): DWORD{.stdcall, dynlib: "version",
      importc: "VerInstallFileW".}
  proc GetFileVersionInfoSize*(lptstrFilename: LPWSTR, lpdwHandle: LPDWORD): DWORD{.
      stdcall, dynlib: "version", importc: "GetFileVersionInfoSizeW".}
  proc GetFileVersionInfo*(lptstrFilename: LPWSTR, dwHandle: DWORD,
                           dwLen: DWORD, lpData: LPVOID): WINBOOL{.stdcall,
      dynlib: "version", importc: "GetFileVersionInfoW".}
  proc VerLanguageName*(wLang: DWORD, szLang: LPWSTR, nSize: DWORD): DWORD{.
      stdcall, dynlib: "kernel32", importc: "VerLanguageNameW".}
  proc VerQueryValue*(pBlock: LPVOID, lpSubBlock: LPWSTR, lplpBuffer: LPVOID,
                      puLen: PUINT): WINBOOL{.stdcall, dynlib: "version",
      importc: "VerQueryValueW".}
  proc VerFindFile*(uFlags: DWORD, szFileName: LPWSTR, szWinDir: LPWSTR,
                    szAppDir: LPWSTR, szCurDir: LPWSTR, lpuCurDirLen: PUINT,
                    szDestDir: LPWSTR, lpuDestDirLen: PUINT): DWORD{.stdcall,
      dynlib: "version", importc: "VerFindFileW".}
  proc RegSetValueEx*(key: HKEY, lpValueName: LPCWSTR, Reserved: DWORD,
                      dwType: DWORD, lpData: LPBYTE, cbData: DWORD): LONG{.
      stdcall, dynlib: "advapi32", importc: "RegSetValueExW".}
  proc RegUnLoadKey*(key: HKEY, lpSubKey: LPCWSTR): LONG{.stdcall,
      dynlib: "advapi32", importc: "RegUnLoadKeyW".}
  proc InitiateSystemShutdown*(lpMachineName: LPWSTR, lpMessage: LPWSTR,
                               dwTimeout: DWORD, bForceAppsClosed: WINBOOL,
                               bRebootAfterShutdown: WINBOOL): WINBOOL{.stdcall,
      dynlib: "advapi32", importc: "InitiateSystemShutdownW".}
  proc AbortSystemShutdown*(lpMachineName: LPWSTR): WINBOOL{.stdcall,
      dynlib: "advapi32", importc: "AbortSystemShutdownW".}
  proc RegRestoreKey*(key: HKEY, lpFile: LPCWSTR, dwFlags: DWORD): LONG{.
      stdcall, dynlib: "advapi32", importc: "RegRestoreKeyW".}
  proc RegSaveKey*(key: HKEY, lpFile: LPCWSTR,
                   lpSecurityAttributes: LPSECURITY_ATTRIBUTES): LONG{.stdcall,
      dynlib: "advapi32", importc: "RegSaveKeyW".}
  proc RegSetValue*(key: HKEY, lpSubKey: LPCWSTR, dwType: DWORD,
                    lpData: LPCWSTR, cbData: DWORD): LONG{.stdcall,
      dynlib: "advapi32", importc: "RegSetValueW".}
  proc RegQueryValue*(key: HKEY, lpSubKey: LPCWSTR, lpValue: LPWSTR,
                      lpcbValue: PLONG): LONG{.stdcall, dynlib: "advapi32",
      importc: "RegQueryValueW".}
  proc RegQueryMultipleValues*(key: HKEY, val_list: PVALENT, num_vals: DWORD,
                               lpValueBuf: LPWSTR, ldwTotsize: LPDWORD): LONG{.
      stdcall, dynlib: "advapi32", importc: "RegQueryMultipleValuesW".}
  proc RegQueryValueEx*(key: HKEY, lpValueName: LPCWSTR, lpReserved: LPDWORD,
                        lpType: LPDWORD, lpData: LPBYTE, lpcbData: LPDWORD): LONG{.
      stdcall, dynlib: "advapi32", importc: "RegQueryValueExW".}
  proc RegReplaceKey*(key: HKEY, lpSubKey: LPCWSTR, lpNewFile: LPCWSTR,
                      lpOldFile: LPCWSTR): LONG{.stdcall, dynlib: "advapi32",
      importc: "RegReplaceKeyW".}
  proc RegConnectRegistry*(lpMachineName: LPWSTR, key: HKEY, phkResult: PHKEY): LONG{.
      stdcall, dynlib: "advapi32", importc: "RegConnectRegistryW".}
  proc RegCreateKey*(key: HKEY, lpSubKey: LPCWSTR, phkResult: PHKEY): LONG{.
      stdcall, dynlib: "advapi32", importc: "RegCreateKeyW".}
  proc RegCreateKeyEx*(key: HKEY, lpSubKey: LPCWSTR, Reserved: DWORD,
                       lpClass: LPWSTR, dwOptions: DWORD, samDesired: REGSAM,
                       lpSecurityAttributes: LPSECURITY_ATTRIBUTES,
                       phkResult: PHKEY, lpdwDisposition: LPDWORD): LONG{.
      stdcall, dynlib: "advapi32", importc: "RegCreateKeyExW".}
  proc RegDeleteKey*(key: HKEY, lpSubKey: LPCWSTR): LONG{.stdcall,
      dynlib: "advapi32", importc: "RegDeleteKeyW".}
  proc RegDeleteValue*(key: HKEY, lpValueName: LPCWSTR): LONG{.stdcall,
      dynlib: "advapi32", importc: "RegDeleteValueW".}
  proc RegEnumKey*(key: HKEY, dwIndex: DWORD, lpName: LPWSTR, cbName: DWORD): LONG{.
      stdcall, dynlib: "advapi32", importc: "RegEnumKeyW".}
  proc RegEnumKeyEx*(key: HKEY, dwIndex: DWORD, lpName: LPWSTR,
                     lpcbName: LPDWORD, lpReserved: LPDWORD, lpClass: LPWSTR,
                     lpcbClass: LPDWORD, lpftLastWriteTime: PFILETIME): LONG{.
      stdcall, dynlib: "advapi32", importc: "RegEnumKeyExW".}
  proc RegEnumValue*(key: HKEY, dwIndex: DWORD, lpValueName: LPWSTR,
                     lpcbValueName: LPDWORD, lpReserved: LPDWORD,
                     lpType: LPDWORD, lpData: LPBYTE, lpcbData: LPDWORD): LONG{.
      stdcall, dynlib: "advapi32", importc: "RegEnumValueW".}
  proc RegLoadKey*(key: HKEY, lpSubKey: LPCWSTR, lpFile: LPCWSTR): LONG{.
      stdcall, dynlib: "advapi32", importc: "RegLoadKeyW".}
  proc RegOpenKey*(key: HKEY, lpSubKey: LPCWSTR, phkResult: PHKEY): LONG{.
      stdcall, dynlib: "advapi32", importc: "RegOpenKeyW".}
  proc RegOpenKeyEx*(key: HKEY, lpSubKey: LPCWSTR, ulOptions: DWORD,
                     samDesired: REGSAM, phkResult: PHKEY): LONG{.stdcall,
      dynlib: "advapi32", importc: "RegOpenKeyExW".}
  proc RegQueryInfoKey*(key: HKEY, lpClass: LPWSTR, lpcbClass: LPDWORD,
                        lpReserved: LPDWORD, lpcSubKeys: LPDWORD,
                        lpcbMaxSubKeyLen: LPDWORD, lpcbMaxClassLen: LPDWORD,
                        lpcValues: LPDWORD, lpcbMaxValueNameLen: LPDWORD,
                        lpcbMaxValueLen: LPDWORD,
                        lpcbSecurityDescriptor: LPDWORD,
                        lpftLastWriteTime: PFILETIME): LONG{.stdcall,
      dynlib: "advapi32", importc: "RegQueryInfoKeyW".}
  proc CompareString*(Locale: LCID, dwCmpFlags: DWORD, lpString1: LPCWSTR,
                      cchCount1: int32, lpString2: LPCWSTR, cchCount2: int32): int32{.
      stdcall, dynlib: "kernel32", importc: "CompareStringW".}
  proc LCMapString*(Locale: LCID, dwMapFlags: DWORD, lpSrcStr: LPCWSTR,
                    cchSrc: int32, lpDestStr: LPWSTR, cchDest: int32): int32{.
      stdcall, dynlib: "kernel32", importc: "LCMapStringW".}
  proc GetLocaleInfo*(Locale: LCID, LCType: LCTYPE, lpLCData: LPWSTR,
                      cchData: int32): int32{.stdcall, dynlib: "kernel32",
      importc: "GetLocaleInfoW".}
  proc SetLocaleInfo*(Locale: LCID, LCType: LCTYPE, lpLCData: LPCWSTR): WINBOOL{.
      stdcall, dynlib: "kernel32", importc: "SetLocaleInfoW".}
  proc GetTimeFormat*(Locale: LCID, dwFlags: DWORD, lpTime: LPSYSTEMTIME,
                      lpFormat: LPCWSTR, lpTimeStr: LPWSTR, cchTime: int32): int32{.
      stdcall, dynlib: "kernel32", importc: "GetTimeFormatW".}
  proc GetDateFormat*(Locale: LCID, dwFlags: DWORD, lpDate: LPSYSTEMTIME,
                      lpFormat: LPCWSTR, lpDateStr: LPWSTR, cchDate: int32): int32{.
      stdcall, dynlib: "kernel32", importc: "GetDateFormatW".}
  proc GetNumberFormat*(Locale: LCID, dwFlags: DWORD, lpValue: LPCWSTR,
                        lpFormat: PNUMBERFMT, lpNumberStr: LPWSTR,
                        cchNumber: int32): int32{.stdcall, dynlib: "kernel32",
      importc: "GetNumberFormatW".}
  proc GetCurrencyFormat*(Locale: LCID, dwFlags: DWORD, lpValue: LPCWSTR,
                          lpFormat: PCURRENCYFMT, lpCurrencyStr: LPWSTR,
                          cchCurrency: int32): int32{.stdcall,
      dynlib: "kernel32", importc: "GetCurrencyFormatW".}
  proc EnumCalendarInfo*(lpCalInfoEnumProc: CALINFO_ENUMPROC, Locale: LCID,
                         Calendar: CALID, CalType: CALTYPE): WINBOOL{.stdcall,
      dynlib: "kernel32", importc: "EnumCalendarInfoW".}
  proc EnumTimeFormats*(lpTimeFmtEnumProc: TIMEFMT_ENUMPROC, Locale: LCID,
                        dwFlags: DWORD): WINBOOL{.stdcall, dynlib: "kernel32",
      importc: "EnumTimeFormatsW".}
  proc EnumDateFormats*(lpDateFmtEnumProc: DATEFMT_ENUMPROC, Locale: LCID,
                        dwFlags: DWORD): WINBOOL{.stdcall, dynlib: "kernel32",
      importc: "EnumDateFormatsW".}
  proc GetStringTypeEx*(Locale: LCID, dwInfoType: DWORD, lpSrcStr: LPCWSTR,
                        cchSrc: int32, lpCharType: LPWORD): WINBOOL{.stdcall,
      dynlib: "kernel32", importc: "GetStringTypeExW".}
  proc GetStringType*(dwInfoType: DWORD, lpSrcStr: LPCWSTR, cchSrc: int32,
                      lpCharType: LPWORD): WINBOOL{.stdcall, dynlib: "kernel32",
      importc: "GetStringTypeW".}
  proc FoldString*(dwMapFlags: DWORD, lpSrcStr: LPCWSTR, cchSrc: int32,
                   lpDestStr: LPWSTR, cchDest: int32): int32{.stdcall,
      dynlib: "kernel32", importc: "FoldStringW".}
  proc EnumSystemLocales*(lpLocaleEnumProc: LOCALE_ENUMPROC, dwFlags: DWORD): WINBOOL{.
      stdcall, dynlib: "kernel32", importc: "EnumSystemLocalesW".}
  proc EnumSystemCodePages*(lpCodePageEnumProc: CODEPAGE_ENUMPROC,
                            dwFlags: DWORD): WINBOOL{.stdcall,
      dynlib: "kernel32", importc: "EnumSystemCodePagesW".}
  proc PeekConsoleInput*(hConsoleInput: HANDLE, lpBuffer: PINPUTRECORD,
                         nLength: DWORD, lpNumberOfEventsRead: LPDWORD): WINBOOL{.
      stdcall, dynlib: "kernel32", importc: "PeekConsoleInputW".}
  proc ReadConsoleInput*(hConsoleInput: HANDLE, lpBuffer: PINPUTRECORD,
                         nLength: DWORD, lpNumberOfEventsRead: LPDWORD): WINBOOL{.
      stdcall, dynlib: "kernel32", importc: "ReadConsoleInputW".}
  proc WriteConsoleInput*(hConsoleInput: HANDLE, lpBuffer: PINPUTRECORD,
                          nLength: DWORD, lpNumberOfEventsWritten: LPDWORD): WINBOOL{.
      stdcall, dynlib: "kernel32", importc: "WriteConsoleInputW".}
  proc ReadConsoleOutput*(hConsoleOutput: HANDLE, lpBuffer: PCHAR_INFO,
                          dwBufferSize: COORD, dwBufferCoord: COORD,
                          lpReadRegion: PSMALL_RECT): WINBOOL{.stdcall,
      dynlib: "kernel32", importc: "ReadConsoleOutputW".}
  proc WriteConsoleOutput*(hConsoleOutput: HANDLE, lpBuffer: PCHAR_INFO,
                           dwBufferSize: COORD, dwBufferCoord: COORD,
                           lpWriteRegion: PSMALL_RECT): WINBOOL{.stdcall,
      dynlib: "kernel32", importc: "WriteConsoleOutputW".}
  proc ReadConsoleOutputCharacter*(hConsoleOutput: HANDLE, lpCharacter: LPWSTR,
                                   nLength: DWORD, dwReadCoord: COORD,
                                   lpNumberOfCharsRead: LPDWORD): WINBOOL{.
      stdcall, dynlib: "kernel32", importc: "ReadConsoleOutputCharacterW".}
  proc WriteConsoleOutputCharacter*(hConsoleOutput: HANDLE,
                                    lpCharacter: LPCWSTR, nLength: DWORD,
                                    dwWriteCoord: COORD,
                                    lpNumberOfCharsWritten: LPDWORD): WINBOOL{.
      stdcall, dynlib: "kernel32", importc: "WriteConsoleOutputCharacterW".}
  proc FillConsoleOutputCharacter*(hConsoleOutput: HANDLE, cCharacter: WCHAR,
                                   nLength: DWORD, dwWriteCoord: COORD,
                                   lpNumberOfCharsWritten: LPDWORD): WINBOOL{.
      stdcall, dynlib: "kernel32", importc: "FillConsoleOutputCharacterW".}
  proc ScrollConsoleScreenBuffer*(hConsoleOutput: HANDLE,
                                  lpScrollRectangle: PSMALL_RECT,
                                  lpClipRectangle: PSMALL_RECT,
                                  dwDestinationOrigin: COORD, lpFill: PCHAR_INFO): WINBOOL{.
      stdcall, dynlib: "kernel32", importc: "ScrollConsoleScreenBufferW".}
  proc GetConsoleTitle*(lpConsoleTitle: LPWSTR, nSize: DWORD): DWORD{.stdcall,
      dynlib: "kernel32", importc: "GetConsoleTitleW".}
  proc SetConsoleTitle*(lpConsoleTitle: LPCWSTR): WINBOOL{.stdcall,
      dynlib: "kernel32", importc: "SetConsoleTitleW".}
  proc ReadConsole*(hConsoleInput: HANDLE, lpBuffer: LPVOID,
                    nNumberOfCharsToRead: DWORD, lpNumberOfCharsRead: LPDWORD,
                    lpReserved: LPVOID): WINBOOL{.stdcall, dynlib: "kernel32",
      importc: "ReadConsoleW".}
  proc WriteConsole*(hConsoleOutput: HANDLE, lpBuffer: pointer,
                     nNumberOfCharsToWrite: DWORD,
                     lpNumberOfCharsWritten: LPDWORD, lpReserved: LPVOID): WINBOOL{.
      stdcall, dynlib: "kernel32", importc: "WriteConsoleW".}
  proc WNetAddConnection*(lpRemoteName: LPCWSTR, lpPassword: LPCWSTR,
                          lpLocalName: LPCWSTR): DWORD{.stdcall, dynlib: "mpr",
      importc: "WNetAddConnectionW".}
  proc WNetAddConnection2*(lpNetResource: LPNETRESOURCE, lpPassword: LPCWSTR,
                           lpUserName: LPCWSTR, dwFlags: DWORD): DWORD{.stdcall,
      dynlib: "mpr", importc: "WNetAddConnection2W".}
  proc WNetAddConnection3*(hwndOwner: HWND, lpNetResource: LPNETRESOURCE,
                           lpPassword: LPCWSTR, lpUserName: LPCWSTR,
                           dwFlags: DWORD): DWORD{.stdcall, dynlib: "mpr",
      importc: "WNetAddConnection3W".}
  proc WNetCancelConnection*(lpName: LPCWSTR, fForce: WINBOOL): DWORD{.stdcall,
      dynlib: "mpr", importc: "WNetCancelConnectionW".}
  proc WNetCancelConnection2*(lpName: LPCWSTR, dwFlags: DWORD, fForce: WINBOOL): DWORD{.
      stdcall, dynlib: "mpr", importc: "WNetCancelConnection2W".}
  proc WNetGetConnection*(lpLocalName: LPCWSTR, lpRemoteName: LPWSTR,
                          lpnLength: LPDWORD): DWORD{.stdcall, dynlib: "mpr",
      importc: "WNetGetConnectionW".}
  proc WNetUseConnection*(hwndOwner: HWND, lpNetResource: LPNETRESOURCE,
                          lpUserID: LPCWSTR, lpPassword: LPCWSTR,
                          dwFlags: DWORD, lpAccessName: LPWSTR,
                          lpBufferSize: LPDWORD, lpResult: LPDWORD): DWORD{.
      stdcall, dynlib: "mpr", importc: "WNetUseConnectionW".}
  proc WNetSetConnection*(lpName: LPCWSTR, dwProperties: DWORD, pvValues: LPVOID): DWORD{.
      stdcall, dynlib: "mpr", importc: "WNetSetConnectionW".}
  proc WNetConnectionDialog1*(lpConnDlgStruct: LPCONNECTDLGSTRUCT): DWORD{.
      stdcall, dynlib: "mpr", importc: "WNetConnectionDialog1W".}
  proc WNetDisconnectDialog1*(lpConnDlgStruct: LPDISCDLGSTRUCT): DWORD{.stdcall,
      dynlib: "mpr", importc: "WNetDisconnectDialog1W".}
  proc WNetOpenEnum*(dwScope: DWORD, dwType: DWORD, dwUsage: DWORD,
                     lpNetResource: LPNETRESOURCE, lphEnum: LPHANDLE): DWORD{.
      stdcall, dynlib: "mpr", importc: "WNetOpenEnumW".}
  proc WNetEnumResource*(hEnum: HANDLE, lpcCount: LPDWORD, lpBuffer: LPVOID,
                         lpBufferSize: LPDWORD): DWORD{.stdcall, dynlib: "mpr",
      importc: "WNetEnumResourceW".}
  proc WNetGetUniversalName*(lpLocalPath: LPCWSTR, dwInfoLevel: DWORD,
                             lpBuffer: LPVOID, lpBufferSize: LPDWORD): DWORD{.
      stdcall, dynlib: "mpr", importc: "WNetGetUniversalNameW".}
  proc WNetGetUser*(lpName: LPCWSTR, lpUserName: LPWSTR, lpnLength: LPDWORD): DWORD{.
      stdcall, dynlib: "mpr", importc: "WNetGetUserW".}
  proc WNetGetProviderName*(dwNetType: DWORD, lpProviderName: LPWSTR,
                            lpBufferSize: LPDWORD): DWORD{.stdcall,
      dynlib: "mpr", importc: "WNetGetProviderNameW".}
  proc WNetGetNetworkInformation*(lpProvider: LPCWSTR,
                                  lpNetInfoStruct: LPNETINFOSTRUCT): DWORD{.
      stdcall, dynlib: "mpr", importc: "WNetGetNetworkInformationW".}
  proc WNetGetLastError*(lpError: LPDWORD, lpErrorBuf: LPWSTR,
                         nErrorBufSize: DWORD, lpNameBuf: LPWSTR,
                         nNameBufSize: DWORD): DWORD{.stdcall, dynlib: "mpr",
      importc: "WNetGetLastErrorW".}
  proc MultinetGetConnectionPerformance*(lpNetResource: LPNETRESOURCE,
      lpNetConnectInfoStruct: LPNETCONNECTINFOSTRUCT): DWORD{.stdcall,
      dynlib: "mpr", importc: "MultinetGetConnectionPerformanceW".}
  proc ChangeServiceConfig*(hService: SC_HANDLE, dwServiceType: DWORD,
                            dwStartType: DWORD, dwErrorControl: DWORD,
                            lpBinaryPathName: LPCWSTR,
                            lpLoadOrderGroup: LPCWSTR, lpdwTagId: LPDWORD,
                            lpDependencies: LPCWSTR,
                            lpServiceStartName: LPCWSTR, lpPassword: LPCWSTR,
                            lpDisplayName: LPCWSTR): WINBOOL{.stdcall,
      dynlib: "advapi32", importc: "ChangeServiceConfigW".}
  proc CreateService*(hSCManager: SC_HANDLE, lpServiceName: LPCWSTR,
                      lpDisplayName: LPCWSTR, dwDesiredAccess: DWORD,
                      dwServiceType: DWORD, dwStartType: DWORD,
                      dwErrorControl: DWORD, lpBinaryPathName: LPCWSTR,
                      lpLoadOrderGroup: LPCWSTR, lpdwTagId: LPDWORD,
                      lpDependencies: LPCWSTR, lpServiceStartName: LPCWSTR,
                      lpPassword: LPCWSTR): SC_HANDLE{.stdcall,
      dynlib: "advapi32", importc: "CreateServiceW".}
  proc EnumDependentServices*(hService: SC_HANDLE, dwServiceState: DWORD,
                              lpServices: LPENUM_SERVICE_STATUS,
                              cbBufSize: DWORD, pcbBytesNeeded: LPDWORD,
                              lpServicesReturned: LPDWORD): WINBOOL{.stdcall,
      dynlib: "advapi32", importc: "EnumDependentServicesW".}
  proc EnumServicesStatus*(hSCManager: SC_HANDLE, dwServiceType: DWORD,
                           dwServiceState: DWORD,
                           lpServices: LPENUM_SERVICE_STATUS, cbBufSize: DWORD,
                           pcbBytesNeeded: LPDWORD, lpServicesReturned: LPDWORD,
                           lpResumeHandle: LPDWORD): WINBOOL{.stdcall,
      dynlib: "advapi32", importc: "EnumServicesStatusW".}
  proc GetServiceKeyName*(hSCManager: SC_HANDLE, lpDisplayName: LPCWSTR,
                          lpServiceName: LPWSTR, lpcchBuffer: LPDWORD): WINBOOL{.
      stdcall, dynlib: "advapi32", importc: "GetServiceKeyNameW".}
  proc GetServiceDisplayName*(hSCManager: SC_HANDLE, lpServiceName: LPCWSTR,
                              lpDisplayName: LPWSTR, lpcchBuffer: LPDWORD): WINBOOL{.
      stdcall, dynlib: "advapi32", importc: "GetServiceDisplayNameW".}
  proc OpenSCManager*(lpMachineName: LPCWSTR, lpDatabaseName: LPCWSTR,
                      dwDesiredAccess: DWORD): SC_HANDLE{.stdcall,
      dynlib: "advapi32", importc: "OpenSCManagerW".}
  proc OpenService*(hSCManager: SC_HANDLE, lpServiceName: LPCWSTR,
                    dwDesiredAccess: DWORD): SC_HANDLE{.stdcall,
      dynlib: "advapi32", importc: "OpenServiceW".}
  proc QueryServiceConfig*(hService: SC_HANDLE,
                           lpServiceConfig: LPQUERY_SERVICE_CONFIG,
                           cbBufSize: DWORD, pcbBytesNeeded: LPDWORD): WINBOOL{.
      stdcall, dynlib: "advapi32", importc: "QueryServiceConfigW".}
  proc QueryServiceLockStatus*(hSCManager: SC_HANDLE,
                               lpLockStatus: LPQUERY_SERVICE_LOCK_STATUS,
                               cbBufSize: DWORD, pcbBytesNeeded: LPDWORD): WINBOOL{.
      stdcall, dynlib: "advapi32", importc: "QueryServiceLockStatusW".}
  proc RegisterServiceCtrlHandler*(lpServiceName: LPCWSTR,
                                   lpHandlerProc: LPHANDLER_FUNCTION): SERVICE_STATUS_HANDLE{.
      stdcall, dynlib: "advapi32", importc: "RegisterServiceCtrlHandlerW".}
  proc StartServiceCtrlDispatcher*(lpServiceStartTable: LPSERVICE_TABLE_ENTRY): WINBOOL{.
      stdcall, dynlib: "advapi32", importc: "StartServiceCtrlDispatcherW".}
  proc StartService*(hService: SC_HANDLE, dwNumServiceArgs: DWORD,
                     lpServiceArgVectors: LPCWSTR): WINBOOL{.stdcall,
      dynlib: "advapi32", importc: "StartServiceW".}
  proc DragQueryFile*(para1: HDROP, para2: int, para3: LPCWSTR, para4: int): int{.
      stdcall, dynlib: "shell32", importc: "DragQueryFileW".}
  proc ExtractAssociatedIcon*(para1: HINST, para2: LPCWSTR, para3: LPWORD): HICON{.
      stdcall, dynlib: "shell32", importc: "ExtractAssociatedIconW".}
  proc ExtractIcon*(para1: HINST, para2: LPCWSTR, para3: int): HICON{.stdcall,
      dynlib: "shell32", importc: "ExtractIconW".}
  proc FindExecutable*(para1: LPCWSTR, para2: LPCWSTR, para3: LPCWSTR): HINST{.
      stdcall, dynlib: "shell32", importc: "FindExecutableW".}
  proc ShellAbout*(para1: HWND, para2: LPCWSTR, para3: LPCWSTR, para4: HICON): int32{.
      stdcall, dynlib: "shell32", importc: "ShellAboutW".}
  proc ShellExecute*(para1: HWND, para2: LPCWSTR, para3: LPCWSTR,
                     para4: LPCWSTR, para5: LPCWSTR, para6: int32): HINST{.
      stdcall, dynlib: "shell32", importc: "ShellExecuteW".}
  proc Shell_NotifyIcon*(dwMessage: DWORD, lpData: PNotifyIconDataA): WINBOOL{.
      stdcall, dynlib: "shell32", importc: "Shell_NotifyIconW".}
  proc DdeCreateStringHandle*(para1: DWORD, para2: LPCWSTR, para3: int32): HSZ{.
      stdcall, dynlib: "user32", importc: "DdeCreateStringHandleW".}
  proc DdeInitialize*(para1: LPDWORD, para2: PFNCALLBACK, para3: DWORD,
                      para4: DWORD): UINT{.stdcall, dynlib: "user32",
      importc: "DdeInitializeW".}
  proc DdeQueryString*(para1: DWORD, para2: HSZ, para3: LPCWSTR, para4: DWORD,
                       para5: int32): DWORD{.stdcall, dynlib: "user32",
      importc: "DdeQueryStringW".}
  proc LogonUser*(para1: LPWSTR, para2: LPWSTR, para3: LPWSTR, para4: DWORD,
                  para5: DWORD, para6: PHANDLE): WINBOOL{.stdcall,
      dynlib: "advapi32", importc: "LogonUserW".}
  proc CreateProcessAsUser*(para1: HANDLE, para2: LPCWSTR, para3: LPWSTR,
                            para4: LPSECURITY_ATTRIBUTES,
                            para5: LPSECURITY_ATTRIBUTES, para6: WINBOOL,
                            para7: DWORD, para8: LPVOID, para9: LPCWSTR,
                            para10: LPSTARTUPINFO, para11: LPPROCESS_INFORMATION): WINBOOL{.
      stdcall, dynlib: "advapi32", importc: "CreateProcessAsUserW".}
else:
  proc GetBinaryType*(lpApplicationName: LPCSTR, lpBinaryType: LPDWORD): WINBOOL{.
      stdcall, dynlib: "kernel32", importc: "GetBinaryTypeA".}
  proc GetShortPathName*(lpszLongPath: LPCSTR, lpszShortPath: LPSTR,
                         cchBuffer: DWORD): DWORD{.stdcall, dynlib: "kernel32",
      importc: "GetShortPathNameA".}
  proc GetEnvironmentStrings*(): LPSTR{.stdcall, dynlib: "kernel32",
                                        importc: "GetEnvironmentStringsA".}
  proc FreeEnvironmentStrings*(para1: LPSTR): WINBOOL{.stdcall,
      dynlib: "kernel32", importc: "FreeEnvironmentStringsA".}
  proc FormatMessage*(dwFlags: DWORD, lpSource: LPCVOID, dwMessageId: DWORD,
                      dwLanguageId: DWORD, lpBuffer: LPSTR, nSize: DWORD,
                      Arguments: va_list): DWORD{.stdcall, dynlib: "kernel32",
      importc: "FormatMessageA".}
  proc CreateMailslot*(lpName: LPCSTR, nMaxMessageSize: DWORD,
                       lReadTimeout: DWORD,
                       lpSecurityAttributes: LPSECURITY_ATTRIBUTES): HANDLE{.
      stdcall, dynlib: "kernel32", importc: "CreateMailslotA".}
  proc lstrcmp*(lpString1: LPCSTR, lpString2: LPCSTR): int32{.stdcall,
      dynlib: "kernel32", importc: "lstrcmpA".}
  proc lstrcmpi*(lpString1: LPCSTR, lpString2: LPCSTR): int32{.stdcall,
      dynlib: "kernel32", importc: "lstrcmpiA".}
  proc lstrcpyn*(lpString1: LPSTR, lpString2: LPCSTR, iMaxLength: int32): LPSTR{.
      stdcall, dynlib: "kernel32", importc: "lstrcpynA".}
  proc lstrcpy*(lpString1: LPSTR, lpString2: LPCSTR): LPSTR{.stdcall,
      dynlib: "kernel32", importc: "lstrcpyA".}
  proc lstrcat*(lpString1: LPSTR, lpString2: LPCSTR): LPSTR{.stdcall,
      dynlib: "kernel32", importc: "lstrcatA".}
  proc lstrlen*(lpString: LPCSTR): int32{.stdcall, dynlib: "kernel32",
      importc: "lstrlenA".}
  proc CreateMutex*(lpMutexAttributes: LPSECURITY_ATTRIBUTES,
                    bInitialOwner: WINBOOL, lpName: LPCSTR): HANDLE{.stdcall,
      dynlib: "kernel32", importc: "CreateMutexA".}
  proc OpenMutex*(dwDesiredAccess: DWORD, bInheritHandle: WINBOOL,
                  lpName: LPCSTR): HANDLE{.stdcall, dynlib: "kernel32",
      importc: "OpenMutexA".}
  proc CreateEvent*(lpEventAttributes: LPSECURITY_ATTRIBUTES,
                    bManualReset: WINBOOL, bInitialState: WINBOOL,
                    lpName: LPCSTR): HANDLE{.stdcall, dynlib: "kernel32",
      importc: "CreateEventA".}
  proc OpenEvent*(dwDesiredAccess: DWORD, bInheritHandle: WINBOOL,
                  lpName: LPCSTR): HANDLE{.stdcall, dynlib: "kernel32",
      importc: "OpenEventA".}
  proc CreateSemaphore*(lpSemaphoreAttributes: LPSECURITY_ATTRIBUTES,
                        lInitialCount: LONG, lMaximumCount: LONG, lpName: LPCSTR): HANDLE{.
      stdcall, dynlib: "kernel32", importc: "CreateSemaphoreA".}
  proc OpenSemaphore*(dwDesiredAccess: DWORD, bInheritHandle: WINBOOL,
                      lpName: LPCSTR): HANDLE{.stdcall, dynlib: "kernel32",
      importc: "OpenSemaphoreA".}
  proc CreateFileMapping*(hFile: HANDLE,
                          lpFileMappingAttributes: LPSECURITY_ATTRIBUTES,
                          flProtect: DWORD, dwMaximumSizeHigh: DWORD,
                          dwMaximumSizeLow: DWORD, lpName: LPCSTR): HANDLE{.
      stdcall, dynlib: "kernel32", importc: "CreateFileMappingA".}
  proc OpenFileMapping*(dwDesiredAccess: DWORD, bInheritHandle: WINBOOL,
                        lpName: LPCSTR): HANDLE{.stdcall, dynlib: "kernel32",
      importc: "OpenFileMappingA".}
  proc GetLogicalDriveStrings*(nBufferLength: DWORD, lpBuffer: LPSTR): DWORD{.
      stdcall, dynlib: "kernel32", importc: "GetLogicalDriveStringsA".}
  proc LoadLibrary*(lpLibFileName: LPCSTR): HINST{.stdcall, dynlib: "kernel32",
      importc: "LoadLibraryA".}
  proc LoadLibraryEx*(lpLibFileName: LPCSTR, hFile: HANDLE, dwFlags: DWORD): HINST{.
      stdcall, dynlib: "kernel32", importc: "LoadLibraryExA".}
  proc GetModuleFileName*(hModule: HINST, lpFilename: LPSTR, nSize: DWORD): DWORD{.
      stdcall, dynlib: "kernel32", importc: "GetModuleFileNameA".}
  proc GetModuleHandle*(lpModuleName: LPCSTR): HMODULE{.stdcall,
      dynlib: "kernel32", importc: "GetModuleHandleA".}
  proc FatalAppExit*(uAction: UINT, lpMessageText: LPCSTR){.stdcall,
      dynlib: "kernel32", importc: "FatalAppExitA".}
  proc GetCommandLine*(): LPSTR{.stdcall, dynlib: "kernel32",
                                 importc: "GetCommandLineA".}
  proc GetEnvironmentVariable*(lpName: LPCSTR, lpBuffer: LPSTR, nSize: DWORD): DWORD{.
      stdcall, dynlib: "kernel32", importc: "GetEnvironmentVariableA".}
  proc SetEnvironmentVariable*(lpName: LPCSTR, lpValue: LPCSTR): WINBOOL{.
      stdcall, dynlib: "kernel32", importc: "SetEnvironmentVariableA".}
  proc ExpandEnvironmentStrings*(lpSrc: LPCSTR, lpDst: LPSTR, nSize: DWORD): DWORD{.
      stdcall, dynlib: "kernel32", importc: "ExpandEnvironmentStringsA".}
  proc OutputDebugString*(lpOutputString: LPCSTR){.stdcall, dynlib: "kernel32",
      importc: "OutputDebugStringA".}
  proc FindResource*(hModule: HINST, lpName: LPCSTR, lpType: LPCSTR): HRSRC{.
      stdcall, dynlib: "kernel32", importc: "FindResourceA".}
  proc FindResourceEx*(hModule: HINST, lpType: LPCSTR, lpName: LPCSTR,
                       wLanguage: int16): HRSRC{.stdcall, dynlib: "kernel32",
      importc: "FindResourceExA".}
  proc EnumResourceTypes*(hModule: HINST, lpEnumFunc: ENUMRESTYPEPROC,
                          lParam: LONG): WINBOOL{.stdcall, dynlib: "kernel32",
      importc: "EnumResourceTypesA".}
  proc EnumResourceNames*(hModule: HINST, lpType: LPCSTR,
                          lpEnumFunc: ENUMRESNAMEPROC, lParam: LONG): WINBOOL{.
      stdcall, dynlib: "kernel32", importc: "EnumResourceNamesA".}
  proc EnumResourceLanguages*(hModule: HINST, lpType: LPCSTR, lpName: LPCSTR,
                              lpEnumFunc: ENUMRESLANGPROC, lParam: LONG): WINBOOL{.
      stdcall, dynlib: "kernel32", importc: "EnumResourceLanguagesA".}
  proc BeginUpdateResource*(pFileName: LPCSTR, bDeleteExistingResources: WINBOOL): HANDLE{.
      stdcall, dynlib: "kernel32", importc: "BeginUpdateResourceA".}
  proc UpdateResource*(hUpdate: HANDLE, lpType: LPCSTR, lpName: LPCSTR,
                       wLanguage: int16, lpData: LPVOID, cbData: DWORD): WINBOOL{.
      stdcall, dynlib: "kernel32", importc: "UpdateResourceA".}
  proc EndUpdateResource*(hUpdate: HANDLE, fDiscard: WINBOOL): WINBOOL{.stdcall,
      dynlib: "kernel32", importc: "EndUpdateResourceA".}
  proc GlobalAddAtom*(lpString: LPCSTR): ATOM{.stdcall, dynlib: "kernel32",
      importc: "GlobalAddAtomA".}
  proc GlobalFindAtom*(lpString: LPCSTR): ATOM{.stdcall, dynlib: "kernel32",
      importc: "GlobalFindAtomA".}
  proc GlobalGetAtomName*(nAtom: ATOM, lpBuffer: LPSTR, nSize: int32): UINT{.
      stdcall, dynlib: "kernel32", importc: "GlobalGetAtomNameA".}
  proc AddAtom*(lpString: LPCSTR): ATOM{.stdcall, dynlib: "kernel32",
      importc: "AddAtomA".}
  proc FindAtom*(lpString: LPCSTR): ATOM{.stdcall, dynlib: "kernel32",
      importc: "FindAtomA".}
  proc GetAtomName*(nAtom: ATOM, lpBuffer: LPSTR, nSize: int32): UINT{.stdcall,
      dynlib: "kernel32", importc: "GetAtomNameA".}
  proc GetProfileInt*(lpAppName: LPCSTR, lpKeyName: LPCSTR, nDefault: WINT): UINT{.
      stdcall, dynlib: "kernel32", importc: "GetProfileIntA".}
  proc GetProfileString*(lpAppName: LPCSTR, lpKeyName: LPCSTR,
                         lpDefault: LPCSTR, lpReturnedString: LPSTR,
                         nSize: DWORD): DWORD{.stdcall, dynlib: "kernel32",
      importc: "GetProfileStringA".}
  proc WriteProfileString*(lpAppName: LPCSTR, lpKeyName: LPCSTR,
                           lpString: LPCSTR): WINBOOL{.stdcall,
      dynlib: "kernel32", importc: "WriteProfileStringA".}
  proc GetProfileSection*(lpAppName: LPCSTR, lpReturnedString: LPSTR,
                          nSize: DWORD): DWORD{.stdcall, dynlib: "kernel32",
      importc: "GetProfileSectionA".}
  proc WriteProfileSection*(lpAppName: LPCSTR, lpString: LPCSTR): WINBOOL{.
      stdcall, dynlib: "kernel32", importc: "WriteProfileSectionA".}
  proc GetPrivateProfileInt*(lpAppName: LPCSTR, lpKeyName: LPCSTR,
                             nDefault: WINT, lpFileName: LPCSTR): UINT{.stdcall,
      dynlib: "kernel32", importc: "GetPrivateProfileIntA".}
  proc GetPrivateProfileString*(lpAppName: LPCSTR, lpKeyName: LPCSTR,
                                lpDefault: LPCSTR, lpReturnedString: LPSTR,
                                nSize: DWORD, lpFileName: LPCSTR): DWORD{.
      stdcall, dynlib: "kernel32", importc: "GetPrivateProfileStringA".}
  proc WritePrivateProfileString*(lpAppName: LPCSTR, lpKeyName: LPCSTR,
                                  lpString: LPCSTR, lpFileName: LPCSTR): WINBOOL{.
      stdcall, dynlib: "kernel32", importc: "WritePrivateProfileStringA".}
  proc GetPrivateProfileSection*(lpAppName: LPCSTR, lpReturnedString: LPSTR,
                                 nSize: DWORD, lpFileName: LPCSTR): DWORD{.
      stdcall, dynlib: "kernel32", importc: "GetPrivateProfileSectionA".}
  proc WritePrivateProfileSection*(lpAppName: LPCSTR, lpString: LPCSTR,
                                   lpFileName: LPCSTR): WINBOOL{.stdcall,
      dynlib: "kernel32", importc: "WritePrivateProfileSectionA".}
  proc GetDriveType*(lpRootPathName: LPCSTR): UINT{.stdcall, dynlib: "kernel32",
      importc: "GetDriveTypeA".}
  proc GetSystemDirectory*(lpBuffer: LPSTR, uSize: UINT): UINT{.stdcall,
      dynlib: "kernel32", importc: "GetSystemDirectoryA".}
  proc GetTempPath*(nBufferLength: DWORD, lpBuffer: LPSTR): DWORD{.stdcall,
      dynlib: "kernel32", importc: "GetTempPathA".}
  proc GetTempFileName*(lpPathName: LPCSTR, lpPrefixString: LPCSTR,
                        uUnique: UINT, lpTempFileName: LPSTR): UINT{.stdcall,
      dynlib: "kernel32", importc: "GetTempFileNameA".}
  proc GetWindowsDirectory*(lpBuffer: LPSTR, uSize: UINT): UINT{.stdcall,
      dynlib: "kernel32", importc: "GetWindowsDirectoryA".}
  proc SetCurrentDirectory*(lpPathName: LPCSTR): WINBOOL{.stdcall,
      dynlib: "kernel32", importc: "SetCurrentDirectoryA".}
  proc GetCurrentDirectory*(nBufferLength: DWORD, lpBuffer: LPSTR): DWORD{.
      stdcall, dynlib: "kernel32", importc: "GetCurrentDirectoryA".}
  proc GetDiskFreeSpace*(lpRootPathName: LPCSTR, lpSectorsPerCluster: LPDWORD,
                         lpBytesPerSector: LPDWORD,
                         lpNumberOfFreeClusters: LPDWORD,
                         lpTotalNumberOfClusters: LPDWORD): WINBOOL{.stdcall,
      dynlib: "kernel32", importc: "GetDiskFreeSpaceA".}
  proc CreateDirectory*(lpPathName: LPCSTR,
                        lpSecurityAttributes: LPSECURITY_ATTRIBUTES): WINBOOL{.
      stdcall, dynlib: "kernel32", importc: "CreateDirectoryA".}
  proc CreateDirectoryEx*(lpTemplateDirectory: LPCSTR, lpNewDirectory: LPCSTR,
                          lpSecurityAttributes: LPSECURITY_ATTRIBUTES): WINBOOL{.
      stdcall, dynlib: "kernel32", importc: "CreateDirectoryExA".}
  proc RemoveDirectory*(lpPathName: LPCSTR): WINBOOL{.stdcall,
      dynlib: "kernel32", importc: "RemoveDirectoryA".}
  proc GetFullPathName*(lpFileName: LPCSTR, nBufferLength: DWORD,
                        lpBuffer: LPSTR, lpFilePart: var LPSTR): DWORD{.stdcall,
      dynlib: "kernel32", importc: "GetFullPathNameA".}
  proc DefineDosDevice*(dwFlags: DWORD, lpDeviceName: LPCSTR,
                        lpTargetPath: LPCSTR): WINBOOL{.stdcall,
      dynlib: "kernel32", importc: "DefineDosDeviceA".}
  proc QueryDosDevice*(lpDeviceName: LPCSTR, lpTargetPath: LPSTR, ucchMax: DWORD): DWORD{.
      stdcall, dynlib: "kernel32", importc: "QueryDosDeviceA".}
  proc CreateFile*(lpFileName: LPCSTR, dwDesiredAccess: DWORD,
                   dwShareMode: DWORD,
                   lpSecurityAttributes: LPSECURITY_ATTRIBUTES,
                   dwCreationDisposition: DWORD, dwFlagsAndAttributes: DWORD,
                   hTemplateFile: HANDLE): HANDLE{.stdcall, dynlib: "kernel32",
      importc: "CreateFileA".}
  proc SetFileAttributes*(lpFileName: LPCSTR, dwFileAttributes: DWORD): WINBOOL{.
      stdcall, dynlib: "kernel32", importc: "SetFileAttributesA".}
  proc GetFileAttributes*(lpFileName: LPCSTR): DWORD{.stdcall,
      dynlib: "kernel32", importc: "GetFileAttributesA".}
  proc GetCompressedFileSize*(lpFileName: LPCSTR, lpFileSizeHigh: LPDWORD): DWORD{.
      stdcall, dynlib: "kernel32", importc: "GetCompressedFileSizeA".}
  proc DeleteFile*(lpFileName: LPCSTR): WINBOOL{.stdcall, dynlib: "kernel32",
      importc: "DeleteFileA".}
  proc SearchPath*(lpPath: LPCSTR, lpFileName: LPCSTR, lpExtension: LPCSTR,
                   nBufferLength: DWORD, lpBuffer: LPSTR, lpFilePart: LPSTR): DWORD{.
      stdcall, dynlib: "kernel32", importc: "SearchPathA".}
  proc CopyFile*(lpExistingFileName: LPCSTR, lpNewFileName: LPCSTR,
                 bFailIfExists: WINBOOL): WINBOOL{.stdcall, dynlib: "kernel32",
      importc: "CopyFileA".}
  proc MoveFile*(lpExistingFileName: LPCSTR, lpNewFileName: LPCSTR): WINBOOL{.
      stdcall, dynlib: "kernel32", importc: "MoveFileA".}
  proc MoveFileEx*(lpExistingFileName: LPCSTR, lpNewFileName: LPCSTR,
                   dwFlags: DWORD): WINBOOL{.stdcall, dynlib: "kernel32",
      importc: "MoveFileExA".}
  proc CreateNamedPipe*(lpName: LPCSTR, dwOpenMode: DWORD, dwPipeMode: DWORD,
                        nMaxInstances: DWORD, nOutBufferSize: DWORD,
                        nInBufferSize: DWORD, nDefaultTimeOut: DWORD,
                        lpSecurityAttributes: LPSECURITY_ATTRIBUTES): HANDLE{.
      stdcall, dynlib: "kernel32", importc: "CreateNamedPipeA".}
  proc GetNamedPipeHandleState*(hNamedPipe: HANDLE, lpState: LPDWORD,
                                lpCurInstances: LPDWORD,
                                lpMaxCollectionCount: LPDWORD,
                                lpCollectDataTimeout: LPDWORD,
                                lpUserName: LPSTR, nMaxUserNameSize: DWORD): WINBOOL{.
      stdcall, dynlib: "kernel32", importc: "GetNamedPipeHandleStateA".}
  proc CallNamedPipe*(lpNamedPipeName: LPCSTR, lpInBuffer: LPVOID,
                      nInBufferSize: DWORD, lpOutBuffer: LPVOID,
                      nOutBufferSize: DWORD, lpBytesRead: LPDWORD,
                      nTimeOut: DWORD): WINBOOL{.stdcall, dynlib: "kernel32",
      importc: "CallNamedPipeA".}
  proc WaitNamedPipe*(lpNamedPipeName: LPCSTR, nTimeOut: DWORD): WINBOOL{.
      stdcall, dynlib: "kernel32", importc: "WaitNamedPipeA".}
  proc SetVolumeLabel*(lpRootPathName: LPCSTR, lpVolumeName: LPCSTR): WINBOOL{.
      stdcall, dynlib: "kernel32", importc: "SetVolumeLabelA".}
  proc GetVolumeInformation*(lpRootPathName: LPCSTR, lpVolumeNameBuffer: LPSTR,
                             nVolumeNameSize: DWORD,
                             lpVolumeSerialNumber: LPDWORD,
                             lpMaximumComponentLength: LPDWORD,
                             lpFileSystemFlags: LPDWORD,
                             lpFileSystemNameBuffer: LPSTR,
                             nFileSystemNameSize: DWORD): WINBOOL{.stdcall,
      dynlib: "kernel32", importc: "GetVolumeInformationA".}
  proc ClearEventLog*(hEventLog: HANDLE, lpBackupFileName: LPCSTR): WINBOOL{.
      stdcall, dynlib: "advapi32", importc: "ClearEventLogA".}
  proc BackupEventLog*(hEventLog: HANDLE, lpBackupFileName: LPCSTR): WINBOOL{.
      stdcall, dynlib: "advapi32", importc: "BackupEventLogA".}
  proc OpenEventLog*(lpUNCServerName: LPCSTR, lpSourceName: LPCSTR): HANDLE{.
      stdcall, dynlib: "advapi32", importc: "OpenEventLogA".}
  proc RegisterEventSource*(lpUNCServerName: LPCSTR, lpSourceName: LPCSTR): HANDLE{.
      stdcall, dynlib: "advapi32", importc: "RegisterEventSourceA".}
  proc OpenBackupEventLog*(lpUNCServerName: LPCSTR, lpFileName: LPCSTR): HANDLE{.
      stdcall, dynlib: "advapi32", importc: "OpenBackupEventLogA".}
  proc ReadEventLog*(hEventLog: HANDLE, dwReadFlags: DWORD,
                     dwRecordOffset: DWORD, lpBuffer: LPVOID,
                     nNumberOfBytesToRead: DWORD, pnBytesRead: LPDWORD,
                     pnMinNumberOfBytesNeeded: LPDWORD): WINBOOL{.stdcall,
      dynlib: "advapi32", importc: "ReadEventLogA".}
  proc ReportEvent*(hEventLog: HANDLE, wType: int16, wCategory: int16,
                    dwEventID: DWORD, lpUserSid: PSID, wNumStrings: int16,
                    dwDataSize: DWORD, lpStrings: LPPCSTR, lpRawData: LPVOID): WINBOOL{.
      stdcall, dynlib: "advapi32", importc: "ReportEventA".}
  proc AccessCheckAndAuditAlarm*(SubsystemName: LPCSTR, HandleId: LPVOID,
                                 ObjectTypeName: LPSTR, ObjectName: LPSTR,
                                 SecurityDescriptor: PSECURITY_DESCRIPTOR,
                                 DesiredAccess: DWORD,
                                 GenericMapping: PGENERIC_MAPPING,
                                 ObjectCreation: WINBOOL,
                                 GrantedAccess: LPDWORD, AccessStatus: LPBOOL,
                                 pfGenerateOnClose: LPBOOL): WINBOOL{.stdcall,
      dynlib: "advapi32", importc: "AccessCheckAndAuditAlarmA".}
  proc ObjectOpenAuditAlarm*(SubsystemName: LPCSTR, HandleId: LPVOID,
                             ObjectTypeName: LPSTR, ObjectName: LPSTR,
                             pSecurityDescriptor: PSECURITY_DESCRIPTOR,
                             ClientToken: HANDLE, DesiredAccess: DWORD,
                             GrantedAccess: DWORD, Privileges: PPRIVILEGE_SET,
                             ObjectCreation: WINBOOL, AccessGranted: WINBOOL,
                             GenerateOnClose: LPBOOL): WINBOOL{.stdcall,
      dynlib: "advapi32", importc: "ObjectOpenAuditAlarmA".}
  proc ObjectPrivilegeAuditAlarm*(SubsystemName: LPCSTR, HandleId: LPVOID,
                                  ClientToken: HANDLE, DesiredAccess: DWORD,
                                  Privileges: PPRIVILEGE_SET,
                                  AccessGranted: WINBOOL): WINBOOL{.stdcall,
      dynlib: "advapi32", importc: "ObjectPrivilegeAuditAlarmA".}
  proc ObjectCloseAuditAlarm*(SubsystemName: LPCSTR, HandleId: LPVOID,
                              GenerateOnClose: WINBOOL): WINBOOL{.stdcall,
      dynlib: "advapi32", importc: "ObjectCloseAuditAlarmA".}
  proc PrivilegedServiceAuditAlarm*(SubsystemName: LPCSTR, ServiceName: LPCSTR,
                                    ClientToken: HANDLE,
                                    Privileges: PPRIVILEGE_SET,
                                    AccessGranted: WINBOOL): WINBOOL{.stdcall,
      dynlib: "advapi32", importc: "PrivilegedServiceAuditAlarmA".}
  proc SetFileSecurity*(lpFileName: LPCSTR,
                        SecurityInformation: SECURITY_INFORMATION,
                        pSecurityDescriptor: PSECURITY_DESCRIPTOR): WINBOOL{.
      stdcall, dynlib: "advapi32", importc: "SetFileSecurityA".}
  proc GetFileSecurity*(lpFileName: LPCSTR,
                        RequestedInformation: SECURITY_INFORMATION,
                        pSecurityDescriptor: PSECURITY_DESCRIPTOR,
                        nLength: DWORD, lpnLengthNeeded: LPDWORD): WINBOOL{.
      stdcall, dynlib: "advapi32", importc: "GetFileSecurityA".}
  proc FindFirstChangeNotification*(lpPathName: LPCSTR, bWatchSubtree: WINBOOL,
                                    dwNotifyFilter: DWORD): HANDLE{.stdcall,
      dynlib: "kernel32", importc: "FindFirstChangeNotificationA".}
  proc IsBadStringPtr*(lpsz: LPCSTR, ucchMax: UINT): WINBOOL{.stdcall,
      dynlib: "kernel32", importc: "IsBadStringPtrA".}
  proc LookupAccountSid*(lpSystemName: LPCSTR, Sid: PSID, Name: LPSTR,
                         cbName: LPDWORD, ReferencedDomainName: LPSTR,
                         cbReferencedDomainName: LPDWORD, peUse: PSID_NAME_USE): WINBOOL{.
      stdcall, dynlib: "advapi32", importc: "LookupAccountSidA".}
  proc LookupAccountName*(lpSystemName: LPCSTR, lpAccountName: LPCSTR,
                          Sid: PSID, cbSid: LPDWORD,
                          ReferencedDomainName: LPSTR,
                          cbReferencedDomainName: LPDWORD, peUse: PSID_NAME_USE): WINBOOL{.
      stdcall, dynlib: "advapi32", importc: "LookupAccountNameA".}
  proc LookupPrivilegeValue*(lpSystemName: LPCSTR, lpName: LPCSTR, lpLuid: PLUID): WINBOOL{.
      stdcall, dynlib: "advapi32", importc: "LookupPrivilegeValueA".}
  proc LookupPrivilegeName*(lpSystemName: LPCSTR, lpLuid: PLUID, lpName: LPSTR,
                            cbName: LPDWORD): WINBOOL{.stdcall,
      dynlib: "advapi32", importc: "LookupPrivilegeNameA".}
  proc LookupPrivilegeDisplayName*(lpSystemName: LPCSTR, lpName: LPCSTR,
                                   lpDisplayName: LPSTR, cbDisplayName: LPDWORD,
                                   lpLanguageId: LPDWORD): WINBOOL{.stdcall,
      dynlib: "advapi32", importc: "LookupPrivilegeDisplayNameA".}
  proc BuildCommDCB*(lpDef: LPCSTR, lpDCB: LPDCB): WINBOOL{.stdcall,
      dynlib: "kernel32", importc: "BuildCommDCBA".}
  proc BuildCommDCBAndTimeouts*(lpDef: LPCSTR, lpDCB: LPDCB,
                                lpCommTimeouts: LPCOMMTIMEOUTS): WINBOOL{.
      stdcall, dynlib: "kernel32", importc: "BuildCommDCBAndTimeoutsA".}
  proc CommConfigDialog*(lpszName: LPCSTR, wnd: HWND, lpCC: LPCOMMCONFIG): WINBOOL{.
      stdcall, dynlib: "kernel32", importc: "CommConfigDialogA".}
  proc GetDefaultCommConfig*(lpszName: LPCSTR, lpCC: LPCOMMCONFIG,
                             lpdwSize: LPDWORD): WINBOOL{.stdcall,
      dynlib: "kernel32", importc: "GetDefaultCommConfigA".}
  proc SetDefaultCommConfig*(lpszName: LPCSTR, lpCC: LPCOMMCONFIG, dwSize: DWORD): WINBOOL{.
      stdcall, dynlib: "kernel32", importc: "SetDefaultCommConfigA".}
  proc GetComputerName*(lpBuffer: LPSTR, nSize: LPDWORD): WINBOOL{.stdcall,
      dynlib: "kernel32", importc: "GetComputerNameA".}
  proc SetComputerName*(lpComputerName: LPCSTR): WINBOOL{.stdcall,
      dynlib: "kernel32", importc: "SetComputerNameA".}
  proc GetUserName*(lpBuffer: LPSTR, nSize: LPDWORD): WINBOOL{.stdcall,
      dynlib: "advapi32", importc: "GetUserNameA".}
  proc wvsprintf*(para1: LPSTR, para2: LPCSTR, arglist: va_list): int32{.
      stdcall, dynlib: "user32", importc: "wvsprintfA".}
  proc LoadKeyboardLayout*(pwszKLID: LPCSTR, Flags: UINT): HKL{.stdcall,
      dynlib: "user32", importc: "LoadKeyboardLayoutA".}
  proc GetKeyboardLayoutName*(pwszKLID: LPSTR): WINBOOL{.stdcall,
      dynlib: "user32", importc: "GetKeyboardLayoutNameA".}
  proc CreateDesktop*(lpszDesktop: LPSTR, lpszDevice: LPSTR,
                      pDevmode: LPDEVMODE, dwFlags: DWORD,
                      dwDesiredAccess: DWORD, lpsa: LPSECURITY_ATTRIBUTES): HDESK{.
      stdcall, dynlib: "user32", importc: "CreateDesktopA".}
  proc OpenDesktop*(lpszDesktop: LPSTR, dwFlags: DWORD, fInherit: WINBOOL,
                    dwDesiredAccess: DWORD): HDESK{.stdcall, dynlib: "user32",
      importc: "OpenDesktopA".}
  proc EnumDesktops*(hwinsta: HWINSTA, lpEnumFunc: DESKTOPENUMPROC,
                     lp: LPARAM): WINBOOL{.stdcall, dynlib: "user32",
      importc: "EnumDesktopsA".}
  proc CreateWindowStation*(lpwinsta: LPSTR, dwReserved: DWORD,
                            dwDesiredAccess: DWORD, lpsa: LPSECURITY_ATTRIBUTES): HWINSTA{.
      stdcall, dynlib: "user32", importc: "CreateWindowStationA".}
  proc OpenWindowStation*(lpszWinSta: LPSTR, fInherit: WINBOOL,
                          dwDesiredAccess: DWORD): HWINSTA{.stdcall,
      dynlib: "user32", importc: "OpenWindowStationA".}
  proc EnumWindowStations*(lpEnumFunc: ENUMWINDOWSTATIONPROC, lp: LPARAM): WINBOOL{.
      stdcall, dynlib: "user32", importc: "EnumWindowStationsA".}
  proc GetUserObjectInformation*(hObj: HANDLE, nIndex: int32, pvInfo: PVOID,
                                 nLength: DWORD, lpnLengthNeeded: LPDWORD): WINBOOL{.
      stdcall, dynlib: "user32", importc: "GetUserObjectInformationA".}
  proc SetUserObjectInformation*(hObj: HANDLE, nIndex: int32, pvInfo: PVOID,
                                 nLength: DWORD): WINBOOL{.stdcall,
      dynlib: "user32", importc: "SetUserObjectInformationA".}
  proc RegisterWindowMessage*(lpString: LPCSTR): UINT{.stdcall,
      dynlib: "user32", importc: "RegisterWindowMessageA".}
  proc GetMessage*(lpMsg: LPMSG, wnd: HWND, wMsgFilterMin: UINT,
                   wMsgFilterMax: UINT): WINBOOL{.stdcall, dynlib: "user32",
      importc: "GetMessageA".}
  proc DispatchMessage*(lpMsg: LPMSG): LONG{.stdcall, dynlib: "user32",
      importc: "DispatchMessageA".}
  proc PeekMessage*(lpMsg: LPMSG, wnd: HWND, wMsgFilterMin: UINT,
                    wMsgFilterMax: UINT, wRemoveMsg: UINT): WINBOOL{.stdcall,
      dynlib: "user32", importc: "PeekMessageA".}
  proc SendMessage*(wnd: HWND, Msg: UINT, wp: WPARAM, lp: LPARAM): LRESULT{.
      stdcall, dynlib: "user32", importc: "SendMessageA".}
  proc SendMessageTimeout*(wnd: HWND, Msg: UINT, wp: WPARAM,
                           lp: LPARAM, fuFlags: UINT, uTimeout: UINT,
                           lpdwResult: LPDWORD): LRESULT{.stdcall,
      dynlib: "user32", importc: "SendMessageTimeoutA".}
  proc SendNotifyMessage*(wnd: HWND, Msg: UINT, wp: WPARAM, lp: LPARAM): WINBOOL{.
      stdcall, dynlib: "user32", importc: "SendNotifyMessageA".}
  proc SendMessageCallback*(wnd: HWND, Msg: UINT, wp: WPARAM,
                            lp: LPARAM, lpResultCallBack: SENDASYNCPROC,
                            dwData: DWORD): WINBOOL{.stdcall, dynlib: "user32",
      importc: "SendMessageCallbackA".}
  proc PostMessage*(wnd: HWND, Msg: UINT, wp: WPARAM, lp: LPARAM): WINBOOL{.
      stdcall, dynlib: "user32", importc: "PostMessageA".}
  proc PostThreadMessage*(idThread: DWORD, Msg: UINT, wp: WPARAM,
                          lp: LPARAM): WINBOOL{.stdcall, dynlib: "user32",
      importc: "PostThreadMessageA".}
  proc DefWindowProc*(wnd: HWND, Msg: UINT, wp: WPARAM, lp: LPARAM): LRESULT{.
      stdcall, dynlib: "user32", importc: "DefWindowProcA".}
  proc CallWindowProc*(lpPrevWndFunc: WNDPROC, wnd: HWND, Msg: UINT,
                       wp: WPARAM, lp: LPARAM): LRESULT{.stdcall,
      dynlib: "user32", importc: "CallWindowProcA".}
  proc RegisterClass*(lpWndClass: LPWNDCLASS): ATOM{.stdcall, dynlib: "user32",
      importc: "RegisterClassA".}
  proc UnregisterClass*(lpClassName: LPCSTR, hInstance: HINST): WINBOOL{.
      stdcall, dynlib: "user32", importc: "UnregisterClassA".}
  proc GetClassInfo*(hInstance: HINST, lpClassName: LPCSTR,
                     lpWndClass: LPWNDCLASS): WINBOOL{.stdcall,
      dynlib: "user32", importc: "GetClassInfoA".}
  proc RegisterClassEx*(para1: LPWNDCLASSEX): ATOM{.stdcall, dynlib: "user32",
      importc: "RegisterClassExA".}
  proc GetClassInfoEx*(para1: HINST, para2: LPCSTR, para3: LPWNDCLASSEX): WINBOOL{.
      stdcall, dynlib: "user32", importc: "GetClassInfoExA".}
  proc CreateWindowEx*(dwExStyle: DWORD, lpClassName: LPCSTR,
                       lpWindowName: LPCSTR, dwStyle: DWORD, X: int32, Y: int32,
                       nWidth: int32, nHeight: int32, hWndParent: HWND,
                       menu: HMENU, hInstance: HINST, lpParam: LPVOID): HWND{.
      stdcall, dynlib: "user32", importc: "CreateWindowExA".}
  proc CreateDialogParam*(hInstance: HINST, lpTemplateName: LPCSTR,
                          hWndParent: HWND, lpDialogFunc: DLGPROC,
                          dwInitParam: LPARAM): HWND{.stdcall, dynlib: "user32",
      importc: "CreateDialogParamA".}
  proc CreateDialogIndirectParam*(hInstance: HINST, lpTemplate: LPCDLGTEMPLATE,

                                  hWndParent: HWND, lpDialogFunc: DLGPROC,
                                  dwInitParam: LPARAM): HWND{.stdcall,
      dynlib: "user32", importc: "CreateDialogIndirectParamA".}
  proc DialogBoxParam*(hInstance: HINST, lpTemplateName: LPCSTR,
                       hWndParent: HWND, lpDialogFunc: DLGPROC,
                       dwInitParam: LPARAM): int32{.stdcall, dynlib: "user32",
      importc: "DialogBoxParamA".}
  proc DialogBoxIndirectParam*(hInstance: HINST,
                               hDialogTemplate: LPCDLGTEMPLATE,
                               hWndParent: HWND, lpDialogFunc: DLGPROC,
                               dwInitParam: LPARAM): int32{.stdcall,
      dynlib: "user32", importc: "DialogBoxIndirectParamA".}
  proc SetDlgItemText*(hDlg: HWND, nIDDlgItem: int32, lpString: LPCSTR): WINBOOL{.
      stdcall, dynlib: "user32", importc: "SetDlgItemTextA".}
  proc GetDlgItemText*(hDlg: HWND, nIDDlgItem: int32, lpString: LPSTR,
                       nMaxCount: int32): UINT{.stdcall, dynlib: "user32",
      importc: "GetDlgItemTextA".}
  proc SendDlgItemMessage*(hDlg: HWND, nIDDlgItem: int32, Msg: UINT,
                           wp: WPARAM, lp: LPARAM): LONG{.stdcall,
      dynlib: "user32", importc: "SendDlgItemMessageA".}
  proc DefDlgProc*(hDlg: HWND, Msg: UINT, wp: WPARAM, lp: LPARAM): LRESULT{.
      stdcall, dynlib: "user32", importc: "DefDlgProcA".}
  proc CallMsgFilter*(lpMsg: LPMSG, nCode: int32): WINBOOL{.stdcall,
      dynlib: "user32", importc: "CallMsgFilterA".}
  proc RegisterClipboardFormat*(lpszFormat: LPCSTR): UINT{.stdcall,
      dynlib: "user32", importc: "RegisterClipboardFormatA".}
  proc GetClipboardFormatName*(format: UINT, lpszFormatName: LPSTR,
                               cchMaxCount: int32): int32{.stdcall,
      dynlib: "user32", importc: "GetClipboardFormatNameA".}
  proc CharToOem*(lpszSrc: LPCSTR, lpszDst: LPSTR): WINBOOL{.stdcall,
      dynlib: "user32", importc: "CharToOemA".}
  proc OemToChar*(lpszSrc: LPCSTR, lpszDst: LPSTR): WINBOOL{.stdcall,
      dynlib: "user32", importc: "OemToCharA".}
  proc CharToOemBuff*(lpszSrc: LPCSTR, lpszDst: LPSTR, cchDstLength: DWORD): WINBOOL{.
      stdcall, dynlib: "user32", importc: "CharToOemBuffA".}
  proc OemToCharBuff*(lpszSrc: LPCSTR, lpszDst: LPSTR, cchDstLength: DWORD): WINBOOL{.
      stdcall, dynlib: "user32", importc: "OemToCharBuffA".}
  proc CharUpper*(lpsz: LPSTR): LPSTR{.stdcall, dynlib: "user32",
                                       importc: "CharUpperA".}
  proc CharUpperBuff*(lpsz: LPSTR, cchLength: DWORD): DWORD{.stdcall,
      dynlib: "user32", importc: "CharUpperBuffA".}
  proc CharLower*(lpsz: LPSTR): LPSTR{.stdcall, dynlib: "user32",
                                       importc: "CharLowerA".}
  proc CharLowerBuff*(lpsz: LPSTR, cchLength: DWORD): DWORD{.stdcall,
      dynlib: "user32", importc: "CharLowerBuffA".}
  proc CharNext*(lpsz: LPCSTR): LPSTR{.stdcall, dynlib: "user32",
                                       importc: "CharNextA".}
  proc CharPrev*(lpszStart: LPCSTR, lpszCurrent: LPCSTR): LPSTR{.stdcall,
      dynlib: "user32", importc: "CharPrevA".}
  proc IsCharAlpha*(ch: CHAR): WINBOOL{.stdcall, dynlib: "user32",
                                        importc: "IsCharAlphaA".}
  proc IsCharAlphaNumeric*(ch: CHAR): WINBOOL{.stdcall, dynlib: "user32",
      importc: "IsCharAlphaNumericA".}
  proc IsCharUpper*(ch: CHAR): WINBOOL{.stdcall, dynlib: "user32",
                                        importc: "IsCharUpperA".}
  proc IsCharLower*(ch: CHAR): WINBOOL{.stdcall, dynlib: "user32",
                                        importc: "IsCharLowerA".}
  proc GetKeyNameText*(lParam: LONG, lpString: LPSTR, nSize: int32): int32{.
      stdcall, dynlib: "user32", importc: "GetKeyNameTextA".}
  proc VkKeyScan*(ch: CHAR): SHORT{.stdcall, dynlib: "user32",
                                    importc: "VkKeyScanA".}
  proc VkKeyScanEx*(ch: CHAR, dwhkl: HKL): SHORT{.stdcall, dynlib: "user32",
      importc: "VkKeyScanExA".}
  proc MapVirtualKey*(uCode: UINT, uMapType: UINT): UINT{.stdcall,
      dynlib: "user32", importc: "MapVirtualKeyA".}
  proc MapVirtualKeyEx*(uCode: UINT, uMapType: UINT, dwhkl: HKL): UINT{.stdcall,
      dynlib: "user32", importc: "MapVirtualKeyExA".}
  proc LoadAccelerators*(hInstance: HINST, lpTableName: LPCSTR): HACCEL{.
      stdcall, dynlib: "user32", importc: "LoadAcceleratorsA".}
  proc CreateAcceleratorTable*(para1: LPACCEL, para2: int32): HACCEL{.stdcall,
      dynlib: "user32", importc: "CreateAcceleratorTableA".}
  proc CopyAcceleratorTable*(hAccelSrc: HACCEL, lpAccelDst: LPACCEL,
                             cAccelEntries: int32): int32{.stdcall,
      dynlib: "user32", importc: "CopyAcceleratorTableA".}
  proc TranslateAccelerator*(wnd: HWND, hAccTable: HACCEL, lpMsg: LPMSG): int32{.
      stdcall, dynlib: "user32", importc: "TranslateAcceleratorA".}
  proc LoadMenu*(hInstance: HINST, lpMenuName: LPCSTR): HMENU{.stdcall,
      dynlib: "user32", importc: "LoadMenuA".}
  proc LoadMenuIndirect*(lpMenuTemplate: LPMENUTEMPLATE): HMENU{.stdcall,
      dynlib: "user32", importc: "LoadMenuIndirectA".}
  proc ChangeMenu*(menu: HMENU, cmd: UINT, lpszNewItem: LPCSTR,
                   cmdInsert: UINT, flags: UINT): WINBOOL{.stdcall,
      dynlib: "user32", importc: "ChangeMenuA".}
  proc GetMenuString*(menu: HMENU, uIDItem: UINT, lpString: LPSTR,
                      nMaxCount: int32, uFlag: UINT): int32{.stdcall,
      dynlib: "user32", importc: "GetMenuStringA".}
  proc InsertMenu*(menu: HMENU, uPosition: UINT, uFlags: UINT,
                   uIDNewItem: UINT, lpNewItem: LPCSTR): WINBOOL{.stdcall,
      dynlib: "user32", importc: "InsertMenuA".}
  proc AppendMenu*(menu: HMENU, uFlags: UINT, uIDNewItem: UINT,
                   lpNewItem: LPCSTR): WINBOOL{.stdcall, dynlib: "user32",
      importc: "AppendMenuA".}
  proc ModifyMenu*(hMnu: HMENU, uPosition: UINT, uFlags: UINT, uIDNewItem: UINT,
                   lpNewItem: LPCSTR): WINBOOL{.stdcall, dynlib: "user32",
      importc: "ModifyMenuA".}
  proc InsertMenuItem*(para1: HMENU, para2: UINT, para3: WINBOOL,
                       para4: LPCMENUITEMINFO): WINBOOL{.stdcall,
      dynlib: "user32", importc: "InsertMenuItemA".}
  proc GetMenuItemInfo*(para1: HMENU, para2: UINT, para3: WINBOOL,
                        para4: LPMENUITEMINFO): WINBOOL{.stdcall,
      dynlib: "user32", importc: "GetMenuItemInfoA".}
  proc SetMenuItemInfo*(para1: HMENU, para2: UINT, para3: WINBOOL,
                        para4: LPCMENUITEMINFO): WINBOOL{.stdcall,
      dynlib: "user32", importc: "SetMenuItemInfoA".}
  proc DrawText*(hDC: HDC, lpString: LPCSTR, nCount: int32, lpRect: LPRECT,
                 uFormat: UINT): int32{.stdcall, dynlib: "user32",
                                        importc: "DrawTextA".}
  proc DrawTextEx*(para1: HDC, para2: LPSTR, para3: int32, para4: LPRECT,
                   para5: UINT, para6: LPDRAWTEXTPARAMS): int32{.stdcall,
      dynlib: "user32", importc: "DrawTextExA".}
  proc GrayString*(hDC: HDC, hBrush: HBRUSH, lpOutputFunc: GRAYSTRINGPROC,
                   lpData: LPARAM, nCount: int32, X: int32, Y: int32,
                   nWidth: int32, nHeight: int32): WINBOOL{.stdcall,
      dynlib: "user32", importc: "GrayStringA".}
  proc DrawState*(para1: HDC, para2: HBRUSH, para3: DRAWSTATEPROC,
                  para4: LPARAM, para5: WPARAM, para6: int32, para7: int32,
                  para8: int32, para9: int32, para10: UINT): WINBOOL{.stdcall,
      dynlib: "user32", importc: "DrawStateA".}
  proc TabbedTextOut*(dc: HDC, X: int32, Y: int32, lpString: LPCSTR,
                      nCount: int32, nTabPositions: int32,
                      lpnTabStopPositions: LPINT, nTabOrigin: int32): LONG{.
      stdcall, dynlib: "user32", importc: "TabbedTextOutA".}
  proc GetTabbedTextExtent*(hDC: HDC, lpString: LPCSTR, nCount: int32,
                            nTabPositions: int32, lpnTabStopPositions: LPINT): DWORD{.
      stdcall, dynlib: "user32", importc: "GetTabbedTextExtentA".}
  proc SetProp*(wnd: HWND, lpString: LPCSTR, hData: HANDLE): WINBOOL{.stdcall,
      dynlib: "user32", importc: "SetPropA".}
  proc GetProp*(wnd: HWND, lpString: LPCSTR): HANDLE{.stdcall,
      dynlib: "user32", importc: "GetPropA".}
  proc RemoveProp*(wnd: HWND, lpString: LPCSTR): HANDLE{.stdcall,
      dynlib: "user32", importc: "RemovePropA".}
  proc EnumPropsEx*(wnd: HWND, lpEnumFunc: PROPENUMPROCEX, lp: LPARAM): int32{.
      stdcall, dynlib: "user32", importc: "EnumPropsExA".}
  proc EnumProps*(wnd: HWND, lpEnumFunc: PROPENUMPROC): int32{.stdcall,
      dynlib: "user32", importc: "EnumPropsA".}
  proc SetWindowText*(wnd: HWND, lpString: LPCSTR): WINBOOL{.stdcall,
      dynlib: "user32", importc: "SetWindowTextA".}
  proc GetWindowText*(wnd: HWND, lpString: LPSTR, nMaxCount: int32): int32{.
      stdcall, dynlib: "user32", importc: "GetWindowTextA".}
  proc GetWindowTextLength*(wnd: HWND): int32{.stdcall, dynlib: "user32",
      importc: "GetWindowTextLengthA".}
  proc MessageBox*(wnd: HWND, lpText: LPCSTR, lpCaption: LPCSTR, uType: UINT): int32{.
      stdcall, dynlib: "user32", importc: "MessageBoxA".}
  proc MessageBoxEx*(wnd: HWND, lpText: LPCSTR, lpCaption: LPCSTR, uType: UINT,
                     wLanguageId: int16): int32{.stdcall, dynlib: "user32",
      importc: "MessageBoxExA".}
  proc MessageBoxIndirect*(para1: LPMSGBOXPARAMS): int32{.stdcall,
      dynlib: "user32", importc: "MessageBoxIndirectA".}
  proc GetWindowLong*(wnd: HWND, nIndex: int32): LONG{.stdcall,
      dynlib: "user32", importc: "GetWindowLongA".}
  proc SetWindowLong*(wnd: HWND, nIndex: int32, dwNewLong: LONG): LONG{.
      stdcall, dynlib: "user32", importc: "SetWindowLongA".}
  proc GetClassLong*(wnd: HWND, nIndex: int32): DWORD{.stdcall,
      dynlib: "user32", importc: "GetClassLongA".}
  proc SetClassLong*(wnd: HWND, nIndex: int32, dwNewLong: LONG): DWORD{.
      stdcall, dynlib: "user32", importc: "SetClassLongA".}
  when defined(cpu64):
    proc GetWindowLongPtr*(wnd: HWND, nIndex: int32): LONG_PTR{.stdcall,
        dynlib: "user32", importc: "GetWindowLongPtrA".}
    proc SetWindowLongPtr*(wnd: HWND, nIndex: int32, dwNewLong: LONG_PTR): LONG_PTR{.
        stdcall, dynlib: "user32", importc: "SetWindowLongPtrA".}
    proc GetClassLongPtr*(wnd: HWND, nIndex: int32): LONG_PTR{.stdcall,
        dynlib: "user32", importc: "GetClassLongPtrA".}
    proc SetClassLongPtr*(wnd: HWND, nIndex: int32, dwNewLong: LONG_PTR): LONG_PTR{.
        stdcall, dynlib: "user32", importc: "SetClassLongPtrA".}
  else:
    proc GetWindowLongPtr*(wnd: HWND, nIndex: int32): LONG_PTR{.stdcall,
        dynlib: "user32", importc: "GetWindowLongA".}
    proc SetWindowLongPtr*(wnd: HWND, nIndex: int32, dwNewLong: LONG_PTR): LONG_PTR{.
        stdcall, dynlib: "user32", importc: "SetWindowLongA".}
    proc GetClassLongPtr*(wnd: HWND, nIndex: int32): LONG_PTR{.stdcall,
        dynlib: "user32", importc: "GetClassLongA".}
    proc SetClassLongPtr*(wnd: HWND, nIndex: int32, dwNewLong: LONG_PTR): LONG_PTR{.
        stdcall, dynlib: "user32", importc: "SetClassLongA".}
  proc FindWindow*(lpClassName: LPCSTR, lpWindowName: LPCSTR): HWND{.stdcall,
      dynlib: "user32", importc: "FindWindowA".}
  proc FindWindowEx*(para1: HWND, para2: HWND, para3: LPCSTR, para4: LPCSTR): HWND{.
      stdcall, dynlib: "user32", importc: "FindWindowExA".}
  proc GetClassName*(wnd: HWND, lpClassName: LPSTR, nMaxCount: int32): int32{.
      stdcall, dynlib: "user32", importc: "GetClassNameA".}
  proc SetWindowsHookEx*(idHook: int32, lpfn: HOOKPROC, hmod: HINST,
                         dwThreadId: DWORD): HHOOK{.stdcall, dynlib: "user32",
      importc: "SetWindowsHookExA".}
  proc LoadBitmap*(hInstance: HINST, lpBitmapName: LPCSTR): HBITMAP{.stdcall,
      dynlib: "user32", importc: "LoadBitmapA".}
  proc LoadCursor*(hInstance: HINST, lpCursorName: LPCSTR): HCURSOR{.stdcall,
      dynlib: "user32", importc: "LoadCursorA".}
  proc LoadCursorFromFile*(lpFileName: LPCSTR): HCURSOR{.stdcall,
      dynlib: "user32", importc: "LoadCursorFromFileA".}
  proc LoadIcon*(hInstance: HINST, lpIconName: LPCSTR): HICON{.stdcall,
      dynlib: "user32", importc: "LoadIconA".}
  proc LoadImage*(para1: HINST, para2: LPCSTR, para3: UINT, para4: int32,
                  para5: int32, para6: UINT): HANDLE{.stdcall, dynlib: "user32",
      importc: "LoadImageA".}
  proc LoadString*(hInstance: HINST, uID: UINT, lpBuffer: LPSTR,
                   nBufferMax: int32): int32{.stdcall, dynlib: "user32",
      importc: "LoadStringA".}
  proc IsDialogMessage*(hDlg: HWND, lpMsg: LPMSG): WINBOOL{.stdcall,
      dynlib: "user32", importc: "IsDialogMessageA".}
  proc DlgDirList*(hDlg: HWND, lpPathSpec: LPSTR, nIDListBox: int32,
                   nIDStaticPath: int32, uFileType: UINT): int32{.stdcall,
      dynlib: "user32", importc: "DlgDirListA".}
  proc DlgDirSelectEx*(hDlg: HWND, lpString: LPSTR, nCount: int32,
                       nIDListBox: int32): WINBOOL{.stdcall, dynlib: "user32",
      importc: "DlgDirSelectExA".}
  proc DlgDirListComboBox*(hDlg: HWND, lpPathSpec: LPSTR, nIDComboBox: int32,
                           nIDStaticPath: int32, uFiletype: UINT): int32{.
      stdcall, dynlib: "user32", importc: "DlgDirListComboBoxA".}
  proc DlgDirSelectComboBoxEx*(hDlg: HWND, lpString: LPSTR, nCount: int32,
                               nIDComboBox: int32): WINBOOL{.stdcall,
      dynlib: "user32", importc: "DlgDirSelectComboBoxExA".}
  proc DefFrameProc*(wnd: HWND, hWndMDIClient: HWND, uMsg: UINT,
                     wp: WPARAM, lp: LPARAM): LRESULT{.stdcall,
      dynlib: "user32", importc: "DefFrameProcA".}
  proc DefMDIChildProc*(wnd: HWND, uMsg: UINT, wp: WPARAM, lp: LPARAM): LRESULT{.
      stdcall, dynlib: "user32", importc: "DefMDIChildProcA".}
  proc CreateMDIWindow*(lpClassName: LPSTR, lpWindowName: LPSTR, dwStyle: DWORD,
                        X: int32, Y: int32, nWidth: int32, nHeight: int32,
                        hWndParent: HWND, hInstance: HINST, lp: LPARAM): HWND{.
      stdcall, dynlib: "user32", importc: "CreateMDIWindowA".}
  proc WinHelp*(hWndMain: HWND, lpszHelp: LPCSTR, uCommand: UINT, dwData: DWORD): WINBOOL{.
      stdcall, dynlib: "user32", importc: "WinHelpA".}
  proc ChangeDisplaySettings*(lpDevMode: LPDEVMODE, dwFlags: DWORD): LONG{.
      stdcall, dynlib: "user32", importc: "ChangeDisplaySettingsA".}
  proc EnumDisplaySettings*(lpszDeviceName: LPCSTR, iModeNum: DWORD,
                            lpDevMode: LPDEVMODE): WINBOOL{.stdcall,
      dynlib: "user32", importc: "EnumDisplaySettingsA".}
  proc SystemParametersInfo*(uiAction: UINT, uiParam: UINT, pvParam: PVOID,
                             fWinIni: UINT): WINBOOL{.stdcall, dynlib: "user32",
      importc: "SystemParametersInfoA".}
  proc AddFontResource*(para1: LPCSTR): int32{.stdcall, dynlib: "gdi32",
      importc: "AddFontResourceA".}
  proc CopyMetaFile*(para1: HMETAFILE, para2: LPCSTR): HMETAFILE{.stdcall,
      dynlib: "gdi32", importc: "CopyMetaFileA".}
  proc CreateFont*(para1: int32, para2: int32, para3: int32, para4: int32,
                   para5: int32, para6: DWORD, para7: DWORD, para8: DWORD,
                   para9: DWORD, para10: DWORD, para11: DWORD, para12: DWORD,
                   para13: DWORD, para14: LPCSTR): HFONT{.stdcall,
      dynlib: "gdi32", importc: "CreateFontA".}
  proc CreateFontIndirect*(para1: LPLOGFONT): HFONT{.stdcall, dynlib: "gdi32",
      importc: "CreateFontIndirectA".}
  proc CreateFontIndirect*(para1: var LOGFONT): HFONT{.stdcall, dynlib: "gdi32",
      importc: "CreateFontIndirectA".}
  proc CreateIC*(para1: LPCSTR, para2: LPCSTR, para3: LPCSTR, para4: LPDEVMODE): HDC{.
      stdcall, dynlib: "gdi32", importc: "CreateICA".}
  proc CreateMetaFile*(para1: LPCSTR): HDC{.stdcall, dynlib: "gdi32",
      importc: "CreateMetaFileA".}
  proc CreateScalableFontResource*(para1: DWORD, para2: LPCSTR, para3: LPCSTR,
                                   para4: LPCSTR): WINBOOL{.stdcall,
      dynlib: "gdi32", importc: "CreateScalableFontResourceA".}
  proc EnumFontFamiliesEx*(para1: HDC, para2: LPLOGFONT, para3: FONTENUMEXPROC,
                           para4: LPARAM, para5: DWORD): int32{.stdcall,
      dynlib: "gdi32", importc: "EnumFontFamiliesExA".}
  proc EnumFontFamilies*(para1: HDC, para2: LPCSTR, para3: FONTENUMPROC,
                         para4: LPARAM): int32{.stdcall, dynlib: "gdi32",
      importc: "EnumFontFamiliesA".}
  proc EnumFonts*(para1: HDC, para2: LPCSTR, para3: ENUMFONTSPROC, para4: LPARAM): int32{.
      stdcall, dynlib: "gdi32", importc: "EnumFontsA".}
  proc EnumFonts*(para1: HDC, para2: LPCSTR, para3: ENUMFONTSPROC,
                  para4: pointer): int32{.stdcall, dynlib: "gdi32",
      importc: "EnumFontsA".}
  proc GetCharWidth*(para1: HDC, para2: UINT, para3: UINT, para4: LPINT): WINBOOL{.
      stdcall, dynlib: "gdi32", importc: "GetCharWidthA".}
  proc GetCharWidth32*(para1: HDC, para2: UINT, para3: UINT, para4: LPINT): WINBOOL{.
      stdcall, dynlib: "gdi32", importc: "GetCharWidth32A".}
  proc GetCharWidthFloat*(para1: HDC, para2: UINT, para3: UINT, para4: ptr float32): WINBOOL{.
      stdcall, dynlib: "gdi32", importc: "GetCharWidthFloatA".}
  proc GetCharABCWidths*(para1: HDC, para2: UINT, para3: UINT, para4: LPABC): WINBOOL{.
      stdcall, dynlib: "gdi32", importc: "GetCharABCWidthsA".}
  proc GetCharABCWidthsFloat*(para1: HDC, para2: UINT, para3: UINT,
                              para4: LPABCFLOAT): WINBOOL{.stdcall,
      dynlib: "gdi32", importc: "GetCharABCWidthsFloatA".}
  proc GetGlyphOutline*(para1: HDC, para2: UINT, para3: UINT,
                        para4: LPGLYPHMETRICS, para5: DWORD, para6: LPVOID,
                        para7: PMAT2): DWORD{.stdcall, dynlib: "gdi32",
      importc: "GetGlyphOutlineA".}
  proc GetMetaFile*(para1: LPCSTR): HMETAFILE{.stdcall, dynlib: "gdi32",
      importc: "GetMetaFileA".}
  proc GetOutlineTextMetrics*(para1: HDC, para2: UINT,
                              para3: LPOUTLINETEXTMETRIC): UINT{.stdcall,
      dynlib: "gdi32", importc: "GetOutlineTextMetricsA".}
  proc GetTextExtentPoint*(para1: HDC, para2: LPCSTR, para3: int32,
                           para4: LPSIZE): WINBOOL{.stdcall, dynlib: "gdi32",
      importc: "GetTextExtentPointA".}
  proc GetTextExtentPoint32*(para1: HDC, para2: LPCSTR, para3: int32,
                             para4: LPSIZE): WINBOOL{.stdcall, dynlib: "gdi32",
      importc: "GetTextExtentPoint32A".}
  proc GetTextExtentExPoint*(para1: HDC, para2: LPCSTR, para3: int32,
                             para4: int32, para5: LPINT, para6: LPINT,
                             para7: LPSIZE): WINBOOL{.stdcall, dynlib: "gdi32",
      importc: "GetTextExtentExPointA".}
  proc GetCharacterPlacement*(para1: HDC, para2: LPCSTR, para3: int32,
                              para4: int32, para5: LPGCP_RESULTS, para6: DWORD): DWORD{.
      stdcall, dynlib: "gdi32", importc: "GetCharacterPlacementA".}
  proc ResetDC*(para1: HDC, para2: LPDEVMODE): HDC{.stdcall, dynlib: "gdi32",
      importc: "ResetDCA".}
  proc RemoveFontResource*(para1: LPCSTR): WINBOOL{.stdcall, dynlib: "gdi32",
      importc: "RemoveFontResourceA".}
  proc CopyEnhMetaFile*(para1: HENHMETAFILE, para2: LPCSTR): HENHMETAFILE{.
      stdcall, dynlib: "gdi32", importc: "CopyEnhMetaFileA".}
  proc CreateEnhMetaFile*(para1: HDC, para2: LPCSTR, para3: LPRECT,
                          para4: LPCSTR): HDC{.stdcall, dynlib: "gdi32",
      importc: "CreateEnhMetaFileA".}
  proc GetEnhMetaFile*(para1: LPCSTR): HENHMETAFILE{.stdcall, dynlib: "gdi32",
      importc: "GetEnhMetaFileA".}
  proc GetEnhMetaFileDescription*(para1: HENHMETAFILE, para2: UINT, para3: LPSTR): UINT{.
      stdcall, dynlib: "gdi32", importc: "GetEnhMetaFileDescriptionA".}
  proc GetTextMetrics*(para1: HDC, para2: LPTEXTMETRIC): WINBOOL{.stdcall,
      dynlib: "gdi32", importc: "GetTextMetricsA".}
  proc StartDoc*(para1: HDC, para2: PDOCINFO): int32{.stdcall, dynlib: "gdi32",
      importc: "StartDocA".}
  proc GetObject*(para1: HGDIOBJ, para2: int32, para3: LPVOID): int32{.stdcall,
      dynlib: "gdi32", importc: "GetObjectA".}
  proc TextOut*(para1: HDC, para2: int32, para3: int32, para4: LPCSTR,
                para5: int32): WINBOOL{.stdcall, dynlib: "gdi32",
                                        importc: "TextOutA".}
  proc ExtTextOut*(para1: HDC, para2: int32, para3: int32, para4: UINT,
                   para5: LPRECT, para6: LPCSTR, para7: UINT, para8: LPINT): WINBOOL{.
      stdcall, dynlib: "gdi32", importc: "ExtTextOutA".}
  proc PolyTextOut*(para1: HDC, para2: PPOLYTEXT, para3: int32): WINBOOL{.
      stdcall, dynlib: "gdi32", importc: "PolyTextOutA".}
  proc GetTextFace*(para1: HDC, para2: int32, para3: LPSTR): int32{.stdcall,
      dynlib: "gdi32", importc: "GetTextFaceA".}
  proc GetKerningPairs*(para1: HDC, para2: DWORD, para3: LPKERNINGPAIR): DWORD{.
      stdcall, dynlib: "gdi32", importc: "GetKerningPairsA".}
  proc CreateColorSpace*(para1: LPLOGCOLORSPACE): HCOLORSPACE{.stdcall,
      dynlib: "gdi32", importc: "CreateColorSpaceA".}
  proc GetLogColorSpace*(para1: HCOLORSPACE, para2: LPLOGCOLORSPACE,
                         para3: DWORD): WINBOOL{.stdcall, dynlib: "gdi32",
      importc: "GetLogColorSpaceA".}
  proc GetICMProfile*(para1: HDC, para2: DWORD, para3: LPSTR): WINBOOL{.stdcall,
      dynlib: "gdi32", importc: "GetICMProfileA".}
  proc SetICMProfile*(para1: HDC, para2: LPSTR): WINBOOL{.stdcall,
      dynlib: "gdi32", importc: "SetICMProfileA".}
  proc UpdateICMRegKey*(para1: DWORD, para2: DWORD, para3: LPSTR, para4: UINT): WINBOOL{.
      stdcall, dynlib: "gdi32", importc: "UpdateICMRegKeyA".}
  proc EnumICMProfiles*(para1: HDC, para2: ICMENUMPROC, para3: LPARAM): int32{.
      stdcall, dynlib: "gdi32", importc: "EnumICMProfilesA".}
  proc PropertySheet*(lppsph: LPCPROPSHEETHEADER): int32{.stdcall,
      dynlib: "comctl32", importc: "PropertySheetA".}
  proc ImageList_LoadImage*(hi: HINST, lpbmp: LPCSTR, cx: int32, cGrow: int32,
                            crMask: COLORREF, uType: UINT, uFlags: UINT): HIMAGELIST{.
      stdcall, dynlib: "comctl32", importc: "ImageList_LoadImageA".}
  proc CreateStatusWindow*(style: LONG, lpszText: LPCSTR, hwndParent: HWND,
                           wID: UINT): HWND{.stdcall, dynlib: "comctl32",
      importc: "CreateStatusWindowA".}
  proc DrawStatusText*(hDC: HDC, lprc: LPRECT, pszText: LPCSTR, uFlags: UINT){.
      stdcall, dynlib: "comctl32", importc: "DrawStatusTextA".}
  proc GetOpenFileName*(para1: LPOPENFILENAME): WINBOOL{.stdcall,
      dynlib: "comdlg32", importc: "GetOpenFileNameA".}
  proc GetSaveFileName*(para1: LPOPENFILENAME): WINBOOL{.stdcall,
      dynlib: "comdlg32", importc: "GetSaveFileNameA".}
  proc GetFileTitle*(para1: LPCSTR, para2: LPSTR, para3: int16): int{.stdcall,
      dynlib: "comdlg32", importc: "GetFileTitleA".}
  proc ChooseColor*(para1: LPCHOOSECOLOR): WINBOOL{.stdcall, dynlib: "comdlg32",
      importc: "ChooseColorA".}
  proc FindText*(para1: LPFINDREPLACE): HWND{.stdcall, dynlib: "comdlg32",
      importc: "FindTextA".}
  proc ReplaceText*(para1: LPFINDREPLACE): HWND{.stdcall, dynlib: "comdlg32",
      importc: "ReplaceTextA".}
  proc ChooseFont*(para1: LPCHOOSEFONT): WINBOOL{.stdcall, dynlib: "comdlg32",
      importc: "ChooseFontA".}
  proc PrintDlg*(para1: LPPRINTDLG): WINBOOL{.stdcall, dynlib: "comdlg32",
      importc: "PrintDlgA".}
  proc PageSetupDlg*(para1: LPPAGESETUPDLG): WINBOOL{.stdcall,
      dynlib: "comdlg32", importc: "PageSetupDlgA".}
  proc CreateProcess*(lpApplicationName: LPCSTR, lpCommandLine: LPSTR,
                      lpProcessAttributes: LPSECURITY_ATTRIBUTES,
                      lpThreadAttributes: LPSECURITY_ATTRIBUTES,
                      bInheritHandles: WINBOOL, dwCreationFlags: DWORD,
                      lpEnvironment: LPVOID, lpCurrentDirectory: LPCSTR,
                      lpStartupInfo: LPSTARTUPINFO,
                      lpProcessInformation: LPPROCESS_INFORMATION): WINBOOL{.
      stdcall, dynlib: "kernel32", importc: "CreateProcessA".}
  proc GetStartupInfo*(lpStartupInfo: LPSTARTUPINFO){.stdcall,
      dynlib: "kernel32", importc: "GetStartupInfoA".}
  proc FindFirstFile*(lpFileName: LPCSTR, lpFindFileData: LPWIN32_FIND_DATA): HANDLE{.
      stdcall, dynlib: "kernel32", importc: "FindFirstFileA".}
  proc FindNextFile*(hFindFile: HANDLE, lpFindFileData: LPWIN32_FIND_DATA): WINBOOL{.
      stdcall, dynlib: "kernel32", importc: "FindNextFileA".}
  proc GetVersionEx*(VersionInformation: LPOSVERSIONINFO): WINBOOL{.stdcall,
      dynlib: "kernel32", importc: "GetVersionExA".}
  proc CreateWindow*(lpClassName: LPCSTR, lpWindowName: LPCSTR, dwStyle: DWORD,
                     X: int32, Y: int32, nWidth: int32, nHeight: int32,
                     hWndParent: HWND, menu: HMENU, hInstance: HINST,
                     lpParam: LPVOID): HWND
  proc CreateDialog*(hInstance: HINST, lpTemplateName: LPCSTR, hWndParent: HWND,
                     lpDialogFunc: DLGPROC): HWND
  proc CreateDialogIndirect*(hInstance: HINST, lpTemplate: LPCDLGTEMPLATE,
                             hWndParent: HWND, lpDialogFunc: DLGPROC): HWND
  proc DialogBox*(hInstance: HINST, lpTemplateName: LPCSTR, hWndParent: HWND,
                  lpDialogFunc: DLGPROC): int32
  proc DialogBoxIndirect*(hInstance: HINST, hDialogTemplate: LPCDLGTEMPLATE,
                          hWndParent: HWND, lpDialogFunc: DLGPROC): int32
  proc CreateDC*(para1: LPCSTR, para2: LPCSTR, para3: LPCSTR, para4: pDEVMODE): HDC{.
      stdcall, dynlib: "gdi32", importc: "CreateDCA".}
  proc VerInstallFile*(uFlags: DWORD, szSrcFileName: LPSTR,
                       szDestFileName: LPSTR, szSrcDir: LPSTR, szDestDir: LPSTR,
                       szCurDir: LPSTR, szTmpFile: LPSTR, lpuTmpFileLen: PUINT): DWORD{.
      stdcall, dynlib: "version", importc: "VerInstallFileA".}
  proc GetFileVersionInfoSize*(lptstrFilename: LPSTR, lpdwHandle: LPDWORD): DWORD{.
      stdcall, dynlib: "version", importc: "GetFileVersionInfoSizeA".}
  proc GetFileVersionInfo*(lptstrFilename: LPSTR, dwHandle: DWORD, dwLen: DWORD,
                           lpData: LPVOID): WINBOOL{.stdcall, dynlib: "version",
      importc: "GetFileVersionInfoA".}
  proc VerLanguageName*(wLang: DWORD, szLang: LPSTR, nSize: DWORD): DWORD{.
      stdcall, dynlib: "kernel32", importc: "VerLanguageNameA".}
  proc VerQueryValue*(pBlock: LPVOID, lpSubBlock: LPSTR, lplpBuffer: LPVOID,
                      puLen: PUINT): WINBOOL{.stdcall, dynlib: "version",
      importc: "VerQueryValueA".}
  proc VerFindFile*(uFlags: DWORD, szFileName: LPSTR, szWinDir: LPSTR,
                    szAppDir: LPSTR, szCurDir: LPSTR, lpuCurDirLen: PUINT,
                    szDestDir: LPSTR, lpuDestDirLen: PUINT): DWORD{.stdcall,
      dynlib: "version", importc: "VerFindFileA".}
  proc RegConnectRegistry*(lpMachineName: LPSTR, key: HKEY, phkResult: PHKEY): LONG{.
      stdcall, dynlib: "advapi32", importc: "RegConnectRegistryA".}
  proc RegCreateKey*(key: HKEY, lpSubKey: LPCSTR, phkResult: PHKEY): LONG{.
      stdcall, dynlib: "advapi32", importc: "RegCreateKeyA".}
  proc RegCreateKeyEx*(key: HKEY, lpSubKey: LPCSTR, Reserved: DWORD,
                       lpClass: LPSTR, dwOptions: DWORD, samDesired: REGSAM,
                       lpSecurityAttributes: LPSECURITY_ATTRIBUTES,
                       phkResult: PHKEY, lpdwDisposition: LPDWORD): LONG{.
      stdcall, dynlib: "advapi32", importc: "RegCreateKeyExA".}
  proc RegDeleteKey*(key: HKEY, lpSubKey: LPCSTR): LONG{.stdcall,
      dynlib: "advapi32", importc: "RegDeleteKeyA".}
  proc RegDeleteValue*(key: HKEY, lpValueName: LPCSTR): LONG{.stdcall,
      dynlib: "advapi32", importc: "RegDeleteValueA".}
  proc RegEnumKey*(key: HKEY, dwIndex: DWORD, lpName: LPSTR, cbName: DWORD): LONG{.
      stdcall, dynlib: "advapi32", importc: "RegEnumKeyA".}
  proc RegEnumKeyEx*(key: HKEY, dwIndex: DWORD, lpName: LPSTR,
                     lpcbName: LPDWORD, lpReserved: LPDWORD, lpClass: LPSTR,
                     lpcbClass: LPDWORD, lpftLastWriteTime: PFILETIME): LONG{.
      stdcall, dynlib: "advapi32", importc: "RegEnumKeyExA".}
  proc RegEnumValue*(key: HKEY, dwIndex: DWORD, lpValueName: LPSTR,
                     lpcbValueName: LPDWORD, lpReserved: LPDWORD,
                     lpType: LPDWORD, lpData: LPBYTE, lpcbData: LPDWORD): LONG{.
      stdcall, dynlib: "advapi32", importc: "RegEnumValueA".}
  proc RegLoadKey*(key: HKEY, lpSubKey: LPCSTR, lpFile: LPCSTR): LONG{.stdcall,
      dynlib: "advapi32", importc: "RegLoadKeyA".}
  proc RegOpenKey*(key: HKEY, lpSubKey: LPCSTR, phkResult: PHKEY): LONG{.
      stdcall, dynlib: "advapi32", importc: "RegOpenKeyA".}
  proc RegOpenKeyEx*(key: HKEY, lpSubKey: LPCSTR, ulOptions: DWORD,
                     samDesired: REGSAM, phkResult: PHKEY): LONG{.stdcall,
      dynlib: "advapi32", importc: "RegOpenKeyExA".}
  proc RegQueryInfoKey*(key: HKEY, lpClass: LPSTR, lpcbClass: LPDWORD,
                        lpReserved: LPDWORD, lpcSubKeys: LPDWORD,
                        lpcbMaxSubKeyLen: LPDWORD, lpcbMaxClassLen: LPDWORD,
                        lpcValues: LPDWORD, lpcbMaxValueNameLen: LPDWORD,
                        lpcbMaxValueLen: LPDWORD,
                        lpcbSecurityDescriptor: LPDWORD,
                        lpftLastWriteTime: PFILETIME): LONG{.stdcall,
      dynlib: "advapi32", importc: "RegQueryInfoKeyA".}
  proc RegQueryValue*(key: HKEY, lpSubKey: LPCSTR, lpValue: LPSTR,
                      lpcbValue: PLONG): LONG{.stdcall, dynlib: "advapi32",
      importc: "RegQueryValueA".}
  proc RegQueryMultipleValues*(key: HKEY, val_list: PVALENT, num_vals: DWORD,
                               lpValueBuf: LPSTR, ldwTotsize: LPDWORD): LONG{.
      stdcall, dynlib: "advapi32", importc: "RegQueryMultipleValuesA".}
  proc RegQueryValueEx*(key: HKEY, lpValueName: LPCSTR, lpReserved: LPDWORD,
                        lpType: LPDWORD, lpData: LPBYTE, lpcbData: LPDWORD): LONG{.
      stdcall, dynlib: "advapi32", importc: "RegQueryValueExA".}
  proc RegReplaceKey*(key: HKEY, lpSubKey: LPCSTR, lpNewFile: LPCSTR,
                      lpOldFile: LPCSTR): LONG{.stdcall, dynlib: "advapi32",
      importc: "RegReplaceKeyA".}
  proc RegRestoreKey*(key: HKEY, lpFile: LPCSTR, dwFlags: DWORD): LONG{.
      stdcall, dynlib: "advapi32", importc: "RegRestoreKeyA".}
  proc RegSaveKey*(key: HKEY, lpFile: LPCSTR,
                   lpSecurityAttributes: LPSECURITY_ATTRIBUTES): LONG{.stdcall,
      dynlib: "advapi32", importc: "RegSaveKeyA".}
  proc RegSetValue*(key: HKEY, lpSubKey: LPCSTR, dwType: DWORD, lpData: LPCSTR,
                    cbData: DWORD): LONG{.stdcall, dynlib: "advapi32",
      importc: "RegSetValueA".}
  proc RegSetValueEx*(key: HKEY, lpValueName: LPCSTR, Reserved: DWORD,
                      dwType: DWORD, lpData: LPBYTE, cbData: DWORD): LONG{.
      stdcall, dynlib: "advapi32", importc: "RegSetValueExA".}
  proc RegUnLoadKey*(key: HKEY, lpSubKey: LPCSTR): LONG{.stdcall,
      dynlib: "advapi32", importc: "RegUnLoadKeyA".}
  proc InitiateSystemShutdown*(lpMachineName: LPSTR, lpMessage: LPSTR,
                               dwTimeout: DWORD, bForceAppsClosed: WINBOOL,
                               bRebootAfterShutdown: WINBOOL): WINBOOL{.stdcall,
      dynlib: "advapi32", importc: "InitiateSystemShutdownA".}
  proc AbortSystemShutdown*(lpMachineName: LPSTR): WINBOOL{.stdcall,
      dynlib: "advapi32", importc: "AbortSystemShutdownA".}
  proc CompareString*(Locale: LCID, dwCmpFlags: DWORD, lpString1: LPCSTR,
                      cchCount1: int32, lpString2: LPCSTR, cchCount2: int32): int32{.
      stdcall, dynlib: "kernel32", importc: "CompareStringA".}
  proc LCMapString*(Locale: LCID, dwMapFlags: DWORD, lpSrcStr: LPCSTR,
                    cchSrc: int32, lpDestStr: LPSTR, cchDest: int32): int32{.
      stdcall, dynlib: "kernel32", importc: "LCMapStringA".}
  proc GetLocaleInfo*(Locale: LCID, LCType: LCTYPE, lpLCData: LPSTR,
                      cchData: int32): int32{.stdcall, dynlib: "kernel32",
      importc: "GetLocaleInfoA".}
  proc SetLocaleInfo*(Locale: LCID, LCType: LCTYPE, lpLCData: LPCSTR): WINBOOL{.
      stdcall, dynlib: "kernel32", importc: "SetLocaleInfoA".}
  proc GetTimeFormat*(Locale: LCID, dwFlags: DWORD, lpTime: LPSYSTEMTIME,
                      lpFormat: LPCSTR, lpTimeStr: LPSTR, cchTime: int32): int32{.
      stdcall, dynlib: "kernel32", importc: "GetTimeFormatA".}
  proc GetDateFormat*(Locale: LCID, dwFlags: DWORD, lpDate: LPSYSTEMTIME,
                      lpFormat: LPCSTR, lpDateStr: LPSTR, cchDate: int32): int32{.
      stdcall, dynlib: "kernel32", importc: "GetDateFormatA".}
  proc GetNumberFormat*(Locale: LCID, dwFlags: DWORD, lpValue: LPCSTR,
                        lpFormat: PNUMBERFMT, lpNumberStr: LPSTR,
                        cchNumber: int32): int32{.stdcall, dynlib: "kernel32",
      importc: "GetNumberFormatA".}
  proc GetCurrencyFormat*(Locale: LCID, dwFlags: DWORD, lpValue: LPCSTR,
                          lpFormat: PCURRENCYFMT, lpCurrencyStr: LPSTR,
                          cchCurrency: int32): int32{.stdcall,
      dynlib: "kernel32", importc: "GetCurrencyFormatA".}
  proc EnumCalendarInfo*(lpCalInfoEnumProc: CALINFO_ENUMPROC, Locale: LCID,
                         Calendar: CALID, CalType: CALTYPE): WINBOOL{.stdcall,
      dynlib: "kernel32", importc: "EnumCalendarInfoA".}
  proc EnumTimeFormats*(lpTimeFmtEnumProc: TIMEFMT_ENUMPROC, Locale: LCID,
                        dwFlags: DWORD): WINBOOL{.stdcall, dynlib: "kernel32",
      importc: "EnumTimeFormatsA".}
  proc EnumDateFormats*(lpDateFmtEnumProc: DATEFMT_ENUMPROC, Locale: LCID,
                        dwFlags: DWORD): WINBOOL{.stdcall, dynlib: "kernel32",
      importc: "EnumDateFormatsA".}
  proc GetStringTypeEx*(Locale: LCID, dwInfoType: DWORD, lpSrcStr: LPCSTR,
                        cchSrc: int32, lpCharType: LPWORD): WINBOOL{.stdcall,
      dynlib: "kernel32", importc: "GetStringTypeExA".}
  proc GetStringType*(Locale: LCID, dwInfoType: DWORD, lpSrcStr: LPCSTR,
                      cchSrc: int32, lpCharType: LPWORD): WINBOOL{.stdcall,
      dynlib: "kernel32", importc: "GetStringTypeA".}
  proc FoldString*(dwMapFlags: DWORD, lpSrcStr: LPCSTR, cchSrc: int32,
                   lpDestStr: LPSTR, cchDest: int32): int32{.stdcall,
      dynlib: "kernel32", importc: "FoldStringA".}
  proc EnumSystemLocales*(lpLocaleEnumProc: LOCALE_ENUMPROC, dwFlags: DWORD): WINBOOL{.
      stdcall, dynlib: "kernel32", importc: "EnumSystemLocalesA".}
  proc EnumSystemCodePages*(lpCodePageEnumProc: CODEPAGE_ENUMPROC,
                            dwFlags: DWORD): WINBOOL{.stdcall,
      dynlib: "kernel32", importc: "EnumSystemCodePagesA".}
  proc PeekConsoleInput*(hConsoleInput: HANDLE, lpBuffer: PINPUTRECORD,
                         nLength: DWORD, lpNumberOfEventsRead: LPDWORD): WINBOOL{.
      stdcall, dynlib: "kernel32", importc: "PeekConsoleInputA".}
  proc ReadConsoleInput*(hConsoleInput: HANDLE, lpBuffer: PINPUTRECORD,
                         nLength: DWORD, lpNumberOfEventsRead: LPDWORD): WINBOOL{.
      stdcall, dynlib: "kernel32", importc: "ReadConsoleInputA".}
  proc WriteConsoleInput*(hConsoleInput: HANDLE, lpBuffer: PINPUTRECORD,
                          nLength: DWORD, lpNumberOfEventsWritten: LPDWORD): WINBOOL{.
      stdcall, dynlib: "kernel32", importc: "WriteConsoleInputA".}
  proc ReadConsoleOutput*(hConsoleOutput: HANDLE, lpBuffer: PCHAR_INFO,
                          dwBufferSize: COORD, dwBufferCoord: COORD,
                          lpReadRegion: PSMALL_RECT): WINBOOL{.stdcall,
      dynlib: "kernel32", importc: "ReadConsoleOutputA".}
  proc WriteConsoleOutput*(hConsoleOutput: HANDLE, lpBuffer: PCHAR_INFO,
                           dwBufferSize: COORD, dwBufferCoord: COORD,
                           lpWriteRegion: PSMALL_RECT): WINBOOL{.stdcall,
      dynlib: "kernel32", importc: "WriteConsoleOutputA".}
  proc ReadConsoleOutputCharacter*(hConsoleOutput: HANDLE, lpCharacter: LPSTR,
                                   nLength: DWORD, dwReadCoord: COORD,
                                   lpNumberOfCharsRead: LPDWORD): WINBOOL{.
      stdcall, dynlib: "kernel32", importc: "ReadConsoleOutputCharacterA".}
  proc WriteConsoleOutputCharacter*(hConsoleOutput: HANDLE, lpCharacter: LPCSTR,
                                    nLength: DWORD, dwWriteCoord: COORD,
                                    lpNumberOfCharsWritten: LPDWORD): WINBOOL{.
      stdcall, dynlib: "kernel32", importc: "WriteConsoleOutputCharacterA".}
  proc FillConsoleOutputCharacter*(hConsoleOutput: HANDLE, cCharacter: CHAR,
                                   nLength: DWORD, dwWriteCoord: COORD,
                                   lpNumberOfCharsWritten: LPDWORD): WINBOOL{.
      stdcall, dynlib: "kernel32", importc: "FillConsoleOutputCharacterA".}
  proc ScrollConsoleScreenBuffer*(hConsoleOutput: HANDLE,
                                  lpScrollRectangle: PSMALL_RECT,
                                  lpClipRectangle: PSMALL_RECT,
                                  dwDestinationOrigin: COORD, lpFill: PCHAR_INFO): WINBOOL{.
      stdcall, dynlib: "kernel32", importc: "ScrollConsoleScreenBufferA".}
  proc GetConsoleTitle*(lpConsoleTitle: LPSTR, nSize: DWORD): DWORD{.stdcall,
      dynlib: "kernel32", importc: "GetConsoleTitleA".}
  proc SetConsoleTitle*(lpConsoleTitle: LPCSTR): WINBOOL{.stdcall,
      dynlib: "kernel32", importc: "SetConsoleTitleA".}
  proc ReadConsole*(hConsoleInput: HANDLE, lpBuffer: LPVOID,
                    nNumberOfCharsToRead: DWORD, lpNumberOfCharsRead: LPDWORD,
                    lpReserved: LPVOID): WINBOOL{.stdcall, dynlib: "kernel32",
      importc: "ReadConsoleA".}
  proc WriteConsole*(hConsoleOutput: HANDLE, lpBuffer: pointer,
                     nNumberOfCharsToWrite: DWORD,
                     lpNumberOfCharsWritten: LPDWORD, lpReserved: LPVOID): WINBOOL{.
      stdcall, dynlib: "kernel32", importc: "WriteConsoleA".}
  proc WNetAddConnection*(lpRemoteName: LPCSTR, lpPassword: LPCSTR,
                          lpLocalName: LPCSTR): DWORD{.stdcall, dynlib: "mpr",
      importc: "WNetAddConnectionA".}
  proc WNetAddConnection2*(lpNetResource: LPNETRESOURCE, lpPassword: LPCSTR,
                           lpUserName: LPCSTR, dwFlags: DWORD): DWORD{.stdcall,
      dynlib: "mpr", importc: "WNetAddConnection2A".}
  proc WNetAddConnection3*(hwndOwner: HWND, lpNetResource: LPNETRESOURCE,
                           lpPassword: LPCSTR, lpUserName: LPCSTR,
                           dwFlags: DWORD): DWORD{.stdcall, dynlib: "mpr",
      importc: "WNetAddConnection3A".}
  proc WNetCancelConnection*(lpName: LPCSTR, fForce: WINBOOL): DWORD{.stdcall,
      dynlib: "mpr", importc: "WNetCancelConnectionA".}
  proc WNetCancelConnection2*(lpName: LPCSTR, dwFlags: DWORD, fForce: WINBOOL): DWORD{.
      stdcall, dynlib: "mpr", importc: "WNetCancelConnection2A".}
  proc WNetGetConnection*(lpLocalName: LPCSTR, lpRemoteName: LPSTR,
                          lpnLength: LPDWORD): DWORD{.stdcall, dynlib: "mpr",
      importc: "WNetGetConnectionA".}
  proc WNetUseConnection*(hwndOwner: HWND, lpNetResource: LPNETRESOURCE,
                          lpUserID: LPCSTR, lpPassword: LPCSTR, dwFlags: DWORD,
                          lpAccessName: LPSTR, lpBufferSize: LPDWORD,
                          lpResult: LPDWORD): DWORD{.stdcall, dynlib: "mpr",
      importc: "WNetUseConnectionA".}
  proc WNetSetConnection*(lpName: LPCSTR, dwProperties: DWORD, pvValues: LPVOID): DWORD{.
      stdcall, dynlib: "mpr", importc: "WNetSetConnectionA".}
  proc WNetConnectionDialog1*(lpConnDlgStruct: LPCONNECTDLGSTRUCT): DWORD{.
      stdcall, dynlib: "mpr", importc: "WNetConnectionDialog1A".}
  proc WNetDisconnectDialog1*(lpConnDlgStruct: LPDISCDLGSTRUCT): DWORD{.stdcall,
      dynlib: "mpr", importc: "WNetDisconnectDialog1A".}
  proc WNetOpenEnum*(dwScope: DWORD, dwType: DWORD, dwUsage: DWORD,
                     lpNetResource: LPNETRESOURCE, lphEnum: LPHANDLE): DWORD{.
      stdcall, dynlib: "mpr", importc: "WNetOpenEnumA".}
  proc WNetEnumResource*(hEnum: HANDLE, lpcCount: LPDWORD, lpBuffer: LPVOID,
                         lpBufferSize: LPDWORD): DWORD{.stdcall, dynlib: "mpr",
      importc: "WNetEnumResourceA".}
  proc WNetGetUniversalName*(lpLocalPath: LPCSTR, dwInfoLevel: DWORD,
                             lpBuffer: LPVOID, lpBufferSize: LPDWORD): DWORD{.
      stdcall, dynlib: "mpr", importc: "WNetGetUniversalNameA".}
  proc WNetGetUser*(lpName: LPCSTR, lpUserName: LPSTR, lpnLength: LPDWORD): DWORD{.
      stdcall, dynlib: "mpr", importc: "WNetGetUserA".}
  proc WNetGetProviderName*(dwNetType: DWORD, lpProviderName: LPSTR,
                            lpBufferSize: LPDWORD): DWORD{.stdcall,
      dynlib: "mpr", importc: "WNetGetProviderNameA".}
  proc WNetGetNetworkInformation*(lpProvider: LPCSTR,
                                  lpNetInfoStruct: LPNETINFOSTRUCT): DWORD{.
      stdcall, dynlib: "mpr", importc: "WNetGetNetworkInformationA".}
  proc WNetGetLastError*(lpError: LPDWORD, lpErrorBuf: LPSTR,
                         nErrorBufSize: DWORD, lpNameBuf: LPSTR,
                         nNameBufSize: DWORD): DWORD{.stdcall, dynlib: "mpr",
      importc: "WNetGetLastErrorA".}
  proc MultinetGetConnectionPerformance*(lpNetResource: LPNETRESOURCE,
      lpNetConnectInfoStruct: LPNETCONNECTINFOSTRUCT): DWORD{.stdcall,
      dynlib: "mpr", importc: "MultinetGetConnectionPerformanceA".}
  proc ChangeServiceConfig*(hService: SC_HANDLE, dwServiceType: DWORD,
                            dwStartType: DWORD, dwErrorControl: DWORD,
                            lpBinaryPathName: LPCSTR, lpLoadOrderGroup: LPCSTR,
                            lpdwTagId: LPDWORD, lpDependencies: LPCSTR,
                            lpServiceStartName: LPCSTR, lpPassword: LPCSTR,
                            lpDisplayName: LPCSTR): WINBOOL{.stdcall,
      dynlib: "advapi32", importc: "ChangeServiceConfigA".}
  proc CreateService*(hSCManager: SC_HANDLE, lpServiceName: LPCSTR,
                      lpDisplayName: LPCSTR, dwDesiredAccess: DWORD,
                      dwServiceType: DWORD, dwStartType: DWORD,
                      dwErrorControl: DWORD, lpBinaryPathName: LPCSTR,
                      lpLoadOrderGroup: LPCSTR, lpdwTagId: LPDWORD,
                      lpDependencies: LPCSTR, lpServiceStartName: LPCSTR,
                      lpPassword: LPCSTR): SC_HANDLE{.stdcall,
      dynlib: "advapi32", importc: "CreateServiceA".}
  proc EnumDependentServices*(hService: SC_HANDLE, dwServiceState: DWORD,
                              lpServices: LPENUM_SERVICE_STATUS,
                              cbBufSize: DWORD, pcbBytesNeeded: LPDWORD,
                              lpServicesReturned: LPDWORD): WINBOOL{.stdcall,
      dynlib: "advapi32", importc: "EnumDependentServicesA".}
  proc EnumServicesStatus*(hSCManager: SC_HANDLE, dwServiceType: DWORD,
                           dwServiceState: DWORD,
                           lpServices: LPENUM_SERVICE_STATUS, cbBufSize: DWORD,
                           pcbBytesNeeded: LPDWORD, lpServicesReturned: LPDWORD,
                           lpResumeHandle: LPDWORD): WINBOOL{.stdcall,
      dynlib: "advapi32", importc: "EnumServicesStatusA".}
  proc GetServiceKeyName*(hSCManager: SC_HANDLE, lpDisplayName: LPCSTR,
                          lpServiceName: LPSTR, lpcchBuffer: LPDWORD): WINBOOL{.
      stdcall, dynlib: "advapi32", importc: "GetServiceKeyNameA".}
  proc GetServiceDisplayName*(hSCManager: SC_HANDLE, lpServiceName: LPCSTR,
                              lpDisplayName: LPSTR, lpcchBuffer: LPDWORD): WINBOOL{.
      stdcall, dynlib: "advapi32", importc: "GetServiceDisplayNameA".}
  proc OpenSCManager*(lpMachineName: LPCSTR, lpDatabaseName: LPCSTR,
                      dwDesiredAccess: DWORD): SC_HANDLE{.stdcall,
      dynlib: "advapi32", importc: "OpenSCManagerA".}
  proc OpenService*(hSCManager: SC_HANDLE, lpServiceName: LPCSTR,
                    dwDesiredAccess: DWORD): SC_HANDLE{.stdcall,
      dynlib: "advapi32", importc: "OpenServiceA".}
  proc QueryServiceConfig*(hService: SC_HANDLE,
                           lpServiceConfig: LPQUERY_SERVICE_CONFIG,
                           cbBufSize: DWORD, pcbBytesNeeded: LPDWORD): WINBOOL{.
      stdcall, dynlib: "advapi32", importc: "QueryServiceConfigA".}
  proc QueryServiceLockStatus*(hSCManager: SC_HANDLE,
                               lpLockStatus: LPQUERY_SERVICE_LOCK_STATUS,
                               cbBufSize: DWORD, pcbBytesNeeded: LPDWORD): WINBOOL{.
      stdcall, dynlib: "advapi32", importc: "QueryServiceLockStatusA".}
  proc RegisterServiceCtrlHandler*(lpServiceName: LPCSTR,
                                   lpHandlerProc: LPHANDLER_FUNCTION): SERVICE_STATUS_HANDLE{.
      stdcall, dynlib: "advapi32", importc: "RegisterServiceCtrlHandlerA".}
  proc StartServiceCtrlDispatcher*(lpServiceStartTable: LPSERVICE_TABLE_ENTRY): WINBOOL{.
      stdcall, dynlib: "advapi32", importc: "StartServiceCtrlDispatcherA".}
  proc StartService*(hService: SC_HANDLE, dwNumServiceArgs: DWORD,
                     lpServiceArgVectors: LPCSTR): WINBOOL{.stdcall,
      dynlib: "advapi32", importc: "StartServiceA".}
  proc DragQueryFile*(para1: HDROP, para2: int, para3: cstring, para4: int): int{.
      stdcall, dynlib: "shell32", importc: "DragQueryFileA".}
  proc ExtractAssociatedIcon*(para1: HINST, para2: cstring, para3: LPWORD): HICON{.
      stdcall, dynlib: "shell32", importc: "ExtractAssociatedIconA".}
  proc ExtractIcon*(para1: HINST, para2: cstring, para3: int): HICON{.stdcall,
      dynlib: "shell32", importc: "ExtractIconA".}
  proc FindExecutable*(para1: cstring, para2: cstring, para3: cstring): HINST{.
      stdcall, dynlib: "shell32", importc: "FindExecutableA".}
  proc ShellAbout*(para1: HWND, para2: cstring, para3: cstring, para4: HICON): int32{.
      stdcall, dynlib: "shell32", importc: "ShellAboutA".}
  proc ShellExecute*(para1: HWND, para2: cstring, para3: cstring,
                     para4: cstring, para5: cstring, para6: int32): HINST{.
      stdcall, dynlib: "shell32", importc: "ShellExecuteA".}
  proc Shell_NotifyIcon*(dwMessage: DWORD, lpData: PNotifyIconDataA): WINBOOL{.
      stdcall, dynlib: "shell32", importc: "Shell_NotifyIconA".}
  proc DdeCreateStringHandle*(para1: DWORD, para2: cstring, para3: int32): HSZ{.
      stdcall, dynlib: "user32", importc: "DdeCreateStringHandleA".}
  proc DdeInitialize*(para1: LPDWORD, para2: PFNCALLBACK, para3: DWORD,
                      para4: DWORD): UINT{.stdcall, dynlib: "user32",
      importc: "DdeInitializeA".}
  proc DdeQueryString*(para1: DWORD, para2: HSZ, para3: cstring, para4: DWORD,
                       para5: int32): DWORD{.stdcall, dynlib: "user32",
      importc: "DdeQueryStringA".}
  proc LogonUser*(para1: LPSTR, para2: LPSTR, para3: LPSTR, para4: DWORD,
                  para5: DWORD, para6: PHANDLE): WINBOOL{.stdcall,
      dynlib: "advapi32", importc: "LogonUserA".}
  proc CreateProcessAsUser*(para1: HANDLE, para2: LPCTSTR, para3: LPTSTR,
                            para4: LPSECURITY_ATTRIBUTES,
                            para5: LPSECURITY_ATTRIBUTES, para6: WINBOOL,
                            para7: DWORD, para8: LPVOID, para9: LPCTSTR,
                            para10: LPSTARTUPINFO, para11: LPPROCESS_INFORMATION): WINBOOL{.
      stdcall, dynlib: "advapi32", importc: "CreateProcessAsUserA".}
proc GetRandomRgn*(aHDC: HDC, aHRGN: HRGN, iNum: WINT): WINT{.stdcall,
     importc, dynlib: "gdi32".}

proc AccessCheck*(pSecurityDescriptor: PSECURITY_DESCRIPTOR,
                  ClientToken: HANDLE, DesiredAccess: DWORD,
                  GenericMapping: PGENERIC_MAPPING,
                  PrivilegeSet: PPRIVILEGE_SET, PrivilegeSetLength: LPDWORD,
                  GrantedAccess: LPDWORD, AccessStatus: LPBOOL): WINBOOL{.
    stdcall, dynlib: "advapi32", importc: "AccessCheck".}
proc FreeResource*(hResData: HGLOBAL): WINBOOL{.stdcall, dynlib: "kernel32",
    importc: "FreeResource".}
proc LockResource*(hResData: HGLOBAL): LPVOID{.stdcall, dynlib: "kernel32",
    importc: "LockResource".}
proc FreeLibrary*(hLibModule: HINST): WINBOOL{.stdcall, dynlib: "kernel32",
    importc: "FreeLibrary".}
proc FreeLibraryAndExitThread*(hLibModule: HMODULE, dwExitCode: DWORD){.stdcall,
    dynlib: "kernel32", importc: "FreeLibraryAndExitThread".}
proc DisableThreadLibraryCalls*(hLibModule: HMODULE): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "DisableThreadLibraryCalls".}
proc GetProcAddress*(hModule: HINST, lpProcName: LPCSTR): FARPROC{.stdcall,
    dynlib: "kernel32", importc: "GetProcAddress".}
proc GetVersion*(): DWORD{.stdcall, dynlib: "kernel32", importc: "GetVersion".}
proc GlobalAlloc*(uFlags: INT, dwBytes: DWORD): HGLOBAL{.stdcall,
    dynlib: "kernel32", importc: "GlobalAlloc".}
proc GlobalReAlloc*(hMem: HGLOBAL, dwBytes: DWORD, uFlags: INT): HGLOBAL{.
    stdcall, dynlib: "kernel32", importc: "GlobalReAlloc".}
proc GlobalSize*(hMem: HGLOBAL): DWORD{.stdcall, dynlib: "kernel32",
                                        importc: "GlobalSize".}
proc GlobalFlags*(hMem: HGLOBAL): UINT{.stdcall, dynlib: "kernel32",
                                        importc: "GlobalFlags".}
proc GlobalLock*(hMem: HGLOBAL): LPVOID{.stdcall, dynlib: "kernel32",
    importc: "GlobalLock".}
proc GlobalHandle*(pMem: LPCVOID): HGLOBAL{.stdcall, dynlib: "kernel32",
    importc: "GlobalHandle".}
proc GlobalUnlock*(hMem: HGLOBAL): WINBOOL{.stdcall, dynlib: "kernel32",
    importc: "GlobalUnlock".}
proc GlobalFree*(hMem: HGLOBAL): HGLOBAL{.stdcall, dynlib: "kernel32",
    importc: "GlobalFree".}
proc GlobalCompact*(dwMinFree: DWORD): UINT{.stdcall, dynlib: "kernel32",
    importc: "GlobalCompact".}
proc GlobalFix*(hMem: HGLOBAL){.stdcall, dynlib: "kernel32",
                                importc: "GlobalFix".}
proc GlobalUnfix*(hMem: HGLOBAL){.stdcall, dynlib: "kernel32",
                                  importc: "GlobalUnfix".}
proc GlobalWire*(hMem: HGLOBAL): LPVOID{.stdcall, dynlib: "kernel32",
    importc: "GlobalWire".}
proc GlobalUnWire*(hMem: HGLOBAL): WINBOOL{.stdcall, dynlib: "kernel32",
    importc: "GlobalUnWire".}
proc GlobalMemoryStatus*(lpBuffer: LPMEMORYSTATUS){.stdcall, dynlib: "kernel32",
    importc: "GlobalMemoryStatus".}
proc LocalAlloc*(uFlags: UINT, uBytes: UINT): HLOCAL{.stdcall,
    dynlib: "kernel32", importc: "LocalAlloc".}
proc LocalReAlloc*(hMem: HLOCAL, uBytes: UINT, uFlags: UINT): HLOCAL{.stdcall,
    dynlib: "kernel32", importc: "LocalReAlloc".}
proc LocalLock*(hMem: HLOCAL): LPVOID{.stdcall, dynlib: "kernel32",
                                       importc: "LocalLock".}
proc LocalHandle*(pMem: LPCVOID): HLOCAL{.stdcall, dynlib: "kernel32",
    importc: "LocalHandle".}
proc LocalUnlock*(hMem: HLOCAL): WINBOOL{.stdcall, dynlib: "kernel32",
    importc: "LocalUnlock".}
proc LocalSize*(hMem: HLOCAL): UINT{.stdcall, dynlib: "kernel32",
                                     importc: "LocalSize".}
proc LocalFlags*(hMem: HLOCAL): UINT{.stdcall, dynlib: "kernel32",
                                      importc: "LocalFlags".}
proc LocalFree*(hMem: HLOCAL): HLOCAL{.stdcall, dynlib: "kernel32",
                                       importc: "LocalFree".}
proc LocalShrink*(hMem: HLOCAL, cbNewSize: UINT): UINT{.stdcall,
    dynlib: "kernel32", importc: "LocalShrink".}
proc LocalCompact*(uMinFree: UINT): UINT{.stdcall, dynlib: "kernel32",
    importc: "LocalCompact".}
proc FlushInstructionCache*(hProcess: HANDLE, lpBaseAddress: LPCVOID,
                            dwSize: DWORD): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "FlushInstructionCache".}
proc VirtualAlloc*(lpAddress: LPVOID, dwSize: DWORD, flAllocationType: DWORD,
                   flProtect: DWORD): LPVOID{.stdcall, dynlib: "kernel32",
    importc: "VirtualAlloc".}
proc VirtualFree*(lpAddress: LPVOID, dwSize: DWORD, dwFreeType: DWORD): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "VirtualFree".}
proc VirtualProtect*(lpAddress: LPVOID, dwSize: DWORD, flNewProtect: DWORD,
                     lpflOldProtect: PDWORD): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "VirtualProtect".}
proc VirtualQuery*(lpAddress: LPCVOID, lpBuffer: PMEMORY_BASIC_INFORMATION,
                   dwLength: DWORD): DWORD{.stdcall, dynlib: "kernel32",
    importc: "VirtualQuery".}
proc VirtualProtectEx*(hProcess: HANDLE, lpAddress: LPVOID, dwSize: DWORD,
                       flNewProtect: DWORD, lpflOldProtect: PDWORD): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "VirtualProtectEx".}
proc VirtualQueryEx*(hProcess: HANDLE, lpAddress: LPCVOID,
                     lpBuffer: PMEMORY_BASIC_INFORMATION, dwLength: DWORD): DWORD{.
    stdcall, dynlib: "kernel32", importc: "VirtualQueryEx".}
proc HeapCreate*(flOptions: DWORD, dwInitialSize: DWORD, dwMaximumSize: DWORD): HANDLE{.
    stdcall, dynlib: "kernel32", importc: "HeapCreate".}
proc HeapDestroy*(hHeap: HANDLE): WINBOOL{.stdcall, dynlib: "kernel32",
    importc: "HeapDestroy".}
proc HeapAlloc*(hHeap: HANDLE, dwFlags: DWORD, dwBytes: DWORD): LPVOID{.stdcall,
    dynlib: "kernel32", importc: "HeapAlloc".}
proc HeapReAlloc*(hHeap: HANDLE, dwFlags: DWORD, lpMem: LPVOID, dwBytes: DWORD): LPVOID{.
    stdcall, dynlib: "kernel32", importc: "HeapReAlloc".}
proc HeapFree*(hHeap: HANDLE, dwFlags: DWORD, lpMem: LPVOID): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "HeapFree".}
proc HeapSize*(hHeap: HANDLE, dwFlags: DWORD, lpMem: LPCVOID): DWORD{.stdcall,
    dynlib: "kernel32", importc: "HeapSize".}
proc HeapValidate*(hHeap: HANDLE, dwFlags: DWORD, lpMem: LPCVOID): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "HeapValidate".}
proc HeapCompact*(hHeap: HANDLE, dwFlags: DWORD): UINT{.stdcall,
    dynlib: "kernel32", importc: "HeapCompact".}
proc GetProcessHeap*(): HANDLE{.stdcall, dynlib: "kernel32",
                                importc: "GetProcessHeap".}
proc GetProcessHeaps*(NumberOfHeaps: DWORD, ProcessHeaps: PHANDLE): DWORD{.
    stdcall, dynlib: "kernel32", importc: "GetProcessHeaps".}
proc HeapLock*(hHeap: HANDLE): WINBOOL{.stdcall, dynlib: "kernel32",
                                        importc: "HeapLock".}
proc HeapUnlock*(hHeap: HANDLE): WINBOOL{.stdcall, dynlib: "kernel32",
    importc: "HeapUnlock".}
proc HeapWalk*(hHeap: HANDLE, lpEntry: LPPROCESS_HEAP_ENTRY): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "HeapWalk".}
proc GetProcessAffinityMask*(hProcess: HANDLE, lpProcessAffinityMask: LPDWORD,
                             lpSystemAffinityMask: LPDWORD): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "GetProcessAffinityMask".}
proc GetProcessTimes*(hProcess: HANDLE, lpCreationTime: LPFILETIME,
                      lpExitTime: LPFILETIME, lpKernelTime: LPFILETIME,
                      lpUserTime: LPFILETIME): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "GetProcessTimes".}
proc GetProcessWorkingSetSize*(hProcess: HANDLE,
                               lpMinimumWorkingSetSize: LPDWORD,
                               lpMaximumWorkingSetSize: LPDWORD): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "GetProcessWorkingSetSize".}
proc SetProcessWorkingSetSize*(hProcess: HANDLE, dwMinimumWorkingSetSize: DWORD,
                               dwMaximumWorkingSetSize: DWORD): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "SetProcessWorkingSetSize".}
proc OpenProcess*(dwDesiredAccess: DWORD, bInheritHandle: WINBOOL,
                  dwProcessId: DWORD): HANDLE{.stdcall, dynlib: "kernel32",
    importc: "OpenProcess".}
proc GetCurrentProcess*(): HANDLE{.stdcall, dynlib: "kernel32",
                                   importc: "GetCurrentProcess".}
proc GetCurrentProcessId*(): DWORD{.stdcall, dynlib: "kernel32",
                                    importc: "GetCurrentProcessId".}
proc ExitProcess*(uExitCode: UINT){.stdcall, dynlib: "kernel32",
                                    importc: "ExitProcess".}
proc TerminateProcess*(hProcess: HANDLE, uExitCode: UINT): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "TerminateProcess".}
proc SetProcessAffinityMask*(hProcess: THandle, dwProcessAffinityMask: DWORD): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "SetProcessAffinityMask".}
proc GetExitCodeProcess*(hProcess: HANDLE, lpExitCode: LPDWORD): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "GetExitCodeProcess".}
proc FatalExit*(ExitCode: int32){.stdcall, dynlib: "kernel32",
                                  importc: "FatalExit".}
proc RaiseException*(dwExceptionCode: DWORD, dwExceptionFlags: DWORD,
                     nNumberOfArguments: DWORD, lpArguments: LPDWORD){.stdcall,
    dynlib: "kernel32", importc: "RaiseException".}
proc UnhandledExceptionFilter*(ExceptionInfo: lpemptyrecord): LONG{.stdcall,
    dynlib: "kernel32", importc: "UnhandledExceptionFilter".}
proc CreateRemoteThread*(hProcess: HANDLE,
                         lpThreadAttributes: LPSECURITY_ATTRIBUTES,
                         dwStackSize: DWORD,
                         lpStartAddress: LPTHREAD_START_ROUTINE,
                         lpParameter: LPVOID, dwCreationFlags: DWORD,
                         lpThreadId: LPDWORD): HANDLE{.stdcall,
    dynlib: "kernel32", importc: "CreateRemoteThread".}
proc GetCurrentThread*(): HANDLE{.stdcall, dynlib: "kernel32",
                                  importc: "GetCurrentThread".}
proc GetCurrentThreadId*(): DWORD{.stdcall, dynlib: "kernel32",
                                   importc: "GetCurrentThreadId".}
proc SetThreadAffinityMask*(hThread: HANDLE, dwThreadAffinityMask: DWORD): DWORD{.
    stdcall, dynlib: "kernel32", importc: "SetThreadAffinityMask".}
proc SetThreadPriority*(hThread: HANDLE, nPriority: int32): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "SetThreadPriority".}
proc GetThreadPriority*(hThread: HANDLE): int32{.stdcall, dynlib: "kernel32",
    importc: "GetThreadPriority".}
proc GetThreadTimes*(hThread: HANDLE, lpCreationTime: LPFILETIME,
                     lpExitTime: LPFILETIME, lpKernelTime: LPFILETIME,
                     lpUserTime: LPFILETIME): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "GetThreadTimes".}
proc ExitThread*(dwExitCode: DWORD){.stdcall, dynlib: "kernel32",
                                     importc: "ExitThread".}
proc TerminateThread*(hThread: HANDLE, dwExitCode: DWORD): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "TerminateThread".}
proc GetExitCodeThread*(hThread: HANDLE, lpExitCode: LPDWORD): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "GetExitCodeThread".}
proc GetThreadSelectorEntry*(hThread: HANDLE, dwSelector: DWORD,
                             lpSelectorEntry: LPLDT_ENTRY): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "GetThreadSelectorEntry".}
proc GetLastError*(): DWORD{.stdcall, dynlib: "kernel32",
                             importc: "GetLastError".}
proc SetLastError*(dwErrCode: DWORD){.stdcall, dynlib: "kernel32",
                                      importc: "SetLastError".}
proc CreateIoCompletionPort*(FileHandle: HANDLE, ExistingCompletionPort: HANDLE,
                             CompletionKey: DWORD,
                             NumberOfConcurrentThreads: DWORD): HANDLE{.stdcall,
    dynlib: "kernel32", importc: "CreateIoCompletionPort".}
proc SetErrorMode*(uMode: UINT): UINT{.stdcall, dynlib: "kernel32",
                                       importc: "SetErrorMode".}
proc ReadProcessMemory*(hProcess: HANDLE, lpBaseAddress: LPCVOID,
                        lpBuffer: LPVOID, nSize: DWORD,
                        lpNumberOfBytesRead: LPDWORD): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "ReadProcessMemory".}
proc WriteProcessMemory*(hProcess: HANDLE, lpBaseAddress: LPVOID,
                         lpBuffer: LPVOID, nSize: DWORD,
                         lpNumberOfBytesWritten: LPDWORD): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "WriteProcessMemory".}
proc GetThreadContext*(hThread: HANDLE, lpContext: LPCONTEXT): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "GetThreadContext".}
proc SuspendThread*(hThread: HANDLE): DWORD{.stdcall, dynlib: "kernel32",
    importc: "SuspendThread".}
proc ResumeThread*(hThread: HANDLE): DWORD{.stdcall, dynlib: "kernel32",
    importc: "ResumeThread".}
proc DebugBreak*(){.stdcall, dynlib: "kernel32", importc: "DebugBreak".}
proc WaitForDebugEvent*(lpDebugEvent: LPDEBUG_EVENT, dwMilliseconds: DWORD): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "WaitForDebugEvent".}
proc ContinueDebugEvent*(dwProcessId: DWORD, dwThreadId: DWORD,
                         dwContinueStatus: DWORD): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "ContinueDebugEvent".}
proc DebugActiveProcess*(dwProcessId: DWORD): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "DebugActiveProcess".}
proc InitializeCriticalSection*(lpCriticalSection: LPCRITICAL_SECTION){.stdcall,
    dynlib: "kernel32", importc: "InitializeCriticalSection".}
proc EnterCriticalSection*(lpCriticalSection: LPCRITICAL_SECTION){.stdcall,
    dynlib: "kernel32", importc: "EnterCriticalSection".}
proc LeaveCriticalSection*(lpCriticalSection: LPCRITICAL_SECTION){.stdcall,
    dynlib: "kernel32", importc: "LeaveCriticalSection".}
proc DeleteCriticalSection*(lpCriticalSection: LPCRITICAL_SECTION){.stdcall,
    dynlib: "kernel32", importc: "DeleteCriticalSection".}
proc TryEnterCriticalSection*(lpCriticalSection: LPCRITICAL_SECTION): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "TryEnterCriticalSection".}
proc SetEvent*(hEvent: HANDLE): WINBOOL{.stdcall, dynlib: "kernel32",
    importc: "SetEvent".}
proc ResetEvent*(hEvent: HANDLE): WINBOOL{.stdcall, dynlib: "kernel32",
    importc: "ResetEvent".}
proc PulseEvent*(hEvent: HANDLE): WINBOOL{.stdcall, dynlib: "kernel32",
    importc: "PulseEvent".}
proc ReleaseSemaphore*(hSemaphore: HANDLE, lReleaseCount: LONG,
                       lpPreviousCount: LPLONG): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "ReleaseSemaphore".}
proc ReleaseMutex*(hMutex: HANDLE): WINBOOL{.stdcall, dynlib: "kernel32",
    importc: "ReleaseMutex".}
proc WaitForSingleObject*(hHandle: HANDLE, dwMilliseconds: DWORD): DWORD{.
    stdcall, dynlib: "kernel32", importc: "WaitForSingleObject".}

proc Sleep*(dwMilliseconds: DWORD){.stdcall, dynlib: "kernel32",
                                    importc: "Sleep".}
proc LoadResource*(hModule: HINST, hResInfo: HRSRC): HGLOBAL{.stdcall,
    dynlib: "kernel32", importc: "LoadResource".}
proc SizeofResource*(hModule: HINST, hResInfo: HRSRC): DWORD{.stdcall,
    dynlib: "kernel32", importc: "SizeofResource".}
proc GlobalDeleteAtom*(nAtom: ATOM): ATOM{.stdcall, dynlib: "kernel32",
    importc: "GlobalDeleteAtom".}
proc InitAtomTable*(nSize: DWORD): WINBOOL{.stdcall, dynlib: "kernel32",
    importc: "InitAtomTable".}
proc DeleteAtom*(nAtom: ATOM): ATOM{.stdcall, dynlib: "kernel32",
                                     importc: "DeleteAtom".}
proc SetHandleCount*(uNumber: UINT): UINT{.stdcall, dynlib: "kernel32",
    importc: "SetHandleCount".}
proc GetLogicalDrives*(): DWORD{.stdcall, dynlib: "kernel32",
                                 importc: "GetLogicalDrives".}
proc LockFile*(hFile: HANDLE, dwFileOffsetLow: DWORD, dwFileOffsetHigh: DWORD,
               nNumberOfBytesToLockLow: DWORD, nNumberOfBytesToLockHigh: DWORD): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "LockFile".}
proc UnlockFile*(hFile: HANDLE, dwFileOffsetLow: DWORD, dwFileOffsetHigh: DWORD,
                 nNumberOfBytesToUnlockLow: DWORD,
                 nNumberOfBytesToUnlockHigh: DWORD): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "UnlockFile".}
proc LockFileEx*(hFile: HANDLE, dwFlags: DWORD, dwReserved: DWORD,
                 nNumberOfBytesToLockLow: DWORD,
                 nNumberOfBytesToLockHigh: DWORD, lpOverlapped: LPOVERLAPPED): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "LockFileEx".}
proc UnlockFileEx*(hFile: HANDLE, dwReserved: DWORD,
                   nNumberOfBytesToUnlockLow: DWORD,
                   nNumberOfBytesToUnlockHigh: DWORD, lpOverlapped: LPOVERLAPPED): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "UnlockFileEx".}
proc GetFileInformationByHandle*(hFile: HANDLE, lpFileInformation: LPBY_HANDLE_FILE_INFORMATION): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "GetFileInformationByHandle".}
proc GetFileType*(hFile: HANDLE): DWORD{.stdcall, dynlib: "kernel32",
    importc: "GetFileType".}
proc GetFileSize*(hFile: HANDLE, lpFileSizeHigh: LPDWORD): DWORD{.stdcall,
    dynlib: "kernel32", importc: "GetFileSize".}
proc GetStdHandle*(nStdHandle: DWORD): HANDLE{.stdcall, dynlib: "kernel32",
    importc: "GetStdHandle".}
proc SetStdHandle*(nStdHandle: DWORD, hHandle: HANDLE): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "SetStdHandle".}
proc FlushFileBuffers*(hFile: HANDLE): WINBOOL{.stdcall, dynlib: "kernel32",
    importc: "FlushFileBuffers".}
proc DeviceIoControl*(hDevice: HANDLE, dwIoControlCode: DWORD,
                      lpInBuffer: LPVOID, nInBufferSize: DWORD,
                      lpOutBuffer: LPVOID, nOutBufferSize: DWORD,
                      lpBytesReturned: LPDWORD, lpOverlapped: LPOVERLAPPED): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "DeviceIoControl".}
proc SetEndOfFile*(hFile: HANDLE): WINBOOL{.stdcall, dynlib: "kernel32",
    importc: "SetEndOfFile".}
proc SetFilePointer*(hFile: HANDLE, lDistanceToMove: LONG,
                     lpDistanceToMoveHigh: PLONG, dwMoveMethod: DWORD): DWORD{.
    stdcall, dynlib: "kernel32", importc: "SetFilePointer".}
proc FindClose*(hFindFile: HANDLE): WINBOOL{.stdcall, dynlib: "kernel32",
    importc: "FindClose".}
proc GetFileTime*(hFile: HANDLE, lpCreationTime: LPFILETIME,
                  lpLastAccessTime: LPFILETIME, lpLastWriteTime: LPFILETIME): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "GetFileTime".}
proc SetFileTime*(hFile: HANDLE, lpCreationTime: LPFILETIME,
                  lpLastAccessTime: LPFILETIME, lpLastWriteTime: LPFILETIME): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "SetFileTime".}
proc CloseHandle*(hObject: HANDLE): WINBOOL{.stdcall, dynlib: "kernel32",
    importc: "CloseHandle".}
proc DuplicateHandle*(hSourceProcessHandle: HANDLE, hSourceHandle: HANDLE,
                      hTargetProcessHandle: HANDLE, lpTargetHandle: LPHANDLE,
                      dwDesiredAccess: DWORD, bInheritHandle: WINBOOL,
                      dwOptions: DWORD): WINBOOL{.stdcall, dynlib: "kernel32",
    importc: "DuplicateHandle".}
proc GetHandleInformation*(hObject: HANDLE, lpdwFlags: LPDWORD): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "GetHandleInformation".}
proc SetHandleInformation*(hObject: HANDLE, dwMask: DWORD, dwFlags: DWORD): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "SetHandleInformation".}
proc LoadModule*(lpModuleName: LPCSTR, lpParameterBlock: LPVOID): DWORD{.
    stdcall, dynlib: "kernel32", importc: "LoadModule".}
proc WinExec*(lpCmdLine: LPCSTR, uCmdShow: UINT): UINT{.stdcall,
    dynlib: "kernel32", importc: "WinExec".}
proc ClearCommBreak*(hFile: HANDLE): WINBOOL{.stdcall, dynlib: "kernel32",
    importc: "ClearCommBreak".}
proc ClearCommError*(hFile: HANDLE, lpErrors: LPDWORD, lpStat: LPCOMSTAT): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "ClearCommError".}
proc SetupComm*(hFile: HANDLE, dwInQueue: DWORD, dwOutQueue: DWORD): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "SetupComm".}
proc EscapeCommFunction*(hFile: HANDLE, dwFunc: DWORD): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "EscapeCommFunction".}
proc GetCommConfig*(hCommDev: HANDLE, lpCC: LPCOMMCONFIG, lpdwSize: LPDWORD): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "GetCommConfig".}
proc GetCommProperties*(hFile: HANDLE, lpCommProp: LPCOMMPROP): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "GetCommProperties".}
proc GetCommModemStatus*(hFile: HANDLE, lpModemStat: PDWORD): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "GetCommModemStatus".}
proc GetCommState*(hFile: HANDLE, lpDCB: PDCB): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "GetCommState".}
proc GetCommTimeouts*(hFile: HANDLE, lpCommTimeouts: PCOMMTIMEOUTS): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "GetCommTimeouts".}
proc PurgeComm*(hFile: HANDLE, dwFlags: DWORD): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "PurgeComm".}
proc SetCommBreak*(hFile: HANDLE): WINBOOL{.stdcall, dynlib: "kernel32",
    importc: "SetCommBreak".}
proc SetCommConfig*(hCommDev: HANDLE, lpCC: LPCOMMCONFIG, dwSize: DWORD): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "SetCommConfig".}
proc SetCommMask*(hFile: HANDLE, dwEvtMask: DWORD): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "SetCommMask".}
proc SetCommState*(hFile: HANDLE, lpDCB: LPDCB): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "SetCommState".}
proc SetCommTimeouts*(hFile: HANDLE, lpCommTimeouts: LPCOMMTIMEOUTS): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "SetCommTimeouts".}
proc TransmitCommChar*(hFile: HANDLE, cChar: char): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "TransmitCommChar".}
proc WaitCommEvent*(hFile: HANDLE, lpEvtMask: LPDWORD,
                    lpOverlapped: LPOVERLAPPED): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "WaitCommEvent".}
proc SetTapePosition*(hDevice: HANDLE, dwPositionMethod: DWORD,
                      dwPartition: DWORD, dwOffsetLow: DWORD,
                      dwOffsetHigh: DWORD, bImmediate: WINBOOL): DWORD{.stdcall,
    dynlib: "kernel32", importc: "SetTapePosition".}
proc GetTapePosition*(hDevice: HANDLE, dwPositionType: DWORD,
                      lpdwPartition: LPDWORD, lpdwOffsetLow: LPDWORD,
                      lpdwOffsetHigh: LPDWORD): DWORD{.stdcall,
    dynlib: "kernel32", importc: "GetTapePosition".}
proc PrepareTape*(hDevice: HANDLE, dwOperation: DWORD, bImmediate: WINBOOL): DWORD{.
    stdcall, dynlib: "kernel32", importc: "PrepareTape".}
proc EraseTape*(hDevice: HANDLE, dwEraseType: DWORD, bImmediate: WINBOOL): DWORD{.
    stdcall, dynlib: "kernel32", importc: "EraseTape".}
proc CreateTapePartition*(hDevice: HANDLE, dwPartitionMethod: DWORD,
                          dwCount: DWORD, dwSize: DWORD): DWORD{.stdcall,
    dynlib: "kernel32", importc: "CreateTapePartition".}
proc WriteTapemark*(hDevice: HANDLE, dwTapemarkType: DWORD,
                    dwTapemarkCount: DWORD, bImmediate: WINBOOL): DWORD{.
    stdcall, dynlib: "kernel32", importc: "WriteTapemark".}
proc GetTapeStatus*(hDevice: HANDLE): DWORD{.stdcall, dynlib: "kernel32",
    importc: "GetTapeStatus".}
proc GetTapeParameters*(hDevice: HANDLE, dwOperation: DWORD, lpdwSize: LPDWORD,
                        lpTapeInformation: LPVOID): DWORD{.stdcall,
    dynlib: "kernel32", importc: "GetTapeParameters".}
proc SetTapeParameters*(hDevice: HANDLE, dwOperation: DWORD,
                        lpTapeInformation: LPVOID): DWORD{.stdcall,
    dynlib: "kernel32", importc: "SetTapeParameters".}
proc Beep*(dwFreq: DWORD, dwDuration: DWORD): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "Beep".}
proc MulDiv*(nNumber: int32, nNumerator: int32, nDenominator: int32): int32{.
    stdcall, dynlib: "kernel32", importc: "MulDiv".}
proc GetSystemTime*(lpSystemTime: LPSYSTEMTIME){.stdcall, dynlib: "kernel32",
    importc: "GetSystemTime".}
proc GetSystemTimeAsFileTime*(lpSystemTimeAsFileTime: LPFILETIME){.stdcall,
    dynlib: "kernel32", importc: "GetSystemTimeAsFileTime".}
proc SetSystemTime*(lpSystemTime: LPSYSTEMTIME): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "SetSystemTime".}
proc GetLocalTime*(lpSystemTime: LPSYSTEMTIME){.stdcall, dynlib: "kernel32",
    importc: "GetLocalTime".}
proc SetLocalTime*(lpSystemTime: LPSYSTEMTIME): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "SetLocalTime".}
proc GetSystemInfo*(lpSystemInfo: LPSYSTEM_INFO){.stdcall, dynlib: "kernel32",
    importc: "GetSystemInfo".}
proc SystemTimeToTzSpecificLocalTime*(lpTimeZoneInformation: LPTIME_ZONE_INFORMATION,
                                      lpUniversalTime: LPSYSTEMTIME,
                                      lpLocalTime: LPSYSTEMTIME): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "SystemTimeToTzSpecificLocalTime".}
proc GetTimeZoneInformation*(lpTimeZoneInformation: LPTIME_ZONE_INFORMATION): DWORD{.
    stdcall, dynlib: "kernel32", importc: "GetTimeZoneInformation".}
proc SetTimeZoneInformation*(lpTimeZoneInformation: LPTIME_ZONE_INFORMATION): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "SetTimeZoneInformation".}
proc SystemTimeToFileTime*(lpSystemTime: LPSYSTEMTIME, lpFileTime: LPFILETIME): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "SystemTimeToFileTime".}
proc FileTimeToLocalFileTime*(FileTime: LPFILETIME,
                              lpLocalFileTime: LPFILETIME): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "FileTimeToLocalFileTime".}
proc LocalFileTimeToFileTime*(lpLocalFileTime: LPFILETIME,
                              lpFileTime: LPFILETIME): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "LocalFileTimeToFileTime".}
proc FileTimeToSystemTime*(lpFileTime: LPFILETIME, lpSystemTime: LPSYSTEMTIME): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "FileTimeToSystemTime".}
proc CompareFileTime*(lpFileTime1: LPFILETIME, lpFileTime2: LPFILETIME): LONG{.
    stdcall, dynlib: "kernel32", importc: "CompareFileTime".}
proc FileTimeToDosDateTime*(lpFileTime: LPFILETIME, lpFatDate: LPWORD,
                            lpFatTime: LPWORD): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "FileTimeToDosDateTime".}
proc DosDateTimeToFileTime*(wFatDate: int16, wFatTime: int16,
                            lpFileTime: LPFILETIME): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "DosDateTimeToFileTime".}
proc GetTickCount*(): DWORD{.stdcall, dynlib: "kernel32",
                             importc: "GetTickCount".}
proc SetSystemTimeAdjustment*(dwTimeAdjustment: DWORD,
                              bTimeAdjustmentDisabled: WINBOOL): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "SetSystemTimeAdjustment".}
proc GetSystemTimeAdjustment*(lpTimeAdjustment: PDWORD, lpTimeIncrement: PDWORD,
                              lpTimeAdjustmentDisabled: PWINBOOL): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "GetSystemTimeAdjustment".}
proc CreatePipe*(hReadPipe: PHANDLE, hWritePipe: PHANDLE,
                 lpPipeAttributes: LPSECURITY_ATTRIBUTES, nSize: DWORD): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "CreatePipe".}
proc ConnectNamedPipe*(hNamedPipe: HANDLE, lpOverlapped: LPOVERLAPPED): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "ConnectNamedPipe".}
proc DisconnectNamedPipe*(hNamedPipe: HANDLE): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "DisconnectNamedPipe".}
proc SetNamedPipeHandleState*(hNamedPipe: HANDLE, lpMode: LPDWORD,
                              lpMaxCollectionCount: LPDWORD,
                              lpCollectDataTimeout: LPDWORD): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "SetNamedPipeHandleState".}
proc GetNamedPipeInfo*(hNamedPipe: HANDLE, lpFlags: LPDWORD,
                       lpOutBufferSize: LPDWORD, lpInBufferSize: LPDWORD,
                       lpMaxInstances: LPDWORD): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "GetNamedPipeInfo".}
proc PeekNamedPipe*(hNamedPipe: HANDLE, lpBuffer: LPVOID, nBufferSize: DWORD,
                    lpBytesRead: LPDWORD, lpTotalBytesAvail: LPDWORD,
                    lpBytesLeftThisMessage: LPDWORD): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "PeekNamedPipe".}
proc TransactNamedPipe*(hNamedPipe: HANDLE, lpInBuffer: LPVOID,
                        nInBufferSize: DWORD, lpOutBuffer: LPVOID,
                        nOutBufferSize: DWORD, lpBytesRead: LPDWORD,
                        lpOverlapped: LPOVERLAPPED): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "TransactNamedPipe".}
proc GetMailslotInfo*(hMailslot: HANDLE, lpMaxMessageSize: LPDWORD,
                      lpNextSize: LPDWORD, lpMessageCount: LPDWORD,
                      lpReadTimeout: LPDWORD): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "GetMailslotInfo".}
proc SetMailslotInfo*(hMailslot: HANDLE, lReadTimeout: DWORD): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "SetMailslotInfo".}
proc MapViewOfFile*(hFileMappingObject: HANDLE, dwDesiredAccess: DWORD,
                    dwFileOffsetHigh: DWORD, dwFileOffsetLow: DWORD,
                    dwNumberOfBytesToMap: DWORD): LPVOID{.stdcall,
    dynlib: "kernel32", importc: "MapViewOfFile".}
proc FlushViewOfFile*(lpBaseAddress: LPCVOID, dwNumberOfBytesToFlush: DWORD): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "FlushViewOfFile".}
proc UnmapViewOfFile*(lpBaseAddress: LPVOID): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "UnmapViewOfFile".}
proc OpenFile*(lpFileName: LPCSTR, lpReOpenBuff: LPOFSTRUCT, uStyle: UINT): HFILE{.
    stdcall, dynlib: "kernel32", importc: "OpenFile".}
proc lopen*(lpPathName: LPCSTR, iReadWrite: int32): HFILE{.stdcall,
    dynlib: "kernel32", importc: "_lopen".}
proc lcreat*(lpPathName: LPCSTR, iAttribute: int32): HFILE{.stdcall,
    dynlib: "kernel32", importc: "_lcreat".}
proc lread*(hFile: HFILE, lpBuffer: LPVOID, uBytes: UINT): UINT{.stdcall,
    dynlib: "kernel32", importc: "_lread".}
proc lwrite*(hFile: HFILE, lpBuffer: LPCSTR, uBytes: UINT): UINT{.stdcall,
    dynlib: "kernel32", importc: "_lwrite".}
proc hread*(hFile: HFILE, lpBuffer: LPVOID, lBytes: int32): int32{.stdcall,
    dynlib: "kernel32", importc: "_hread".}
proc hwrite*(hFile: HFILE, lpBuffer: LPCSTR, lBytes: int32): int32{.stdcall,
    dynlib: "kernel32", importc: "_hwrite".}
proc lclose*(file: HFILE): HFILE{.stdcall, dynlib: "kernel32",
                                   importc: "_lclose".}
proc llseek*(file: HFILE, lOffset: LONG, iOrigin: int32): LONG{.stdcall,
    dynlib: "kernel32", importc: "_llseek".}
proc IsTextUnicode*(lpBuffer: LPVOID, cb: int32, lpi: LPINT): WINBOOL{.stdcall,
    dynlib: "advapi32", importc: "IsTextUnicode".}
proc TlsAlloc*(): DWORD{.stdcall, dynlib: "kernel32", importc: "TlsAlloc".}
proc TlsGetValue*(dwTlsIndex: DWORD): LPVOID{.stdcall, dynlib: "kernel32",
    importc: "TlsGetValue".}
proc TlsSetValue*(dwTlsIndex: DWORD, lpTlsValue: LPVOID): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "TlsSetValue".}
proc TlsFree*(dwTlsIndex: DWORD): WINBOOL{.stdcall, dynlib: "kernel32",
    importc: "TlsFree".}
proc SleepEx*(dwMilliseconds: DWORD, bAlertable: WINBOOL): DWORD{.stdcall,
    dynlib: "kernel32", importc: "SleepEx".}
proc WaitForSingleObjectEx*(hHandle: HANDLE, dwMilliseconds: DWORD,
                            bAlertable: WINBOOL): DWORD{.stdcall,
    dynlib: "kernel32", importc: "WaitForSingleObjectEx".}
proc WaitForMultipleObjectsEx*(nCount: DWORD, lpHandles: LPHANDLE,
                               bWaitAll: WINBOOL, dwMilliseconds: DWORD,
                               bAlertable: WINBOOL): DWORD{.stdcall,
    dynlib: "kernel32", importc: "WaitForMultipleObjectsEx".}
proc ReadFileEx*(hFile: HANDLE, lpBuffer: LPVOID, nNumberOfBytesToRead: DWORD,
                 lpOverlapped: LPOVERLAPPED,
                 lpCompletionRoutine: LPOVERLAPPED_COMPLETION_ROUTINE): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "ReadFileEx".}
proc WriteFileEx*(hFile: HANDLE, lpBuffer: LPCVOID,
                  nNumberOfBytesToWrite: DWORD, lpOverlapped: LPOVERLAPPED,
                  lpCompletionRoutine: LPOVERLAPPED_COMPLETION_ROUTINE): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "WriteFileEx".}
proc BackupRead*(hFile: HANDLE, lpBuffer: LPBYTE, nNumberOfBytesToRead: DWORD,
                 lpNumberOfBytesRead: LPDWORD, bAbort: WINBOOL,
                 bProcessSecurity: WINBOOL, lpContext: var LPVOID): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "BackupRead".}
proc BackupSeek*(hFile: HANDLE, dwLowBytesToSeek: DWORD,
                 dwHighBytesToSeek: DWORD, lpdwLowByteSeeked: LPDWORD,
                 lpdwHighByteSeeked: LPDWORD, lpContext: var LPVOID): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "BackupSeek".}
proc BackupWrite*(hFile: HANDLE, lpBuffer: LPBYTE, nNumberOfBytesToWrite: DWORD,
                  lpNumberOfBytesWritten: LPDWORD, bAbort: WINBOOL,
                  bProcessSecurity: WINBOOL, lpContext: var LPVOID): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "BackupWrite".}
proc SetProcessShutdownParameters*(dwLevel: DWORD, dwFlags: DWORD): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "SetProcessShutdownParameters".}
proc GetProcessShutdownParameters*(lpdwLevel: LPDWORD, lpdwFlags: LPDWORD): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "GetProcessShutdownParameters".}
proc SetFileApisToOEM*(){.stdcall, dynlib: "kernel32",
                          importc: "SetFileApisToOEM".}
proc SetFileApisToANSI*(){.stdcall, dynlib: "kernel32",
                           importc: "SetFileApisToANSI".}
proc AreFileApisANSI*(): WINBOOL{.stdcall, dynlib: "kernel32",
                                  importc: "AreFileApisANSI".}
proc CloseEventLog*(hEventLog: HANDLE): WINBOOL{.stdcall, dynlib: "advapi32",
    importc: "CloseEventLog".}
proc DeregisterEventSource*(hEventLog: HANDLE): WINBOOL{.stdcall,
    dynlib: "advapi32", importc: "DeregisterEventSource".}
proc NotifyChangeEventLog*(hEventLog: HANDLE, hEvent: HANDLE): WINBOOL{.stdcall,
    dynlib: "advapi32", importc: "NotifyChangeEventLog".}
proc GetNumberOfEventLogRecords*(hEventLog: HANDLE, NumberOfRecords: PDWORD): WINBOOL{.
    stdcall, dynlib: "advapi32", importc: "GetNumberOfEventLogRecords".}
proc GetOldestEventLogRecord*(hEventLog: HANDLE, OldestRecord: PDWORD): WINBOOL{.
    stdcall, dynlib: "advapi32", importc: "GetOldestEventLogRecord".}
proc DuplicateToken*(ExistingTokenHandle: HANDLE,
                     ImpersonationLevel: SECURITY_IMPERSONATION_LEVEL,
                     DuplicateTokenHandle: PHANDLE): WINBOOL{.stdcall,
    dynlib: "advapi32", importc: "DuplicateToken".}
proc GetKernelObjectSecurity*(Handle: HANDLE,
                              RequestedInformation: SECURITY_INFORMATION,
                              pSecurityDescriptor: PSECURITY_DESCRIPTOR,
                              nLength: DWORD, lpnLengthNeeded: LPDWORD): WINBOOL{.
    stdcall, dynlib: "advapi32", importc: "GetKernelObjectSecurity".}
proc ImpersonateNamedPipeClient*(hNamedPipe: HANDLE): WINBOOL{.stdcall,
    dynlib: "advapi32", importc: "ImpersonateNamedPipeClient".}
proc ImpersonateLoggedOnUser*(hToken: HANDLE): WINBOOL{.stdcall,
    dynlib: "advapi32", importc: "ImpersonateLoggedOnUser".}
proc ImpersonateSelf*(ImpersonationLevel: SECURITY_IMPERSONATION_LEVEL): WINBOOL{.
    stdcall, dynlib: "advapi32", importc: "ImpersonateSelf".}
proc RevertToSelf*(): WINBOOL{.stdcall, dynlib: "advapi32",
                               importc: "RevertToSelf".}
proc SetThreadToken*(Thread: PHANDLE, Token: HANDLE): WINBOOL{.stdcall,
    dynlib: "advapi32", importc: "SetThreadToken".}
proc OpenProcessToken*(ProcessHandle: HANDLE, DesiredAccess: DWORD,
                       TokenHandle: PHANDLE): WINBOOL{.stdcall,
    dynlib: "advapi32", importc: "OpenProcessToken".}
proc OpenThreadToken*(ThreadHandle: HANDLE, DesiredAccess: DWORD,
                      OpenAsSelf: WINBOOL, TokenHandle: PHANDLE): WINBOOL{.
    stdcall, dynlib: "advapi32", importc: "OpenThreadToken".}
proc GetTokenInformation*(TokenHandle: HANDLE,
                          TokenInformationClass: TOKEN_INFORMATION_CLASS,
                          TokenInformation: LPVOID,
                          TokenInformationLength: DWORD, ReturnLength: PDWORD): WINBOOL{.
    stdcall, dynlib: "advapi32", importc: "GetTokenInformation".}
proc SetTokenInformation*(TokenHandle: HANDLE,
                          TokenInformationClass: TOKEN_INFORMATION_CLASS,
                          TokenInformation: LPVOID,
                          TokenInformationLength: DWORD): WINBOOL{.stdcall,
    dynlib: "advapi32", importc: "SetTokenInformation".}
proc AdjustTokenPrivileges*(TokenHandle: HANDLE, DisableAllPrivileges: WINBOOL,
                            NewState: PTOKEN_PRIVILEGES, BufferLength: DWORD,
                            PreviousState: PTOKEN_PRIVILEGES,
                            ReturnLength: PDWORD): WINBOOL{.stdcall,
    dynlib: "advapi32", importc: "AdjustTokenPrivileges".}
proc AdjustTokenGroups*(TokenHandle: HANDLE, ResetToDefault: WINBOOL,
                        NewState: PTOKEN_GROUPS, BufferLength: DWORD,
                        PreviousState: PTOKEN_GROUPS, ReturnLength: PDWORD): WINBOOL{.
    stdcall, dynlib: "advapi32", importc: "AdjustTokenGroups".}
proc PrivilegeCheck*(ClientToken: HANDLE, RequiredPrivileges: PPRIVILEGE_SET,
                     pfResult: LPBOOL): WINBOOL{.stdcall, dynlib: "advapi32",
    importc: "PrivilegeCheck".}
proc IsValidSid*(pSid: PSID): WINBOOL{.stdcall, dynlib: "advapi32",
                                       importc: "IsValidSid".}
proc EqualSid*(pSid1: PSID, pSid2: PSID): WINBOOL{.stdcall, dynlib: "advapi32",
    importc: "EqualSid".}
proc EqualPrefixSid*(pSid1: PSID, pSid2: PSID): WINBOOL{.stdcall,
    dynlib: "advapi32", importc: "EqualPrefixSid".}
proc GetSidLengthRequired*(nSubAuthorityCount: UCHAR): DWORD{.stdcall,
    dynlib: "advapi32", importc: "GetSidLengthRequired".}
proc AllocateAndInitializeSid*(pIdentifierAuthority: PSID_IDENTIFIER_AUTHORITY,
                               nSubAuthorityCount: int8, nSubAuthority0: DWORD,
                               nSubAuthority1: DWORD, nSubAuthority2: DWORD,
                               nSubAuthority3: DWORD, nSubAuthority4: DWORD,
                               nSubAuthority5: DWORD, nSubAuthority6: DWORD,
                               nSubAuthority7: DWORD, pSid: var PSID): WINBOOL{.
    stdcall, dynlib: "advapi32", importc: "AllocateAndInitializeSid".}
proc FreeSid*(pSid: PSID): PVOID{.stdcall, dynlib: "advapi32",
                                  importc: "FreeSid".}
proc InitializeSid*(Sid: PSID, pIdentifierAuthority: PSID_IDENTIFIER_AUTHORITY,
                    nSubAuthorityCount: int8): WINBOOL{.stdcall,
    dynlib: "advapi32", importc: "InitializeSid".}
proc GetSidIdentifierAuthority*(pSid: PSID): PSID_IDENTIFIER_AUTHORITY{.stdcall,
    dynlib: "advapi32", importc: "GetSidIdentifierAuthority".}
proc GetSidSubAuthority*(pSid: PSID, nSubAuthority: DWORD): PDWORD{.stdcall,
    dynlib: "advapi32", importc: "GetSidSubAuthority".}
proc GetSidSubAuthorityCount*(pSid: PSID): PUCHAR{.stdcall, dynlib: "advapi32",
    importc: "GetSidSubAuthorityCount".}
proc GetLengthSid*(pSid: PSID): DWORD{.stdcall, dynlib: "advapi32",
                                       importc: "GetLengthSid".}
proc CopySid*(nDestinationSidLength: DWORD, pDestinationSid: PSID,
              pSourceSid: PSID): WINBOOL{.stdcall, dynlib: "advapi32",
    importc: "CopySid".}
proc AreAllAccessesGranted*(GrantedAccess: DWORD, DesiredAccess: DWORD): WINBOOL{.
    stdcall, dynlib: "advapi32", importc: "AreAllAccessesGranted".}
proc AreAnyAccessesGranted*(GrantedAccess: DWORD, DesiredAccess: DWORD): WINBOOL{.
    stdcall, dynlib: "advapi32", importc: "AreAnyAccessesGranted".}
proc MapGenericMask*(AccessMask: PDWORD, GenericMapping: PGENERIC_MAPPING){.
    stdcall, dynlib: "advapi32", importc: "MapGenericMask".}
proc IsValidAcl*(pAcl: PACL): WINBOOL{.stdcall, dynlib: "advapi32",
                                       importc: "IsValidAcl".}
proc InitializeAcl*(pAcl: PACL, nAclLength: DWORD, dwAclRevision: DWORD): WINBOOL{.
    stdcall, dynlib: "advapi32", importc: "InitializeAcl".}
proc GetAclInformation*(pAcl: PACL, pAclInformation: LPVOID,
                        nAclInformationLength: DWORD,
                        dwAclInformationClass: ACL_INFORMATION_CLASS): WINBOOL{.
    stdcall, dynlib: "advapi32", importc: "GetAclInformation".}
proc SetAclInformation*(pAcl: PACL, pAclInformation: LPVOID,
                        nAclInformationLength: DWORD,
                        dwAclInformationClass: ACL_INFORMATION_CLASS): WINBOOL{.
    stdcall, dynlib: "advapi32", importc: "SetAclInformation".}
proc AddAce*(pAcl: PACL, dwAceRevision: DWORD, dwStartingAceIndex: DWORD,
             pAceList: LPVOID, nAceListLength: DWORD): WINBOOL{.stdcall,
    dynlib: "advapi32", importc: "AddAce".}
proc DeleteAce*(pAcl: PACL, dwAceIndex: DWORD): WINBOOL{.stdcall,
    dynlib: "advapi32", importc: "DeleteAce".}
proc GetAce*(pAcl: PACL, dwAceIndex: DWORD, pAce: var LPVOID): WINBOOL{.stdcall,
    dynlib: "advapi32", importc: "GetAce".}
proc AddAccessAllowedAce*(pAcl: PACL, dwAceRevision: DWORD, AccessMask: DWORD,
                          pSid: PSID): WINBOOL{.stdcall, dynlib: "advapi32",
    importc: "AddAccessAllowedAce".}
proc AddAccessDeniedAce*(pAcl: PACL, dwAceRevision: DWORD, AccessMask: DWORD,
                         pSid: PSID): WINBOOL{.stdcall, dynlib: "advapi32",
    importc: "AddAccessDeniedAce".}
proc AddAuditAccessAce*(pAcl: PACL, dwAceRevision: DWORD, dwAccessMask: DWORD,
                        pSid: PSID, bAuditSuccess: WINBOOL,
                        bAuditFailure: WINBOOL): WINBOOL{.stdcall,
    dynlib: "advapi32", importc: "AddAuditAccessAce".}
proc FindFirstFreeAce*(pAcl: PACL, pAce: var LPVOID): WINBOOL{.stdcall,
    dynlib: "advapi32", importc: "FindFirstFreeAce".}
proc InitializeSecurityDescriptor*(pSecurityDescriptor: PSECURITY_DESCRIPTOR,
                                   dwRevision: DWORD): WINBOOL{.stdcall,
    dynlib: "advapi32", importc: "InitializeSecurityDescriptor".}
proc IsValidSecurityDescriptor*(pSecurityDescriptor: PSECURITY_DESCRIPTOR): WINBOOL{.
    stdcall, dynlib: "advapi32", importc: "IsValidSecurityDescriptor".}
proc GetSecurityDescriptorLength*(pSecurityDescriptor: PSECURITY_DESCRIPTOR): DWORD{.
    stdcall, dynlib: "advapi32", importc: "GetSecurityDescriptorLength".}
proc GetSecurityDescriptorControl*(pSecurityDescriptor: PSECURITY_DESCRIPTOR,
                                   pControl: PSECURITY_DESCRIPTOR_CONTROL,
                                   lpdwRevision: LPDWORD): WINBOOL{.stdcall,
    dynlib: "advapi32", importc: "GetSecurityDescriptorControl".}
proc SetSecurityDescriptorDacl*(pSecurityDescriptor: PSECURITY_DESCRIPTOR,
                                bDaclPresent: WINBOOL, pDacl: PACL,
                                bDaclDefaulted: WINBOOL): WINBOOL{.stdcall,
    dynlib: "advapi32", importc: "SetSecurityDescriptorDacl".}
proc GetSecurityDescriptorDacl*(pSecurityDescriptor: PSECURITY_DESCRIPTOR,
                                lpbDaclPresent: LPBOOL, pDacl: var PACL,
                                lpbDaclDefaulted: LPBOOL): WINBOOL{.stdcall,
    dynlib: "advapi32", importc: "GetSecurityDescriptorDacl".}
proc SetSecurityDescriptorSacl*(pSecurityDescriptor: PSECURITY_DESCRIPTOR,
                                bSaclPresent: WINBOOL, pSacl: PACL,
                                bSaclDefaulted: WINBOOL): WINBOOL{.stdcall,
    dynlib: "advapi32", importc: "SetSecurityDescriptorSacl".}
proc GetSecurityDescriptorSacl*(pSecurityDescriptor: PSECURITY_DESCRIPTOR,
                                lpbSaclPresent: LPBOOL, pSacl: var PACL,
                                lpbSaclDefaulted: LPBOOL): WINBOOL{.stdcall,
    dynlib: "advapi32", importc: "GetSecurityDescriptorSacl".}
proc SetSecurityDescriptorOwner*(pSecurityDescriptor: PSECURITY_DESCRIPTOR,
                                 pOwner: PSID, bOwnerDefaulted: WINBOOL): WINBOOL{.
    stdcall, dynlib: "advapi32", importc: "SetSecurityDescriptorOwner".}
proc GetSecurityDescriptorOwner*(pSecurityDescriptor: PSECURITY_DESCRIPTOR,
                                 pOwner: var PSID, lpbOwnerDefaulted: LPBOOL): WINBOOL{.
    stdcall, dynlib: "advapi32", importc: "GetSecurityDescriptorOwner".}
proc SetSecurityDescriptorGroup*(pSecurityDescriptor: PSECURITY_DESCRIPTOR,
                                 pGroup: PSID, bGroupDefaulted: WINBOOL): WINBOOL{.
    stdcall, dynlib: "advapi32", importc: "SetSecurityDescriptorGroup".}
proc GetSecurityDescriptorGroup*(pSecurityDescriptor: PSECURITY_DESCRIPTOR,
                                 pGroup: var PSID, lpbGroupDefaulted: LPBOOL): WINBOOL{.
    stdcall, dynlib: "advapi32", importc: "GetSecurityDescriptorGroup".}
proc CreatePrivateObjectSecurity*(ParentDescriptor: PSECURITY_DESCRIPTOR,
                                  CreatorDescriptor: PSECURITY_DESCRIPTOR,
                                  NewDescriptor: var PSECURITY_DESCRIPTOR,
                                  IsDirectoryObject: WINBOOL, Token: HANDLE,
                                  GenericMapping: PGENERIC_MAPPING): WINBOOL{.
    stdcall, dynlib: "advapi32", importc: "CreatePrivateObjectSecurity".}
proc SetPrivateObjectSecurity*(SecurityInformation: SECURITY_INFORMATION,
                               ModificationDescriptor: PSECURITY_DESCRIPTOR,
    ObjectsSecurityDescriptor: var PSECURITY_DESCRIPTOR,
                               GenericMapping: PGENERIC_MAPPING, Token: HANDLE): WINBOOL{.
    stdcall, dynlib: "advapi32", importc: "SetPrivateObjectSecurity".}
proc GetPrivateObjectSecurity*(ObjectDescriptor: PSECURITY_DESCRIPTOR,
                               SecurityInformation: SECURITY_INFORMATION,
                               ResultantDescriptor: PSECURITY_DESCRIPTOR,
                               DescriptorLength: DWORD, ReturnLength: PDWORD): WINBOOL{.
    stdcall, dynlib: "advapi32", importc: "GetPrivateObjectSecurity".}
proc DestroyPrivateObjectSecurity*(ObjectDescriptor: PSECURITY_DESCRIPTOR): WINBOOL{.
    stdcall, dynlib: "advapi32", importc: "DestroyPrivateObjectSecurity".}
proc MakeSelfRelativeSD*(pAbsoluteSecurityDescriptor: PSECURITY_DESCRIPTOR,
                         pSelfRelativeSecurityDescriptor: PSECURITY_DESCRIPTOR,
                         lpdwBufferLength: LPDWORD): WINBOOL{.stdcall,
    dynlib: "advapi32", importc: "MakeSelfRelativeSD".}
proc MakeAbsoluteSD*(pSelfRelativeSecurityDescriptor: PSECURITY_DESCRIPTOR,
                     pAbsoluteSecurityDescriptor: PSECURITY_DESCRIPTOR,
                     lpdwAbsoluteSecurityDescriptorSize: LPDWORD, pDacl: PACL,
                     lpdwDaclSize: LPDWORD, pSacl: PACL, lpdwSaclSize: LPDWORD,
                     pOwner: PSID, lpdwOwnerSize: LPDWORD, pPrimaryGroup: PSID,
                     lpdwPrimaryGroupSize: LPDWORD): WINBOOL{.stdcall,
    dynlib: "advapi32", importc: "MakeAbsoluteSD".}
proc SetKernelObjectSecurity*(Handle: HANDLE,
                              SecurityInformation: SECURITY_INFORMATION,
                              SecurityDescriptor: PSECURITY_DESCRIPTOR): WINBOOL{.
    stdcall, dynlib: "advapi32", importc: "SetKernelObjectSecurity".}
proc FindNextChangeNotification*(hChangeHandle: HANDLE): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "FindNextChangeNotification".}
proc FindCloseChangeNotification*(hChangeHandle: HANDLE): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "FindCloseChangeNotification".}
proc VirtualLock*(lpAddress: LPVOID, dwSize: DWORD): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "VirtualLock".}
proc VirtualUnlock*(lpAddress: LPVOID, dwSize: DWORD): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "VirtualUnlock".}
proc MapViewOfFileEx*(hFileMappingObject: HANDLE, dwDesiredAccess: DWORD,
                      dwFileOffsetHigh: DWORD, dwFileOffsetLow: DWORD,
                      dwNumberOfBytesToMap: DWORD, lpBaseAddress: LPVOID): LPVOID{.
    stdcall, dynlib: "kernel32", importc: "MapViewOfFileEx".}
proc SetPriorityClass*(hProcess: HANDLE, dwPriorityClass: DWORD): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "SetPriorityClass".}
proc GetPriorityClass*(hProcess: HANDLE): DWORD{.stdcall, dynlib: "kernel32",
    importc: "GetPriorityClass".}
proc IsBadReadPtr*(lp: pointer, ucb: UINT): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "IsBadReadPtr".}
proc IsBadWritePtr*(lp: LPVOID, ucb: UINT): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "IsBadWritePtr".}
proc IsBadHugeReadPtr*(lp: pointer, ucb: UINT): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "IsBadHugeReadPtr".}
proc IsBadHugeWritePtr*(lp: LPVOID, ucb: UINT): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "IsBadHugeWritePtr".}
proc IsBadCodePtr*(lpfn: FARPROC): WINBOOL{.stdcall, dynlib: "kernel32",
    importc: "IsBadCodePtr".}
proc AllocateLocallyUniqueId*(Luid: PLUID): WINBOOL{.stdcall,
    dynlib: "advapi32", importc: "AllocateLocallyUniqueId".}
proc QueryPerformanceCounter*(lpPerformanceCount: PLARGE_INTEGER): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "QueryPerformanceCounter".}
proc QueryPerformanceFrequency*(lpFrequency: PLARGE_INTEGER): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "QueryPerformanceFrequency".}
proc ActivateKeyboardLayout*(hkl: HKL, Flags: UINT): WINBOOL{.stdcall,
    dynlib: "user32", importc: "ActivateKeyboardLayout".}
proc UnloadKeyboardLayout*(hkl: HKL): WINBOOL{.stdcall, dynlib: "user32",
    importc: "UnloadKeyboardLayout".}
proc GetKeyboardLayoutList*(nBuff: int32, lpList: var HKL): int32{.stdcall,
    dynlib: "user32", importc: "GetKeyboardLayoutList".}
proc GetKeyboardLayout*(dwLayout: DWORD): HKL{.stdcall, dynlib: "user32",
    importc: "GetKeyboardLayout".}
proc OpenInputDesktop*(dwFlags: DWORD, fInherit: WINBOOL, dwDesiredAccess: DWORD): HDESK{.
    stdcall, dynlib: "user32", importc: "OpenInputDesktop".}
proc EnumDesktopWindows*(hDesktop: HDESK, lpfn: ENUMWINDOWSPROC, lp: LPARAM): WINBOOL{.
    stdcall, dynlib: "user32", importc: "EnumDesktopWindows".}
proc SwitchDesktop*(hDesktop: HDESK): WINBOOL{.stdcall, dynlib: "user32",
    importc: "SwitchDesktop".}
proc SetThreadDesktop*(hDesktop: HDESK): WINBOOL{.stdcall, dynlib: "user32",
    importc: "SetThreadDesktop".}
proc CloseDesktop*(hDesktop: HDESK): WINBOOL{.stdcall, dynlib: "user32",
    importc: "CloseDesktop".}
proc GetThreadDesktop*(dwThreadId: DWORD): HDESK{.stdcall, dynlib: "user32",
    importc: "GetThreadDesktop".}
proc CloseWindowStation*(hWinSta: HWINSTA): WINBOOL{.stdcall, dynlib: "user32",
    importc: "CloseWindowStation".}
proc SetProcessWindowStation*(hWinSta: HWINSTA): WINBOOL{.stdcall,
    dynlib: "user32", importc: "SetProcessWindowStation".}
proc GetProcessWindowStation*(): HWINSTA{.stdcall, dynlib: "user32",
    importc: "GetProcessWindowStation".}
proc SetUserObjectSecurity*(hObj: HANDLE, pSIRequested: PSECURITY_INFORMATION,
                            pSID: PSECURITY_DESCRIPTOR): WINBOOL{.stdcall,
    dynlib: "user32", importc: "SetUserObjectSecurity".}
proc GetUserObjectSecurity*(hObj: HANDLE, pSIRequested: PSECURITY_INFORMATION,
                            pSID: PSECURITY_DESCRIPTOR, nLength: DWORD,
                            lpnLengthNeeded: LPDWORD): WINBOOL{.stdcall,
    dynlib: "user32", importc: "GetUserObjectSecurity".}
proc TranslateMessage*(lpMsg: LPMSG): WINBOOL{.stdcall, dynlib: "user32",
    importc: "TranslateMessage".}
proc SetMessageQueue*(cMessagesMax: int32): WINBOOL{.stdcall, dynlib: "user32",
    importc: "SetMessageQueue".}
proc RegisterHotKey*(wnd: HWND, anID: int32, fsModifiers: UINT, vk: UINT): WINBOOL{.
    stdcall, dynlib: "user32", importc: "RegisterHotKey".}
proc UnregisterHotKey*(wnd: HWND, anID: int32): WINBOOL{.stdcall,
    dynlib: "user32", importc: "UnregisterHotKey".}
proc ExitWindowsEx*(uFlags: UINT, dwReserved: DWORD): WINBOOL{.stdcall,
    dynlib: "user32", importc: "ExitWindowsEx".}
proc SwapMouseButton*(fSwap: WINBOOL): WINBOOL{.stdcall, dynlib: "user32",
    importc: "SwapMouseButton".}
proc GetMessagePos*(): DWORD{.stdcall, dynlib: "user32",
                              importc: "GetMessagePos".}
proc GetMessageTime*(): LONG{.stdcall, dynlib: "user32",
                              importc: "GetMessageTime".}
proc GetMessageExtraInfo*(): LONG{.stdcall, dynlib: "user32",
                                   importc: "GetMessageExtraInfo".}
proc SetMessageExtraInfo*(lp: LPARAM): LPARAM{.stdcall, dynlib: "user32",
    importc: "SetMessageExtraInfo".}
proc BroadcastSystemMessage*(para1: DWORD, para2: LPDWORD, para3: UINT,
                             para4: WPARAM, para5: LPARAM): int32{.stdcall,
    dynlib: "user32", importc: "BroadcastSystemMessage".}
proc AttachThreadInput*(idAttach: DWORD, idAttachTo: DWORD, fAttach: WINBOOL): WINBOOL{.
    stdcall, dynlib: "user32", importc: "AttachThreadInput".}
proc ReplyMessage*(lResult: LRESULT): WINBOOL{.stdcall, dynlib: "user32",
    importc: "ReplyMessage".}
proc WaitMessage*(): WINBOOL{.stdcall, dynlib: "user32", importc: "WaitMessage".}
proc WaitForInputIdle*(hProcess: HANDLE, dwMilliseconds: DWORD): DWORD{.stdcall,
    dynlib: "user32", importc: "WaitForInputIdle".}
proc PostQuitMessage*(nExitCode: int32){.stdcall, dynlib: "user32",
    importc: "PostQuitMessage".}
proc InSendMessage*(): WINBOOL{.stdcall, dynlib: "user32",
                                importc: "InSendMessage".}
proc GetDoubleClickTime*(): UINT{.stdcall, dynlib: "user32",
                                  importc: "GetDoubleClickTime".}
proc SetDoubleClickTime*(para1: UINT): WINBOOL{.stdcall, dynlib: "user32",
    importc: "SetDoubleClickTime".}
proc IsWindow*(wnd: HWND): WINBOOL{.stdcall, dynlib: "user32",
                                     importc: "IsWindow".}
proc IsMenu*(menu: HMENU): WINBOOL{.stdcall, dynlib: "user32",
                                     importc: "IsMenu".}
proc IsChild*(hWndParent: HWND, wnd: HWND): WINBOOL{.stdcall, dynlib: "user32",
    importc: "IsChild".}
proc DestroyWindow*(wnd: HWND): WINBOOL{.stdcall, dynlib: "user32",
    importc: "DestroyWindow".}
proc ShowWindow*(wnd: HWND, nCmdShow: int32): WINBOOL{.stdcall,
    dynlib: "user32", importc: "ShowWindow".}
proc ShowWindowAsync*(wnd: HWND, nCmdShow: int32): WINBOOL{.stdcall,
    dynlib: "user32", importc: "ShowWindowAsync".}
proc FlashWindow*(wnd: HWND, bInvert: WINBOOL): WINBOOL{.stdcall,
    dynlib: "user32", importc: "FlashWindow".}
proc ShowOwnedPopups*(wnd: HWND, fShow: WINBOOL): WINBOOL{.stdcall,
    dynlib: "user32", importc: "ShowOwnedPopups".}
proc OpenIcon*(wnd: HWND): WINBOOL{.stdcall, dynlib: "user32",
                                     importc: "OpenIcon".}
proc CloseWindow*(wnd: HWND): WINBOOL{.stdcall, dynlib: "user32",
                                        importc: "CloseWindow".}
proc MoveWindow*(wnd: HWND, X: int32, Y: int32, nWidth: int32, nHeight: int32,
                 bRepaint: WINBOOL): WINBOOL{.stdcall, dynlib: "user32",
    importc: "MoveWindow".}
proc SetWindowPos*(wnd: HWND, hWndInsertAfter: HWND, X: int32, Y: int32,
                   cx: int32, cy: int32, uFlags: UINT): WINBOOL{.stdcall,
    dynlib: "user32", importc: "SetWindowPos".}
proc GetWindowPlacement*(wnd: HWND, lpwndpl: var WINDOWPLACEMENT): WINBOOL{.
    stdcall, dynlib: "user32", importc: "GetWindowPlacement".}
proc SetWindowPlacement*(wnd: HWND, lpwndpl: var WINDOWPLACEMENT): WINBOOL{.
    stdcall, dynlib: "user32", importc: "SetWindowPlacement".}
proc GetWindowPlacement*(wnd: HWND, lpwndpl: PWINDOWPLACEMENT): WINBOOL{.
    stdcall, dynlib: "user32", importc: "GetWindowPlacement".}
proc SetWindowPlacement*(wnd: HWND, lpwndpl: PWINDOWPLACEMENT): WINBOOL{.
    stdcall, dynlib: "user32", importc: "SetWindowPlacement".}
proc BeginDeferWindowPos*(nNumWindows: int32): HDWP{.stdcall, dynlib: "user32",
    importc: "BeginDeferWindowPos".}
proc DeferWindowPos*(hWinPosInfo: HDWP, wnd: HWND, hWndInsertAfter: HWND,
                     x: int32, y: int32, cx: int32, cy: int32, uFlags: UINT): HDWP{.
    stdcall, dynlib: "user32", importc: "DeferWindowPos".}
proc EndDeferWindowPos*(hWinPosInfo: HDWP): WINBOOL{.stdcall, dynlib: "user32",
    importc: "EndDeferWindowPos".}
proc IsWindowVisible*(wnd: HWND): WINBOOL{.stdcall, dynlib: "user32",
    importc: "IsWindowVisible".}
proc IsIconic*(wnd: HWND): WINBOOL{.stdcall, dynlib: "user32",
                                     importc: "IsIconic".}
proc AnyPopup*(): WINBOOL{.stdcall, dynlib: "user32", importc: "AnyPopup".}
proc BringWindowToTop*(wnd: HWND): WINBOOL{.stdcall, dynlib: "user32",
    importc: "BringWindowToTop".}
proc IsZoomed*(wnd: HWND): WINBOOL{.stdcall, dynlib: "user32",
                                     importc: "IsZoomed".}
proc EndDialog*(hDlg: HWND, nResult: int32): WINBOOL{.stdcall, dynlib: "user32",
    importc: "EndDialog".}
proc GetDlgItem*(hDlg: HWND, nIDDlgItem: int32): HWND{.stdcall,
    dynlib: "user32", importc: "GetDlgItem".}
proc SetDlgItemInt*(hDlg: HWND, nIDDlgItem: int32, uValue: UINT,
                    bSigned: WINBOOL): WINBOOL{.stdcall, dynlib: "user32",
    importc: "SetDlgItemInt".}
proc GetDlgItemInt*(hDlg: HWND, nIDDlgItem: int32, lpTranslated: var WINBOOL,
                    bSigned: WINBOOL): UINT{.stdcall, dynlib: "user32",
    importc: "GetDlgItemInt".}
proc CheckDlgButton*(hDlg: HWND, nIDButton: int32, uCheck: UINT): WINBOOL{.
    stdcall, dynlib: "user32", importc: "CheckDlgButton".}
proc CheckRadioButton*(hDlg: HWND, nIDFirstButton: int32, nIDLastButton: int32,
                       nIDCheckButton: int32): WINBOOL{.stdcall,
    dynlib: "user32", importc: "CheckRadioButton".}
proc IsDlgButtonChecked*(hDlg: HWND, nIDButton: int32): UINT{.stdcall,
    dynlib: "user32", importc: "IsDlgButtonChecked".}
proc GetNextDlgGroupItem*(hDlg: HWND, hCtl: HWND, bPrevious: WINBOOL): HWND{.
    stdcall, dynlib: "user32", importc: "GetNextDlgGroupItem".}
proc GetNextDlgTabItem*(hDlg: HWND, hCtl: HWND, bPrevious: WINBOOL): HWND{.
    stdcall, dynlib: "user32", importc: "GetNextDlgTabItem".}
proc GetDlgCtrlID*(wnd: HWND): int32{.stdcall, dynlib: "user32",
                                       importc: "GetDlgCtrlID".}
proc GetDialogBaseUnits*(): int32{.stdcall, dynlib: "user32",
                                   importc: "GetDialogBaseUnits".}
proc OpenClipboard*(hWndNewOwner: HWND): WINBOOL{.stdcall, dynlib: "user32",
    importc: "OpenClipboard".}
proc CloseClipboard*(): WINBOOL{.stdcall, dynlib: "user32",
                                 importc: "CloseClipboard".}
proc GetClipboardOwner*(): HWND{.stdcall, dynlib: "user32",
                                 importc: "GetClipboardOwner".}
proc SetClipboardViewer*(hWndNewViewer: HWND): HWND{.stdcall, dynlib: "user32",
    importc: "SetClipboardViewer".}
proc GetClipboardViewer*(): HWND{.stdcall, dynlib: "user32",
                                  importc: "GetClipboardViewer".}
proc ChangeClipboardChain*(hWndRemove: HWND, hWndNewNext: HWND): WINBOOL{.
    stdcall, dynlib: "user32", importc: "ChangeClipboardChain".}
proc SetClipboardData*(uFormat: UINT, hMem: HANDLE): HANDLE{.stdcall,
    dynlib: "user32", importc: "SetClipboardData".}
proc GetClipboardData*(uFormat: UINT): HANDLE{.stdcall, dynlib: "user32",
    importc: "GetClipboardData".}
proc CountClipboardFormats*(): int32{.stdcall, dynlib: "user32",
                                      importc: "CountClipboardFormats".}
proc EnumClipboardFormats*(format: UINT): UINT{.stdcall, dynlib: "user32",
    importc: "EnumClipboardFormats".}
proc EmptyClipboard*(): WINBOOL{.stdcall, dynlib: "user32",
                                 importc: "EmptyClipboard".}
proc IsClipboardFormatAvailable*(format: UINT): WINBOOL{.stdcall,
    dynlib: "user32", importc: "IsClipboardFormatAvailable".}
proc GetPriorityClipboardFormat*(paFormatPriorityList: var UINT, cFormats: int32): int32{.
    stdcall, dynlib: "user32", importc: "GetPriorityClipboardFormat".}
proc GetOpenClipboardWindow*(): HWND{.stdcall, dynlib: "user32",
                                      importc: "GetOpenClipboardWindow".}
proc CharNextExA*(CodePage: int16, lpCurrentChar: LPCSTR, dwFlags: DWORD): LPSTR{.
    stdcall, dynlib: "user32", importc: "CharNextExA".}
proc CharPrevExA*(CodePage: int16, lpStart: LPCSTR, lpCurrentChar: LPCSTR,
                  dwFlags: DWORD): LPSTR{.stdcall, dynlib: "user32",
    importc: "CharPrevExA".}
proc SetFocus*(wnd: HWND): HWND{.stdcall, dynlib: "user32", importc: "SetFocus".}
proc GetActiveWindow*(): HWND{.stdcall, dynlib: "user32",
                               importc: "GetActiveWindow".}
proc GetFocus*(): HWND{.stdcall, dynlib: "user32", importc: "GetFocus".}
proc GetKBCodePage*(): UINT{.stdcall, dynlib: "user32", importc: "GetKBCodePage".}
proc GetKeyState*(nVirtKey: int32): SHORT{.stdcall, dynlib: "user32",
    importc: "GetKeyState".}
proc GetAsyncKeyState*(vKey: int32): SHORT{.stdcall, dynlib: "user32",
    importc: "GetAsyncKeyState".}
proc GetKeyboardState*(lpKeyState: PBYTE): WINBOOL{.stdcall, dynlib: "user32",
    importc: "GetKeyboardState".}
proc SetKeyboardState*(lpKeyState: LPBYTE): WINBOOL{.stdcall, dynlib: "user32",
    importc: "SetKeyboardState".}
proc GetKeyboardType*(nTypeFlag: int32): int32{.stdcall, dynlib: "user32",
    importc: "GetKeyboardType".}
proc ToAscii*(uVirtKey: UINT, uScanCode: UINT, lpKeyState: PBYTE,
              lpChar: LPWORD, uFlags: UINT): int32{.stdcall, dynlib: "user32",
    importc: "ToAscii".}
proc ToAsciiEx*(uVirtKey: UINT, uScanCode: UINT, lpKeyState: PBYTE,
                lpChar: LPWORD, uFlags: UINT, dwhkl: HKL): int32{.stdcall,
    dynlib: "user32", importc: "ToAsciiEx".}
proc ToUnicode*(wVirtKey: UINT, wScanCode: UINT, lpKeyState: PBYTE,
                pwszBuff: LPWSTR, cchBuff: int32, wFlags: UINT): int32{.stdcall,
    dynlib: "user32", importc: "ToUnicode".}
proc OemKeyScan*(wOemChar: int16): DWORD{.stdcall, dynlib: "user32",
    importc: "OemKeyScan".}
proc keybd_event*(bVk: int8, bScan: int8, dwFlags: DWORD, dwExtraInfo: DWORD){.
    stdcall, dynlib: "user32", importc: "keybd_event".}
proc mouse_event*(dwFlags: DWORD, dx: DWORD, dy: DWORD, cButtons: DWORD,
                  dwExtraInfo: DWORD){.stdcall, dynlib: "user32",
                                       importc: "mouse_event".}
proc GetInputState*(): WINBOOL{.stdcall, dynlib: "user32",
                                importc: "GetInputState".}
proc GetQueueStatus*(flags: UINT): DWORD{.stdcall, dynlib: "user32",
    importc: "GetQueueStatus".}
proc GetCapture*(): HWND{.stdcall, dynlib: "user32", importc: "GetCapture".}
proc SetCapture*(wnd: HWND): HWND{.stdcall, dynlib: "user32",
                                    importc: "SetCapture".}
proc ReleaseCapture*(): WINBOOL{.stdcall, dynlib: "user32",
                                 importc: "ReleaseCapture".}
proc MsgWaitForMultipleObjects*(nCount: DWORD, pHandles: LPHANDLE,
                                fWaitAll: WINBOOL, dwMilliseconds: DWORD,
                                dwWakeMask: DWORD): DWORD{.stdcall,
    dynlib: "user32", importc: "MsgWaitForMultipleObjects".}
proc SetTimer*(wnd: HWND, nIDEvent: UINT, uElapse: UINT, lpTimerFunc: TIMERPROC): UINT{.
    stdcall, dynlib: "user32", importc: "SetTimer".}
proc KillTimer*(wnd: HWND, uIDEvent: UINT): WINBOOL{.stdcall, dynlib: "user32",
    importc: "KillTimer".}
proc IsWindowUnicode*(wnd: HWND): WINBOOL{.stdcall, dynlib: "user32",
    importc: "IsWindowUnicode".}
proc EnableWindow*(wnd: HWND, bEnable: WINBOOL): WINBOOL{.stdcall,
    dynlib: "user32", importc: "EnableWindow".}
proc IsWindowEnabled*(wnd: HWND): WINBOOL{.stdcall, dynlib: "user32",
    importc: "IsWindowEnabled".}
proc DestroyAcceleratorTable*(hAccel: HACCEL): WINBOOL{.stdcall,
    dynlib: "user32", importc: "DestroyAcceleratorTable".}
proc GetSystemMetrics*(nIndex: int32): int32{.stdcall, dynlib: "user32",
    importc: "GetSystemMetrics".}
proc GetMenu*(wnd: HWND): HMENU{.stdcall, dynlib: "user32", importc: "GetMenu".}
proc SetMenu*(wnd: HWND, menu: HMENU): WINBOOL{.stdcall, dynlib: "user32",
    importc: "SetMenu".}
proc HiliteMenuItem*(wnd: HWND, menu: HMENU, uIDHiliteItem: UINT,
                     uHilite: UINT): WINBOOL{.stdcall, dynlib: "user32",
    importc: "HiliteMenuItem".}
proc GetMenuState*(menu: HMENU, uId: UINT, uFlags: UINT): UINT{.stdcall,
    dynlib: "user32", importc: "GetMenuState".}
proc DrawMenuBar*(wnd: HWND): WINBOOL{.stdcall, dynlib: "user32",
                                        importc: "DrawMenuBar".}
proc GetSystemMenu*(wnd: HWND, bRevert: WINBOOL): HMENU{.stdcall,
    dynlib: "user32", importc: "GetSystemMenu".}
proc CreateMenu*(): HMENU{.stdcall, dynlib: "user32", importc: "CreateMenu".}
proc CreatePopupMenu*(): HMENU{.stdcall, dynlib: "user32",
                                importc: "CreatePopupMenu".}
proc DestroyMenu*(menu: HMENU): WINBOOL{.stdcall, dynlib: "user32",
    importc: "DestroyMenu".}
proc CheckMenuItem*(menu: HMENU, uIDCheckItem: UINT, uCheck: UINT): DWORD{.
    stdcall, dynlib: "user32", importc: "CheckMenuItem".}
proc EnableMenuItem*(menu: HMENU, uIDEnableItem: UINT, uEnable: UINT): WINBOOL{.
    stdcall, dynlib: "user32", importc: "EnableMenuItem".}
proc GetSubMenu*(menu: HMENU, nPos: int32): HMENU{.stdcall, dynlib: "user32",
    importc: "GetSubMenu".}
proc GetMenuItemID*(menu: HMENU, nPos: int32): UINT{.stdcall, dynlib: "user32",
    importc: "GetMenuItemID".}
proc GetMenuItemCount*(menu: HMENU): int32{.stdcall, dynlib: "user32",
    importc: "GetMenuItemCount".}
proc RemoveMenu*(menu: HMENU, uPosition: UINT, uFlags: UINT): WINBOOL{.stdcall,
    dynlib: "user32", importc: "RemoveMenu".}
proc DeleteMenu*(menu: HMENU, uPosition: UINT, uFlags: UINT): WINBOOL{.stdcall,
    dynlib: "user32", importc: "DeleteMenu".}
proc SetMenuItemBitmaps*(menu: HMENU, uPosition: UINT, uFlags: UINT,
                         hBitmapUnchecked: HBITMAP, hBitmapChecked: HBITMAP): WINBOOL{.
    stdcall, dynlib: "user32", importc: "SetMenuItemBitmaps".}
proc GetMenuCheckMarkDimensions*(): LONG{.stdcall, dynlib: "user32",
    importc: "GetMenuCheckMarkDimensions".}
proc TrackPopupMenu*(menu: HMENU, uFlags: UINT, x: int32, y: int32,
                     nReserved: int32, wnd: HWND, prcRect: var RECT): WINBOOL{.
    stdcall, dynlib: "user32", importc: "TrackPopupMenu".}
proc GetMenuDefaultItem*(menu: HMENU, fByPos: UINT, gmdiFlags: UINT): UINT{.
    stdcall, dynlib: "user32", importc: "GetMenuDefaultItem".}
proc SetMenuDefaultItem*(menu: HMENU, uItem: UINT, fByPos: UINT): WINBOOL{.
    stdcall, dynlib: "user32", importc: "SetMenuDefaultItem".}
proc GetMenuItemRect*(wnd: HWND, menu: HMENU, uItem: UINT, lprcItem: LPRECT): WINBOOL{.
    stdcall, dynlib: "user32", importc: "GetMenuItemRect".}
proc MenuItemFromPoint*(wnd: HWND, menu: HMENU, ptScreen: POINT): int32{.
    stdcall, dynlib: "user32", importc: "MenuItemFromPoint".}
proc DragObject*(para1: HWND, para2: HWND, para3: UINT, para4: DWORD,
                 para5: HCURSOR): DWORD{.stdcall, dynlib: "user32",
    importc: "DragObject".}
proc DragDetect*(wnd: HWND, pt: POINT): WINBOOL{.stdcall, dynlib: "user32",
    importc: "DragDetect".}
proc DrawIcon*(hDC: HDC, X: int32, Y: int32, icon: HICON): WINBOOL{.stdcall,
    dynlib: "user32", importc: "DrawIcon".}
proc UpdateWindow*(wnd: HWND): WINBOOL{.stdcall, dynlib: "user32",
    importc: "UpdateWindow".}
proc SetActiveWindow*(wnd: HWND): HWND{.stdcall, dynlib: "user32",
    importc: "SetActiveWindow".}
proc GetForegroundWindow*(): HWND{.stdcall, dynlib: "user32",
                                   importc: "GetForegroundWindow".}
proc PaintDesktop*(hdc: HDC): WINBOOL{.stdcall, dynlib: "user32",
                                       importc: "PaintDesktop".}
proc SetForegroundWindow*(wnd: HWND): WINBOOL{.stdcall, dynlib: "user32",
    importc: "SetForegroundWindow".}
proc WindowFromDC*(hDC: HDC): HWND{.stdcall, dynlib: "user32",
                                    importc: "WindowFromDC".}
proc GetDC*(wnd: HWND): HDC{.stdcall, dynlib: "user32", importc: "GetDC".}
proc GetDCEx*(wnd: HWND, hrgnClip: HRGN, flags: DWORD): HDC{.stdcall,
    dynlib: "user32", importc: "GetDCEx".}
proc GetWindowDC*(wnd: HWND): HDC{.stdcall, dynlib: "user32",
                                    importc: "GetWindowDC".}
proc ReleaseDC*(wnd: HWND, hDC: HDC): int32{.stdcall, dynlib: "user32",
    importc: "ReleaseDC".}
proc BeginPaint*(wnd: HWND, lpPaint: LPPAINTSTRUCT): HDC{.stdcall,
    dynlib: "user32", importc: "BeginPaint".}
proc EndPaint*(wnd: HWND, lpPaint: LPPAINTSTRUCT): WINBOOL{.stdcall,
    dynlib: "user32", importc: "EndPaint".}
proc GetUpdateRect*(wnd: HWND, lpRect: LPRECT, bErase: WINBOOL): WINBOOL{.
    stdcall, dynlib: "user32", importc: "GetUpdateRect".}
proc GetUpdateRgn*(wnd: HWND, hRgn: HRGN, bErase: WINBOOL): int32{.stdcall,
    dynlib: "user32", importc: "GetUpdateRgn".}
proc SetWindowRgn*(wnd: HWND, hRgn: HRGN, bRedraw: WINBOOL): int32{.stdcall,
    dynlib: "user32", importc: "SetWindowRgn".}
proc GetWindowRgn*(wnd: HWND, hRgn: HRGN): int32{.stdcall, dynlib: "user32",
    importc: "GetWindowRgn".}
proc ExcludeUpdateRgn*(hDC: HDC, wnd: HWND): int32{.stdcall, dynlib: "user32",
    importc: "ExcludeUpdateRgn".}
proc InvalidateRect*(wnd: HWND, lpRect: var RECT, bErase: WINBOOL): WINBOOL{.
    stdcall, dynlib: "user32", importc: "InvalidateRect".}
proc InvalidateRect*(wnd: HWND, lpRect: LPRECT, bErase: WINBOOL): WINBOOL{.
    stdcall, dynlib: "user32", importc: "InvalidateRect".}
proc ValidateRect*(wnd: HWND, lpRect: var RECT): WINBOOL{.stdcall,
    dynlib: "user32", importc: "ValidateRect".}
proc ValidateRect*(wnd: HWND, lpRect: LPRECT): WINBOOL{.stdcall,
    dynlib: "user32", importc: "ValidateRect".}
proc InvalidateRgn*(wnd: HWND, hRgn: HRGN, bErase: WINBOOL): WINBOOL{.stdcall,
    dynlib: "user32", importc: "InvalidateRgn".}
proc ValidateRgn*(wnd: HWND, hRgn: HRGN): WINBOOL{.stdcall, dynlib: "user32",
    importc: "ValidateRgn".}
proc RedrawWindow*(wnd: HWND, lprcUpdate: var RECT, hrgnUpdate: HRGN,
                   flags: UINT): WINBOOL{.stdcall, dynlib: "user32",
    importc: "RedrawWindow".}
proc RedrawWindow*(wnd: HWND, lprcUpdate: LPRECT, hrgnUpdate: HRGN, flags: UINT): WINBOOL{.
    stdcall, dynlib: "user32", importc: "RedrawWindow".}
proc LockWindowUpdate*(hWndLock: HWND): WINBOOL{.stdcall, dynlib: "user32",
    importc: "LockWindowUpdate".}
proc ScrollWindow*(wnd: HWND, XAmount: int32, YAmount: int32, lpRect: var RECT,
                   lpClipRect: var RECT): WINBOOL{.stdcall, dynlib: "user32",
    importc: "ScrollWindow".}
proc ScrollDC*(hDC: HDC, dx: int32, dy: int32, lprcScroll: var RECT,
               lprcClip: var RECT, hrgnUpdate: HRGN, lprcUpdate: LPRECT): WINBOOL{.
    stdcall, dynlib: "user32", importc: "ScrollDC".}
proc ScrollWindowEx*(wnd: HWND, dx: int32, dy: int32, prcScroll: var RECT,
                     prcClip: var RECT, hrgnUpdate: HRGN, prcUpdate: LPRECT,
                     flags: UINT): int32{.stdcall, dynlib: "user32",
    importc: "ScrollWindowEx".}
proc SetScrollPos*(wnd: HWND, nBar: int32, nPos: int32, bRedraw: WINBOOL): int32{.
    stdcall, dynlib: "user32", importc: "SetScrollPos".}
proc GetScrollPos*(wnd: HWND, nBar: int32): int32{.stdcall, dynlib: "user32",
    importc: "GetScrollPos".}
proc SetScrollRange*(wnd: HWND, nBar: int32, nMinPos: int32, nMaxPos: int32,
                     bRedraw: WINBOOL): WINBOOL{.stdcall, dynlib: "user32",
    importc: "SetScrollRange".}
proc GetScrollRange*(wnd: HWND, nBar: int32, lpMinPos: LPINT, lpMaxPos: LPINT): WINBOOL{.
    stdcall, dynlib: "user32", importc: "GetScrollRange".}
proc ShowScrollBar*(wnd: HWND, wBar: int32, bShow: WINBOOL): WINBOOL{.stdcall,
    dynlib: "user32", importc: "ShowScrollBar".}
proc EnableScrollBar*(wnd: HWND, wSBflags: UINT, wArrows: UINT): WINBOOL{.
    stdcall, dynlib: "user32", importc: "EnableScrollBar".}
proc GetClientRect*(wnd: HWND, lpRect: LPRECT): WINBOOL{.stdcall,
    dynlib: "user32", importc: "GetClientRect".}
proc GetWindowRect*(wnd: HWND, lpRect: LPRECT): WINBOOL{.stdcall,
    dynlib: "user32", importc: "GetWindowRect".}
proc AdjustWindowRect*(lpRect: LPRECT, dwStyle: DWORD, bMenu: WINBOOL): WINBOOL{.
    stdcall, dynlib: "user32", importc: "AdjustWindowRect".}
proc AdjustWindowRectEx*(lpRect: LPRECT, dwStyle: DWORD, bMenu: WINBOOL,
                         dwExStyle: DWORD): WINBOOL{.stdcall, dynlib: "user32",
    importc: "AdjustWindowRectEx".}
proc SetWindowContextHelpId*(para1: HWND, para2: DWORD): WINBOOL{.stdcall,
    dynlib: "user32", importc: "SetWindowContextHelpId".}
proc GetWindowContextHelpId*(para1: HWND): DWORD{.stdcall, dynlib: "user32",
    importc: "GetWindowContextHelpId".}
proc SetMenuContextHelpId*(para1: HMENU, para2: DWORD): WINBOOL{.stdcall,
    dynlib: "user32", importc: "SetMenuContextHelpId".}
proc GetMenuContextHelpId*(para1: HMENU): DWORD{.stdcall, dynlib: "user32",
    importc: "GetMenuContextHelpId".}
proc MessageBeep*(uType: UINT): WINBOOL{.stdcall, dynlib: "user32",
    importc: "MessageBeep".}
proc ShowCursor*(bShow: WINBOOL): int32{.stdcall, dynlib: "user32",
    importc: "ShowCursor".}
proc SetCursorPos*(X: int32, Y: int32): WINBOOL{.stdcall, dynlib: "user32",
    importc: "SetCursorPos".}
proc SetCursor*(cursor: HCURSOR): HCURSOR{.stdcall, dynlib: "user32",
    importc: "SetCursor".}
proc GetCursorPos*(lpPoint: LPPOINT): WINBOOL{.stdcall, dynlib: "user32",
    importc: "GetCursorPos".}
proc ClipCursor*(lpRect: LPRECT): WINBOOL{.stdcall, dynlib: "user32",
    importc: "ClipCursor".}
proc GetClipCursor*(lpRect: LPRECT): WINBOOL{.stdcall, dynlib: "user32",
    importc: "GetClipCursor".}
proc GetCursor*(): HCURSOR{.stdcall, dynlib: "user32", importc: "GetCursor".}
proc CreateCaret*(wnd: HWND, hBitmap: HBITMAP, nWidth: int32, nHeight: int32): WINBOOL{.
    stdcall, dynlib: "user32", importc: "CreateCaret".}
proc GetCaretBlinkTime*(): UINT{.stdcall, dynlib: "user32",
                                 importc: "GetCaretBlinkTime".}
proc SetCaretBlinkTime*(uMSeconds: UINT): WINBOOL{.stdcall, dynlib: "user32",
    importc: "SetCaretBlinkTime".}
proc DestroyCaret*(): WINBOOL{.stdcall, dynlib: "user32",
                               importc: "DestroyCaret".}
proc HideCaret*(wnd: HWND): WINBOOL{.stdcall, dynlib: "user32",
                                      importc: "HideCaret".}
proc ShowCaret*(wnd: HWND): WINBOOL{.stdcall, dynlib: "user32",
                                      importc: "ShowCaret".}
proc SetCaretPos*(X: int32, Y: int32): WINBOOL{.stdcall, dynlib: "user32",
    importc: "SetCaretPos".}
proc GetCaretPos*(lpPoint: LPPOINT): WINBOOL{.stdcall, dynlib: "user32",
    importc: "GetCaretPos".}
proc ClientToScreen*(wnd: HWND, lpPoint: LPPOINT): WINBOOL{.stdcall,
    dynlib: "user32", importc: "ClientToScreen".}
proc ScreenToClient*(wnd: HWND, lpPoint: LPPOINT): WINBOOL{.stdcall,
    dynlib: "user32", importc: "ScreenToClient".}
proc MapWindowPoints*(hWndFrom: HWND, hWndTo: HWND, lpPoints: LPPOINT,
                      cPoints: UINT): int32{.stdcall, dynlib: "user32",
    importc: "MapWindowPoints".}
proc WindowFromPoint*(Point: POINT): HWND{.stdcall, dynlib: "user32",
    importc: "WindowFromPoint".}
proc ChildWindowFromPoint*(hWndParent: HWND, Point: POINT): HWND{.stdcall,
    dynlib: "user32", importc: "ChildWindowFromPoint".}
proc GetSysColor*(nIndex: int32): DWORD{.stdcall, dynlib: "user32",
    importc: "GetSysColor".}
proc GetSysColorBrush*(nIndex: int32): HBRUSH{.stdcall, dynlib: "user32",
    importc: "GetSysColorBrush".}
proc SetSysColors*(cElements: int32, lpaElements: var wINT,
                   lpaRgbValues: var COLORREF): WINBOOL{.stdcall,
    dynlib: "user32", importc: "SetSysColors".}
proc DrawFocusRect*(hDC: HDC, lprc: var RECT): WINBOOL{.stdcall,
    dynlib: "user32", importc: "DrawFocusRect".}
proc FillRect*(hDC: HDC, lprc: RECT, hbr: HBRUSH): int32{.stdcall,
    dynlib: "user32", importc: "FillRect".}
proc FrameRect*(hDC: HDC, lprc: var RECT, hbr: HBRUSH): int32{.stdcall,
    dynlib: "user32", importc: "FrameRect".}
proc InvertRect*(hDC: HDC, lprc: var RECT): WINBOOL{.stdcall, dynlib: "user32",
    importc: "InvertRect".}
proc SetRect*(lprc: LPRECT, xLeft: int32, yTop: int32, xRight: int32,
              yBottom: int32): WINBOOL{.stdcall, dynlib: "user32",
                                        importc: "SetRect".}
proc SetRectEmpty*(lprc: LPRECT): WINBOOL{.stdcall, dynlib: "user32",
    importc: "SetRectEmpty".}
proc CopyRect*(lprcDst: LPRECT, lprcSrc: var RECT): WINBOOL{.stdcall,
    dynlib: "user32", importc: "CopyRect".}
proc InflateRect*(lprc: LPRECT, dx: int32, dy: int32): WINBOOL{.stdcall,
    dynlib: "user32", importc: "InflateRect".}
proc IntersectRect*(lprcDst: LPRECT, lprcSrc1: var RECT, lprcSrc2: var RECT): WINBOOL{.
    stdcall, dynlib: "user32", importc: "IntersectRect".}
proc UnionRect*(lprcDst: LPRECT, lprcSrc1: var RECT, lprcSrc2: var RECT): WINBOOL{.
    stdcall, dynlib: "user32", importc: "UnionRect".}
proc SubtractRect*(lprcDst: LPRECT, lprcSrc1: var RECT, lprcSrc2: var RECT): WINBOOL{.
    stdcall, dynlib: "user32", importc: "SubtractRect".}
proc OffsetRect*(lprc: LPRECT, dx: int32, dy: int32): WINBOOL{.stdcall,
    dynlib: "user32", importc: "OffsetRect".}
proc IsRectEmpty*(lprc: var RECT): WINBOOL{.stdcall, dynlib: "user32",
    importc: "IsRectEmpty".}
proc EqualRect*(lprc1: var RECT, lprc2: var RECT): WINBOOL{.stdcall,
    dynlib: "user32", importc: "EqualRect".}
proc PtInRect*(lprc: var RECT, pt: POINT): WINBOOL{.stdcall, dynlib: "user32",
    importc: "PtInRect".}
proc PtInRect*(lprc: LPRECT, pt: POINT): WINBOOL{.stdcall, dynlib: "user32",
    importc: "PtInRect".}
proc GetWindowWord*(wnd: HWND, nIndex: int32): int16{.stdcall,
    dynlib: "user32", importc: "GetWindowWord".}
proc SetWindowWord*(wnd: HWND, nIndex: int32, wNewWord: int16): int16{.stdcall,
    dynlib: "user32", importc: "SetWindowWord".}
proc GetClassWord*(wnd: HWND, nIndex: int32): int16{.stdcall, dynlib: "user32",
    importc: "GetClassWord".}
proc SetClassWord*(wnd: HWND, nIndex: int32, wNewWord: int16): int16{.stdcall,
    dynlib: "user32", importc: "SetClassWord".}
proc GetDesktopWindow*(): HWND{.stdcall, dynlib: "user32",
                                importc: "GetDesktopWindow".}
proc GetParent*(wnd: HWND): HWND{.stdcall, dynlib: "user32",
                                   importc: "GetParent".}
proc SetParent*(hWndChild: HWND, hWndNewParent: HWND): HWND{.stdcall,
    dynlib: "user32", importc: "SetParent".}
proc EnumChildWindows*(hWndParent: HWND, lpEnumFunc: ENUMWINDOWSPROC,
                       lp: LPARAM): WINBOOL{.stdcall, dynlib: "user32",
    importc: "EnumChildWindows".}
proc EnumWindows*(lpEnumFunc: ENUMWINDOWSPROC, lp: LPARAM): WINBOOL{.
    stdcall, dynlib: "user32", importc: "EnumWindows".}
proc EnumThreadWindows*(dwThreadId: DWORD, lpfn: ENUMWINDOWSPROC, lp: LPARAM): WINBOOL{.
    stdcall, dynlib: "user32", importc: "EnumThreadWindows".}
proc EnumTaskWindows*(hTask: HWND, lpfn: FARPROC, lp: LPARAM): WINBOOL{.
    stdcall, dynlib: "user32", importc: "EnumThreadWindows".}
proc GetTopWindow*(wnd: HWND): HWND{.stdcall, dynlib: "user32",
                                      importc: "GetTopWindow".}
proc GetWindowThreadProcessId*(wnd: HWND, lpdwProcessId: LPDWORD): DWORD{.
    stdcall, dynlib: "user32", importc: "GetWindowThreadProcessId".}
proc GetLastActivePopup*(wnd: HWND): HWND{.stdcall, dynlib: "user32",
    importc: "GetLastActivePopup".}
proc GetWindow*(wnd: HWND, uCmd: UINT): HWND{.stdcall, dynlib: "user32",
    importc: "GetWindow".}
proc UnhookWindowsHook*(nCode: int32, pfnFilterProc: HOOKPROC): WINBOOL{.
    stdcall, dynlib: "user32", importc: "UnhookWindowsHook".}
proc UnhookWindowsHookEx*(hhk: HHOOK): WINBOOL{.stdcall, dynlib: "user32",
    importc: "UnhookWindowsHookEx".}
proc CallNextHookEx*(hhk: HHOOK, nCode: int32, wp: WPARAM, lp: LPARAM): LRESULT{.
    stdcall, dynlib: "user32", importc: "CallNextHookEx".}
proc CheckMenuRadioItem*(para1: HMENU, para2: UINT, para3: UINT, para4: UINT,
                         para5: UINT): WINBOOL{.stdcall, dynlib: "user32",
    importc: "CheckMenuRadioItem".}
proc CreateCursor*(hInst: HINST, xHotSpot: int32, yHotSpot: int32,
                   nWidth: int32, nHeight: int32, pvANDPlane: pointer,
                   pvXORPlane: pointer): HCURSOR{.stdcall, dynlib: "user32",
    importc: "CreateCursor".}
proc DestroyCursor*(cursor: HCURSOR): WINBOOL{.stdcall, dynlib: "user32",
    importc: "DestroyCursor".}
proc SetSystemCursor*(hcur: HCURSOR, anID: DWORD): WINBOOL{.stdcall,
    dynlib: "user32", importc: "SetSystemCursor".}
proc CreateIcon*(hInstance: HINST, nWidth: int32, nHeight: int32, cPlanes: int8,
                 cBitsPixel: int8, lpbANDbits: var int8, lpbXORbits: var int8): HICON{.
    stdcall, dynlib: "user32", importc: "CreateIcon".}
proc DestroyIcon*(icon: HICON): WINBOOL{.stdcall, dynlib: "user32",
    importc: "DestroyIcon".}
proc LookupIconIdFromDirectory*(presbits: PBYTE, fIcon: WINBOOL): int32{.
    stdcall, dynlib: "user32", importc: "LookupIconIdFromDirectory".}
proc LookupIconIdFromDirectoryEx*(presbits: PBYTE, fIcon: WINBOOL,
                                  cxDesired: int32, cyDesired: int32,
                                  Flags: UINT): int32{.stdcall,
    dynlib: "user32", importc: "LookupIconIdFromDirectoryEx".}
proc CreateIconFromResource*(presbits: PBYTE, dwResSize: DWORD, fIcon: WINBOOL,
                             dwVer: DWORD): HICON{.stdcall, dynlib: "user32",
    importc: "CreateIconFromResource".}
proc CreateIconFromResourceEx*(presbits: PBYTE, dwResSize: DWORD,
                               fIcon: WINBOOL, dwVer: DWORD, cxDesired: int32,
                               cyDesired: int32, Flags: UINT): HICON{.stdcall,
    dynlib: "user32", importc: "CreateIconFromResourceEx".}
proc CopyImage*(para1: HANDLE, para2: UINT, para3: int32, para4: int32,
                para5: UINT): HICON{.stdcall, dynlib: "user32",
                                     importc: "CopyImage".}
proc CreateIconIndirect*(piconinfo: PICONINFO): HICON{.stdcall,
    dynlib: "user32", importc: "CreateIconIndirect".}
proc CopyIcon*(icon: HICON): HICON{.stdcall, dynlib: "user32",
                                     importc: "CopyIcon".}
proc GetIconInfo*(icon: HICON, piconinfo: PICONINFO): WINBOOL{.stdcall,
    dynlib: "user32", importc: "GetIconInfo".}
proc MapDialogRect*(hDlg: HWND, lpRect: LPRECT): WINBOOL{.stdcall,
    dynlib: "user32", importc: "MapDialogRect".}
proc SetScrollInfo*(para1: HWND, para2: int32, para3: LPCSCROLLINFO,
                    para4: WINBOOL): int32{.stdcall, dynlib: "user32",
    importc: "SetScrollInfo".}
proc GetScrollInfo*(para1: HWND, para2: int32, para3: LPSCROLLINFO): WINBOOL{.
    stdcall, dynlib: "user32", importc: "GetScrollInfo".}
proc TranslateMDISysAccel*(hWndClient: HWND, lpMsg: LPMSG): WINBOOL{.stdcall,
    dynlib: "user32", importc: "TranslateMDISysAccel".}
proc ArrangeIconicWindows*(wnd: HWND): UINT{.stdcall, dynlib: "user32",
    importc: "ArrangeIconicWindows".}
proc TileWindows*(hwndParent: HWND, wHow: UINT, lpRect: var RECT, cKids: UINT,
                  lpKids: var HWND): int16{.stdcall, dynlib: "user32",
    importc: "TileWindows".}
proc CascadeWindows*(hwndParent: HWND, wHow: UINT, lpRect: var RECT,
                     cKids: UINT, lpKids: var HWND): int16{.stdcall,
    dynlib: "user32", importc: "CascadeWindows".}
proc SetLastErrorEx*(dwErrCode: DWORD, dwType: DWORD){.stdcall,
    dynlib: "user32", importc: "SetLastErrorEx".}
proc SetDebugErrorLevel*(dwLevel: DWORD){.stdcall, dynlib: "user32",
    importc: "SetDebugErrorLevel".}
proc DrawEdge*(hdc: HDC, qrc: LPRECT, edge: UINT, grfFlags: UINT): WINBOOL{.
    stdcall, dynlib: "user32", importc: "DrawEdge".}
proc DrawFrameControl*(para1: HDC, para2: LPRECT, para3: UINT, para4: UINT): WINBOOL{.
    stdcall, dynlib: "user32", importc: "DrawFrameControl".}
proc DrawCaption*(para1: HWND, para2: HDC, para3: var RECT, para4: UINT): WINBOOL{.
    stdcall, dynlib: "user32", importc: "DrawCaption".}
proc DrawAnimatedRects*(wnd: HWND, idAni: int32, lprcFrom: var RECT,
                        lprcTo: var RECT): WINBOOL{.stdcall, dynlib: "user32",
    importc: "DrawAnimatedRects".}
proc TrackPopupMenuEx*(para1: HMENU, para2: UINT, para3: int32, para4: int32,
                       para5: HWND, para6: LPTPMPARAMS): WINBOOL{.stdcall,
    dynlib: "user32", importc: "TrackPopupMenuEx".}
proc ChildWindowFromPointEx*(para1: HWND, para2: POINT, para3: UINT): HWND{.
    stdcall, dynlib: "user32", importc: "ChildWindowFromPointEx".}
proc DrawIconEx*(hdc: HDC, xLeft: int32, yTop: int32, icon: HICON,
                 cxWidth: int32, cyWidth: int32, istepIfAniCur: UINT,
                 hbrFlickerFreeDraw: HBRUSH, diFlags: UINT): WINBOOL{.stdcall,
    dynlib: "user32", importc: "DrawIconEx".}
proc AnimatePalette*(para1: HPALETTE, para2: UINT, para3: UINT,
                     para4: var PALETTEENTRY): WINBOOL{.stdcall,
    dynlib: "gdi32", importc: "AnimatePalette".}
proc Arc*(para1: HDC, para2: int32, para3: int32, para4: int32, para5: int32,
          para6: int32, para7: int32, para8: int32, para9: int32): WINBOOL{.
    stdcall, dynlib: "gdi32", importc: "Arc".}
proc BitBlt*(para1: HDC, para2: int32, para3: int32, para4: int32, para5: int32,
             para6: HDC, para7: int32, para8: int32, para9: DWORD): WINBOOL{.
    stdcall, dynlib: "gdi32", importc: "BitBlt".}
proc CancelDC*(para1: HDC): WINBOOL{.stdcall, dynlib: "gdi32",
                                     importc: "CancelDC".}
proc Chord*(para1: HDC, para2: int32, para3: int32, para4: int32, para5: int32,
            para6: int32, para7: int32, para8: int32, para9: int32): WINBOOL{.
    stdcall, dynlib: "gdi32", importc: "Chord".}
proc CloseMetaFile*(para1: HDC): HMETAFILE{.stdcall, dynlib: "gdi32",
    importc: "CloseMetaFile".}
proc CombineRgn*(para1: HRGN, para2: HRGN, para3: HRGN, para4: int32): int32{.
    stdcall, dynlib: "gdi32", importc: "CombineRgn".}
proc CreateBitmap*(para1: int32, para2: int32, para3: UINT, para4: UINT,
                   para5: pointer): HBITMAP{.stdcall, dynlib: "gdi32",
    importc: "CreateBitmap".}
proc CreateBitmapIndirect*(para1: var BITMAP): HBITMAP{.stdcall,
    dynlib: "gdi32", importc: "CreateBitmapIndirect".}
proc CreateBrushIndirect*(para1: var LOGBRUSH): HBRUSH{.stdcall,
    dynlib: "gdi32", importc: "CreateBrushIndirect".}
proc CreateCompatibleBitmap*(para1: HDC, para2: int32, para3: int32): HBITMAP{.
    stdcall, dynlib: "gdi32", importc: "CreateCompatibleBitmap".}
proc CreateDiscardableBitmap*(para1: HDC, para2: int32, para3: int32): HBITMAP{.
    stdcall, dynlib: "gdi32", importc: "CreateDiscardableBitmap".}
proc CreateCompatibleDC*(para1: HDC): HDC{.stdcall, dynlib: "gdi32",
    importc: "CreateCompatibleDC".}
proc CreateDIBitmap*(para1: HDC, para2: var BITMAPINFOHEADER, para3: DWORD,
                     para4: pointer, para5: var BITMAPINFO, para6: UINT): HBITMAP{.
    stdcall, dynlib: "gdi32", importc: "CreateDIBitmap".}
proc CreateDIBPatternBrush*(para1: HGLOBAL, para2: UINT): HBRUSH{.stdcall,
    dynlib: "gdi32", importc: "CreateDIBPatternBrush".}
proc CreateDIBPatternBrushPt*(para1: pointer, para2: UINT): HBRUSH{.stdcall,
    dynlib: "gdi32", importc: "CreateDIBPatternBrushPt".}
proc CreateEllipticRgn*(para1: int32, para2: int32, para3: int32, para4: int32): HRGN{.
    stdcall, dynlib: "gdi32", importc: "CreateEllipticRgn".}
proc CreateEllipticRgnIndirect*(para1: var RECT): HRGN{.stdcall,
    dynlib: "gdi32", importc: "CreateEllipticRgnIndirect".}
proc CreateHatchBrush*(para1: int32, para2: COLORREF): HBRUSH{.stdcall,
    dynlib: "gdi32", importc: "CreateHatchBrush".}
proc CreatePalette*(para1: var LOGPALETTE): HPALETTE{.stdcall, dynlib: "gdi32",
    importc: "CreatePalette".}
proc CreatePen*(para1: int32, para2: int32, para3: COLORREF): HPEN{.stdcall,
    dynlib: "gdi32", importc: "CreatePen".}
proc CreatePenIndirect*(para1: var LOGPEN): HPEN{.stdcall, dynlib: "gdi32",
    importc: "CreatePenIndirect".}
proc CreatePolyPolygonRgn*(para1: var POINT, para2: var wINT, para3: int32,
                           para4: int32): HRGN{.stdcall, dynlib: "gdi32",
    importc: "CreatePolyPolygonRgn".}
proc CreatePatternBrush*(para1: HBITMAP): HBRUSH{.stdcall, dynlib: "gdi32",
    importc: "CreatePatternBrush".}
proc CreateRectRgn*(para1: int32, para2: int32, para3: int32, para4: int32): HRGN{.
    stdcall, dynlib: "gdi32", importc: "CreateRectRgn".}
proc CreateRectRgnIndirect*(para1: var RECT): HRGN{.stdcall, dynlib: "gdi32",
    importc: "CreateRectRgnIndirect".}
proc CreateRoundRectRgn*(para1: int32, para2: int32, para3: int32, para4: int32,
                         para5: int32, para6: int32): HRGN{.stdcall,
    dynlib: "gdi32", importc: "CreateRoundRectRgn".}
proc CreateSolidBrush*(para1: COLORREF): HBRUSH{.stdcall, dynlib: "gdi32",
    importc: "CreateSolidBrush".}
proc DeleteDC*(para1: HDC): WINBOOL{.stdcall, dynlib: "gdi32",
                                     importc: "DeleteDC".}
proc DeleteMetaFile*(para1: HMETAFILE): WINBOOL{.stdcall, dynlib: "gdi32",
    importc: "DeleteMetaFile".}
proc DeleteObject*(para1: HGDIOBJ): WINBOOL{.stdcall, dynlib: "gdi32",
    importc: "DeleteObject".}
proc DrawEscape*(para1: HDC, para2: int32, para3: int32, para4: LPCSTR): int32{.
    stdcall, dynlib: "gdi32", importc: "DrawEscape".}
proc Ellipse*(para1: HDC, para2: int32, para3: int32, para4: int32, para5: int32): WINBOOL{.
    stdcall, dynlib: "gdi32", importc: "Ellipse".}
proc EnumObjects*(para1: HDC, para2: int32, para3: ENUMOBJECTSPROC,
                  para4: LPARAM): int32{.stdcall, dynlib: "gdi32",
    importc: "EnumObjects".}
proc EqualRgn*(para1: HRGN, para2: HRGN): WINBOOL{.stdcall, dynlib: "gdi32",
    importc: "EqualRgn".}
proc Escape*(para1: HDC, para2: int32, para3: int32, para4: LPCSTR,
             para5: LPVOID): int32{.stdcall, dynlib: "gdi32", importc: "Escape".}
proc ExtEscape*(para1: HDC, para2: int32, para3: int32, para4: LPCSTR,
                para5: int32, para6: LPSTR): int32{.stdcall, dynlib: "gdi32",
    importc: "ExtEscape".}
proc ExcludeClipRect*(para1: HDC, para2: int32, para3: int32, para4: int32,
                      para5: int32): int32{.stdcall, dynlib: "gdi32",
    importc: "ExcludeClipRect".}
proc ExtCreateRegion*(para1: var XFORM, para2: DWORD, para3: var RGNDATA): HRGN{.
    stdcall, dynlib: "gdi32", importc: "ExtCreateRegion".}
proc ExtFloodFill*(para1: HDC, para2: int32, para3: int32, para4: COLORREF,
                   para5: UINT): WINBOOL{.stdcall, dynlib: "gdi32",
    importc: "ExtFloodFill".}
proc FillRgn*(para1: HDC, para2: HRGN, para3: HBRUSH): WINBOOL{.stdcall,
    dynlib: "gdi32", importc: "FillRgn".}
proc FloodFill*(para1: HDC, para2: int32, para3: int32, para4: COLORREF): WINBOOL{.
    stdcall, dynlib: "gdi32", importc: "FloodFill".}
proc FrameRgn*(para1: HDC, para2: HRGN, para3: HBRUSH, para4: int32,
               para5: int32): WINBOOL{.stdcall, dynlib: "gdi32",
                                       importc: "FrameRgn".}
proc GetROP2*(para1: HDC): int32{.stdcall, dynlib: "gdi32", importc: "GetROP2".}
proc GetAspectRatioFilterEx*(para1: HDC, para2: LPSIZE): WINBOOL{.stdcall,
    dynlib: "gdi32", importc: "GetAspectRatioFilterEx".}
proc GetBkColor*(para1: HDC): COLORREF{.stdcall, dynlib: "gdi32",
                                        importc: "GetBkColor".}
proc GetBkMode*(para1: HDC): int32{.stdcall, dynlib: "gdi32",
                                    importc: "GetBkMode".}
proc GetBitmapBits*(para1: HBITMAP, para2: LONG, para3: LPVOID): LONG{.stdcall,
    dynlib: "gdi32", importc: "GetBitmapBits".}
proc GetBitmapDimensionEx*(para1: HBITMAP, para2: LPSIZE): WINBOOL{.stdcall,
    dynlib: "gdi32", importc: "GetBitmapDimensionEx".}
proc GetBoundsRect*(para1: HDC, para2: LPRECT, para3: UINT): UINT{.stdcall,
    dynlib: "gdi32", importc: "GetBoundsRect".}
proc GetBrushOrgEx*(para1: HDC, para2: LPPOINT): WINBOOL{.stdcall,
    dynlib: "gdi32", importc: "GetBrushOrgEx".}
proc GetClipBox*(para1: HDC, para2: LPRECT): int32{.stdcall, dynlib: "gdi32",
    importc: "GetClipBox".}
proc GetClipRgn*(para1: HDC, para2: HRGN): int32{.stdcall, dynlib: "gdi32",
    importc: "GetClipRgn".}
proc GetMetaRgn*(para1: HDC, para2: HRGN): int32{.stdcall, dynlib: "gdi32",
    importc: "GetMetaRgn".}
proc GetCurrentObject*(para1: HDC, para2: UINT): HGDIOBJ{.stdcall,
    dynlib: "gdi32", importc: "GetCurrentObject".}
proc GetCurrentPositionEx*(para1: HDC, para2: LPPOINT): WINBOOL{.stdcall,
    dynlib: "gdi32", importc: "GetCurrentPositionEx".}
proc GetDeviceCaps*(para1: HDC, para2: int32): int32{.stdcall, dynlib: "gdi32",
    importc: "GetDeviceCaps".}
proc GetDIBits*(para1: HDC, para2: HBITMAP, para3: UINT, para4: UINT,
                para5: LPVOID, para6: LPBITMAPINFO, para7: UINT): int32{.
    stdcall, dynlib: "gdi32", importc: "GetDIBits".}
proc GetFontData*(para1: HDC, para2: DWORD, para3: DWORD, para4: LPVOID,
                  para5: DWORD): DWORD{.stdcall, dynlib: "gdi32",
                                        importc: "GetFontData".}
proc GetGraphicsMode*(para1: HDC): int32{.stdcall, dynlib: "gdi32",
    importc: "GetGraphicsMode".}
proc GetMapMode*(para1: HDC): int32{.stdcall, dynlib: "gdi32",
                                     importc: "GetMapMode".}
proc GetMetaFileBitsEx*(para1: HMETAFILE, para2: UINT, para3: LPVOID): UINT{.
    stdcall, dynlib: "gdi32", importc: "GetMetaFileBitsEx".}
proc GetNearestColor*(para1: HDC, para2: COLORREF): COLORREF{.stdcall,
    dynlib: "gdi32", importc: "GetNearestColor".}
proc GetNearestPaletteIndex*(para1: HPALETTE, para2: COLORREF): UINT{.stdcall,
    dynlib: "gdi32", importc: "GetNearestPaletteIndex".}
proc GetObjectType*(h: HGDIOBJ): DWORD{.stdcall, dynlib: "gdi32",
                                        importc: "GetObjectType".}
proc GetPaletteEntries*(para1: HPALETTE, para2: UINT, para3: UINT,
                        para4: LPPALETTEENTRY): UINT{.stdcall, dynlib: "gdi32",
    importc: "GetPaletteEntries".}
proc GetPixel*(para1: HDC, para2: int32, para3: int32): COLORREF{.stdcall,
    dynlib: "gdi32", importc: "GetPixel".}
proc GetPixelFormat*(para1: HDC): int32{.stdcall, dynlib: "gdi32",
    importc: "GetPixelFormat".}
proc GetPolyFillMode*(para1: HDC): int32{.stdcall, dynlib: "gdi32",
    importc: "GetPolyFillMode".}
proc GetRasterizerCaps*(para1: LPRASTERIZER_STATUS, para2: UINT): WINBOOL{.
    stdcall, dynlib: "gdi32", importc: "GetRasterizerCaps".}
proc GetRegionData*(para1: HRGN, para2: DWORD, para3: LPRGNDATA): DWORD{.
    stdcall, dynlib: "gdi32", importc: "GetRegionData".}
proc GetRgnBox*(para1: HRGN, para2: LPRECT): int32{.stdcall, dynlib: "gdi32",
    importc: "GetRgnBox".}
proc GetStockObject*(para1: int32): HGDIOBJ{.stdcall, dynlib: "gdi32",
    importc: "GetStockObject".}
proc GetStretchBltMode*(para1: HDC): int32{.stdcall, dynlib: "gdi32",
    importc: "GetStretchBltMode".}
proc GetSystemPaletteEntries*(para1: HDC, para2: UINT, para3: UINT,
                              para4: LPPALETTEENTRY): UINT{.stdcall,
    dynlib: "gdi32", importc: "GetSystemPaletteEntries".}
proc GetSystemPaletteUse*(para1: HDC): UINT{.stdcall, dynlib: "gdi32",
    importc: "GetSystemPaletteUse".}
proc GetTextCharacterExtra*(para1: HDC): int32{.stdcall, dynlib: "gdi32",
    importc: "GetTextCharacterExtra".}
proc GetTextAlign*(para1: HDC): UINT{.stdcall, dynlib: "gdi32",
                                      importc: "GetTextAlign".}
proc GetTextColor*(para1: HDC): COLORREF{.stdcall, dynlib: "gdi32",
    importc: "GetTextColor".}
proc GetTextCharset*(hdc: HDC): int32{.stdcall, dynlib: "gdi32",
                                       importc: "GetTextCharset".}
proc GetTextCharsetInfo*(hdc: HDC, lpSig: LPFONTSIGNATURE, dwFlags: DWORD): int32{.
    stdcall, dynlib: "gdi32", importc: "GetTextCharsetInfo".}
proc TranslateCharsetInfo*(lpSrc: var DWORD, lpCs: LPCHARSETINFO, dwFlags: DWORD): WINBOOL{.
    stdcall, dynlib: "gdi32", importc: "TranslateCharsetInfo".}
proc GetFontLanguageInfo*(para1: HDC): DWORD{.stdcall, dynlib: "gdi32",
    importc: "GetFontLanguageInfo".}
proc GetViewportExtEx*(para1: HDC, para2: LPSIZE): WINBOOL{.stdcall,
    dynlib: "gdi32", importc: "GetViewportExtEx".}
proc GetViewportOrgEx*(para1: HDC, para2: LPPOINT): WINBOOL{.stdcall,
    dynlib: "gdi32", importc: "GetViewportOrgEx".}
proc GetWindowExtEx*(para1: HDC, para2: LPSIZE): WINBOOL{.stdcall,
    dynlib: "gdi32", importc: "GetWindowExtEx".}
proc GetWindowOrgEx*(para1: HDC, para2: LPPOINT): WINBOOL{.stdcall,
    dynlib: "gdi32", importc: "GetWindowOrgEx".}
proc IntersectClipRect*(para1: HDC, para2: int32, para3: int32, para4: int32,
                        para5: int32): int32{.stdcall, dynlib: "gdi32",
    importc: "IntersectClipRect".}
proc InvertRgn*(para1: HDC, para2: HRGN): WINBOOL{.stdcall, dynlib: "gdi32",
    importc: "InvertRgn".}
proc LineDDA*(para1: int32, para2: int32, para3: int32, para4: int32,
              para5: LINEDDAPROC, para6: LPARAM): WINBOOL{.stdcall,
    dynlib: "gdi32", importc: "LineDDA".}
proc LineTo*(para1: HDC, para2: int32, para3: int32): WINBOOL{.stdcall,
    dynlib: "gdi32", importc: "LineTo".}
proc MaskBlt*(para1: HDC, para2: int32, para3: int32, para4: int32,
              para5: int32, para6: HDC, para7: int32, para8: int32,
              para9: HBITMAP, para10: int32, para11: int32, para12: DWORD): WINBOOL{.
    stdcall, dynlib: "gdi32", importc: "MaskBlt".}
proc PlgBlt*(para1: HDC, para2: var POINT, para3: HDC, para4: int32,
             para5: int32, para6: int32, para7: int32, para8: HBITMAP,
             para9: int32, para10: int32): WINBOOL{.stdcall, dynlib: "gdi32",
    importc: "PlgBlt".}
proc OffsetClipRgn*(para1: HDC, para2: int32, para3: int32): int32{.stdcall,
    dynlib: "gdi32", importc: "OffsetClipRgn".}
proc OffsetRgn*(para1: HRGN, para2: int32, para3: int32): int32{.stdcall,
    dynlib: "gdi32", importc: "OffsetRgn".}
proc PatBlt*(para1: HDC, para2: int32, para3: int32, para4: int32, para5: int32,
             para6: DWORD): WINBOOL{.stdcall, dynlib: "gdi32", importc: "PatBlt".}
proc Pie*(para1: HDC, para2: int32, para3: int32, para4: int32, para5: int32,
          para6: int32, para7: int32, para8: int32, para9: int32): WINBOOL{.
    stdcall, dynlib: "gdi32", importc: "Pie".}
proc PlayMetaFile*(para1: HDC, para2: HMETAFILE): WINBOOL{.stdcall,
    dynlib: "gdi32", importc: "PlayMetaFile".}
proc PaintRgn*(para1: HDC, para2: HRGN): WINBOOL{.stdcall, dynlib: "gdi32",
    importc: "PaintRgn".}
proc PolyPolygon*(para1: HDC, para2: var POINT, para3: var wINT, para4: int32): WINBOOL{.
    stdcall, dynlib: "gdi32", importc: "PolyPolygon".}
proc PtInRegion*(para1: HRGN, para2: int32, para3: int32): WINBOOL{.stdcall,
    dynlib: "gdi32", importc: "PtInRegion".}
proc PtVisible*(para1: HDC, para2: int32, para3: int32): WINBOOL{.stdcall,
    dynlib: "gdi32", importc: "PtVisible".}
proc RectInRegion*(para1: HRGN, para2: var RECT): WINBOOL{.stdcall,
    dynlib: "gdi32", importc: "RectInRegion".}
proc RectVisible*(para1: HDC, para2: var RECT): WINBOOL{.stdcall,
    dynlib: "gdi32", importc: "RectVisible".}
proc Rectangle*(para1: HDC, para2: int32, para3: int32, para4: int32,
                para5: int32): WINBOOL{.stdcall, dynlib: "gdi32",
                                        importc: "Rectangle".}
proc RestoreDC*(para1: HDC, para2: int32): WINBOOL{.stdcall, dynlib: "gdi32",
    importc: "RestoreDC".}
proc RealizePalette*(para1: HDC): UINT{.stdcall, dynlib: "gdi32",
                                        importc: "RealizePalette".}
proc RoundRect*(para1: HDC, para2: int32, para3: int32, para4: int32,
                para5: int32, para6: int32, para7: int32): WINBOOL{.stdcall,
    dynlib: "gdi32", importc: "RoundRect".}
proc ResizePalette*(para1: HPALETTE, para2: UINT): WINBOOL{.stdcall,
    dynlib: "gdi32", importc: "ResizePalette".}
proc SaveDC*(para1: HDC): int32{.stdcall, dynlib: "gdi32", importc: "SaveDC".}
proc SelectClipRgn*(para1: HDC, para2: HRGN): int32{.stdcall, dynlib: "gdi32",
    importc: "SelectClipRgn".}
proc ExtSelectClipRgn*(para1: HDC, para2: HRGN, para3: int32): int32{.stdcall,
    dynlib: "gdi32", importc: "ExtSelectClipRgn".}
proc SetMetaRgn*(para1: HDC): int32{.stdcall, dynlib: "gdi32",
                                     importc: "SetMetaRgn".}
proc SelectObject*(para1: HDC, para2: HGDIOBJ): HGDIOBJ{.stdcall,
    dynlib: "gdi32", importc: "SelectObject".}
proc SelectPalette*(para1: HDC, para2: HPALETTE, para3: WINBOOL): HPALETTE{.
    stdcall, dynlib: "gdi32", importc: "SelectPalette".}
proc SetBkColor*(para1: HDC, para2: COLORREF): COLORREF{.stdcall,
    dynlib: "gdi32", importc: "SetBkColor".}
proc SetBkMode*(para1: HDC, para2: int32): int32{.stdcall, dynlib: "gdi32",
    importc: "SetBkMode".}
proc SetBitmapBits*(para1: HBITMAP, para2: DWORD, para3: pointer): LONG{.
    stdcall, dynlib: "gdi32", importc: "SetBitmapBits".}
proc SetBoundsRect*(para1: HDC, para2: var RECT, para3: UINT): UINT{.stdcall,
    dynlib: "gdi32", importc: "SetBoundsRect".}
proc SetDIBits*(para1: HDC, para2: HBITMAP, para3: UINT, para4: UINT,
                para5: pointer, para6: PBITMAPINFO, para7: UINT): int32{.
    stdcall, dynlib: "gdi32", importc: "SetDIBits".}
proc SetDIBitsToDevice*(para1: HDC, para2: int32, para3: int32, para4: DWORD,
                        para5: DWORD, para6: int32, para7: int32, para8: UINT,
                        para9: UINT, para10: pointer, para11: var BITMAPINFO,
                        para12: UINT): int32{.stdcall, dynlib: "gdi32",
    importc: "SetDIBitsToDevice".}
proc SetMapperFlags*(para1: HDC, para2: DWORD): DWORD{.stdcall, dynlib: "gdi32",
    importc: "SetMapperFlags".}
proc SetGraphicsMode*(hdc: HDC, iMode: int32): int32{.stdcall, dynlib: "gdi32",
    importc: "SetGraphicsMode".}
proc SetMapMode*(para1: HDC, para2: int32): int32{.stdcall, dynlib: "gdi32",
    importc: "SetMapMode".}
proc SetMetaFileBitsEx*(para1: UINT, para2: var int8): HMETAFILE{.stdcall,
    dynlib: "gdi32", importc: "SetMetaFileBitsEx".}
proc SetPaletteEntries*(para1: HPALETTE, para2: UINT, para3: UINT,
                        para4: var PALETTEENTRY): UINT{.stdcall,
    dynlib: "gdi32", importc: "SetPaletteEntries".}
proc SetPixel*(para1: HDC, para2: int32, para3: int32, para4: COLORREF): COLORREF{.
    stdcall, dynlib: "gdi32", importc: "SetPixel".}
proc SetPixelV*(para1: HDC, para2: int32, para3: int32, para4: COLORREF): WINBOOL{.
    stdcall, dynlib: "gdi32", importc: "SetPixelV".}
proc SetPolyFillMode*(para1: HDC, para2: int32): int32{.stdcall,
    dynlib: "gdi32", importc: "SetPolyFillMode".}
proc StretchBlt*(para1: HDC, para2: int32, para3: int32, para4: int32,
                 para5: int32, para6: HDC, para7: int32, para8: int32,
                 para9: int32, para10: int32, para11: DWORD): WINBOOL{.stdcall,
    dynlib: "gdi32", importc: "StretchBlt".}
proc SetRectRgn*(para1: HRGN, para2: int32, para3: int32, para4: int32,
                 para5: int32): WINBOOL{.stdcall, dynlib: "gdi32",
    importc: "SetRectRgn".}
proc StretchDIBits*(para1: HDC, para2: int32, para3: int32, para4: int32,
                    para5: int32, para6: int32, para7: int32, para8: int32,
                    para9: int32, para10: pointer, para11: var BITMAPINFO,
                    para12: UINT, para13: DWORD): int32{.stdcall,
    dynlib: "gdi32", importc: "StretchDIBits".}
proc SetROP2*(para1: HDC, para2: int32): int32{.stdcall, dynlib: "gdi32",
    importc: "SetROP2".}
proc SetStretchBltMode*(para1: HDC, para2: int32): int32{.stdcall,
    dynlib: "gdi32", importc: "SetStretchBltMode".}
proc SetSystemPaletteUse*(para1: HDC, para2: UINT): UINT{.stdcall,
    dynlib: "gdi32", importc: "SetSystemPaletteUse".}
proc SetTextCharacterExtra*(para1: HDC, para2: int32): int32{.stdcall,
    dynlib: "gdi32", importc: "SetTextCharacterExtra".}
proc SetTextColor*(para1: HDC, para2: COLORREF): COLORREF{.stdcall,
    dynlib: "gdi32", importc: "SetTextColor".}
proc SetTextAlign*(para1: HDC, para2: UINT): UINT{.stdcall, dynlib: "gdi32",
    importc: "SetTextAlign".}
proc SetTextJustification*(para1: HDC, para2: int32, para3: int32): WINBOOL{.
    stdcall, dynlib: "gdi32", importc: "SetTextJustification".}
proc UpdateColors*(para1: HDC): WINBOOL{.stdcall, dynlib: "gdi32",
    importc: "UpdateColors".}
proc PlayMetaFileRecord*(para1: HDC, para2: LPHANDLETABLE, para3: LPMETARECORD,
                         para4: UINT): WINBOOL{.stdcall, dynlib: "gdi32",
    importc: "PlayMetaFileRecord".}
proc EnumMetaFile*(para1: HDC, para2: HMETAFILE, para3: ENUMMETAFILEPROC,
                   para4: LPARAM): WINBOOL{.stdcall, dynlib: "gdi32",
    importc: "EnumMetaFile".}
proc CloseEnhMetaFile*(para1: HDC): HENHMETAFILE{.stdcall, dynlib: "gdi32",
    importc: "CloseEnhMetaFile".}
proc DeleteEnhMetaFile*(para1: HENHMETAFILE): WINBOOL{.stdcall, dynlib: "gdi32",
    importc: "DeleteEnhMetaFile".}
proc EnumEnhMetaFile*(para1: HDC, para2: HENHMETAFILE, para3: ENHMETAFILEPROC,
                      para4: LPVOID, para5: var RECT): WINBOOL{.stdcall,
    dynlib: "gdi32", importc: "EnumEnhMetaFile".}
proc GetEnhMetaFileHeader*(para1: HENHMETAFILE, para2: UINT,
                           para3: LPENHMETAHEADER): UINT{.stdcall,
    dynlib: "gdi32", importc: "GetEnhMetaFileHeader".}
proc GetEnhMetaFilePaletteEntries*(para1: HENHMETAFILE, para2: UINT,
                                   para3: LPPALETTEENTRY): UINT{.stdcall,
    dynlib: "gdi32", importc: "GetEnhMetaFilePaletteEntries".}
proc GetEnhMetaFileBits*(para1: HENHMETAFILE, para2: UINT, para3: LPBYTE): UINT{.
    stdcall, dynlib: "gdi32", importc: "GetEnhMetaFileBits".}
proc GetWinMetaFileBits*(para1: HENHMETAFILE, para2: UINT, para3: LPBYTE,
                         para4: wINT, para5: HDC): UINT{.stdcall,
    dynlib: "gdi32", importc: "GetWinMetaFileBits".}
proc PlayEnhMetaFile*(para1: HDC, para2: HENHMETAFILE, para3: RECT): WINBOOL{.
    stdcall, dynlib: "gdi32", importc: "PlayEnhMetaFile".}
proc PlayEnhMetaFileRecord*(para1: HDC, para2: LPHANDLETABLE,
                            para3: var TENHMETARECORD, para4: UINT): WINBOOL{.
    stdcall, dynlib: "gdi32", importc: "PlayEnhMetaFileRecord".}
proc SetEnhMetaFileBits*(para1: UINT, para2: var int8): HENHMETAFILE{.stdcall,
    dynlib: "gdi32", importc: "SetEnhMetaFileBits".}
proc SetWinMetaFileBits*(para1: UINT, para2: var int8, para3: HDC,
                         para4: var METAFILEPICT): HENHMETAFILE{.stdcall,
    dynlib: "gdi32", importc: "SetWinMetaFileBits".}
proc GdiComment*(para1: HDC, para2: UINT, para3: var int8): WINBOOL{.stdcall,
    dynlib: "gdi32", importc: "GdiComment".}
proc AngleArc*(para1: HDC, para2: int32, para3: int32, para4: DWORD,
               para5: float32, para6: float32): WINBOOL{.stdcall,
    dynlib: "gdi32", importc: "AngleArc".}
proc PolyPolyline*(para1: HDC, para2: var POINT, para3: var DWORD, para4: DWORD): WINBOOL{.
    stdcall, dynlib: "gdi32", importc: "PolyPolyline".}
proc GetWorldTransform*(para1: HDC, para2: LPXFORM): WINBOOL{.stdcall,
    dynlib: "gdi32", importc: "GetWorldTransform".}
proc SetWorldTransform*(para1: HDC, para2: var XFORM): WINBOOL{.stdcall,
    dynlib: "gdi32", importc: "SetWorldTransform".}
proc ModifyWorldTransform*(para1: HDC, para2: var XFORM, para3: DWORD): WINBOOL{.
    stdcall, dynlib: "gdi32", importc: "ModifyWorldTransform".}
proc CombineTransform*(para1: LPXFORM, para2: var XFORM, para3: var XFORM): WINBOOL{.
    stdcall, dynlib: "gdi32", importc: "CombineTransform".}
proc CreateDIBSection*(para1: HDC, para2: var BITMAPINFO, para3: UINT,
                       para4: var pointer, para5: HANDLE, para6: DWORD): HBITMAP{.
    stdcall, dynlib: "gdi32", importc: "CreateDIBSection".}
proc GetDIBColorTable*(para1: HDC, para2: UINT, para3: UINT, para4: var RGBQUAD): UINT{.
    stdcall, dynlib: "gdi32", importc: "GetDIBColorTable".}
proc SetDIBColorTable*(para1: HDC, para2: UINT, para3: UINT, para4: var RGBQUAD): UINT{.
    stdcall, dynlib: "gdi32", importc: "SetDIBColorTable".}
proc SetColorAdjustment*(para1: HDC, para2: var COLORADJUSTMENT): WINBOOL{.
    stdcall, dynlib: "gdi32", importc: "SetColorAdjustment".}
proc GetColorAdjustment*(para1: HDC, para2: LPCOLORADJUSTMENT): WINBOOL{.
    stdcall, dynlib: "gdi32", importc: "GetColorAdjustment".}
proc CreateHalftonePalette*(para1: HDC): HPALETTE{.stdcall, dynlib: "gdi32",
    importc: "CreateHalftonePalette".}
proc EndDoc*(para1: HDC): int32{.stdcall, dynlib: "gdi32", importc: "EndDoc".}
proc StartPage*(para1: HDC): int32{.stdcall, dynlib: "gdi32",
                                    importc: "StartPage".}
proc EndPage*(para1: HDC): int32{.stdcall, dynlib: "gdi32", importc: "EndPage".}
proc AbortDoc*(para1: HDC): int32{.stdcall, dynlib: "gdi32", importc: "AbortDoc".}
proc SetAbortProc*(para1: HDC, para2: TABORTPROC): int32{.stdcall,
    dynlib: "gdi32", importc: "SetAbortProc".}
proc ArcTo*(para1: HDC, para2: int32, para3: int32, para4: int32, para5: int32,
            para6: int32, para7: int32, para8: int32, para9: int32): WINBOOL{.
    stdcall, dynlib: "gdi32", importc: "ArcTo".}
proc BeginPath*(para1: HDC): WINBOOL{.stdcall, dynlib: "gdi32",
                                      importc: "BeginPath".}
proc CloseFigure*(para1: HDC): WINBOOL{.stdcall, dynlib: "gdi32",
                                        importc: "CloseFigure".}
proc EndPath*(para1: HDC): WINBOOL{.stdcall, dynlib: "gdi32", importc: "EndPath".}
proc FillPath*(para1: HDC): WINBOOL{.stdcall, dynlib: "gdi32",
                                     importc: "FillPath".}
proc FlattenPath*(para1: HDC): WINBOOL{.stdcall, dynlib: "gdi32",
                                        importc: "FlattenPath".}
proc GetPath*(para1: HDC, para2: LPPOINT, para3: LPBYTE, para4: int32): int32{.
    stdcall, dynlib: "gdi32", importc: "GetPath".}
proc PathToRegion*(para1: HDC): HRGN{.stdcall, dynlib: "gdi32",
                                      importc: "PathToRegion".}
proc PolyDraw*(para1: HDC, para2: var POINT, para3: var int8, para4: int32): WINBOOL{.
    stdcall, dynlib: "gdi32", importc: "PolyDraw".}
proc SelectClipPath*(para1: HDC, para2: int32): WINBOOL{.stdcall,
    dynlib: "gdi32", importc: "SelectClipPath".}
proc SetArcDirection*(para1: HDC, para2: int32): int32{.stdcall,
    dynlib: "gdi32", importc: "SetArcDirection".}
proc SetMiterLimit*(para1: HDC, para2: float32, para3: ptr float32): WINBOOL{.
    stdcall, dynlib: "gdi32", importc: "SetMiterLimit".}
proc StrokeAndFillPath*(para1: HDC): WINBOOL{.stdcall, dynlib: "gdi32",
    importc: "StrokeAndFillPath".}
proc StrokePath*(para1: HDC): WINBOOL{.stdcall, dynlib: "gdi32",
                                       importc: "StrokePath".}
proc WidenPath*(para1: HDC): WINBOOL{.stdcall, dynlib: "gdi32",
                                      importc: "WidenPath".}
proc ExtCreatePen*(para1: DWORD, para2: DWORD, para3: var LOGBRUSH,
                   para4: DWORD, para5: var DWORD): HPEN{.stdcall,
    dynlib: "gdi32", importc: "ExtCreatePen".}
proc GetMiterLimit*(para1: HDC, para2: ptr float32): WINBOOL{.stdcall,
    dynlib: "gdi32", importc: "GetMiterLimit".}
proc GetArcDirection*(para1: HDC): int32{.stdcall, dynlib: "gdi32",
    importc: "GetArcDirection".}
proc MoveToEx*(para1: HDC, para2: int32, para3: int32, para4: LPPOINT): WINBOOL{.
    stdcall, dynlib: "gdi32", importc: "MoveToEx".}
proc CreatePolygonRgn*(para1: var POINT, para2: int32, para3: int32): HRGN{.
    stdcall, dynlib: "gdi32", importc: "CreatePolygonRgn".}
proc DPtoLP*(para1: HDC, para2: LPPOINT, para3: int32): WINBOOL{.stdcall,
    dynlib: "gdi32", importc: "DPtoLP".}
proc LPtoDP*(para1: HDC, para2: LPPOINT, para3: int32): WINBOOL{.stdcall,
    dynlib: "gdi32", importc: "LPtoDP".}
proc Polygon*(para1: HDC, para2: LPPOINT, para3: int32): WINBOOL{.stdcall,
    dynlib: "gdi32", importc: "Polygon".}
proc Polyline*(para1: HDC, para2: LPPOINT, para3: int32): WINBOOL{.stdcall,
    dynlib: "gdi32", importc: "Polyline".}
proc PolyBezier*(para1: HDC, para2: LPPOINT, para3: DWORD): WINBOOL{.stdcall,
    dynlib: "gdi32", importc: "PolyBezier".}
proc PolyBezierTo*(para1: HDC, para2: POINT, para3: DWORD): WINBOOL{.stdcall,
    dynlib: "gdi32", importc: "PolyBezierTo".}
proc PolylineTo*(para1: HDC, para2: LPPOINT, para3: DWORD): WINBOOL{.stdcall,
    dynlib: "gdi32", importc: "PolylineTo".}
proc SetViewportExtEx*(para1: HDC, para2: int32, para3: int32, para4: LPSIZE): WINBOOL{.
    stdcall, dynlib: "gdi32", importc: "SetViewportExtEx".}
proc SetViewportOrgEx*(para1: HDC, para2: int32, para3: int32, para4: LPPOINT): WINBOOL{.
    stdcall, dynlib: "gdi32", importc: "SetViewportOrgEx".}
proc SetWindowExtEx*(para1: HDC, para2: int32, para3: int32, para4: LPSIZE): WINBOOL{.
    stdcall, dynlib: "gdi32", importc: "SetWindowExtEx".}
proc SetWindowOrgEx*(para1: HDC, para2: int32, para3: int32, para4: LPPOINT): WINBOOL{.
    stdcall, dynlib: "gdi32", importc: "SetWindowOrgEx".}
proc OffsetViewportOrgEx*(para1: HDC, para2: int32, para3: int32, para4: LPPOINT): WINBOOL{.
    stdcall, dynlib: "gdi32", importc: "OffsetViewportOrgEx".}
proc OffsetWindowOrgEx*(para1: HDC, para2: int32, para3: int32, para4: LPPOINT): WINBOOL{.
    stdcall, dynlib: "gdi32", importc: "OffsetWindowOrgEx".}
proc ScaleViewportExtEx*(para1: HDC, para2: int32, para3: int32, para4: int32,
                         para5: int32, para6: LPSIZE): WINBOOL{.stdcall,
    dynlib: "gdi32", importc: "ScaleViewportExtEx".}
proc ScaleWindowExtEx*(para1: HDC, para2: int32, para3: int32, para4: int32,
                       para5: int32, para6: LPSIZE): WINBOOL{.stdcall,
    dynlib: "gdi32", importc: "ScaleWindowExtEx".}
proc SetBitmapDimensionEx*(para1: HBITMAP, para2: int32, para3: int32,
                           para4: LPSIZE): WINBOOL{.stdcall, dynlib: "gdi32",
    importc: "SetBitmapDimensionEx".}
proc SetBrushOrgEx*(para1: HDC, para2: int32, para3: int32, para4: LPPOINT): WINBOOL{.
    stdcall, dynlib: "gdi32", importc: "SetBrushOrgEx".}
proc GetDCOrgEx*(para1: HDC, para2: LPPOINT): WINBOOL{.stdcall, dynlib: "gdi32",
    importc: "GetDCOrgEx".}
proc FixBrushOrgEx*(para1: HDC, para2: int32, para3: int32, para4: LPPOINT): WINBOOL{.
    stdcall, dynlib: "gdi32", importc: "FixBrushOrgEx".}
proc UnrealizeObject*(para1: HGDIOBJ): WINBOOL{.stdcall, dynlib: "gdi32",
    importc: "UnrealizeObject".}
proc GdiFlush*(): WINBOOL{.stdcall, dynlib: "gdi32", importc: "GdiFlush".}
proc GdiSetBatchLimit*(para1: DWORD): DWORD{.stdcall, dynlib: "gdi32",
    importc: "GdiSetBatchLimit".}
proc GdiGetBatchLimit*(): DWORD{.stdcall, dynlib: "gdi32",
                                 importc: "GdiGetBatchLimit".}
proc SetICMMode*(para1: HDC, para2: int32): int32{.stdcall, dynlib: "gdi32",
    importc: "SetICMMode".}
proc CheckColorsInGamut*(para1: HDC, para2: LPVOID, para3: LPVOID, para4: DWORD): WINBOOL{.
    stdcall, dynlib: "gdi32", importc: "CheckColorsInGamut".}
proc GetColorSpace*(para1: HDC): HANDLE{.stdcall, dynlib: "gdi32",
    importc: "GetColorSpace".}
proc SetColorSpace*(para1: HDC, para2: HCOLORSPACE): WINBOOL{.stdcall,
    dynlib: "gdi32", importc: "SetColorSpace".}
proc DeleteColorSpace*(para1: HCOLORSPACE): WINBOOL{.stdcall, dynlib: "gdi32",
    importc: "DeleteColorSpace".}
proc GetDeviceGammaRamp*(para1: HDC, para2: LPVOID): WINBOOL{.stdcall,
    dynlib: "gdi32", importc: "GetDeviceGammaRamp".}
proc SetDeviceGammaRamp*(para1: HDC, para2: LPVOID): WINBOOL{.stdcall,
    dynlib: "gdi32", importc: "SetDeviceGammaRamp".}
proc ColorMatchToTarget*(para1: HDC, para2: HDC, para3: DWORD): WINBOOL{.
    stdcall, dynlib: "gdi32", importc: "ColorMatchToTarget".}
proc CreatePropertySheetPageA*(lppsp: LPCPROPSHEETPAGE): HPROPSHEETPAGE{.
    stdcall, dynlib: "comctl32", importc: "CreatePropertySheetPageA".}
proc DestroyPropertySheetPage*(hPSPage: HPROPSHEETPAGE): WINBOOL{.stdcall,
    dynlib: "comctl32", importc: "DestroyPropertySheetPage".}
proc InitCommonControls*(){.stdcall, dynlib: "comctl32",
                            importc: "InitCommonControls".}
proc ImageList_AddIcon*(himl: HIMAGELIST, hicon: HICON): int32
proc ImageList_Create*(cx: int32, cy: int32, flags: UINT, cInitial: int32,
                       cGrow: int32): HIMAGELIST{.stdcall, dynlib: "comctl32",
    importc: "ImageList_Create".}
proc ImageList_Destroy*(himl: HIMAGELIST): WINBOOL{.stdcall, dynlib: "comctl32",
    importc: "ImageList_Destroy".}
proc ImageList_GetImageCount*(himl: HIMAGELIST): int32{.stdcall,
    dynlib: "comctl32", importc: "ImageList_GetImageCount".}
proc ImageList_Add*(himl: HIMAGELIST, hbmImage: HBITMAP, hbmMask: HBITMAP): int32{.
    stdcall, dynlib: "comctl32", importc: "ImageList_Add".}
proc ImageList_ReplaceIcon*(himl: HIMAGELIST, i: int32, hicon: HICON): int32{.
    stdcall, dynlib: "comctl32", importc: "ImageList_ReplaceIcon".}
proc ImageList_SetBkColor*(himl: HIMAGELIST, clrBk: COLORREF): COLORREF{.
    stdcall, dynlib: "comctl32", importc: "ImageList_SetBkColor".}
proc ImageList_GetBkColor*(himl: HIMAGELIST): COLORREF{.stdcall,
    dynlib: "comctl32", importc: "ImageList_GetBkColor".}
proc ImageList_SetOverlayImage*(himl: HIMAGELIST, iImage: int32, iOverlay: int32): WINBOOL{.
    stdcall, dynlib: "comctl32", importc: "ImageList_SetOverlayImage".}
proc ImageList_Draw*(himl: HIMAGELIST, i: int32, hdcDst: HDC, x: int32,
                     y: int32, fStyle: UINT): WINBOOL{.stdcall,
    dynlib: "comctl32", importc: "ImageList_Draw".}
proc ImageList_Replace*(himl: HIMAGELIST, i: int32, hbmImage: HBITMAP,
                        hbmMask: HBITMAP): WINBOOL{.stdcall, dynlib: "comctl32",
    importc: "ImageList_Replace".}
proc ImageList_AddMasked*(himl: HIMAGELIST, hbmImage: HBITMAP, crMask: COLORREF): int32{.
    stdcall, dynlib: "comctl32", importc: "ImageList_AddMasked".}
proc ImageList_DrawEx*(himl: HIMAGELIST, i: int32, hdcDst: HDC, x: int32,
                       y: int32, dx: int32, dy: int32, rgbBk: COLORREF,
                       rgbFg: COLORREF, fStyle: UINT): WINBOOL{.stdcall,
    dynlib: "comctl32", importc: "ImageList_DrawEx".}
proc ImageList_Remove*(himl: HIMAGELIST, i: int32): WINBOOL{.stdcall,
    dynlib: "comctl32", importc: "ImageList_Remove".}
proc ImageList_GetIcon*(himl: HIMAGELIST, i: int32, flags: UINT): HICON{.
    stdcall, dynlib: "comctl32", importc: "ImageList_GetIcon".}
proc ImageList_BeginDrag*(himlTrack: HIMAGELIST, iTrack: int32,
                          dxHotspot: int32, dyHotspot: int32): WINBOOL{.stdcall,
    dynlib: "comctl32", importc: "ImageList_BeginDrag".}
proc ImageList_EndDrag*(){.stdcall, dynlib: "comctl32",
                           importc: "ImageList_EndDrag".}
proc ImageList_DragEnter*(hwndLock: HWND, x: int32, y: int32): WINBOOL{.stdcall,
    dynlib: "comctl32", importc: "ImageList_DragEnter".}
proc ImageList_DragLeave*(hwndLock: HWND): WINBOOL{.stdcall, dynlib: "comctl32",
    importc: "ImageList_DragLeave".}
proc ImageList_DragMove*(x: int32, y: int32): WINBOOL{.stdcall,
    dynlib: "comctl32", importc: "ImageList_DragMove".}
proc ImageList_SetDragCursorImage*(himlDrag: HIMAGELIST, iDrag: int32,
                                   dxHotspot: int32, dyHotspot: int32): WINBOOL{.
    stdcall, dynlib: "comctl32", importc: "ImageList_SetDragCursorImage".}
proc ImageList_DragShowNolock*(fShow: WINBOOL): WINBOOL{.stdcall,
    dynlib: "comctl32", importc: "ImageList_DragShowNolock".}
proc ImageList_GetDragImage*(ppt: LPPOINT, pptHotspot: LPPOINT): HIMAGELIST{.
    stdcall, dynlib: "comctl32", importc: "ImageList_GetDragImage".}
proc ImageList_GetIconSize*(himl: HIMAGELIST, cx: var int32, cy: var int32): WINBOOL{.
    stdcall, dynlib: "comctl32", importc: "ImageList_GetIconSize".}
proc ImageList_SetIconSize*(himl: HIMAGELIST, cx: int32, cy: int32): WINBOOL{.
    stdcall, dynlib: "comctl32", importc: "ImageList_SetIconSize".}
proc ImageList_GetImageInfo*(himl: HIMAGELIST, i: int32,
                             pImageInfo: var IMAGEINFO): WINBOOL{.stdcall,
    dynlib: "comctl32", importc: "ImageList_GetImageInfo".}
proc ImageList_Merge*(himl1: HIMAGELIST, i1: int32, himl2: HIMAGELIST,
                      i2: int32, dx: int32, dy: int32): HIMAGELIST{.stdcall,
    dynlib: "comctl32", importc: "ImageList_Merge".}
proc ImageList_SetImageCount*(himl: HIMAGELIST, uNewCount: UINT): int{.stdcall,
    dynlib: "comctl32.dll", importc: "ImageList_SetImageCount".}
proc CreateToolbarEx*(wnd: HWND, ws: DWORD, wID: UINT, nBitmaps: int32,
                      hBMInst: HINST, wBMID: UINT, lpButtons: LPCTBBUTTON,
                      iNumButtons: int32, dxButton: int32, dyButton: int32,
                      dxBitmap: int32, dyBitmap: int32, uStructSize: UINT): HWND{.
    stdcall, dynlib: "comctl32", importc: "CreateToolbarEx".}
proc CreateMappedBitmap*(hInstance: HINST, idBitmap: int32, wFlags: UINT,
                         lpColorMap: LPCOLORMAP, iNumMaps: int32): HBITMAP{.
    stdcall, dynlib: "comctl32", importc: "CreateMappedBitmap".}
proc MenuHelp*(uMsg: UINT, wp: WPARAM, lp: LPARAM, hMainMenu: HMENU,
               hInst: HINST, hwndStatus: HWND, lpwIDs: var UINT){.stdcall,
    dynlib: "comctl32", importc: "MenuHelp".}
proc ShowHideMenuCtl*(wnd: HWND, uFlags: UINT, lpInfo: LPINT): WINBOOL{.
    stdcall, dynlib: "comctl32", importc: "ShowHideMenuCtl".}
proc GetEffectiveClientRect*(wnd: HWND, lprc: LPRECT, lpInfo: LPINT){.stdcall,
    dynlib: "comctl32", importc: "GetEffectiveClientRect".}
proc MakeDragList*(hLB: HWND): WINBOOL{.stdcall, dynlib: "comctl32",
                                        importc: "MakeDragList".}
proc DrawInsert*(handParent: HWND, hLB: HWND, nItem: int32){.stdcall,
    dynlib: "comctl32", importc: "DrawInsert".}
proc LBItemFromPt*(hLB: HWND, pt: POINT, bAutoScroll: WINBOOL): int32{.stdcall,
    dynlib: "comctl32", importc: "LBItemFromPt".}
proc CreateUpDownControl*(dwStyle: DWORD, x: int32, y: int32, cx: int32,
                          cy: int32, hParent: HWND, nID: int32, hInst: HINST,
                          hBuddy: HWND, nUpper: int32, nLower: int32,
                          nPos: int32): HWND{.stdcall, dynlib: "comctl32",
    importc: "CreateUpDownControl".}
proc RegCloseKey*(key: HKEY): LONG{.stdcall, dynlib: "advapi32",
                                     importc: "RegCloseKey".}
proc RegSetKeySecurity*(key: HKEY, SecurityInformation: SECURITY_INFORMATION,
                        pSecurityDescriptor: PSECURITY_DESCRIPTOR): LONG{.
    stdcall, dynlib: "advapi32", importc: "RegSetKeySecurity".}
proc RegFlushKey*(key: HKEY): LONG{.stdcall, dynlib: "advapi32",
                                     importc: "RegFlushKey".}
proc RegGetKeySecurity*(key: HKEY, SecurityInformation: SECURITY_INFORMATION,
                        pSecurityDescriptor: PSECURITY_DESCRIPTOR,
                        lpcbSecurityDescriptor: LPDWORD): LONG{.stdcall,
    dynlib: "advapi32", importc: "RegGetKeySecurity".}
proc RegNotifyChangeKeyValue*(key: HKEY, bWatchSubtree: WINBOOL,
                              dwNotifyFilter: DWORD, hEvent: HANDLE,
                              fAsynchronus: WINBOOL): LONG{.stdcall,
    dynlib: "advapi32", importc: "RegNotifyChangeKeyValue".}
proc IsValidCodePage*(CodePage: UINT): WINBOOL{.stdcall, dynlib: "kernel32",
    importc: "IsValidCodePage".}
proc GetACP*(): UINT{.stdcall, dynlib: "kernel32", importc: "GetACP".}
proc GetOEMCP*(): UINT{.stdcall, dynlib: "kernel32", importc: "GetOEMCP".}
proc GetCPInfo*(para1: UINT, para2: LPCPINFO): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "GetCPInfo".}
proc IsDBCSLeadByte*(TestChar: int8): WINBOOL{.stdcall, dynlib: "kernel32",
    importc: "IsDBCSLeadByte".}
proc IsDBCSLeadByteEx*(CodePage: UINT, TestChar: int8): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "IsDBCSLeadByteEx".}
proc MultiByteToWideChar*(CodePage: UINT, dwFlags: DWORD,
                          lpMultiByteStr: LPCSTR, cchMultiByte: int32,
                          lpWideCharStr: LPWSTR, cchWideChar: int32): int32{.
    stdcall, dynlib: "kernel32", importc: "MultiByteToWideChar".}
proc WideCharToMultiByte*(CodePage: UINT, dwFlags: DWORD,
                          lpWideCharStr: LPCWSTR, cchWideChar: int32,
                          lpMultiByteStr: LPSTR, cchMultiByte: int32,
                          lpDefaultChar: LPCSTR, lpUsedDefaultChar: LPBOOL): int32{.
    stdcall, dynlib: "kernel32", importc: "WideCharToMultiByte".}
proc IsValidLocale*(Locale: LCID, dwFlags: DWORD): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "IsValidLocale".}
proc ConvertDefaultLocale*(Locale: LCID): LCID{.stdcall, dynlib: "kernel32",
    importc: "ConvertDefaultLocale".}
proc GetThreadLocale*(): LCID{.stdcall, dynlib: "kernel32",
                               importc: "GetThreadLocale".}
proc SetThreadLocale*(Locale: LCID): WINBOOL{.stdcall, dynlib: "kernel32",
    importc: "SetThreadLocale".}
proc GetSystemDefaultLangID*(): LANGID{.stdcall, dynlib: "kernel32",
                                        importc: "GetSystemDefaultLangID".}
proc GetUserDefaultLangID*(): LANGID{.stdcall, dynlib: "kernel32",
                                      importc: "GetUserDefaultLangID".}
proc GetSystemDefaultLCID*(): LCID{.stdcall, dynlib: "kernel32",
                                    importc: "GetSystemDefaultLCID".}
proc GetUserDefaultLCID*(): LCID{.stdcall, dynlib: "kernel32",
                                  importc: "GetUserDefaultLCID".}
proc ReadConsoleOutputAttribute*(hConsoleOutput: HANDLE, lpAttribute: LPWORD,
                                 nLength: DWORD, dwReadCoord: COORD,
                                 lpNumberOfAttrsRead: LPDWORD): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "ReadConsoleOutputAttribute".}
proc WriteConsoleOutputAttribute*(hConsoleOutput: HANDLE,
                                  lpAttribute: var int16, nLength: DWORD,
                                  dwWriteCoord: COORD,
                                  lpNumberOfAttrsWritten: LPDWORD): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "WriteConsoleOutputAttribute".}
proc FillConsoleOutputAttribute*(hConsoleOutput: HANDLE, wAttribute: int16,
                                 nLength: DWORD, dwWriteCoord: COORD,
                                 lpNumberOfAttrsWritten: LPDWORD): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "FillConsoleOutputAttribute".}
proc GetConsoleMode*(hConsoleHandle: HANDLE, lpMode: LPDWORD): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "GetConsoleMode".}
proc GetNumberOfConsoleInputEvents*(hConsoleInput: HANDLE,
                                    lpNumberOfEvents: PDWORD): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "GetNumberOfConsoleInputEvents".}
proc GetConsoleScreenBufferInfo*(hConsoleOutput: HANDLE,
    lpConsoleScreenBufferInfo: PCONSOLE_SCREEN_BUFFER_INFO): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "GetConsoleScreenBufferInfo".}
proc GetLargestConsoleWindowSize*(hConsoleOutput: HANDLE): COORD
proc GetConsoleCursorInfo*(hConsoleOutput: HANDLE,
                           lpConsoleCursorInfo: PCONSOLE_CURSOR_INFO): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "GetConsoleCursorInfo".}
proc GetNumberOfConsoleMouseButtons*(lpNumberOfMouseButtons: LPDWORD): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "GetNumberOfConsoleMouseButtons".}
proc SetConsoleMode*(hConsoleHandle: HANDLE, dwMode: DWORD): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "SetConsoleMode".}
proc SetConsoleActiveScreenBuffer*(hConsoleOutput: HANDLE): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "SetConsoleActiveScreenBuffer".}
proc FlushConsoleInputBuffer*(hConsoleInput: HANDLE): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "FlushConsoleInputBuffer".}
proc SetConsoleScreenBufferSize*(hConsoleOutput: HANDLE, dwSize: COORD): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "SetConsoleScreenBufferSize".}
proc SetConsoleCursorPosition*(hConsoleOutput: HANDLE, dwCursorPosition: COORD): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "SetConsoleCursorPosition".}
proc SetConsoleCursorInfo*(hConsoleOutput: HANDLE,
                           lpConsoleCursorInfo: PCONSOLE_CURSOR_INFO): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "SetConsoleCursorInfo".}
proc SetConsoleWindowInfo*(hConsoleOutput: HANDLE, bAbsolute: WINBOOL,
                           lpConsoleWindow: var SMALL_RECT): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "SetConsoleWindowInfo".}
proc SetConsoleTextAttribute*(hConsoleOutput: HANDLE, wAttributes: int16): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "SetConsoleTextAttribute".}
proc SetConsoleCtrlHandler*(HandlerRoutine: PHANDLER_ROUTINE, Add: WINBOOL): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "SetConsoleCtrlHandler".}
proc GenerateConsoleCtrlEvent*(dwCtrlEvent: DWORD, dwProcessGroupId: DWORD): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "GenerateConsoleCtrlEvent".}
proc AllocConsole*(): WINBOOL{.stdcall, dynlib: "kernel32",
                               importc: "AllocConsole".}
proc FreeConsole*(): WINBOOL{.stdcall, dynlib: "kernel32",
                              importc: "FreeConsole".}
proc CreateConsoleScreenBuffer*(dwDesiredAccess: DWORD, dwShareMode: DWORD,
                                lpSecurityAttributes: var SECURITY_ATTRIBUTES,
                                dwFlags: DWORD, lpScreenBufferData: LPVOID): HANDLE{.
    stdcall, dynlib: "kernel32", importc: "CreateConsoleScreenBuffer".}
proc GetConsoleCP*(): UINT{.stdcall, dynlib: "kernel32", importc: "GetConsoleCP".}
proc SetConsoleCP*(wCodePageID: UINT): WINBOOL{.stdcall, dynlib: "kernel32",
    importc: "SetConsoleCP".}
proc GetConsoleOutputCP*(): UINT{.stdcall, dynlib: "kernel32",
                                  importc: "GetConsoleOutputCP".}
proc SetConsoleOutputCP*(wCodePageID: UINT): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "SetConsoleOutputCP".}
proc WNetConnectionDialog*(wnd: HWND, dwType: DWORD): DWORD{.stdcall,
    dynlib: "mpr", importc: "WNetConnectionDialog".}
proc WNetDisconnectDialog*(wnd: HWND, dwType: DWORD): DWORD{.stdcall,
    dynlib: "mpr", importc: "WNetDisconnectDialog".}
proc WNetCloseEnum*(hEnum: HANDLE): DWORD{.stdcall, dynlib: "mpr",
    importc: "WNetCloseEnum".}
proc CloseServiceHandle*(hSCObject: SC_HANDLE): WINBOOL{.stdcall,
    dynlib: "advapi32", importc: "CloseServiceHandle".}
proc ControlService*(hService: SC_HANDLE, dwControl: DWORD,
                     lpServiceStatus: LPSERVICE_STATUS): WINBOOL{.stdcall,
    dynlib: "advapi32", importc: "ControlService".}
proc DeleteService*(hService: SC_HANDLE): WINBOOL{.stdcall, dynlib: "advapi32",
    importc: "DeleteService".}
proc LockServiceDatabase*(hSCManager: SC_HANDLE): SC_LOCK{.stdcall,
    dynlib: "advapi32", importc: "LockServiceDatabase".}
proc NotifyBootConfigStatus*(BootAcceptable: WINBOOL): WINBOOL{.stdcall,
    dynlib: "advapi32", importc: "NotifyBootConfigStatus".}
proc QueryServiceObjectSecurity*(hService: SC_HANDLE,
                                 dwSecurityInformation: SECURITY_INFORMATION,
                                 lpSecurityDescriptor: PSECURITY_DESCRIPTOR,
                                 cbBufSize: DWORD, pcbBytesNeeded: LPDWORD): WINBOOL{.
    stdcall, dynlib: "advapi32", importc: "QueryServiceObjectSecurity".}
proc QueryServiceStatus*(hService: SC_HANDLE, lpServiceStatus: LPSERVICE_STATUS): WINBOOL{.
    stdcall, dynlib: "advapi32", importc: "QueryServiceStatus".}
proc SetServiceObjectSecurity*(hService: SC_HANDLE,
                               dwSecurityInformation: SECURITY_INFORMATION,
                               lpSecurityDescriptor: PSECURITY_DESCRIPTOR): WINBOOL{.
    stdcall, dynlib: "advapi32", importc: "SetServiceObjectSecurity".}
proc SetServiceStatus*(hServiceStatus: SERVICE_STATUS_HANDLE,
                       lpServiceStatus: LPSERVICE_STATUS): WINBOOL{.stdcall,
    dynlib: "advapi32", importc: "SetServiceStatus".}
proc UnlockServiceDatabase*(ScLock: SC_LOCK): WINBOOL{.stdcall,
    dynlib: "advapi32", importc: "UnlockServiceDatabase".}
proc ChoosePixelFormat*(para1: HDC, para2: PPIXELFORMATDESCRIPTOR): int32{.
    stdcall, dynlib: "gdi32", importc: "ChoosePixelFormat".}
proc DescribePixelFormat*(para1: HDC, para2: int32, para3: UINT,
                          para4: LPPIXELFORMATDESCRIPTOR): int32{.stdcall,
    dynlib: "gdi32", importc: "DescribePixelFormat".}
proc SetPixelFormat*(para1: HDC, para2: int32, para3: PPIXELFORMATDESCRIPTOR): WINBOOL{.
    stdcall, dynlib: "gdi32", importc: "SetPixelFormat".}
proc SwapBuffers*(para1: HDC): WINBOOL{.stdcall, dynlib: "gdi32",
                                        importc: "SwapBuffers".}
proc DragQueryPoint*(para1: HDROP, para2: LPPOINT): WINBOOL{.stdcall,
    dynlib: "shell32", importc: "DragQueryPoint".}
proc DragFinish*(para1: HDROP){.stdcall, dynlib: "shell32",
                                importc: "DragFinish".}
proc DragAcceptFiles*(para1: HWND, para2: WINBOOL){.stdcall, dynlib: "shell32",
    importc: "DragAcceptFiles".}
proc DuplicateIcon*(para1: HINST, para2: HICON): HICON{.stdcall,
    dynlib: "shell32", importc: "DuplicateIcon".}
proc DdeAbandonTransaction*(para1: DWORD, para2: HCONV, para3: DWORD): WINBOOL{.
    stdcall, dynlib: "user32", importc: "DdeAbandonTransaction".}
proc DdeAccessData*(para1: HDDEDATA, para2: PDWORD): PBYTE{.stdcall,
    dynlib: "user32", importc: "DdeAccessData".}
proc DdeAddData*(para1: HDDEDATA, para2: PBYTE, para3: DWORD, para4: DWORD): HDDEDATA{.
    stdcall, dynlib: "user32", importc: "DdeAddData".}
proc DdeClientTransaction*(para1: PBYTE, para2: DWORD, para3: HCONV, para4: HSZ,
                           para5: UINT, para6: UINT, para7: DWORD, para8: PDWORD): HDDEDATA{.
    stdcall, dynlib: "user32", importc: "DdeClientTransaction".}
proc DdeCmpStringHandles*(para1: HSZ, para2: HSZ): int32{.stdcall,
    dynlib: "user32", importc: "DdeCmpStringHandles".}
proc DdeConnect*(para1: DWORD, para2: HSZ, para3: HSZ, para4: var CONVCONTEXT): HCONV{.
    stdcall, dynlib: "user32", importc: "DdeConnect".}
proc DdeConnectList*(para1: DWORD, para2: HSZ, para3: HSZ, para4: HCONVLIST,
                     para5: PCONVCONTEXT): HCONVLIST{.stdcall, dynlib: "user32",
    importc: "DdeConnectList".}
proc DdeCreateDataHandle*(para1: DWORD, para2: LPBYTE, para3: DWORD,
                          para4: DWORD, para5: HSZ, para6: UINT, para7: UINT): HDDEDATA{.
    stdcall, dynlib: "user32", importc: "DdeCreateDataHandle".}
proc DdeDisconnect*(para1: HCONV): WINBOOL{.stdcall, dynlib: "user32",
    importc: "DdeDisconnect".}
proc DdeDisconnectList*(para1: HCONVLIST): WINBOOL{.stdcall, dynlib: "user32",
    importc: "DdeDisconnectList".}
proc DdeEnableCallback*(para1: DWORD, para2: HCONV, para3: UINT): WINBOOL{.
    stdcall, dynlib: "user32", importc: "DdeEnableCallback".}
proc DdeFreeDataHandle*(para1: HDDEDATA): WINBOOL{.stdcall, dynlib: "user32",
    importc: "DdeFreeDataHandle".}
proc DdeFreeStringHandle*(para1: DWORD, para2: HSZ): WINBOOL{.stdcall,
    dynlib: "user32", importc: "DdeFreeStringHandle".}
proc DdeGetData*(para1: HDDEDATA, para2: LPBYTE, para3: DWORD, para4: DWORD): DWORD{.
    stdcall, dynlib: "user32", importc: "DdeGetData".}
proc DdeGetLastError*(para1: DWORD): UINT{.stdcall, dynlib: "user32",
    importc: "DdeGetLastError".}
proc DdeImpersonateClient*(para1: HCONV): WINBOOL{.stdcall, dynlib: "user32",
    importc: "DdeImpersonateClient".}
proc DdeKeepStringHandle*(para1: DWORD, para2: HSZ): WINBOOL{.stdcall,
    dynlib: "user32", importc: "DdeKeepStringHandle".}
proc DdeNameService*(para1: DWORD, para2: HSZ, para3: HSZ, para4: UINT): HDDEDATA{.
    stdcall, dynlib: "user32", importc: "DdeNameService".}
proc DdePostAdvise*(para1: DWORD, para2: HSZ, para3: HSZ): WINBOOL{.stdcall,
    dynlib: "user32", importc: "DdePostAdvise".}
proc DdeQueryConvInfo*(para1: HCONV, para2: DWORD, para3: PCONVINFO): UINT{.
    stdcall, dynlib: "user32", importc: "DdeQueryConvInfo".}
proc DdeQueryNextServer*(para1: HCONVLIST, para2: HCONV): HCONV{.stdcall,
    dynlib: "user32", importc: "DdeQueryNextServer".}
proc DdeReconnect*(para1: HCONV): HCONV{.stdcall, dynlib: "user32",
    importc: "DdeReconnect".}
proc DdeSetUserHandle*(para1: HCONV, para2: DWORD, para3: DWORD): WINBOOL{.
    stdcall, dynlib: "user32", importc: "DdeSetUserHandle".}
proc DdeUnaccessData*(para1: HDDEDATA): WINBOOL{.stdcall, dynlib: "user32",
    importc: "DdeUnaccessData".}
proc DdeUninitialize*(para1: DWORD): WINBOOL{.stdcall, dynlib: "user32",
    importc: "DdeUninitialize".}
proc SHAddToRecentDocs*(para1: UINT, para2: LPCVOID){.stdcall,
    dynlib: "shell32", importc: "SHAddToRecentDocs".}
proc SHBrowseForFolder*(para1: LPBROWSEINFO): LPITEMIDLIST{.stdcall,
    dynlib: "shell32", importc: "SHBrowseForFolder".}
proc SHChangeNotify*(para1: LONG, para2: UINT, para3: LPCVOID, para4: LPCVOID){.
    stdcall, dynlib: "shell32", importc: "SHChangeNotify".}
proc SHFileOperation*(para1: LPSHFILEOPSTRUCT): int32{.stdcall,
    dynlib: "shell32", importc: "SHFileOperation".}
proc SHFreeNameMappings*(para1: HANDLE){.stdcall, dynlib: "shell32",
    importc: "SHFreeNameMappings".}
proc SHGetFileInfo*(para1: LPCTSTR, para2: DWORD, para3: var SHFILEINFO,
                    para4: UINT, para5: UINT): DWORD{.stdcall,
    dynlib: "shell32", importc: "SHGetFileInfo".}
proc SHGetPathFromIDList*(para1: LPCITEMIDLIST, para2: LPTSTR): WINBOOL{.
    stdcall, dynlib: "shell32", importc: "SHGetPathFromIDList".}
proc SHGetSpecialFolderLocation*(para1: HWND, para2: int32,
                                 para3: var LPITEMIDLIST): HRESULT{.stdcall,
    dynlib: "shell32", importc: "SHGetSpecialFolderLocation".}
proc CommDlgExtendedError*(): DWORD{.stdcall, dynlib: "comdlg32",
                                     importc: "CommDlgExtendedError".}
  # wgl Windows OpenGL helper functions
proc wglUseFontBitmaps*(para1: HDC, para2: DWORD, para3: DWORD, para4: DWORD): WINBOOL{.
    stdcall, dynlib: "opengl32", importc: "wglUseFontBitmapsA".}
proc wglCreateContext*(para1: HDC): HGLRC{.stdcall, dynlib: "opengl32",
    importc: "wglCreateContext".}
proc wglCreateLayerContext*(para1: HDC, para2: int32): HGLRC{.stdcall,
    dynlib: "opengl32", importc: "wglCreateLayerContext".}
proc wglCopyContext*(para1: HGLRC, para2: HGLRC, para3: UINT): WINBOOL{.stdcall,
    dynlib: "opengl32", importc: "wglCopyContext".}
proc wglDeleteContext*(para1: HGLRC): WINBOOL{.stdcall, dynlib: "opengl32",
    importc: "wglDeleteContext".}
proc wglGetCurrentContext*(): HGLRC{.stdcall, dynlib: "opengl32",
                                     importc: "wglGetCurrentContext".}
proc wglGetCurrentDC*(): HDC{.stdcall, dynlib: "opengl32",
                              importc: "wglGetCurrentDC".}
proc wglMakeCurrent*(para1: HDC, para2: HGLRC): WINBOOL{.stdcall,
    dynlib: "opengl32", importc: "wglMakeCurrent".}
proc wglShareLists*(para1: HGLRC, para2: HGLRC): WINBOOL{.stdcall,
    dynlib: "opengl32", importc: "wglShareLists".}
proc wglUseFontBitmapsW*(para1: HDC, para2: DWORD, para3: DWORD, para4: DWORD): WINBOOL{.
    stdcall, dynlib: "opengl32", importc: "wglUseFontBitmapsW".}
proc wglUseFontOutlines*(para1: HDC, para2: DWORD, para3: DWORD, para4: DWORD,
                         para5: float32, para6: float32, para7: int32,
                         para8: LPGLYPHMETRICSFLOAT): WINBOOL{.stdcall,
    dynlib: "opengl32", importc: "wglUseFontOutlinesA".}
proc wglUseFontBitmapsA*(para1: HDC, para2: DWORD, para3: DWORD, para4: DWORD): WINBOOL{.
    stdcall, dynlib: "opengl32", importc: "wglUseFontBitmapsA".}
proc wglUseFontOutlinesA*(para1: HDC, para2: DWORD, para3: DWORD, para4: DWORD,
                          para5: float32, para6: float32, para7: int32,
                          para8: LPGLYPHMETRICSFLOAT): WINBOOL{.stdcall,
    dynlib: "opengl32", importc: "wglUseFontOutlinesA".}
proc wglDescribeLayerPlane*(para1: HDC, para2: int32, para3: int32, para4: UINT,
                            para5: LPLAYERPLANEDESCRIPTOR): WINBOOL{.stdcall,
    dynlib: "opengl32", importc: "wglDescribeLayerPlane".}
proc wglGetLayerPaletteEntries*(para1: HDC, para2: int32, para3: int32,
                                para4: int32, para5: var COLORREF): int32{.
    stdcall, dynlib: "opengl32", importc: "wglGetLayerPaletteEntries".}
proc wglGetProcAddress*(para1: LPCSTR): TProc{.stdcall, dynlib: "opengl32",
    importc: "wglGetProcAddress".}
proc wglRealizeLayerPalette*(para1: HDC, para2: int32, para3: WINBOOL): WINBOOL{.
    stdcall, dynlib: "opengl32", importc: "wglRealizeLayerPalette".}
proc wglSetLayerPaletteEntries*(para1: HDC, para2: int32, para3: int32,
                                para4: int32, para5: var COLORREF): int32{.
    stdcall, dynlib: "opengl32", importc: "wglSetLayerPaletteEntries".}
proc wglSwapLayerBuffers*(para1: HDC, para2: UINT): WINBOOL{.stdcall,
    dynlib: "opengl32", importc: "wglSwapLayerBuffers".}
proc wglUseFontOutlinesW*(para1: HDC, para2: DWORD, para3: DWORD, para4: DWORD,
                          para5: float32, para6: float32, para7: int32,
                          para8: LPGLYPHMETRICSFLOAT): WINBOOL{.stdcall,
    dynlib: "opengl32", importc: "wglUseFontOutlinesW".}
  # translated macros
proc Animate_Create*(hWndP: HWND, id: HMENU, dwStyle: DWORD, hInstance: HINST): HWND
proc Animate_Open*(wnd: HWND, szName: LPTSTR): LRESULT
proc Animate_Play*(wnd: HWND, `from`, `to`: int32, rep: UINT): LRESULT

proc Animate_Stop*(wnd: HWND): LRESULT
proc Animate_Close*(wnd: HWND): LRESULT
proc Animate_Seek*(wnd: HWND, frame: int32): LRESULT
proc PropSheet_AddPage*(hPropSheetDlg: HWND, hpage: HPROPSHEETPAGE): LRESULT
proc PropSheet_Apply*(hPropSheetDlg: HWND): LRESULT
proc PropSheet_CancelToClose*(hPropSheetDlg: HWND): LRESULT
proc PropSheet_Changed*(hPropSheetDlg, hwndPage: HWND): LRESULT
proc PropSheet_GetCurrentPageHwnd*(hDlg: HWND): LRESULT
proc PropSheet_GetTabControl*(hPropSheetDlg: HWND): LRESULT
proc PropSheet_IsDialogMessage*(hDlg: HWND, pMsg: int32): LRESULT
proc PropSheet_PressButton*(hPropSheetDlg: HWND, iButton: int32): LRESULT
proc PropSheet_QuerySiblings*(hPropSheetDlg: HWND, param1, param2: int32): LRESULT
proc PropSheet_RebootSystem*(hPropSheetDlg: HWND): LRESULT
proc PropSheet_RemovePage*(hPropSheetDlg: HWND, hpage: HPROPSHEETPAGE,
                           index: int32): LRESULT
proc PropSheet_RestartWindows*(hPropSheetDlg: HWND): LRESULT
proc PropSheet_SetCurSel*(hPropSheetDlg: HWND, hpage: HPROPSHEETPAGE,
                          index: int32): LRESULT
proc PropSheet_SetCurSelByID*(hPropSheetDlg: HWND, id: int32): LRESULT
proc PropSheet_SetFinishText*(hPropSheetDlg: HWND, lpszText: LPTSTR): LRESULT
proc PropSheet_SetTitle*(hPropSheetDlg: HWND, dwStyle: DWORD, lpszText: LPCTSTR): LRESULT
proc PropSheet_SetWizButtons*(hPropSheetDlg: HWND, dwFlags: DWORD): LRESULT
proc PropSheet_UnChanged*(hPropSheetDlg: HWND, hwndPage: HWND): LRESULT
proc Header_DeleteItem*(hwndHD: HWND, index: int32): WINBOOL
proc Header_GetItem*(hwndHD: HWND, index: int32, hdi: var HD_ITEM): WINBOOL
proc Header_GetItemCount*(hwndHD: HWND): int32
proc Header_InsertItem*(hwndHD: HWND, index: int32, hdi: var HD_ITEM): int32
proc Header_Layout*(hwndHD: HWND, layout: var HD_LAYOUT): WINBOOL
proc Header_SetItem*(hwndHD: HWND, index: int32, hdi: var HD_ITEM): WINBOOL
proc ListView_Arrange*(hwndLV: HWND, code: UINT): LRESULT
proc ListView_CreateDragImage*(wnd: HWND, i: int32, lpptUpLeft: LPPOINT): LRESULT
proc ListView_DeleteAllItems*(wnd: HWND): LRESULT
proc ListView_DeleteColumn*(wnd: HWND, iCol: int32): LRESULT
proc ListView_DeleteItem*(wnd: HWND, iItem: int32): LRESULT
proc ListView_EditLabel*(hwndLV: HWND, i: int32): LRESULT
proc ListView_EnsureVisible*(hwndLV: HWND, i, fPartialOK: int32): LRESULT
proc ListView_FindItem*(wnd: HWND, iStart: int32, lvfi: var LV_FINDINFO): int32
proc ListView_GetBkColor*(wnd: HWND): LRESULT
proc ListView_GetCallbackMask*(wnd: HWND): LRESULT
proc ListView_GetColumn*(wnd: HWND, iCol: int32, col: var LV_COLUMN): LRESULT
proc ListView_GetColumnWidth*(wnd: HWND, iCol: int32): LRESULT
proc ListView_GetCountPerPage*(hwndLV: HWND): LRESULT
proc ListView_GetEditControl*(hwndLV: HWND): LRESULT
proc ListView_GetImageList*(wnd: HWND, iImageList: wINT): LRESULT
proc ListView_GetISearchString*(hwndLV: HWND, lpsz: LPTSTR): LRESULT
proc ListView_GetItem*(wnd: HWND, item: var LV_ITEM): LRESULT
proc ListView_GetItemCount*(wnd: HWND): LRESULT
proc ListView_GetItemPosition*(hwndLV: HWND, i: int32, pt: var POINT): int32
proc ListView_GetItemSpacing*(hwndLV: HWND, fSmall: int32): LRESULT
proc ListView_GetItemState*(hwndLV: HWND, i, mask: int32): LRESULT
proc ListView_GetNextItem*(wnd: HWND, iStart, flags: int32): LRESULT
proc ListView_GetOrigin*(hwndLV: HWND, pt: var POINT): LRESULT
proc ListView_GetSelectedCount*(hwndLV: HWND): LRESULT
proc ListView_GetStringWidth*(hwndLV: HWND, psz: LPCTSTR): LRESULT
proc ListView_GetTextBkColor*(wnd: HWND): LRESULT
proc ListView_GetTextColor*(wnd: HWND): LRESULT
proc ListView_GetTopIndex*(hwndLV: HWND): LRESULT
proc ListView_GetViewRect*(wnd: HWND, rc: var RECT): LRESULT
proc ListView_HitTest*(hwndLV: HWND, info: var LV_HITTESTINFO): LRESULT
proc ListView_InsertColumn*(wnd: HWND, iCol: int32, col: var LV_COLUMN): LRESULT
proc ListView_InsertItem*(wnd: HWND, item: var LV_ITEM): LRESULT
proc ListView_RedrawItems*(hwndLV: HWND, iFirst, iLast: int32): LRESULT
proc ListView_Scroll*(hwndLV: HWND, dx, dy: int32): LRESULT
proc ListView_SetBkColor*(wnd: HWND, clrBk: COLORREF): LRESULT
proc ListView_SetCallbackMask*(wnd: HWND, mask: UINT): LRESULT
proc ListView_SetColumn*(wnd: HWND, iCol: int32, col: var LV_COLUMN): LRESULT
proc ListView_SetColumnWidth*(wnd: HWND, iCol, cx: int32): LRESULT
proc ListView_SetImageList*(wnd: HWND, himl: int32, iImageList: HIMAGELIST): LRESULT
proc ListView_SetItem*(wnd: HWND, item: var LV_ITEM): LRESULT
proc ListView_SetItemCount*(hwndLV: HWND, cItems: int32): LRESULT
proc ListView_SetItemPosition*(hwndLV: HWND, i, x, y: int32): LRESULT
proc ListView_SetItemPosition32*(hwndLV: HWND, i, x, y: int32): LRESULT
proc ListView_SetItemState*(hwndLV: HWND, i, data, mask: int32): LRESULT
proc ListView_SetItemText*(hwndLV: HWND, i, iSubItem: int32, pszText: LPTSTR): LRESULT
proc ListView_SetTextBkColor*(wnd: HWND, clrTextBk: COLORREF): LRESULT
proc ListView_SetTextColor*(wnd: HWND, clrText: COLORREF): LRESULT
proc ListView_SortItems*(hwndLV: HWND, pfnCompare: PFNLVCOMPARE, lPrm: LPARAM): LRESULT
proc ListView_Update*(hwndLV: HWND, i: int32): LRESULT
proc TreeView_InsertItem*(wnd: HWND, lpis: LPTV_INSERTSTRUCT): LRESULT
proc TreeView_DeleteItem*(wnd: HWND, hitem: HTREEITEM): LRESULT
proc TreeView_DeleteAllItems*(wnd: HWND): LRESULT
proc TreeView_Expand*(wnd: HWND, hitem: HTREEITEM, code: int32): LRESULT
proc TreeView_GetCount*(wnd: HWND): LRESULT
proc TreeView_GetIndent*(wnd: HWND): LRESULT
proc TreeView_SetIndent*(wnd: HWND, indent: int32): LRESULT
proc TreeView_GetImageList*(wnd: HWND, iImage: WPARAM): LRESULT
proc TreeView_SetImageList*(wnd: HWND, himl: HIMAGELIST, iImage: WPARAM): LRESULT
proc TreeView_GetNextItem*(wnd: HWND, hitem: HTREEITEM, code: int32): LRESULT
proc TreeView_GetChild*(wnd: HWND, hitem: HTREEITEM): LRESULT
proc TreeView_GetNextSibling*(wnd: HWND, hitem: HTREEITEM): LRESULT
proc TreeView_GetPrevSibling*(wnd: HWND, hitem: HTREEITEM): LRESULT
proc TreeView_GetParent*(wnd: HWND, hitem: HTREEITEM): LRESULT
proc TreeView_GetFirstVisible*(wnd: HWND): LRESULT
proc TreeView_GetNextVisible*(wnd: HWND, hitem: HTREEITEM): LRESULT
proc TreeView_GetPrevVisible*(wnd: HWND, hitem: HTREEITEM): LRESULT
proc TreeView_GetSelection*(wnd: HWND): LRESULT
proc TreeView_GetDropHilight*(wnd: HWND): LRESULT
proc TreeView_GetRoot*(wnd: HWND): LRESULT
proc TreeView_Select*(wnd: HWND, hitem: HTREEITEM, code: int32): LRESULT
proc TreeView_SelectItem*(wnd: HWND, hitem: HTREEITEM): LRESULT
proc TreeView_SelectDropTarget*(wnd: HWND, hitem: HTREEITEM): LRESULT
proc TreeView_SelectSetFirstVisible*(wnd: HWND, hitem: HTREEITEM): LRESULT
proc TreeView_GetItem*(wnd: HWND, item: var TV_ITEM): LRESULT
proc TreeView_SetItem*(wnd: HWND, item: var TV_ITEM): LRESULT
proc TreeView_EditLabel*(wnd: HWND, hitem: HTREEITEM): LRESULT
proc TreeView_GetEditControl*(wnd: HWND): LRESULT
proc TreeView_GetVisibleCount*(wnd: HWND): LRESULT
proc TreeView_HitTest*(wnd: HWND, lpht: LPTV_HITTESTINFO): LRESULT
proc TreeView_CreateDragImage*(wnd: HWND, hitem: HTREEITEM): LRESULT
proc TreeView_SortChildren*(wnd: HWND, hitem: HTREEITEM, recurse: int32): LRESULT
proc TreeView_EnsureVisible*(wnd: HWND, hitem: HTREEITEM): LRESULT
proc TreeView_SortChildrenCB*(wnd: HWND, psort: LPTV_SORTCB, recurse: int32): LRESULT
proc TreeView_EndEditLabelNow*(wnd: HWND, fCancel: int32): LRESULT
proc TreeView_GetISearchString*(hwndTV: HWND, lpsz: LPTSTR): LRESULT
proc TabCtrl_GetImageList*(wnd: HWND): LRESULT
proc TabCtrl_SetImageList*(wnd: HWND, himl: HIMAGELIST): LRESULT
proc TabCtrl_GetItemCount*(wnd: HWND): LRESULT
proc TabCtrl_GetItem*(wnd: HWND, iItem: int32, item: var TC_ITEM): LRESULT
proc TabCtrl_SetItem*(wnd: HWND, iItem: int32, item: var TC_ITEM): LRESULT

proc TabCtrl_InsertItem*(wnd: HWND, iItem: int32, item: var TC_ITEM): LRESULT
proc TabCtrl_DeleteItem*(wnd: HWND, i: int32): LRESULT
proc TabCtrl_DeleteAllItems*(wnd: HWND): LRESULT
proc TabCtrl_GetItemRect*(wnd: HWND, i: int32, rc: var RECT): LRESULT
proc TabCtrl_GetCurSel*(wnd: HWND): LRESULT
proc TabCtrl_SetCurSel*(wnd: HWND, i: int32): LRESULT
proc TabCtrl_HitTest*(hwndTC: HWND, info: var TC_HITTESTINFO): LRESULT
proc TabCtrl_SetItemExtra*(hwndTC: HWND, cb: int32): LRESULT
proc TabCtrl_AdjustRect*(wnd: HWND, bLarger: WINBOOL, rc: var RECT): LRESULT
proc TabCtrl_SetItemSize*(wnd: HWND, x, y: int32): LRESULT
proc TabCtrl_RemoveImage*(wnd: HWND, i: WPARAM): LRESULT
proc TabCtrl_SetPadding*(wnd: HWND, cx, cy: int32): LRESULT
proc TabCtrl_GetRowCount*(wnd: HWND): LRESULT
proc TabCtrl_GetToolTips*(wnd: HWND): LRESULT
proc TabCtrl_SetToolTips*(wnd: HWND, hwndTT: int32): LRESULT
proc TabCtrl_GetCurFocus*(wnd: HWND): LRESULT
proc TabCtrl_SetCurFocus*(wnd: HWND, i: int32): LRESULT
proc SNDMSG*(wnd: HWND, Msg: UINT, wp: WPARAM, lp: LPARAM): LRESULT
proc CommDlg_OpenSave_GetSpecA*(hdlg: HWND, psz: LPSTR, cbmax: int32): LRESULT
proc CommDlg_OpenSave_GetSpecW*(hdlg: HWND, psz: LPWSTR, cbmax: int32): LRESULT
when defined(winUnicode):
  proc CommDlg_OpenSave_GetSpec*(hdlg: HWND, psz: LPWSTR, cbmax: int32): LRESULT
else:
  proc CommDlg_OpenSave_GetSpec*(hdlg: HWND, psz: LPSTR, cbmax: int32): LRESULT
proc CommDlg_OpenSave_GetFilePathA*(hdlg: HWND, psz: LPSTR, cbmax: int32): LRESULT
proc CommDlg_OpenSave_GetFilePathW*(hdlg: HWND, psz: LPWSTR, cbmax: int32): LRESULT
when defined(winUnicode):
  proc CommDlg_OpenSave_GetFilePath*(hdlg: HWND, psz: LPWSTR, cbmax: int32): LRESULT
else:
  proc CommDlg_OpenSave_GetFilePath*(hdlg: HWND, psz: LPSTR, cbmax: int32): LRESULT
proc CommDlg_OpenSave_GetFolderPathA*(hdlg: HWND, psz: LPSTR, cbmax: int32): LRESULT
proc CommDlg_OpenSave_GetFolderPathW*(hdlg: HWND, psz: LPWSTR, cbmax: int32): LRESULT
when defined(winUnicode):
  proc CommDlg_OpenSave_GetFolderPath*(hdlg: HWND, psz: LPWSTR, cbmax: int32): LRESULT
else:
  proc CommDlg_OpenSave_GetFolderPath*(hdlg: HWND, psz: LPSTR, cbmax: int32): LRESULT
proc CommDlg_OpenSave_GetFolderIDList*(hdlg: HWND, pidl: LPVOID, cbmax: int32): LRESULT
proc CommDlg_OpenSave_SetControlText*(hdlg: HWND, id: int32, text: LPSTR): LRESULT
proc CommDlg_OpenSave_HideControl*(hdlg: HWND, id: int32): LRESULT
proc CommDlg_OpenSave_SetDefExt*(hdlg: HWND, pszext: LPSTR): LRESULT
proc GetNextWindow*(wnd: HWND, uCmd: UINT): HWND{.stdcall, dynlib: "user32",
    importc: "GetWindow".}
proc GlobalAllocPtr*(flags, cb: DWord): Pointer
proc GlobalFreePtr*(lp: Pointer): Pointer
proc GlobalUnlockPtr*(lp: pointer): Pointer
proc GlobalLockPtr*(lp: pointer): Pointer
proc GlobalReAllocPtr*(lp: Pointer, cbNew, flags: DWord): Pointer
proc GlobalPtrHandle*(lp: pointer): Pointer
proc SetLayeredWindowAttributes*(HWND: hwnd, crKey: COLORREF, bAlpha: int8,
                                 dwFlags: DWORD): WINBOOL{.stdcall,
    dynlib: "user32", importc: "SetLayeredWindowAttributes".}
type
  PIID* = PGUID
  TIID* = TGUID
  TFNDlgProc* = FARPROC
  TFNThreadStartRoutine* = FARPROC
  TFNTimerAPCRoutine* = FARPROC
  TFNFiberStartRoutine* = FARPROC
  TFNHookProc* = HOOKPROC
  PObjectTypeList* = ptr TObjectTypeList
  OBJECT_TYPE_LIST* {.final, pure.} = object
    Level*: int16
    Sbz*: int16
    ObjectType*: PGUID

  TObjectTypeList* = OBJECT_TYPE_LIST
  AUDIT_EVENT_TYPE* = DWORD
  PBlendFunction* = ptr TBlendFunction
  BLENDFUNCTION* {.final, pure.} = object
    BlendOp*: int8
    BlendFlags*: int8
    SourceConstantAlpha*: int8
    AlphaFormat*: int8

  TBlendFunction* = BLENDFUNCTION
  WIN_CERTIFICATE* {.final, pure.} = object
    dwLength*: DWord
    wRevision*: int16
    wCertificateType*: int16
    bCertificate*: array[0..0, int8]

  TWinCertificate* = WIN_CERTIFICATE
  PWinCertificate* = ptr TWinCertificate
  TMaxLogPalette* {.final, pure.} = object
    palVersion*: int16
    palNumEntries*: int16
    palPalEntry*: array[int8, TPaletteEntry]

  PMaxLogPalette* = ptr TMaxLogPalette
  POSVersionInfoA* = POSVERSIONINFO
  TBitmapFileHeader* = BITMAPFILEHEADER
  PBitmapFileHeader* = ptr TBitmapFileHeader

const
  # dll names
  advapi32* = "advapi32.dll"
  kernel32* = "kernel32.dll"
  mpr* = "mpr.dll"
  version* = "version.dll"
  comctl32* = "comctl32.dll"
  gdi32* = "gdi32.dll"
  opengl32* = "opengl32.dll"
  user32* = "user32.dll"
  wintrust* = "wintrust.dll"
  # Openfile Share modes normally declared in sysutils
  fmShareCompat* = 0x00000000
  fmShareExclusive* = 0x00000010
  fmShareDenyWrite* = 0x00000020
  fmShareDenyRead* = 0x00000030
  fmShareDenyNone* = 0x00000040
  # HRESULT codes, delphilike
  SIF_TRACKPOS* = 0x00000010
  HTBORDER* = 18
  CP_UTF7* = 65000
  CP_UTF8* = 65001
  CREATE_NO_WINDOW* = 0x08000000
  VK_ATTN* = 246
  VK_CRSEL* = 247
  VK_EXSEL* = 248
  VK_EREOF* = 249
  VK_PLAY* = 250
  VK_ZOOM* = 251
  VK_NONAME* = 252
  VK_PA1* = 253
  VK_OEM_CLEAR* = 254

const                         # Severity values
  FACILITY_NT_BIT* = 0x10000000

                            #  A language ID is a 16 bit value which is the combination of a
                            #  primary language ID and a secondary language ID.  The bits are
                            #  allocated as follows:
                            #
                            #       +-----------------------+-------------------------+
                            #       |     Sublanguage ID    |   Primary Language ID   |
                            #       +-----------------------+-------------------------+
                            #        15                   10 9                       0   bit
                            #
                            #
                            #  Language ID creation/extraction macros:
                            #
                            #    MAKELANGID    - construct language id from a primary language id and
                            #                    a sublanguage id.
                            #    PRIMARYLANGID - extract primary language id from a language id.
                            #    SUBLANGID     - extract sublanguage id from a language id.
                            #
proc MAKELANGID*(PrimaryLang, SubLang: USHORT): int16
proc PRIMARYLANGID*(LangId: int16): int16
proc SUBLANGID*(LangId: int16): int16

  #
  #  A locale ID is a 32 bit value which is the combination of a
  #  language ID, a sort ID, and a reserved area.  The bits are
  #  allocated as follows:
  #
  #       +-------------+---------+-------------------------+
  #       |   Reserved  | Sort ID |      Language ID        |
  #       +-------------+---------+-------------------------+
  #        31         20 19     16 15                      0   bit
  #
  #
  #  Locale ID creation/extraction macros:
  #
  #    MAKELCID            - construct the locale id from a language id and a sort id.
  #    MAKESORTLCID        - construct the locale id from a language id, sort id, and sort version.
  #    LANGIDFROMLCID      - extract the language id from a locale id.
  #    SORTIDFROMLCID      - extract the sort id from a locale id.
  #    SORTVERSIONFROMLCID - extract the sort version from a locale id.
  #
const
  NLS_VALID_LOCALE_MASK* = 0x000FFFFF

proc MAKELCID*(LangId, SortId: int16): DWORD
proc MAKESORTLCID*(LangId, SortId, SortVersion: int16): DWORD
proc LANGIDFROMLCID*(LocaleId: LCID): int16
proc SORTIDFROMLCID*(LocaleId: LCID): int16
proc SORTVERSIONFROMLCID*(LocaleId: LCID): int16

  #
  #  Default System and User IDs for language and locale.
  #
proc LANG_SYSTEM_DEFAULT*(): int16
proc LANG_USER_DEFAULT*(): int16
proc LOCALE_NEUTRAL*(): DWORD
proc LOCALE_INVARIANT*(): DWORD
proc Succeeded*(Status: HRESULT): WINBOOL
proc Failed*(Status: HRESULT): WINBOOL
proc IsError*(Status: HRESULT): WINBOOL
proc HResultCode*(hr: HRESULT): int32
proc HResultFacility*(hr: HRESULT): int32
proc HResultSeverity*(hr: HRESULT): int32
proc MakeResult*(p1, p2, mask: int32): HRESULT
proc HResultFromWin32*(x: int32): HRESULT
proc HResultFromNT*(x: int32): HRESULT
proc InitializeCriticalSection*(CriticalSection: var TRTLCriticalSection){.
    stdcall, dynlib: "kernel32", importc: "InitializeCriticalSection".}
proc EnterCriticalSection*(CriticalSection: var TRTLCriticalSection){.stdcall,
    dynlib: "kernel32", importc: "EnterCriticalSection".}
proc LeaveCriticalSection*(CriticalSection: var TRTLCriticalSection){.stdcall,
    dynlib: "kernel32", importc: "LeaveCriticalSection".}
proc DeleteCriticalSection*(CriticalSection: var TRTLCriticalSection){.stdcall,
    dynlib: "kernel32", importc: "DeleteCriticalSection".}
proc InitializeCriticalSectionAndSpinCount*(
    CriticalSection: var TRTLCriticalSection, dwSpinCount: DWORD): WINBOOL{.
    stdcall, dynlib: "kernel32",
    importc: "InitializeCriticalSectionAndSpinCount".}
proc SetCriticalSectionSpinCount*(CriticalSection: var TRTLCriticalSection,
                                  dwSpinCount: DWORD): DWORD{.stdcall,
    dynlib: "kernel32", importc: "SetCriticalSectionSpinCount".}
proc TryEnterCriticalSection*(CriticalSection: var TRTLCriticalSection): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "TryEnterCriticalSection".}
proc ControlService*(hService: SC_HANDLE, dwControl: DWORD,
                     ServiceStatus: var TSERVICESTATUS): WINBOOL{.stdcall,
    dynlib: "advapi32", importc: "ControlService".}
proc QueryServiceStatus*(hService: SC_HANDLE,
                         lpServiceStatus: var TSERVICESTATUS): WINBOOL{.stdcall,
    dynlib: "advapi32", importc: "QueryServiceStatus".}
proc SetServiceStatus*(hServiceStatus: SERVICE_STATUS_HANDLE,
                       ServiceStatus: TSERVICESTATUS): WINBOOL{.stdcall,
    dynlib: "advapi32", importc: "SetServiceStatus".}
proc AdjustTokenPrivileges*(TokenHandle: THandle, DisableAllPrivileges: WINBOOL,
                            NewState: TTokenPrivileges, BufferLength: DWORD,
                            PreviousState: var TTokenPrivileges,
                            ReturnLength: var DWORD): WINBOOL{.stdcall,
    dynlib: "advapi32", importc: "AdjustTokenPrivileges".}
proc AdjustWindowRect*(lpRect: var TRect, dwStyle: DWORD, bMenu: WINBOOL): WINBOOL{.
    stdcall, dynlib: "user32", importc: "AdjustWindowRect".}
proc AdjustWindowRectEx*(lpRect: var TRect, dwStyle: DWORD, bMenu: WINBOOL,
                         dwExStyle: DWORD): WINBOOL{.stdcall, dynlib: "user32",
    importc: "AdjustWindowRectEx".}
proc AllocateAndInitializeSid*(pIdentifierAuthority: TSIDIdentifierAuthority,
                               nSubAuthorityCount: int8,
                               nSubAuthority0, nSubAuthority1: DWORD,
    nSubAuthority2, nSubAuthority3, nSubAuthority4: DWORD, nSubAuthority5,
    nSubAuthority6, nSubAuthority7: DWORD, pSid: var Pointer): WINBOOL{.stdcall,
    dynlib: "advapi32", importc: "AllocateAndInitializeSid".}
proc AllocateLocallyUniqueId*(Luid: var TLargeInteger): WINBOOL{.stdcall,
    dynlib: "advapi32", importc: "AllocateLocallyUniqueId".}
proc BackupRead*(hFile: THandle, lpBuffer: PByte, nNumberOfBytesToRead: DWORD,
                 lpNumberOfBytesRead: var DWORD, bAbort: WINBOOL,
                 bProcessSecurity: WINBOOL, lpContext: var Pointer): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "BackupRead".}
proc BackupSeek*(hFile: THandle, dwLowBytesToSeek, dwHighBytesToSeek: DWORD,
                 lpdwLowByteSeeked, lpdwHighByteSeeked: var DWORD,
                 lpContext: Pointer): WINBOOL{.stdcall, dynlib: "kernel32",
    importc: "BackupSeek".}
proc BackupWrite*(hFile: THandle, lpBuffer: PByte, nNumberOfBytesToWrite: DWORD,
                  lpNumberOfBytesWritten: var DWORD,
                  bAbort, bProcessSecurity: WINBOOL, lpContext: var Pointer): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "BackupWrite".}
proc BeginPaint*(wnd: HWND, lpPaint: var TPaintStruct): HDC{.stdcall,
    dynlib: "user32", importc: "BeginPaint".}
proc BuildCommDCB*(lpDef: cstring, lpDCB: var TDCB): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "BuildCommDCBA".}
proc BuildCommDCBA*(lpDef: LPCSTR, lpDCB: var TDCB): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "BuildCommDCBA".}
proc BuildCommDCBAndTimeouts*(lpDef: cstring, lpDCB: var TDCB,
                              lpCommTimeouts: var TCommTimeouts): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "BuildCommDCBAndTimeoutsA".}
proc BuildCommDCBAndTimeoutsA*(lpDef: LPCSTR, lpDCB: var TDCB,
                               lpCommTimeouts: var TCommTimeouts): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "BuildCommDCBAndTimeoutsA".}
proc BuildCommDCBAndTimeoutsW*(lpDef: LPWSTR, lpDCB: var TDCB,
                               lpCommTimeouts: var TCommTimeouts): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "BuildCommDCBAndTimeoutsW".}
proc BuildCommDCBW*(lpDef: LPWSTR, lpDCB: var TDCB): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "BuildCommDCBW".}
proc CallMsgFilter*(lpMsg: var TMsg, nCode: int): WINBOOL{.stdcall,
    dynlib: "user32", importc: "CallMsgFilterA".}
proc CallMsgFilterA*(lpMsg: var TMsg, nCode: int): WINBOOL{.stdcall,
    dynlib: "user32", importc: "CallMsgFilterA".}
proc CallMsgFilterW*(lpMsg: var TMsg, nCode: int): WINBOOL{.stdcall,
    dynlib: "user32", importc: "CallMsgFilterW".}
proc CallNamedPipe*(lpNamedPipeName: cstring, lpInBuffer: Pointer,
                    nInBufferSize: DWORD, lpOutBuffer: Pointer,
                    nOutBufferSize: DWORD, lpBytesRead: var DWORD,
                    nTimeOut: DWORD): WINBOOL{.stdcall, dynlib: "kernel32",
    importc: "CallNamedPipeA".}
proc CallNamedPipeA*(lpNamedPipeName: LPCSTR, lpInBuffer: Pointer,
                     nInBufferSize: DWORD, lpOutBuffer: Pointer,
                     nOutBufferSize: DWORD, lpBytesRead: var DWORD,
                     nTimeOut: DWORD): WINBOOL{.stdcall, dynlib: "kernel32",
    importc: "CallNamedPipeA".}
proc CallNamedPipeW*(lpNamedPipeName: LPWSTR, lpInBuffer: Pointer,
                     nInBufferSize: DWORD, lpOutBuffer: Pointer,
                     nOutBufferSize: DWORD, lpBytesRead: var DWORD,
                     nTimeOut: DWORD): WINBOOL{.stdcall, dynlib: "kernel32",
    importc: "CallNamedPipeW".}
proc CoRegisterClassObject*(para1: TCLSID, para2: pointer, para3: DWORD,
                            para4: DWORD, out_para5: DWORD): HRESULT{.stdcall,
    dynlib: "ole32.dll", importc: "CoRegisterClassObject".}
proc ChangeDisplaySettings*(lpDevMode: var TDeviceMode, dwFlags: DWORD): int32{.
    stdcall, dynlib: "user32", importc: "ChangeDisplaySettingsA".}
proc ChangeDisplaySettingsA*(lpDevMode: var TDeviceModeA, dwFlags: DWORD): int32{.
    stdcall, dynlib: "user32", importc: "ChangeDisplaySettingsA".}
proc ChangeDisplaySettingsEx*(lpszDeviceName: cstring,
                              lpDevMode: var TDeviceMode, wnd: HWND,
                              dwFlags: DWORD, lParam: Pointer): int32{.stdcall,
    dynlib: "user32", importc: "ChangeDisplaySettingsExA".}
proc ChangeDisplaySettingsExA*(lpszDeviceName: LPCSTR,
                               lpDevMode: var TDeviceModeA, wnd: HWND,
                               dwFlags: DWORD, lParam: Pointer): int32{.stdcall,
    dynlib: "user32", importc: "ChangeDisplaySettingsExA".}
proc ChangeDisplaySettingsExW*(lpszDeviceName: LPWSTR,
                               lpDevMode: var TDeviceModeW, wnd: HWND,
                               dwFlags: DWORD, lParam: Pointer): int32{.stdcall,
    dynlib: "user32", importc: "ChangeDisplaySettingsExW".}
proc ChangeDisplaySettingsW*(lpDevMode: var TDeviceModeW, dwFlags: DWORD): int32{.
    stdcall, dynlib: "user32", importc: "ChangeDisplaySettingsW".}
  #function CheckColorsInGamut(DC: HDC; var RGBQuads, Results; Count: DWORD): WINBOOL; stdcall; external 'gdi32' name 'CheckColorsInGamut';
proc ChoosePixelFormat*(para1: HDC, para2: var PIXELFORMATDESCRIPTOR): int32{.
    stdcall, dynlib: "gdi32", importc: "ChoosePixelFormat".}
proc ClearCommError*(hFile: THandle, lpErrors: var DWORD, lpStat: PComStat): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "ClearCommError".}
proc ClientToScreen*(wnd: HWND, lpPoint: var TPoint): WINBOOL{.stdcall,
    dynlib: "user32", importc: "ClientToScreen".}
proc ClipCursor*(lpRect: var RECT): WINBOOL{.stdcall, dynlib: "user32",
    importc: "ClipCursor".}
  #function CombineTransform(var p1: TXForm; const p2, p3: TXForm): WINBOOL; stdcall; external 'gdi32' name 'CombineTransform';
proc CommConfigDialog*(lpszName: cstring, wnd: HWND, lpCC: var TCommConfig): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "CommConfigDialogA".}
proc CommConfigDialogA*(lpszName: LPCSTR, wnd: HWND, lpCC: var TCommConfig): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "CommConfigDialogA".}
proc CommConfigDialogW*(lpszName: LPWSTR, wnd: HWND, lpCC: var TCommConfig): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "CommConfigDialogW".}
  #function CompareFileTime(const lpFileTime1, lpFileTime2: TFileTime): Longint; stdcall; external 'kernel32' name 'CompareFileTime';
  #function ConvertToAutoInheritPrivateObjectSecurity(ParentDescriptor, CurrentSecurityDescriptor: PSecurityDescriptor; var NewDescriptor: PSecurityDescriptor; ObjectType: PGUID; IsDirectoryObject: WINBOOL; const GenericMapping: TGenericMapping): WINBOOL;
  #  stdcall; external 'advapi32' name 'ConvertToAutoInheritPrivateObjectSecurity';
proc CopyAcceleratorTable*(hAccelSrc: HACCEL, lpAccelDst: pointer,
                           cAccelEntries: int): int{.stdcall, dynlib: "user32",
    importc: "CopyAcceleratorTableA".}
proc CopyAcceleratorTableA*(hAccelSrc: HACCEL, lpAccelDst: pointer,
                            cAccelEntries: int): int{.stdcall, dynlib: "user32",
    importc: "CopyAcceleratorTableA".}
proc CopyAcceleratorTableW*(hAccelSrc: HACCEL, lpAccelDst: pointer,
                            cAccelEntries: int): int{.stdcall, dynlib: "user32",
    importc: "CopyAcceleratorTableW".}
proc CopyRect*(lprcDst: var TRect, lprcSrc: TRect): WINBOOL{.stdcall,
    dynlib: "user32", importc: "CopyRect".}
proc CreateAcceleratorTable*(Accel: pointer, Count: int): HACCEL{.stdcall,
    dynlib: "user32", importc: "CreateAcceleratorTableA".}
proc CreateAcceleratorTableA*(Accel: pointer, Count: int): HACCEL{.stdcall,
    dynlib: "user32", importc: "CreateAcceleratorTableA".}
proc CreateAcceleratorTableW*(Accel: pointer, Count: int): HACCEL{.stdcall,
    dynlib: "user32", importc: "CreateAcceleratorTableW".}
  #function CreateBitmapIndirect(const p1: TBitmap): HBITMAP; stdcall; external 'gdi32' name 'CreateBitmapIndirect';
  #function CreateBrushIndirect(const p1: TLogBrush): HBRUSH; stdcall; external 'gdi32' name 'CreateBrushIndirect';
proc CreateColorSpace*(ColorSpace: var TLogColorSpace): HCOLORSPACE{.stdcall,
    dynlib: "gdi32", importc: "CreateColorSpaceA".}
proc CreateColorSpaceA*(ColorSpace: var TLogColorSpaceA): HCOLORSPACE{.stdcall,
    dynlib: "gdi32", importc: "CreateColorSpaceA".}
  #function CreateColorSpaceW(var ColorSpace: TLogColorSpaceW): HCOLORSPACE; stdcall; external 'gdi32' name 'CreateColorSpaceW';
proc CreateDialogIndirectParam*(hInstance: HINST, lpTemplate: TDlgTemplate,
                                hWndParent: HWND, lpDialogFunc: TFNDlgProc,
                                dwInitParam: LPARAM): HWND{.stdcall,
    dynlib: "user32", importc: "CreateDialogIndirectParamA".}
  #function CreateDialogIndirectParamA(hInstance: HINST; const lpTemplate: TDlgTemplate; hWndParent: HWND; lpDialogFunc: TFNDlgProc; dwInitParam: LPARAM): HWND; stdcall; external 'user32' name 'CreateDialogIndirectParamA';
  #function CreateDialogIndirectParamW(hInstance: HINST; const lpTemplate: TDlgTemplate; hWndParent: HWND; lpDialogFunc: TFNDlgProc; dwInitParam: LPARAM): HWND; stdcall; external 'user32' name 'CreateDialogIndirectParamW';
  #function CreateDIBitmap(DC: HDC; var InfoHeader: TBitmapInfoHeader; dwUsage: DWORD; InitBits: PChar; var InitInfo: TBitmapInfo; wUsage: UINT): HBITMAP; stdcall; external 'gdi32' name 'CreateDIBitmap';
  #function CreateDIBPatternBrushPt(const p1: Pointer; p2: UINT): HBRUSH; stdcall; external 'gdi32' name 'CreateDIBPatternBrushPt';
  #function CreateDIBSection(DC: HDC; const p2: TBitmapInfo; p3: UINT; var p4: Pointer; p5: THandle; p6: DWORD): HBITMAP; stdcall; external 'gdi32' name 'CreateDIBSection';
  #function CreateEllipticRgnIndirect(const p1: TRect): HRGN; stdcall; external 'gdi32' name 'CreateEllipticRgnIndirect';
  #function CreateFontIndirect(const p1: TLogFont): HFONT;stdcall; external 'gdi32' name 'CreateFontIndirectA';
  #function CreateFontIndirectA(const p1: TLogFontA): HFONT; stdcall; external 'gdi32' name 'CreateFontIndirectA';
  #function CreateFontIndirectEx(const p1: PEnumLogFontExDV): HFONT;stdcall; external 'gdi32' name 'CreateFontIndirectExA';
  #function CreateFontIndirectExA(const p1: PEnumLogFontExDVA): HFONT;stdcall; external 'gdi32' name 'CreateFontIndirectExA';
  #function CreateFontIndirectExW(const p1: PEnumLogFontExDVW): HFONT;stdcall; external 'gdi32' name 'CreateFontIndirectExW';
  #function CreateFontIndirectW(const p1: TLogFontW): HFONT; stdcall; external 'gdi32' name 'CreateFontIndirectW';
proc CreateIconIndirect*(piconinfo: var TIconInfo): HICON{.stdcall,
    dynlib: "user32", importc: "CreateIconIndirect".}
  #function CreatePalette(const LogPalette: TLogPalette): HPalette; stdcall; external 'gdi32' name 'CreatePalette';
  #function CreatePenIndirect(const LogPen: TLogPen): HPEN; stdcall; external 'gdi32' name 'CreatePenIndirect';
proc CreatePipe*(hReadPipe, hWritePipe: var THandle,
                 lpPipeAttributes: PSecurityAttributes, nSize: DWORD): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "CreatePipe".}
proc CreatePolygonRgn*(Points: pointer, Count, FillMode: int): HRGN{.stdcall,
    dynlib: "gdi32", importc: "CreatePolygonRgn".}
proc CreatePolyPolygonRgn*(pPtStructs: pointer, pIntArray: pointer, p3, p4: int): HRGN{.
    stdcall, dynlib: "gdi32", importc: "CreatePolyPolygonRgn".}
  #function CreatePrivateObjectSecurity(ParentDescriptor, CreatorDescriptor: PSecurityDescriptor; var NewDescriptor: PSecurityDescriptor; IsDirectoryObject: WINBOOL; Token: THandle; const GenericMapping: TGenericMapping): WINBOOL;
  #  stdcall; external 'advapi32' name 'CreatePrivateObjectSecurity';
  #function CreatePrivateObjectSecurityEx(ParentDescriptor, CreatorDescriptor: PSecurityDescriptor; var NewDescriptor: PSecurityDescriptor; ObjectType: PGUID; IsContainerObject: WINBOOL; AutoInheritFlags: ULONG; Token: THandle;
  #  const GenericMapping: TGenericMapping): WINBOOL;stdcall; external 'advapi32' name 'CreatePrivateObjectSecurityEx';
proc CreateProcess*(lpApplicationName: cstring, lpCommandLine: cstring,
    lpProcessAttributes, lpThreadAttributes: PSecurityAttributes,
                    bInheritHandles: WINBOOL, dwCreationFlags: DWORD,
                    lpEnvironment: Pointer, lpCurrentDirectory: cstring,
                    lpStartupInfo: TStartupInfo,
                    lpProcessInformation: var TProcessInformation): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "CreateProcessA".}
proc CreateProcessA*(lpApplicationName: LPCSTR, lpCommandLine: LPCSTR,
    lpProcessAttributes, lpThreadAttributes: PSecurityAttributes,
                     bInheritHandles: WINBOOL, dwCreationFlags: DWORD,
                     lpEnvironment: Pointer, lpCurrentDirectory: LPCSTR,
                     lpStartupInfo: TStartupInfo,
                     lpProcessInformation: var TProcessInformation): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "CreateProcessA".}
  #function CreateProcessAsUser(hToken: THandle; lpApplicationName: PChar; lpCommandLine: PChar; lpProcessAttributes: PSecurityAttributes; lpThreadAttributes: PSecurityAttributes; bInheritHandles: WINBOOL; dwCreationFlags: DWORD;
  # lpEnvironment: Pointer; lpCurrentDirectory: PChar; const lpStartupInfo: TStartupInfo; var lpProcessInformation: TProcessInformation): WINBOOL;stdcall; external 'advapi32' name 'CreateProcessAsUserA';
  #function CreateProcessAsUserA(hToken: THandle; lpApplicationName: LPCSTR; lpCommandLine: LPCSTR; lpProcessAttributes: PSecurityAttributes; lpThreadAttributes: PSecurityAttributes; bInheritHandles: WINBOOL; dwCreationFlags: DWORD;
  #  lpEnvironment: Pointer; lpCurrentDirectory: LPCSTR; const lpStartupInfo: TStartupInfo; var lpProcessInformation: TProcessInformation): WINBOOL; stdcall; external 'advapi32' name 'CreateProcessAsUserA';
  #function CreateProcessAsUserW(hToken: THandle; lpApplicationName: LPWSTR; lpCommandLine: LPWSTR; lpProcessAttributes: PSecurityAttributes; lpThreadAttributes: PSecurityAttributes; bInheritHandles: WINBOOL; dwCreationFlags: DWORD;
  #  lpEnvironment: Pointer; lpCurrentDirectory: LPWSTR; const lpStartupInfo: TStartupInfo; var lpProcessInformation: TProcessInformation): WINBOOL; stdcall; external 'advapi32' name 'CreateProcessAsUserW';
proc CreateProcessW*(lpApplicationName: LPWSTR, lpCommandLine: LPWSTR,
    lpProcessAttributes, lpThreadAttributes: PSecurityAttributes,
                     bInheritHandles: WINBOOL, dwCreationFlags: DWORD,
                     lpEnvironment: Pointer, lpCurrentDirectory: LPWSTR,
                     lpStartupInfo: TStartupInfo,
                     lpProcessInformation: var TProcessInformation): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "CreateProcessW".}
  #function CreateRectRgnIndirect(const p1: TRect): HRGN; stdcall; external 'gdi32' name 'CreateRectRgnIndirect';
proc CreateRemoteThread*(hProcess: THandle, lpThreadAttributes: Pointer,
                         dwStackSize: DWORD,
                         lpStartAddress: TFNThreadStartRoutine,
                         lpParameter: Pointer, dwCreationFlags: DWORD,
                         lpThreadId: var DWORD): THandle{.stdcall,
    dynlib: "kernel32", importc: "CreateRemoteThread".}
proc CreateThread*(lpThreadAttributes: Pointer, dwStackSize: DWORD,
                   lpStartAddress: TFNThreadStartRoutine, lpParameter: Pointer,
                   dwCreationFlags: DWORD, lpThreadId: var DWORD): THandle{.
    stdcall, dynlib: "kernel32", importc: "CreateThread".}
proc DdeSetQualityOfService*(hWndClient: HWnd,
                             pqosNew: TSecurityQualityOfService,
                             pqosPrev: PSecurityQualityOfService): WINBOOL{.
    stdcall, dynlib: "user32", importc: "DdeSetQualityOfService".}
  #function DeleteAce(var pAcl: TACL; dwAceIndex: DWORD): WINBOOL; stdcall; external 'advapi32' name 'DeleteAce';
proc DescribePixelFormat*(DC: HDC, p2: int, p3: UINT,
                          p4: var TPixelFormatDescriptor): WINBOOL{.stdcall,
    dynlib: "gdi32", importc: "DescribePixelFormat".}
  #function DestroyPrivateObjectSecurity(var ObjectDescriptor: PSecurityDescriptor): WINBOOL; stdcall; external 'advapi32' name 'DestroyPrivateObjectSecurity';
proc DeviceIoControl*(hDevice: THandle, dwIoControlCode: DWORD,
                      lpInBuffer: Pointer, nInBufferSize: DWORD,
                      lpOutBuffer: Pointer, nOutBufferSize: DWORD,
                      lpBytesReturned: var DWORD, lpOverlapped: POverlapped): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "DeviceIoControl".}
proc DialogBoxIndirectParam*(hInstance: HINST, lpDialogTemplate: TDlgTemplate,
                             hWndParent: HWND, lpDialogFunc: TFNDlgProc,
                             dwInitParam: LPARAM): int{.stdcall,
    dynlib: "user32", importc: "DialogBoxIndirectParamA".}
proc DialogBoxIndirectParamA*(hInstance: HINST, lpDialogTemplate: TDlgTemplate,
                              hWndParent: HWND, lpDialogFunc: TFNDlgProc,
                              dwInitParam: LPARAM): int{.stdcall,
    dynlib: "user32", importc: "DialogBoxIndirectParamA".}
proc DialogBoxIndirectParamW*(hInstance: HINST, lpDialogTemplate: TDlgTemplate,
                              hWndParent: HWND, lpDialogFunc: TFNDlgProc,
                              dwInitParam: LPARAM): int{.stdcall,
    dynlib: "user32", importc: "DialogBoxIndirectParamW".}
proc DispatchMessage*(lpMsg: TMsg): int32{.stdcall, dynlib: "user32",
    importc: "DispatchMessageA".}
proc DispatchMessageA*(lpMsg: TMsg): int32{.stdcall, dynlib: "user32",
    importc: "DispatchMessageA".}
proc DispatchMessageW*(lpMsg: TMsg): int32{.stdcall, dynlib: "user32",
    importc: "DispatchMessageW".}
proc DosDateTimeToFileTime*(wFatDate, wFatTime: int16, lpFileTime: var TFileTime): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "DosDateTimeToFileTime".}
proc DPtoLP*(DC: HDC, Points: pointer, Count: int): WINBOOL{.stdcall,
    dynlib: "gdi32", importc: "DPtoLP".}
  # function DrawAnimatedRects(wnd: HWND; idAni: Integer; const lprcFrom, lprcTo: TRect): WINBOOL; stdcall; external 'user32' name 'DrawAnimatedRects';
  #function DrawCaption(p1: HWND; p2: HDC; const p3: TRect; p4: UINT): WINBOOL; stdcall; external 'user32' name 'DrawCaption';
proc DrawEdge*(hdc: HDC, qrc: var TRect, edge: UINT, grfFlags: UINT): WINBOOL{.
    stdcall, dynlib: "user32", importc: "DrawEdge".}
  #function DrawFocusRect(hDC: HDC; const lprc: TRect): WINBOOL; stdcall; external 'user32' name 'DrawFocusRect';
proc DrawFrameControl*(DC: HDC, Rect: TRect, uType, uState: UINT): WINBOOL{.
    stdcall, dynlib: "user32", importc: "DrawFrameControl".}
proc DrawText*(hDC: HDC, lpString: cstring, nCount: int, lpRect: var TRect,
               uFormat: UINT): int{.stdcall, dynlib: "user32",
                                    importc: "DrawTextA".}
proc DrawTextA*(hDC: HDC, lpString: LPCSTR, nCount: int, lpRect: var TRect,
                uFormat: UINT): int{.stdcall, dynlib: "user32",
                                     importc: "DrawTextA".}
proc DrawTextEx*(DC: HDC, lpchText: cstring, cchText: int, p4: var TRect,
                 dwDTFormat: UINT, DTParams: PDrawTextParams): int{.stdcall,
    dynlib: "user32", importc: "DrawTextExA".}
proc DrawTextExA*(DC: HDC, lpchText: LPCSTR, cchText: int, p4: var TRect,
                  dwDTFormat: UINT, DTParams: PDrawTextParams): int{.stdcall,
    dynlib: "user32", importc: "DrawTextExA".}
proc DrawTextExW*(DC: HDC, lpchText: LPWSTR, cchText: int, p4: var TRect,
                  dwDTFormat: UINT, DTParams: PDrawTextParams): int{.stdcall,
    dynlib: "user32", importc: "DrawTextExW".}
proc DrawTextW*(hDC: HDC, lpString: LPWSTR, nCount: int, lpRect: var TRect,
                uFormat: UINT): int{.stdcall, dynlib: "user32",
                                     importc: "DrawTextW".}
  #function DuplicateTokenEx(hExistingToken: THandle; dwDesiredAccess: DWORD; lpTokenAttributes: PSecurityAttributes; ImpersonationLevel: TSecurityImpersonationLevel; TokenType: TTokenType; var phNewToken: THandle): WINBOOL;
  #  stdcall; external 'advapi32' name 'DuplicateTokenEx';
proc EndPaint*(wnd: HWND, lpPaint: TPaintStruct): WINBOOL{.stdcall,
    dynlib: "user32", importc: "EndPaint".}
  #function EnumDisplayDevices(Unused: Pointer; iDevNum: DWORD; var lpDisplayDevice: TDisplayDevice; dwFlags: DWORD): WINBOOL;stdcall; external 'user32' name 'EnumDisplayDevicesA';
  #function EnumDisplayDevicesA(Unused: Pointer; iDevNum: DWORD; var lpDisplayDevice: TDisplayDeviceA; dwFlags: DWORD): WINBOOL;stdcall; external 'user32' name 'EnumDisplayDevicesA';
  #function EnumDisplayDevicesW(Unused: Pointer; iDevNum: DWORD; var lpDisplayDevice: TDisplayDeviceW; dwFlags: DWORD): WINBOOL;stdcall; external 'user32' name 'EnumDisplayDevicesW';
proc EnumDisplaySettings*(lpszDeviceName: cstring, iModeNum: DWORD,
                          lpDevMode: var TDeviceMode): WINBOOL{.stdcall,
    dynlib: "user32", importc: "EnumDisplaySettingsA".}
proc EnumDisplaySettingsA*(lpszDeviceName: LPCSTR, iModeNum: DWORD,
                           lpDevMode: var TDeviceModeA): WINBOOL{.stdcall,
    dynlib: "user32", importc: "EnumDisplaySettingsA".}
proc EnumDisplaySettingsW*(lpszDeviceName: LPWSTR, iModeNum: DWORD,
                           lpDevMode: var TDeviceModeW): WINBOOL{.stdcall,
    dynlib: "user32", importc: "EnumDisplaySettingsW".}
  #function EnumEnhMetaFile(DC: HDC; p2: HENHMETAFILE; p3: TFNEnhMFEnumProc; p4: Pointer; const p5: TRect): WINBOOL; stdcall; external 'gdi32' name 'EnumEnhMetaFile';
  #function EnumFontFamiliesEx(DC: HDC; var p2: TLogFont; p3: TFNFontEnumProc; p4: LPARAM; p5: DWORD): WINBOOL;stdcall; external 'gdi32' name 'EnumFontFamiliesExA';
  #function EnumFontFamiliesExA(DC: HDC; var p2: TLogFontA; p3: TFNFontEnumProcA; p4: LPARAM; p5: DWORD): WINBOOL; stdcall; external 'gdi32' name 'EnumFontFamiliesExA';
  #function EnumFontFamiliesExW(DC: HDC; var p2: TLogFontW; p3: TFNFontEnumProcW; p4: LPARAM; p5: DWORD): WINBOOL; stdcall; external 'gdi32' name 'EnumFontFamiliesExW';
  #function EqualRect(const lprc1, lprc2: TRect): WINBOOL; stdcall; external 'user32' name 'EqualRect';
proc ExtCreatePen*(PenStyle, Width: DWORD, Brush: TLogBrush, StyleCount: DWORD,
                   Style: Pointer): HPEN{.stdcall, dynlib: "gdi32",
    importc: "ExtCreatePen".}
proc ExtCreateRegion*(p1: PXForm, p2: DWORD, p3: TRgnData): HRGN{.stdcall,
    dynlib: "gdi32", importc: "ExtCreateRegion".}
  # function ExtEscape(DC: HDC; p2, p3: Integer; const p4: LPCSTR; p5: Integer; p6: LPSTR): Integer; stdcall; external 'gdi32' name 'ExtEscape';
proc FileTimeToDosDateTime*(lpFileTime: TFileTime,
                            lpFatDate, lpFatTime: var int16): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "FileTimeToDosDateTime".}
proc FileTimeToLocalFileTime*(lpFileTime: TFileTime,
                              lpLocalFileTime: var TFileTime): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "FileTimeToLocalFileTime".}
proc FileTimeToSystemTime*(lpFileTime: TFileTime, lpSystemTime: var TSystemTime): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "FileTimeToSystemTime".}
proc FillConsoleOutputAttribute*(hConsoleOutput: THandle, wAttribute: int16,
                                 nLength: DWORD, dwWriteCoord: TCoord,
                                 lpNumberOfAttrsWritten: var DWORD): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "FillConsoleOutputAttribute".}
proc FillConsoleOutputCharacter*(hConsoleOutput: THandle, cCharacter: Char,
                                 nLength: DWORD, dwWriteCoord: TCoord,
                                 lpNumberOfCharsWritten: var DWORD): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "FillConsoleOutputCharacterA".}
proc FillConsoleOutputCharacterA*(hConsoleOutput: THandle, cCharacter: char,
                                  nLength: DWORD, dwWriteCoord: TCoord,
                                  lpNumberOfCharsWritten: var DWORD): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "FillConsoleOutputCharacterA".}
proc FillConsoleOutputCharacterW*(hConsoleOutput: THandle, cCharacter: WideChar,
                                  nLength: DWORD, dwWriteCoord: TCoord,
                                  lpNumberOfCharsWritten: var DWORD): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "FillConsoleOutputCharacterW".}
  #function FillRect(hDC: HDC; const lprc: TRect; hbr: HBRUSH): Integer; stdcall; external 'user32' name 'FillRect';
proc FindFirstFile*(lpFileName: cstring, lpFindFileData: var TWIN32FindData): THandle{.
    stdcall, dynlib: "kernel32", importc: "FindFirstFileA".}
proc FindFirstFileA*(lpFileName: LPCSTR, lpFindFileData: var TWIN32FindDataA): THandle{.
    stdcall, dynlib: "kernel32", importc: "FindFirstFileA".}
proc FindFirstFileW*(lpFileName: LPWSTR, lpFindFileData: var TWIN32FindDataW): THandle{.
    stdcall, dynlib: "kernel32", importc: "FindFirstFileW".}
  #function FindFirstFreeAce(var pAcl: TACL; var pAce: Pointer): WINBOOL; stdcall; external 'advapi32' name 'FindFirstFreeAce';
proc FindNextFile*(hFindFile: THandle, lpFindFileData: var TWIN32FindData): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "FindNextFileA".}
proc FindNextFileA*(hFindFile: THandle, lpFindFileData: var TWIN32FindDataA): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "FindNextFileA".}
proc FindNextFileW*(hFindFile: THandle, lpFindFileData: var TWIN32FindDataW): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "FindNextFileW".}
  #function FlushInstructionCache(hProcess: THandle; const lpBaseAddress: Pointer; dwSize: DWORD): WINBOOL; stdcall; external 'kernel32' name 'FlushInstructionCache';
  #function FlushViewOfFile(const lpBaseAddress: Pointer; dwNumberOfBytesToFlush: DWORD): WINBOOL; stdcall; external 'kernel32' name 'FlushViewOfFile';
  #function FrameRect(hDC: HDC; const lprc: TRect; hbr: HBRUSH): Integer; stdcall; external 'user32' name 'FrameRect';
  #function GetAce(const pAcl: TACL; dwAceIndex: DWORD; var pAce: Pointer): WINBOOL; stdcall; external 'advapi32' name 'GetAce';
  #function GetAclInformation(const pAcl: TACL; pAclInformation: Pointer; nAclInformationLength: DWORD; dwAclInformationClass: TAclInformationClass): WINBOOL; stdcall; external 'advapi32' name 'GetAclInformation';
  #function GetAltTabInfo(wnd: HWND; iItem: Integer; var pati: TAltTabInfo; pszItemText: PChar; cchItemText: UINT): WINBOOL;stdcall; external 'user32' name 'GetAltTabInfoA';
  #function GetAltTabInfoA(wnd: HWND; iItem: Integer; var pati: TAltTabInfo; pszItemText: LPCSTR; cchItemText: UINT): WINBOOL;stdcall; external 'user32' name 'GetAltTabInfoA';
  #function GetAltTabInfoW(wnd: HWND; iItem: Integer; var pati: TAltTabInfo; pszItemText: LPWSTR; cchItemText: UINT): WINBOOL;stdcall; external 'user32' name 'GetAltTabInfoW';
proc GetAspectRatioFilterEx*(DC: HDC, p2: var TSize): WINBOOL{.stdcall,
    dynlib: "gdi32", importc: "GetAspectRatioFilterEx".}
proc GetBinaryType*(lpApplicationName: cstring, lpBinaryType: var DWORD): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "GetBinaryTypeA".}
proc GetBinaryTypeA*(lpApplicationName: LPCSTR, lpBinaryType: var DWORD): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "GetBinaryTypeA".}
proc GetBinaryTypeW*(lpApplicationName: LPWSTR, lpBinaryType: var DWORD): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "GetBinaryTypeW".}
proc GetBitmapDimensionEx*(p1: HBITMAP, p2: var TSize): WINBOOL{.stdcall,
    dynlib: "gdi32", importc: "GetBitmapDimensionEx".}
proc GetBoundsRect*(DC: HDC, p2: var TRect, p3: UINT): UINT{.stdcall,
    dynlib: "gdi32", importc: "GetBoundsRect".}
proc GetBrushOrgEx*(DC: HDC, p2: var TPoint): WINBOOL{.stdcall, dynlib: "gdi32",
    importc: "GetBrushOrgEx".}
proc GetCaretPos*(lpPoint: var TPoint): WINBOOL{.stdcall, dynlib: "user32",
    importc: "GetCaretPos".}
proc GetCharABCWidths*(DC: HDC, p2, p3: UINT, ABCStructs: pointer): WINBOOL{.
    stdcall, dynlib: "gdi32", importc: "GetCharABCWidthsA".}
proc GetCharABCWidthsA*(DC: HDC, p2, p3: UINT, ABCStructs: pointer): WINBOOL{.
    stdcall, dynlib: "gdi32", importc: "GetCharABCWidthsA".}
proc GetCharABCWidthsFloat*(DC: HDC, p2, p3: UINT, ABCFloatSturcts: pointer): WINBOOL{.
    stdcall, dynlib: "gdi32", importc: "GetCharABCWidthsFloatA".}
proc GetCharABCWidthsFloatA*(DC: HDC, p2, p3: UINT, ABCFloatSturcts: pointer): WINBOOL{.
    stdcall, dynlib: "gdi32", importc: "GetCharABCWidthsFloatA".}
proc GetCharABCWidthsFloatW*(DC: HDC, p2, p3: UINT, ABCFloatSturcts: pointer): WINBOOL{.
    stdcall, dynlib: "gdi32", importc: "GetCharABCWidthsFloatW".}
  #function GetCharABCWidthsI(DC: HDC; p2, p3: UINT; p4: PWORD; const Widths): WINBOOL;stdcall; external 'gdi32' name 'GetCharABCWidthsI';
proc GetCharABCWidthsW*(DC: HDC, p2, p3: UINT, ABCStructs: pointer): WINBOOL{.
    stdcall, dynlib: "gdi32", importc: "GetCharABCWidthsW".}
proc GetCharacterPlacement*(DC: HDC, p2: cstring, p3, p4: WINBOOL,
                            p5: var TGCPResults, p6: DWORD): DWORD{.stdcall,
    dynlib: "gdi32", importc: "GetCharacterPlacementA".}
proc GetCharacterPlacementA*(DC: HDC, p2: LPCSTR, p3, p4: WINBOOL,
                             p5: var TGCPResults, p6: DWORD): DWORD{.stdcall,
    dynlib: "gdi32", importc: "GetCharacterPlacementA".}
proc GetCharacterPlacementW*(DC: HDC, p2: LPWSTR, p3, p4: WINBOOL,
                             p5: var TGCPResults, p6: DWORD): DWORD{.stdcall,
    dynlib: "gdi32", importc: "GetCharacterPlacementW".}
proc GetCharWidth*(DC: HDC, p2, p3: UINT, Widths: pointer): WINBOOL{.stdcall,
    dynlib: "gdi32", importc: "GetCharWidthA".}
proc GetCharWidth32*(DC: HDC, p2, p3: UINT, Widths: pointer): WINBOOL{.stdcall,
    dynlib: "gdi32", importc: "GetCharWidth32A".}
proc GetCharWidth32A*(DC: HDC, p2, p3: UINT, Widths: pointer): WINBOOL{.stdcall,
    dynlib: "gdi32", importc: "GetCharWidth32A".}
proc GetCharWidth32W*(DC: HDC, p2, p3: UINT, Widths: pointer): WINBOOL{.stdcall,
    dynlib: "gdi32", importc: "GetCharWidth32W".}
proc GetCharWidthA*(DC: HDC, p2, p3: UINT, Widths: pointer): WINBOOL{.stdcall,
    dynlib: "gdi32", importc: "GetCharWidthA".}
proc GetCharWidthFloat*(DC: HDC, p2, p3: UINT, Widths: pointer): WINBOOL{.
    stdcall, dynlib: "gdi32", importc: "GetCharWidthFloatA".}
proc GetCharWidthFloatA*(DC: HDC, p2, p3: UINT, Widths: pointer): WINBOOL{.
    stdcall, dynlib: "gdi32", importc: "GetCharWidthFloatA".}
proc GetCharWidthFloatW*(DC: HDC, p2, p3: UINT, Widths: pointer): WINBOOL{.
    stdcall, dynlib: "gdi32", importc: "GetCharWidthFloatW".}
  #function GetCharWidthI(DC: HDC; p2, p3: UINT; p4: PWORD; const Widths:pointer): WINBOOL;stdcall; external 'gdi32' name 'GetCharWidthI';
proc GetCharWidthW*(DC: HDC, p2, p3: UINT, Widths: pointer): WINBOOL{.stdcall,
    dynlib: "gdi32", importc: "GetCharWidthW".}
proc GetClassInfo*(hInstance: HINST, lpClassName: cstring,
                   lpWndClass: var TWndClass): WINBOOL{.stdcall,
    dynlib: "user32", importc: "GetClassInfoA".}
proc GetClassInfoA*(hInstance: HINST, lpClassName: LPCSTR,
                    lpWndClass: var TWndClassA): WINBOOL{.stdcall,
    dynlib: "user32", importc: "GetClassInfoA".}
proc GetClassInfoEx*(Instance: HINST, Classname: cstring,
                     WndClass: var TWndClassEx): WINBOOL{.stdcall,
    dynlib: "user32", importc: "GetClassInfoExA".}
  #function GetClassInfoExA(Instance: HINST; Classname: LPCSTR; var WndClass: TWndClassExA): WINBOOL; stdcall; external 'user32' name 'GetClassInfoExA';
  #function GetClassInfoExW(Instance: HINST; Classname: LPWSTR; var WndClass: TWndClassExW): WINBOOL; stdcall; external 'user32' name 'GetClassInfoExW';
  #function GetClassInfoW(hInstance: HINST; lpClassName: LPWSTR; var lpWndClass: TWndClassW): WINBOOL; stdcall; external 'user32' name 'GetClassInfoW';
proc GetClientRect*(wnd: HWND, lpRect: var TRect): WINBOOL{.stdcall,
    dynlib: "user32", importc: "GetClientRect".}
proc GetClipBox*(DC: HDC, Rect: var TRect): int{.stdcall, dynlib: "gdi32",
    importc: "GetClipBox".}
proc GetClipCursor*(lpRect: var TRect): WINBOOL{.stdcall, dynlib: "user32",
    importc: "GetClipCursor".}
proc GetColorAdjustment*(DC: HDC, p2: var TColorAdjustment): WINBOOL{.stdcall,
    dynlib: "gdi32", importc: "GetColorAdjustment".}
proc GetCommConfig*(hCommDev: THandle, lpCC: var TCommConfig,
                    lpdwSize: var DWORD): WINBOOL{.stdcall, dynlib: "kernel32",
    importc: "GetCommConfig".}
proc GetCommMask*(hFile: THandle, lpEvtMask: var DWORD): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "GetCommMask".}
proc GetCommModemStatus*(hFile: THandle, lpModemStat: var DWORD): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "GetCommModemStatus".}
proc GetCommProperties*(hFile: THandle, lpCommProp: var TCommProp): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "GetCommProperties".}
proc GetCommState*(hFile: THandle, lpDCB: var TDCB): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "GetCommState".}
proc GetCommTimeouts*(hFile: THandle, lpCommTimeouts: var TCommTimeouts): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "GetCommTimeouts".}
proc GetComputerName*(lpBuffer: cstring, nSize: var DWORD): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "GetComputerNameA".}
proc GetComputerNameA*(lpBuffer: LPCSTR, nSize: var DWORD): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "GetComputerNameA".}
proc GetComputerNameW*(lpBuffer: LPWSTR, nSize: var DWORD): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "GetComputerNameW".}
proc GetConsoleCursorInfo*(hConsoleOutput: THandle,
                           lpConsoleCursorInfo: var TConsoleCursorInfo): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "GetConsoleCursorInfo".}
proc GetConsoleMode*(hConsoleHandle: THandle, lpMode: var DWORD): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "GetConsoleMode".}
proc GetConsoleScreenBufferInfo*(hConsoleOutput: THandle,
    lpConsoleScreenBufferInfo: var TConsoleScreenBufferInfo): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "GetConsoleScreenBufferInfo".}
proc GetCPInfo*(CodePage: UINT, lpCPInfo: var TCPInfo): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "GetCPInfo".}
  #function GetCurrentHwProfile(var lpHwProfileInfo: THWProfileInfo): WINBOOL;stdcall; external 'advapi32' name 'GetCurrentHwProfileA';
  #function GetCurrentHwProfileA(var lpHwProfileInfo: THWProfileInfoA): WINBOOL;stdcall; external 'advapi32' name 'GetCurrentHwProfileA';
  #function GetCurrentHwProfileW(var lpHwProfileInfo: THWProfileInfoW): WINBOOL;stdcall; external 'advapi32' name 'GetCurrentHwProfileW';
proc GetCursorInfo*(pci: var TCursorInfo): WINBOOL{.stdcall, dynlib: "user32",
    importc: "GetCursorInfo".}
proc GetCursorPos*(lpPoint: var TPoint): WINBOOL{.stdcall, dynlib: "user32",
    importc: "GetCursorPos".}
proc GetDCOrgEx*(DC: HDC, Origin: var TPoint): WINBOOL{.stdcall,
    dynlib: "gdi32", importc: "GetDCOrgEx".}
proc GetDefaultCommConfig*(lpszName: cstring, lpCC: var TCommConfig,
                           lpdwSize: var DWORD): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "GetDefaultCommConfigA".}
proc GetDefaultCommConfigA*(lpszName: LPCSTR, lpCC: var TCommConfig,
                            lpdwSize: var DWORD): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "GetDefaultCommConfigA".}
proc GetDefaultCommConfigW*(lpszName: LPWSTR, lpCC: var TCommConfig,
                            lpdwSize: var DWORD): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "GetDefaultCommConfigW".}
proc GetDIBColorTable*(DC: HDC, p2, p3: UINT, RGBQuadStructs: pointer): UINT{.
    stdcall, dynlib: "gdi32", importc: "GetDIBColorTable".}
proc GetDIBits*(DC: HDC, Bitmap: HBitmap, StartScan, NumScans: UINT,
                Bits: Pointer, BitInfo: var TBitmapInfo, Usage: UINT): int{.
    stdcall, dynlib: "gdi32", importc: "GetDIBits".}
proc GetDiskFreeSpace*(lpRootPathName: cstring, lpSectorsPerCluster,
    lpBytesPerSector, lpNumberOfFreeClusters, lpTotalNumberOfClusters: var DWORD): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "GetDiskFreeSpaceA".}
proc GetDiskFreeSpaceA*(lpRootPathName: LPCSTR, lpSectorsPerCluster,
    lpBytesPerSector, lpNumberOfFreeClusters, lpTotalNumberOfClusters: var DWORD): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "GetDiskFreeSpaceA".}
proc GetDiskFreeSpaceEx*(lpDirectoryName: cstring, lpFreeBytesAvailableToCaller,
    lpTotalNumberOfBytes: var TLargeInteger,
                         lpTotalNumberOfFreeBytes: PLargeInteger): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "GetDiskFreeSpaceExA".}
proc GetDiskFreeSpaceExA*(lpDirectoryName: LPCSTR, lpFreeBytesAvailableToCaller,
    lpTotalNumberOfBytes: var TLargeInteger,
                          lpTotalNumberOfFreeBytes: PLargeInteger): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "GetDiskFreeSpaceExA".}
proc GetDiskFreeSpaceExW*(lpDirectoryName: LPWSTR, lpFreeBytesAvailableToCaller,
    lpTotalNumberOfBytes: var TLargeInteger,
                          lpTotalNumberOfFreeBytes: PLargeInteger): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "GetDiskFreeSpaceExW".}
proc GetDiskFreeSpaceW*(lpRootPathName: LPWSTR, lpSectorsPerCluster,
    lpBytesPerSector, lpNumberOfFreeClusters, lpTotalNumberOfClusters: var DWORD): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "GetDiskFreeSpaceW".}
proc GetDiskFreeSpaceEx*(lpDirectoryName: cstring, lpFreeBytesAvailableToCaller,
    lpTotalNumberOfBytes: pLargeInteger, lpTotalNumberOfFreeBytes: PLargeInteger): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "GetDiskFreeSpaceExA".}
proc GetDiskFreeSpaceExA*(lpDirectoryName: LPCSTR, lpFreeBytesAvailableToCaller,
    lpTotalNumberOfBytes: pLargeInteger, lpTotalNumberOfFreeBytes: PLargeInteger): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "GetDiskFreeSpaceExA".}
proc GetDiskFreeSpaceExW*(lpDirectoryName: LPWSTR, lpFreeBytesAvailableToCaller,
    lpTotalNumberOfBytes: pLargeInteger, lpTotalNumberOfFreeBytes: PLargeInteger): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "GetDiskFreeSpaceExW".}
  #function GetEnhMetaFilePixelFormat(p1: HENHMETAFILE; p2: Cardinal; var p3: TPixelFormatDescriptor): UINT;stdcall; external 'gdi32' name 'GetEnhMetaFilePixelFormat';
proc GetExitCodeProcess*(hProcess: THandle, lpExitCode: var DWORD): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "GetExitCodeProcess".}
proc GetExitCodeThread*(hThread: THandle, lpExitCode: var DWORD): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "GetExitCodeThread".}
proc GetFileInformationByHandle*(hFile: THandle, lpFileInformation: var TByHandleFileInformation): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "GetFileInformationByHandle".}
  #function GetFileSecurity(lpFileName: PChar; RequestedInformation: SECURITY_INFORMATION; pSecurityDescriptor: PSecurityDescriptor; nLength: DWORD; var lpnLengthNeeded: DWORD): WINBOOL;stdcall; external 'advapi32' name 'GetFileSecurityA';
  #function GetFileSecurityA(lpFileName: LPCSTR; RequestedInformation: SECURITY_INFORMATION; pSecurityDescriptor: PSecurityDescriptor; nLength: DWORD; var lpnLengthNeeded: DWORD): WINBOOL; stdcall; external 'advapi32' name 'GetFileSecurityA';
  #function GetFileSecurityW(lpFileName: LPWSTR; RequestedInformation: SECURITY_INFORMATION; pSecurityDescriptor: PSecurityDescriptor; nLength: DWORD; var lpnLengthNeeded: DWORD): WINBOOL; stdcall; external 'advapi32' name 'GetFileSecurityW';
proc GetFileVersionInfoSize*(lptstrFilename: cstring, lpdwHandle: var DWORD): DWORD{.
    stdcall, dynlib: "version", importc: "GetFileVersionInfoSizeA".}
proc GetFileVersionInfoSizeA*(lptstrFilename: LPCSTR, lpdwHandle: var DWORD): DWORD{.
    stdcall, dynlib: "version", importc: "GetFileVersionInfoSizeA".}
proc GetFileVersionInfoSizeW*(lptstrFilename: LPWSTR, lpdwHandle: var DWORD): DWORD{.
    stdcall, dynlib: "version", importc: "GetFileVersionInfoSizeW".}
  # removed because old definition was wrong !
  # function GetFullPathName(lpFileName: PChar; nBufferLength: DWORD; lpBuffer: PChar; var lpFilePart: PChar): DWORD;stdcall; external 'kernel32' name 'GetFullPathNameA';
  # function GetFullPathNameA(lpFileName: LPCSTR; nBufferLength: DWORD; lpBuffer: LPCSTR; var lpFilePart: LPCSTR): DWORD; stdcall; external 'kernel32' name 'GetFullPathNameA';
  # function GetFullPathNameW(lpFileName: LPWSTR; nBufferLength: DWORD; lpBuffer: LPWSTR; var lpFilePart: LPWSTR): DWORD; stdcall; external 'kernel32' name 'GetFullPathNameW';
proc GetGlyphOutline*(DC: HDC, p2, p3: UINT, p4: TGlyphMetrics, p5: DWORD,
                      p6: Pointer, p7: TMat2): DWORD{.stdcall, dynlib: "gdi32",
    importc: "GetGlyphOutlineA".}
proc GetGlyphOutlineA*(DC: HDC, p2, p3: UINT, p4: TGlyphMetrics, p5: DWORD,
                       p6: Pointer, p7: TMat2): DWORD{.stdcall, dynlib: "gdi32",
    importc: "GetGlyphOutlineA".}
proc GetGlyphOutlineW*(DC: HDC, p2, p3: UINT, p4: TGlyphMetrics, p5: DWORD,
                       p6: Pointer, p7: TMat2): DWORD{.stdcall, dynlib: "gdi32",
    importc: "GetGlyphOutlineW".}
  #function GetGUIThreadInfo(idThread: DWORD; var pgui: TGUIThreadinfo): WINBOOL;stdcall; external 'user32' name 'GetGUIThreadInfo';
proc GetHandleInformation*(hObject: THandle, lpdwFlags: var DWORD): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "GetHandleInformation".}
  #function GetICMProfile(DC: HDC; var Size: DWORD; Name: PChar): WINBOOL;stdcall; external 'gdi32' name 'GetICMProfileA';
  #function GetICMProfileA(DC: HDC; var Size: DWORD; Name: LPCSTR): WINBOOL; stdcall; external 'gdi32' name 'GetICMProfileA';
  #function GetICMProfileW(DC: HDC; var Size: DWORD; Name: LPWSTR): WINBOOL; stdcall; external 'gdi32' name 'GetICMProfileW';
proc GetIconInfo*(icon: HICON, piconinfo: var TIconInfo): WINBOOL{.stdcall,
    dynlib: "user32", importc: "GetIconInfo".}
  #function GetKernelObjectSecurity(Handle: THandle; RequestedInformation: SECURITY_INFORMATION; pSecurityDescriptor: PSecurityDescriptor; nLength: DWORD; var lpnLengthNeeded: DWORD): WINBOOL; stdcall; external 'advapi32' name 'GetKernelObjectSecurity';
proc GetKerningPairs*(DC: HDC, Count: DWORD, KerningPairs: pointer): DWORD{.
    stdcall, dynlib: "gdi32", importc: "GetKerningPairs".}
proc GetKeyboardLayoutList*(nBuff: int, List: pointer): UINT{.stdcall,
    dynlib: "user32", importc: "GetKeyboardLayoutList".}
  #function GetKeyboardState(var KeyState: TKeyboardState): WINBOOL; stdcall; external 'user32' name 'GetKeyboardState';
  #function GetLastInputInfo(var plii: TLastInputInfo): WINBOOL;stdcall; external 'user32' name 'GetLastInputInfo';
proc GetSystemTime*(lpSystemTime: var SYSTEMTIME){.stdcall, dynlib: "kernel32",
    importc: "GetSystemTime".}
proc GetLocalTime*(SystemTime: var SYSTEMTIME){.stdcall, dynlib: "kernel32",
    importc: "GetLocalTime".}
proc GetSystemInfo*(SystemInfo: var SYSTEM_INFO){.stdcall, dynlib: "kernel32",
    importc: "GetSystemInfo".}
proc SetSystemTime*(lpSystemTime: var SYSTEMTIME): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "SetSystemTime".}
proc SetLocalTime*(lpSystemTime: var SYSTEMTIME): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "SetLocalTime".}
proc GetLogColorSpace*(p1: HCOLORSPACE, ColorSpace: var TLogColorSpace,
                       Size: DWORD): WINBOOL{.stdcall, dynlib: "gdi32",
    importc: "GetLogColorSpaceA".}
proc GetLogColorSpaceA*(p1: HCOLORSPACE, ColorSpace: var TLogColorSpaceA,
                        Size: DWORD): WINBOOL{.stdcall, dynlib: "gdi32",
    importc: "GetLogColorSpaceA".}
  #function GetLogColorSpaceW(p1: HCOLORSPACE; var ColorSpace: TLogColorSpaceW; Size: DWORD): WINBOOL; stdcall; external 'gdi32' name 'GetLogColorSpaceW';
proc GetMailslotInfo*(hMailslot: THandle, lpMaxMessageSize: Pointer,
                      lpNextSize: var DWORD,
                      lpMessageCount, lpReadTimeout: Pointer): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "GetMailslotInfo".}
  #function GetMenuBarInfo(hend: HWND; idObject, idItem: Longint; var pmbi: TMenuBarInfo): WINBOOL;stdcall; external 'user32' name 'GetMenuBarInfo';
  #function GetMenuInfo(menu: HMENU; var lpmi: TMenuInfo): WINBOOL;stdcall; external 'user32' name 'GetMenuInfo';
proc GetMenuItemInfo*(p1: HMENU, p2: UINT, p3: WINBOOL, p4: var TMenuItemInfo): WINBOOL{.
    stdcall, dynlib: "user32", importc: "GetMenuItemInfoA".}
proc GetMenuItemInfoA*(p1: HMENU, p2: UINT, p3: WINBOOL, p4: var TMenuItemInfoA): WINBOOL{.
    stdcall, dynlib: "user32", importc: "GetMenuItemInfoA".}
  #function GetMenuItemInfoW(p1: HMENU; p2: UINT; p3: WINBOOL; var p4: TMenuItemInfoW): WINBOOL; stdcall; external 'user32' name 'GetMenuItemInfoW';
proc GetMenuItemRect*(wnd: HWND, menu: HMENU, uItem: UINT, lprcItem: var TRect): WINBOOL{.
    stdcall, dynlib: "user32", importc: "GetMenuItemRect".}
proc GetMessage*(lpMsg: var TMsg, wnd: HWND, wMsgFilterMin, wMsgFilterMax: UINT): WINBOOL{.
    stdcall, dynlib: "user32", importc: "GetMessageA".}
proc GetMessageA*(lpMsg: var TMsg, wnd: HWND,
                  wMsgFilterMin, wMsgFilterMax: UINT): WINBOOL{.stdcall,
    dynlib: "user32", importc: "GetMessageA".}
proc GetMessageW*(lpMsg: var TMsg, wnd: HWND,
                  wMsgFilterMin, wMsgFilterMax: UINT): WINBOOL{.stdcall,
    dynlib: "user32", importc: "GetMessageW".}
proc GetMiterLimit*(DC: HDC, Limit: var float32): WINBOOL{.stdcall,
    dynlib: "gdi32", importc: "GetMiterLimit".}
  #function GetMouseMovePoints(cbSize: UINT; var lppt, lpptBuf: TMouseMovePoint; nBufPoints: Integer; resolution: DWORD): Integer;stdcall; external 'user32' name 'GetMouseMovePoints';
proc GetNamedPipeInfo*(hNamedPipe: THandle, lpFlags: var DWORD,
                       lpOutBufferSize, lpInBufferSize, lpMaxInstances: Pointer): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "GetNamedPipeInfo".}
proc GetNumberOfConsoleInputEvents*(hConsoleInput: THandle,
                                    lpNumberOfEvents: var DWORD): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "GetNumberOfConsoleInputEvents".}
proc GetNumberOfConsoleMouseButtons*(lpNumberOfMouseButtons: var DWORD): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "GetNumberOfConsoleMouseButtons".}
  #function GetNumberOfEventLogRecords(hEventLog: THandle; var NumberOfRecords: DWORD): WINBOOL; stdcall; external 'advapi32' name 'GetNumberOfEventLogRecords';
  #function GetOldestEventLogRecord(hEventLog: THandle; var OldestRecord: DWORD): WINBOOL; stdcall; external 'advapi32' name 'GetOldestEventLogRecord';
proc GetOverlappedResult*(hFile: THandle, lpOverlapped: TOverlapped,
                          lpNumberOfBytesTransferred: var DWORD, bWait: WINBOOL): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "GetOverlappedResult".}
proc GetPaletteEntries*(Palette: HPALETTE, StartIndex, NumEntries: UINT,
                        PaletteEntries: pointer): UINT{.stdcall,
    dynlib: "gdi32", importc: "GetPaletteEntries".}
proc GetPath*(DC: HDC, Points, Types: pointer, nSize: int): int{.stdcall,
    dynlib: "gdi32", importc: "GetPath".}
proc GetPriorityClipboardFormat*(paFormatPriorityList: pointer, cFormats: int): int{.
    stdcall, dynlib: "user32", importc: "GetPriorityClipboardFormat".}
  #function GetPrivateObjectSecurity(ObjectDescriptor: PSecurityDescriptor; SecurityInformation: SECURITY_INFORMATION; ResultantDescriptor: PSecurityDescriptor; DescriptorLength: DWORD; var ReturnLength: DWORD): WINBOOL;
  #  stdcall; external 'advapi32' name 'GetPrivateObjectSecurity';
proc GetPrivateProfileSectionNamesA*(lpszReturnBuffer: LPSTR, nSize: DWORD,
                                     lpFileName: LPCSTR): DWORD{.stdcall,
    dynlib: "kernel32", importc: "GetPrivateProfileSectionNamesA".}
proc GetPrivateProfileSectionNamesW*(lpszReturnBuffer: LPWSTR, nSize: DWORD,
                                     lpFileName: LPCWSTR): DWORD{.stdcall,
    dynlib: "kernel32", importc: "GetPrivateProfileSectionNamesW".}
proc GetPrivateProfileSectionNames*(lpszReturnBuffer: LPTSTR, nSize: DWORD,
                                    lpFileName: LPCTSTR): DWORD{.stdcall,
    dynlib: "kernel32", importc: "GetPrivateProfileSectionNamesA".}
proc GetPrivateProfileStructA*(lpszSection, lpszKey: LPCSTR, lpStruct: LPVOID,
                               uSizeStruct: UINT, szFile: LPCSTR): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "GetPrivateProfileStructA".}
proc GetPrivateProfileStructW*(lpszSection, lpszKey: LPCWSTR, lpStruct: LPVOID,
                               uSizeStruct: UINT, szFile: LPCWSTR): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "GetPrivateProfileStructW".}
proc GetPrivateProfileStruct*(lpszSection, lpszKey: LPCTSTR, lpStruct: LPVOID,
                              uSizeStruct: UINT, szFile: LPCTSTR): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "GetPrivateProfileStructA".}
proc GetProcessAffinityMask*(hProcess: THandle, lpProcessAffinityMask,
    lpSystemAffinityMask: var DWORD): WINBOOL{.stdcall, dynlib: "kernel32",
    importc: "GetProcessAffinityMask".}
proc GetProcessHeaps*(NumberOfHeaps: DWORD, ProcessHeaps: var THandle): DWORD{.
    stdcall, dynlib: "kernel32", importc: "GetProcessHeaps".}
proc GetProcessPriorityBoost*(hThread: THandle,
                              DisablePriorityBoost: var WINBOOL): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "GetProcessPriorityBoost".}
proc GetProcessShutdownParameters*(lpdwLevel, lpdwFlags: var DWORD): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "GetProcessShutdownParameters".}
proc GetProcessTimes*(hProcess: THandle, lpCreationTime, lpExitTime,
    lpKernelTime, lpUserTime: var TFileTime): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "GetProcessTimes".}
proc GetProcessWorkingSetSize*(hProcess: THandle, lpMinimumWorkingSetSize,
    lpMaximumWorkingSetSize: var DWORD): WINBOOL{.stdcall, dynlib: "kernel32",
    importc: "GetProcessWorkingSetSize".}
proc GetQueuedCompletionStatus*(CompletionPort: THandle,
    lpNumberOfBytesTransferred, lpCompletionKey: var DWORD,
                                lpOverlapped: var POverlapped,
                                dwMilliseconds: DWORD): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "GetQueuedCompletionStatus".}
proc GetRasterizerCaps*(p1: var TRasterizerStatus, p2: UINT): WINBOOL{.stdcall,
    dynlib: "gdi32", importc: "GetRasterizerCaps".}
proc GetRgnBox*(RGN: HRGN, p2: var TRect): int{.stdcall, dynlib: "gdi32",
    importc: "GetRgnBox".}
proc GetScrollInfo*(wnd: HWND, BarFlag: int, ScrollInfo: var TScrollInfo): WINBOOL{.
    stdcall, dynlib: "user32", importc: "GetScrollInfo".}
proc GetScrollRange*(wnd: HWND, nBar: int, lpMinPos, lpMaxPos: var int): WINBOOL{.
    stdcall, dynlib: "user32", importc: "GetScrollRange".}
  #function GetSecurityDescriptorControl(pSecurityDescriptor: PSecurityDescriptor; var pControl: SECURITY_DESCRIPTOR_CONTROL; var lpdwRevision: DWORD): WINBOOL; stdcall; external 'advapi32' name 'GetSecurityDescriptorControl';
  #function GetSecurityDescriptorDacl(pSecurityDescriptor: PSecurityDescriptor; var lpbDaclPresent: WINBOOL; var pDacl: PACL; var lpbDaclDefaulted: WINBOOL): WINBOOL; stdcall; external 'advapi32' name 'GetSecurityDescriptorDacl';
  #function GetSecurityDescriptorGroup(pSecurityDescriptor: PSecurityDescriptor; var pGroup: PSID; var lpbGroupDefaulted: WINBOOL): WINBOOL; stdcall; external 'advapi32' name 'GetSecurityDescriptorGroup';
  #function GetSecurityDescriptorOwner(pSecurityDescriptor: PSecurityDescriptor; var pOwner: PSID; var lpbOwnerDefaulted: WINBOOL): WINBOOL; stdcall; external 'advapi32' name 'GetSecurityDescriptorOwner';
  #function GetSecurityDescriptorSacl(pSecurityDescriptor: PSecurityDescriptor; var lpbSaclPresent: WINBOOL; var pSacl: PACL; var lpbSaclDefaulted: WINBOOL): WINBOOL; stdcall; external 'advapi32' name 'GetSecurityDescriptorSacl';
proc GetStartupInfo*(lpStartupInfo: var TSTARTUPINFO){.stdcall,
    dynlib: "kernel32", importc: "GetStartupInfoA".}
proc GetStringTypeA*(Locale: LCID, dwInfoType: DWORD, lpSrcStr: LPCSTR,
                     cchSrc: WINBOOL, lpCharType: var int16): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "GetStringTypeA".}
proc GetStringTypeEx*(Locale: LCID, dwInfoType: DWORD, lpSrcStr: cstring,
                      cchSrc: int, lpCharType: var int16): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "GetStringTypeExA".}
proc GetStringTypeExA*(Locale: LCID, dwInfoType: DWORD, lpSrcStr: LPCSTR,
                       cchSrc: int, lpCharType: var int16): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "GetStringTypeExA".}
proc GetStringTypeExW*(Locale: LCID, dwInfoType: DWORD, lpSrcStr: LPWSTR,
                       cchSrc: int, lpCharType: var int16): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "GetStringTypeExW".}
proc GetStringTypeW*(dwInfoType: DWORD, lpSrcStr: WCHAR, cchSrc: WINBOOL,
                     lpCharType: var int16): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "GetStringTypeW".}
proc GetSystemPaletteEntries*(DC: HDC, StartIndex, NumEntries: UINT,
                              PaletteEntries: pointer): UINT{.stdcall,
    dynlib: "gdi32", importc: "GetSystemPaletteEntries".}
proc GetSystemPowerStatus*(lpSystemPowerStatus: var TSystemPowerStatus): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "GetSystemPowerStatus".}
proc GetSystemTimeAdjustment*(lpTimeAdjustment, lpTimeIncrement: var DWORD,
                              lpTimeAdjustmentDisabled: var WINBOOL): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "GetSystemTimeAdjustment".}
proc GetSystemTimeAsFileTime*(lpSystemTimeAsFileTime: var TFILETIME){.stdcall,
    dynlib: "kernel32", importc: "GetSystemTimeAsFileTime".}
proc GetTabbedTextExtent*(hDC: HDC, lpString: cstring,
                          nCount, nTabPositions: int,
                          lpnTabStopPositions: pointer): DWORD{.stdcall,
    dynlib: "user32", importc: "GetTabbedTextExtentA".}
proc GetTabbedTextExtentA*(hDC: HDC, lpString: LPCSTR,
                           nCount, nTabPositions: int,
                           lpnTabStopPositions: pointer): DWORD{.stdcall,
    dynlib: "user32", importc: "GetTabbedTextExtentA".}
proc GetTabbedTextExtentW*(hDC: HDC, lpString: LPWSTR,
                           nCount, nTabPositions: int,
                           lpnTabStopPositions: pointer): DWORD{.stdcall,
    dynlib: "user32", importc: "GetTabbedTextExtentW".}
proc GetTapeParameters*(hDevice: THandle, dwOperation: DWORD,
                        lpdwSize: var DWORD, lpTapeInformation: Pointer): DWORD{.
    stdcall, dynlib: "kernel32", importc: "GetTapeParameters".}
proc GetTapePosition*(hDevice: THandle, dwPositionType: DWORD,
                      lpdwPartition, lpdwOffsetLow: var DWORD,
                      lpdwOffsetHigh: Pointer): DWORD{.stdcall,
    dynlib: "kernel32", importc: "GetTapePosition".}
proc GetTextExtentExPoint*(DC: HDC, p2: cstring, p3, p4: int, p5, p6: PInteger,
                           p7: var TSize): WINBOOL{.stdcall, dynlib: "gdi32",
    importc: "GetTextExtentExPointA".}
proc GetTextExtentExPointA*(DC: HDC, p2: LPCSTR, p3, p4: int, p5, p6: PInteger,
                            p7: var TSize): WINBOOL{.stdcall, dynlib: "gdi32",
    importc: "GetTextExtentExPointA".}
  #function GetTextExtentExPointI(DC: HDC; p2: PWORD; p3, p4: Integer; p5, p6: PINT; var p7: TSize): WINBOOL;stdcall; external 'gdi32' name 'GetTextExtentExPointI';
proc GetTextExtentExPointW*(DC: HDC, p2: LPWSTR, p3, p4: int, p5, p6: PInteger,
                            p7: var TSize): WINBOOL{.stdcall, dynlib: "gdi32",
    importc: "GetTextExtentExPointW".}
proc GetTextExtentPoint*(DC: HDC, Str: cstring, Count: int, Size: var TSize): WINBOOL{.
    stdcall, dynlib: "gdi32", importc: "GetTextExtentPointA".}
proc GetTextExtentPoint32*(DC: HDC, Str: cstring, Count: int, Size: var TSize): WINBOOL{.
    stdcall, dynlib: "gdi32", importc: "GetTextExtentPoint32A".}
proc GetTextExtentPoint32A*(DC: HDC, Str: LPCSTR, Count: int, Size: var TSize): WINBOOL{.
    stdcall, dynlib: "gdi32", importc: "GetTextExtentPoint32A".}
proc GetTextExtentPoint32W*(DC: HDC, Str: LPWSTR, Count: int, Size: var TSize): WINBOOL{.
    stdcall, dynlib: "gdi32", importc: "GetTextExtentPoint32W".}
proc GetTextExtentPointA*(DC: HDC, Str: LPCSTR, Count: int, Size: var TSize): WINBOOL{.
    stdcall, dynlib: "gdi32", importc: "GetTextExtentPointA".}
  #function GetTextExtentPointI(DC: HDC; p2: PWORD; p3: Integer; var p4: TSize): WINBOOL;stdcall; external 'gdi32' name 'GetTextExtentPointI';
proc GetTextExtentPointW*(DC: HDC, Str: LPWSTR, Count: int, Size: var TSize): WINBOOL{.
    stdcall, dynlib: "gdi32", importc: "GetTextExtentPointW".}
proc GetTextMetrics*(DC: HDC, TM: var TTextMetric): WINBOOL{.stdcall,
    dynlib: "gdi32", importc: "GetTextMetricsA".}
  #function GetTextMetricsA(DC: HDC; var TM: TTextMetricA): WINBOOL; stdcall; external 'gdi32' name 'GetTextMetricsA';
  #function GetTextMetricsW(DC: HDC; var TM: TTextMetricW): WINBOOL; stdcall; external 'gdi32' name 'GetTextMetricsW';
proc GetThreadContext*(hThread: THandle, lpContext: var TContext): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "GetThreadContext".}
proc GetThreadPriorityBoost*(hThread: THandle, DisablePriorityBoost: var WINBOOL): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "GetThreadPriorityBoost".}
proc GetThreadSelectorEntry*(hThread: THandle, dwSelector: DWORD,
                             lpSelectorEntry: var TLDTEntry): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "GetThreadSelectorEntry".}
proc GetThreadTimes*(hThread: THandle, lpCreationTime, lpExitTime, lpKernelTime,
                                       lpUserTime: var TFileTime): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "GetThreadTimes".}
proc GetTimeZoneInformation*(lpTimeZoneInformation: var TTimeZoneInformation): DWORD{.
    stdcall, dynlib: "kernel32", importc: "GetTimeZoneInformation".}
  #function GetTitleBarInfo(wnd: HWND; var pti: TTitleBarInfo): WINBOOL;stdcall; external 'user32' name 'GetTitleBarInfo';
  #function GetTokenInformation(TokenHandle: THandle; TokenInformationClass: TTokenInformationClass; TokenInformation: Pointer; TokenInformationLength: DWORD; var ReturnLength: DWORD): WINBOOL; stdcall; external 'advapi32' name 'GetTokenInformation';
proc GetUpdateRect*(wnd: HWND, lpRect: var TRect, bErase: WINBOOL): WINBOOL{.
    stdcall, dynlib: "user32", importc: "GetUpdateRect".}
proc GetUserName*(lpBuffer: cstring, nSize: var DWORD): WINBOOL{.stdcall,
    dynlib: "advapi32", importc: "GetUserNameA".}
proc GetUserNameA*(lpBuffer: LPCSTR, nSize: var DWORD): WINBOOL{.stdcall,
    dynlib: "advapi32", importc: "GetUserNameA".}
proc GetUserNameW*(lpBuffer: LPWSTR, nSize: var DWORD): WINBOOL{.stdcall,
    dynlib: "advapi32", importc: "GetUserNameW".}
proc GetUserObjectInformation*(hObj: THandle, nIndex: int, pvInfo: Pointer,
                               nLength: DWORD, lpnLengthNeeded: var DWORD): WINBOOL{.
    stdcall, dynlib: "user32", importc: "GetUserObjectInformationA".}
proc GetUserObjectInformationA*(hObj: THandle, nIndex: int, pvInfo: Pointer,
                                nLength: DWORD, lpnLengthNeeded: var DWORD): WINBOOL{.
    stdcall, dynlib: "user32", importc: "GetUserObjectInformationA".}
proc GetUserObjectInformationW*(hObj: THandle, nIndex: int, pvInfo: Pointer,
                                nLength: DWORD, lpnLengthNeeded: var DWORD): WINBOOL{.
    stdcall, dynlib: "user32", importc: "GetUserObjectInformationW".}
proc GetUserObjectSecurity*(hObj: THandle, pSIRequested: var DWORD,
                            pSID: PSecurityDescriptor, nLength: DWORD,
                            lpnLengthNeeded: var DWORD): WINBOOL{.stdcall,
    dynlib: "user32", importc: "GetUserObjectSecurity".}
proc GetVersionEx*(lpVersionInformation: var TOSVersionInfo): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "GetVersionExA".}
proc GetVersionExA*(lpVersionInformation: var TOSVersionInfo): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "GetVersionExA".}
proc GetVersionExW*(lpVersionInformation: var TOSVersionInfoW): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "GetVersionExW".}
proc GetViewportExtEx*(DC: HDC, Size: var TSize): WINBOOL{.stdcall,
    dynlib: "gdi32", importc: "GetViewportExtEx".}
proc GetViewportOrgEx*(DC: HDC, Point: var TPoint): WINBOOL{.stdcall,
    dynlib: "gdi32", importc: "GetViewportOrgEx".}
proc GetVolumeInformation*(lpRootPathName: cstring, lpVolumeNameBuffer: cstring,
                           nVolumeNameSize: DWORD, lpVolumeSerialNumber: PDWORD,
    lpMaximumComponentLength, lpFileSystemFlags: var DWORD,
                           lpFileSystemNameBuffer: cstring,
                           nFileSystemNameSize: DWORD): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "GetVolumeInformationA".}
proc GetVolumeInformationA*(lpRootPathName: LPCSTR, lpVolumeNameBuffer: LPCSTR,
                            nVolumeNameSize: DWORD,
                            lpVolumeSerialNumber: PDWORD,
    lpMaximumComponentLength, lpFileSystemFlags: var DWORD,
                            lpFileSystemNameBuffer: LPCSTR,
                            nFileSystemNameSize: DWORD): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "GetVolumeInformationA".}
proc GetVolumeInformationW*(lpRootPathName: LPWSTR, lpVolumeNameBuffer: LPWSTR,
                            nVolumeNameSize: DWORD,
                            lpVolumeSerialNumber: PDWORD,
    lpMaximumComponentLength, lpFileSystemFlags: var DWORD,
                            lpFileSystemNameBuffer: LPWSTR,
                            nFileSystemNameSize: DWORD): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "GetVolumeInformationW".}
proc GetWindowExtEx*(DC: HDC, Size: var TSize): WINBOOL{.stdcall,
    dynlib: "gdi32", importc: "GetWindowExtEx".}
  #function GetWindowInfo(wnd: HWND; var pwi: TWindowInfo): WINBOOL;stdcall; external 'user32' name 'GetWindowInfo';
proc GetWindowOrgEx*(DC: HDC, Point: var TPoint): WINBOOL{.stdcall,
    dynlib: "gdi32", importc: "GetWindowOrgEx".}
proc GetWindowRect*(wnd: HWND, lpRect: var TRect): WINBOOL{.stdcall,
    dynlib: "user32", importc: "GetWindowRect".}
proc GetWorldTransform*(DC: HDC, p2: var TXForm): WINBOOL{.stdcall,
    dynlib: "gdi32", importc: "GetWorldTransform".}
  #function GradientFill(DC: HDC; var p2: TTriVertex; p3: ULONG; p4: Pointer; p5, p6: ULONG): WINBOOL;stdcall; external 'gdi32' name 'GradientFill';
proc GlobalMemoryStatus*(Buffer: var MEMORYSTATUS){.stdcall, dynlib: "kernel32",
    importc: "GlobalMemoryStatus".}
proc HeapWalk*(hHeap: THandle, lpEntry: var TProcessHeapEntry): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "HeapWalk".}
proc ImageList_GetDragImage*(ppt: var POINT, pptHotspot: var POINT): HIMAGELIST{.
    stdcall, dynlib: "comctl32", importc: "ImageList_GetDragImage".}
proc InflateRect*(lprc: var TRect, dx, dy: int): WINBOOL{.stdcall,
    dynlib: "user32", importc: "InflateRect".}
proc InitializeAcl*(pAcl: var TACL, nAclLength, dwAclRevision: DWORD): WINBOOL{.
    stdcall, dynlib: "advapi32", importc: "InitializeAcl".}
proc InitializeSid*(Sid: Pointer, pIdentifierAuthority: TSIDIdentifierAuthority,
                    nSubAuthorityCount: int8): WINBOOL{.stdcall,
    dynlib: "advapi32", importc: "InitializeSid".}
proc InsertMenuItemA*(p1: HMENU, p2: UINT, p3: WINBOOL, p4: TMenuItemInfoA): WINBOOL{.
    stdcall, dynlib: "user32", importc: "InsertMenuItemA".}
  #function InsertMenuItemW(p1: HMENU; p2: UINT; p3: WINBOOL; const p4: TMenuItemInfoW): WINBOOL; stdcall; external 'user32' name 'InsertMenuItemW';
proc IntersectRect*(lprcDst: var TRect, lprcSrc1, lprcSrc2: TRect): WINBOOL{.
    stdcall, dynlib: "user32", importc: "IntersectRect".}
  #function InvertRect(hDC: HDC; const lprc: TRect): WINBOOL; stdcall; external 'user32' name 'InvertRect';
proc IsDialogMessage*(hDlg: HWND, lpMsg: var TMsg): WINBOOL{.stdcall,
    dynlib: "user32", importc: "IsDialogMessageA".}
proc IsDialogMessageA*(hDlg: HWND, lpMsg: var TMsg): WINBOOL{.stdcall,
    dynlib: "user32", importc: "IsDialogMessageA".}
proc IsDialogMessageW*(hDlg: HWND, lpMsg: var TMsg): WINBOOL{.stdcall,
    dynlib: "user32", importc: "IsDialogMessageW".}
  #function IsRectEmpty(const lprc: TRect): WINBOOL; stdcall; external 'user32' name 'IsRectEmpty';
proc IsValidAcl*(pAcl: TACL): WINBOOL{.stdcall, dynlib: "advapi32",
                                       importc: "IsValidAcl".}
proc LocalFileTimeToFileTime*(lpLocalFileTime: TFileTime,
                              lpFileTime: var TFileTime): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "LocalFileTimeToFileTime".}
proc LockFileEx*(hFile: THandle, dwFlags, dwReserved: DWORD,
                 nNumberOfBytesToLockLow, nNumberOfBytesToLockHigh: DWORD,
                 lpOverlapped: TOverlapped): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "LockFileEx".}
proc LogonUser*(lpszUsername, lpszDomain, lpszPassword: cstring,
                dwLogonType, dwLogonProvider: DWORD, phToken: var THandle): WINBOOL{.
    stdcall, dynlib: "advapi32", importc: "LogonUserA".}
proc LogonUserA*(lpszUsername, lpszDomain, lpszPassword: LPCSTR,
                 dwLogonType, dwLogonProvider: DWORD, phToken: var THandle): WINBOOL{.
    stdcall, dynlib: "advapi32", importc: "LogonUserA".}
proc LogonUserW*(lpszUsername, lpszDomain, lpszPassword: LPWSTR,
                 dwLogonType, dwLogonProvider: DWORD, phToken: var THandle): WINBOOL{.
    stdcall, dynlib: "advapi32", importc: "LogonUserW".}
proc LookupAccountName*(lpSystemName, lpAccountName: cstring, Sid: PSID,
                        cbSid: var DWORD, ReferencedDomainName: cstring,
                        cbReferencedDomainName: var DWORD,
                        peUse: var SID_NAME_USE): WINBOOL{.stdcall,
    dynlib: "advapi32", importc: "LookupAccountNameA".}
proc LookupAccountNameA*(lpSystemName, lpAccountName: LPCSTR, Sid: PSID,
                         cbSid: var DWORD, ReferencedDomainName: LPCSTR,
                         cbReferencedDomainName: var DWORD,
                         peUse: var SID_NAME_USE): WINBOOL{.stdcall,
    dynlib: "advapi32", importc: "LookupAccountNameA".}
proc LookupAccountNameW*(lpSystemName, lpAccountName: LPWSTR, Sid: PSID,
                         cbSid: var DWORD, ReferencedDomainName: LPWSTR,
                         cbReferencedDomainName: var DWORD,
                         peUse: var SID_NAME_USE): WINBOOL{.stdcall,
    dynlib: "advapi32", importc: "LookupAccountNameW".}
proc LookupAccountSid*(lpSystemName: cstring, Sid: PSID, Name: cstring,
                       cbName: var DWORD, ReferencedDomainName: cstring,
                       cbReferencedDomainName: var DWORD,
                       peUse: var SID_NAME_USE): WINBOOL{.stdcall,
    dynlib: "advapi32", importc: "LookupAccountSidA".}
proc LookupAccountSidA*(lpSystemName: LPCSTR, Sid: PSID, Name: LPCSTR,
                        cbName: var DWORD, ReferencedDomainName: LPCSTR,
                        cbReferencedDomainName: var DWORD,
                        peUse: var SID_NAME_USE): WINBOOL{.stdcall,
    dynlib: "advapi32", importc: "LookupAccountSidA".}
proc LookupAccountSidW*(lpSystemName: LPWSTR, Sid: PSID, Name: LPWSTR,
                        cbName: var DWORD, ReferencedDomainName: LPWSTR,
                        cbReferencedDomainName: var DWORD,
                        peUse: var SID_NAME_USE): WINBOOL{.stdcall,
    dynlib: "advapi32", importc: "LookupAccountSidW".}
proc LookupPrivilegeDisplayName*(lpSystemName, lpName: LPCSTR,
                                 lpDisplayName: cstring,
                                 cbDisplayName, lpLanguageId: var DWORD): WINBOOL{.
    stdcall, dynlib: "advapi32", importc: "LookupPrivilegeDisplayNameA".}
proc LookupPrivilegeDisplayNameA*(lpSystemName, lpName: LPCSTR,
                                  lpDisplayName: LPCSTR,
                                  cbDisplayName, lpLanguageId: var DWORD): WINBOOL{.
    stdcall, dynlib: "advapi32", importc: "LookupPrivilegeDisplayNameA".}
proc LookupPrivilegeDisplayNameW*(lpSystemName, lpName: LPCSTR,
                                  lpDisplayName: LPWSTR,
                                  cbDisplayName, lpLanguageId: var DWORD): WINBOOL{.
    stdcall, dynlib: "advapi32", importc: "LookupPrivilegeDisplayNameW".}
proc LookupPrivilegeName*(lpSystemName: cstring, lpLuid: var TLargeInteger,
                          lpName: cstring, cbName: var DWORD): WINBOOL{.stdcall,
    dynlib: "advapi32", importc: "LookupPrivilegeNameA".}
proc LookupPrivilegeNameA*(lpSystemName: LPCSTR, lpLuid: var TLargeInteger,
                           lpName: LPCSTR, cbName: var DWORD): WINBOOL{.stdcall,
    dynlib: "advapi32", importc: "LookupPrivilegeNameA".}
proc LookupPrivilegeNameW*(lpSystemName: LPWSTR, lpLuid: var TLargeInteger,
                           lpName: LPWSTR, cbName: var DWORD): WINBOOL{.stdcall,
    dynlib: "advapi32", importc: "LookupPrivilegeNameW".}
proc LookupPrivilegeValue*(lpSystemName, lpName: cstring,
                           lpLuid: var TLargeInteger): WINBOOL{.stdcall,
    dynlib: "advapi32", importc: "LookupPrivilegeValueA".}
proc LookupPrivilegeValueA*(lpSystemName, lpName: LPCSTR,
                            lpLuid: var TLargeInteger): WINBOOL{.stdcall,
    dynlib: "advapi32", importc: "LookupPrivilegeValueA".}
proc LookupPrivilegeValueW*(lpSystemName, lpName: LPWSTR,
                            lpLuid: var TLargeInteger): WINBOOL{.stdcall,
    dynlib: "advapi32", importc: "LookupPrivilegeValueW".}
proc LPtoDP*(DC: HDC, Points: pointer, Count: int): WINBOOL{.stdcall,
    dynlib: "gdi32", importc: "LPtoDP".}
proc MakeAbsoluteSD*(pSelfRelativeSecurityDescriptor: PSecurityDescriptor,
                     pAbsoluteSecurityDescriptor: PSecurityDescriptor,
                     lpdwAbsoluteSecurityDescriptorSi: var DWORD,
                     pDacl: var TACL, lpdwDaclSize: var DWORD, pSacl: var TACL,

                     lpdwSaclSize: var DWORD, pOwner: PSID,
                     lpdwOwnerSize: var DWORD, pPrimaryGroup: Pointer,
                     lpdwPrimaryGroupSize: var DWORD): WINBOOL{.stdcall,
    dynlib: "advapi32", importc: "MakeAbsoluteSD".}
proc MakeSelfRelativeSD*(pAbsoluteSecurityDescriptor: PSecurityDescriptor,
                         pSelfRelativeSecurityDescriptor: PSecurityDescriptor,
                         lpdwBufferLength: var DWORD): WINBOOL{.stdcall,
    dynlib: "advapi32", importc: "MakeSelfRelativeSD".}
proc MapDialogRect*(hDlg: HWND, lpRect: var TRect): WINBOOL{.stdcall,
    dynlib: "user32", importc: "MapDialogRect".}
proc MapWindowPoints*(hWndFrom, hWndTo: HWND, lpPoints: pointer, cPoints: UINT): int{.
    stdcall, dynlib: "user32", importc: "MapWindowPoints".}
proc MessageBoxIndirect*(MsgBoxParams: TMsgBoxParams): WINBOOL{.stdcall,
    dynlib: "user32", importc: "MessageBoxIndirectA".}
proc MessageBoxIndirectA*(MsgBoxParams: TMsgBoxParamsA): WINBOOL{.stdcall,
    dynlib: "user32", importc: "MessageBoxIndirectA".}
  #function MessageBoxIndirectW(const MsgBoxParams: TMsgBoxParamsW): WINBOOL; stdcall; external 'user32' name 'MessageBoxIndirectW';
  #function ModifyWorldTransform(DC: HDC; const p2: TXForm; p3: DWORD): WINBOOL; stdcall; external 'gdi32' name 'ModifyWorldTransform';
proc MsgWaitForMultipleObjects*(nCount: DWORD, pHandles: pointer,
                                fWaitAll: WINBOOL,
                                dwMilliseconds, dwWakeMask: DWORD): DWORD{.
    stdcall, dynlib: "user32", importc: "MsgWaitForMultipleObjects".}
proc MsgWaitForMultipleObjectsEx*(nCount: DWORD, pHandles: pointer,
                                  dwMilliseconds, dwWakeMask, dwFlags: DWORD): DWORD{.
    stdcall, dynlib: "user32", importc: "MsgWaitForMultipleObjectsEx".}
  # function MultiByteToWideChar(CodePage: UINT; dwFlags: DWORD; const lpMultiByteStr: LPCSTR; cchMultiByte: Integer; lLPWSTRStr: LPWSTR; cchWideChar: Integer): Integer; stdcall; external 'kernel32' name 'MultiByteToWideChar';
proc ObjectOpenAuditAlarm*(SubsystemName: cstring, HandleId: Pointer,
                           ObjectTypeName: cstring, ObjectName: cstring,
                           pSecurityDescriptor: PSecurityDescriptor,
                           ClientToken: THandle,
                           DesiredAccess, GrantedAccess: DWORD,
                           Privileges: var TPrivilegeSet,
                           ObjectCreation, AccessGranted: WINBOOL,
                           GenerateOnClose: var WINBOOL): WINBOOL{.stdcall,
    dynlib: "advapi32", importc: "ObjectOpenAuditAlarmA".}
proc ObjectOpenAuditAlarmA*(SubsystemName: LPCSTR, HandleId: Pointer,
                            ObjectTypeName: LPCSTR, ObjectName: LPCSTR,
                            pSecurityDescriptor: PSecurityDescriptor,
                            ClientToken: THandle,
                            DesiredAccess, GrantedAccess: DWORD,
                            Privileges: var TPrivilegeSet,
                            ObjectCreation, AccessGranted: WINBOOL,
                            GenerateOnClose: var WINBOOL): WINBOOL{.stdcall,
    dynlib: "advapi32", importc: "ObjectOpenAuditAlarmA".}
proc ObjectOpenAuditAlarmW*(SubsystemName: LPWSTR, HandleId: Pointer,
                            ObjectTypeName: LPWSTR, ObjectName: LPWSTR,
                            pSecurityDescriptor: PSecurityDescriptor,
                            ClientToken: THandle,
                            DesiredAccess, GrantedAccess: DWORD,
                            Privileges: var TPrivilegeSet,
                            ObjectCreation, AccessGranted: WINBOOL,
                            GenerateOnClose: var WINBOOL): WINBOOL{.stdcall,
    dynlib: "advapi32", importc: "ObjectOpenAuditAlarmW".}
proc ObjectPrivilegeAuditAlarm*(SubsystemName: cstring, HandleId: Pointer,
                                ClientToken: THandle, DesiredAccess: DWORD,
                                Privileges: var TPrivilegeSet,
                                AccessGranted: WINBOOL): WINBOOL{.stdcall,
    dynlib: "advapi32", importc: "ObjectPrivilegeAuditAlarmA".}
proc ObjectPrivilegeAuditAlarmA*(SubsystemName: LPCSTR, HandleId: Pointer,
                                 ClientToken: THandle, DesiredAccess: DWORD,
                                 Privileges: var TPrivilegeSet,
                                 AccessGranted: WINBOOL): WINBOOL{.stdcall,
    dynlib: "advapi32", importc: "ObjectPrivilegeAuditAlarmA".}
proc ObjectPrivilegeAuditAlarmW*(SubsystemName: LPWSTR, HandleId: Pointer,
                                 ClientToken: THandle, DesiredAccess: DWORD,
                                 Privileges: var TPrivilegeSet,
                                 AccessGranted: WINBOOL): WINBOOL{.stdcall,
    dynlib: "advapi32", importc: "ObjectPrivilegeAuditAlarmW".}
proc OffsetRect*(lprc: var TRect, dx, dy: int): WINBOOL{.stdcall,
    dynlib: "user32", importc: "OffsetRect".}
proc OffsetViewportOrgEx*(DC: HDC, X, Y: int, Points: pointer): WINBOOL{.
    stdcall, dynlib: "gdi32", importc: "OffsetViewportOrgEx".}
proc OffsetWindowOrgEx*(DC: HDC, X, Y: int, Points: pointer): WINBOOL{.stdcall,
    dynlib: "gdi32", importc: "OffsetWindowOrgEx".}
proc OpenFile*(lpFileName: LPCSTR, lpReOpenBuff: var TOFStruct, uStyle: UINT): HFILE{.
    stdcall, dynlib: "kernel32", importc: "OpenFile".}
proc OpenProcessToken*(ProcessHandle: THandle, DesiredAccess: DWORD,
                       TokenHandle: var THandle): WINBOOL{.stdcall,
    dynlib: "advapi32", importc: "OpenProcessToken".}
proc OpenThreadToken*(ThreadHandle: THandle, DesiredAccess: DWORD,
                      OpenAsSelf: WINBOOL, TokenHandle: var THandle): WINBOOL{.
    stdcall, dynlib: "advapi32", importc: "OpenThreadToken".}
proc PeekConsoleInput*(hConsoleInput: THandle, lpBuffer: var TInputRecord,
                       nLength: DWORD, lpNumberOfEventsRead: var DWORD): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "PeekConsoleInputA".}
proc PeekConsoleInputA*(hConsoleInput: THandle, lpBuffer: var TInputRecord,
                        nLength: DWORD, lpNumberOfEventsRead: var DWORD): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "PeekConsoleInputA".}
proc PeekConsoleInputW*(hConsoleInput: THandle, lpBuffer: var TInputRecord,
                        nLength: DWORD, lpNumberOfEventsRead: var DWORD): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "PeekConsoleInputW".}
proc PeekMessage*(lpMsg: var TMsg, wnd: HWND,
                  wMsgFilterMin, wMsgFilterMax, wRemoveMsg: UINT): WINBOOL{.
    stdcall, dynlib: "user32", importc: "PeekMessageA".}
proc PeekMessageA*(lpMsg: var TMsg, wnd: HWND,
                   wMsgFilterMin, wMsgFilterMax, wRemoveMsg: UINT): WINBOOL{.
    stdcall, dynlib: "user32", importc: "PeekMessageA".}
proc PeekMessageW*(lpMsg: var TMsg, wnd: HWND,
                   wMsgFilterMin, wMsgFilterMax, wRemoveMsg: UINT): WINBOOL{.
    stdcall, dynlib: "user32", importc: "PeekMessageW".}
  #function PlayEnhMetaFile(DC: HDC; p2: HENHMETAFILE; const p3: TRect): WINBOOL; stdcall; external 'gdi32' name 'PlayEnhMetaFile';
proc PlayEnhMetaFileRecord*(DC: HDC, p2: var THandleTable, p3: TEnhMetaRecord,
                            p4: UINT): WINBOOL{.stdcall, dynlib: "gdi32",
    importc: "PlayEnhMetaFileRecord".}
proc PlayMetaFileRecord*(DC: HDC, p2: THandleTable, p3: TMetaRecord, p4: UINT): WINBOOL{.
    stdcall, dynlib: "gdi32", importc: "PlayMetaFileRecord".}
proc PlgBlt*(DC: HDC, PointsArray: pointer, p3: HDC, p4, p5, p6, p7: int,
             p8: HBITMAP, p9, p10: int): WINBOOL{.stdcall, dynlib: "gdi32",
    importc: "PlgBlt".}
proc PolyBezier*(DC: HDC, Points: pointer, Count: DWORD): WINBOOL{.stdcall,
    dynlib: "gdi32", importc: "PolyBezier".}
proc PolyBezierTo*(DC: HDC, Points: pointer, Count: DWORD): WINBOOL{.stdcall,
    dynlib: "gdi32", importc: "PolyBezierTo".}
proc PolyDraw*(DC: HDC, Points, Types: pointer, cCount: int): WINBOOL{.stdcall,
    dynlib: "gdi32", importc: "PolyDraw".}
proc Polygon*(DC: HDC, Points: pointer, Count: int): WINBOOL{.stdcall,
    dynlib: "gdi32", importc: "Polygon".}
proc Polyline*(DC: HDC, Points: pointer, Count: int): WINBOOL{.stdcall,
    dynlib: "gdi32", importc: "Polyline".}
proc PolyLineTo*(DC: HDC, Points: pointer, Count: DWORD): WINBOOL{.stdcall,
    dynlib: "gdi32", importc: "PolylineTo".}
proc PolyPolygon*(DC: HDC, Points: pointer, nPoints: pointer, p4: int): WINBOOL{.
    stdcall, dynlib: "gdi32", importc: "PolyPolygon".}
proc PolyPolyline*(DC: HDC, PointStructs: pointer, Points: pointer, p4: DWORD): WINBOOL{.
    stdcall, dynlib: "gdi32", importc: "PolyPolyline".}
proc PolyTextOut*(DC: HDC, PolyTextArray: pointer, Strings: int): WINBOOL{.
    stdcall, dynlib: "gdi32", importc: "PolyTextOutA".}
proc PolyTextOutA*(DC: HDC, PolyTextArray: pointer, Strings: int): WINBOOL{.
    stdcall, dynlib: "gdi32", importc: "PolyTextOutA".}
proc PolyTextOutW*(DC: HDC, PolyTextArray: pointer, Strings: int): WINBOOL{.
    stdcall, dynlib: "gdi32", importc: "PolyTextOutW".}
proc PrivilegeCheck*(ClientToken: THandle, RequiredPrivileges: TPrivilegeSet,
                     pfResult: var WINBOOL): WINBOOL{.stdcall,
    dynlib: "advapi32", importc: "PrivilegeCheck".}
proc PrivilegedServiceAuditAlarm*(SubsystemName, ServiceName: cstring,
                                  ClientToken: THandle,
                                  Privileges: var TPrivilegeSet,
                                  AccessGranted: WINBOOL): WINBOOL{.stdcall,
    dynlib: "advapi32", importc: "PrivilegedServiceAuditAlarmA".}
proc PrivilegedServiceAuditAlarmA*(SubsystemName, ServiceName: LPCSTR,
                                   ClientToken: THandle,
                                   Privileges: var TPrivilegeSet,
                                   AccessGranted: WINBOOL): WINBOOL{.stdcall,
    dynlib: "advapi32", importc: "PrivilegedServiceAuditAlarmA".}
proc PrivilegedServiceAuditAlarmW*(SubsystemName, ServiceName: LPWSTR,
                                   ClientToken: THandle,
                                   Privileges: var TPrivilegeSet,
                                   AccessGranted: WINBOOL): WINBOOL{.stdcall,
    dynlib: "advapi32", importc: "PrivilegedServiceAuditAlarmW".}
  #function PtInRect(const lprc: TRect; pt: TPoint): WINBOOL; stdcall; external 'user32' name 'PtInRect';
proc QueryPerformanceCounter*(lpPerformanceCount: var TLargeInteger): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "QueryPerformanceCounter".}
proc QueryPerformanceFrequency*(lpFrequency: var TLargeInteger): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "QueryPerformanceFrequency".}
  #function QueryRecoveryAgents(p1: PChar; var p2: Pointer; var p3: TRecoveryAgentInformation): DWORD;stdcall; external 'kernel32' name 'QueryRecoveryAgentsA';
  #function QueryRecoveryAgentsA(p1: LPCSTR; var p2: Pointer; var p3: TRecoveryAgentInformationA): DWORD;stdcall; external 'kernel32' name 'QueryRecoveryAgentsA';
  #function QueryRecoveryAgentsW(p1: LPWSTR; var p2: Pointer; var p3: TRecoveryAgentInformationW): DWORD;stdcall; external 'kernel32' name 'QueryRecoveryAgentsW';
proc RaiseException*(dwExceptionCode: DWORD, dwExceptionFlags: DWORD,
                     nNumberOfArguments: DWORD, lpArguments: var DWORD){.
    stdcall, dynlib: "kernel32", importc: "RaiseException".}
proc UnhandledExceptionFilter*(ExceptionInfo: var emptyrecord): LONG{.stdcall,
    dynlib: "kernel32", importc: "UnhandledExceptionFilter".}
proc ReadConsole*(hConsoleInput: THandle, lpBuffer: Pointer,
                  nNumberOfCharsToRead: DWORD, lpNumberOfCharsRead: var DWORD,
                  lpReserved: Pointer): WINBOOL{.stdcall, dynlib: "kernel32",
    importc: "ReadConsoleA".}
proc ReadConsoleA*(hConsoleInput: THandle, lpBuffer: Pointer,
                   nNumberOfCharsToRead: DWORD, lpNumberOfCharsRead: var DWORD,
                   lpReserved: Pointer): WINBOOL{.stdcall, dynlib: "kernel32",
    importc: "ReadConsoleA".}
proc ReadConsoleInput*(hConsoleInput: THandle, lpBuffer: var TInputRecord,
                       nLength: DWORD, lpNumberOfEventsRead: var DWORD): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "ReadConsoleInputA".}
proc ReadConsoleInputA*(hConsoleInput: THandle, lpBuffer: var TInputRecord,
                        nLength: DWORD, lpNumberOfEventsRead: var DWORD): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "ReadConsoleInputA".}
proc ReadConsoleInputW*(hConsoleInput: THandle, lpBuffer: var TInputRecord,
                        nLength: DWORD, lpNumberOfEventsRead: var DWORD): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "ReadConsoleInputW".}
proc ReadConsoleOutput*(hConsoleOutput: THandle, lpBuffer: Pointer,
                        dwBufferSize, dwBufferCoord: TCoord,
                        lpReadRegion: var TSmallRect): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "ReadConsoleOutputA".}
proc ReadConsoleOutputA*(hConsoleOutput: THandle, lpBuffer: Pointer,
                         dwBufferSize, dwBufferCoord: TCoord,
                         lpReadRegion: var TSmallRect): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "ReadConsoleOutputA".}
proc ReadConsoleOutputAttribute*(hConsoleOutput: THandle, lpAttribute: Pointer,
                                 nLength: DWORD, dwReadCoord: TCoord,
                                 lpNumberOfAttrsRead: var DWORD): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "ReadConsoleOutputAttribute".}
proc ReadConsoleOutputCharacter*(hConsoleOutput: THandle, lpCharacter: LPCSTR,
                                 nLength: DWORD, dwReadCoord: TCoord,
                                 lpNumberOfCharsRead: var DWORD): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "ReadConsoleOutputCharacterA".}
proc ReadConsoleOutputCharacterA*(hConsoleOutput: THandle, lpCharacter: LPCSTR,
                                  nLength: DWORD, dwReadCoord: TCoord,
                                  lpNumberOfCharsRead: var DWORD): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "ReadConsoleOutputCharacterA".}
proc ReadConsoleOutputCharacterW*(hConsoleOutput: THandle, lpCharacter: LPCSTR,
                                  nLength: DWORD, dwReadCoord: TCoord,
                                  lpNumberOfCharsRead: var DWORD): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "ReadConsoleOutputCharacterW".}
proc ReadConsoleOutputW*(hConsoleOutput: THandle, lpBuffer: Pointer,
                         dwBufferSize, dwBufferCoord: TCoord,
                         lpReadRegion: var TSmallRect): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "ReadConsoleOutputW".}
proc ReadConsoleW*(hConsoleInput: THandle, lpBuffer: Pointer,
                   nNumberOfCharsToRead: DWORD, lpNumberOfCharsRead: var DWORD,
                   lpReserved: Pointer): WINBOOL{.stdcall, dynlib: "kernel32",
    importc: "ReadConsoleW".}
proc ReadEventLog*(hEventLog: THandle, dwReadFlags, dwRecordOffset: DWORD,
                   lpBuffer: Pointer, nNumberOfBytesToRead: DWORD,
                   pnBytesRead, pnMinNumberOfBytesNeeded: var DWORD): WINBOOL{.
    stdcall, dynlib: "advapi32", importc: "ReadEventLogA".}
proc ReadEventLogA*(hEventLog: THandle, dwReadFlags, dwRecordOffset: DWORD,
                    lpBuffer: Pointer, nNumberOfBytesToRead: DWORD,
                    pnBytesRead, pnMinNumberOfBytesNeeded: var DWORD): WINBOOL{.
    stdcall, dynlib: "advapi32", importc: "ReadEventLogA".}
proc ReadEventLogW*(hEventLog: THandle, dwReadFlags, dwRecordOffset: DWORD,
                    lpBuffer: Pointer, nNumberOfBytesToRead: DWORD,
                    pnBytesRead, pnMinNumberOfBytesNeeded: var DWORD): WINBOOL{.
    stdcall, dynlib: "advapi32", importc: "ReadEventLogW".}
proc ReadFile*(hFile: THandle, Buffer: pointer, nNumberOfBytesToRead: DWORD,
               lpNumberOfBytesRead: var DWORD, lpOverlapped: POverlapped): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "ReadFile".}
proc ReadProcessMemory*(hProcess: THandle, lpBaseAddress: Pointer,
                        lpBuffer: Pointer, nSize: DWORD,
                        lpNumberOfBytesRead: var DWORD): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "ReadProcessMemory".}
  #function RectInRegion(RGN: HRGN; const p2: TRect): WINBOOL; stdcall; external 'gdi32' name 'RectInRegion';
  #function RectVisible(DC: HDC; const Rect: TRect): WINBOOL; stdcall; external 'gdi32' name 'RectVisible';
proc RegConnectRegistry*(lpMachineName: cstring, key: HKEY, phkResult: var HKEY): int32{.
    stdcall, dynlib: "advapi32", importc: "RegConnectRegistryA".}
proc RegConnectRegistryA*(lpMachineName: LPCSTR, key: HKEY, phkResult: var HKEY): int32{.
    stdcall, dynlib: "advapi32", importc: "RegConnectRegistryA".}
proc RegConnectRegistryW*(lpMachineName: LPWSTR, key: HKEY, phkResult: var HKEY): int32{.
    stdcall, dynlib: "advapi32", importc: "RegConnectRegistryW".}
proc RegCreateKey*(key: HKEY, lpSubKey: cstring, phkResult: var HKEY): int32{.
    stdcall, dynlib: "advapi32", importc: "RegCreateKeyA".}
proc RegCreateKeyA*(key: HKEY, lpSubKey: LPCSTR, phkResult: var HKEY): int32{.
    stdcall, dynlib: "advapi32", importc: "RegCreateKeyA".}
proc RegCreateKeyEx*(key: HKEY, lpSubKey: cstring, Reserved: DWORD,
                     lpClass: cstring, dwOptions: DWORD, samDesired: REGSAM,
                     lpSecurityAttributes: PSecurityAttributes,
                     phkResult: var HKEY, lpdwDisposition: PDWORD): int32{.
    stdcall, dynlib: "advapi32", importc: "RegCreateKeyExA".}
proc RegCreateKeyExA*(key: HKEY, lpSubKey: LPCSTR, Reserved: DWORD,
                      lpClass: LPCSTR, dwOptions: DWORD, samDesired: REGSAM,
                      lpSecurityAttributes: PSecurityAttributes,
                      phkResult: var HKEY, lpdwDisposition: PDWORD): int32{.
    stdcall, dynlib: "advapi32", importc: "RegCreateKeyExA".}
proc RegCreateKeyExW*(key: HKEY, lpSubKey: LPWSTR, Reserved: DWORD,
                      lpClass: LPWSTR, dwOptions: DWORD, samDesired: REGSAM,
                      lpSecurityAttributes: PSecurityAttributes,
                      phkResult: var HKEY, lpdwDisposition: PDWORD): int32{.
    stdcall, dynlib: "advapi32", importc: "RegCreateKeyExW".}
proc RegCreateKeyW*(key: HKEY, lpSubKey: LPWSTR, phkResult: var HKEY): int32{.
    stdcall, dynlib: "advapi32", importc: "RegCreateKeyW".}
proc RegEnumKeyEx*(key: HKEY, dwIndex: DWORD, lpName: cstring,
                   lpcbName: var DWORD, lpReserved: Pointer, lpClass: cstring,
                   lpcbClass: PDWORD, lpftLastWriteTime: PFileTime): int32{.
    stdcall, dynlib: "advapi32", importc: "RegEnumKeyExA".}
proc RegEnumKeyExA*(key: HKEY, dwIndex: DWORD, lpName: LPCSTR,
                    lpcbName: var DWORD, lpReserved: Pointer, lpClass: LPCSTR,
                    lpcbClass: PDWORD, lpftLastWriteTime: PFileTime): int32{.
    stdcall, dynlib: "advapi32", importc: "RegEnumKeyExA".}
proc RegEnumKeyExW*(key: HKEY, dwIndex: DWORD, lpName: LPWSTR,
                    lpcbName: var DWORD, lpReserved: Pointer, lpClass: LPWSTR,
                    lpcbClass: PDWORD, lpftLastWriteTime: PFileTime): int32{.
    stdcall, dynlib: "advapi32", importc: "RegEnumKeyExW".}
proc RegEnumValue*(key: HKEY, dwIndex: DWORD, lpValueName: cstring,
                   lpcbValueName: var DWORD, lpReserved: Pointer,
                   lpType: PDWORD, lpData: PByte, lpcbData: PDWORD): int32{.
    stdcall, dynlib: "advapi32", importc: "RegEnumValueA".}
proc RegEnumValueA*(key: HKEY, dwIndex: DWORD, lpValueName: cstring,
                    lpcbValueName: var DWORD, lpReserved: Pointer,
                    lpType: PDWORD, lpData: PByte, lpcbData: PDWORD): int32{.
    stdcall, dynlib: "advapi32", importc: "RegEnumValueA".}
proc RegEnumValueW*(key: HKEY, dwIndex: DWORD, lpValueName: cstring,
                    lpcbValueName: var DWORD, lpReserved: Pointer,
                    lpType: PDWORD, lpData: PByte, lpcbData: PDWORD): int32{.
    stdcall, dynlib: "advapi32", importc: "RegEnumValueW".}
proc RegGetKeySecurity*(key: HKEY, SecurityInformation: SECURITY_INFORMATION,
                        pSecurityDescriptor: PSecurityDescriptor,
                        lpcbSecurityDescriptor: var DWORD): int32{.stdcall,
    dynlib: "advapi32", importc: "RegGetKeySecurity".}
proc RegSetValueEx*(key: HKEY, lpValueName: LPCSTR, Reserved: DWORD,
                    dwType: DWORD, lpData: pointer, cbData: DWORD): LONG{.
    stdcall, dynlib: "advapi32", importc: "RegSetValueExA".}
proc RegSetValueExA*(key: HKEY, lpValueName: LPCSTR, Reserved: DWORD,
                     dwType: DWORD, lpData: pointer, cbData: DWORD): LONG{.
    stdcall, dynlib: "advapi32", importc: "RegSetValueExA".}
proc RegSetValueExW*(key: HKEY, lpValueName: LPCWSTR, Reserved: DWORD,
                     dwType: DWORD, lpData: pointer, cbData: DWORD): LONG{.
    stdcall, dynlib: "advapi32", importc: "RegSetValueExW".}
proc RegisterClass*(lpWndClass: TWndClass): ATOM{.stdcall, dynlib: "user32",
    importc: "RegisterClassA".}
proc RegisterClassA*(lpWndClass: TWndClassA): ATOM{.stdcall, dynlib: "user32",
    importc: "RegisterClassA".}
proc RegisterClassEx*(WndClass: TWndClassEx): ATOM{.stdcall, dynlib: "user32",
    importc: "RegisterClassExA".}
proc RegisterClassExA*(WndClass: TWndClassExA): ATOM{.stdcall, dynlib: "user32",
    importc: "RegisterClassExA".}
proc RegisterClassExW*(WndClass: TWndClassExW): ATOM{.stdcall, dynlib: "user32",
    importc: "RegisterClassExW".}
proc RegisterClassW*(lpWndClass: TWndClassW): ATOM{.stdcall, dynlib: "user32",
    importc: "RegisterClassW".}
proc RegOpenKey*(key: HKEY, lpSubKey: cstring, phkResult: var HKEY): int32{.
    stdcall, dynlib: "advapi32", importc: "RegOpenKeyA".}
proc RegOpenKeyA*(key: HKEY, lpSubKey: LPCSTR, phkResult: var HKEY): int32{.
    stdcall, dynlib: "advapi32", importc: "RegOpenKeyA".}
proc RegOpenKeyEx*(key: HKEY, lpSubKey: cstring, ulOptions: DWORD,
                   samDesired: REGSAM, phkResult: var HKEY): int32{.stdcall,
    dynlib: "advapi32", importc: "RegOpenKeyExA".}
proc RegOpenKeyExA*(key: HKEY, lpSubKey: LPCSTR, ulOptions: DWORD,
                    samDesired: REGSAM, phkResult: var HKEY): int32{.stdcall,
    dynlib: "advapi32", importc: "RegOpenKeyExA".}
proc RegOpenKeyExW*(key: HKEY, lpSubKey: LPWSTR, ulOptions: DWORD,
                    samDesired: REGSAM, phkResult: var HKEY): int32{.stdcall,
    dynlib: "advapi32", importc: "RegOpenKeyExW".}
proc RegOpenKeyW*(key: HKEY, lpSubKey: LPWSTR, phkResult: var HKEY): int32{.
    stdcall, dynlib: "advapi32", importc: "RegOpenKeyW".}
proc RegQueryMultipleValues*(key: HKEY, ValList: pointer, NumVals: DWORD,
                             lpValueBuf: cstring, ldwTotsize: var DWORD): int32{.
    stdcall, dynlib: "advapi32", importc: "RegQueryMultipleValuesA".}
proc RegQueryMultipleValuesA*(key: HKEY, ValList: pointer, NumVals: DWORD,
                              lpValueBuf: LPCSTR, ldwTotsize: var DWORD): int32{.
    stdcall, dynlib: "advapi32", importc: "RegQueryMultipleValuesA".}
proc RegQueryMultipleValuesW*(key: HKEY, ValList: pointer, NumVals: DWORD,
                              lpValueBuf: LPWSTR, ldwTotsize: var DWORD): int32{.
    stdcall, dynlib: "advapi32", importc: "RegQueryMultipleValuesW".}
proc RegQueryValue*(key: HKEY, lpSubKey: cstring, lpValue: cstring,
                    lpcbValue: var int32): int32{.stdcall, dynlib: "advapi32",
    importc: "RegQueryValueA".}
proc RegQueryValueA*(key: HKEY, lpSubKey: LPCSTR, lpValue: LPCSTR,
                     lpcbValue: var int32): int32{.stdcall, dynlib: "advapi32",
    importc: "RegQueryValueA".}
proc RegQueryValueW*(key: HKEY, lpSubKey: LPWSTR, lpValue: LPWSTR,
                     lpcbValue: var int32): int32{.stdcall, dynlib: "advapi32",
    importc: "RegQueryValueW".}
proc ResetDC*(DC: HDC, p2: TDeviceMode): HDC{.stdcall, dynlib: "gdi32",
    importc: "ResetDCA".}
proc ResetDCA*(DC: HDC, p2: TDeviceModeA): HDC{.stdcall, dynlib: "gdi32",
    importc: "ResetDCA".}
  #function ResetDCW(DC: HDC; const p2: TDeviceModeW): HDC; stdcall; external 'gdi32' name 'ResetDCW';
proc ScreenToClient*(wnd: HWND, lpPoint: var TPoint): WINBOOL{.stdcall,
    dynlib: "user32", importc: "ScreenToClient".}
proc ScrollConsoleScreenBuffer*(hConsoleOutput: THandle,
                                lpScrollRectangle: TSmallRect,
                                lpClipRectangle: TSmallRect,
                                dwDestinationOrigin: TCoord,
                                lpFill: var TCharInfo): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "ScrollConsoleScreenBufferA".}
proc ScrollConsoleScreenBufferA*(hConsoleOutput: THandle,
                                 lpScrollRectangle: TSmallRect,
                                 lpClipRectangle: TSmallRect,
                                 dwDestinationOrigin: TCoord,
                                 lpFill: var TCharInfo): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "ScrollConsoleScreenBufferA".}
proc ScrollConsoleScreenBufferW*(hConsoleOutput: THandle,
                                 lpScrollRectangle: TSmallRect,
                                 lpClipRectangle: TSmallRect,
                                 dwDestinationOrigin: TCoord,
                                 lpFill: var TCharInfo): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "ScrollConsoleScreenBufferW".}
proc ScrollWindow*(wnd: HWND, XAmount: int32, YAmount: int32, rect: LPRECT,
                   lpClipRect: lpRECT): WINBOOL{.stdcall, dynlib: "user32",
    importc: "ScrollWindow".}
proc ScrollWindowEx*(wnd: HWND, dx: int32, dy: int32, prcScroll: lpRECT,
                     prcClip: lpRECT, hrgnUpdate: HRGN, prcUpdate: LPRECT,
                     flags: UINT): int32{.stdcall, dynlib: "user32",
    importc: "ScrollWindowEx".}
  #function ScrollDC(DC: HDC; DX, DY: Integer; var Scroll, Clip: TRect; Rgn: HRGN; Update: PRect): WINBOOL; stdcall; external 'user32' name 'ScrollDC';
  #function SearchPath(lpPath, lpFileName, lpExtension: PChar; nBufferLength: DWORD; lpBuffer: PChar; var lpFilePart: PChar): DWORD;stdcall; external 'kernel32' name 'SearchPathA';
  #function SearchPathA(lpPath, lpFileName, lpExtension: LPCSTR; nBufferLength: DWORD; lpBuffer: LPCSTR; var lpFilePart: LPCSTR): DWORD; stdcall; external 'kernel32' name 'SearchPathA';
  #function SearchPathW(lpPath, lpFileName, lpExtension: LPWSTR; nBufferLength: DWORD; lpBuffer: LPWSTR; var lpFilePart: LPWSTR): DWORD; stdcall; external 'kernel32' name 'SearchPathW';
  #function SendInput(cInputs: UINT; var pInputs: TInput; cbSize: Integer): UINT;stdcall; external 'user32' name 'SendInput';
proc SendMessageTimeout*(wnd: HWND, Msg: UINT, wp: WPARAM, lp: LPARAM,
                         fuFlags, uTimeout: UINT, lpdwResult: var DWORD): LRESULT{.
    stdcall, dynlib: "user32", importc: "SendMessageTimeoutA".}
proc SendMessageTimeoutA*(wnd: HWND, Msg: UINT, wp: WPARAM, lp: LPARAM,
                          fuFlags, uTimeout: UINT, lpdwResult: var DWORD): LRESULT{.
    stdcall, dynlib: "user32", importc: "SendMessageTimeoutA".}
proc SendMessageTimeoutW*(wnd: HWND, Msg: UINT, wp: WPARAM, lp: LPARAM,
                          fuFlags, uTimeout: UINT, lpdwResult: var DWORD): LRESULT{.
    stdcall, dynlib: "user32", importc: "SendMessageTimeoutW".}
  #function SetAclInformation(var pAcl: TACL; pAclInformation: Pointer; nAclInformationLength: DWORD; dwAclInformationClass: TAclInformationClass): WINBOOL; stdcall; external 'advapi32' name 'SetAclInformation';
  #function SetColorAdjustment(DC: HDC; const p2: TColorAdjustment): WINBOOL; stdcall; external 'gdi32' name 'SetColorAdjustment';
proc SetCommConfig*(hCommDev: THandle, lpCC: TCommConfig, dwSize: DWORD): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "SetCommConfig".}
proc SetCommState*(hFile: THandle, lpDCB: TDCB): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "SetCommState".}
proc SetCommTimeouts*(hFile: THandle, lpCommTimeouts: TCommTimeouts): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "SetCommTimeouts".}
proc SetConsoleCursorInfo*(hConsoleOutput: THandle,
                           lpConsoleCursorInfo: TConsoleCursorInfo): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "SetConsoleCursorInfo".}
  #function SetConsoleWindowInfo(hConsoleOutput: THandle; bAbsolute: WINBOOL; const lpConsoleWindow: TSmallRect): WINBOOL; stdcall; external 'kernel32' name 'SetConsoleWindowInfo';
proc SetDIBColorTable*(DC: HDC, p2, p3: UINT, RGBQuadSTructs: pointer): UINT{.
    stdcall, dynlib: "gdi32", importc: "SetDIBColorTable".}
proc SetDIBits*(DC: HDC, Bitmap: HBITMAP, StartScan, NumScans: UINT,
                Bits: Pointer, BitsInfo: var TBitmapInfo, Usage: UINT): int{.
    stdcall, dynlib: "gdi32", importc: "SetDIBits".}
  #function SetDIBitsToDevice(DC: HDC; DestX, DestY: Integer; Width, Height: DWORD; SrcX, SrcY: Integer; nStartScan, NumScans: UINT; Bits: Pointer; var BitsInfo: TBitmapInfo; Usage: UINT): Integer; stdcall; external 'gdi32' name 'SetDIBitsToDevice';
proc SetEnhMetaFileBits*(para1: UINT, para2: pointer): HENHMETAFILE{.stdcall,
    dynlib: "gdi32", importc: "SetEnhMetaFileBits".}
proc SetFileTime*(hFile: HANDLE, lpCreationTime: var FILETIME,
                  lpLastAccessTime: var FILETIME, lpLastWriteTime: var FILETIME): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "SetFileTime".}
  #function SetKeyboardState(var KeyState: TKeyboardState): WINBOOL; stdcall; external 'user32' name 'SetKeyboardState';
  #function SetLocalTime(const lpSystemTime: TSystemTime): WINBOOL; stdcall; external 'kernel32' name 'SetLocalTime';
  #function SetMenuInfo(menu: HMENU; const lpcmi: TMenuInfo): WINBOOL;stdcall; external 'user32' name 'SetMenuInfo';
proc SetMenuItemInfo*(p1: HMENU, p2: UINT, p3: WINBOOL, p4: TMenuItemInfo): WINBOOL{.
    stdcall, dynlib: "user32", importc: "SetMenuItemInfoA".}
proc SetMenuItemInfoA*(p1: HMENU, p2: UINT, p3: WINBOOL, p4: TMenuItemInfoA): WINBOOL{.
    stdcall, dynlib: "user32", importc: "SetMenuItemInfoA".}
  #function SetMenuItemInfoW(p1: HMENU; p2: UINT; p3: WINBOOL; const p4: TMenuItemInfoW): WINBOOL; stdcall; external 'user32' name 'SetMenuItemInfoW';
proc SetMetaFileBitsEx*(p1: UINT, p2: cstring): HMETAFILE{.stdcall,
    dynlib: "gdi32", importc: "SetMetaFileBitsEx".}
proc SetNamedPipeHandleState*(hNamedPipe: THandle, lpMode: var DWORD,
    lpMaxCollectionCount, lpCollectDataTimeout: Pointer): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "SetNamedPipeHandleState".}
proc SetPaletteEntries*(Palette: HPALETTE, StartIndex, NumEntries: UINT,
                        PaletteEntries: pointer): UINT{.stdcall,
    dynlib: "gdi32", importc: "SetPaletteEntries".}
  #function SetPrivateObjectSecurity(SecurityInformation: SECURITY_INFORMATION; ModificationDescriptor: PSecurityDescriptor; var ObjectsSecurityDescriptor: PSecurityDescriptor; const GenericMapping: TGenericMapping; Token: THandle): WINBOOL;
  #  stdcall; external 'advapi32' name 'SetPrivateObjectSecurity';
  #function SetPrivateObjectSecurityEx(SecurityInformation: SECURITY_INFORMATION; ModificationDescriptor: PSecurityDescriptor; var ObjectsSecurityDescriptor: PSecurityDescriptor; AutoInheritFlags: ULONG;
  #  const GenericMapping: TGenericMapping; Token: THandle): WINBOOL;stdcall; external 'advapi32' name 'SetPrivateObjectSecurityEx';
proc SetRect*(lprc: var TRect, xLeft, yTop, xRight, yBottom: int): WINBOOL{.
    stdcall, dynlib: "user32", importc: "SetRect".}
proc SetRectEmpty*(lprc: var TRect): WINBOOL{.stdcall, dynlib: "user32",
    importc: "SetRectEmpty".}
proc SetScrollInfo*(wnd: HWND, BarFlag: int, ScrollInfo: TScrollInfo,
                    Redraw: WINBOOL): int{.stdcall, dynlib: "user32",
    importc: "SetScrollInfo".}
proc SetSysColors*(cElements: int, lpaElements: pointer, lpaRgbValues: pointer): WINBOOL{.
    stdcall, dynlib: "user32", importc: "SetSysColors".}
  #function SetSystemTime(const lpSystemTime: TSystemTime): WINBOOL; stdcall; external 'kernel32' name 'SetSystemTime';
proc SetThreadContext*(hThread: THandle, lpContext: TContext): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "SetThreadContext".}
  #function SetTimeZoneInformation(const lpTimeZoneInformation: TTimeZoneInformation): WINBOOL; stdcall; external 'kernel32' name 'SetTimeZoneInformation';
proc SetUserObjectSecurity*(hObj: THandle, pSIRequested: var DWORD,
                            pSID: PSecurityDescriptor): WINBOOL{.stdcall,
    dynlib: "user32", importc: "SetUserObjectSecurity".}
proc SetWaitableTimer*(hTimer: THandle, lpDueTime: var TLargeInteger,
                       lPeriod: int32, pfnCompletionRoutine: TFNTimerAPCRoutine,
                       lpArgToCompletionRoutine: Pointer, fResume: WINBOOL): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "SetWaitableTimer".}
proc SetWinMetaFileBits*(p1: UINT, p2: cstring, p3: HDC, p4: TMetaFilePict): HENHMETAFILE{.
    stdcall, dynlib: "gdi32", importc: "SetWinMetaFileBits".}
  #function SetWorldTransform(DC: HDC; const p2: TXForm): WINBOOL; stdcall; external 'gdi32' name 'SetWorldTransform';
proc StartDoc*(DC: HDC, p2: TDocInfo): int{.stdcall, dynlib: "gdi32",
    importc: "StartDocA".}
proc StartDocA*(DC: HDC, p2: TDocInfoA): int{.stdcall, dynlib: "gdi32",
    importc: "StartDocA".}
  #function StartDocW(DC: HDC; const p2: TDocInfoW): Integer; stdcall; external 'gdi32' name 'StartDocW';
  #function StretchDIBits(DC: HDC; DestX, DestY, DestWidth, DestHegiht, SrcX, SrcY, SrcWidth, SrcHeight: Integer; Bits: Pointer; var BitsInfo: TBitmapInfo; Usage: UINT; Rop: DWORD): Integer; stdcall; external 'gdi32' name 'StretchDIBits';
proc SubtractRect*(lprcDst: var TRect, lprcSrc1, lprcSrc2: TRect): WINBOOL{.
    stdcall, dynlib: "user32", importc: "SubtractRect".}
proc SystemTimeToFileTime*(lpSystemTime: TSystemTime, lpFileTime: var TFileTime): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "SystemTimeToFileTime".}
proc SystemTimeToTzSpecificLocalTime*(lpTimeZoneInformation: PTimeZoneInformation,
    lpUniversalTime, lpLocalTime: var TSystemTime): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "SystemTimeToTzSpecificLocalTime".}
proc TabbedTextOut*(hDC: HDC, X, Y: int, lpString: cstring,
                    nCount, nTabPositions: int, lpnTabStopPositions: pointer,
                    nTabOrigin: int): int32{.stdcall, dynlib: "user32",
    importc: "TabbedTextOutA".}
proc TabbedTextOutA*(hDC: HDC, X, Y: int, lpString: LPCSTR,
                     nCount, nTabPositions: int, lpnTabStopPositions: pointer,
                     nTabOrigin: int): int32{.stdcall, dynlib: "user32",
    importc: "TabbedTextOutA".}
proc TabbedTextOutW*(hDC: HDC, X, Y: int, lpString: LPWSTR,
                     nCount, nTabPositions: int, lpnTabStopPositions: pointer,
                     nTabOrigin: int): int32{.stdcall, dynlib: "user32",
    importc: "TabbedTextOutW".}
  #function ToAscii(uVirtKey, uScanCode: UINT; const KeyState: TKeyboardState; lpChar: PChar; uFlags: UINT): Integer; stdcall; external 'user32' name 'ToAscii';
  #function ToAsciiEx(uVirtKey: UINT; uScanCode: UINT; const KeyState: TKeyboardState; lpChar: PChar; uFlags: UINT; dwhkl: HKL): Integer; stdcall; external 'user32' name 'ToAsciiEx';
  #function ToUnicode(wVirtKey, wScanCode: UINT; const KeyState: TKeyboardState; var pwszBuff; cchBuff: Integer; wFlags: UINT): Integer; stdcall; external 'user32' name 'ToUnicode';
  # Careful, NT and higher only.
proc TrackMouseEvent*(EventTrack: var TTrackMouseEvent): WINBOOL{.stdcall,
    dynlib: "user32", importc: "TrackMouseEvent".}
proc TrackMouseEvent*(lpEventTrack: PTrackMouseEvent): WINBOOL{.stdcall,
    dynlib: "user32", importc: "TrackMouseEvent".}
proc TrackPopupMenu*(menu: HMENU, uFlags: UINT, x: int32, y: int32,
                     nReserved: int32, wnd: HWND, prcRect: PRect): WINBOOL{.
    stdcall, dynlib: "user32", importc: "TrackPopupMenu".}
proc TransactNamedPipe*(hNamedPipe: THandle, lpInBuffer: Pointer,
                        nInBufferSize: DWORD, lpOutBuffer: Pointer,
                        nOutBufferSize: DWORD, lpBytesRead: var DWORD,
                        lpOverlapped: POverlapped): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "TransactNamedPipe".}
proc TranslateAccelerator*(wnd: HWND, hAccTable: HACCEL, lpMsg: var TMsg): int{.
    stdcall, dynlib: "user32", importc: "TranslateAcceleratorA".}
proc TranslateAcceleratorA*(wnd: HWND, hAccTable: HACCEL, lpMsg: var TMsg): int{.
    stdcall, dynlib: "user32", importc: "TranslateAcceleratorA".}
proc TranslateAcceleratorW*(wnd: HWND, hAccTable: HACCEL, lpMsg: var TMsg): int{.
    stdcall, dynlib: "user32", importc: "TranslateAcceleratorW".}
proc TranslateCharsetInfo*(lpSrc: var DWORD, lpCs: var TCharsetInfo,
                           dwFlags: DWORD): WINBOOL{.stdcall, dynlib: "gdi32",
    importc: "TranslateCharsetInfo".}
proc TranslateMDISysAccel*(hWndClient: HWND, lpMsg: TMsg): WINBOOL{.stdcall,
    dynlib: "user32", importc: "TranslateMDISysAccel".}
proc TranslateMessage*(lpMsg: TMsg): WINBOOL{.stdcall, dynlib: "user32",
    importc: "TranslateMessage".}
  #function TransparentDIBits(DC: HDC; p2, p3, p4, p5: Integer; const p6: Pointer; const p7: PBitmapInfo; p8: UINT; p9, p10, p11, p12: Integer; p13: UINT): WINBOOL;stdcall; external 'gdi32' name 'TransparentDIBits';
proc UnhandledExceptionFilter*(ExceptionInfo: TExceptionPointers): int32{.
    stdcall, dynlib: "kernel32", importc: "UnhandledExceptionFilter".}
proc UnionRect*(lprcDst: var TRect, lprcSrc1, lprcSrc2: TRect): WINBOOL{.
    stdcall, dynlib: "user32", importc: "UnionRect".}
proc UnlockFileEx*(hFile: THandle, dwReserved, nNumberOfBytesToUnlockLow: DWORD,
                   nNumberOfBytesToUnlockHigh: DWORD, lpOverlapped: TOverlapped): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "UnlockFileEx".}
proc VerFindFile*(uFlags: DWORD,
                  szFileName, szWinDir, szAppDir, szCurDir: cstring,
                  lpuCurDirLen: var UINT, szDestDir: cstring,
                  lpuDestDirLen: var UINT): DWORD{.stdcall, dynlib: "version",
    importc: "VerFindFileA".}
proc VerFindFileA*(uFlags: DWORD,
                   szFileName, szWinDir, szAppDir, szCurDir: LPCSTR,
                   lpuCurDirLen: var UINT, szDestDir: LPCSTR,
                   lpuDestDirLen: var UINT): DWORD{.stdcall, dynlib: "version",
    importc: "VerFindFileA".}
proc VerFindFileW*(uFlags: DWORD,
                   szFileName, szWinDir, szAppDir, szCurDir: LPWSTR,
                   lpuCurDirLen: var UINT, szDestDir: LPWSTR,
                   lpuDestDirLen: var UINT): DWORD{.stdcall, dynlib: "version",
    importc: "VerFindFileW".}
proc VerInstallFile*(uFlags: DWORD, szSrcFileName, szDestFileName, szSrcDir,
                                    szDestDir, szCurDir, szTmpFile: cstring,
                     lpuTmpFileLen: var UINT): DWORD{.stdcall,
    dynlib: "version", importc: "VerInstallFileA".}
proc VerInstallFileA*(uFlags: DWORD, szSrcFileName, szDestFileName, szSrcDir,
                                     szDestDir, szCurDir, szTmpFile: LPCSTR,
                      lpuTmpFileLen: var UINT): DWORD{.stdcall,
    dynlib: "version", importc: "VerInstallFileA".}
proc VerInstallFileW*(uFlags: DWORD, szSrcFileName, szDestFileName, szSrcDir,
                                     szDestDir, szCurDir, szTmpFile: LPWSTR,
                      lpuTmpFileLen: var UINT): DWORD{.stdcall,
    dynlib: "version", importc: "VerInstallFileW".}
proc VerQueryValue*(pBlock: Pointer, lpSubBlock: cstring,
                    lplpBuffer: var Pointer, puLen: var UINT): WINBOOL{.stdcall,
    dynlib: "version", importc: "VerQueryValueA".}
proc VerQueryValueA*(pBlock: Pointer, lpSubBlock: LPCSTR,
                     lplpBuffer: var Pointer, puLen: var UINT): WINBOOL{.
    stdcall, dynlib: "version", importc: "VerQueryValueA".}
proc VerQueryValueW*(pBlock: Pointer, lpSubBlock: LPWSTR,
                     lplpBuffer: var Pointer, puLen: var UINT): WINBOOL{.
    stdcall, dynlib: "version", importc: "VerQueryValueW".}
proc VirtualQuery*(lpAddress: Pointer, lpBuffer: var TMemoryBasicInformation,
                   dwLength: DWORD): DWORD{.stdcall, dynlib: "kernel32",
    importc: "VirtualQuery".}
proc VirtualQueryEx*(hProcess: THandle, lpAddress: Pointer,
                     lpBuffer: var TMemoryBasicInformation, dwLength: DWORD): DWORD{.
    stdcall, dynlib: "kernel32", importc: "VirtualQueryEx".}
proc WaitCommEvent*(hFile: THandle, lpEvtMask: var DWORD,
                    lpOverlapped: POverlapped): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "WaitCommEvent".}
proc WaitForDebugEvent*(lpDebugEvent: var TDebugEvent, dwMilliseconds: DWORD): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "WaitForDebugEvent".}
proc wglDescribeLayerPlane*(p1: HDC, p2, p3: int, p4: int,
                            p5: var TLayerPlaneDescriptor): WINBOOL{.stdcall,
    dynlib: "opengl32", importc: "wglDescribeLayerPlane".}
proc wglGetLayerPaletteEntries*(p1: HDC, p2, p3, p4: int, pcr: pointer): int{.
    stdcall, dynlib: "opengl32", importc: "wglGetLayerPaletteEntries".}
proc wglSetLayerPaletteEntries*(p1: HDC, p2, p3, p4: int, pcr: pointer): int{.
    stdcall, dynlib: "opengl32", importc: "wglSetLayerPaletteEntries".}
  #function wglSwapMultipleBuffers(p1: UINT; const p2: PWGLSwap): DWORD;stdcall; external 'opengl32' name 'wglSwapMultipleBuffers';
  #function WinSubmitCertificate(var lpCertificate: TWinCertificate): WINBOOL;stdcall; external 'imaghlp' name 'WinSubmitCertificate';
  #function WinVerifyTrust(wnd: HWND; const ActionID: TGUID; ActionData: Pointer): Longint;stdcall; external 'imaghlp' name 'WinVerifyTrust';
proc WNetAddConnection2*(lpNetResource: var TNetResource,
                         lpPassword, lpUserName: cstring, dwFlags: DWORD): DWORD{.
    stdcall, dynlib: "mpr", importc: "WNetAddConnection2A".}
proc WNetAddConnection2A*(lpNetResource: var TNetResourceA,
                          lpPassword, lpUserName: LPCSTR, dwFlags: DWORD): DWORD{.
    stdcall, dynlib: "mpr", importc: "WNetAddConnection2A".}
  #function WNetAddConnection2W(var lpNetResource: TNetResourceW; lpPassword, lpUserName: LPWSTR; dwFlags: DWORD): DWORD; stdcall; external 'mpr' name 'WNetAddConnection2W';
proc WNetAddConnection3*(hwndOwner: HWND, lpNetResource: var TNetResource,
                         lpPassword, lpUserName: cstring, dwFlags: DWORD): DWORD{.
    stdcall, dynlib: "mpr", importc: "WNetAddConnection3A".}
proc WNetAddConnection3A*(hwndOwner: HWND, lpNetResource: var TNetResourceA,
                          lpPassword, lpUserName: LPCSTR, dwFlags: DWORD): DWORD{.
    stdcall, dynlib: "mpr", importc: "WNetAddConnection3A".}
  #function WNetAddConnection3W(hwndOwner: HWND; var lpNetResource: TNetResourceW; lpPassword, lpUserName: LPWSTR; dwFlags: DWORD): DWORD; stdcall; external 'mpr' name 'WNetAddConnection3W';
proc WNetConnectionDialog1*(lpConnDlgStruct: var TConnectDlgStruct): DWORD{.
    stdcall, dynlib: "mpr", importc: "WNetConnectionDialog1A".}
proc WNetConnectionDialog1A*(lpConnDlgStruct: var TConnectDlgStruct): DWORD{.
    stdcall, dynlib: "mpr", importc: "WNetConnectionDialog1A".}
  #function WNetConnectionDialog1W(var lpConnDlgStruct: TConnectDlgStruct): DWORD; stdcall; external 'mpr' name 'WNetConnectionDialog1W';
proc WNetDisconnectDialog1*(lpConnDlgStruct: var TDiscDlgStruct): DWORD{.
    stdcall, dynlib: "mpr", importc: "WNetDisconnectDialog1A".}
proc WNetDisconnectDialog1A*(lpConnDlgStruct: var TDiscDlgStructA): DWORD{.
    stdcall, dynlib: "mpr", importc: "WNetDisconnectDialog1A".}
  #function WNetDisconnectDialog1W(var lpConnDlgStruct: TDiscDlgStructW): DWORD; stdcall; external 'mpr' name 'WNetDisconnectDialog1W';
proc WNetEnumResource*(hEnum: THandle, lpcCount: var DWORD, lpBuffer: Pointer,
                       lpBufferSize: var DWORD): DWORD{.stdcall, dynlib: "mpr",
    importc: "WNetEnumResourceA".}
proc WNetEnumResourceA*(hEnum: THandle, lpcCount: var DWORD, lpBuffer: Pointer,
                        lpBufferSize: var DWORD): DWORD{.stdcall, dynlib: "mpr",
    importc: "WNetEnumResourceA".}
proc WNetEnumResourceW*(hEnum: THandle, lpcCount: var DWORD, lpBuffer: Pointer,
                        lpBufferSize: var DWORD): DWORD{.stdcall, dynlib: "mpr",
    importc: "WNetEnumResourceW".}
proc WNetGetConnection*(lpLocalName: cstring, lpRemoteName: cstring,
                        lpnLength: var DWORD): DWORD{.stdcall, dynlib: "mpr",
    importc: "WNetGetConnectionA".}
proc WNetGetConnectionA*(lpLocalName: LPCSTR, lpRemoteName: LPCSTR,
                         lpnLength: var DWORD): DWORD{.stdcall, dynlib: "mpr",
    importc: "WNetGetConnectionA".}
proc WNetGetConnectionW*(lpLocalName: LPWSTR, lpRemoteName: LPWSTR,
                         lpnLength: var DWORD): DWORD{.stdcall, dynlib: "mpr",
    importc: "WNetGetConnectionW".}
proc WNetGetLastError*(lpError: var DWORD, lpErrorBuf: cstring,
                       nErrorBufSize: DWORD, lpNameBuf: cstring,
                       nNameBufSize: DWORD): DWORD{.stdcall, dynlib: "mpr",
    importc: "WNetGetLastErrorA".}
proc WNetGetLastErrorA*(lpError: var DWORD, lpErrorBuf: LPCSTR,
                        nErrorBufSize: DWORD, lpNameBuf: LPCSTR,
                        nNameBufSize: DWORD): DWORD{.stdcall, dynlib: "mpr",
    importc: "WNetGetLastErrorA".}
proc WNetGetLastErrorW*(lpError: var DWORD, lpErrorBuf: LPWSTR,
                        nErrorBufSize: DWORD, lpNameBuf: LPWSTR,
                        nNameBufSize: DWORD): DWORD{.stdcall, dynlib: "mpr",
    importc: "WNetGetLastErrorW".}
proc WNetGetNetworkInformation*(lpProvider: cstring,
                                lpNetInfoStruct: var TNetInfoStruct): DWORD{.
    stdcall, dynlib: "mpr", importc: "WNetGetNetworkInformationA".}
proc WNetGetNetworkInformationA*(lpProvider: LPCSTR,
                                 lpNetInfoStruct: var TNetInfoStruct): DWORD{.
    stdcall, dynlib: "mpr", importc: "WNetGetNetworkInformationA".}
proc WNetGetNetworkInformationW*(lpProvider: LPWSTR,
                                 lpNetInfoStruct: var TNetInfoStruct): DWORD{.
    stdcall, dynlib: "mpr", importc: "WNetGetNetworkInformationW".}
proc WNetGetProviderName*(dwNetType: DWORD, lpProviderName: cstring,
                          lpBufferSize: var DWORD): DWORD{.stdcall,
    dynlib: "mpr", importc: "WNetGetProviderNameA".}
proc WNetGetProviderNameA*(dwNetType: DWORD, lpProviderName: LPCSTR,
                           lpBufferSize: var DWORD): DWORD{.stdcall,
    dynlib: "mpr", importc: "WNetGetProviderNameA".}
proc WNetGetProviderNameW*(dwNetType: DWORD, lpProviderName: LPWSTR,
                           lpBufferSize: var DWORD): DWORD{.stdcall,
    dynlib: "mpr", importc: "WNetGetProviderNameW".}
proc WNetGetResourceParent*(lpNetResource: PNetResource, lpBuffer: Pointer,
                            cbBuffer: var DWORD): DWORD{.stdcall, dynlib: "mpr",
    importc: "WNetGetResourceParentA".}
proc WNetGetResourceParentA*(lpNetResource: PNetResourceA, lpBuffer: Pointer,
                             cbBuffer: var DWORD): DWORD{.stdcall,
    dynlib: "mpr", importc: "WNetGetResourceParentA".}
  #function WNetGetResourceParentW(lpNetResource: PNetResourceW; lpBuffer: Pointer; var cbBuffer: DWORD): DWORD;stdcall; external 'mpr' name 'WNetGetResourceParentW';
proc WNetGetUniversalName*(lpLocalPath: cstring, dwInfoLevel: DWORD,
                           lpBuffer: Pointer, lpBufferSize: var DWORD): DWORD{.
    stdcall, dynlib: "mpr", importc: "WNetGetUniversalNameA".}
proc WNetGetUniversalNameA*(lpLocalPath: LPCSTR, dwInfoLevel: DWORD,
                            lpBuffer: Pointer, lpBufferSize: var DWORD): DWORD{.
    stdcall, dynlib: "mpr", importc: "WNetGetUniversalNameA".}
proc WNetGetUniversalNameW*(lpLocalPath: LPWSTR, dwInfoLevel: DWORD,
                            lpBuffer: Pointer, lpBufferSize: var DWORD): DWORD{.
    stdcall, dynlib: "mpr", importc: "WNetGetUniversalNameW".}
proc WNetGetUser*(lpName: cstring, lpUserName: cstring, lpnLength: var DWORD): DWORD{.
    stdcall, dynlib: "mpr", importc: "WNetGetUserA".}
proc WNetGetUserA*(lpName: LPCSTR, lpUserName: LPCSTR, lpnLength: var DWORD): DWORD{.
    stdcall, dynlib: "mpr", importc: "WNetGetUserA".}
proc WNetGetUserW*(lpName: LPWSTR, lpUserName: LPWSTR, lpnLength: var DWORD): DWORD{.
    stdcall, dynlib: "mpr", importc: "WNetGetUserW".}
proc WNetOpenEnum*(dwScope, dwType, dwUsage: DWORD, lpNetResource: PNetResource,
                   lphEnum: var THandle): DWORD{.stdcall, dynlib: "mpr",
    importc: "WNetOpenEnumA".}
proc WNetOpenEnumA*(dwScope, dwType, dwUsage: DWORD,
                    lpNetResource: PNetResourceA, lphEnum: var THandle): DWORD{.
    stdcall, dynlib: "mpr", importc: "WNetOpenEnumA".}
  #function WNetOpenEnumW(dwScope, dwType, dwUsage: DWORD; lpNetResource: PNetResourceW; var lphEnum: THandle): DWORD; stdcall; external 'mpr' name 'WNetOpenEnumW';
proc WNetUseConnection*(hwndOwner: HWND, lpNetResource: var TNetResource,
                        lpUserID: cstring, lpPassword: cstring, dwFlags: DWORD,
                        lpAccessName: cstring, lpBufferSize: var DWORD,
                        lpResult: var DWORD): DWORD{.stdcall, dynlib: "mpr",
    importc: "WNetUseConnectionA".}
proc WNetUseConnectionA*(hwndOwner: HWND, lpNetResource: var TNetResourceA,
                         lpUserID: LPCSTR, lpPassword: LPCSTR, dwFlags: DWORD,
                         lpAccessName: LPCSTR, lpBufferSize: var DWORD,
                         lpResult: var DWORD): DWORD{.stdcall, dynlib: "mpr",
    importc: "WNetUseConnectionA".}
  #function WNetUseConnectionW(hwndOwner: HWND; var lpNetResource: TNetResourceW; lpUserID: LPWSTR; lpPassword: LPWSTR; dwFlags: DWORD; lpAccessName: LPWSTR; var lpBufferSize: DWORD; var lpResult: DWORD): DWORD; stdcall; external 'mpr' name 'WNetUseConnectionW';
proc WriteConsole*(hConsoleOutput: THandle, lpBuffer: Pointer,
                   nNumberOfCharsToWrite: DWORD,
                   lpNumberOfCharsWritten: var DWORD, lpReserved: Pointer): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "WriteConsoleA".}
proc WriteConsoleA*(hConsoleOutput: THandle, lpBuffer: Pointer,
                    nNumberOfCharsToWrite: DWORD,
                    lpNumberOfCharsWritten: var DWORD, lpReserved: Pointer): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "WriteConsoleA".}
proc WriteConsoleInput*(hConsoleInput: THandle, lpBuffer: TInputRecord,
                        nLength: DWORD, lpNumberOfEventsWritten: var DWORD): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "WriteConsoleInputA".}
proc WriteConsoleInputA*(hConsoleInput: THandle, lpBuffer: TInputRecord,
                         nLength: DWORD, lpNumberOfEventsWritten: var DWORD): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "WriteConsoleInputA".}
proc WriteConsoleInputW*(hConsoleInput: THandle, lpBuffer: TInputRecord,
                         nLength: DWORD, lpNumberOfEventsWritten: var DWORD): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "WriteConsoleInputW".}
proc WriteConsoleOutput*(hConsoleOutput: THandle, lpBuffer: Pointer,
                         dwBufferSize, dwBufferCoord: TCoord,
                         lpWriteRegion: var TSmallRect): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "WriteConsoleOutputA".}
proc WriteConsoleOutputA*(hConsoleOutput: THandle, lpBuffer: Pointer,
                          dwBufferSize, dwBufferCoord: TCoord,
                          lpWriteRegion: var TSmallRect): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "WriteConsoleOutputA".}
proc WriteConsoleOutputAttribute*(hConsoleOutput: THandle, lpAttribute: Pointer,
                                  nLength: DWORD, dwWriteCoord: TCoord,
                                  lpNumberOfAttrsWritten: var DWORD): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "WriteConsoleOutputAttribute".}
proc WriteConsoleOutputCharacter*(hConsoleOutput: THandle, lpCharacter: cstring,
                                  nLength: DWORD, dwWriteCoord: TCoord,
                                  lpNumberOfCharsWritten: var DWORD): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "WriteConsoleOutputCharacterA".}
proc WriteConsoleOutputCharacterA*(hConsoleOutput: THandle, lpCharacter: LPCSTR,
                                   nLength: DWORD, dwWriteCoord: TCoord,
                                   lpNumberOfCharsWritten: var DWORD): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "WriteConsoleOutputCharacterA".}
proc WriteConsoleOutputCharacterW*(hConsoleOutput: THandle, lpCharacter: LPWSTR,
                                   nLength: DWORD, dwWriteCoord: TCoord,
                                   lpNumberOfCharsWritten: var DWORD): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "WriteConsoleOutputCharacterW".}
proc WriteConsoleOutputW*(hConsoleOutput: THandle, lpBuffer: Pointer,
                          dwBufferSize, dwBufferCoord: TCoord,
                          lpWriteRegion: var TSmallRect): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "WriteConsoleOutputW".}
proc WriteConsoleW*(hConsoleOutput: THandle, lpBuffer: Pointer,
                    nNumberOfCharsToWrite: DWORD,
                    lpNumberOfCharsWritten: var DWORD, lpReserved: Pointer): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "WriteConsoleW".}
proc WriteFile*(hFile: THandle, Buffer: pointer, nNumberOfBytesToWrite: DWORD,
                lpNumberOfBytesWritten: var DWORD, lpOverlapped: POverlapped): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "WriteFile".}
proc WriteFileEx*(hFile: THandle, lpBuffer: Pointer,
                  nNumberOfBytesToWrite: DWORD, lpOverlapped: TOverlapped,
                  lpCompletionRoutine: FARPROC): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "WriteFileEx".}
proc WritePrivateProfileStructA*(lpszSection, lpszKey: LPCSTR, lpStruct: LPVOID,
                                 uSizeStruct: UINT, szFile: LPCSTR): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "WritePrivateProfileStructA".}
proc WritePrivateProfileStructW*(lpszSection, lpszKey: LPCWSTR,
                                 lpStruct: LPVOID, uSizeStruct: UINT,
                                 szFile: LPCWSTR): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "WritePrivateProfileStructW".}
proc WritePrivateProfileStruct*(lpszSection, lpszKey: LPCTSTR, lpStruct: LPVOID,
                                uSizeStruct: UINT, szFile: LPCTSTR): WINBOOL{.
    stdcall, dynlib: "kernel32", importc: "WritePrivateProfileStructA".}
proc WriteProcessMemory*(hProcess: THandle, lpBaseAddress: Pointer,
                         lpBuffer: Pointer, nSize: DWORD,
                         lpNumberOfBytesWritten: var DWORD): WINBOOL{.stdcall,
    dynlib: "kernel32", importc: "WriteProcessMemory".}
proc SHFileOperation*(para1: var SHFILEOPSTRUCT): int32{.stdcall,
    dynlib: "shell32", importc: "SHFileOperation".}

  # these are old Win16 funcs that under win32 are aliases for several char* funcs.
# exist under Win32 (even in SDK's from 2002), but are officially "deprecated"
proc AnsiNext*(lpsz: LPCSTR): LPSTR{.stdcall, dynlib: "user32",
                                     importc: "CharNextA".}
proc AnsiPrev*(lpszStart: LPCSTR, lpszCurrent: LPCSTR): LPSTR{.stdcall,
    dynlib: "user32", importc: "CharPrevA".}
proc AnsiToOem*(lpszSrc: LPCSTR, lpszDst: LPSTR): WINBOOL{.stdcall,
    dynlib: "user32", importc: "CharToOemA".}
proc OemToAnsi*(lpszSrc: LPCSTR, lpszDst: LPSTR): WINBOOL{.stdcall,
    dynlib: "user32", importc: "OemToCharA".}
proc AnsiToOemBuff*(lpszSrc: LPCSTR, lpszDst: LPSTR, cchDstLength: DWORD): WINBOOL{.
    stdcall, dynlib: "user32", importc: "CharToOemBuffA".}
proc OemToAnsiBuff*(lpszSrc: LPCSTR, lpszDst: LPSTR, cchDstLength: DWORD): WINBOOL{.
    stdcall, dynlib: "user32", importc: "OemToCharBuffA".}
proc AnsiUpper*(lpsz: LPSTR): LPSTR{.stdcall, dynlib: "user32",
                                     importc: "CharUpperA".}
proc AnsiUpperBuff*(lpsz: LPSTR, cchLength: DWORD): DWORD{.stdcall,
    dynlib: "user32", importc: "CharUpperBuffA".}
proc AnsiLower*(lpsz: LPSTR): LPSTR{.stdcall, dynlib: "user32",
                                     importc: "CharLowerA".}
proc AnsiLowerBuff*(lpsz: LPSTR, cchLength: DWORD): DWORD{.stdcall,
    dynlib: "user32", importc: "CharLowerBuffA".}

#== Implementation of macros

# WinBase.h

proc FreeModule*(h: HINST): WINBOOL =
  result = FreeLibrary(h)

proc MakeProcInstance*(p, i: pointer): pointer =
  result = p

proc FreeProcInstance*(p: pointer): pointer =
  result = p

proc GlobalDiscard*(hglbMem: HGLOBAL): HGLOBAL =
  result = GlobalReAlloc(hglbMem, 0, GMEM_MOVEABLE)

proc LocalDiscard*(hlocMem: HLOCAL): HLOCAL =
  result = LocalReAlloc(hlocMem, 0, LMEM_MOVEABLE)

# WinGDI.h

proc GetGValue*(rgb: int32): int8 =
  result = toU8(rgb shr 8'i32)
proc RGB*(r, g, b: int): COLORREF =
  result = toU32(r) or (toU32(g) shl 8) or (toU32(b) shl 16)
proc RGB*(r, g, b: range[0 .. 255]): COLORREF =
  result = r or g shl 8 or b shl 16

proc PALETTERGB*(r, g, b: range[0..255]): COLORREF =
  result = 0x02000000 or RGB(r, g, b)

proc PALETTEINDEX*(i: DWORD): COLORREF =
  result = COLORREF(0x01000000'i32 or i and 0xffff'i32)


proc GetRValue*(rgb: COLORREF): int8 =
  result = toU8(rgb)

proc GetGValue*(rgb: COLORREF): int8 =
  result = toU8(rgb shr 8)

proc GetBValue*(rgb: COLORREF): int8 =
  result = toU8(rgb shr 16)

#

proc HIBYTE*(w: int32): int8 =
  result = toU8(w shr 8'i32 and 0x000000FF'i32)

proc HIWORD*(L: int32): int16 =
  result = toU16(L shr 16'i32 and 0x0000FFFF'i32)

proc LOBYTE*(w: int32): int8 =
  result = toU8(w)

proc LOWORD*(L: int32): int16 =
  result = toU16(L)

proc MAKELONG*(a, b: int32): LONG =
  result = a and 0x0000ffff'i32 or b shl 16'i32

proc MAKEWORD*(a, b: int32): int16 =
  result = toU16(a and 0xff'i32) or toU16(b shl 8'i32)

proc SEXT_HIWORD*(L: int32): int32 =
  # return type might be wrong
  result = HIWORD(L)

proc ZEXT_HIWORD*(L: int32): int32 =
  # return type might be wrong
  result = HIWORD(L) and 0xffff'i32

proc SEXT_LOWORD*(L: int32): int32 =
  result = LOWORD(L)

proc INDEXTOOVERLAYMASK*(i: int32): int32 =
  # return type might be wrong
  result = i shl 8'i32

proc INDEXTOSTATEIMAGEMASK*(i: int32): int32 =
  # return type might be wrong
  result = i shl 12'i32

proc MAKEINTATOM*(i: int32): LPTSTR =
  result = cast[LPTSTR](cast[ULONG_PTR](ToU16(i)))

proc MAKELANGID*(p, s: int32): int32 =
  # return type might be wrong
  result = toU16(s) shl 10'i16 or toU16(p)

proc PRIMARYLANGID*(lgid: int32): int16 =
  result = toU16(lgid) and 0x000003FF'i16

proc SUBLANGID*(lgid: int32): int32 =
  # return type might be wrong
  result = toU16(lgid) shr 10'i16

proc MAKELCID*(lgid, srtid: int32): DWORD =
  result = toU32(srtid shl 16'i32 or lgid and 0xffff'i32)

proc MAKELPARAM*(L, h: int32): LPARAM =
  result = LPARAM(MAKELONG(L, h))

proc MAKELRESULT*(L, h: int32): LRESULT =
  result = LRESULT(MAKELONG(L, h))

proc MAKEROP4*(fore, back: int32): DWORD =
  result = back shl 8'i32 and 0xFF000000'i32 or fore

proc MAKEWPARAM*(L, h: int32): WPARAM =
  result = WPARAM(MAKELONG(L, h))

proc GET_X_LPARAM*(lp: Windows.LParam): int32 =
  result = LOWORD(lp.int32)

proc GET_Y_LPARAM*(lp: Windows.LParam): int32 =
  result = HIWORD(lp.int32)

proc UNICODE_NULL*(): WCHAR =
  result = 0'u16



proc GetFirstChild*(h: HWND): HWND =
  result = GetTopWindow(h)

proc GetNextSibling*(h: HWND): HWND =
  result = GetWindow(h, GW_HWNDNEXT)

proc GetWindowID*(h: HWND): int32 =
  result = GetDlgCtrlID(h)

proc SubclassWindow*(h: HWND, p: LONG): LONG =
  result = SetWindowLong(h, GWL_WNDPROC, p)

proc GET_WM_COMMAND_CMD*(w, L: int32): int32 =
  # return type might be wrong
  result = HIWORD(w)

proc GET_WM_COMMAND_ID(w, L: int32): int32 =
  # return type might be wrong
  result = LOWORD(w)

proc GET_WM_CTLCOLOR_HDC(w, L, msg: int32): HDC =
  result = HDC(w)

proc GET_WM_CTLCOLOR_HWND(w, L, msg: int32): HWND =
  result = HWND(L)

proc GET_WM_HSCROLL_CODE(w, L: int32): int32 =
  # return type might be wrong
  result = LOWORD(w)

proc GET_WM_HSCROLL_HWND(w, L: int32): HWND =
  result = HWND(L)

proc GET_WM_HSCROLL_POS(w, L: int32): int32 =
  # return type might be wrong
  result = HIWORD(w)

proc GET_WM_MDIACTIVATE_FACTIVATE(h, a, b: int32): int32 =
  # return type might be wrong
  result = ord(b == h)

proc GET_WM_MDIACTIVATE_HWNDACTIVATE(a, b: int32): HWND =
  result = HWND(b)

proc GET_WM_MDIACTIVATE_HWNDDEACT(a, b: int32): HWND =
  result = HWND(a)

proc GET_WM_VSCROLL_CODE(w, L: int32): int32 =
  # return type might be wrong
  result = LOWORD(w)

proc GET_WM_VSCROLL_HWND(w, L: int32): HWND =
  result = HWND(L)

proc GET_WM_VSCROLL_POS(w, L: int32): int32 =
  # return type might be wrong
  result = HIWORD(w)

proc fBinary(a: var DCB): DWORD =
  result = (a.flags and bm_DCB_fBinary) shr bp_DCB_fBinary

proc set_fBinary(a: var DCB, fBinary: DWORD) =
  a.flags = a.flags or ((fBinary shl bp_DCB_fBinary) and bm_DCB_fBinary)

proc fParity(a: var DCB): DWORD =
  result = (a.flags and bm_DCB_fParity) shr bp_DCB_fParity

proc set_fParity(a: var DCB, fParity: DWORD) =
  a.flags = a.flags or ((fParity shl bp_DCB_fParity) and bm_DCB_fParity)

proc fOutxCtsFlow(a: var DCB): DWORD =
  result = (a.flags and bm_DCB_fOutxCtsFlow) shr bp_DCB_fOutxCtsFlow

proc set_fOutxCtsFlow(a: var DCB, fOutxCtsFlow: DWORD) =
  a.flags = a.flags or
      ((fOutxCtsFlow shl bp_DCB_fOutxCtsFlow) and bm_DCB_fOutxCtsFlow)

proc fOutxDsrFlow(a: var DCB): DWORD =
  result = (a.flags and bm_DCB_fOutxDsrFlow) shr bp_DCB_fOutxDsrFlow

proc set_fOutxDsrFlow(a: var DCB, fOutxDsrFlow: DWORD) =
  a.flags = a.flags or
      ((fOutxDsrFlow shl bp_DCB_fOutxDsrFlow) and bm_DCB_fOutxDsrFlow)

proc fDtrControl(a: var DCB): DWORD =
  result = (a.flags and bm_DCB_fDtrControl) shr bp_DCB_fDtrControl

proc set_fDtrControl(a: var DCB, fDtrControl: DWORD) =
  a.flags = a.flags or
      ((fDtrControl shl bp_DCB_fDtrControl) and bm_DCB_fDtrControl)

proc fDsrSensitivity(a: var DCB): DWORD =
  result = (a.flags and bm_DCB_fDsrSensitivity) shr bp_DCB_fDsrSensitivity

proc set_fDsrSensitivity(a: var DCB, fDsrSensitivity: DWORD) =
  a.flags = a.flags or
      ((fDsrSensitivity shl bp_DCB_fDsrSensitivity) and
      bm_DCB_fDsrSensitivity)

proc fTXContinueOnXoff(a: var DCB): DWORD =
  result = (a.flags and bm_DCB_fTXContinueOnXoff) shr
      bp_DCB_fTXContinueOnXoff

proc set_fTXContinueOnXoff(a: var DCB, fTXContinueOnXoff: DWORD) =
  a.flags = a.flags or
      ((fTXContinueOnXoff shl bp_DCB_fTXContinueOnXoff) and
      bm_DCB_fTXContinueOnXoff)

proc fOutX(a: var DCB): DWORD =
  result = (a.flags and bm_DCB_fOutX) shr bp_DCB_fOutX

proc set_fOutX(a: var DCB, fOutX: DWORD) =
  a.flags = a.flags or ((fOutX shl bp_DCB_fOutX) and bm_DCB_fOutX)

proc fInX(a: var DCB): DWORD =
  result = (a.flags and bm_DCB_fInX) shr bp_DCB_fInX

proc set_fInX(a: var DCB, fInX: DWORD) =
  a.flags = a.flags or ((fInX shl bp_DCB_fInX) and bm_DCB_fInX)

proc fErrorChar(a: var DCB): DWORD =
  result = (a.flags and bm_DCB_fErrorChar) shr bp_DCB_fErrorChar

proc set_fErrorChar(a: var DCB, fErrorChar: DWORD) =
  a.flags = a.flags or
      ((fErrorChar shl bp_DCB_fErrorChar) and bm_DCB_fErrorChar)

proc fNull(a: var DCB): DWORD =
  result = (a.flags and bm_DCB_fNull) shr bp_DCB_fNull

proc set_fNull(a: var DCB, fNull: DWORD) =
  a.flags = a.flags or ((fNull shl bp_DCB_fNull) and bm_DCB_fNull)

proc fRtsControl(a: var DCB): DWORD =
  result = (a.flags and bm_DCB_fRtsControl) shr bp_DCB_fRtsControl

proc set_fRtsControl(a: var DCB, fRtsControl: DWORD) =
  a.flags = a.flags or
      ((fRtsControl shl bp_DCB_fRtsControl) and bm_DCB_fRtsControl)

proc fAbortOnError(a: var DCB): DWORD =
  result = (a.flags and bm_DCB_fAbortOnError) shr bp_DCB_fAbortOnError

proc set_fAbortOnError(a: var DCB, fAbortOnError: DWORD) =
  a.flags = a.flags or
      ((fAbortOnError shl bp_DCB_fAbortOnError) and bm_DCB_fAbortOnError)

proc fDummy2(a: var DCB): DWORD =
  result = (a.flags and bm_DCB_fDummy2) shr bp_DCB_fDummy2

proc set_fDummy2(a: var DCB, fDummy2: DWORD) =
  a.flags = a.flags or ((fDummy2 shl bp_DCB_fDummy2) and bm_DCB_fDummy2)

proc fCtsHold(a: var COMSTAT): DWORD =
  result = (a.flag0 and bm_COMSTAT_fCtsHold) shr bp_COMSTAT_fCtsHold

proc set_fCtsHold(a: var COMSTAT, fCtsHold: DWORD) =
  a.flag0 = a.flag0 or
      ((fCtsHold shl bp_COMSTAT_fCtsHold) and bm_COMSTAT_fCtsHold)

proc fDsrHold(a: var COMSTAT): DWORD =
  result = (a.flag0 and bm_COMSTAT_fDsrHold) shr bp_COMSTAT_fDsrHold

proc set_fDsrHold(a: var COMSTAT, fDsrHold: DWORD) =
  a.flag0 = a.flag0 or
      ((fDsrHold shl bp_COMSTAT_fDsrHold) and bm_COMSTAT_fDsrHold)

proc fRlsdHold(a: var COMSTAT): DWORD =
  result = (a.flag0 and bm_COMSTAT_fRlsdHold) shr bp_COMSTAT_fRlsdHold

proc set_fRlsdHold(a: var COMSTAT, fRlsdHold: DWORD) =
  a.flag0 = a.flag0 or
      ((fRlsdHold shl bp_COMSTAT_fRlsdHold) and bm_COMSTAT_fRlsdHold)

proc fXoffHold(a: var COMSTAT): DWORD =
  result = (a.flag0 and bm_COMSTAT_fXoffHold) shr bp_COMSTAT_fXoffHold

proc set_fXoffHold(a: var COMSTAT, fXoffHold: DWORD) =
  a.flag0 = a.flag0 or
      ((fXoffHold shl bp_COMSTAT_fXoffHold) and bm_COMSTAT_fXoffHold)

proc fXoffSent(a: var COMSTAT): DWORD =
  result = (a.flag0 and bm_COMSTAT_fXoffSent) shr bp_COMSTAT_fXoffSent

proc set_fXoffSent(a: var COMSTAT, fXoffSent: DWORD) =
  a.flag0 = a.flag0 or
      ((fXoffSent shl bp_COMSTAT_fXoffSent) and bm_COMSTAT_fXoffSent)

proc fEof(a: var COMSTAT): DWORD =
  result = (a.flag0 and bm_COMSTAT_fEof) shr bp_COMSTAT_fEof

proc set_fEof(a: var COMSTAT, fEof: DWORD) =
  a.flag0 = a.flag0 or ((fEof shl bp_COMSTAT_fEof) and bm_COMSTAT_fEof)

proc fTxim(a: var COMSTAT): DWORD =
  result = (a.flag0 and bm_COMSTAT_fTxim) shr bp_COMSTAT_fTxim

proc set_fTxim(a: var COMSTAT, fTxim: DWORD) =
  a.flag0 = a.flag0 or ((fTxim shl bp_COMSTAT_fTxim) and bm_COMSTAT_fTxim)

proc fReserved(a: var COMSTAT): DWORD =
  result = (a.flag0 and bm_COMSTAT_fReserved) shr bp_COMSTAT_fReserved

proc set_fReserved(a: var COMSTAT, fReserved: DWORD) =
  a.flag0 = a.flag0 or
      ((fReserved shl bp_COMSTAT_fReserved) and bm_COMSTAT_fReserved)

proc bAppReturnCode(a: var DDEACK): int16 =
  result = (a.flag0 and bm_DDEACK_bAppReturnCode) shr
      bp_DDEACK_bAppReturnCode

proc set_bAppReturnCode(a: var DDEACK, bAppReturnCode: int16) =
  a.flag0 = a.flag0 or
      ((bAppReturnCode shl bp_DDEACK_bAppReturnCode) and
      bm_DDEACK_bAppReturnCode)

proc reserved(a: var DDEACK): int16 =
  result = (a.flag0 and bm_DDEACK_reserved) shr bp_DDEACK_reserved

proc set_reserved(a: var DDEACK, reserved: int16) =
  a.flag0 = a.flag0 or
      ((reserved shl bp_DDEACK_reserved) and bm_DDEACK_reserved)

proc fBusy(a: var DDEACK): int16 =
  result = (a.flag0 and bm_DDEACK_fBusy) shr bp_DDEACK_fBusy

proc set_fBusy(a: var DDEACK, fBusy: int16) =
  a.flag0 = a.flag0 or ((fBusy shl bp_DDEACK_fBusy) and bm_DDEACK_fBusy)

proc fAck(a: var DDEACK): int16 =
  result = (a.flag0 and bm_DDEACK_fAck) shr bp_DDEACK_fAck

proc set_fAck(a: var DDEACK, fAck: int16) =
  a.flag0 = a.flag0 or ((fAck shl bp_DDEACK_fAck) and bm_DDEACK_fAck)

proc reserved(a: var DDEADVISE): int16 =
  result = (a.flag0 and bm_DDEADVISE_reserved) shr bp_DDEADVISE_reserved

proc set_reserved(a: var DDEADVISE, reserved: int16) =
  a.flag0 = a.flag0 or
      ((reserved shl bp_DDEADVISE_reserved) and bm_DDEADVISE_reserved)

proc fDeferUpd(a: var DDEADVISE): int16 =
  result = (a.flag0 and bm_DDEADVISE_fDeferUpd) shr bp_DDEADVISE_fDeferUpd

proc set_fDeferUpd(a: var DDEADVISE, fDeferUpd: int16) =
  a.flag0 = a.flag0 or
      ((fDeferUpd shl bp_DDEADVISE_fDeferUpd) and bm_DDEADVISE_fDeferUpd)

proc fAckReq(a: var DDEADVISE): int16 =
  result = (a.flag0 and bm_DDEADVISE_fAckReq) shr bp_DDEADVISE_fAckReq

proc set_fAckReq(a: var DDEADVISE, fAckReq: int16) =
  a.flag0 = a.flag0 or
      ((fAckReq shl bp_DDEADVISE_fAckReq) and bm_DDEADVISE_fAckReq)

proc unused(a: var DDEDATA): int16 =
  result = (a.flag0 and bm_DDEDATA_unused) shr bp_DDEDATA_unused

proc set_unused(a: var DDEDATA, unused: int16) =
  a.flag0 = a.flag0 or ((unused shl bp_DDEDATA_unused) and bm_DDEDATA_unused)

proc fResponse(a: var DDEDATA): int16 =
  result = (a.flag0 and bm_DDEDATA_fResponse) shr bp_DDEDATA_fResponse

proc set_fResponse(a: var DDEDATA, fResponse: int16) =
  a.flag0 = a.flag0 or
      ((fResponse shl bp_DDEDATA_fResponse) and bm_DDEDATA_fResponse)

proc fRelease(a: var DDEDATA): int16 =
  result = (a.flag0 and bm_DDEDATA_fRelease) shr bp_DDEDATA_fRelease

proc set_fRelease(a: var DDEDATA, fRelease: int16) =
  a.flag0 = a.flag0 or
      ((fRelease shl bp_DDEDATA_fRelease) and bm_DDEDATA_fRelease)

proc reserved(a: var DDEDATA): int16 =
  result = (a.flag0 and bm_DDEDATA_reserved) shr bp_DDEDATA_reserved

proc set_reserved(a: var DDEDATA, reserved: int16) =
  a.flag0 = a.flag0 or
      ((reserved shl bp_DDEDATA_reserved) and bm_DDEDATA_reserved)

proc fAckReq(a: var DDEDATA): int16 =
  result = (a.flag0 and bm_DDEDATA_fAckReq) shr bp_DDEDATA_fAckReq

proc set_fAckReq(a: var DDEDATA, fAckReq: int16) =
  a.flag0 = a.flag0 or
      ((fAckReq shl bp_DDEDATA_fAckReq) and bm_DDEDATA_fAckReq)

proc unused(a: var DDELN): int16 =
  result = (a.flag0 and bm_DDELN_unused) shr bp_DDELN_unused

proc set_unused(a: var DDELN, unused: int16) =
  a.flag0 = a.flag0 or ((unused shl bp_DDELN_unused) and bm_DDELN_unused)

proc fRelease(a: var DDELN): int16 =
  result = (a.flag0 and bm_DDELN_fRelease) shr bp_DDELN_fRelease

proc set_fRelease(a: var DDELN, fRelease: int16) =
  a.flag0 = a.flag0 or
      ((fRelease shl bp_DDELN_fRelease) and bm_DDELN_fRelease)

proc fDeferUpd(a: var DDELN): int16 =
  result = (a.flag0 and bm_DDELN_fDeferUpd) shr bp_DDELN_fDeferUpd

proc set_fDeferUpd(a: var DDELN, fDeferUpd: int16) =
  a.flag0 = a.flag0 or
      ((fDeferUpd shl bp_DDELN_fDeferUpd) and bm_DDELN_fDeferUpd)

proc fAckReq(a: var DDELN): int16 =
  result = (a.flag0 and bm_DDELN_fAckReq) shr bp_DDELN_fAckReq

proc set_fAckReq(a: var DDELN, fAckReq: int16) =
  a.flag0 = a.flag0 or ((fAckReq shl bp_DDELN_fAckReq) and bm_DDELN_fAckReq)

proc unused(a: var DDEPOKE): int16 =
  result = (a.flag0 and bm_DDEPOKE_unused) shr bp_DDEPOKE_unused

proc set_unused(a: var DDEPOKE, unused: int16) =
  a.flag0 = a.flag0 or ((unused shl bp_DDEPOKE_unused) and bm_DDEPOKE_unused)

proc fRelease(a: var DDEPOKE): int16 =
  result = (a.flag0 and bm_DDEPOKE_fRelease) shr bp_DDEPOKE_fRelease

proc set_fRelease(a: var DDEPOKE, fRelease: int16) =
  a.flag0 = a.flag0 or
      ((fRelease shl bp_DDEPOKE_fRelease) and bm_DDEPOKE_fRelease)

proc fReserved(a: var DDEPOKE): int16 =
  result = (a.flag0 and bm_DDEPOKE_fReserved) shr bp_DDEPOKE_fReserved

proc set_fReserved(a: var DDEPOKE, fReserved: int16) =
  a.flag0 = a.flag0 or
      ((fReserved shl bp_DDEPOKE_fReserved) and bm_DDEPOKE_fReserved)

proc unused(a: var DDEUP): int16 =
  result = (a.flag0 and bm_DDEUP_unused) shr bp_DDEUP_unused

proc set_unused(a: var DDEUP, unused: int16) =
  a.flag0 = a.flag0 or ((unused shl bp_DDEUP_unused) and bm_DDEUP_unused)

proc fAck(a: var DDEUP): int16 =
  result = (a.flag0 and bm_DDEUP_fAck) shr bp_DDEUP_fAck

proc set_fAck(a: var DDEUP, fAck: int16) =
  a.flag0 = a.flag0 or ((fAck shl bp_DDEUP_fAck) and bm_DDEUP_fAck)

proc fRelease(a: var DDEUP): int16 =
  result = (a.flag0 and bm_DDEUP_fRelease) shr bp_DDEUP_fRelease

proc set_fRelease(a: var DDEUP, fRelease: int16) =
  a.flag0 = a.flag0 or
      ((fRelease shl bp_DDEUP_fRelease) and bm_DDEUP_fRelease)

proc fReserved(a: var DDEUP): int16 =
  result = (a.flag0 and bm_DDEUP_fReserved) shr bp_DDEUP_fReserved

proc set_fReserved(a: var DDEUP, fReserved: int16) =
  a.flag0 = a.flag0 or
      ((fReserved shl bp_DDEUP_fReserved) and bm_DDEUP_fReserved)

proc fAckReq(a: var DDEUP): int16 =
  result = (a.flag0 and bm_DDEUP_fAckReq) shr bp_DDEUP_fAckReq

proc set_fAckReq(a: var DDEUP, fAckReq: int16) =
  a.flag0 = a.flag0 or ((fAckReq shl bp_DDEUP_fAckReq) and bm_DDEUP_fAckReq)

proc CreateWindowA(lpClassName: LPCSTR, lpWindowName: LPCSTR, dwStyle: DWORD,
                   X: int32, Y: int32, nWidth: int32, nHeight: int32,
                   hWndParent: HWND, menu: HMENU, hInstance: HINST,
                   lpParam: LPVOID): HWND =
  result = CreateWindowExA(0, lpClassName, lpWindowName, dwStyle, x, y, nWidth,
                           nHeight, hWndParent, menu, hInstance, lpParam)

proc CreateDialogA(hInstance: HINST, lpTemplateName: LPCSTR, hWndParent: HWND,
                   lpDialogFunc: DLGPROC): HWND =
  result = CreateDialogParamA(hInstance, lpTemplateName, hWndParent,
                              lpDialogFunc, 0)

proc CreateDialogIndirectA(hInstance: HINST, lpTemplate: LPCDLGTEMPLATE,
                           hWndParent: HWND, lpDialogFunc: DLGPROC): HWND =
  result = CreateDialogIndirectParamA(hInstance, lpTemplate, hWndParent,
                                      lpDialogFunc, 0)

proc DialogBoxA(hInstance: HINST, lpTemplateName: LPCSTR, hWndParent: HWND,
                lpDialogFunc: DLGPROC): int32 =
  result = DialogBoxParamA(hInstance, lpTemplateName, hWndParent, lpDialogFunc,
                           0)

proc DialogBoxIndirectA(hInstance: HINST, hDialogTemplate: LPCDLGTEMPLATE,
                        hWndParent: HWND, lpDialogFunc: DLGPROC): int32 =
  result = DialogBoxIndirectParamA(hInstance, hDialogTemplate, hWndParent,
                                   lpDialogFunc, 0)

proc CreateWindowW(lpClassName: LPCWSTR, lpWindowName: LPCWSTR, dwStyle: DWORD,
                   X: int32, Y: int32, nWidth: int32, nHeight: int32,
                   hWndParent: HWND, menu: HMENU, hInstance: HINST,
                   lpParam: LPVOID): HWND =
  result = CreateWindowExW(0, lpClassName, lpWindowName, dwStyle, x, y, nWidth,
                           nHeight, hWndParent, menu, hInstance, lpParam)

proc CreateDialogW(hInstance: HINST, lpName: LPCWSTR, hWndParent: HWND,
                   lpDialogFunc: DLGPROC): HWND =
  result = CreateDialogParamW(hInstance, lpName, hWndParent, lpDialogFunc, 0)

proc CreateDialogIndirectW(hInstance: HINST, lpTemplate: LPCDLGTEMPLATE,
                           hWndParent: HWND, lpDialogFunc: DLGPROC): HWND =
  result = CreateDialogIndirectParamW(hInstance, lpTemplate, hWndParent,
                                      lpDialogFunc, 0)

proc DialogBoxW(hInstance: HINST, lpTemplate: LPCWSTR, hWndParent: HWND,
                lpDialogFunc: DLGPROC): int32 =
  result = DialogBoxParamW(hInstance, lpTemplate, hWndParent, lpDialogFunc, 0)

proc DialogBoxIndirectW(hInstance: HINST, lpTemplate: LPCDLGTEMPLATE,
                        hWndParent: HWND, lpDialogFunc: DLGPROC): int32 =
  result = DialogBoxIndirectParamW(hInstance, lpTemplate, hWndParent,
                                   lpDialogFunc, 0)

when defined(winUnicode):
  proc CreateWindow(lpClassName: LPCWSTR, lpWindowName: LPCWSTR, dwStyle: DWORD,
                    X: int32, Y: int32, nWidth: int32, nHeight: int32,
                    hWndParent: HWND, menu: HMENU, hInstance: HINST,
                    lpParam: LPVOID): HWND =
    result = CreateWindowEx(0, lpClassName, lpWindowName, dwStyle, x, y, nWidth,
                            nHeight, hWndParent, hMenu, hInstance, lpParam)

  proc CreateDialog(hInstance: HINST, lpName: LPCWSTR, hWndParent: HWND,
                    lpDialogFunc: DLGPROC): HWND =
    result = CreateDialogParam(hInstance, lpName, hWndParent, lpDialogFunc, 0)

  proc CreateDialogIndirect(hInstance: HINST, lpTemplate: LPCDLGTEMPLATE,
                            hWndParent: HWND, lpDialogFunc: DLGPROC): HWND =
    result = CreateDialogIndirectParam(hInstance, lpTemplate, hWndParent,
                                       lpDialogFunc, 0)

  proc DialogBox(hInstance: HINST, lpTemplate: LPCWSTR, hWndParent: HWND,
                 lpDialogFunc: DLGPROC): int32 =
    result = DialogBoxParam(hInstance, lpTemplate, hWndParent, lpDialogFunc, 0)

  proc DialogBoxIndirect(hInstance: HINST, lpTemplate: LPCDLGTEMPLATE,
                         hWndParent: HWND, lpDialogFunc: DLGPROC): int32 =
    result = DialogBoxIndirectParam(hInstance, lpTemplate, hWndParent,
                                    lpDialogFunc, 0)

else:
  proc CreateWindow(lpClassName: LPCSTR, lpWindowName: LPCSTR, dwStyle: DWORD,
                    X: int32, Y: int32, nWidth: int32, nHeight: int32,
                    hWndParent: HWND, menu: HMENU, hInstance: HINST,
                    lpParam: LPVOID): HWND =
    result = CreateWindowEx(0, lpClassName, lpWindowName, dwStyle, x, y, nWidth,
                            nHeight, hWndParent, menu, hInstance, lpParam)

  proc CreateDialog(hInstance: HINST, lpTemplateName: LPCSTR, hWndParent: HWND,
                    lpDialogFunc: DLGPROC): HWND =
    result = CreateDialogParam(hInstance, lpTemplateName, hWndParent,
                               lpDialogFunc, 0)

  proc CreateDialogIndirect(hInstance: HINST, lpTemplate: LPCDLGTEMPLATE,
                            hWndParent: HWND, lpDialogFunc: DLGPROC): HWND =
    result = CreateDialogIndirectParam(hInstance, lpTemplate, hWndParent,
                                       lpDialogFunc, 0)

  proc DialogBox(hInstance: HINST, lpTemplateName: LPCSTR, hWndParent: HWND,
                 lpDialogFunc: DLGPROC): int32 =
    result = DialogBoxParam(hInstance, lpTemplateName, hWndParent, lpDialogFunc,
                            0)

  proc DialogBoxIndirect(hInstance: HINST, hDialogTemplate: LPCDLGTEMPLATE,
                         hWndParent: HWND, lpDialogFunc: DLGPROC): int32 =
    result = DialogBoxIndirectParam(hInstance, hDialogTemplate, hWndParent,
                                    lpDialogFunc, 0)

proc GlobalAllocPtr(flags, cb: DWord): Pointer =
  result = GlobalLock(GlobalAlloc(flags, cb))

proc GlobalFreePtr(lp: Pointer): Pointer =
  result = cast[Pointer](GlobalFree(cast[HWND](GlobalUnlockPtr(lp))))

proc GlobalUnlockPtr(lp: pointer): Pointer =
  discard GlobalUnlock(GlobalHandle(lp))
  result = lp

proc GlobalLockPtr(lp: pointer): Pointer =
  result = GlobalLock(GlobalHandle(lp))

proc GlobalReAllocPtr(lp: Pointer, cbNew, flags: DWord): Pointer =
  result = GlobalLock(GlobalReAlloc(cast[HWND](GlobalUnlockPtr(lp)), cbNew, flags))

proc GlobalPtrHandle(lp: pointer): Pointer =
  result = cast[Pointer](GlobalHandle(lp))

proc ImageList_AddIcon(himl: HIMAGELIST, hicon: HICON): int32 =
  result = ImageList_ReplaceIcon(himl, -1, hicon)

proc Animate_Create(hWndP: HWND, id: HMENU, dwStyle: DWORD, hInstance: HINST): HWND =
  result = CreateWindow(cast[LPCSTR](ANIMATE_CLASS), nil, dwStyle, 0, 0, 0, 0, hwndP,
                        id, hInstance, nil)

proc Animate_Open(wnd: HWND, szName: LPTSTR): LRESULT =
  result = SendMessage(wnd, ACM_OPEN, 0, cast[LPARAM](szName))

proc Animate_Play(wnd: HWND, `from`, `to`: int32, rep: UINT): LRESULT =
  result = SendMessage(wnd, ACM_PLAY, WPARAM(rep),
                       LPARAM(MAKELONG(`from`, `to`)))

proc Animate_Stop(wnd: HWND): LRESULT =
  result = SendMessage(wnd, ACM_STOP, 0, 0)

proc Animate_Close(wnd: HWND): LRESULT =
  result = Animate_Open(wnd, nil)

proc Animate_Seek(wnd: HWND, frame: int32): LRESULT =
  result = Animate_Play(wnd, frame, frame, 1)

proc PropSheet_AddPage(hPropSheetDlg: HWND, hpage: HPROPSHEETPAGE): LRESULT =
  result = SendMessage(hPropSheetDlg, PSM_ADDPAGE, 0, cast[LPARAM](hpage))

proc PropSheet_Apply(hPropSheetDlg: HWND): LRESULT =
  result = SendMessage(hPropSheetDlg, PSM_APPLY, 0, 0)

proc PropSheet_CancelToClose(hPropSheetDlg: HWND): LRESULT =
  result = SendMessage(hPropSheetDlg, PSM_CANCELTOCLOSE, 0, 0)

proc PropSheet_Changed(hPropSheetDlg, hwndPage: HWND): LRESULT =
  result = SendMessage(hPropSheetDlg, PSM_CHANGED, WPARAM(hwndPage), 0)

proc PropSheet_GetCurrentPageHwnd(hDlg: HWND): LRESULT =
  result = SendMessage(hDlg, PSM_GETCURRENTPAGEHWND, 0, 0)

proc PropSheet_GetTabControl(hPropSheetDlg: HWND): LRESULT =
  result = SendMessage(hPropSheetDlg, PSM_GETTABCONTROL, 0, 0)

proc PropSheet_IsDialogMessage(hDlg: HWND, pMsg: int32): LRESULT =
  result = SendMessage(hDlg, PSM_ISDIALOGMESSAGE, 0, LPARAM(pMsg))

proc PropSheet_PressButton(hPropSheetDlg: HWND, iButton: int32): LRESULT =
  result = SendMessage(hPropSheetDlg, PSM_PRESSBUTTON, WPARAM(int32(iButton)), 0)

proc PropSheet_QuerySiblings(hPropSheetDlg: HWND, param1, param2: int32): LRESULT =
  result = SendMessage(hPropSheetDlg, PSM_QUERYSIBLINGS, WPARAM(param1),
                       LPARAM(param2))

proc PropSheet_RebootSystem(hPropSheetDlg: HWND): LRESULT =
  result = SendMessage(hPropSheetDlg, PSM_REBOOTSYSTEM, 0, 0)

proc PropSheet_RemovePage(hPropSheetDlg: HWND, hpage: HPROPSHEETPAGE,
                          index: int32): LRESULT =
  result = SendMessage(hPropSheetDlg, PSM_REMOVEPAGE, WPARAM(index),
                       cast[LPARAM](hpage))

proc PropSheet_RestartWindows(hPropSheetDlg: HWND): LRESULT =
  result = SendMessage(hPropSheetDlg, PSM_RESTARTWINDOWS, 0, 0)

proc PropSheet_SetCurSel(hPropSheetDlg: HWND, hpage: HPROPSHEETPAGE,
                         index: int32): LRESULT =
  result = SendMessage(hPropSheetDlg, PSM_SETCURSEL, WPARAM(index),
                       cast[LPARAM](hpage))

proc PropSheet_SetCurSelByID(hPropSheetDlg: HWND, id: int32): LRESULT =
  result = SendMessage(hPropSheetDlg, PSM_SETCURSELID, 0, LPARAM(id))

proc PropSheet_SetFinishText(hPropSheetDlg: HWND, lpszText: LPTSTR): LRESULT =
  result = SendMessage(hPropSheetDlg, PSM_SETFINISHTEXT, 0, cast[LPARAM](lpszText))

proc PropSheet_SetTitle(hPropSheetDlg: HWND, dwStyle: DWORD, lpszText: LPCTSTR): LRESULT =
  result = SendMessage(hPropSheetDlg, PSM_SETTITLE, WPARAM(dwStyle),
                       cast[LPARAM](lpszText))

proc PropSheet_SetWizButtons(hPropSheetDlg: HWND, dwFlags: DWORD): LRESULT =
  result = SendMessage(hPropSheetDlg, PSM_SETWIZBUTTONS, 0, LPARAM(dwFlags))

proc PropSheet_UnChanged(hPropSheetDlg: HWND, hwndPage: HWND): LRESULT =
  result = SendMessage(hPropSheetDlg, PSM_UNCHANGED, WPARAM(hwndPage), 0)

proc Header_DeleteItem(hwndHD: HWND, index: int32): WINBOOL =
  result = WINBOOL(SendMessage(hwndHD, HDM_DELETEITEM, WPARAM(index), 0))

proc Header_GetItem(hwndHD: HWND, index: int32, hdi: var HD_ITEM): WINBOOL =
  result = WINBOOL(SendMessage(hwndHD, HDM_GETITEM, WPARAM(index),
                               cast[LPARAM](addr(hdi))))

proc Header_GetItemCount(hwndHD: HWND): int32 =
  result = int32(SendMessage(hwndHD, HDM_GETITEMCOUNT, 0, 0))

proc Header_InsertItem(hwndHD: HWND, index: int32, hdi: var HD_ITEM): int32 =
  result = int32(SendMessage(hwndHD, HDM_INSERTITEM, WPARAM(index),
                             cast[LPARAM](addr(hdi))))

proc Header_Layout(hwndHD: HWND, layout: var HD_LAYOUT): WINBOOL =
  result = WINBOOL(SendMessage(hwndHD, HDM_LAYOUT, 0,
                   cast[LPARAM](addr(layout))))

proc Header_SetItem(hwndHD: HWND, index: int32, hdi: var HD_ITEM): WINBOOL =
  result = WINBOOL(SendMessage(hwndHD, HDM_SETITEM, WPARAM(index),
                               cast[LPARAM](addr(hdi))))

proc ListView_Arrange(hwndLV: HWND, code: UINT): LRESULT =
  result = SendMessage(hwndLV, LVM_ARRANGE, WPARAM(code), 0)

proc ListView_CreateDragImage(wnd: HWND, i: int32, lpptUpLeft: LPPOINT): LRESULT =
  result = SendMessage(wnd, LVM_CREATEDRAGIMAGE, WPARAM(i), cast[LPARAM](lpptUpLeft))

proc ListView_DeleteAllItems(wnd: HWND): LRESULT =
  result = SendMessage(wnd, LVM_DELETEALLITEMS, 0, 0)

proc ListView_DeleteColumn(wnd: HWND, iCol: int32): LRESULT =
  result = SendMessage(wnd, LVM_DELETECOLUMN, WPARAM(iCol), 0)

proc ListView_DeleteItem(wnd: HWND, iItem: int32): LRESULT =
  result = SendMessage(wnd, LVM_DELETEITEM, WPARAM(iItem), 0)

proc ListView_EditLabel(hwndLV: HWND, i: int32): LRESULT =
  result = SendMessage(hwndLV, LVM_EDITLABEL, WPARAM(int32(i)), 0)

proc ListView_EnsureVisible(hwndLV: HWND, i, fPartialOK: int32): LRESULT =
  result = SendMessage(hwndLV, LVM_ENSUREVISIBLE, WPARAM(i),
                       MAKELPARAM(fPartialOK, 0))

proc ListView_FindItem(wnd: HWND, iStart: int32, lvfi: var LV_FINDINFO): int32 =
  result = SendMessage(wnd, LVM_FINDITEM, WPARAM(iStart), 
                       cast[LPARAM](addr(lvfi))).int32

proc ListView_GetBkColor(wnd: HWND): LRESULT =
  result = SendMessage(wnd, LVM_GETBKCOLOR, 0, 0)

proc ListView_GetCallbackMask(wnd: HWND): LRESULT =
  result = SendMessage(wnd, LVM_GETCALLBACKMASK, 0, 0)

proc ListView_GetColumn(wnd: HWND, iCol: int32, col: var LV_COLUMN): LRESULT =
  result = SendMessage(wnd, LVM_GETCOLUMN, WPARAM(iCol), cast[LPARAM](addr(col)))

proc ListView_GetColumnWidth(wnd: HWND, iCol: int32): LRESULT =
  result = SendMessage(wnd, LVM_GETCOLUMNWIDTH, WPARAM(iCol), 0)

proc ListView_GetCountPerPage(hwndLV: HWND): LRESULT =
  result = SendMessage(hwndLV, LVM_GETCOUNTPERPAGE, 0, 0)

proc ListView_GetEditControl(hwndLV: HWND): LRESULT =
  result = SendMessage(hwndLV, LVM_GETEDITCONTROL, 0, 0)

proc ListView_GetImageList(wnd: HWND, iImageList: wINT): LRESULT =
  result = SendMessage(wnd, LVM_GETIMAGELIST, WPARAM(iImageList), 0)

proc ListView_GetISearchString(hwndLV: HWND, lpsz: LPTSTR): LRESULT =
  result = SendMessage(hwndLV, LVM_GETISEARCHSTRING, 0, cast[LPARAM](lpsz))

proc ListView_GetItem(wnd: HWND, item: var LV_ITEM): LRESULT =
  result = SendMessage(wnd, LVM_GETITEM, 0, cast[LPARAM](addr(item)))

proc ListView_GetItemCount(wnd: HWND): LRESULT =
  result = SendMessage(wnd, LVM_GETITEMCOUNT, 0, 0)

proc ListView_GetItemPosition(hwndLV: HWND, i: int32, pt: var POINT): int32 =
  result = SendMessage(hwndLV, LVM_GETITEMPOSITION, WPARAM(int32(i)),
                       cast[LPARAM](addr(pt))).int32

proc ListView_GetItemSpacing(hwndLV: HWND, fSmall: int32): LRESULT =
  result = SendMessage(hwndLV, LVM_GETITEMSPACING, fSmall, 0)

proc ListView_GetItemState(hwndLV: HWND, i, mask: int32): LRESULT =
  result = SendMessage(hwndLV, LVM_GETITEMSTATE, WPARAM(i), LPARAM(mask))

proc ListView_GetNextItem(wnd: HWND, iStart, flags: int32): LRESULT =
  result = SendMessage(wnd, LVM_GETNEXTITEM, WPARAM(iStart), LPARAM(flags))

proc ListView_GetOrigin(hwndLV: HWND, pt: var POINT): LRESULT =
  result = SendMessage(hwndLV, LVM_GETORIGIN, WPARAM(0), cast[LPARAM](addr(pt)))

proc ListView_GetSelectedCount(hwndLV: HWND): LRESULT =
  result = SendMessage(hwndLV, LVM_GETSELECTEDCOUNT, 0, 0)

proc ListView_GetStringWidth(hwndLV: HWND, psz: LPCTSTR): LRESULT =
  result = SendMessage(hwndLV, LVM_GETSTRINGWIDTH, 0, cast[LPARAM](psz))

proc ListView_GetTextBkColor(wnd: HWND): LRESULT =
  result = SendMessage(wnd, LVM_GETTEXTBKCOLOR, 0, 0)

proc ListView_GetTextColor(wnd: HWND): LRESULT =
  result = SendMessage(wnd, LVM_GETTEXTCOLOR, 0, 0)

proc ListView_GetTopIndex(hwndLV: HWND): LRESULT =
  result = SendMessage(hwndLV, LVM_GETTOPINDEX, 0, 0)

proc ListView_GetViewRect(wnd: HWND, rc: var RECT): LRESULT =
  result = SendMessage(wnd, LVM_GETVIEWRECT, 0, cast[LPARAM](addr(rc)))

proc ListView_HitTest(hwndLV: HWND, info: var LV_HITTESTINFO): LRESULT =
  result = SendMessage(hwndLV, LVM_HITTEST, 0, cast[LPARAM](addr(info)))

proc ListView_InsertColumn(wnd: HWND, iCol: int32, col: var LV_COLUMN): LRESULT =
  result = SendMessage(wnd, LVM_INSERTCOLUMN, WPARAM(iCol), cast[LPARAM](addr(col)))

proc ListView_InsertItem(wnd: HWND, item: var LV_ITEM): LRESULT =
  result = SendMessage(wnd, LVM_INSERTITEM, 0, cast[LPARAM](addr(item)))

proc ListView_RedrawItems(hwndLV: HWND, iFirst, iLast: int32): LRESULT =
  result = SendMessage(hwndLV, LVM_REDRAWITEMS, WPARAM(iFirst), LPARAM(iLast))

proc ListView_Scroll(hwndLV: HWND, dx, dy: int32): LRESULT =
  result = SendMessage(hwndLV, LVM_SCROLL, WPARAM(dx), LPARAM(dy))

proc ListView_SetBkColor(wnd: HWND, clrBk: COLORREF): LRESULT =
  result = SendMessage(wnd, LVM_SETBKCOLOR, 0, LPARAM(clrBk))

proc ListView_SetCallbackMask(wnd: HWND, mask: UINT): LRESULT =
  result = SendMessage(wnd, LVM_SETCALLBACKMASK, WPARAM(mask), 0)

proc ListView_SetColumn(wnd: HWND, iCol: int32, col: var LV_COLUMN): LRESULT =
  result = SendMessage(wnd, LVM_SETCOLUMN, WPARAM(iCol), cast[LPARAM](addr(col)))

proc ListView_SetColumnWidth(wnd: HWND, iCol, cx: int32): LRESULT =
  result = SendMessage(wnd, LVM_SETCOLUMNWIDTH, WPARAM(iCol), MAKELPARAM(cx, 0))

proc ListView_SetImageList(wnd: HWND, himl: int32, iImageList: HIMAGELIST): LRESULT =
  result = SendMessage(wnd, LVM_SETIMAGELIST, WPARAM(iImageList),
                       LPARAM(UINT(himl)))

proc ListView_SetItem(wnd: HWND, item: var LV_ITEM): LRESULT =
  result = SendMessage(wnd, LVM_SETITEM, 0, cast[LPARAM](addr(item)))

proc ListView_SetItemCount(hwndLV: HWND, cItems: int32): LRESULT =
  result = SendMessage(hwndLV, LVM_SETITEMCOUNT, WPARAM(cItems), 0)

proc ListView_SetItemPosition(hwndLV: HWND, i, x, y: int32): LRESULT =
  result = SendMessage(hwndLV, LVM_SETITEMPOSITION, WPARAM(i), MAKELPARAM(x, y))

proc ListView_SetItemPosition32(hwndLV: HWND, i, x, y: int32): LRESULT =
  var ptNewPos: POINT
  ptNewPos.x = x
  ptNewPos.y = y
  result = SendMessage(hwndLV, LVM_SETITEMPOSITION32, WPARAM(i),
                       cast[LPARAM](addr(ptNewPos)))

proc ListView_SetItemState(hwndLV: HWND, i, data, mask: int32): LRESULT =
  var gnu_lvi: LV_ITEM
  gnu_lvi.stateMask = uint(mask)
  gnu_lvi.state = uint(data)
  result = SendMessage(hwndLV, LVM_SETITEMSTATE, WPARAM(i),
                       cast[LPARAM](addr(gnu_lvi)))

proc ListView_SetItemText(hwndLV: HWND, i, iSubItem: int32, pszText: LPTSTR): LRESULT =
  var gnu_lvi: LV_ITEM
  gnu_lvi.iSubItem = iSubItem
  gnu_lvi.pszText = pszText
  result = SendMessage(hwndLV, LVM_SETITEMTEXT, WPARAM(i),
                       cast[LPARAM](addr(gnu_lvi)))

proc ListView_SetTextBkColor(wnd: HWND, clrTextBk: COLORREF): LRESULT =
  result = SendMessage(wnd, LVM_SETTEXTBKCOLOR, 0, LPARAM(clrTextBk))

proc ListView_SetTextColor(wnd: HWND, clrText: COLORREF): LRESULT =
  result = SendMessage(wnd, LVM_SETTEXTCOLOR, 0, LPARAM(clrText))

proc ListView_SortItems(hwndLV: HWND, pfnCompare: PFNLVCOMPARE, 
                        lPrm: LPARAM): LRESULT =
  result = SendMessage(hwndLV, LVM_SORTITEMS, WPARAM(lPrm), 
                       cast[LPARAM](pfnCompare))

proc ListView_Update(hwndLV: HWND, i: int32): LRESULT =
  result = SendMessage(hwndLV, LVM_UPDATE, WPARAM(i), 0)

proc TreeView_InsertItem(wnd: HWND, lpis: LPTV_INSERTSTRUCT): LRESULT =
  result = SendMessage(wnd, TVM_INSERTITEM, 0, cast[LPARAM](lpis))

proc TreeView_DeleteItem(wnd: HWND, hitem: HTREEITEM): LRESULT =
  result = SendMessage(wnd, TVM_DELETEITEM, 0, cast[LPARAM](hitem))

proc TreeView_DeleteAllItems(wnd: HWND): LRESULT =
  result = SendMessage(wnd, TVM_DELETEITEM, 0, cast[LPARAM](TVI_ROOT))

proc TreeView_Expand(wnd: HWND, hitem: HTREEITEM, code: int32): LRESULT =
  result = SendMessage(wnd, TVM_EXPAND, WPARAM(code), cast[LPARAM](hitem))

proc TreeView_GetCount(wnd: HWND): LRESULT =
  result = SendMessage(wnd, TVM_GETCOUNT, 0, 0)

proc TreeView_GetIndent(wnd: HWND): LRESULT =
  result = SendMessage(wnd, TVM_GETINDENT, 0, 0)

proc TreeView_SetIndent(wnd: HWND, indent: int32): LRESULT =
  result = SendMessage(wnd, TVM_SETINDENT, WPARAM(indent), 0)

proc TreeView_GetImageList(wnd: HWND, iImage: WPARAM): LRESULT =
  result = SendMessage(wnd, TVM_GETIMAGELIST, iImage, 0)

proc TreeView_SetImageList(wnd: HWND, himl: HIMAGELIST, iImage: WPARAM): LRESULT =
  result = SendMessage(wnd, TVM_SETIMAGELIST, iImage, LPARAM(UINT(himl)))

proc TreeView_GetNextItem(wnd: HWND, hitem: HTREEITEM, code: int32): LRESULT =
  result = SendMessage(wnd, TVM_GETNEXTITEM, WPARAM(code), cast[LPARAM](hitem))

proc TreeView_GetChild(wnd: HWND, hitem: HTREEITEM): LRESULT =
  result = TreeView_GetNextItem(wnd, hitem, TVGN_CHILD)

proc TreeView_GetNextSibling(wnd: HWND, hitem: HTREEITEM): LRESULT =
  result = TreeView_GetNextItem(wnd, hitem, TVGN_NEXT)

proc TreeView_GetPrevSibling(wnd: HWND, hitem: HTREEITEM): LRESULT =
  result = TreeView_GetNextItem(wnd, hitem, TVGN_PREVIOUS)

proc TreeView_GetParent(wnd: HWND, hitem: HTREEITEM): LRESULT =
  result = TreeView_GetNextItem(wnd, hitem, TVGN_PARENT)

proc TreeView_GetFirstVisible(wnd: HWND): LRESULT =
  result = TreeView_GetNextItem(wnd, HTREEITEM(nil), TVGN_FIRSTVISIBLE)

proc TreeView_GetNextVisible(wnd: HWND, hitem: HTREEITEM): LRESULT =
  result = TreeView_GetNextItem(wnd, hitem, TVGN_NEXTVISIBLE)

proc TreeView_GetPrevVisible(wnd: HWND, hitem: HTREEITEM): LRESULT =
  result = TreeView_GetNextItem(wnd, hitem, TVGN_PREVIOUSVISIBLE)

proc TreeView_GetSelection(wnd: HWND): LRESULT =
  result = TreeView_GetNextItem(wnd, HTREEITEM(nil), TVGN_CARET)

proc TreeView_GetDropHilight(wnd: HWND): LRESULT =
  result = TreeView_GetNextItem(wnd, HTREEITEM(nil), TVGN_DROPHILITE)

proc TreeView_GetRoot(wnd: HWND): LRESULT =
  result = TreeView_GetNextItem(wnd, HTREEITEM(nil), TVGN_ROOT)

proc TreeView_Select(wnd: HWND, hitem: HTREEITEM, code: int32): LRESULT =
  result = SendMessage(wnd, TVM_SELECTITEM, WPARAM(code), cast[LPARAM](hitem))

proc TreeView_SelectItem(wnd: HWND, hitem: HTREEITEM): LRESULT =
  result = TreeView_Select(wnd, hitem, TVGN_CARET)

proc TreeView_SelectDropTarget(wnd: HWND, hitem: HTREEITEM): LRESULT =
  result = TreeView_Select(wnd, hitem, TVGN_DROPHILITE)

proc TreeView_SelectSetFirstVisible(wnd: HWND, hitem: HTREEITEM): LRESULT =
  result = TreeView_Select(wnd, hitem, TVGN_FIRSTVISIBLE)

proc TreeView_GetItem(wnd: HWND, item: var TV_ITEM): LRESULT =
  result = SendMessage(wnd, TVM_GETITEM, 0, cast[LPARAM](addr(item)))

proc TreeView_SetItem(wnd: HWND, item: var TV_ITEM): LRESULT =
  result = SendMessage(wnd, TVM_SETITEM, 0, cast[LPARAM](addr(item)))

proc TreeView_EditLabel(wnd: HWND, hitem: HTREEITEM): LRESULT =
  Result = SendMessage(wnd, TVM_EDITLABEL, 0, cast[LPARAM](hitem))

proc TreeView_GetEditControl(wnd: HWND): LRESULT =
  result = SendMessage(wnd, TVM_GETEDITCONTROL, 0, 0)

proc TreeView_GetVisibleCount(wnd: HWND): LRESULT =
  result = SendMessage(wnd, TVM_GETVISIBLECOUNT, 0, 0)

proc TreeView_HitTest(wnd: HWND, lpht: LPTV_HITTESTINFO): LRESULT =
  result = SendMessage(wnd, TVM_HITTEST, 0, cast[LPARAM](lpht))

proc TreeView_CreateDragImage(wnd: HWND, hitem: HTREEITEM): LRESULT =
  result = SendMessage(wnd, TVM_CREATEDRAGIMAGE, 0, cast[LPARAM](hitem))

proc TreeView_SortChildren(wnd: HWND, hitem: HTREEITEM, recurse: int32): LRESULT =
  result = SendMessage(wnd, TVM_SORTCHILDREN, WPARAM(recurse), cast[LPARAM](hitem))

proc TreeView_EnsureVisible(wnd: HWND, hitem: HTREEITEM): LRESULT =
  result = SendMessage(wnd, TVM_ENSUREVISIBLE, 0, cast[LPARAM](hitem))

proc TreeView_SortChildrenCB(wnd: HWND, psort: LPTV_SORTCB, recurse: int32): LRESULT =
  result = SendMessage(wnd, TVM_SORTCHILDRENCB, WPARAM(recurse), cast[LPARAM](psort))

proc TreeView_EndEditLabelNow(wnd: HWND, fCancel: int32): LRESULT =
  result = SendMessage(wnd, TVM_ENDEDITLABELNOW, WPARAM(fCancel), 0)

proc TreeView_GetISearchString(hwndTV: HWND, lpsz: LPTSTR): LRESULT =
  result = SendMessage(hwndTV, TVM_GETISEARCHSTRING, 0, cast[LPARAM](lpsz))

proc TabCtrl_GetImageList(wnd: HWND): LRESULT =
  result = SendMessage(wnd, TCM_GETIMAGELIST, 0, 0)

proc TabCtrl_SetImageList(wnd: HWND, himl: HIMAGELIST): LRESULT =
  result = SendMessage(wnd, TCM_SETIMAGELIST, 0, LPARAM(UINT(himl)))

proc TabCtrl_GetItemCount(wnd: HWND): LRESULT =
  result = SendMessage(wnd, TCM_GETITEMCOUNT, 0, 0)

proc TabCtrl_GetItem(wnd: HWND, iItem: int32, item: var TC_ITEM): LRESULT =
  result = SendMessage(wnd, TCM_GETITEM, WPARAM(iItem), cast[LPARAM](addr(item)))

proc TabCtrl_SetItem(wnd: HWND, iItem: int32, item: var TC_ITEM): LRESULT =
  result = SendMessage(wnd, TCM_SETITEM, WPARAM(iItem), cast[LPARAM](addr(item)))

proc TabCtrl_InsertItem(wnd: HWND, iItem: int32, item: var TC_ITEM): LRESULT =
  result = SendMessage(wnd, TCM_INSERTITEM, WPARAM(iItem), cast[LPARAM](addr(item)))

proc TabCtrl_DeleteItem(wnd: HWND, i: int32): LRESULT =
  result = SendMessage(wnd, TCM_DELETEITEM, WPARAM(i), 0)

proc TabCtrl_DeleteAllItems(wnd: HWND): LRESULT =
  result = SendMessage(wnd, TCM_DELETEALLITEMS, 0, 0)

proc TabCtrl_GetItemRect(wnd: HWND, i: int32, rc: var RECT): LRESULT =
  result = SendMessage(wnd, TCM_GETITEMRECT, WPARAM(int32(i)), cast[LPARAM](addr(rc)))

proc TabCtrl_GetCurSel(wnd: HWND): LRESULT =
  result = SendMessage(wnd, TCM_GETCURSEL, 0, 0)

proc TabCtrl_SetCurSel(wnd: HWND, i: int32): LRESULT =
  result = SendMessage(wnd, TCM_SETCURSEL, WPARAM(i), 0)

proc TabCtrl_HitTest(hwndTC: HWND, info: var TC_HITTESTINFO): LRESULT =
  result = SendMessage(hwndTC, TCM_HITTEST, 0, cast[LPARAM](addr(info)))

proc TabCtrl_SetItemExtra(hwndTC: HWND, cb: int32): LRESULT =
  result = SendMessage(hwndTC, TCM_SETITEMEXTRA, WPARAM(cb), 0)

proc TabCtrl_AdjustRect(wnd: HWND, bLarger: WINBOOL, rc: var RECT): LRESULT =
  result = SendMessage(wnd, TCM_ADJUSTRECT, WPARAM(bLarger), cast[LPARAM](addr(rc)))

proc TabCtrl_SetItemSize(wnd: HWND, x, y: int32): LRESULT =
  result = SendMessage(wnd, TCM_SETITEMSIZE, 0, MAKELPARAM(x, y))

proc TabCtrl_RemoveImage(wnd: HWND, i: WPARAM): LRESULT =
  result = SendMessage(wnd, TCM_REMOVEIMAGE, i, 0)

proc TabCtrl_SetPadding(wnd: HWND, cx, cy: int32): LRESULT =
  result = SendMessage(wnd, TCM_SETPADDING, 0, MAKELPARAM(cx, cy))

proc TabCtrl_GetRowCount(wnd: HWND): LRESULT =
  result = SendMessage(wnd, TCM_GETROWCOUNT, 0, 0)

proc TabCtrl_GetToolTips(wnd: HWND): LRESULT =
  result = SendMessage(wnd, TCM_GETTOOLTIPS, 0, 0)

proc TabCtrl_SetToolTips(wnd: HWND, hwndTT: int32): LRESULT =
  result = SendMessage(wnd, TCM_SETTOOLTIPS, WPARAM(hwndTT), 0)

proc TabCtrl_GetCurFocus(wnd: HWND): LRESULT =
  result = SendMessage(wnd, TCM_GETCURFOCUS, 0, 0)

proc TabCtrl_SetCurFocus(wnd: HWND, i: int32): LRESULT =
  result = SendMessage(wnd, TCM_SETCURFOCUS, i, 0)

proc SNDMSG(wnd: HWND, Msg: UINT, wp: WPARAM, lp: LPARAM): LRESULT =
  result = SendMessage(wnd, Msg, wp, lp)

proc CommDlg_OpenSave_GetSpecA(hdlg: HWND, psz: LPSTR, cbmax: int32): LRESULT =
  result = SNDMSG(hdlg, CDM_GETSPEC, WPARAM(cbmax), cast[LPARAM](psz))

proc CommDlg_OpenSave_GetSpecW(hdlg: HWND, psz: LPWSTR, cbmax: int32): LRESULT =
  result = SNDMSG(hdlg, CDM_GETSPEC, WPARAM(cbmax), cast[LPARAM](psz))

when defined(winUnicode):
  proc CommDlg_OpenSave_GetSpec(hdlg: HWND, psz: LPWSTR, cbmax: int32): LRESULT =
    result = SNDMSG(hdlg, CDM_GETSPEC, WPARAM(cbmax), cast[LPARAM](psz))
else:
  proc CommDlg_OpenSave_GetSpec(hdlg: HWND, psz: LPSTR, cbmax: int32): LRESULT =
    result = SNDMSG(hdlg, CDM_GETSPEC, WPARAM(cbmax), cast[LPARAM](psz))

proc CommDlg_OpenSave_GetFilePathA(hdlg: HWND, psz: LPSTR, cbmax: int32): LRESULT =
  result = SNDMSG(hdlg, CDM_GETFILEPATH, WPARAM(cbmax), cast[LPARAM](psz))

proc CommDlg_OpenSave_GetFilePathW(hdlg: HWND, psz: LPWSTR, cbmax: int32): LRESULT =
  result = SNDMSG(hdlg, CDM_GETFILEPATH, WPARAM(cbmax), cast[LPARAM](psz))

when defined(winUnicode):
  proc CommDlg_OpenSave_GetFilePath(hdlg: HWND, psz: LPWSTR, cbmax: int32): LRESULT =
    result = SNDMSG(hdlg, CDM_GETFILEPATH, WPARAM(cbmax), cast[LPARAM](psz))
else:
  proc CommDlg_OpenSave_GetFilePath(hdlg: HWND, psz: LPSTR, cbmax: int32): LRESULT =
    result = SNDMSG(hdlg, CDM_GETFILEPATH, WPARAM(cbmax), cast[LPARAM](psz))

proc CommDlg_OpenSave_GetFolderPathA(hdlg: HWND, psz: LPSTR, cbmax: int32): LRESULT =
  result = SNDMSG(hdlg, CDM_GETFOLDERPATH, WPARAM(cbmax), cast[LPARAM](psz))

proc CommDlg_OpenSave_GetFolderPathW(hdlg: HWND, psz: LPWSTR, cbmax: int32): LRESULT =
  result = SNDMSG(hdlg, CDM_GETFOLDERPATH, WPARAM(cbmax), cast[LPARAM](psz))

when defined(winUnicode):
  proc CommDlg_OpenSave_GetFolderPath(hdlg: HWND, psz: LPWSTR, cbmax: int32): LRESULT =
    result = SNDMSG(hdlg, CDM_GETFOLDERPATH, WPARAM(cbmax), cast[LPARAM]((psz)))
else:
  proc CommDlg_OpenSave_GetFolderPath(hdlg: HWND, psz: LPSTR, cbmax: int32): LRESULT =
    result = SNDMSG(hdlg, CDM_GETFOLDERPATH, WPARAM(cbmax), cast[LPARAM](psz))

proc CommDlg_OpenSave_GetFolderIDList(hdlg: HWND, pidl: LPVOID, cbmax: int32): LRESULT =
  result = SNDMSG(hdlg, CDM_GETFOLDERIDLIST, WPARAM(cbmax), cast[LPARAM](pidl))

proc CommDlg_OpenSave_SetControlText(hdlg: HWND, id: int32, text: LPSTR): LRESULT =
  result = SNDMSG(hdlg, CDM_SETCONTROLTEXT, WPARAM(id), cast[LPARAM](text))

proc CommDlg_OpenSave_HideControl(hdlg: HWND, id: int32): LRESULT =
  result = SNDMSG(hdlg, CDM_HIDECONTROL, WPARAM(id), 0)

proc CommDlg_OpenSave_SetDefExt(hdlg: HWND, pszext: LPSTR): LRESULT =
  result = SNDMSG(hdlg, CDM_SETDEFEXT, 0, cast[LPARAM](pszext))

proc InternalGetLargestConsoleWindowSize(hConsoleOutput: HANDLE): DWord{.
    stdcall, dynlib: "kernel32", importc: "GetLargestConsoleWindowSize".}
proc GetLargestConsoleWindowSize(hConsoleOutput: HANDLE): COORD =
  var res: dword
  res = InternalGetLargestConsoleWindowSize(hConsoleOutput)
  result.y = toU16(res and 0x0000ffff) # XXX: correct?
  result.x = toU16(res shr 16)

proc Succeeded(Status: HRESULT): WINBOOL =
  result = (Status and 0x80000000).WinBool

proc Failed(Status: HRESULT): WINBOOL =
  result = (Status and 0x80000000).WinBool

proc IsError(Status: HRESULT): WINBOOL =
  result = ord((int(Status) shr 31) == SEVERITY_ERROR)

proc HResultCode(hr: HRESULT): int32 =
  result = hr and 0x0000FFFF'i32

proc HResultFacility(hr: HRESULT): int32 =
  result = (hr shr 16'i32) and 0x00001FFF'i32

proc HResultSeverity(hr: HRESULT): int32 =
  result = (hr shr 31'i32) and 0x00000001'i32

proc MakeResult(p1, p2, mask: int32): HRESULT =
  result = (p1 shl 31'i32) or (p2 shl 16'i32) or mask

proc HResultFromWin32(x: int32): HRESULT =
  result = x
  if result != 0'i32:
    result = ((result and 0x0000FFFF'i32) or (int32(FACILITY_WIN32) shl 16'i32) or
        0x80000000'i32)

proc HResultFromNT(x: int32): HRESULT =
  result = x or int32(FACILITY_NT_BIT)

proc MAKELANGID(PrimaryLang, SubLang: USHORT): int16 =
  result = (SubLang shl 10'i16) or PrimaryLang

proc PRIMARYLANGID(LangId: int16): int16 =
  result = LangId and 0x000003FF'i16

proc SUBLANGID(LangId: int16): int16 =
  result = LangId shr 10'i16

proc MAKELCID(LangId, SortId: int16): DWORD =
  result = toU32((ze(SortId) shl 16) or ze(LangId))

proc MAKESORTLCID(LangId, SortId, SortVersion: int16): DWORD =
  result = MAKELCID(LangId, SortId) or (SortVersion shl 20'i32)

proc LANGIDFROMLCID(LocaleId: LCID): int16 =
  result = toU16(LocaleId)

proc SORTIDFROMLCID(LocaleId: LCID): int16 =
  result = toU16((DWORD(LocaleId) shr 16) and 0x0000000F)

proc SORTVERSIONFROMLCID(LocaleId: LCID): int16 =
  result = toU16((DWORD(LocaleId) shr 20) and 0x0000000F)

proc LANG_SYSTEM_DEFAULT(): int16 =
  result = toU16(MAKELANGID(toU16(LANG_NEUTRAL), SUBLANG_SYS_DEFAULT))

proc LANG_USER_DEFAULT(): int16 =
  result = toU16(MAKELANGID(toU16(LANG_NEUTRAL), SUBLANG_DEFAULT))

proc LOCALE_NEUTRAL(): DWORD =
  result = MAKELCID(MAKELANGID(toU16(LANG_NEUTRAL), SUBLANG_NEUTRAL), SORT_DEFAULT)

proc LOCALE_INVARIANT(): DWORD =
  result = MAKELCID(MAKELANGID(toU16(LANG_INVARIANT), SUBLANG_NEUTRAL), SORT_DEFAULT)