kProfiler2/kPrf2WinApiWrappers-kernel32.h

   1 typedef PVOID WINAPI FN_EncodePointer( PVOID Ptr );
   2 __declspec(dllexport) PVOID WINAPI kPrf2Wrap_EncodePointer( PVOID Ptr )
   3 {
   4     static FN_EncodePointer *pfn = 0;
   5     if (!pfn)
   6         kPrf2WrapResolve((void **)&pfn, "EncodePointer", &g_Kernel32);
   7     return pfn( Ptr );
   8 }
   9
  10 typedef PVOID WINAPI FN_DecodePointer( PVOID Ptr );
  11 __declspec(dllexport) PVOID WINAPI kPrf2Wrap_DecodePointer( PVOID Ptr )
  12 {
  13     static FN_DecodePointer *pfn = 0;
  14     if (!pfn)
  15         kPrf2WrapResolve((void **)&pfn, "DecodePointer", &g_Kernel32);
  16     return pfn( Ptr );
  17 }
  18
  19 typedef PVOID WINAPI FN_EncodeSystemPointer( PVOID Ptr );
  20 __declspec(dllexport) PVOID WINAPI kPrf2Wrap_EncodeSystemPointer( PVOID Ptr )
  21 {
  22     static FN_EncodeSystemPointer *pfn = 0;
  23     if (!pfn)
  24         kPrf2WrapResolve((void **)&pfn, "EncodeSystemPointer", &g_Kernel32);
  25     return pfn( Ptr );
  26 }
  27
  28 typedef PVOID WINAPI FN_DecodeSystemPointer( PVOID Ptr );
  29 __declspec(dllexport) PVOID WINAPI kPrf2Wrap_DecodeSystemPointer( PVOID Ptr )
  30 {
  31     static FN_DecodeSystemPointer *pfn = 0;
  32     if (!pfn)
  33         kPrf2WrapResolve((void **)&pfn, "DecodeSystemPointer", &g_Kernel32);
  34     return pfn( Ptr );
  35 }
  36
  37 typedef DWORD WINAPI FN_GetFreeSpace( UINT a);
  38 __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetFreeSpace( UINT a)
  39 {
  40     static FN_GetFreeSpace *pfn = 0;
  41     if (!pfn)
  42         kPrf2WrapResolve((void **)&pfn, "GetFreeSpace", &g_Kernel32);
  43     return pfn( a);
  44 }
  45
  46 typedef LONG WINAPI FN_InterlockedIncrement( LONG volatile * lpAddend );
  47 __declspec(dllexport) LONG WINAPI kPrf2Wrap_InterlockedIncrement( LONG volatile * lpAddend )
  48 {
  49     static FN_InterlockedIncrement *pfn = 0;
  50     if (!pfn)
  51         kPrf2WrapResolve((void **)&pfn, "InterlockedIncrement", &g_Kernel32);
  52     return pfn( lpAddend );
  53 }
  54
  55 typedef LONG WINAPI FN_InterlockedDecrement( LONG volatile * lpAddend );
  56 __declspec(dllexport) LONG WINAPI kPrf2Wrap_InterlockedDecrement( LONG volatile * lpAddend )
  57 {
  58     static FN_InterlockedDecrement *pfn = 0;
  59     if (!pfn)
  60         kPrf2WrapResolve((void **)&pfn, "InterlockedDecrement", &g_Kernel32);
  61     return pfn( lpAddend );
  62 }
  63
  64 typedef LONG WINAPI FN_InterlockedExchange( LONG volatile * Target, LONG Value );
  65 __declspec(dllexport) LONG WINAPI kPrf2Wrap_InterlockedExchange( LONG volatile * Target, LONG Value )
  66 {
  67     static FN_InterlockedExchange *pfn = 0;
  68     if (!pfn)
  69         kPrf2WrapResolve((void **)&pfn, "InterlockedExchange", &g_Kernel32);
  70     return pfn( Target, Value );
  71 }
  72
  73 typedef LONG WINAPI FN_InterlockedExchangeAdd( LONG volatile * Addend, LONG Value );
  74 __declspec(dllexport) LONG WINAPI kPrf2Wrap_InterlockedExchangeAdd( LONG volatile * Addend, LONG Value )
  75 {
  76     static FN_InterlockedExchangeAdd *pfn = 0;
  77     if (!pfn)
  78         kPrf2WrapResolve((void **)&pfn, "InterlockedExchangeAdd", &g_Kernel32);
  79     return pfn( Addend, Value );
  80 }
  81
  82 typedef LONG WINAPI FN_InterlockedCompareExchange( LONG volatile * Destination, LONG Exchange, LONG Comperand );
  83 __declspec(dllexport) LONG WINAPI kPrf2Wrap_InterlockedCompareExchange( LONG volatile * Destination, LONG Exchange, LONG Comperand )
  84 {
  85     static FN_InterlockedCompareExchange *pfn = 0;
  86     if (!pfn)
  87         kPrf2WrapResolve((void **)&pfn, "InterlockedCompareExchange", &g_Kernel32);
  88     return pfn( Destination, Exchange, Comperand );
  89 }
  90
  91 typedef LONGLONG WINAPI FN_InterlockedCompareExchange64( LONGLONG volatile * Destination, LONGLONG Exchange, LONGLONG Comperand );
  92 __declspec(dllexport) LONGLONG WINAPI kPrf2Wrap_InterlockedCompareExchange64( LONGLONG volatile * Destination, LONGLONG Exchange, LONGLONG Comperand )
  93 {
  94     static FN_InterlockedCompareExchange64 *pfn = 0;
  95     if (!pfn)
  96         kPrf2WrapResolve((void **)&pfn, "InterlockedCompareExchange64", &g_Kernel32);
  97     return pfn( Destination, Exchange, Comperand );
  98 }
  99
 100 typedef VOID WINAPI FN_InitializeSListHead( PSLIST_HEADER ListHead );
 101 __declspec(dllexport) VOID WINAPI kPrf2Wrap_InitializeSListHead( PSLIST_HEADER ListHead )
 102 {
 103     static FN_InitializeSListHead *pfn = 0;
 104     if (!pfn)
 105         kPrf2WrapResolve((void **)&pfn, "InitializeSListHead", &g_Kernel32);
 106     pfn( ListHead );
 107 }
 108
 109 typedef PSLIST_ENTRY WINAPI FN_InterlockedPopEntrySList( PSLIST_HEADER ListHead );
 110 __declspec(dllexport) PSLIST_ENTRY WINAPI kPrf2Wrap_InterlockedPopEntrySList( PSLIST_HEADER ListHead )
 111 {
 112     static FN_InterlockedPopEntrySList *pfn = 0;
 113     if (!pfn)
 114         kPrf2WrapResolve((void **)&pfn, "InterlockedPopEntrySList", &g_Kernel32);
 115     return pfn( ListHead );
 116 }
 117
 118 typedef PSLIST_ENTRY WINAPI FN_InterlockedPushEntrySList( PSLIST_HEADER ListHead, PSLIST_ENTRY ListEntry );
 119 __declspec(dllexport) PSLIST_ENTRY WINAPI kPrf2Wrap_InterlockedPushEntrySList( PSLIST_HEADER ListHead, PSLIST_ENTRY ListEntry )
 120 {
 121     static FN_InterlockedPushEntrySList *pfn = 0;
 122     if (!pfn)
 123         kPrf2WrapResolve((void **)&pfn, "InterlockedPushEntrySList", &g_Kernel32);
 124     return pfn( ListHead, ListEntry );
 125 }
 126
 127 typedef PSLIST_ENTRY WINAPI FN_InterlockedFlushSList( PSLIST_HEADER ListHead );
 128 __declspec(dllexport) PSLIST_ENTRY WINAPI kPrf2Wrap_InterlockedFlushSList( PSLIST_HEADER ListHead )
 129 {
 130     static FN_InterlockedFlushSList *pfn = 0;
 131     if (!pfn)
 132         kPrf2WrapResolve((void **)&pfn, "InterlockedFlushSList", &g_Kernel32);
 133     return pfn( ListHead );
 134 }
 135
 136 typedef USHORT WINAPI FN_QueryDepthSList( PSLIST_HEADER ListHead );
 137 __declspec(dllexport) USHORT WINAPI kPrf2Wrap_QueryDepthSList( PSLIST_HEADER ListHead )
 138 {
 139     static FN_QueryDepthSList *pfn = 0;
 140     if (!pfn)
 141         kPrf2WrapResolve((void **)&pfn, "QueryDepthSList", &g_Kernel32);
 142     return pfn( ListHead );
 143 }
 144
 145 typedef BOOL WINAPI FN_FreeResource( HGLOBAL hResData );
 146 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_FreeResource( HGLOBAL hResData )
 147 {
 148     static FN_FreeResource *pfn = 0;
 149     if (!pfn)
 150         kPrf2WrapResolve((void **)&pfn, "FreeResource", &g_Kernel32);
 151     return pfn( hResData );
 152 }
 153
 154 typedef LPVOID WINAPI FN_LockResource( HGLOBAL hResData );
 155 __declspec(dllexport) LPVOID WINAPI kPrf2Wrap_LockResource( HGLOBAL hResData )
 156 {
 157     static FN_LockResource *pfn = 0;
 158     if (!pfn)
 159         kPrf2WrapResolve((void **)&pfn, "LockResource", &g_Kernel32);
 160     return pfn( hResData );
 161 }
 162
 163 typedef BOOL WINAPI FN_FreeLibrary( HMODULE hLibModule );
 164 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_FreeLibrary( HMODULE hLibModule )
 165 {
 166     static FN_FreeLibrary *pfn = 0;
 167     if (!pfn)
 168         kPrf2WrapResolve((void **)&pfn, "FreeLibrary", &g_Kernel32);
 169     return pfn( hLibModule );
 170 }
 171
 172 typedef VOID WINAPI FN_FreeLibraryAndExitThread( HMODULE hLibModule, DWORD dwExitCode );
 173 __declspec(dllexport) VOID WINAPI kPrf2Wrap_FreeLibraryAndExitThread( HMODULE hLibModule, DWORD dwExitCode )
 174 {
 175     static FN_FreeLibraryAndExitThread *pfn = 0;
 176     if (!pfn)
 177         kPrf2WrapResolve((void **)&pfn, "FreeLibraryAndExitThread", &g_Kernel32);
 178     pfn( hLibModule, dwExitCode );
 179 }
 180
 181 typedef BOOL WINAPI FN_DisableThreadLibraryCalls( HMODULE hLibModule );
 182 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_DisableThreadLibraryCalls( HMODULE hLibModule )
 183 {
 184     static FN_DisableThreadLibraryCalls *pfn = 0;
 185     if (!pfn)
 186         kPrf2WrapResolve((void **)&pfn, "DisableThreadLibraryCalls", &g_Kernel32);
 187     return pfn( hLibModule );
 188 }
 189
 190 typedef FARPROC WINAPI FN_GetProcAddress( HMODULE hModule, LPCSTR lpProcName );
 191 __declspec(dllexport) FARPROC WINAPI kPrf2Wrap_GetProcAddress( HMODULE hModule, LPCSTR lpProcName )
 192 {
 193     static FN_GetProcAddress *pfn = 0;
 194     if (!pfn)
 195         kPrf2WrapResolve((void **)&pfn, "GetProcAddress", &g_Kernel32);
 196     return pfn( hModule, lpProcName );
 197 }
 198
 199 typedef DWORD WINAPI FN_GetVersion( VOID );
 200 __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetVersion( VOID )
 201 {
 202     static FN_GetVersion *pfn = 0;
 203     if (!pfn)
 204         kPrf2WrapResolve((void **)&pfn, "GetVersion", &g_Kernel32);
 205     return pfn ();
 206 }
 207
 208 typedef HGLOBAL WINAPI FN_GlobalAlloc( UINT uFlags, SIZE_T dwBytes );
 209 __declspec(dllexport) HGLOBAL WINAPI kPrf2Wrap_GlobalAlloc( UINT uFlags, SIZE_T dwBytes )
 210 {
 211     static FN_GlobalAlloc *pfn = 0;
 212     if (!pfn)
 213         kPrf2WrapResolve((void **)&pfn, "GlobalAlloc", &g_Kernel32);
 214     return pfn( uFlags, dwBytes );
 215 }
 216
 217 typedef HGLOBAL WINAPI FN_GlobalReAlloc( HGLOBAL hMem, SIZE_T dwBytes, UINT uFlags );
 218 __declspec(dllexport) HGLOBAL WINAPI kPrf2Wrap_GlobalReAlloc( HGLOBAL hMem, SIZE_T dwBytes, UINT uFlags )
 219 {
 220     static FN_GlobalReAlloc *pfn = 0;
 221     if (!pfn)
 222         kPrf2WrapResolve((void **)&pfn, "GlobalReAlloc", &g_Kernel32);
 223     return pfn( hMem, dwBytes, uFlags );
 224 }
 225
 226 typedef SIZE_T WINAPI FN_GlobalSize( HGLOBAL hMem );
 227 __declspec(dllexport) SIZE_T WINAPI kPrf2Wrap_GlobalSize( HGLOBAL hMem )
 228 {
 229     static FN_GlobalSize *pfn = 0;
 230     if (!pfn)
 231         kPrf2WrapResolve((void **)&pfn, "GlobalSize", &g_Kernel32);
 232     return pfn( hMem );
 233 }
 234
 235 typedef UINT WINAPI FN_GlobalFlags( HGLOBAL hMem );
 236 __declspec(dllexport) UINT WINAPI kPrf2Wrap_GlobalFlags( HGLOBAL hMem )
 237 {
 238     static FN_GlobalFlags *pfn = 0;
 239     if (!pfn)
 240         kPrf2WrapResolve((void **)&pfn, "GlobalFlags", &g_Kernel32);
 241     return pfn( hMem );
 242 }
 243
 244 typedef LPVOID WINAPI FN_GlobalLock( HGLOBAL hMem );
 245 __declspec(dllexport) LPVOID WINAPI kPrf2Wrap_GlobalLock( HGLOBAL hMem )
 246 {
 247     static FN_GlobalLock *pfn = 0;
 248     if (!pfn)
 249         kPrf2WrapResolve((void **)&pfn, "GlobalLock", &g_Kernel32);
 250     return pfn( hMem );
 251 }
 252
 253 typedef HGLOBAL WINAPI FN_GlobalHandle( LPCVOID pMem );
 254 __declspec(dllexport) HGLOBAL WINAPI kPrf2Wrap_GlobalHandle( LPCVOID pMem )
 255 {
 256     static FN_GlobalHandle *pfn = 0;
 257     if (!pfn)
 258         kPrf2WrapResolve((void **)&pfn, "GlobalHandle", &g_Kernel32);
 259     return pfn( pMem );
 260 }
 261
 262 typedef BOOL WINAPI FN_GlobalUnlock( HGLOBAL hMem );
 263 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GlobalUnlock( HGLOBAL hMem )
 264 {
 265     static FN_GlobalUnlock *pfn = 0;
 266     if (!pfn)
 267         kPrf2WrapResolve((void **)&pfn, "GlobalUnlock", &g_Kernel32);
 268     return pfn( hMem );
 269 }
 270
 271 typedef HGLOBAL WINAPI FN_GlobalFree( HGLOBAL hMem );
 272 __declspec(dllexport) HGLOBAL WINAPI kPrf2Wrap_GlobalFree( HGLOBAL hMem )
 273 {
 274     static FN_GlobalFree *pfn = 0;
 275     if (!pfn)
 276         kPrf2WrapResolve((void **)&pfn, "GlobalFree", &g_Kernel32);
 277     return pfn( hMem );
 278 }
 279
 280 typedef SIZE_T WINAPI FN_GlobalCompact( DWORD dwMinFree );
 281 __declspec(dllexport) SIZE_T WINAPI kPrf2Wrap_GlobalCompact( DWORD dwMinFree )
 282 {
 283     static FN_GlobalCompact *pfn = 0;
 284     if (!pfn)
 285         kPrf2WrapResolve((void **)&pfn, "GlobalCompact", &g_Kernel32);
 286     return pfn( dwMinFree );
 287 }
 288
 289 typedef VOID WINAPI FN_GlobalFix( HGLOBAL hMem );
 290 __declspec(dllexport) VOID WINAPI kPrf2Wrap_GlobalFix( HGLOBAL hMem )
 291 {
 292     static FN_GlobalFix *pfn = 0;
 293     if (!pfn)
 294         kPrf2WrapResolve((void **)&pfn, "GlobalFix", &g_Kernel32);
 295     pfn( hMem );
 296 }
 297
 298 typedef VOID WINAPI FN_GlobalUnfix( HGLOBAL hMem );
 299 __declspec(dllexport) VOID WINAPI kPrf2Wrap_GlobalUnfix( HGLOBAL hMem )
 300 {
 301     static FN_GlobalUnfix *pfn = 0;
 302     if (!pfn)
 303         kPrf2WrapResolve((void **)&pfn, "GlobalUnfix", &g_Kernel32);
 304     pfn( hMem );
 305 }
 306
 307 typedef LPVOID WINAPI FN_GlobalWire( HGLOBAL hMem );
 308 __declspec(dllexport) LPVOID WINAPI kPrf2Wrap_GlobalWire( HGLOBAL hMem )
 309 {
 310     static FN_GlobalWire *pfn = 0;
 311     if (!pfn)
 312         kPrf2WrapResolve((void **)&pfn, "GlobalWire", &g_Kernel32);
 313     return pfn( hMem );
 314 }
 315
 316 typedef BOOL WINAPI FN_GlobalUnWire( HGLOBAL hMem );
 317 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GlobalUnWire( HGLOBAL hMem )
 318 {
 319     static FN_GlobalUnWire *pfn = 0;
 320     if (!pfn)
 321         kPrf2WrapResolve((void **)&pfn, "GlobalUnWire", &g_Kernel32);
 322     return pfn( hMem );
 323 }
 324
 325 typedef VOID WINAPI FN_GlobalMemoryStatus( LPMEMORYSTATUS lpBuffer );
 326 __declspec(dllexport) VOID WINAPI kPrf2Wrap_GlobalMemoryStatus( LPMEMORYSTATUS lpBuffer )
 327 {
 328     static FN_GlobalMemoryStatus *pfn = 0;
 329     if (!pfn)
 330         kPrf2WrapResolve((void **)&pfn, "GlobalMemoryStatus", &g_Kernel32);
 331     pfn( lpBuffer );
 332 }
 333
 334 typedef BOOL WINAPI FN_GlobalMemoryStatusEx( LPMEMORYSTATUSEX lpBuffer );
 335 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GlobalMemoryStatusEx( LPMEMORYSTATUSEX lpBuffer )
 336 {
 337     static FN_GlobalMemoryStatusEx *pfn = 0;
 338     if (!pfn)
 339         kPrf2WrapResolve((void **)&pfn, "GlobalMemoryStatusEx", &g_Kernel32);
 340     return pfn( lpBuffer );
 341 }
 342
 343 typedef HLOCAL WINAPI FN_LocalAlloc( UINT uFlags, SIZE_T uBytes );
 344 __declspec(dllexport) HLOCAL WINAPI kPrf2Wrap_LocalAlloc( UINT uFlags, SIZE_T uBytes )
 345 {
 346     static FN_LocalAlloc *pfn = 0;
 347     if (!pfn)
 348         kPrf2WrapResolve((void **)&pfn, "LocalAlloc", &g_Kernel32);
 349     return pfn( uFlags, uBytes );
 350 }
 351
 352 typedef HLOCAL WINAPI FN_LocalReAlloc( HLOCAL hMem, SIZE_T uBytes, UINT uFlags );
 353 __declspec(dllexport) HLOCAL WINAPI kPrf2Wrap_LocalReAlloc( HLOCAL hMem, SIZE_T uBytes, UINT uFlags )
 354 {
 355     static FN_LocalReAlloc *pfn = 0;
 356     if (!pfn)
 357         kPrf2WrapResolve((void **)&pfn, "LocalReAlloc", &g_Kernel32);
 358     return pfn( hMem, uBytes, uFlags );
 359 }
 360
 361 typedef LPVOID WINAPI FN_LocalLock( HLOCAL hMem );
 362 __declspec(dllexport) LPVOID WINAPI kPrf2Wrap_LocalLock( HLOCAL hMem )
 363 {
 364     static FN_LocalLock *pfn = 0;
 365     if (!pfn)
 366         kPrf2WrapResolve((void **)&pfn, "LocalLock", &g_Kernel32);
 367     return pfn( hMem );
 368 }
 369
 370 typedef HLOCAL WINAPI FN_LocalHandle( LPCVOID pMem );
 371 __declspec(dllexport) HLOCAL WINAPI kPrf2Wrap_LocalHandle( LPCVOID pMem )
 372 {
 373     static FN_LocalHandle *pfn = 0;
 374     if (!pfn)
 375         kPrf2WrapResolve((void **)&pfn, "LocalHandle", &g_Kernel32);
 376     return pfn( pMem );
 377 }
 378
 379 typedef BOOL WINAPI FN_LocalUnlock( HLOCAL hMem );
 380 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_LocalUnlock( HLOCAL hMem )
 381 {
 382     static FN_LocalUnlock *pfn = 0;
 383     if (!pfn)
 384         kPrf2WrapResolve((void **)&pfn, "LocalUnlock", &g_Kernel32);
 385     return pfn( hMem );
 386 }
 387
 388 typedef SIZE_T WINAPI FN_LocalSize( HLOCAL hMem );
 389 __declspec(dllexport) SIZE_T WINAPI kPrf2Wrap_LocalSize( HLOCAL hMem )
 390 {
 391     static FN_LocalSize *pfn = 0;
 392     if (!pfn)
 393         kPrf2WrapResolve((void **)&pfn, "LocalSize", &g_Kernel32);
 394     return pfn( hMem );
 395 }
 396
 397 typedef UINT WINAPI FN_LocalFlags( HLOCAL hMem );
 398 __declspec(dllexport) UINT WINAPI kPrf2Wrap_LocalFlags( HLOCAL hMem )
 399 {
 400     static FN_LocalFlags *pfn = 0;
 401     if (!pfn)
 402         kPrf2WrapResolve((void **)&pfn, "LocalFlags", &g_Kernel32);
 403     return pfn( hMem );
 404 }
 405
 406 typedef HLOCAL WINAPI FN_LocalFree( HLOCAL hMem );
 407 __declspec(dllexport) HLOCAL WINAPI kPrf2Wrap_LocalFree( HLOCAL hMem )
 408 {
 409     static FN_LocalFree *pfn = 0;
 410     if (!pfn)
 411         kPrf2WrapResolve((void **)&pfn, "LocalFree", &g_Kernel32);
 412     return pfn( hMem );
 413 }
 414
 415 typedef SIZE_T WINAPI FN_LocalShrink( HLOCAL hMem, UINT cbNewSize );
 416 __declspec(dllexport) SIZE_T WINAPI kPrf2Wrap_LocalShrink( HLOCAL hMem, UINT cbNewSize )
 417 {
 418     static FN_LocalShrink *pfn = 0;
 419     if (!pfn)
 420         kPrf2WrapResolve((void **)&pfn, "LocalShrink", &g_Kernel32);
 421     return pfn( hMem, cbNewSize );
 422 }
 423
 424 typedef SIZE_T WINAPI FN_LocalCompact( UINT uMinFree );
 425 __declspec(dllexport) SIZE_T WINAPI kPrf2Wrap_LocalCompact( UINT uMinFree )
 426 {
 427     static FN_LocalCompact *pfn = 0;
 428     if (!pfn)
 429         kPrf2WrapResolve((void **)&pfn, "LocalCompact", &g_Kernel32);
 430     return pfn( uMinFree );
 431 }
 432
 433 typedef BOOL WINAPI FN_FlushInstructionCache( HANDLE hProcess, LPCVOID lpBaseAddress, SIZE_T dwSize );
 434 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_FlushInstructionCache( HANDLE hProcess, LPCVOID lpBaseAddress, SIZE_T dwSize )
 435 {
 436     static FN_FlushInstructionCache *pfn = 0;
 437     if (!pfn)
 438         kPrf2WrapResolve((void **)&pfn, "FlushInstructionCache", &g_Kernel32);
 439     return pfn( hProcess, lpBaseAddress, dwSize );
 440 }
 441
 442 typedef LPVOID WINAPI FN_VirtualAlloc( LPVOID lpAddress, SIZE_T dwSize, DWORD flAllocationType, DWORD flProtect );
 443 __declspec(dllexport) LPVOID WINAPI kPrf2Wrap_VirtualAlloc( LPVOID lpAddress, SIZE_T dwSize, DWORD flAllocationType, DWORD flProtect )
 444 {
 445     static FN_VirtualAlloc *pfn = 0;
 446     if (!pfn)
 447         kPrf2WrapResolve((void **)&pfn, "VirtualAlloc", &g_Kernel32);
 448     return pfn( lpAddress, dwSize, flAllocationType, flProtect );
 449 }
 450
 451 typedef BOOL WINAPI FN_VirtualFree( LPVOID lpAddress, SIZE_T dwSize, DWORD dwFreeType );
 452 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_VirtualFree( LPVOID lpAddress, SIZE_T dwSize, DWORD dwFreeType )
 453 {
 454     static FN_VirtualFree *pfn = 0;
 455     if (!pfn)
 456         kPrf2WrapResolve((void **)&pfn, "VirtualFree", &g_Kernel32);
 457     return pfn( lpAddress, dwSize, dwFreeType );
 458 }
 459
 460 typedef BOOL WINAPI FN_VirtualProtect( LPVOID lpAddress, SIZE_T dwSize, DWORD flNewProtect, PDWORD lpflOldProtect );
 461 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_VirtualProtect( LPVOID lpAddress, SIZE_T dwSize, DWORD flNewProtect, PDWORD lpflOldProtect )
 462 {
 463     static FN_VirtualProtect *pfn = 0;
 464     if (!pfn)
 465         kPrf2WrapResolve((void **)&pfn, "VirtualProtect", &g_Kernel32);
 466     return pfn( lpAddress, dwSize, flNewProtect, lpflOldProtect );
 467 }
 468
 469 typedef SIZE_T WINAPI FN_VirtualQuery( LPCVOID lpAddress, PMEMORY_BASIC_INFORMATION lpBuffer, SIZE_T dwLength );
 470 __declspec(dllexport) SIZE_T WINAPI kPrf2Wrap_VirtualQuery( LPCVOID lpAddress, PMEMORY_BASIC_INFORMATION lpBuffer, SIZE_T dwLength )
 471 {
 472     static FN_VirtualQuery *pfn = 0;
 473     if (!pfn)
 474         kPrf2WrapResolve((void **)&pfn, "VirtualQuery", &g_Kernel32);
 475     return pfn( lpAddress, lpBuffer, dwLength );
 476 }
 477
 478 typedef LPVOID WINAPI FN_VirtualAllocEx( HANDLE hProcess, LPVOID lpAddress, SIZE_T dwSize, DWORD flAllocationType, DWORD flProtect );
 479 __declspec(dllexport) LPVOID WINAPI kPrf2Wrap_VirtualAllocEx( HANDLE hProcess, LPVOID lpAddress, SIZE_T dwSize, DWORD flAllocationType, DWORD flProtect )
 480 {
 481     static FN_VirtualAllocEx *pfn = 0;
 482     if (!pfn)
 483         kPrf2WrapResolve((void **)&pfn, "VirtualAllocEx", &g_Kernel32);
 484     return pfn( hProcess, lpAddress, dwSize, flAllocationType, flProtect );
 485 }
 486
 487 typedef UINT WINAPI FN_GetWriteWatch( DWORD dwFlags, PVOID lpBaseAddress, SIZE_T dwRegionSize, PVOID * lpAddresses, ULONG_PTR * lpdwCount, PULONG lpdwGranularity );
 488 __declspec(dllexport) UINT WINAPI kPrf2Wrap_GetWriteWatch( DWORD dwFlags, PVOID lpBaseAddress, SIZE_T dwRegionSize, PVOID * lpAddresses, ULONG_PTR * lpdwCount, PULONG lpdwGranularity )
 489 {
 490     static FN_GetWriteWatch *pfn = 0;
 491     if (!pfn)
 492         kPrf2WrapResolve((void **)&pfn, "GetWriteWatch", &g_Kernel32);
 493     return pfn( dwFlags, lpBaseAddress, dwRegionSize, lpAddresses, lpdwCount, lpdwGranularity );
 494 }
 495
 496 typedef UINT WINAPI FN_ResetWriteWatch( LPVOID lpBaseAddress, SIZE_T dwRegionSize );
 497 __declspec(dllexport) UINT WINAPI kPrf2Wrap_ResetWriteWatch( LPVOID lpBaseAddress, SIZE_T dwRegionSize )
 498 {
 499     static FN_ResetWriteWatch *pfn = 0;
 500     if (!pfn)
 501         kPrf2WrapResolve((void **)&pfn, "ResetWriteWatch", &g_Kernel32);
 502     return pfn( lpBaseAddress, dwRegionSize );
 503 }
 504
 505 typedef SIZE_T WINAPI FN_GetLargePageMinimum( VOID );
 506 __declspec(dllexport) SIZE_T WINAPI kPrf2Wrap_GetLargePageMinimum( VOID )
 507 {
 508     static FN_GetLargePageMinimum *pfn = 0;
 509     if (!pfn)
 510         kPrf2WrapResolve((void **)&pfn, "GetLargePageMinimum", &g_Kernel32);
 511     return pfn ();
 512 }
 513
 514 typedef UINT WINAPI FN_EnumSystemFirmwareTables( DWORD FirmwareTableProviderSignature, PVOID pFirmwareTableEnumBuffer, DWORD BufferSize );
 515 __declspec(dllexport) UINT WINAPI kPrf2Wrap_EnumSystemFirmwareTables( DWORD FirmwareTableProviderSignature, PVOID pFirmwareTableEnumBuffer, DWORD BufferSize )
 516 {
 517     static FN_EnumSystemFirmwareTables *pfn = 0;
 518     if (!pfn)
 519         kPrf2WrapResolve((void **)&pfn, "EnumSystemFirmwareTables", &g_Kernel32);
 520     return pfn( FirmwareTableProviderSignature, pFirmwareTableEnumBuffer, BufferSize );
 521 }
 522
 523 typedef UINT WINAPI FN_GetSystemFirmwareTable( DWORD FirmwareTableProviderSignature, DWORD FirmwareTableID, PVOID pFirmwareTableBuffer, DWORD BufferSize );
 524 __declspec(dllexport) UINT WINAPI kPrf2Wrap_GetSystemFirmwareTable( DWORD FirmwareTableProviderSignature, DWORD FirmwareTableID, PVOID pFirmwareTableBuffer, DWORD BufferSize )
 525 {
 526     static FN_GetSystemFirmwareTable *pfn = 0;
 527     if (!pfn)
 528         kPrf2WrapResolve((void **)&pfn, "GetSystemFirmwareTable", &g_Kernel32);
 529     return pfn( FirmwareTableProviderSignature, FirmwareTableID, pFirmwareTableBuffer, BufferSize );
 530 }
 531
 532 typedef BOOL WINAPI FN_VirtualFreeEx( HANDLE hProcess, LPVOID lpAddress, SIZE_T dwSize, DWORD dwFreeType );
 533 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_VirtualFreeEx( HANDLE hProcess, LPVOID lpAddress, SIZE_T dwSize, DWORD dwFreeType )
 534 {
 535     static FN_VirtualFreeEx *pfn = 0;
 536     if (!pfn)
 537         kPrf2WrapResolve((void **)&pfn, "VirtualFreeEx", &g_Kernel32);
 538     return pfn( hProcess, lpAddress, dwSize, dwFreeType );
 539 }
 540
 541 typedef BOOL WINAPI FN_VirtualProtectEx( HANDLE hProcess, LPVOID lpAddress, SIZE_T dwSize, DWORD flNewProtect, PDWORD lpflOldProtect );
 542 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_VirtualProtectEx( HANDLE hProcess, LPVOID lpAddress, SIZE_T dwSize, DWORD flNewProtect, PDWORD lpflOldProtect )
 543 {
 544     static FN_VirtualProtectEx *pfn = 0;
 545     if (!pfn)
 546         kPrf2WrapResolve((void **)&pfn, "VirtualProtectEx", &g_Kernel32);
 547     return pfn( hProcess, lpAddress, dwSize, flNewProtect, lpflOldProtect );
 548 }
 549
 550 typedef SIZE_T WINAPI FN_VirtualQueryEx( HANDLE hProcess, LPCVOID lpAddress, PMEMORY_BASIC_INFORMATION lpBuffer, SIZE_T dwLength );
 551 __declspec(dllexport) SIZE_T WINAPI kPrf2Wrap_VirtualQueryEx( HANDLE hProcess, LPCVOID lpAddress, PMEMORY_BASIC_INFORMATION lpBuffer, SIZE_T dwLength )
 552 {
 553     static FN_VirtualQueryEx *pfn = 0;
 554     if (!pfn)
 555         kPrf2WrapResolve((void **)&pfn, "VirtualQueryEx", &g_Kernel32);
 556     return pfn( hProcess, lpAddress, lpBuffer, dwLength );
 557 }
 558
 559 typedef HANDLE WINAPI FN_HeapCreate( DWORD flOptions, SIZE_T dwInitialSize, SIZE_T dwMaximumSize );
 560 __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_HeapCreate( DWORD flOptions, SIZE_T dwInitialSize, SIZE_T dwMaximumSize )
 561 {
 562     static FN_HeapCreate *pfn = 0;
 563     if (!pfn)
 564         kPrf2WrapResolve((void **)&pfn, "HeapCreate", &g_Kernel32);
 565     return pfn( flOptions, dwInitialSize, dwMaximumSize );
 566 }
 567
 568 typedef BOOL WINAPI FN_HeapDestroy( HANDLE hHeap );
 569 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_HeapDestroy( HANDLE hHeap )
 570 {
 571     static FN_HeapDestroy *pfn = 0;
 572     if (!pfn)
 573         kPrf2WrapResolve((void **)&pfn, "HeapDestroy", &g_Kernel32);
 574     return pfn( hHeap );
 575 }
 576
 577 typedef LPVOID WINAPI FN_HeapAlloc( HANDLE hHeap, DWORD dwFlags, SIZE_T dwBytes );
 578 __declspec(dllexport) LPVOID WINAPI kPrf2Wrap_HeapAlloc( HANDLE hHeap, DWORD dwFlags, SIZE_T dwBytes )
 579 {
 580     static FN_HeapAlloc *pfn = 0;
 581     if (!pfn)
 582         kPrf2WrapResolve((void **)&pfn, "HeapAlloc", &g_Kernel32);
 583     return pfn( hHeap, dwFlags, dwBytes );
 584 }
 585
 586 typedef LPVOID WINAPI FN_HeapReAlloc( HANDLE hHeap, DWORD dwFlags, LPVOID lpMem, SIZE_T dwBytes );
 587 __declspec(dllexport) LPVOID WINAPI kPrf2Wrap_HeapReAlloc( HANDLE hHeap, DWORD dwFlags, LPVOID lpMem, SIZE_T dwBytes )
 588 {
 589     static FN_HeapReAlloc *pfn = 0;
 590     if (!pfn)
 591         kPrf2WrapResolve((void **)&pfn, "HeapReAlloc", &g_Kernel32);
 592     return pfn( hHeap, dwFlags, lpMem, dwBytes );
 593 }
 594
 595 typedef BOOL WINAPI FN_HeapFree( HANDLE hHeap, DWORD dwFlags, LPVOID lpMem );
 596 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_HeapFree( HANDLE hHeap, DWORD dwFlags, LPVOID lpMem )
 597 {
 598     static FN_HeapFree *pfn = 0;
 599     if (!pfn)
 600         kPrf2WrapResolve((void **)&pfn, "HeapFree", &g_Kernel32);
 601     return pfn( hHeap, dwFlags, lpMem );
 602 }
 603
 604 typedef SIZE_T WINAPI FN_HeapSize( HANDLE hHeap, DWORD dwFlags, LPCVOID lpMem );
 605 __declspec(dllexport) SIZE_T WINAPI kPrf2Wrap_HeapSize( HANDLE hHeap, DWORD dwFlags, LPCVOID lpMem )
 606 {
 607     static FN_HeapSize *pfn = 0;
 608     if (!pfn)
 609         kPrf2WrapResolve((void **)&pfn, "HeapSize", &g_Kernel32);
 610     return pfn( hHeap, dwFlags, lpMem );
 611 }
 612
 613 typedef BOOL WINAPI FN_HeapValidate( HANDLE hHeap, DWORD dwFlags, LPCVOID lpMem );
 614 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_HeapValidate( HANDLE hHeap, DWORD dwFlags, LPCVOID lpMem )
 615 {
 616     static FN_HeapValidate *pfn = 0;
 617     if (!pfn)
 618         kPrf2WrapResolve((void **)&pfn, "HeapValidate", &g_Kernel32);
 619     return pfn( hHeap, dwFlags, lpMem );
 620 }
 621
 622 typedef SIZE_T WINAPI FN_HeapCompact( HANDLE hHeap, DWORD dwFlags );
 623 __declspec(dllexport) SIZE_T WINAPI kPrf2Wrap_HeapCompact( HANDLE hHeap, DWORD dwFlags )
 624 {
 625     static FN_HeapCompact *pfn = 0;
 626     if (!pfn)
 627         kPrf2WrapResolve((void **)&pfn, "HeapCompact", &g_Kernel32);
 628     return pfn( hHeap, dwFlags );
 629 }
 630
 631 typedef HANDLE WINAPI FN_GetProcessHeap( VOID );
 632 __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_GetProcessHeap( VOID )
 633 {
 634     static FN_GetProcessHeap *pfn = 0;
 635     if (!pfn)
 636         kPrf2WrapResolve((void **)&pfn, "GetProcessHeap", &g_Kernel32);
 637     return pfn ();
 638 }
 639
 640 typedef DWORD WINAPI FN_GetProcessHeaps( DWORD NumberOfHeaps, PHANDLE ProcessHeaps );
 641 __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetProcessHeaps( DWORD NumberOfHeaps, PHANDLE ProcessHeaps )
 642 {
 643     static FN_GetProcessHeaps *pfn = 0;
 644     if (!pfn)
 645         kPrf2WrapResolve((void **)&pfn, "GetProcessHeaps", &g_Kernel32);
 646     return pfn( NumberOfHeaps, ProcessHeaps );
 647 }
 648
 649 typedef BOOL WINAPI FN_HeapLock( HANDLE hHeap );
 650 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_HeapLock( HANDLE hHeap )
 651 {
 652     static FN_HeapLock *pfn = 0;
 653     if (!pfn)
 654         kPrf2WrapResolve((void **)&pfn, "HeapLock", &g_Kernel32);
 655     return pfn( hHeap );
 656 }
 657
 658 typedef BOOL WINAPI FN_HeapUnlock( HANDLE hHeap );
 659 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_HeapUnlock( HANDLE hHeap )
 660 {
 661     static FN_HeapUnlock *pfn = 0;
 662     if (!pfn)
 663         kPrf2WrapResolve((void **)&pfn, "HeapUnlock", &g_Kernel32);
 664     return pfn( hHeap );
 665 }
 666
 667 typedef BOOL WINAPI FN_HeapWalk( HANDLE hHeap, LPPROCESS_HEAP_ENTRY lpEntry );
 668 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_HeapWalk( HANDLE hHeap, LPPROCESS_HEAP_ENTRY lpEntry )
 669 {
 670     static FN_HeapWalk *pfn = 0;
 671     if (!pfn)
 672         kPrf2WrapResolve((void **)&pfn, "HeapWalk", &g_Kernel32);
 673     return pfn( hHeap, lpEntry );
 674 }
 675
 676 typedef BOOL WINAPI FN_HeapSetInformation( HANDLE HeapHandle, HEAP_INFORMATION_CLASS HeapInformationClass, PVOID HeapInformation, SIZE_T HeapInformationLength );
 677 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_HeapSetInformation( HANDLE HeapHandle, HEAP_INFORMATION_CLASS HeapInformationClass, PVOID HeapInformation, SIZE_T HeapInformationLength )
 678 {
 679     static FN_HeapSetInformation *pfn = 0;
 680     if (!pfn)
 681         kPrf2WrapResolve((void **)&pfn, "HeapSetInformation", &g_Kernel32);
 682     return pfn( HeapHandle, HeapInformationClass, HeapInformation, HeapInformationLength );
 683 }
 684
 685 typedef BOOL WINAPI FN_HeapQueryInformation( HANDLE HeapHandle, HEAP_INFORMATION_CLASS HeapInformationClass, PVOID HeapInformation, SIZE_T HeapInformationLength, PSIZE_T ReturnLength );
 686 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_HeapQueryInformation( HANDLE HeapHandle, HEAP_INFORMATION_CLASS HeapInformationClass, PVOID HeapInformation, SIZE_T HeapInformationLength, PSIZE_T ReturnLength )
 687 {
 688     static FN_HeapQueryInformation *pfn = 0;
 689     if (!pfn)
 690         kPrf2WrapResolve((void **)&pfn, "HeapQueryInformation", &g_Kernel32);
 691     return pfn( HeapHandle, HeapInformationClass, HeapInformation, HeapInformationLength, ReturnLength );
 692 }
 693
 694 typedef BOOL WINAPI FN_GetBinaryTypeA( LPCSTR lpApplicationName, LPDWORD lpBinaryType );
 695 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetBinaryTypeA( LPCSTR lpApplicationName, LPDWORD lpBinaryType )
 696 {
 697     static FN_GetBinaryTypeA *pfn = 0;
 698     if (!pfn)
 699         kPrf2WrapResolve((void **)&pfn, "GetBinaryTypeA", &g_Kernel32);
 700     return pfn( lpApplicationName, lpBinaryType );
 701 }
 702
 703 typedef BOOL WINAPI FN_GetBinaryTypeW( LPCWSTR lpApplicationName, LPDWORD lpBinaryType );
 704 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetBinaryTypeW( LPCWSTR lpApplicationName, LPDWORD lpBinaryType )
 705 {
 706     static FN_GetBinaryTypeW *pfn = 0;
 707     if (!pfn)
 708         kPrf2WrapResolve((void **)&pfn, "GetBinaryTypeW", &g_Kernel32);
 709     return pfn( lpApplicationName, lpBinaryType );
 710 }
 711
 712 typedef DWORD WINAPI FN_GetShortPathNameA( LPCSTR lpszLongPath, LPSTR lpszShortPath, DWORD cchBuffer );
 713 __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetShortPathNameA( LPCSTR lpszLongPath, LPSTR lpszShortPath, DWORD cchBuffer )
 714 {
 715     static FN_GetShortPathNameA *pfn = 0;
 716     if (!pfn)
 717         kPrf2WrapResolve((void **)&pfn, "GetShortPathNameA", &g_Kernel32);
 718     return pfn( lpszLongPath, lpszShortPath, cchBuffer );
 719 }
 720
 721 typedef DWORD WINAPI FN_GetShortPathNameW( LPCWSTR lpszLongPath, LPWSTR lpszShortPath, DWORD cchBuffer );
 722 __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetShortPathNameW( LPCWSTR lpszLongPath, LPWSTR lpszShortPath, DWORD cchBuffer )
 723 {
 724     static FN_GetShortPathNameW *pfn = 0;
 725     if (!pfn)
 726         kPrf2WrapResolve((void **)&pfn, "GetShortPathNameW", &g_Kernel32);
 727     return pfn( lpszLongPath, lpszShortPath, cchBuffer );
 728 }
 729
 730 typedef DWORD WINAPI FN_GetLongPathNameA( LPCSTR lpszShortPath, LPSTR lpszLongPath, DWORD cchBuffer );
 731 __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetLongPathNameA( LPCSTR lpszShortPath, LPSTR lpszLongPath, DWORD cchBuffer )
 732 {
 733     static FN_GetLongPathNameA *pfn = 0;
 734     if (!pfn)
 735         kPrf2WrapResolve((void **)&pfn, "GetLongPathNameA", &g_Kernel32);
 736     return pfn( lpszShortPath, lpszLongPath, cchBuffer );
 737 }
 738
 739 typedef DWORD WINAPI FN_GetLongPathNameW( LPCWSTR lpszShortPath, LPWSTR lpszLongPath, DWORD cchBuffer );
 740 __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetLongPathNameW( LPCWSTR lpszShortPath, LPWSTR lpszLongPath, DWORD cchBuffer )
 741 {
 742     static FN_GetLongPathNameW *pfn = 0;
 743     if (!pfn)
 744         kPrf2WrapResolve((void **)&pfn, "GetLongPathNameW", &g_Kernel32);
 745     return pfn( lpszShortPath, lpszLongPath, cchBuffer );
 746 }
 747
 748 typedef BOOL WINAPI FN_GetProcessAffinityMask( HANDLE hProcess, PDWORD_PTR lpProcessAffinityMask, PDWORD_PTR lpSystemAffinityMask );
 749 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetProcessAffinityMask( HANDLE hProcess, PDWORD_PTR lpProcessAffinityMask, PDWORD_PTR lpSystemAffinityMask )
 750 {
 751     static FN_GetProcessAffinityMask *pfn = 0;
 752     if (!pfn)
 753         kPrf2WrapResolve((void **)&pfn, "GetProcessAffinityMask", &g_Kernel32);
 754     return pfn( hProcess, lpProcessAffinityMask, lpSystemAffinityMask );
 755 }
 756
 757 typedef BOOL WINAPI FN_SetProcessAffinityMask( HANDLE hProcess, DWORD_PTR dwProcessAffinityMask );
 758 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetProcessAffinityMask( HANDLE hProcess, DWORD_PTR dwProcessAffinityMask )
 759 {
 760     static FN_SetProcessAffinityMask *pfn = 0;
 761     if (!pfn)
 762         kPrf2WrapResolve((void **)&pfn, "SetProcessAffinityMask", &g_Kernel32);
 763     return pfn( hProcess, dwProcessAffinityMask );
 764 }
 765
 766 typedef BOOL WINAPI FN_GetProcessHandleCount( HANDLE hProcess, PDWORD pdwHandleCount );
 767 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetProcessHandleCount( HANDLE hProcess, PDWORD pdwHandleCount )
 768 {
 769     static FN_GetProcessHandleCount *pfn = 0;
 770     if (!pfn)
 771         kPrf2WrapResolve((void **)&pfn, "GetProcessHandleCount", &g_Kernel32);
 772     return pfn( hProcess, pdwHandleCount );
 773 }
 774
 775 typedef BOOL WINAPI FN_GetProcessTimes( HANDLE hProcess, LPFILETIME lpCreationTime, LPFILETIME lpExitTime, LPFILETIME lpKernelTime, LPFILETIME lpUserTime );
 776 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetProcessTimes( HANDLE hProcess, LPFILETIME lpCreationTime, LPFILETIME lpExitTime, LPFILETIME lpKernelTime, LPFILETIME lpUserTime )
 777 {
 778     static FN_GetProcessTimes *pfn = 0;
 779     if (!pfn)
 780         kPrf2WrapResolve((void **)&pfn, "GetProcessTimes", &g_Kernel32);
 781     return pfn( hProcess, lpCreationTime, lpExitTime, lpKernelTime, lpUserTime );
 782 }
 783
 784 typedef BOOL WINAPI FN_GetProcessIoCounters( HANDLE hProcess, PIO_COUNTERS lpIoCounters );
 785 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetProcessIoCounters( HANDLE hProcess, PIO_COUNTERS lpIoCounters )
 786 {
 787     static FN_GetProcessIoCounters *pfn = 0;
 788     if (!pfn)
 789         kPrf2WrapResolve((void **)&pfn, "GetProcessIoCounters", &g_Kernel32);
 790     return pfn( hProcess, lpIoCounters );
 791 }
 792
 793 typedef BOOL WINAPI FN_GetProcessWorkingSetSize( HANDLE hProcess, PSIZE_T lpMinimumWorkingSetSize, PSIZE_T lpMaximumWorkingSetSize );
 794 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetProcessWorkingSetSize( HANDLE hProcess, PSIZE_T lpMinimumWorkingSetSize, PSIZE_T lpMaximumWorkingSetSize )
 795 {
 796     static FN_GetProcessWorkingSetSize *pfn = 0;
 797     if (!pfn)
 798         kPrf2WrapResolve((void **)&pfn, "GetProcessWorkingSetSize", &g_Kernel32);
 799     return pfn( hProcess, lpMinimumWorkingSetSize, lpMaximumWorkingSetSize );
 800 }
 801
 802 typedef BOOL WINAPI FN_GetProcessWorkingSetSizeEx( HANDLE hProcess, PSIZE_T lpMinimumWorkingSetSize, PSIZE_T lpMaximumWorkingSetSize, PDWORD Flags );
 803 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetProcessWorkingSetSizeEx( HANDLE hProcess, PSIZE_T lpMinimumWorkingSetSize, PSIZE_T lpMaximumWorkingSetSize, PDWORD Flags )
 804 {
 805     static FN_GetProcessWorkingSetSizeEx *pfn = 0;
 806     if (!pfn)
 807         kPrf2WrapResolve((void **)&pfn, "GetProcessWorkingSetSizeEx", &g_Kernel32);
 808     return pfn( hProcess, lpMinimumWorkingSetSize, lpMaximumWorkingSetSize, Flags );
 809 }
 810
 811 typedef BOOL WINAPI FN_SetProcessWorkingSetSize( HANDLE hProcess, SIZE_T dwMinimumWorkingSetSize, SIZE_T dwMaximumWorkingSetSize );
 812 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetProcessWorkingSetSize( HANDLE hProcess, SIZE_T dwMinimumWorkingSetSize, SIZE_T dwMaximumWorkingSetSize )
 813 {
 814     static FN_SetProcessWorkingSetSize *pfn = 0;
 815     if (!pfn)
 816         kPrf2WrapResolve((void **)&pfn, "SetProcessWorkingSetSize", &g_Kernel32);
 817     return pfn( hProcess, dwMinimumWorkingSetSize, dwMaximumWorkingSetSize );
 818 }
 819
 820 typedef BOOL WINAPI FN_SetProcessWorkingSetSizeEx( HANDLE hProcess, SIZE_T dwMinimumWorkingSetSize, SIZE_T dwMaximumWorkingSetSize, DWORD Flags );
 821 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetProcessWorkingSetSizeEx( HANDLE hProcess, SIZE_T dwMinimumWorkingSetSize, SIZE_T dwMaximumWorkingSetSize, DWORD Flags )
 822 {
 823     static FN_SetProcessWorkingSetSizeEx *pfn = 0;
 824     if (!pfn)
 825         kPrf2WrapResolve((void **)&pfn, "SetProcessWorkingSetSizeEx", &g_Kernel32);
 826     return pfn( hProcess, dwMinimumWorkingSetSize, dwMaximumWorkingSetSize, Flags );
 827 }
 828
 829 typedef HANDLE WINAPI FN_OpenProcess( DWORD dwDesiredAccess, BOOL bInheritHandle, DWORD dwProcessId );
 830 __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_OpenProcess( DWORD dwDesiredAccess, BOOL bInheritHandle, DWORD dwProcessId )
 831 {
 832     static FN_OpenProcess *pfn = 0;
 833     if (!pfn)
 834         kPrf2WrapResolve((void **)&pfn, "OpenProcess", &g_Kernel32);
 835     return pfn( dwDesiredAccess, bInheritHandle, dwProcessId );
 836 }
 837
 838 typedef HANDLE WINAPI FN_GetCurrentProcess( VOID );
 839 __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_GetCurrentProcess( VOID )
 840 {
 841     static FN_GetCurrentProcess *pfn = 0;
 842     if (!pfn)
 843         kPrf2WrapResolve((void **)&pfn, "GetCurrentProcess", &g_Kernel32);
 844     return pfn ();
 845 }
 846
 847 typedef DWORD WINAPI FN_GetCurrentProcessId( VOID );
 848 __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetCurrentProcessId( VOID )
 849 {
 850     static FN_GetCurrentProcessId *pfn = 0;
 851     if (!pfn)
 852         kPrf2WrapResolve((void **)&pfn, "GetCurrentProcessId", &g_Kernel32);
 853     return pfn ();
 854 }
 855
 856 typedef VOID WINAPI FN_ExitProcess( UINT uExitCode );
 857 __declspec(dllexport) VOID WINAPI kPrf2Wrap_ExitProcess( UINT uExitCode )
 858 {
 859     static FN_ExitProcess *pfn = 0;
 860     if (!pfn)
 861         kPrf2WrapResolve((void **)&pfn, "ExitProcess", &g_Kernel32);
 862     pfn( uExitCode );
 863 }
 864
 865 typedef BOOL WINAPI FN_TerminateProcess( HANDLE hProcess, UINT uExitCode );
 866 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_TerminateProcess( HANDLE hProcess, UINT uExitCode )
 867 {
 868     static FN_TerminateProcess *pfn = 0;
 869     if (!pfn)
 870         kPrf2WrapResolve((void **)&pfn, "TerminateProcess", &g_Kernel32);
 871     return pfn( hProcess, uExitCode );
 872 }
 873
 874 typedef BOOL WINAPI FN_GetExitCodeProcess( HANDLE hProcess, LPDWORD lpExitCode );
 875 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetExitCodeProcess( HANDLE hProcess, LPDWORD lpExitCode )
 876 {
 877     static FN_GetExitCodeProcess *pfn = 0;
 878     if (!pfn)
 879         kPrf2WrapResolve((void **)&pfn, "GetExitCodeProcess", &g_Kernel32);
 880     return pfn( hProcess, lpExitCode );
 881 }
 882
 883 typedef VOID WINAPI FN_FatalExit( int ExitCode );
 884 __declspec(dllexport) VOID WINAPI kPrf2Wrap_FatalExit( int ExitCode )
 885 {
 886     static FN_FatalExit *pfn = 0;
 887     if (!pfn)
 888         kPrf2WrapResolve((void **)&pfn, "FatalExit", &g_Kernel32);
 889     pfn( ExitCode );
 890 }
 891
 892 typedef LPCH WINAPI FN_GetEnvironmentStrings( VOID );
 893 __declspec(dllexport) LPCH WINAPI kPrf2Wrap_GetEnvironmentStrings( VOID )
 894 {
 895     static FN_GetEnvironmentStrings *pfn = 0;
 896     if (!pfn)
 897         kPrf2WrapResolve((void **)&pfn, "GetEnvironmentStrings", &g_Kernel32);
 898     return pfn ();
 899 }
 900
 901 typedef LPWCH WINAPI FN_GetEnvironmentStringsW( VOID );
 902 __declspec(dllexport) LPWCH WINAPI kPrf2Wrap_GetEnvironmentStringsW( VOID )
 903 {
 904     static FN_GetEnvironmentStringsW *pfn = 0;
 905     if (!pfn)
 906         kPrf2WrapResolve((void **)&pfn, "GetEnvironmentStringsW", &g_Kernel32);
 907     return pfn ();
 908 }
 909
 910 typedef BOOL WINAPI FN_SetEnvironmentStringsA( LPCH NewEnvironment );
 911 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetEnvironmentStringsA( LPCH NewEnvironment )
 912 {
 913     static FN_SetEnvironmentStringsA *pfn = 0;
 914     if (!pfn)
 915         kPrf2WrapResolve((void **)&pfn, "SetEnvironmentStringsA", &g_Kernel32);
 916     return pfn( NewEnvironment );
 917 }
 918
 919 typedef BOOL WINAPI FN_SetEnvironmentStringsW( LPWCH NewEnvironment );
 920 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetEnvironmentStringsW( LPWCH NewEnvironment )
 921 {
 922     static FN_SetEnvironmentStringsW *pfn = 0;
 923     if (!pfn)
 924         kPrf2WrapResolve((void **)&pfn, "SetEnvironmentStringsW", &g_Kernel32);
 925     return pfn( NewEnvironment );
 926 }
 927
 928 typedef BOOL WINAPI FN_FreeEnvironmentStringsA( LPCH a);
 929 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_FreeEnvironmentStringsA( LPCH a)
 930 {
 931     static FN_FreeEnvironmentStringsA *pfn = 0;
 932     if (!pfn)
 933         kPrf2WrapResolve((void **)&pfn, "FreeEnvironmentStringsA", &g_Kernel32);
 934     return pfn( a);
 935 }
 936
 937 typedef BOOL WINAPI FN_FreeEnvironmentStringsW( LPWCH a);
 938 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_FreeEnvironmentStringsW( LPWCH a)
 939 {
 940     static FN_FreeEnvironmentStringsW *pfn = 0;
 941     if (!pfn)
 942         kPrf2WrapResolve((void **)&pfn, "FreeEnvironmentStringsW", &g_Kernel32);
 943     return pfn( a);
 944 }
 945
 946 typedef VOID WINAPI FN_RaiseException( DWORD dwExceptionCode, DWORD dwExceptionFlags, DWORD nNumberOfArguments, CONST ULONG_PTR * lpArguments );
 947 __declspec(dllexport) VOID WINAPI kPrf2Wrap_RaiseException( DWORD dwExceptionCode, DWORD dwExceptionFlags, DWORD nNumberOfArguments, CONST ULONG_PTR * lpArguments )
 948 {
 949     static FN_RaiseException *pfn = 0;
 950     if (!pfn)
 951         kPrf2WrapResolve((void **)&pfn, "RaiseException", &g_Kernel32);
 952     pfn( dwExceptionCode, dwExceptionFlags, nNumberOfArguments, lpArguments );
 953 }
 954
 955 typedef LONG WINAPI FN_UnhandledExceptionFilter( struct _EXCEPTION_POINTERS * ExceptionInfo );
 956 __declspec(dllexport) LONG WINAPI kPrf2Wrap_UnhandledExceptionFilter( struct _EXCEPTION_POINTERS * ExceptionInfo )
 957 {
 958     static FN_UnhandledExceptionFilter *pfn = 0;
 959     if (!pfn)
 960         kPrf2WrapResolve((void **)&pfn, "UnhandledExceptionFilter", &g_Kernel32);
 961     return pfn( ExceptionInfo );
 962 }
 963
 964 typedef LPTOP_LEVEL_EXCEPTION_FILTER WINAPI FN_SetUnhandledExceptionFilter( LPTOP_LEVEL_EXCEPTION_FILTER lpTopLevelExceptionFilter );
 965 __declspec(dllexport) LPTOP_LEVEL_EXCEPTION_FILTER WINAPI kPrf2Wrap_SetUnhandledExceptionFilter( LPTOP_LEVEL_EXCEPTION_FILTER lpTopLevelExceptionFilter )
 966 {
 967     static FN_SetUnhandledExceptionFilter *pfn = 0;
 968     if (!pfn)
 969         kPrf2WrapResolve((void **)&pfn, "SetUnhandledExceptionFilter", &g_Kernel32);
 970     return pfn( lpTopLevelExceptionFilter );
 971 }
 972
 973 typedef LPVOID WINAPI FN_CreateFiber( SIZE_T dwStackSize, LPFIBER_START_ROUTINE lpStartAddress, LPVOID lpParameter );
 974 __declspec(dllexport) LPVOID WINAPI kPrf2Wrap_CreateFiber( SIZE_T dwStackSize, LPFIBER_START_ROUTINE lpStartAddress, LPVOID lpParameter )
 975 {
 976     static FN_CreateFiber *pfn = 0;
 977     if (!pfn)
 978         kPrf2WrapResolve((void **)&pfn, "CreateFiber", &g_Kernel32);
 979     return pfn( dwStackSize, lpStartAddress, lpParameter );
 980 }
 981
 982 typedef LPVOID WINAPI FN_CreateFiberEx( SIZE_T dwStackCommitSize, SIZE_T dwStackReserveSize, DWORD dwFlags, LPFIBER_START_ROUTINE lpStartAddress, LPVOID lpParameter );
 983 __declspec(dllexport) LPVOID WINAPI kPrf2Wrap_CreateFiberEx( SIZE_T dwStackCommitSize, SIZE_T dwStackReserveSize, DWORD dwFlags, LPFIBER_START_ROUTINE lpStartAddress, LPVOID lpParameter )
 984 {
 985     static FN_CreateFiberEx *pfn = 0;
 986     if (!pfn)
 987         kPrf2WrapResolve((void **)&pfn, "CreateFiberEx", &g_Kernel32);
 988     return pfn( dwStackCommitSize, dwStackReserveSize, dwFlags, lpStartAddress, lpParameter );
 989 }
 990
 991 typedef VOID WINAPI FN_DeleteFiber( LPVOID lpFiber );
 992 __declspec(dllexport) VOID WINAPI kPrf2Wrap_DeleteFiber( LPVOID lpFiber )
 993 {
 994     static FN_DeleteFiber *pfn = 0;
 995     if (!pfn)
 996         kPrf2WrapResolve((void **)&pfn, "DeleteFiber", &g_Kernel32);
 997     pfn( lpFiber );
 998 }
 999
1000 typedef LPVOID WINAPI FN_ConvertThreadToFiber( LPVOID lpParameter );
1001 __declspec(dllexport) LPVOID WINAPI kPrf2Wrap_ConvertThreadToFiber( LPVOID lpParameter )
1002 {
1003     static FN_ConvertThreadToFiber *pfn = 0;
1004     if (!pfn)
1005         kPrf2WrapResolve((void **)&pfn, "ConvertThreadToFiber", &g_Kernel32);
1006     return pfn( lpParameter );
1007 }
1008
1009 typedef LPVOID WINAPI FN_ConvertThreadToFiberEx( LPVOID lpParameter, DWORD dwFlags );
1010 __declspec(dllexport) LPVOID WINAPI kPrf2Wrap_ConvertThreadToFiberEx( LPVOID lpParameter, DWORD dwFlags )
1011 {
1012     static FN_ConvertThreadToFiberEx *pfn = 0;
1013     if (!pfn)
1014         kPrf2WrapResolve((void **)&pfn, "ConvertThreadToFiberEx", &g_Kernel32);
1015     return pfn( lpParameter, dwFlags );
1016 }
1017
1018 typedef BOOL WINAPI FN_ConvertFiberToThread( VOID );
1019 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_ConvertFiberToThread( VOID )
1020 {
1021     static FN_ConvertFiberToThread *pfn = 0;
1022     if (!pfn)
1023         kPrf2WrapResolve((void **)&pfn, "ConvertFiberToThread", &g_Kernel32);
1024     return pfn ();
1025 }
1026
1027 typedef VOID WINAPI FN_SwitchToFiber( LPVOID lpFiber );
1028 __declspec(dllexport) VOID WINAPI kPrf2Wrap_SwitchToFiber( LPVOID lpFiber )
1029 {
1030     static FN_SwitchToFiber *pfn = 0;
1031     if (!pfn)
1032         kPrf2WrapResolve((void **)&pfn, "SwitchToFiber", &g_Kernel32);
1033     pfn( lpFiber );
1034 }
1035
1036 typedef BOOL WINAPI FN_SwitchToThread( VOID );
1037 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SwitchToThread( VOID )
1038 {
1039     static FN_SwitchToThread *pfn = 0;
1040     if (!pfn)
1041         kPrf2WrapResolve((void **)&pfn, "SwitchToThread", &g_Kernel32);
1042     return pfn ();
1043 }
1044
1045 typedef HANDLE WINAPI FN_CreateThread( LPSECURITY_ATTRIBUTES lpThreadAttributes, SIZE_T dwStackSize, LPTHREAD_START_ROUTINE lpStartAddress, LPVOID lpParameter, DWORD dwCreationFlags, LPDWORD lpThreadId );
1046 __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_CreateThread( LPSECURITY_ATTRIBUTES lpThreadAttributes, SIZE_T dwStackSize, LPTHREAD_START_ROUTINE lpStartAddress, LPVOID lpParameter, DWORD dwCreationFlags, LPDWORD lpThreadId )
1047 {
1048     static FN_CreateThread *pfn = 0;
1049     if (!pfn)
1050         kPrf2WrapResolve((void **)&pfn, "CreateThread", &g_Kernel32);
1051     return pfn( lpThreadAttributes, dwStackSize, lpStartAddress, lpParameter, dwCreationFlags, lpThreadId );
1052 }
1053
1054 typedef HANDLE WINAPI FN_CreateRemoteThread( HANDLE hProcess, LPSECURITY_ATTRIBUTES lpThreadAttributes, SIZE_T dwStackSize, LPTHREAD_START_ROUTINE lpStartAddress, LPVOID lpParameter, DWORD dwCreationFlags, LPDWORD lpThreadId );
1055 __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_CreateRemoteThread( HANDLE hProcess, LPSECURITY_ATTRIBUTES lpThreadAttributes, SIZE_T dwStackSize, LPTHREAD_START_ROUTINE lpStartAddress, LPVOID lpParameter, DWORD dwCreationFlags, LPDWORD lpThreadId )
1056 {
1057     static FN_CreateRemoteThread *pfn = 0;
1058     if (!pfn)
1059         kPrf2WrapResolve((void **)&pfn, "CreateRemoteThread", &g_Kernel32);
1060     return pfn( hProcess, lpThreadAttributes, dwStackSize, lpStartAddress, lpParameter, dwCreationFlags, lpThreadId );
1061 }
1062
1063 typedef HANDLE WINAPI FN_GetCurrentThread( VOID );
1064 __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_GetCurrentThread( VOID )
1065 {
1066     static FN_GetCurrentThread *pfn = 0;
1067     if (!pfn)
1068         kPrf2WrapResolve((void **)&pfn, "GetCurrentThread", &g_Kernel32);
1069     return pfn ();
1070 }
1071
1072 typedef DWORD WINAPI FN_GetCurrentThreadId( VOID );
1073 __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetCurrentThreadId( VOID )
1074 {
1075     static FN_GetCurrentThreadId *pfn = 0;
1076     if (!pfn)
1077         kPrf2WrapResolve((void **)&pfn, "GetCurrentThreadId", &g_Kernel32);
1078     return pfn ();
1079 }
1080
1081 typedef BOOL WINAPI FN_SetThreadStackGuarantee( PULONG StackSizeInBytes );
1082 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetThreadStackGuarantee( PULONG StackSizeInBytes )
1083 {
1084     static FN_SetThreadStackGuarantee *pfn = 0;
1085     if (!pfn)
1086         kPrf2WrapResolve((void **)&pfn, "SetThreadStackGuarantee", &g_Kernel32);
1087     return pfn( StackSizeInBytes );
1088 }
1089
1090 typedef DWORD WINAPI FN_GetProcessIdOfThread( HANDLE Thread );
1091 __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetProcessIdOfThread( HANDLE Thread )
1092 {
1093     static FN_GetProcessIdOfThread *pfn = 0;
1094     if (!pfn)
1095         kPrf2WrapResolve((void **)&pfn, "GetProcessIdOfThread", &g_Kernel32);
1096     return pfn( Thread );
1097 }
1098
1099 typedef DWORD WINAPI FN_GetThreadId( HANDLE Thread );
1100 __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetThreadId( HANDLE Thread )
1101 {
1102     static FN_GetThreadId *pfn = 0;
1103     if (!pfn)
1104         kPrf2WrapResolve((void **)&pfn, "GetThreadId", &g_Kernel32);
1105     return pfn( Thread );
1106 }
1107
1108 typedef DWORD WINAPI FN_GetProcessId( HANDLE Process );
1109 __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetProcessId( HANDLE Process )
1110 {
1111     static FN_GetProcessId *pfn = 0;
1112     if (!pfn)
1113         kPrf2WrapResolve((void **)&pfn, "GetProcessId", &g_Kernel32);
1114     return pfn( Process );
1115 }
1116
1117 typedef DWORD WINAPI FN_GetCurrentProcessorNumber( VOID );
1118 __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetCurrentProcessorNumber( VOID )
1119 {
1120     static FN_GetCurrentProcessorNumber *pfn = 0;
1121     if (!pfn)
1122         kPrf2WrapResolve((void **)&pfn, "GetCurrentProcessorNumber", &g_Kernel32);
1123     return pfn ();
1124 }
1125
1126 typedef DWORD_PTR WINAPI FN_SetThreadAffinityMask( HANDLE hThread, DWORD_PTR dwThreadAffinityMask );
1127 __declspec(dllexport) DWORD_PTR WINAPI kPrf2Wrap_SetThreadAffinityMask( HANDLE hThread, DWORD_PTR dwThreadAffinityMask )
1128 {
1129     static FN_SetThreadAffinityMask *pfn = 0;
1130     if (!pfn)
1131         kPrf2WrapResolve((void **)&pfn, "SetThreadAffinityMask", &g_Kernel32);
1132     return pfn( hThread, dwThreadAffinityMask );
1133 }
1134
1135 typedef DWORD WINAPI FN_SetThreadIdealProcessor( HANDLE hThread, DWORD dwIdealProcessor );
1136 __declspec(dllexport) DWORD WINAPI kPrf2Wrap_SetThreadIdealProcessor( HANDLE hThread, DWORD dwIdealProcessor )
1137 {
1138     static FN_SetThreadIdealProcessor *pfn = 0;
1139     if (!pfn)
1140         kPrf2WrapResolve((void **)&pfn, "SetThreadIdealProcessor", &g_Kernel32);
1141     return pfn( hThread, dwIdealProcessor );
1142 }
1143
1144 typedef BOOL WINAPI FN_SetProcessPriorityBoost( HANDLE hProcess, BOOL bDisablePriorityBoost );
1145 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetProcessPriorityBoost( HANDLE hProcess, BOOL bDisablePriorityBoost )
1146 {
1147     static FN_SetProcessPriorityBoost *pfn = 0;
1148     if (!pfn)
1149         kPrf2WrapResolve((void **)&pfn, "SetProcessPriorityBoost", &g_Kernel32);
1150     return pfn( hProcess, bDisablePriorityBoost );
1151 }
1152
1153 typedef BOOL WINAPI FN_GetProcessPriorityBoost( HANDLE hProcess, PBOOL pDisablePriorityBoost );
1154 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetProcessPriorityBoost( HANDLE hProcess, PBOOL pDisablePriorityBoost )
1155 {
1156     static FN_GetProcessPriorityBoost *pfn = 0;
1157     if (!pfn)
1158         kPrf2WrapResolve((void **)&pfn, "GetProcessPriorityBoost", &g_Kernel32);
1159     return pfn( hProcess, pDisablePriorityBoost );
1160 }
1161
1162 typedef BOOL WINAPI FN_RequestWakeupLatency( LATENCY_TIME latency );
1163 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_RequestWakeupLatency( LATENCY_TIME latency )
1164 {
1165     static FN_RequestWakeupLatency *pfn = 0;
1166     if (!pfn)
1167         kPrf2WrapResolve((void **)&pfn, "RequestWakeupLatency", &g_Kernel32);
1168     return pfn( latency );
1169 }
1170
1171 typedef BOOL WINAPI FN_IsSystemResumeAutomatic( VOID );
1172 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_IsSystemResumeAutomatic( VOID )
1173 {
1174     static FN_IsSystemResumeAutomatic *pfn = 0;
1175     if (!pfn)
1176         kPrf2WrapResolve((void **)&pfn, "IsSystemResumeAutomatic", &g_Kernel32);
1177     return pfn ();
1178 }
1179
1180 typedef HANDLE WINAPI FN_OpenThread( DWORD dwDesiredAccess, BOOL bInheritHandle, DWORD dwThreadId );
1181 __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_OpenThread( DWORD dwDesiredAccess, BOOL bInheritHandle, DWORD dwThreadId )
1182 {
1183     static FN_OpenThread *pfn = 0;
1184     if (!pfn)
1185         kPrf2WrapResolve((void **)&pfn, "OpenThread", &g_Kernel32);
1186     return pfn( dwDesiredAccess, bInheritHandle, dwThreadId );
1187 }
1188
1189 typedef BOOL WINAPI FN_SetThreadPriority( HANDLE hThread, int nPriority );
1190 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetThreadPriority( HANDLE hThread, int nPriority )
1191 {
1192     static FN_SetThreadPriority *pfn = 0;
1193     if (!pfn)
1194         kPrf2WrapResolve((void **)&pfn, "SetThreadPriority", &g_Kernel32);
1195     return pfn( hThread, nPriority );
1196 }
1197
1198 typedef BOOL WINAPI FN_SetThreadPriorityBoost( HANDLE hThread, BOOL bDisablePriorityBoost );
1199 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetThreadPriorityBoost( HANDLE hThread, BOOL bDisablePriorityBoost )
1200 {
1201     static FN_SetThreadPriorityBoost *pfn = 0;
1202     if (!pfn)
1203         kPrf2WrapResolve((void **)&pfn, "SetThreadPriorityBoost", &g_Kernel32);
1204     return pfn( hThread, bDisablePriorityBoost );
1205 }
1206
1207 typedef BOOL WINAPI FN_GetThreadPriorityBoost( HANDLE hThread, PBOOL pDisablePriorityBoost );
1208 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetThreadPriorityBoost( HANDLE hThread, PBOOL pDisablePriorityBoost )
1209 {
1210     static FN_GetThreadPriorityBoost *pfn = 0;
1211     if (!pfn)
1212         kPrf2WrapResolve((void **)&pfn, "GetThreadPriorityBoost", &g_Kernel32);
1213     return pfn( hThread, pDisablePriorityBoost );
1214 }
1215
1216 typedef int WINAPI FN_GetThreadPriority( HANDLE hThread );
1217 __declspec(dllexport) int WINAPI kPrf2Wrap_GetThreadPriority( HANDLE hThread )
1218 {
1219     static FN_GetThreadPriority *pfn = 0;
1220     if (!pfn)
1221         kPrf2WrapResolve((void **)&pfn, "GetThreadPriority", &g_Kernel32);
1222     return pfn( hThread );
1223 }
1224
1225 typedef BOOL WINAPI FN_GetThreadTimes( HANDLE hThread, LPFILETIME lpCreationTime, LPFILETIME lpExitTime, LPFILETIME lpKernelTime, LPFILETIME lpUserTime );
1226 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetThreadTimes( HANDLE hThread, LPFILETIME lpCreationTime, LPFILETIME lpExitTime, LPFILETIME lpKernelTime, LPFILETIME lpUserTime )
1227 {
1228     static FN_GetThreadTimes *pfn = 0;
1229     if (!pfn)
1230         kPrf2WrapResolve((void **)&pfn, "GetThreadTimes", &g_Kernel32);
1231     return pfn( hThread, lpCreationTime, lpExitTime, lpKernelTime, lpUserTime );
1232 }
1233
1234 typedef BOOL WINAPI FN_GetThreadIOPendingFlag( HANDLE hThread, PBOOL lpIOIsPending );
1235 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetThreadIOPendingFlag( HANDLE hThread, PBOOL lpIOIsPending )
1236 {
1237     static FN_GetThreadIOPendingFlag *pfn = 0;
1238     if (!pfn)
1239         kPrf2WrapResolve((void **)&pfn, "GetThreadIOPendingFlag", &g_Kernel32);
1240     return pfn( hThread, lpIOIsPending );
1241 }
1242
1243 typedef VOID WINAPI FN_ExitThread( DWORD dwExitCode );
1244 __declspec(dllexport) VOID WINAPI kPrf2Wrap_ExitThread( DWORD dwExitCode )
1245 {
1246     static FN_ExitThread *pfn = 0;
1247     if (!pfn)
1248         kPrf2WrapResolve((void **)&pfn, "ExitThread", &g_Kernel32);
1249     pfn( dwExitCode );
1250 }
1251
1252 typedef BOOL WINAPI FN_TerminateThread( HANDLE hThread, DWORD dwExitCode );
1253 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_TerminateThread( HANDLE hThread, DWORD dwExitCode )
1254 {
1255     static FN_TerminateThread *pfn = 0;
1256     if (!pfn)
1257         kPrf2WrapResolve((void **)&pfn, "TerminateThread", &g_Kernel32);
1258     return pfn( hThread, dwExitCode );
1259 }
1260
1261 typedef BOOL WINAPI FN_GetExitCodeThread( HANDLE hThread, LPDWORD lpExitCode );
1262 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetExitCodeThread( HANDLE hThread, LPDWORD lpExitCode )
1263 {
1264     static FN_GetExitCodeThread *pfn = 0;
1265     if (!pfn)
1266         kPrf2WrapResolve((void **)&pfn, "GetExitCodeThread", &g_Kernel32);
1267     return pfn( hThread, lpExitCode );
1268 }
1269
1270 typedef BOOL WINAPI FN_GetThreadSelectorEntry( HANDLE hThread, DWORD dwSelector, LPLDT_ENTRY lpSelectorEntry );
1271 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetThreadSelectorEntry( HANDLE hThread, DWORD dwSelector, LPLDT_ENTRY lpSelectorEntry )
1272 {
1273     static FN_GetThreadSelectorEntry *pfn = 0;
1274     if (!pfn)
1275         kPrf2WrapResolve((void **)&pfn, "GetThreadSelectorEntry", &g_Kernel32);
1276     return pfn( hThread, dwSelector, lpSelectorEntry );
1277 }
1278
1279 typedef EXECUTION_STATE WINAPI FN_SetThreadExecutionState( EXECUTION_STATE esFlags );
1280 __declspec(dllexport) EXECUTION_STATE WINAPI kPrf2Wrap_SetThreadExecutionState( EXECUTION_STATE esFlags )
1281 {
1282     static FN_SetThreadExecutionState *pfn = 0;
1283     if (!pfn)
1284         kPrf2WrapResolve((void **)&pfn, "SetThreadExecutionState", &g_Kernel32);
1285     return pfn( esFlags );
1286 }
1287
1288 typedef DWORD WINAPI FN_GetLastError( VOID );
1289 __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetLastError( VOID )
1290 {
1291     static FN_GetLastError *pfn = 0;
1292     if (!pfn)
1293         kPrf2WrapResolve((void **)&pfn, "GetLastError", &g_Kernel32);
1294     return pfn ();
1295 }
1296
1297 typedef VOID WINAPI FN_SetLastError( DWORD dwErrCode );
1298 __declspec(dllexport) VOID WINAPI kPrf2Wrap_SetLastError( DWORD dwErrCode )
1299 {
1300     static FN_SetLastError *pfn = 0;
1301     if (!pfn)
1302         kPrf2WrapResolve((void **)&pfn, "SetLastError", &g_Kernel32);
1303     pfn( dwErrCode );
1304 }
1305
1306 typedef VOID WINAPI FN_RestoreLastError( DWORD dwErrCode );
1307 __declspec(dllexport) VOID WINAPI kPrf2Wrap_RestoreLastError( DWORD dwErrCode )
1308 {
1309     static FN_RestoreLastError *pfn = 0;
1310     if (!pfn)
1311         kPrf2WrapResolve((void **)&pfn, "RestoreLastError", &g_Kernel32);
1312     pfn( dwErrCode );
1313 }
1314
1315 typedef BOOL WINAPI FN_GetOverlappedResult( HANDLE hFile, LPOVERLAPPED lpOverlapped, LPDWORD lpNumberOfBytesTransferred, BOOL bWait );
1316 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetOverlappedResult( HANDLE hFile, LPOVERLAPPED lpOverlapped, LPDWORD lpNumberOfBytesTransferred, BOOL bWait )
1317 {
1318     static FN_GetOverlappedResult *pfn = 0;
1319     if (!pfn)
1320         kPrf2WrapResolve((void **)&pfn, "GetOverlappedResult", &g_Kernel32);
1321     return pfn( hFile, lpOverlapped, lpNumberOfBytesTransferred, bWait );
1322 }
1323
1324 typedef HANDLE WINAPI FN_CreateIoCompletionPort( HANDLE FileHandle, HANDLE ExistingCompletionPort, ULONG_PTR CompletionKey, DWORD NumberOfConcurrentThreads );
1325 __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_CreateIoCompletionPort( HANDLE FileHandle, HANDLE ExistingCompletionPort, ULONG_PTR CompletionKey, DWORD NumberOfConcurrentThreads )
1326 {
1327     static FN_CreateIoCompletionPort *pfn = 0;
1328     if (!pfn)
1329         kPrf2WrapResolve((void **)&pfn, "CreateIoCompletionPort", &g_Kernel32);
1330     return pfn( FileHandle, ExistingCompletionPort, CompletionKey, NumberOfConcurrentThreads );
1331 }
1332
1333 typedef BOOL WINAPI FN_GetQueuedCompletionStatus( HANDLE CompletionPort, LPDWORD lpNumberOfBytesTransferred, PULONG_PTR lpCompletionKey, LPOVERLAPPED * lpOverlapped, DWORD dwMilliseconds );
1334 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetQueuedCompletionStatus( HANDLE CompletionPort, LPDWORD lpNumberOfBytesTransferred, PULONG_PTR lpCompletionKey, LPOVERLAPPED * lpOverlapped, DWORD dwMilliseconds )
1335 {
1336     static FN_GetQueuedCompletionStatus *pfn = 0;
1337     if (!pfn)
1338         kPrf2WrapResolve((void **)&pfn, "GetQueuedCompletionStatus", &g_Kernel32);
1339     return pfn( CompletionPort, lpNumberOfBytesTransferred, lpCompletionKey, lpOverlapped, dwMilliseconds );
1340 }
1341
1342 typedef BOOL WINAPI FN_PostQueuedCompletionStatus( HANDLE CompletionPort, DWORD dwNumberOfBytesTransferred, ULONG_PTR dwCompletionKey, LPOVERLAPPED lpOverlapped );
1343 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_PostQueuedCompletionStatus( HANDLE CompletionPort, DWORD dwNumberOfBytesTransferred, ULONG_PTR dwCompletionKey, LPOVERLAPPED lpOverlapped )
1344 {
1345     static FN_PostQueuedCompletionStatus *pfn = 0;
1346     if (!pfn)
1347         kPrf2WrapResolve((void **)&pfn, "PostQueuedCompletionStatus", &g_Kernel32);
1348     return pfn( CompletionPort, dwNumberOfBytesTransferred, dwCompletionKey, lpOverlapped );
1349 }
1350
1351 typedef UINT WINAPI FN_SetErrorMode( UINT uMode );
1352 __declspec(dllexport) UINT WINAPI kPrf2Wrap_SetErrorMode( UINT uMode )
1353 {
1354     static FN_SetErrorMode *pfn = 0;
1355     if (!pfn)
1356         kPrf2WrapResolve((void **)&pfn, "SetErrorMode", &g_Kernel32);
1357     return pfn( uMode );
1358 }
1359
1360 typedef BOOL WINAPI FN_ReadProcessMemory( HANDLE hProcess, LPCVOID lpBaseAddress, LPVOID lpBuffer, SIZE_T nSize, SIZE_T * lpNumberOfBytesRead );
1361 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_ReadProcessMemory( HANDLE hProcess, LPCVOID lpBaseAddress, LPVOID lpBuffer, SIZE_T nSize, SIZE_T * lpNumberOfBytesRead )
1362 {
1363     static FN_ReadProcessMemory *pfn = 0;
1364     if (!pfn)
1365         kPrf2WrapResolve((void **)&pfn, "ReadProcessMemory", &g_Kernel32);
1366     return pfn( hProcess, lpBaseAddress, lpBuffer, nSize, lpNumberOfBytesRead );
1367 }
1368
1369 typedef BOOL WINAPI FN_WriteProcessMemory( HANDLE hProcess, LPVOID lpBaseAddress, LPCVOID lpBuffer, SIZE_T nSize, SIZE_T * lpNumberOfBytesWritten );
1370 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_WriteProcessMemory( HANDLE hProcess, LPVOID lpBaseAddress, LPCVOID lpBuffer, SIZE_T nSize, SIZE_T * lpNumberOfBytesWritten )
1371 {
1372     static FN_WriteProcessMemory *pfn = 0;
1373     if (!pfn)
1374         kPrf2WrapResolve((void **)&pfn, "WriteProcessMemory", &g_Kernel32);
1375     return pfn( hProcess, lpBaseAddress, lpBuffer, nSize, lpNumberOfBytesWritten );
1376 }
1377
1378 typedef BOOL WINAPI FN_GetThreadContext( HANDLE hThread, LPCONTEXT lpContext );
1379 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetThreadContext( HANDLE hThread, LPCONTEXT lpContext )
1380 {
1381     static FN_GetThreadContext *pfn = 0;
1382     if (!pfn)
1383         kPrf2WrapResolve((void **)&pfn, "GetThreadContext", &g_Kernel32);
1384     return pfn( hThread, lpContext );
1385 }
1386
1387 typedef BOOL WINAPI FN_SetThreadContext( HANDLE hThread, CONST CONTEXT * lpContext );
1388 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetThreadContext( HANDLE hThread, CONST CONTEXT * lpContext )
1389 {
1390     static FN_SetThreadContext *pfn = 0;
1391     if (!pfn)
1392         kPrf2WrapResolve((void **)&pfn, "SetThreadContext", &g_Kernel32);
1393     return pfn( hThread, lpContext );
1394 }
1395
1396 typedef DWORD WINAPI FN_SuspendThread( HANDLE hThread );
1397 __declspec(dllexport) DWORD WINAPI kPrf2Wrap_SuspendThread( HANDLE hThread )
1398 {
1399     static FN_SuspendThread *pfn = 0;
1400     if (!pfn)
1401         kPrf2WrapResolve((void **)&pfn, "SuspendThread", &g_Kernel32);
1402     return pfn( hThread );
1403 }
1404
1405 typedef DWORD WINAPI FN_ResumeThread( HANDLE hThread );
1406 __declspec(dllexport) DWORD WINAPI kPrf2Wrap_ResumeThread( HANDLE hThread )
1407 {
1408     static FN_ResumeThread *pfn = 0;
1409     if (!pfn)
1410         kPrf2WrapResolve((void **)&pfn, "ResumeThread", &g_Kernel32);
1411     return pfn( hThread );
1412 }
1413
1414 typedef DWORD WINAPI FN_QueueUserAPC( PAPCFUNC pfnAPC, HANDLE hThread, ULONG_PTR dwData );
1415 __declspec(dllexport) DWORD WINAPI kPrf2Wrap_QueueUserAPC( PAPCFUNC pfnAPC, HANDLE hThread, ULONG_PTR dwData )
1416 {
1417     static FN_QueueUserAPC *pfn = 0;
1418     if (!pfn)
1419         kPrf2WrapResolve((void **)&pfn, "QueueUserAPC", &g_Kernel32);
1420     return pfn( pfnAPC, hThread, dwData );
1421 }
1422
1423 typedef BOOL WINAPI FN_IsDebuggerPresent( VOID );
1424 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_IsDebuggerPresent( VOID )
1425 {
1426     static FN_IsDebuggerPresent *pfn = 0;
1427     if (!pfn)
1428         kPrf2WrapResolve((void **)&pfn, "IsDebuggerPresent", &g_Kernel32);
1429     return pfn ();
1430 }
1431
1432 typedef BOOL WINAPI FN_CheckRemoteDebuggerPresent( HANDLE hProcess, PBOOL pbDebuggerPresent );
1433 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_CheckRemoteDebuggerPresent( HANDLE hProcess, PBOOL pbDebuggerPresent )
1434 {
1435     static FN_CheckRemoteDebuggerPresent *pfn = 0;
1436     if (!pfn)
1437         kPrf2WrapResolve((void **)&pfn, "CheckRemoteDebuggerPresent", &g_Kernel32);
1438     return pfn( hProcess, pbDebuggerPresent );
1439 }
1440
1441 typedef VOID WINAPI FN_DebugBreak( VOID );
1442 __declspec(dllexport) VOID WINAPI kPrf2Wrap_DebugBreak( VOID )
1443 {
1444     static FN_DebugBreak *pfn = 0;
1445     if (!pfn)
1446         kPrf2WrapResolve((void **)&pfn, "DebugBreak", &g_Kernel32);
1447     pfn ();
1448 }
1449
1450 typedef BOOL WINAPI FN_WaitForDebugEvent( LPDEBUG_EVENT lpDebugEvent, DWORD dwMilliseconds );
1451 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_WaitForDebugEvent( LPDEBUG_EVENT lpDebugEvent, DWORD dwMilliseconds )
1452 {
1453     static FN_WaitForDebugEvent *pfn = 0;
1454     if (!pfn)
1455         kPrf2WrapResolve((void **)&pfn, "WaitForDebugEvent", &g_Kernel32);
1456     return pfn( lpDebugEvent, dwMilliseconds );
1457 }
1458
1459 typedef BOOL WINAPI FN_ContinueDebugEvent( DWORD dwProcessId, DWORD dwThreadId, DWORD dwContinueStatus );
1460 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_ContinueDebugEvent( DWORD dwProcessId, DWORD dwThreadId, DWORD dwContinueStatus )
1461 {
1462     static FN_ContinueDebugEvent *pfn = 0;
1463     if (!pfn)
1464         kPrf2WrapResolve((void **)&pfn, "ContinueDebugEvent", &g_Kernel32);
1465     return pfn( dwProcessId, dwThreadId, dwContinueStatus );
1466 }
1467
1468 typedef BOOL WINAPI FN_DebugActiveProcess( DWORD dwProcessId );
1469 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_DebugActiveProcess( DWORD dwProcessId )
1470 {
1471     static FN_DebugActiveProcess *pfn = 0;
1472     if (!pfn)
1473         kPrf2WrapResolve((void **)&pfn, "DebugActiveProcess", &g_Kernel32);
1474     return pfn( dwProcessId );
1475 }
1476
1477 typedef BOOL WINAPI FN_DebugActiveProcessStop( DWORD dwProcessId );
1478 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_DebugActiveProcessStop( DWORD dwProcessId )
1479 {
1480     static FN_DebugActiveProcessStop *pfn = 0;
1481     if (!pfn)
1482         kPrf2WrapResolve((void **)&pfn, "DebugActiveProcessStop", &g_Kernel32);
1483     return pfn( dwProcessId );
1484 }
1485
1486 typedef BOOL WINAPI FN_DebugSetProcessKillOnExit( BOOL KillOnExit );
1487 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_DebugSetProcessKillOnExit( BOOL KillOnExit )
1488 {
1489     static FN_DebugSetProcessKillOnExit *pfn = 0;
1490     if (!pfn)
1491         kPrf2WrapResolve((void **)&pfn, "DebugSetProcessKillOnExit", &g_Kernel32);
1492     return pfn( KillOnExit );
1493 }
1494
1495 typedef BOOL WINAPI FN_DebugBreakProcess( HANDLE Process );
1496 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_DebugBreakProcess( HANDLE Process )
1497 {
1498     static FN_DebugBreakProcess *pfn = 0;
1499     if (!pfn)
1500         kPrf2WrapResolve((void **)&pfn, "DebugBreakProcess", &g_Kernel32);
1501     return pfn( Process );
1502 }
1503
1504 typedef VOID WINAPI FN_InitializeCriticalSection( LPCRITICAL_SECTION lpCriticalSection );
1505 __declspec(dllexport) VOID WINAPI kPrf2Wrap_InitializeCriticalSection( LPCRITICAL_SECTION lpCriticalSection )
1506 {
1507     static FN_InitializeCriticalSection *pfn = 0;
1508     if (!pfn)
1509         kPrf2WrapResolve((void **)&pfn, "InitializeCriticalSection", &g_Kernel32);
1510     pfn( lpCriticalSection );
1511 }
1512
1513 typedef VOID WINAPI FN_EnterCriticalSection( LPCRITICAL_SECTION lpCriticalSection );
1514 __declspec(dllexport) VOID WINAPI kPrf2Wrap_EnterCriticalSection( LPCRITICAL_SECTION lpCriticalSection )
1515 {
1516     static FN_EnterCriticalSection *pfn = 0;
1517     if (!pfn)
1518         kPrf2WrapResolve((void **)&pfn, "EnterCriticalSection", &g_Kernel32);
1519     pfn( lpCriticalSection );
1520 }
1521
1522 typedef VOID WINAPI FN_LeaveCriticalSection( LPCRITICAL_SECTION lpCriticalSection );
1523 __declspec(dllexport) VOID WINAPI kPrf2Wrap_LeaveCriticalSection( LPCRITICAL_SECTION lpCriticalSection )
1524 {
1525     static FN_LeaveCriticalSection *pfn = 0;
1526     if (!pfn)
1527         kPrf2WrapResolve((void **)&pfn, "LeaveCriticalSection", &g_Kernel32);
1528     pfn( lpCriticalSection );
1529 }
1530
1531 typedef BOOL WINAPI FN_InitializeCriticalSectionAndSpinCount( LPCRITICAL_SECTION lpCriticalSection, DWORD dwSpinCount );
1532 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_InitializeCriticalSectionAndSpinCount( LPCRITICAL_SECTION lpCriticalSection, DWORD dwSpinCount )
1533 {
1534     static FN_InitializeCriticalSectionAndSpinCount *pfn = 0;
1535     if (!pfn)
1536         kPrf2WrapResolve((void **)&pfn, "InitializeCriticalSectionAndSpinCount", &g_Kernel32);
1537     return pfn( lpCriticalSection, dwSpinCount );
1538 }
1539
1540 typedef DWORD WINAPI FN_SetCriticalSectionSpinCount( LPCRITICAL_SECTION lpCriticalSection, DWORD dwSpinCount );
1541 __declspec(dllexport) DWORD WINAPI kPrf2Wrap_SetCriticalSectionSpinCount( LPCRITICAL_SECTION lpCriticalSection, DWORD dwSpinCount )
1542 {
1543     static FN_SetCriticalSectionSpinCount *pfn = 0;
1544     if (!pfn)
1545         kPrf2WrapResolve((void **)&pfn, "SetCriticalSectionSpinCount", &g_Kernel32);
1546     return pfn( lpCriticalSection, dwSpinCount );
1547 }
1548
1549 typedef BOOL WINAPI FN_TryEnterCriticalSection( LPCRITICAL_SECTION lpCriticalSection );
1550 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_TryEnterCriticalSection( LPCRITICAL_SECTION lpCriticalSection )
1551 {
1552     static FN_TryEnterCriticalSection *pfn = 0;
1553     if (!pfn)
1554         kPrf2WrapResolve((void **)&pfn, "TryEnterCriticalSection", &g_Kernel32);
1555     return pfn( lpCriticalSection );
1556 }
1557
1558 typedef VOID WINAPI FN_DeleteCriticalSection( LPCRITICAL_SECTION lpCriticalSection );
1559 __declspec(dllexport) VOID WINAPI kPrf2Wrap_DeleteCriticalSection( LPCRITICAL_SECTION lpCriticalSection )
1560 {
1561     static FN_DeleteCriticalSection *pfn = 0;
1562     if (!pfn)
1563         kPrf2WrapResolve((void **)&pfn, "DeleteCriticalSection", &g_Kernel32);
1564     pfn( lpCriticalSection );
1565 }
1566
1567 typedef BOOL WINAPI FN_SetEvent( HANDLE hEvent );
1568 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetEvent( HANDLE hEvent )
1569 {
1570     static FN_SetEvent *pfn = 0;
1571     if (!pfn)
1572         kPrf2WrapResolve((void **)&pfn, "SetEvent", &g_Kernel32);
1573     return pfn( hEvent );
1574 }
1575
1576 typedef BOOL WINAPI FN_ResetEvent( HANDLE hEvent );
1577 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_ResetEvent( HANDLE hEvent )
1578 {
1579     static FN_ResetEvent *pfn = 0;
1580     if (!pfn)
1581         kPrf2WrapResolve((void **)&pfn, "ResetEvent", &g_Kernel32);
1582     return pfn( hEvent );
1583 }
1584
1585 typedef BOOL WINAPI FN_PulseEvent( HANDLE hEvent );
1586 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_PulseEvent( HANDLE hEvent )
1587 {
1588     static FN_PulseEvent *pfn = 0;
1589     if (!pfn)
1590         kPrf2WrapResolve((void **)&pfn, "PulseEvent", &g_Kernel32);
1591     return pfn( hEvent );
1592 }
1593
1594 typedef BOOL WINAPI FN_ReleaseSemaphore( HANDLE hSemaphore, LONG lReleaseCount, LPLONG lpPreviousCount );
1595 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_ReleaseSemaphore( HANDLE hSemaphore, LONG lReleaseCount, LPLONG lpPreviousCount )
1596 {
1597     static FN_ReleaseSemaphore *pfn = 0;
1598     if (!pfn)
1599         kPrf2WrapResolve((void **)&pfn, "ReleaseSemaphore", &g_Kernel32);
1600     return pfn( hSemaphore, lReleaseCount, lpPreviousCount );
1601 }
1602
1603 typedef BOOL WINAPI FN_ReleaseMutex( HANDLE hMutex );
1604 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_ReleaseMutex( HANDLE hMutex )
1605 {
1606     static FN_ReleaseMutex *pfn = 0;
1607     if (!pfn)
1608         kPrf2WrapResolve((void **)&pfn, "ReleaseMutex", &g_Kernel32);
1609     return pfn( hMutex );
1610 }
1611
1612 typedef DWORD WINAPI FN_WaitForSingleObject( HANDLE hHandle, DWORD dwMilliseconds );
1613 __declspec(dllexport) DWORD WINAPI kPrf2Wrap_WaitForSingleObject( HANDLE hHandle, DWORD dwMilliseconds )
1614 {
1615     static FN_WaitForSingleObject *pfn = 0;
1616     if (!pfn)
1617         kPrf2WrapResolve((void **)&pfn, "WaitForSingleObject", &g_Kernel32);
1618     return pfn( hHandle, dwMilliseconds );
1619 }
1620
1621 typedef DWORD WINAPI FN_WaitForMultipleObjects( DWORD nCount, CONST HANDLE * lpHandles, BOOL bWaitAll, DWORD dwMilliseconds );
1622 __declspec(dllexport) DWORD WINAPI kPrf2Wrap_WaitForMultipleObjects( DWORD nCount, CONST HANDLE * lpHandles, BOOL bWaitAll, DWORD dwMilliseconds )
1623 {
1624     static FN_WaitForMultipleObjects *pfn = 0;
1625     if (!pfn)
1626         kPrf2WrapResolve((void **)&pfn, "WaitForMultipleObjects", &g_Kernel32);
1627     return pfn( nCount, lpHandles, bWaitAll, dwMilliseconds );
1628 }
1629
1630 typedef VOID WINAPI FN_Sleep( DWORD dwMilliseconds );
1631 __declspec(dllexport) VOID WINAPI kPrf2Wrap_Sleep( DWORD dwMilliseconds )
1632 {
1633     static FN_Sleep *pfn = 0;
1634     if (!pfn)
1635         kPrf2WrapResolve((void **)&pfn, "Sleep", &g_Kernel32);
1636     pfn( dwMilliseconds );
1637 }
1638
1639 typedef HGLOBAL WINAPI FN_LoadResource( HMODULE hModule, HRSRC hResInfo );
1640 __declspec(dllexport) HGLOBAL WINAPI kPrf2Wrap_LoadResource( HMODULE hModule, HRSRC hResInfo )
1641 {
1642     static FN_LoadResource *pfn = 0;
1643     if (!pfn)
1644         kPrf2WrapResolve((void **)&pfn, "LoadResource", &g_Kernel32);
1645     return pfn( hModule, hResInfo );
1646 }
1647
1648 typedef DWORD WINAPI FN_SizeofResource( HMODULE hModule, HRSRC hResInfo );
1649 __declspec(dllexport) DWORD WINAPI kPrf2Wrap_SizeofResource( HMODULE hModule, HRSRC hResInfo )
1650 {
1651     static FN_SizeofResource *pfn = 0;
1652     if (!pfn)
1653         kPrf2WrapResolve((void **)&pfn, "SizeofResource", &g_Kernel32);
1654     return pfn( hModule, hResInfo );
1655 }
1656
1657 typedef ATOM WINAPI FN_GlobalDeleteAtom( ATOM nAtom );
1658 __declspec(dllexport) ATOM WINAPI kPrf2Wrap_GlobalDeleteAtom( ATOM nAtom )
1659 {
1660     static FN_GlobalDeleteAtom *pfn = 0;
1661     if (!pfn)
1662         kPrf2WrapResolve((void **)&pfn, "GlobalDeleteAtom", &g_Kernel32);
1663     return pfn( nAtom );
1664 }
1665
1666 typedef BOOL WINAPI FN_InitAtomTable( DWORD nSize );
1667 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_InitAtomTable( DWORD nSize )
1668 {
1669     static FN_InitAtomTable *pfn = 0;
1670     if (!pfn)
1671         kPrf2WrapResolve((void **)&pfn, "InitAtomTable", &g_Kernel32);
1672     return pfn( nSize );
1673 }
1674
1675 typedef ATOM WINAPI FN_DeleteAtom( ATOM nAtom );
1676 __declspec(dllexport) ATOM WINAPI kPrf2Wrap_DeleteAtom( ATOM nAtom )
1677 {
1678     static FN_DeleteAtom *pfn = 0;
1679     if (!pfn)
1680         kPrf2WrapResolve((void **)&pfn, "DeleteAtom", &g_Kernel32);
1681     return pfn( nAtom );
1682 }
1683
1684 typedef UINT WINAPI FN_SetHandleCount( UINT uNumber );
1685 __declspec(dllexport) UINT WINAPI kPrf2Wrap_SetHandleCount( UINT uNumber )
1686 {
1687     static FN_SetHandleCount *pfn = 0;
1688     if (!pfn)
1689         kPrf2WrapResolve((void **)&pfn, "SetHandleCount", &g_Kernel32);
1690     return pfn( uNumber );
1691 }
1692
1693 typedef DWORD WINAPI FN_GetLogicalDrives( VOID );
1694 __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetLogicalDrives( VOID )
1695 {
1696     static FN_GetLogicalDrives *pfn = 0;
1697     if (!pfn)
1698         kPrf2WrapResolve((void **)&pfn, "GetLogicalDrives", &g_Kernel32);
1699     return pfn ();
1700 }
1701
1702 typedef BOOL WINAPI FN_LockFile( HANDLE hFile, DWORD dwFileOffsetLow, DWORD dwFileOffsetHigh, DWORD nNumberOfBytesToLockLow, DWORD nNumberOfBytesToLockHigh );
1703 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_LockFile( HANDLE hFile, DWORD dwFileOffsetLow, DWORD dwFileOffsetHigh, DWORD nNumberOfBytesToLockLow, DWORD nNumberOfBytesToLockHigh )
1704 {
1705     static FN_LockFile *pfn = 0;
1706     if (!pfn)
1707         kPrf2WrapResolve((void **)&pfn, "LockFile", &g_Kernel32);
1708     return pfn( hFile, dwFileOffsetLow, dwFileOffsetHigh, nNumberOfBytesToLockLow, nNumberOfBytesToLockHigh );
1709 }
1710
1711 typedef BOOL WINAPI FN_UnlockFile( HANDLE hFile, DWORD dwFileOffsetLow, DWORD dwFileOffsetHigh, DWORD nNumberOfBytesToUnlockLow, DWORD nNumberOfBytesToUnlockHigh );
1712 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_UnlockFile( HANDLE hFile, DWORD dwFileOffsetLow, DWORD dwFileOffsetHigh, DWORD nNumberOfBytesToUnlockLow, DWORD nNumberOfBytesToUnlockHigh )
1713 {
1714     static FN_UnlockFile *pfn = 0;
1715     if (!pfn)
1716         kPrf2WrapResolve((void **)&pfn, "UnlockFile", &g_Kernel32);
1717     return pfn( hFile, dwFileOffsetLow, dwFileOffsetHigh, nNumberOfBytesToUnlockLow, nNumberOfBytesToUnlockHigh );
1718 }
1719
1720 typedef BOOL WINAPI FN_LockFileEx( HANDLE hFile, DWORD dwFlags, DWORD dwReserved, DWORD nNumberOfBytesToLockLow, DWORD nNumberOfBytesToLockHigh, LPOVERLAPPED lpOverlapped );
1721 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_LockFileEx( HANDLE hFile, DWORD dwFlags, DWORD dwReserved, DWORD nNumberOfBytesToLockLow, DWORD nNumberOfBytesToLockHigh, LPOVERLAPPED lpOverlapped )
1722 {
1723     static FN_LockFileEx *pfn = 0;
1724     if (!pfn)
1725         kPrf2WrapResolve((void **)&pfn, "LockFileEx", &g_Kernel32);
1726     return pfn( hFile, dwFlags, dwReserved, nNumberOfBytesToLockLow, nNumberOfBytesToLockHigh, lpOverlapped );
1727 }
1728
1729 typedef BOOL WINAPI FN_UnlockFileEx( HANDLE hFile, DWORD dwReserved, DWORD nNumberOfBytesToUnlockLow, DWORD nNumberOfBytesToUnlockHigh, LPOVERLAPPED lpOverlapped );
1730 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_UnlockFileEx( HANDLE hFile, DWORD dwReserved, DWORD nNumberOfBytesToUnlockLow, DWORD nNumberOfBytesToUnlockHigh, LPOVERLAPPED lpOverlapped )
1731 {
1732     static FN_UnlockFileEx *pfn = 0;
1733     if (!pfn)
1734         kPrf2WrapResolve((void **)&pfn, "UnlockFileEx", &g_Kernel32);
1735     return pfn( hFile, dwReserved, nNumberOfBytesToUnlockLow, nNumberOfBytesToUnlockHigh, lpOverlapped );
1736 }
1737
1738 typedef BOOL WINAPI FN_GetFileInformationByHandle( HANDLE hFile, LPBY_HANDLE_FILE_INFORMATION lpFileInformation );
1739 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetFileInformationByHandle( HANDLE hFile, LPBY_HANDLE_FILE_INFORMATION lpFileInformation )
1740 {
1741     static FN_GetFileInformationByHandle *pfn = 0;
1742     if (!pfn)
1743         kPrf2WrapResolve((void **)&pfn, "GetFileInformationByHandle", &g_Kernel32);
1744     return pfn( hFile, lpFileInformation );
1745 }
1746
1747 typedef DWORD WINAPI FN_GetFileType( HANDLE hFile );
1748 __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetFileType( HANDLE hFile )
1749 {
1750     static FN_GetFileType *pfn = 0;
1751     if (!pfn)
1752         kPrf2WrapResolve((void **)&pfn, "GetFileType", &g_Kernel32);
1753     return pfn( hFile );
1754 }
1755
1756 typedef DWORD WINAPI FN_GetFileSize( HANDLE hFile, LPDWORD lpFileSizeHigh );
1757 __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetFileSize( HANDLE hFile, LPDWORD lpFileSizeHigh )
1758 {
1759     static FN_GetFileSize *pfn = 0;
1760     if (!pfn)
1761         kPrf2WrapResolve((void **)&pfn, "GetFileSize", &g_Kernel32);
1762     return pfn( hFile, lpFileSizeHigh );
1763 }
1764
1765 typedef BOOL WINAPI FN_GetFileSizeEx( HANDLE hFile, PLARGE_INTEGER lpFileSize );
1766 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetFileSizeEx( HANDLE hFile, PLARGE_INTEGER lpFileSize )
1767 {
1768     static FN_GetFileSizeEx *pfn = 0;
1769     if (!pfn)
1770         kPrf2WrapResolve((void **)&pfn, "GetFileSizeEx", &g_Kernel32);
1771     return pfn( hFile, lpFileSize );
1772 }
1773
1774 typedef HANDLE WINAPI FN_GetStdHandle( DWORD nStdHandle );
1775 __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_GetStdHandle( DWORD nStdHandle )
1776 {
1777     static FN_GetStdHandle *pfn = 0;
1778     if (!pfn)
1779         kPrf2WrapResolve((void **)&pfn, "GetStdHandle", &g_Kernel32);
1780     return pfn( nStdHandle );
1781 }
1782
1783 typedef BOOL WINAPI FN_SetStdHandle( DWORD nStdHandle, HANDLE hHandle );
1784 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetStdHandle( DWORD nStdHandle, HANDLE hHandle )
1785 {
1786     static FN_SetStdHandle *pfn = 0;
1787     if (!pfn)
1788         kPrf2WrapResolve((void **)&pfn, "SetStdHandle", &g_Kernel32);
1789     return pfn( nStdHandle, hHandle );
1790 }
1791
1792 typedef BOOL WINAPI FN_WriteFile( HANDLE hFile, LPCVOID lpBuffer, DWORD nNumberOfBytesToWrite, LPDWORD lpNumberOfBytesWritten, LPOVERLAPPED lpOverlapped );
1793 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_WriteFile( HANDLE hFile, LPCVOID lpBuffer, DWORD nNumberOfBytesToWrite, LPDWORD lpNumberOfBytesWritten, LPOVERLAPPED lpOverlapped )
1794 {
1795     static FN_WriteFile *pfn = 0;
1796     if (!pfn)
1797         kPrf2WrapResolve((void **)&pfn, "WriteFile", &g_Kernel32);
1798     return pfn( hFile, lpBuffer, nNumberOfBytesToWrite, lpNumberOfBytesWritten, lpOverlapped );
1799 }
1800
1801 typedef BOOL WINAPI FN_ReadFile( HANDLE hFile, LPVOID lpBuffer, DWORD nNumberOfBytesToRead, LPDWORD lpNumberOfBytesRead, LPOVERLAPPED lpOverlapped );
1802 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_ReadFile( HANDLE hFile, LPVOID lpBuffer, DWORD nNumberOfBytesToRead, LPDWORD lpNumberOfBytesRead, LPOVERLAPPED lpOverlapped )
1803 {
1804     static FN_ReadFile *pfn = 0;
1805     if (!pfn)
1806         kPrf2WrapResolve((void **)&pfn, "ReadFile", &g_Kernel32);
1807     return pfn( hFile, lpBuffer, nNumberOfBytesToRead, lpNumberOfBytesRead, lpOverlapped );
1808 }
1809
1810 typedef BOOL WINAPI FN_FlushFileBuffers( HANDLE hFile );
1811 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_FlushFileBuffers( HANDLE hFile )
1812 {
1813     static FN_FlushFileBuffers *pfn = 0;
1814     if (!pfn)
1815         kPrf2WrapResolve((void **)&pfn, "FlushFileBuffers", &g_Kernel32);
1816     return pfn( hFile );
1817 }
1818
1819 typedef BOOL WINAPI FN_DeviceIoControl( HANDLE hDevice, DWORD dwIoControlCode, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped );
1820 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_DeviceIoControl( HANDLE hDevice, DWORD dwIoControlCode, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped )
1821 {
1822     static FN_DeviceIoControl *pfn = 0;
1823     if (!pfn)
1824         kPrf2WrapResolve((void **)&pfn, "DeviceIoControl", &g_Kernel32);
1825     return pfn( hDevice, dwIoControlCode, lpInBuffer, nInBufferSize, lpOutBuffer, nOutBufferSize, lpBytesReturned, lpOverlapped );
1826 }
1827
1828 typedef BOOL WINAPI FN_RequestDeviceWakeup( HANDLE hDevice );
1829 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_RequestDeviceWakeup( HANDLE hDevice )
1830 {
1831     static FN_RequestDeviceWakeup *pfn = 0;
1832     if (!pfn)
1833         kPrf2WrapResolve((void **)&pfn, "RequestDeviceWakeup", &g_Kernel32);
1834     return pfn( hDevice );
1835 }
1836
1837 typedef BOOL WINAPI FN_CancelDeviceWakeupRequest( HANDLE hDevice );
1838 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_CancelDeviceWakeupRequest( HANDLE hDevice )
1839 {
1840     static FN_CancelDeviceWakeupRequest *pfn = 0;
1841     if (!pfn)
1842         kPrf2WrapResolve((void **)&pfn, "CancelDeviceWakeupRequest", &g_Kernel32);
1843     return pfn( hDevice );
1844 }
1845
1846 typedef BOOL WINAPI FN_GetDevicePowerState( HANDLE hDevice, BOOL * pfOn );
1847 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetDevicePowerState( HANDLE hDevice, BOOL * pfOn )
1848 {
1849     static FN_GetDevicePowerState *pfn = 0;
1850     if (!pfn)
1851         kPrf2WrapResolve((void **)&pfn, "GetDevicePowerState", &g_Kernel32);
1852     return pfn( hDevice, pfOn );
1853 }
1854
1855 typedef BOOL WINAPI FN_SetMessageWaitingIndicator( HANDLE hMsgIndicator, ULONG ulMsgCount );
1856 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetMessageWaitingIndicator( HANDLE hMsgIndicator, ULONG ulMsgCount )
1857 {
1858     static FN_SetMessageWaitingIndicator *pfn = 0;
1859     if (!pfn)
1860         kPrf2WrapResolve((void **)&pfn, "SetMessageWaitingIndicator", &g_Kernel32);
1861     return pfn( hMsgIndicator, ulMsgCount );
1862 }
1863
1864 typedef BOOL WINAPI FN_SetEndOfFile( HANDLE hFile );
1865 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetEndOfFile( HANDLE hFile )
1866 {
1867     static FN_SetEndOfFile *pfn = 0;
1868     if (!pfn)
1869         kPrf2WrapResolve((void **)&pfn, "SetEndOfFile", &g_Kernel32);
1870     return pfn( hFile );
1871 }
1872
1873 typedef DWORD WINAPI FN_SetFilePointer( HANDLE hFile, LONG lDistanceToMove, PLONG lpDistanceToMoveHigh, DWORD dwMoveMethod );
1874 __declspec(dllexport) DWORD WINAPI kPrf2Wrap_SetFilePointer( HANDLE hFile, LONG lDistanceToMove, PLONG lpDistanceToMoveHigh, DWORD dwMoveMethod )
1875 {
1876     static FN_SetFilePointer *pfn = 0;
1877     if (!pfn)
1878         kPrf2WrapResolve((void **)&pfn, "SetFilePointer", &g_Kernel32);
1879     return pfn( hFile, lDistanceToMove, lpDistanceToMoveHigh, dwMoveMethod );
1880 }
1881
1882 typedef BOOL WINAPI FN_SetFilePointerEx( HANDLE hFile, LARGE_INTEGER liDistanceToMove, PLARGE_INTEGER lpNewFilePointer, DWORD dwMoveMethod );
1883 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetFilePointerEx( HANDLE hFile, LARGE_INTEGER liDistanceToMove, PLARGE_INTEGER lpNewFilePointer, DWORD dwMoveMethod )
1884 {
1885     static FN_SetFilePointerEx *pfn = 0;
1886     if (!pfn)
1887         kPrf2WrapResolve((void **)&pfn, "SetFilePointerEx", &g_Kernel32);
1888     return pfn( hFile, liDistanceToMove, lpNewFilePointer, dwMoveMethod );
1889 }
1890
1891 typedef BOOL WINAPI FN_FindClose( HANDLE hFindFile );
1892 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_FindClose( HANDLE hFindFile )
1893 {
1894     static FN_FindClose *pfn = 0;
1895     if (!pfn)
1896         kPrf2WrapResolve((void **)&pfn, "FindClose", &g_Kernel32);
1897     return pfn( hFindFile );
1898 }
1899
1900 typedef BOOL WINAPI FN_GetFileTime( HANDLE hFile, LPFILETIME lpCreationTime, LPFILETIME lpLastAccessTime, LPFILETIME lpLastWriteTime );
1901 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetFileTime( HANDLE hFile, LPFILETIME lpCreationTime, LPFILETIME lpLastAccessTime, LPFILETIME lpLastWriteTime )
1902 {
1903     static FN_GetFileTime *pfn = 0;
1904     if (!pfn)
1905         kPrf2WrapResolve((void **)&pfn, "GetFileTime", &g_Kernel32);
1906     return pfn( hFile, lpCreationTime, lpLastAccessTime, lpLastWriteTime );
1907 }
1908
1909 typedef BOOL WINAPI FN_SetFileTime( HANDLE hFile, CONST FILETIME * lpCreationTime, CONST FILETIME * lpLastAccessTime, CONST FILETIME * lpLastWriteTime );
1910 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetFileTime( HANDLE hFile, CONST FILETIME * lpCreationTime, CONST FILETIME * lpLastAccessTime, CONST FILETIME * lpLastWriteTime )
1911 {
1912     static FN_SetFileTime *pfn = 0;
1913     if (!pfn)
1914         kPrf2WrapResolve((void **)&pfn, "SetFileTime", &g_Kernel32);
1915     return pfn( hFile, lpCreationTime, lpLastAccessTime, lpLastWriteTime );
1916 }
1917
1918 typedef BOOL WINAPI FN_SetFileValidData( HANDLE hFile, LONGLONG ValidDataLength );
1919 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetFileValidData( HANDLE hFile, LONGLONG ValidDataLength )
1920 {
1921     static FN_SetFileValidData *pfn = 0;
1922     if (!pfn)
1923         kPrf2WrapResolve((void **)&pfn, "SetFileValidData", &g_Kernel32);
1924     return pfn( hFile, ValidDataLength );
1925 }
1926
1927 typedef BOOL WINAPI FN_SetFileShortNameA( HANDLE hFile, LPCSTR lpShortName );
1928 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetFileShortNameA( HANDLE hFile, LPCSTR lpShortName )
1929 {
1930     static FN_SetFileShortNameA *pfn = 0;
1931     if (!pfn)
1932         kPrf2WrapResolve((void **)&pfn, "SetFileShortNameA", &g_Kernel32);
1933     return pfn( hFile, lpShortName );
1934 }
1935
1936 typedef BOOL WINAPI FN_SetFileShortNameW( HANDLE hFile, LPCWSTR lpShortName );
1937 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetFileShortNameW( HANDLE hFile, LPCWSTR lpShortName )
1938 {
1939     static FN_SetFileShortNameW *pfn = 0;
1940     if (!pfn)
1941         kPrf2WrapResolve((void **)&pfn, "SetFileShortNameW", &g_Kernel32);
1942     return pfn( hFile, lpShortName );
1943 }
1944
1945 typedef BOOL WINAPI FN_CloseHandle( HANDLE hObject );
1946 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_CloseHandle( HANDLE hObject )
1947 {
1948     static FN_CloseHandle *pfn = 0;
1949     if (!pfn)
1950         kPrf2WrapResolve((void **)&pfn, "CloseHandle", &g_Kernel32);
1951     return pfn( hObject );
1952 }
1953
1954 typedef BOOL WINAPI FN_DuplicateHandle( HANDLE hSourceProcessHandle, HANDLE hSourceHandle, HANDLE hTargetProcessHandle, LPHANDLE lpTargetHandle, DWORD dwDesiredAccess, BOOL bInheritHandle, DWORD dwOptions );
1955 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_DuplicateHandle( HANDLE hSourceProcessHandle, HANDLE hSourceHandle, HANDLE hTargetProcessHandle, LPHANDLE lpTargetHandle, DWORD dwDesiredAccess, BOOL bInheritHandle, DWORD dwOptions )
1956 {
1957     static FN_DuplicateHandle *pfn = 0;
1958     if (!pfn)
1959         kPrf2WrapResolve((void **)&pfn, "DuplicateHandle", &g_Kernel32);
1960     return pfn( hSourceProcessHandle, hSourceHandle, hTargetProcessHandle, lpTargetHandle, dwDesiredAccess, bInheritHandle, dwOptions );
1961 }
1962
1963 typedef BOOL WINAPI FN_GetHandleInformation( HANDLE hObject, LPDWORD lpdwFlags );
1964 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetHandleInformation( HANDLE hObject, LPDWORD lpdwFlags )
1965 {
1966     static FN_GetHandleInformation *pfn = 0;
1967     if (!pfn)
1968         kPrf2WrapResolve((void **)&pfn, "GetHandleInformation", &g_Kernel32);
1969     return pfn( hObject, lpdwFlags );
1970 }
1971
1972 typedef BOOL WINAPI FN_SetHandleInformation( HANDLE hObject, DWORD dwMask, DWORD dwFlags );
1973 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetHandleInformation( HANDLE hObject, DWORD dwMask, DWORD dwFlags )
1974 {
1975     static FN_SetHandleInformation *pfn = 0;
1976     if (!pfn)
1977         kPrf2WrapResolve((void **)&pfn, "SetHandleInformation", &g_Kernel32);
1978     return pfn( hObject, dwMask, dwFlags );
1979 }
1980
1981 typedef DWORD WINAPI FN_LoadModule( LPCSTR lpModuleName, LPVOID lpParameterBlock );
1982 __declspec(dllexport) DWORD WINAPI kPrf2Wrap_LoadModule( LPCSTR lpModuleName, LPVOID lpParameterBlock )
1983 {
1984     static FN_LoadModule *pfn = 0;
1985     if (!pfn)
1986         kPrf2WrapResolve((void **)&pfn, "LoadModule", &g_Kernel32);
1987     return pfn( lpModuleName, lpParameterBlock );
1988 }
1989
1990 typedef UINT WINAPI FN_WinExec( LPCSTR lpCmdLine, UINT uCmdShow );
1991 __declspec(dllexport) UINT WINAPI kPrf2Wrap_WinExec( LPCSTR lpCmdLine, UINT uCmdShow )
1992 {
1993     static FN_WinExec *pfn = 0;
1994     if (!pfn)
1995         kPrf2WrapResolve((void **)&pfn, "WinExec", &g_Kernel32);
1996     return pfn( lpCmdLine, uCmdShow );
1997 }
1998
1999 typedef BOOL WINAPI FN_ClearCommBreak( HANDLE hFile );
2000 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_ClearCommBreak( HANDLE hFile )
2001 {
2002     static FN_ClearCommBreak *pfn = 0;
2003     if (!pfn)
2004         kPrf2WrapResolve((void **)&pfn, "ClearCommBreak", &g_Kernel32);
2005     return pfn( hFile );
2006 }
2007
2008 typedef BOOL WINAPI FN_ClearCommError( HANDLE hFile, LPDWORD lpErrors, LPCOMSTAT lpStat );
2009 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_ClearCommError( HANDLE hFile, LPDWORD lpErrors, LPCOMSTAT lpStat )
2010 {
2011     static FN_ClearCommError *pfn = 0;
2012     if (!pfn)
2013         kPrf2WrapResolve((void **)&pfn, "ClearCommError", &g_Kernel32);
2014     return pfn( hFile, lpErrors, lpStat );
2015 }
2016
2017 typedef BOOL WINAPI FN_SetupComm( HANDLE hFile, DWORD dwInQueue, DWORD dwOutQueue );
2018 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetupComm( HANDLE hFile, DWORD dwInQueue, DWORD dwOutQueue )
2019 {
2020     static FN_SetupComm *pfn = 0;
2021     if (!pfn)
2022         kPrf2WrapResolve((void **)&pfn, "SetupComm", &g_Kernel32);
2023     return pfn( hFile, dwInQueue, dwOutQueue );
2024 }
2025
2026 typedef BOOL WINAPI FN_EscapeCommFunction( HANDLE hFile, DWORD dwFunc );
2027 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_EscapeCommFunction( HANDLE hFile, DWORD dwFunc )
2028 {
2029     static FN_EscapeCommFunction *pfn = 0;
2030     if (!pfn)
2031         kPrf2WrapResolve((void **)&pfn, "EscapeCommFunction", &g_Kernel32);
2032     return pfn( hFile, dwFunc );
2033 }
2034
2035 typedef BOOL WINAPI FN_GetCommConfig( HANDLE hCommDev, LPCOMMCONFIG lpCC, LPDWORD lpdwSize );
2036 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetCommConfig( HANDLE hCommDev, LPCOMMCONFIG lpCC, LPDWORD lpdwSize )
2037 {
2038     static FN_GetCommConfig *pfn = 0;
2039     if (!pfn)
2040         kPrf2WrapResolve((void **)&pfn, "GetCommConfig", &g_Kernel32);
2041     return pfn( hCommDev, lpCC, lpdwSize );
2042 }
2043
2044 typedef BOOL WINAPI FN_GetCommMask( HANDLE hFile, LPDWORD lpEvtMask );
2045 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetCommMask( HANDLE hFile, LPDWORD lpEvtMask )
2046 {
2047     static FN_GetCommMask *pfn = 0;
2048     if (!pfn)
2049         kPrf2WrapResolve((void **)&pfn, "GetCommMask", &g_Kernel32);
2050     return pfn( hFile, lpEvtMask );
2051 }
2052
2053 typedef BOOL WINAPI FN_GetCommProperties( HANDLE hFile, LPCOMMPROP lpCommProp );
2054 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetCommProperties( HANDLE hFile, LPCOMMPROP lpCommProp )
2055 {
2056     static FN_GetCommProperties *pfn = 0;
2057     if (!pfn)
2058         kPrf2WrapResolve((void **)&pfn, "GetCommProperties", &g_Kernel32);
2059     return pfn( hFile, lpCommProp );
2060 }
2061
2062 typedef BOOL WINAPI FN_GetCommModemStatus( HANDLE hFile, LPDWORD lpModemStat );
2063 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetCommModemStatus( HANDLE hFile, LPDWORD lpModemStat )
2064 {
2065     static FN_GetCommModemStatus *pfn = 0;
2066     if (!pfn)
2067         kPrf2WrapResolve((void **)&pfn, "GetCommModemStatus", &g_Kernel32);
2068     return pfn( hFile, lpModemStat );
2069 }
2070
2071 typedef BOOL WINAPI FN_GetCommState( HANDLE hFile, LPDCB lpDCB );
2072 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetCommState( HANDLE hFile, LPDCB lpDCB )
2073 {
2074     static FN_GetCommState *pfn = 0;
2075     if (!pfn)
2076         kPrf2WrapResolve((void **)&pfn, "GetCommState", &g_Kernel32);
2077     return pfn( hFile, lpDCB );
2078 }
2079
2080 typedef BOOL WINAPI FN_GetCommTimeouts( HANDLE hFile, LPCOMMTIMEOUTS lpCommTimeouts );
2081 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetCommTimeouts( HANDLE hFile, LPCOMMTIMEOUTS lpCommTimeouts )
2082 {
2083     static FN_GetCommTimeouts *pfn = 0;
2084     if (!pfn)
2085         kPrf2WrapResolve((void **)&pfn, "GetCommTimeouts", &g_Kernel32);
2086     return pfn( hFile, lpCommTimeouts );
2087 }
2088
2089 typedef BOOL WINAPI FN_PurgeComm( HANDLE hFile, DWORD dwFlags );
2090 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_PurgeComm( HANDLE hFile, DWORD dwFlags )
2091 {
2092     static FN_PurgeComm *pfn = 0;
2093     if (!pfn)
2094         kPrf2WrapResolve((void **)&pfn, "PurgeComm", &g_Kernel32);
2095     return pfn( hFile, dwFlags );
2096 }
2097
2098 typedef BOOL WINAPI FN_SetCommBreak( HANDLE hFile );
2099 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetCommBreak( HANDLE hFile )
2100 {
2101     static FN_SetCommBreak *pfn = 0;
2102     if (!pfn)
2103         kPrf2WrapResolve((void **)&pfn, "SetCommBreak", &g_Kernel32);
2104     return pfn( hFile );
2105 }
2106
2107 typedef BOOL WINAPI FN_SetCommConfig( HANDLE hCommDev, LPCOMMCONFIG lpCC, DWORD dwSize );
2108 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetCommConfig( HANDLE hCommDev, LPCOMMCONFIG lpCC, DWORD dwSize )
2109 {
2110     static FN_SetCommConfig *pfn = 0;
2111     if (!pfn)
2112         kPrf2WrapResolve((void **)&pfn, "SetCommConfig", &g_Kernel32);
2113     return pfn( hCommDev, lpCC, dwSize );
2114 }
2115
2116 typedef BOOL WINAPI FN_SetCommMask( HANDLE hFile, DWORD dwEvtMask );
2117 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetCommMask( HANDLE hFile, DWORD dwEvtMask )
2118 {
2119     static FN_SetCommMask *pfn = 0;
2120     if (!pfn)
2121         kPrf2WrapResolve((void **)&pfn, "SetCommMask", &g_Kernel32);
2122     return pfn( hFile, dwEvtMask );
2123 }
2124
2125 typedef BOOL WINAPI FN_SetCommState( HANDLE hFile, LPDCB lpDCB );
2126 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetCommState( HANDLE hFile, LPDCB lpDCB )
2127 {
2128     static FN_SetCommState *pfn = 0;
2129     if (!pfn)
2130         kPrf2WrapResolve((void **)&pfn, "SetCommState", &g_Kernel32);
2131     return pfn( hFile, lpDCB );
2132 }
2133
2134 typedef BOOL WINAPI FN_SetCommTimeouts( HANDLE hFile, LPCOMMTIMEOUTS lpCommTimeouts );
2135 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetCommTimeouts( HANDLE hFile, LPCOMMTIMEOUTS lpCommTimeouts )
2136 {
2137     static FN_SetCommTimeouts *pfn = 0;
2138     if (!pfn)
2139         kPrf2WrapResolve((void **)&pfn, "SetCommTimeouts", &g_Kernel32);
2140     return pfn( hFile, lpCommTimeouts );
2141 }
2142
2143 typedef BOOL WINAPI FN_TransmitCommChar( HANDLE hFile, char cChar );
2144 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_TransmitCommChar( HANDLE hFile, char cChar )
2145 {
2146     static FN_TransmitCommChar *pfn = 0;
2147     if (!pfn)
2148         kPrf2WrapResolve((void **)&pfn, "TransmitCommChar", &g_Kernel32);
2149     return pfn( hFile, cChar );
2150 }
2151
2152 typedef BOOL WINAPI FN_WaitCommEvent( HANDLE hFile, LPDWORD lpEvtMask, LPOVERLAPPED lpOverlapped );
2153 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_WaitCommEvent( HANDLE hFile, LPDWORD lpEvtMask, LPOVERLAPPED lpOverlapped )
2154 {
2155     static FN_WaitCommEvent *pfn = 0;
2156     if (!pfn)
2157         kPrf2WrapResolve((void **)&pfn, "WaitCommEvent", &g_Kernel32);
2158     return pfn( hFile, lpEvtMask, lpOverlapped );
2159 }
2160
2161 typedef DWORD WINAPI FN_SetTapePosition( HANDLE hDevice, DWORD dwPositionMethod, DWORD dwPartition, DWORD dwOffsetLow, DWORD dwOffsetHigh, BOOL bImmediate );
2162 __declspec(dllexport) DWORD WINAPI kPrf2Wrap_SetTapePosition( HANDLE hDevice, DWORD dwPositionMethod, DWORD dwPartition, DWORD dwOffsetLow, DWORD dwOffsetHigh, BOOL bImmediate )
2163 {
2164     static FN_SetTapePosition *pfn = 0;
2165     if (!pfn)
2166         kPrf2WrapResolve((void **)&pfn, "SetTapePosition", &g_Kernel32);
2167     return pfn( hDevice, dwPositionMethod, dwPartition, dwOffsetLow, dwOffsetHigh, bImmediate );
2168 }
2169
2170 typedef DWORD WINAPI FN_GetTapePosition( HANDLE hDevice, DWORD dwPositionType, LPDWORD lpdwPartition, LPDWORD lpdwOffsetLow, LPDWORD lpdwOffsetHigh );
2171 __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetTapePosition( HANDLE hDevice, DWORD dwPositionType, LPDWORD lpdwPartition, LPDWORD lpdwOffsetLow, LPDWORD lpdwOffsetHigh )
2172 {
2173     static FN_GetTapePosition *pfn = 0;
2174     if (!pfn)
2175         kPrf2WrapResolve((void **)&pfn, "GetTapePosition", &g_Kernel32);
2176     return pfn( hDevice, dwPositionType, lpdwPartition, lpdwOffsetLow, lpdwOffsetHigh );
2177 }
2178
2179 typedef DWORD WINAPI FN_PrepareTape( HANDLE hDevice, DWORD dwOperation, BOOL bImmediate );
2180 __declspec(dllexport) DWORD WINAPI kPrf2Wrap_PrepareTape( HANDLE hDevice, DWORD dwOperation, BOOL bImmediate )
2181 {
2182     static FN_PrepareTape *pfn = 0;
2183     if (!pfn)
2184         kPrf2WrapResolve((void **)&pfn, "PrepareTape", &g_Kernel32);
2185     return pfn( hDevice, dwOperation, bImmediate );
2186 }
2187
2188 typedef DWORD WINAPI FN_EraseTape( HANDLE hDevice, DWORD dwEraseType, BOOL bImmediate );
2189 __declspec(dllexport) DWORD WINAPI kPrf2Wrap_EraseTape( HANDLE hDevice, DWORD dwEraseType, BOOL bImmediate )
2190 {
2191     static FN_EraseTape *pfn = 0;
2192     if (!pfn)
2193         kPrf2WrapResolve((void **)&pfn, "EraseTape", &g_Kernel32);
2194     return pfn( hDevice, dwEraseType, bImmediate );
2195 }
2196
2197 typedef DWORD WINAPI FN_CreateTapePartition( HANDLE hDevice, DWORD dwPartitionMethod, DWORD dwCount, DWORD dwSize );
2198 __declspec(dllexport) DWORD WINAPI kPrf2Wrap_CreateTapePartition( HANDLE hDevice, DWORD dwPartitionMethod, DWORD dwCount, DWORD dwSize )
2199 {
2200     static FN_CreateTapePartition *pfn = 0;
2201     if (!pfn)
2202         kPrf2WrapResolve((void **)&pfn, "CreateTapePartition", &g_Kernel32);
2203     return pfn( hDevice, dwPartitionMethod, dwCount, dwSize );
2204 }
2205
2206 typedef DWORD WINAPI FN_WriteTapemark( HANDLE hDevice, DWORD dwTapemarkType, DWORD dwTapemarkCount, BOOL bImmediate );
2207 __declspec(dllexport) DWORD WINAPI kPrf2Wrap_WriteTapemark( HANDLE hDevice, DWORD dwTapemarkType, DWORD dwTapemarkCount, BOOL bImmediate )
2208 {
2209     static FN_WriteTapemark *pfn = 0;
2210     if (!pfn)
2211         kPrf2WrapResolve((void **)&pfn, "WriteTapemark", &g_Kernel32);
2212     return pfn( hDevice, dwTapemarkType, dwTapemarkCount, bImmediate );
2213 }
2214
2215 typedef DWORD WINAPI FN_GetTapeStatus( HANDLE hDevice );
2216 __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetTapeStatus( HANDLE hDevice )
2217 {
2218     static FN_GetTapeStatus *pfn = 0;
2219     if (!pfn)
2220         kPrf2WrapResolve((void **)&pfn, "GetTapeStatus", &g_Kernel32);
2221     return pfn( hDevice );
2222 }
2223
2224 typedef DWORD WINAPI FN_GetTapeParameters( HANDLE hDevice, DWORD dwOperation, LPDWORD lpdwSize, LPVOID lpTapeInformation );
2225 __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetTapeParameters( HANDLE hDevice, DWORD dwOperation, LPDWORD lpdwSize, LPVOID lpTapeInformation )
2226 {
2227     static FN_GetTapeParameters *pfn = 0;
2228     if (!pfn)
2229         kPrf2WrapResolve((void **)&pfn, "GetTapeParameters", &g_Kernel32);
2230     return pfn( hDevice, dwOperation, lpdwSize, lpTapeInformation );
2231 }
2232
2233 typedef DWORD WINAPI FN_SetTapeParameters( HANDLE hDevice, DWORD dwOperation, LPVOID lpTapeInformation );
2234 __declspec(dllexport) DWORD WINAPI kPrf2Wrap_SetTapeParameters( HANDLE hDevice, DWORD dwOperation, LPVOID lpTapeInformation )
2235 {
2236     static FN_SetTapeParameters *pfn = 0;
2237     if (!pfn)
2238         kPrf2WrapResolve((void **)&pfn, "SetTapeParameters", &g_Kernel32);
2239     return pfn( hDevice, dwOperation, lpTapeInformation );
2240 }
2241
2242 typedef BOOL WINAPI FN_Beep( DWORD dwFreq, DWORD dwDuration );
2243 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_Beep( DWORD dwFreq, DWORD dwDuration )
2244 {
2245     static FN_Beep *pfn = 0;
2246     if (!pfn)
2247         kPrf2WrapResolve((void **)&pfn, "Beep", &g_Kernel32);
2248     return pfn( dwFreq, dwDuration );
2249 }
2250
2251 typedef int WINAPI FN_MulDiv( int nNumber, int nNumerator, int nDenominator );
2252 __declspec(dllexport) int WINAPI kPrf2Wrap_MulDiv( int nNumber, int nNumerator, int nDenominator )
2253 {
2254     static FN_MulDiv *pfn = 0;
2255     if (!pfn)
2256         kPrf2WrapResolve((void **)&pfn, "MulDiv", &g_Kernel32);
2257     return pfn( nNumber, nNumerator, nDenominator );
2258 }
2259
2260 typedef VOID WINAPI FN_GetSystemTime( LPSYSTEMTIME lpSystemTime );
2261 __declspec(dllexport) VOID WINAPI kPrf2Wrap_GetSystemTime( LPSYSTEMTIME lpSystemTime )
2262 {
2263     static FN_GetSystemTime *pfn = 0;
2264     if (!pfn)
2265         kPrf2WrapResolve((void **)&pfn, "GetSystemTime", &g_Kernel32);
2266     pfn( lpSystemTime );
2267 }
2268
2269 typedef VOID WINAPI FN_GetSystemTimeAsFileTime( LPFILETIME lpSystemTimeAsFileTime );
2270 __declspec(dllexport) VOID WINAPI kPrf2Wrap_GetSystemTimeAsFileTime( LPFILETIME lpSystemTimeAsFileTime )
2271 {
2272     static FN_GetSystemTimeAsFileTime *pfn = 0;
2273     if (!pfn)
2274         kPrf2WrapResolve((void **)&pfn, "GetSystemTimeAsFileTime", &g_Kernel32);
2275     pfn( lpSystemTimeAsFileTime );
2276 }
2277
2278 typedef BOOL WINAPI FN_SetSystemTime( CONST SYSTEMTIME * lpSystemTime );
2279 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetSystemTime( CONST SYSTEMTIME * lpSystemTime )
2280 {
2281     static FN_SetSystemTime *pfn = 0;
2282     if (!pfn)
2283         kPrf2WrapResolve((void **)&pfn, "SetSystemTime", &g_Kernel32);
2284     return pfn( lpSystemTime );
2285 }
2286
2287 typedef VOID WINAPI FN_GetLocalTime( LPSYSTEMTIME lpSystemTime );
2288 __declspec(dllexport) VOID WINAPI kPrf2Wrap_GetLocalTime( LPSYSTEMTIME lpSystemTime )
2289 {
2290     static FN_GetLocalTime *pfn = 0;
2291     if (!pfn)
2292         kPrf2WrapResolve((void **)&pfn, "GetLocalTime", &g_Kernel32);
2293     pfn( lpSystemTime );
2294 }
2295
2296 typedef BOOL WINAPI FN_SetLocalTime( CONST SYSTEMTIME * lpSystemTime );
2297 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetLocalTime( CONST SYSTEMTIME * lpSystemTime )
2298 {
2299     static FN_SetLocalTime *pfn = 0;
2300     if (!pfn)
2301         kPrf2WrapResolve((void **)&pfn, "SetLocalTime", &g_Kernel32);
2302     return pfn( lpSystemTime );
2303 }
2304
2305 typedef VOID WINAPI FN_GetSystemInfo( LPSYSTEM_INFO lpSystemInfo );
2306 __declspec(dllexport) VOID WINAPI kPrf2Wrap_GetSystemInfo( LPSYSTEM_INFO lpSystemInfo )
2307 {
2308     static FN_GetSystemInfo *pfn = 0;
2309     if (!pfn)
2310         kPrf2WrapResolve((void **)&pfn, "GetSystemInfo", &g_Kernel32);
2311     pfn( lpSystemInfo );
2312 }
2313
2314 typedef BOOL WINAPI FN_SetSystemFileCacheSize( SIZE_T MinimumFileCacheSize, SIZE_T MaximumFileCacheSize, DWORD Flags );
2315 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetSystemFileCacheSize( SIZE_T MinimumFileCacheSize, SIZE_T MaximumFileCacheSize, DWORD Flags )
2316 {
2317     static FN_SetSystemFileCacheSize *pfn = 0;
2318     if (!pfn)
2319         kPrf2WrapResolve((void **)&pfn, "SetSystemFileCacheSize", &g_Kernel32);
2320     return pfn( MinimumFileCacheSize, MaximumFileCacheSize, Flags );
2321 }
2322
2323 typedef BOOL WINAPI FN_GetSystemFileCacheSize( PSIZE_T lpMinimumFileCacheSize, PSIZE_T lpMaximumFileCacheSize, PDWORD lpFlags );
2324 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetSystemFileCacheSize( PSIZE_T lpMinimumFileCacheSize, PSIZE_T lpMaximumFileCacheSize, PDWORD lpFlags )
2325 {
2326     static FN_GetSystemFileCacheSize *pfn = 0;
2327     if (!pfn)
2328         kPrf2WrapResolve((void **)&pfn, "GetSystemFileCacheSize", &g_Kernel32);
2329     return pfn( lpMinimumFileCacheSize, lpMaximumFileCacheSize, lpFlags );
2330 }
2331
2332 typedef BOOL WINAPI FN_GetSystemRegistryQuota( PDWORD pdwQuotaAllowed, PDWORD pdwQuotaUsed );
2333 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetSystemRegistryQuota( PDWORD pdwQuotaAllowed, PDWORD pdwQuotaUsed )
2334 {
2335     static FN_GetSystemRegistryQuota *pfn = 0;
2336     if (!pfn)
2337         kPrf2WrapResolve((void **)&pfn, "GetSystemRegistryQuota", &g_Kernel32);
2338     return pfn( pdwQuotaAllowed, pdwQuotaUsed );
2339 }
2340
2341 typedef BOOL WINAPI FN_GetSystemTimes( LPFILETIME lpIdleTime, LPFILETIME lpKernelTime, LPFILETIME lpUserTime );
2342 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetSystemTimes( LPFILETIME lpIdleTime, LPFILETIME lpKernelTime, LPFILETIME lpUserTime )
2343 {
2344     static FN_GetSystemTimes *pfn = 0;
2345     if (!pfn)
2346         kPrf2WrapResolve((void **)&pfn, "GetSystemTimes", &g_Kernel32);
2347     return pfn( lpIdleTime, lpKernelTime, lpUserTime );
2348 }
2349
2350 typedef VOID WINAPI FN_GetNativeSystemInfo( LPSYSTEM_INFO lpSystemInfo );
2351 __declspec(dllexport) VOID WINAPI kPrf2Wrap_GetNativeSystemInfo( LPSYSTEM_INFO lpSystemInfo )
2352 {
2353     static FN_GetNativeSystemInfo *pfn = 0;
2354     if (!pfn)
2355         kPrf2WrapResolve((void **)&pfn, "GetNativeSystemInfo", &g_Kernel32);
2356     pfn( lpSystemInfo );
2357 }
2358
2359 typedef BOOL WINAPI FN_IsProcessorFeaturePresent( DWORD ProcessorFeature );
2360 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_IsProcessorFeaturePresent( DWORD ProcessorFeature )
2361 {
2362     static FN_IsProcessorFeaturePresent *pfn = 0;
2363     if (!pfn)
2364         kPrf2WrapResolve((void **)&pfn, "IsProcessorFeaturePresent", &g_Kernel32);
2365     return pfn( ProcessorFeature );
2366 }
2367
2368 typedef BOOL WINAPI FN_SystemTimeToTzSpecificLocalTime( LPTIME_ZONE_INFORMATION lpTimeZoneInformation, LPSYSTEMTIME lpUniversalTime, LPSYSTEMTIME lpLocalTime );
2369 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SystemTimeToTzSpecificLocalTime( LPTIME_ZONE_INFORMATION lpTimeZoneInformation, LPSYSTEMTIME lpUniversalTime, LPSYSTEMTIME lpLocalTime )
2370 {
2371     static FN_SystemTimeToTzSpecificLocalTime *pfn = 0;
2372     if (!pfn)
2373         kPrf2WrapResolve((void **)&pfn, "SystemTimeToTzSpecificLocalTime", &g_Kernel32);
2374     return pfn( lpTimeZoneInformation, lpUniversalTime, lpLocalTime );
2375 }
2376
2377 typedef BOOL WINAPI FN_TzSpecificLocalTimeToSystemTime( LPTIME_ZONE_INFORMATION lpTimeZoneInformation, LPSYSTEMTIME lpLocalTime, LPSYSTEMTIME lpUniversalTime );
2378 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_TzSpecificLocalTimeToSystemTime( LPTIME_ZONE_INFORMATION lpTimeZoneInformation, LPSYSTEMTIME lpLocalTime, LPSYSTEMTIME lpUniversalTime )
2379 {
2380     static FN_TzSpecificLocalTimeToSystemTime *pfn = 0;
2381     if (!pfn)
2382         kPrf2WrapResolve((void **)&pfn, "TzSpecificLocalTimeToSystemTime", &g_Kernel32);
2383     return pfn( lpTimeZoneInformation, lpLocalTime, lpUniversalTime );
2384 }
2385
2386 typedef DWORD WINAPI FN_GetTimeZoneInformation( LPTIME_ZONE_INFORMATION lpTimeZoneInformation );
2387 __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetTimeZoneInformation( LPTIME_ZONE_INFORMATION lpTimeZoneInformation )
2388 {
2389     static FN_GetTimeZoneInformation *pfn = 0;
2390     if (!pfn)
2391         kPrf2WrapResolve((void **)&pfn, "GetTimeZoneInformation", &g_Kernel32);
2392     return pfn( lpTimeZoneInformation );
2393 }
2394
2395 typedef BOOL WINAPI FN_SetTimeZoneInformation( CONST TIME_ZONE_INFORMATION * lpTimeZoneInformation );
2396 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetTimeZoneInformation( CONST TIME_ZONE_INFORMATION * lpTimeZoneInformation )
2397 {
2398     static FN_SetTimeZoneInformation *pfn = 0;
2399     if (!pfn)
2400         kPrf2WrapResolve((void **)&pfn, "SetTimeZoneInformation", &g_Kernel32);
2401     return pfn( lpTimeZoneInformation );
2402 }
2403
2404 typedef BOOL WINAPI FN_SystemTimeToFileTime( CONST SYSTEMTIME * lpSystemTime, LPFILETIME lpFileTime );
2405 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SystemTimeToFileTime( CONST SYSTEMTIME * lpSystemTime, LPFILETIME lpFileTime )
2406 {
2407     static FN_SystemTimeToFileTime *pfn = 0;
2408     if (!pfn)
2409         kPrf2WrapResolve((void **)&pfn, "SystemTimeToFileTime", &g_Kernel32);
2410     return pfn( lpSystemTime, lpFileTime );
2411 }
2412
2413 typedef BOOL WINAPI FN_FileTimeToLocalFileTime( CONST FILETIME * lpFileTime, LPFILETIME lpLocalFileTime );
2414 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_FileTimeToLocalFileTime( CONST FILETIME * lpFileTime, LPFILETIME lpLocalFileTime )
2415 {
2416     static FN_FileTimeToLocalFileTime *pfn = 0;
2417     if (!pfn)
2418         kPrf2WrapResolve((void **)&pfn, "FileTimeToLocalFileTime", &g_Kernel32);
2419     return pfn( lpFileTime, lpLocalFileTime );
2420 }
2421
2422 typedef BOOL WINAPI FN_LocalFileTimeToFileTime( CONST FILETIME * lpLocalFileTime, LPFILETIME lpFileTime );
2423 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_LocalFileTimeToFileTime( CONST FILETIME * lpLocalFileTime, LPFILETIME lpFileTime )
2424 {
2425     static FN_LocalFileTimeToFileTime *pfn = 0;
2426     if (!pfn)
2427         kPrf2WrapResolve((void **)&pfn, "LocalFileTimeToFileTime", &g_Kernel32);
2428     return pfn( lpLocalFileTime, lpFileTime );
2429 }
2430
2431 typedef BOOL WINAPI FN_FileTimeToSystemTime( CONST FILETIME * lpFileTime, LPSYSTEMTIME lpSystemTime );
2432 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_FileTimeToSystemTime( CONST FILETIME * lpFileTime, LPSYSTEMTIME lpSystemTime )
2433 {
2434     static FN_FileTimeToSystemTime *pfn = 0;
2435     if (!pfn)
2436         kPrf2WrapResolve((void **)&pfn, "FileTimeToSystemTime", &g_Kernel32);
2437     return pfn( lpFileTime, lpSystemTime );
2438 }
2439
2440 typedef LONG WINAPI FN_CompareFileTime( CONST FILETIME * lpFileTime1, CONST FILETIME * lpFileTime2 );
2441 __declspec(dllexport) LONG WINAPI kPrf2Wrap_CompareFileTime( CONST FILETIME * lpFileTime1, CONST FILETIME * lpFileTime2 )
2442 {
2443     static FN_CompareFileTime *pfn = 0;
2444     if (!pfn)
2445         kPrf2WrapResolve((void **)&pfn, "CompareFileTime", &g_Kernel32);
2446     return pfn( lpFileTime1, lpFileTime2 );
2447 }
2448
2449 typedef BOOL WINAPI FN_FileTimeToDosDateTime( CONST FILETIME * lpFileTime, LPWORD lpFatDate, LPWORD lpFatTime );
2450 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_FileTimeToDosDateTime( CONST FILETIME * lpFileTime, LPWORD lpFatDate, LPWORD lpFatTime )
2451 {
2452     static FN_FileTimeToDosDateTime *pfn = 0;
2453     if (!pfn)
2454         kPrf2WrapResolve((void **)&pfn, "FileTimeToDosDateTime", &g_Kernel32);
2455     return pfn( lpFileTime, lpFatDate, lpFatTime );
2456 }
2457
2458 typedef BOOL WINAPI FN_DosDateTimeToFileTime( WORD wFatDate, WORD wFatTime, LPFILETIME lpFileTime );
2459 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_DosDateTimeToFileTime( WORD wFatDate, WORD wFatTime, LPFILETIME lpFileTime )
2460 {
2461     static FN_DosDateTimeToFileTime *pfn = 0;
2462     if (!pfn)
2463         kPrf2WrapResolve((void **)&pfn, "DosDateTimeToFileTime", &g_Kernel32);
2464     return pfn( wFatDate, wFatTime, lpFileTime );
2465 }
2466
2467 typedef DWORD WINAPI FN_GetTickCount( VOID );
2468 __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetTickCount( VOID )
2469 {
2470     static FN_GetTickCount *pfn = 0;
2471     if (!pfn)
2472         kPrf2WrapResolve((void **)&pfn, "GetTickCount", &g_Kernel32);
2473     return pfn ();
2474 }
2475
2476 typedef BOOL WINAPI FN_SetSystemTimeAdjustment( DWORD dwTimeAdjustment, BOOL bTimeAdjustmentDisabled );
2477 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetSystemTimeAdjustment( DWORD dwTimeAdjustment, BOOL bTimeAdjustmentDisabled )
2478 {
2479     static FN_SetSystemTimeAdjustment *pfn = 0;
2480     if (!pfn)
2481         kPrf2WrapResolve((void **)&pfn, "SetSystemTimeAdjustment", &g_Kernel32);
2482     return pfn( dwTimeAdjustment, bTimeAdjustmentDisabled );
2483 }
2484
2485 typedef BOOL WINAPI FN_GetSystemTimeAdjustment( PDWORD lpTimeAdjustment, PDWORD lpTimeIncrement, PBOOL lpTimeAdjustmentDisabled );
2486 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetSystemTimeAdjustment( PDWORD lpTimeAdjustment, PDWORD lpTimeIncrement, PBOOL lpTimeAdjustmentDisabled )
2487 {
2488     static FN_GetSystemTimeAdjustment *pfn = 0;
2489     if (!pfn)
2490         kPrf2WrapResolve((void **)&pfn, "GetSystemTimeAdjustment", &g_Kernel32);
2491     return pfn( lpTimeAdjustment, lpTimeIncrement, lpTimeAdjustmentDisabled );
2492 }
2493
2494 typedef DWORD WINAPI FN_FormatMessageA( DWORD dwFlags, LPCVOID lpSource, DWORD dwMessageId, DWORD dwLanguageId, LPSTR lpBuffer, DWORD nSize, va_list * Arguments );
2495 __declspec(dllexport) DWORD WINAPI kPrf2Wrap_FormatMessageA( DWORD dwFlags, LPCVOID lpSource, DWORD dwMessageId, DWORD dwLanguageId, LPSTR lpBuffer, DWORD nSize, va_list * Arguments )
2496 {
2497     static FN_FormatMessageA *pfn = 0;
2498     if (!pfn)
2499         kPrf2WrapResolve((void **)&pfn, "FormatMessageA", &g_Kernel32);
2500     return pfn( dwFlags, lpSource, dwMessageId, dwLanguageId, lpBuffer, nSize, Arguments );
2501 }
2502
2503 typedef DWORD WINAPI FN_FormatMessageW( DWORD dwFlags, LPCVOID lpSource, DWORD dwMessageId, DWORD dwLanguageId, LPWSTR lpBuffer, DWORD nSize, va_list * Arguments );
2504 __declspec(dllexport) DWORD WINAPI kPrf2Wrap_FormatMessageW( DWORD dwFlags, LPCVOID lpSource, DWORD dwMessageId, DWORD dwLanguageId, LPWSTR lpBuffer, DWORD nSize, va_list * Arguments )
2505 {
2506     static FN_FormatMessageW *pfn = 0;
2507     if (!pfn)
2508         kPrf2WrapResolve((void **)&pfn, "FormatMessageW", &g_Kernel32);
2509     return pfn( dwFlags, lpSource, dwMessageId, dwLanguageId, lpBuffer, nSize, Arguments );
2510 }
2511
2512 typedef BOOL WINAPI FN_CreatePipe( PHANDLE hReadPipe, PHANDLE hWritePipe, LPSECURITY_ATTRIBUTES lpPipeAttributes, DWORD nSize );
2513 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_CreatePipe( PHANDLE hReadPipe, PHANDLE hWritePipe, LPSECURITY_ATTRIBUTES lpPipeAttributes, DWORD nSize )
2514 {
2515     static FN_CreatePipe *pfn = 0;
2516     if (!pfn)
2517         kPrf2WrapResolve((void **)&pfn, "CreatePipe", &g_Kernel32);
2518     return pfn( hReadPipe, hWritePipe, lpPipeAttributes, nSize );
2519 }
2520
2521 typedef BOOL WINAPI FN_ConnectNamedPipe( HANDLE hNamedPipe, LPOVERLAPPED lpOverlapped );
2522 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_ConnectNamedPipe( HANDLE hNamedPipe, LPOVERLAPPED lpOverlapped )
2523 {
2524     static FN_ConnectNamedPipe *pfn = 0;
2525     if (!pfn)
2526         kPrf2WrapResolve((void **)&pfn, "ConnectNamedPipe", &g_Kernel32);
2527     return pfn( hNamedPipe, lpOverlapped );
2528 }
2529
2530 typedef BOOL WINAPI FN_DisconnectNamedPipe( HANDLE hNamedPipe );
2531 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_DisconnectNamedPipe( HANDLE hNamedPipe )
2532 {
2533     static FN_DisconnectNamedPipe *pfn = 0;
2534     if (!pfn)
2535         kPrf2WrapResolve((void **)&pfn, "DisconnectNamedPipe", &g_Kernel32);
2536     return pfn( hNamedPipe );
2537 }
2538
2539 typedef BOOL WINAPI FN_SetNamedPipeHandleState( HANDLE hNamedPipe, LPDWORD lpMode, LPDWORD lpMaxCollectionCount, LPDWORD lpCollectDataTimeout );
2540 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetNamedPipeHandleState( HANDLE hNamedPipe, LPDWORD lpMode, LPDWORD lpMaxCollectionCount, LPDWORD lpCollectDataTimeout )
2541 {
2542     static FN_SetNamedPipeHandleState *pfn = 0;
2543     if (!pfn)
2544         kPrf2WrapResolve((void **)&pfn, "SetNamedPipeHandleState", &g_Kernel32);
2545     return pfn( hNamedPipe, lpMode, lpMaxCollectionCount, lpCollectDataTimeout );
2546 }
2547
2548 typedef BOOL WINAPI FN_GetNamedPipeInfo( HANDLE hNamedPipe, LPDWORD lpFlags, LPDWORD lpOutBufferSize, LPDWORD lpInBufferSize, LPDWORD lpMaxInstances );
2549 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetNamedPipeInfo( HANDLE hNamedPipe, LPDWORD lpFlags, LPDWORD lpOutBufferSize, LPDWORD lpInBufferSize, LPDWORD lpMaxInstances )
2550 {
2551     static FN_GetNamedPipeInfo *pfn = 0;
2552     if (!pfn)
2553         kPrf2WrapResolve((void **)&pfn, "GetNamedPipeInfo", &g_Kernel32);
2554     return pfn( hNamedPipe, lpFlags, lpOutBufferSize, lpInBufferSize, lpMaxInstances );
2555 }
2556
2557 typedef BOOL WINAPI FN_PeekNamedPipe( HANDLE hNamedPipe, LPVOID lpBuffer, DWORD nBufferSize, LPDWORD lpBytesRead, LPDWORD lpTotalBytesAvail, LPDWORD lpBytesLeftThisMessage );
2558 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_PeekNamedPipe( HANDLE hNamedPipe, LPVOID lpBuffer, DWORD nBufferSize, LPDWORD lpBytesRead, LPDWORD lpTotalBytesAvail, LPDWORD lpBytesLeftThisMessage )
2559 {
2560     static FN_PeekNamedPipe *pfn = 0;
2561     if (!pfn)
2562         kPrf2WrapResolve((void **)&pfn, "PeekNamedPipe", &g_Kernel32);
2563     return pfn( hNamedPipe, lpBuffer, nBufferSize, lpBytesRead, lpTotalBytesAvail, lpBytesLeftThisMessage );
2564 }
2565
2566 typedef BOOL WINAPI FN_TransactNamedPipe( HANDLE hNamedPipe, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesRead, LPOVERLAPPED lpOverlapped );
2567 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_TransactNamedPipe( HANDLE hNamedPipe, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesRead, LPOVERLAPPED lpOverlapped )
2568 {
2569     static FN_TransactNamedPipe *pfn = 0;
2570     if (!pfn)
2571         kPrf2WrapResolve((void **)&pfn, "TransactNamedPipe", &g_Kernel32);
2572     return pfn( hNamedPipe, lpInBuffer, nInBufferSize, lpOutBuffer, nOutBufferSize, lpBytesRead, lpOverlapped );
2573 }
2574
2575 typedef HANDLE WINAPI FN_CreateMailslotA( LPCSTR lpName, DWORD nMaxMessageSize, DWORD lReadTimeout, LPSECURITY_ATTRIBUTES lpSecurityAttributes );
2576 __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_CreateMailslotA( LPCSTR lpName, DWORD nMaxMessageSize, DWORD lReadTimeout, LPSECURITY_ATTRIBUTES lpSecurityAttributes )
2577 {
2578     static FN_CreateMailslotA *pfn = 0;
2579     if (!pfn)
2580         kPrf2WrapResolve((void **)&pfn, "CreateMailslotA", &g_Kernel32);
2581     return pfn( lpName, nMaxMessageSize, lReadTimeout, lpSecurityAttributes );
2582 }
2583
2584 typedef HANDLE WINAPI FN_CreateMailslotW( LPCWSTR lpName, DWORD nMaxMessageSize, DWORD lReadTimeout, LPSECURITY_ATTRIBUTES lpSecurityAttributes );
2585 __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_CreateMailslotW( LPCWSTR lpName, DWORD nMaxMessageSize, DWORD lReadTimeout, LPSECURITY_ATTRIBUTES lpSecurityAttributes )
2586 {
2587     static FN_CreateMailslotW *pfn = 0;
2588     if (!pfn)
2589         kPrf2WrapResolve((void **)&pfn, "CreateMailslotW", &g_Kernel32);
2590     return pfn( lpName, nMaxMessageSize, lReadTimeout, lpSecurityAttributes );
2591 }
2592
2593 typedef BOOL WINAPI FN_GetMailslotInfo( HANDLE hMailslot, LPDWORD lpMaxMessageSize, LPDWORD lpNextSize, LPDWORD lpMessageCount, LPDWORD lpReadTimeout );
2594 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetMailslotInfo( HANDLE hMailslot, LPDWORD lpMaxMessageSize, LPDWORD lpNextSize, LPDWORD lpMessageCount, LPDWORD lpReadTimeout )
2595 {
2596     static FN_GetMailslotInfo *pfn = 0;
2597     if (!pfn)
2598         kPrf2WrapResolve((void **)&pfn, "GetMailslotInfo", &g_Kernel32);
2599     return pfn( hMailslot, lpMaxMessageSize, lpNextSize, lpMessageCount, lpReadTimeout );
2600 }
2601
2602 typedef BOOL WINAPI FN_SetMailslotInfo( HANDLE hMailslot, DWORD lReadTimeout );
2603 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetMailslotInfo( HANDLE hMailslot, DWORD lReadTimeout )
2604 {
2605     static FN_SetMailslotInfo *pfn = 0;
2606     if (!pfn)
2607         kPrf2WrapResolve((void **)&pfn, "SetMailslotInfo", &g_Kernel32);
2608     return pfn( hMailslot, lReadTimeout );
2609 }
2610
2611 typedef LPVOID WINAPI FN_MapViewOfFile( HANDLE hFileMappingObject, DWORD dwDesiredAccess, DWORD dwFileOffsetHigh, DWORD dwFileOffsetLow, SIZE_T dwNumberOfBytesToMap );
2612 __declspec(dllexport) LPVOID WINAPI kPrf2Wrap_MapViewOfFile( HANDLE hFileMappingObject, DWORD dwDesiredAccess, DWORD dwFileOffsetHigh, DWORD dwFileOffsetLow, SIZE_T dwNumberOfBytesToMap )
2613 {
2614     static FN_MapViewOfFile *pfn = 0;
2615     if (!pfn)
2616         kPrf2WrapResolve((void **)&pfn, "MapViewOfFile", &g_Kernel32);
2617     return pfn( hFileMappingObject, dwDesiredAccess, dwFileOffsetHigh, dwFileOffsetLow, dwNumberOfBytesToMap );
2618 }
2619
2620 typedef BOOL WINAPI FN_FlushViewOfFile( LPCVOID lpBaseAddress, SIZE_T dwNumberOfBytesToFlush );
2621 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_FlushViewOfFile( LPCVOID lpBaseAddress, SIZE_T dwNumberOfBytesToFlush )
2622 {
2623     static FN_FlushViewOfFile *pfn = 0;
2624     if (!pfn)
2625         kPrf2WrapResolve((void **)&pfn, "FlushViewOfFile", &g_Kernel32);
2626     return pfn( lpBaseAddress, dwNumberOfBytesToFlush );
2627 }
2628
2629 typedef BOOL WINAPI FN_UnmapViewOfFile( LPCVOID lpBaseAddress );
2630 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_UnmapViewOfFile( LPCVOID lpBaseAddress )
2631 {
2632     static FN_UnmapViewOfFile *pfn = 0;
2633     if (!pfn)
2634         kPrf2WrapResolve((void **)&pfn, "UnmapViewOfFile", &g_Kernel32);
2635     return pfn( lpBaseAddress );
2636 }
2637
2638 typedef BOOL WINAPI FN_EncryptFileA( LPCSTR lpFileName );
2639 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_EncryptFileA( LPCSTR lpFileName )
2640 {
2641     static FN_EncryptFileA *pfn = 0;
2642     if (!pfn)
2643         kPrf2WrapResolve((void **)&pfn, "EncryptFileA", &g_Kernel32);
2644     return pfn( lpFileName );
2645 }
2646
2647 typedef BOOL WINAPI FN_EncryptFileW( LPCWSTR lpFileName );
2648 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_EncryptFileW( LPCWSTR lpFileName )
2649 {
2650     static FN_EncryptFileW *pfn = 0;
2651     if (!pfn)
2652         kPrf2WrapResolve((void **)&pfn, "EncryptFileW", &g_Kernel32);
2653     return pfn( lpFileName );
2654 }
2655
2656 typedef BOOL WINAPI FN_DecryptFileA( LPCSTR lpFileName, DWORD dwReserved );
2657 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_DecryptFileA( LPCSTR lpFileName, DWORD dwReserved )
2658 {
2659     static FN_DecryptFileA *pfn = 0;
2660     if (!pfn)
2661         kPrf2WrapResolve((void **)&pfn, "DecryptFileA", &g_Kernel32);
2662     return pfn( lpFileName, dwReserved );
2663 }
2664
2665 typedef BOOL WINAPI FN_DecryptFileW( LPCWSTR lpFileName, DWORD dwReserved );
2666 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_DecryptFileW( LPCWSTR lpFileName, DWORD dwReserved )
2667 {
2668     static FN_DecryptFileW *pfn = 0;
2669     if (!pfn)
2670         kPrf2WrapResolve((void **)&pfn, "DecryptFileW", &g_Kernel32);
2671     return pfn( lpFileName, dwReserved );
2672 }
2673
2674 typedef BOOL WINAPI FN_FileEncryptionStatusA( LPCSTR lpFileName, LPDWORD lpStatus );
2675 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_FileEncryptionStatusA( LPCSTR lpFileName, LPDWORD lpStatus )
2676 {
2677     static FN_FileEncryptionStatusA *pfn = 0;
2678     if (!pfn)
2679         kPrf2WrapResolve((void **)&pfn, "FileEncryptionStatusA", &g_Kernel32);
2680     return pfn( lpFileName, lpStatus );
2681 }
2682
2683 typedef BOOL WINAPI FN_FileEncryptionStatusW( LPCWSTR lpFileName, LPDWORD lpStatus );
2684 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_FileEncryptionStatusW( LPCWSTR lpFileName, LPDWORD lpStatus )
2685 {
2686     static FN_FileEncryptionStatusW *pfn = 0;
2687     if (!pfn)
2688         kPrf2WrapResolve((void **)&pfn, "FileEncryptionStatusW", &g_Kernel32);
2689     return pfn( lpFileName, lpStatus );
2690 }
2691
2692 typedef DWORD WINAPI FN_OpenEncryptedFileRawA( LPCSTR lpFileName, ULONG ulFlags, PVOID * pvContext );
2693 __declspec(dllexport) DWORD WINAPI kPrf2Wrap_OpenEncryptedFileRawA( LPCSTR lpFileName, ULONG ulFlags, PVOID * pvContext )
2694 {
2695     static FN_OpenEncryptedFileRawA *pfn = 0;
2696     if (!pfn)
2697         kPrf2WrapResolve((void **)&pfn, "OpenEncryptedFileRawA", &g_Kernel32);
2698     return pfn( lpFileName, ulFlags, pvContext );
2699 }
2700
2701 typedef DWORD WINAPI FN_OpenEncryptedFileRawW( LPCWSTR lpFileName, ULONG ulFlags, PVOID * pvContext );
2702 __declspec(dllexport) DWORD WINAPI kPrf2Wrap_OpenEncryptedFileRawW( LPCWSTR lpFileName, ULONG ulFlags, PVOID * pvContext )
2703 {
2704     static FN_OpenEncryptedFileRawW *pfn = 0;
2705     if (!pfn)
2706         kPrf2WrapResolve((void **)&pfn, "OpenEncryptedFileRawW", &g_Kernel32);
2707     return pfn( lpFileName, ulFlags, pvContext );
2708 }
2709
2710 typedef DWORD WINAPI FN_ReadEncryptedFileRaw( PFE_EXPORT_FUNC pfExportCallback, PVOID pvCallbackContext, PVOID pvContext );
2711 __declspec(dllexport) DWORD WINAPI kPrf2Wrap_ReadEncryptedFileRaw( PFE_EXPORT_FUNC pfExportCallback, PVOID pvCallbackContext, PVOID pvContext )
2712 {
2713     static FN_ReadEncryptedFileRaw *pfn = 0;
2714     if (!pfn)
2715         kPrf2WrapResolve((void **)&pfn, "ReadEncryptedFileRaw", &g_Kernel32);
2716     return pfn( pfExportCallback, pvCallbackContext, pvContext );
2717 }
2718
2719 typedef DWORD WINAPI FN_WriteEncryptedFileRaw( PFE_IMPORT_FUNC pfImportCallback, PVOID pvCallbackContext, PVOID pvContext );
2720 __declspec(dllexport) DWORD WINAPI kPrf2Wrap_WriteEncryptedFileRaw( PFE_IMPORT_FUNC pfImportCallback, PVOID pvCallbackContext, PVOID pvContext )
2721 {
2722     static FN_WriteEncryptedFileRaw *pfn = 0;
2723     if (!pfn)
2724         kPrf2WrapResolve((void **)&pfn, "WriteEncryptedFileRaw", &g_Kernel32);
2725     return pfn( pfImportCallback, pvCallbackContext, pvContext );
2726 }
2727
2728 typedef VOID WINAPI FN_CloseEncryptedFileRaw( PVOID pvContext );
2729 __declspec(dllexport) VOID WINAPI kPrf2Wrap_CloseEncryptedFileRaw( PVOID pvContext )
2730 {
2731     static FN_CloseEncryptedFileRaw *pfn = 0;
2732     if (!pfn)
2733         kPrf2WrapResolve((void **)&pfn, "CloseEncryptedFileRaw", &g_Kernel32);
2734     pfn( pvContext );
2735 }
2736
2737 typedef int WINAPI FN_lstrcmpA( LPCSTR lpString1, LPCSTR lpString2 );
2738 __declspec(dllexport) int WINAPI kPrf2Wrap_lstrcmpA( LPCSTR lpString1, LPCSTR lpString2 )
2739 {
2740     static FN_lstrcmpA *pfn = 0;
2741     if (!pfn)
2742         kPrf2WrapResolve((void **)&pfn, "lstrcmpA", &g_Kernel32);
2743     return pfn( lpString1, lpString2 );
2744 }
2745
2746 typedef int WINAPI FN_lstrcmpW( LPCWSTR lpString1, LPCWSTR lpString2 );
2747 __declspec(dllexport) int WINAPI kPrf2Wrap_lstrcmpW( LPCWSTR lpString1, LPCWSTR lpString2 )
2748 {
2749     static FN_lstrcmpW *pfn = 0;
2750     if (!pfn)
2751         kPrf2WrapResolve((void **)&pfn, "lstrcmpW", &g_Kernel32);
2752     return pfn( lpString1, lpString2 );
2753 }
2754
2755 typedef int WINAPI FN_lstrcmpiA( LPCSTR lpString1, LPCSTR lpString2 );
2756 __declspec(dllexport) int WINAPI kPrf2Wrap_lstrcmpiA( LPCSTR lpString1, LPCSTR lpString2 )
2757 {
2758     static FN_lstrcmpiA *pfn = 0;
2759     if (!pfn)
2760         kPrf2WrapResolve((void **)&pfn, "lstrcmpiA", &g_Kernel32);
2761     return pfn( lpString1, lpString2 );
2762 }
2763
2764 typedef int WINAPI FN_lstrcmpiW( LPCWSTR lpString1, LPCWSTR lpString2 );
2765 __declspec(dllexport) int WINAPI kPrf2Wrap_lstrcmpiW( LPCWSTR lpString1, LPCWSTR lpString2 )
2766 {
2767     static FN_lstrcmpiW *pfn = 0;
2768     if (!pfn)
2769         kPrf2WrapResolve((void **)&pfn, "lstrcmpiW", &g_Kernel32);
2770     return pfn( lpString1, lpString2 );
2771 }
2772
2773 typedef LPSTR WINAPI FN_lstrcpynA( LPSTR lpString1, LPCSTR lpString2, int iMaxLength );
2774 __declspec(dllexport) LPSTR WINAPI kPrf2Wrap_lstrcpynA( LPSTR lpString1, LPCSTR lpString2, int iMaxLength )
2775 {
2776     static FN_lstrcpynA *pfn = 0;
2777     if (!pfn)
2778         kPrf2WrapResolve((void **)&pfn, "lstrcpynA", &g_Kernel32);
2779     return pfn( lpString1, lpString2, iMaxLength );
2780 }
2781
2782 typedef LPWSTR WINAPI FN_lstrcpynW( LPWSTR lpString1, LPCWSTR lpString2, int iMaxLength );
2783 __declspec(dllexport) LPWSTR WINAPI kPrf2Wrap_lstrcpynW( LPWSTR lpString1, LPCWSTR lpString2, int iMaxLength )
2784 {
2785     static FN_lstrcpynW *pfn = 0;
2786     if (!pfn)
2787         kPrf2WrapResolve((void **)&pfn, "lstrcpynW", &g_Kernel32);
2788     return pfn( lpString1, lpString2, iMaxLength );
2789 }
2790
2791 typedef LPSTR WINAPI FN_lstrcpyA( LPSTR lpString1, LPCSTR lpString2 );
2792 __declspec(dllexport) LPSTR WINAPI kPrf2Wrap_lstrcpyA( LPSTR lpString1, LPCSTR lpString2 )
2793 {
2794     static FN_lstrcpyA *pfn = 0;
2795     if (!pfn)
2796         kPrf2WrapResolve((void **)&pfn, "lstrcpyA", &g_Kernel32);
2797     return pfn( lpString1, lpString2 );
2798 }
2799
2800 typedef LPWSTR WINAPI FN_lstrcpyW( LPWSTR lpString1, LPCWSTR lpString2 );
2801 __declspec(dllexport) LPWSTR WINAPI kPrf2Wrap_lstrcpyW( LPWSTR lpString1, LPCWSTR lpString2 )
2802 {
2803     static FN_lstrcpyW *pfn = 0;
2804     if (!pfn)
2805         kPrf2WrapResolve((void **)&pfn, "lstrcpyW", &g_Kernel32);
2806     return pfn( lpString1, lpString2 );
2807 }
2808
2809 typedef LPSTR WINAPI FN_lstrcatA( LPSTR lpString1, LPCSTR lpString2 );
2810 __declspec(dllexport) LPSTR WINAPI kPrf2Wrap_lstrcatA( LPSTR lpString1, LPCSTR lpString2 )
2811 {
2812     static FN_lstrcatA *pfn = 0;
2813     if (!pfn)
2814         kPrf2WrapResolve((void **)&pfn, "lstrcatA", &g_Kernel32);
2815     return pfn( lpString1, lpString2 );
2816 }
2817
2818 typedef LPWSTR WINAPI FN_lstrcatW( LPWSTR lpString1, LPCWSTR lpString2 );
2819 __declspec(dllexport) LPWSTR WINAPI kPrf2Wrap_lstrcatW( LPWSTR lpString1, LPCWSTR lpString2 )
2820 {
2821     static FN_lstrcatW *pfn = 0;
2822     if (!pfn)
2823         kPrf2WrapResolve((void **)&pfn, "lstrcatW", &g_Kernel32);
2824     return pfn( lpString1, lpString2 );
2825 }
2826
2827 typedef int WINAPI FN_lstrlenA( LPCSTR lpString );
2828 __declspec(dllexport) int WINAPI kPrf2Wrap_lstrlenA( LPCSTR lpString )
2829 {
2830     static FN_lstrlenA *pfn = 0;
2831     if (!pfn)
2832         kPrf2WrapResolve((void **)&pfn, "lstrlenA", &g_Kernel32);
2833     return pfn( lpString );
2834 }
2835
2836 typedef int WINAPI FN_lstrlenW( LPCWSTR lpString );
2837 __declspec(dllexport) int WINAPI kPrf2Wrap_lstrlenW( LPCWSTR lpString )
2838 {
2839     static FN_lstrlenW *pfn = 0;
2840     if (!pfn)
2841         kPrf2WrapResolve((void **)&pfn, "lstrlenW", &g_Kernel32);
2842     return pfn( lpString );
2843 }
2844
2845 typedef HFILE WINAPI FN_OpenFile( LPCSTR lpFileName, LPOFSTRUCT lpReOpenBuff, UINT uStyle );
2846 __declspec(dllexport) HFILE WINAPI kPrf2Wrap_OpenFile( LPCSTR lpFileName, LPOFSTRUCT lpReOpenBuff, UINT uStyle )
2847 {
2848     static FN_OpenFile *pfn = 0;
2849     if (!pfn)
2850         kPrf2WrapResolve((void **)&pfn, "OpenFile", &g_Kernel32);
2851     return pfn( lpFileName, lpReOpenBuff, uStyle );
2852 }
2853
2854 typedef HFILE WINAPI FN__lopen( LPCSTR lpPathName, int iReadWrite );
2855 __declspec(dllexport) HFILE WINAPI kPrf2Wrap__lopen( LPCSTR lpPathName, int iReadWrite )
2856 {
2857     static FN__lopen *pfn = 0;
2858     if (!pfn)
2859         kPrf2WrapResolve((void **)&pfn, "_lopen", &g_Kernel32);
2860     return pfn( lpPathName, iReadWrite );
2861 }
2862
2863 typedef HFILE WINAPI FN__lcreat( LPCSTR lpPathName, int iAttribute );
2864 __declspec(dllexport) HFILE WINAPI kPrf2Wrap__lcreat( LPCSTR lpPathName, int iAttribute )
2865 {
2866     static FN__lcreat *pfn = 0;
2867     if (!pfn)
2868         kPrf2WrapResolve((void **)&pfn, "_lcreat", &g_Kernel32);
2869     return pfn( lpPathName, iAttribute );
2870 }
2871
2872 typedef UINT WINAPI FN__lread( HFILE hFile, LPVOID lpBuffer, UINT uBytes );
2873 __declspec(dllexport) UINT WINAPI kPrf2Wrap__lread( HFILE hFile, LPVOID lpBuffer, UINT uBytes )
2874 {
2875     static FN__lread *pfn = 0;
2876     if (!pfn)
2877         kPrf2WrapResolve((void **)&pfn, "_lread", &g_Kernel32);
2878     return pfn( hFile, lpBuffer, uBytes );
2879 }
2880
2881 typedef UINT WINAPI FN__lwrite( HFILE hFile, LPCCH lpBuffer, UINT uBytes );
2882 __declspec(dllexport) UINT WINAPI kPrf2Wrap__lwrite( HFILE hFile, LPCCH lpBuffer, UINT uBytes )
2883 {
2884     static FN__lwrite *pfn = 0;
2885     if (!pfn)
2886         kPrf2WrapResolve((void **)&pfn, "_lwrite", &g_Kernel32);
2887     return pfn( hFile, lpBuffer, uBytes );
2888 }
2889
2890 typedef long WINAPI FN__hread( HFILE hFile, LPVOID lpBuffer, long lBytes );
2891 __declspec(dllexport) long WINAPI kPrf2Wrap__hread( HFILE hFile, LPVOID lpBuffer, long lBytes )
2892 {
2893     static FN__hread *pfn = 0;
2894     if (!pfn)
2895         kPrf2WrapResolve((void **)&pfn, "_hread", &g_Kernel32);
2896     return pfn( hFile, lpBuffer, lBytes );
2897 }
2898
2899 typedef long WINAPI FN__hwrite( HFILE hFile, LPCCH lpBuffer, long lBytes );
2900 __declspec(dllexport) long WINAPI kPrf2Wrap__hwrite( HFILE hFile, LPCCH lpBuffer, long lBytes )
2901 {
2902     static FN__hwrite *pfn = 0;
2903     if (!pfn)
2904         kPrf2WrapResolve((void **)&pfn, "_hwrite", &g_Kernel32);
2905     return pfn( hFile, lpBuffer, lBytes );
2906 }
2907
2908 typedef HFILE WINAPI FN__lclose( HFILE hFile );
2909 __declspec(dllexport) HFILE WINAPI kPrf2Wrap__lclose( HFILE hFile )
2910 {
2911     static FN__lclose *pfn = 0;
2912     if (!pfn)
2913         kPrf2WrapResolve((void **)&pfn, "_lclose", &g_Kernel32);
2914     return pfn( hFile );
2915 }
2916
2917 typedef LONG WINAPI FN__llseek( HFILE hFile, LONG lOffset, int iOrigin );
2918 __declspec(dllexport) LONG WINAPI kPrf2Wrap__llseek( HFILE hFile, LONG lOffset, int iOrigin )
2919 {
2920     static FN__llseek *pfn = 0;
2921     if (!pfn)
2922         kPrf2WrapResolve((void **)&pfn, "_llseek", &g_Kernel32);
2923     return pfn( hFile, lOffset, iOrigin );
2924 }
2925
2926 typedef BOOL WINAPI FN_IsTextUnicode( CONST VOID * lpv, int iSize, LPINT lpiResult );
2927 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_IsTextUnicode( CONST VOID * lpv, int iSize, LPINT lpiResult )
2928 {
2929     static FN_IsTextUnicode *pfn = 0;
2930     if (!pfn)
2931         kPrf2WrapResolve((void **)&pfn, "IsTextUnicode", &g_Kernel32);
2932     return pfn( lpv, iSize, lpiResult );
2933 }
2934
2935 typedef DWORD WINAPI FN_FlsAlloc( PFLS_CALLBACK_FUNCTION lpCallback );
2936 __declspec(dllexport) DWORD WINAPI kPrf2Wrap_FlsAlloc( PFLS_CALLBACK_FUNCTION lpCallback )
2937 {
2938     static FN_FlsAlloc *pfn = 0;
2939     if (!pfn)
2940         kPrf2WrapResolve((void **)&pfn, "FlsAlloc", &g_Kernel32);
2941     return pfn( lpCallback );
2942 }
2943
2944 typedef PVOID WINAPI FN_FlsGetValue( DWORD dwFlsIndex );
2945 __declspec(dllexport) PVOID WINAPI kPrf2Wrap_FlsGetValue( DWORD dwFlsIndex )
2946 {
2947     static FN_FlsGetValue *pfn = 0;
2948     if (!pfn)
2949         kPrf2WrapResolve((void **)&pfn, "FlsGetValue", &g_Kernel32);
2950     return pfn( dwFlsIndex );
2951 }
2952
2953 typedef BOOL WINAPI FN_FlsSetValue( DWORD dwFlsIndex, PVOID lpFlsData );
2954 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_FlsSetValue( DWORD dwFlsIndex, PVOID lpFlsData )
2955 {
2956     static FN_FlsSetValue *pfn = 0;
2957     if (!pfn)
2958         kPrf2WrapResolve((void **)&pfn, "FlsSetValue", &g_Kernel32);
2959     return pfn( dwFlsIndex, lpFlsData );
2960 }
2961
2962 typedef BOOL WINAPI FN_FlsFree( DWORD dwFlsIndex );
2963 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_FlsFree( DWORD dwFlsIndex )
2964 {
2965     static FN_FlsFree *pfn = 0;
2966     if (!pfn)
2967         kPrf2WrapResolve((void **)&pfn, "FlsFree", &g_Kernel32);
2968     return pfn( dwFlsIndex );
2969 }
2970
2971 typedef DWORD WINAPI FN_TlsAlloc( VOID );
2972 __declspec(dllexport) DWORD WINAPI kPrf2Wrap_TlsAlloc( VOID )
2973 {
2974     static FN_TlsAlloc *pfn = 0;
2975     if (!pfn)
2976         kPrf2WrapResolve((void **)&pfn, "TlsAlloc", &g_Kernel32);
2977     return pfn ();
2978 }
2979
2980 typedef LPVOID WINAPI FN_TlsGetValue( DWORD dwTlsIndex );
2981 __declspec(dllexport) LPVOID WINAPI kPrf2Wrap_TlsGetValue( DWORD dwTlsIndex )
2982 {
2983     static FN_TlsGetValue *pfn = 0;
2984     if (!pfn)
2985         kPrf2WrapResolve((void **)&pfn, "TlsGetValue", &g_Kernel32);
2986     return pfn( dwTlsIndex );
2987 }
2988
2989 typedef BOOL WINAPI FN_TlsSetValue( DWORD dwTlsIndex, LPVOID lpTlsValue );
2990 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_TlsSetValue( DWORD dwTlsIndex, LPVOID lpTlsValue )
2991 {
2992     static FN_TlsSetValue *pfn = 0;
2993     if (!pfn)
2994         kPrf2WrapResolve((void **)&pfn, "TlsSetValue", &g_Kernel32);
2995     return pfn( dwTlsIndex, lpTlsValue );
2996 }
2997
2998 typedef BOOL WINAPI FN_TlsFree( DWORD dwTlsIndex );
2999 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_TlsFree( DWORD dwTlsIndex )
3000 {
3001     static FN_TlsFree *pfn = 0;
3002     if (!pfn)
3003         kPrf2WrapResolve((void **)&pfn, "TlsFree", &g_Kernel32);
3004     return pfn( dwTlsIndex );
3005 }
3006
3007 typedef DWORD WINAPI FN_SleepEx( DWORD dwMilliseconds, BOOL bAlertable );
3008 __declspec(dllexport) DWORD WINAPI kPrf2Wrap_SleepEx( DWORD dwMilliseconds, BOOL bAlertable )
3009 {
3010     static FN_SleepEx *pfn = 0;
3011     if (!pfn)
3012         kPrf2WrapResolve((void **)&pfn, "SleepEx", &g_Kernel32);
3013     return pfn( dwMilliseconds, bAlertable );
3014 }
3015
3016 typedef DWORD WINAPI FN_WaitForSingleObjectEx( HANDLE hHandle, DWORD dwMilliseconds, BOOL bAlertable );
3017 __declspec(dllexport) DWORD WINAPI kPrf2Wrap_WaitForSingleObjectEx( HANDLE hHandle, DWORD dwMilliseconds, BOOL bAlertable )
3018 {
3019     static FN_WaitForSingleObjectEx *pfn = 0;
3020     if (!pfn)
3021         kPrf2WrapResolve((void **)&pfn, "WaitForSingleObjectEx", &g_Kernel32);
3022     return pfn( hHandle, dwMilliseconds, bAlertable );
3023 }
3024
3025 typedef DWORD WINAPI FN_WaitForMultipleObjectsEx( DWORD nCount, CONST HANDLE * lpHandles, BOOL bWaitAll, DWORD dwMilliseconds, BOOL bAlertable );
3026 __declspec(dllexport) DWORD WINAPI kPrf2Wrap_WaitForMultipleObjectsEx( DWORD nCount, CONST HANDLE * lpHandles, BOOL bWaitAll, DWORD dwMilliseconds, BOOL bAlertable )
3027 {
3028     static FN_WaitForMultipleObjectsEx *pfn = 0;
3029     if (!pfn)
3030         kPrf2WrapResolve((void **)&pfn, "WaitForMultipleObjectsEx", &g_Kernel32);
3031     return pfn( nCount, lpHandles, bWaitAll, dwMilliseconds, bAlertable );
3032 }
3033
3034 typedef DWORD WINAPI FN_SignalObjectAndWait( HANDLE hObjectToSignal, HANDLE hObjectToWaitOn, DWORD dwMilliseconds, BOOL bAlertable );
3035 __declspec(dllexport) DWORD WINAPI kPrf2Wrap_SignalObjectAndWait( HANDLE hObjectToSignal, HANDLE hObjectToWaitOn, DWORD dwMilliseconds, BOOL bAlertable )
3036 {
3037     static FN_SignalObjectAndWait *pfn = 0;
3038     if (!pfn)
3039         kPrf2WrapResolve((void **)&pfn, "SignalObjectAndWait", &g_Kernel32);
3040     return pfn( hObjectToSignal, hObjectToWaitOn, dwMilliseconds, bAlertable );
3041 }
3042
3043 typedef BOOL WINAPI FN_ReadFileEx( HANDLE hFile, LPVOID lpBuffer, DWORD nNumberOfBytesToRead, LPOVERLAPPED lpOverlapped, LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine );
3044 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_ReadFileEx( HANDLE hFile, LPVOID lpBuffer, DWORD nNumberOfBytesToRead, LPOVERLAPPED lpOverlapped, LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine )
3045 {
3046     static FN_ReadFileEx *pfn = 0;
3047     if (!pfn)
3048         kPrf2WrapResolve((void **)&pfn, "ReadFileEx", &g_Kernel32);
3049     return pfn( hFile, lpBuffer, nNumberOfBytesToRead, lpOverlapped, lpCompletionRoutine );
3050 }
3051
3052 typedef BOOL WINAPI FN_WriteFileEx( HANDLE hFile, LPCVOID lpBuffer, DWORD nNumberOfBytesToWrite, LPOVERLAPPED lpOverlapped, LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine );
3053 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_WriteFileEx( HANDLE hFile, LPCVOID lpBuffer, DWORD nNumberOfBytesToWrite, LPOVERLAPPED lpOverlapped, LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine )
3054 {
3055     static FN_WriteFileEx *pfn = 0;
3056     if (!pfn)
3057         kPrf2WrapResolve((void **)&pfn, "WriteFileEx", &g_Kernel32);
3058     return pfn( hFile, lpBuffer, nNumberOfBytesToWrite, lpOverlapped, lpCompletionRoutine );
3059 }
3060
3061 typedef BOOL WINAPI FN_BackupRead( HANDLE hFile, LPBYTE lpBuffer, DWORD nNumberOfBytesToRead, LPDWORD lpNumberOfBytesRead, BOOL bAbort, BOOL bProcessSecurity, LPVOID * lpContext );
3062 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_BackupRead( HANDLE hFile, LPBYTE lpBuffer, DWORD nNumberOfBytesToRead, LPDWORD lpNumberOfBytesRead, BOOL bAbort, BOOL bProcessSecurity, LPVOID * lpContext )
3063 {
3064     static FN_BackupRead *pfn = 0;
3065     if (!pfn)
3066         kPrf2WrapResolve((void **)&pfn, "BackupRead", &g_Kernel32);
3067     return pfn( hFile, lpBuffer, nNumberOfBytesToRead, lpNumberOfBytesRead, bAbort, bProcessSecurity, lpContext );
3068 }
3069
3070 typedef BOOL WINAPI FN_BackupSeek( HANDLE hFile, DWORD dwLowBytesToSeek, DWORD dwHighBytesToSeek, LPDWORD lpdwLowByteSeeked, LPDWORD lpdwHighByteSeeked, LPVOID * lpContext );
3071 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_BackupSeek( HANDLE hFile, DWORD dwLowBytesToSeek, DWORD dwHighBytesToSeek, LPDWORD lpdwLowByteSeeked, LPDWORD lpdwHighByteSeeked, LPVOID * lpContext )
3072 {
3073     static FN_BackupSeek *pfn = 0;
3074     if (!pfn)
3075         kPrf2WrapResolve((void **)&pfn, "BackupSeek", &g_Kernel32);
3076     return pfn( hFile, dwLowBytesToSeek, dwHighBytesToSeek, lpdwLowByteSeeked, lpdwHighByteSeeked, lpContext );
3077 }
3078
3079 typedef BOOL WINAPI FN_BackupWrite( HANDLE hFile, LPBYTE lpBuffer, DWORD nNumberOfBytesToWrite, LPDWORD lpNumberOfBytesWritten, BOOL bAbort, BOOL bProcessSecurity, LPVOID * lpContext );
3080 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_BackupWrite( HANDLE hFile, LPBYTE lpBuffer, DWORD nNumberOfBytesToWrite, LPDWORD lpNumberOfBytesWritten, BOOL bAbort, BOOL bProcessSecurity, LPVOID * lpContext )
3081 {
3082     static FN_BackupWrite *pfn = 0;
3083     if (!pfn)
3084         kPrf2WrapResolve((void **)&pfn, "BackupWrite", &g_Kernel32);
3085     return pfn( hFile, lpBuffer, nNumberOfBytesToWrite, lpNumberOfBytesWritten, bAbort, bProcessSecurity, lpContext );
3086 }
3087
3088 typedef BOOL WINAPI FN_ReadFileScatter( HANDLE hFile, FILE_SEGMENT_ELEMENT aSegmentArray[], DWORD nNumberOfBytesToRead, LPDWORD lpReserved, LPOVERLAPPED lpOverlapped );
3089 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_ReadFileScatter( HANDLE hFile, FILE_SEGMENT_ELEMENT aSegmentArray[], DWORD nNumberOfBytesToRead, LPDWORD lpReserved, LPOVERLAPPED lpOverlapped )
3090 {
3091     static FN_ReadFileScatter *pfn = 0;
3092     if (!pfn)
3093         kPrf2WrapResolve((void **)&pfn, "ReadFileScatter", &g_Kernel32);
3094     return pfn( hFile, aSegmentArray, nNumberOfBytesToRead, lpReserved, lpOverlapped );
3095 }
3096
3097 typedef BOOL WINAPI FN_WriteFileGather( HANDLE hFile, FILE_SEGMENT_ELEMENT aSegmentArray[], DWORD nNumberOfBytesToWrite, LPDWORD lpReserved, LPOVERLAPPED lpOverlapped );
3098 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_WriteFileGather( HANDLE hFile, FILE_SEGMENT_ELEMENT aSegmentArray[], DWORD nNumberOfBytesToWrite, LPDWORD lpReserved, LPOVERLAPPED lpOverlapped )
3099 {
3100     static FN_WriteFileGather *pfn = 0;
3101     if (!pfn)
3102         kPrf2WrapResolve((void **)&pfn, "WriteFileGather", &g_Kernel32);
3103     return pfn( hFile, aSegmentArray, nNumberOfBytesToWrite, lpReserved, lpOverlapped );
3104 }
3105
3106 typedef HANDLE WINAPI FN_CreateMutexA( LPSECURITY_ATTRIBUTES lpMutexAttributes, BOOL bInitialOwner, LPCSTR lpName );
3107 __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_CreateMutexA( LPSECURITY_ATTRIBUTES lpMutexAttributes, BOOL bInitialOwner, LPCSTR lpName )
3108 {
3109     static FN_CreateMutexA *pfn = 0;
3110     if (!pfn)
3111         kPrf2WrapResolve((void **)&pfn, "CreateMutexA", &g_Kernel32);
3112     return pfn( lpMutexAttributes, bInitialOwner, lpName );
3113 }
3114
3115 typedef HANDLE WINAPI FN_CreateMutexW( LPSECURITY_ATTRIBUTES lpMutexAttributes, BOOL bInitialOwner, LPCWSTR lpName );
3116 __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_CreateMutexW( LPSECURITY_ATTRIBUTES lpMutexAttributes, BOOL bInitialOwner, LPCWSTR lpName )
3117 {
3118     static FN_CreateMutexW *pfn = 0;
3119     if (!pfn)
3120         kPrf2WrapResolve((void **)&pfn, "CreateMutexW", &g_Kernel32);
3121     return pfn( lpMutexAttributes, bInitialOwner, lpName );
3122 }
3123
3124 typedef HANDLE WINAPI FN_OpenMutexA( DWORD dwDesiredAccess, BOOL bInheritHandle, LPCSTR lpName );
3125 __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_OpenMutexA( DWORD dwDesiredAccess, BOOL bInheritHandle, LPCSTR lpName )
3126 {
3127     static FN_OpenMutexA *pfn = 0;
3128     if (!pfn)
3129         kPrf2WrapResolve((void **)&pfn, "OpenMutexA", &g_Kernel32);
3130     return pfn( dwDesiredAccess, bInheritHandle, lpName );
3131 }
3132
3133 typedef HANDLE WINAPI FN_OpenMutexW( DWORD dwDesiredAccess, BOOL bInheritHandle, LPCWSTR lpName );
3134 __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_OpenMutexW( DWORD dwDesiredAccess, BOOL bInheritHandle, LPCWSTR lpName )
3135 {
3136     static FN_OpenMutexW *pfn = 0;
3137     if (!pfn)
3138         kPrf2WrapResolve((void **)&pfn, "OpenMutexW", &g_Kernel32);
3139     return pfn( dwDesiredAccess, bInheritHandle, lpName );
3140 }
3141
3142 typedef HANDLE WINAPI FN_CreateEventA( LPSECURITY_ATTRIBUTES lpEventAttributes, BOOL bManualReset, BOOL bInitialState, LPCSTR lpName );
3143 __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_CreateEventA( LPSECURITY_ATTRIBUTES lpEventAttributes, BOOL bManualReset, BOOL bInitialState, LPCSTR lpName )
3144 {
3145     static FN_CreateEventA *pfn = 0;
3146     if (!pfn)
3147         kPrf2WrapResolve((void **)&pfn, "CreateEventA", &g_Kernel32);
3148     return pfn( lpEventAttributes, bManualReset, bInitialState, lpName );
3149 }
3150
3151 typedef HANDLE WINAPI FN_CreateEventW( LPSECURITY_ATTRIBUTES lpEventAttributes, BOOL bManualReset, BOOL bInitialState, LPCWSTR lpName );
3152 __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_CreateEventW( LPSECURITY_ATTRIBUTES lpEventAttributes, BOOL bManualReset, BOOL bInitialState, LPCWSTR lpName )
3153 {
3154     static FN_CreateEventW *pfn = 0;
3155     if (!pfn)
3156         kPrf2WrapResolve((void **)&pfn, "CreateEventW", &g_Kernel32);
3157     return pfn( lpEventAttributes, bManualReset, bInitialState, lpName );
3158 }
3159
3160 typedef HANDLE WINAPI FN_OpenEventA( DWORD dwDesiredAccess, BOOL bInheritHandle, LPCSTR lpName );
3161 __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_OpenEventA( DWORD dwDesiredAccess, BOOL bInheritHandle, LPCSTR lpName )
3162 {
3163     static FN_OpenEventA *pfn = 0;
3164     if (!pfn)
3165         kPrf2WrapResolve((void **)&pfn, "OpenEventA", &g_Kernel32);
3166     return pfn( dwDesiredAccess, bInheritHandle, lpName );
3167 }
3168
3169 typedef HANDLE WINAPI FN_OpenEventW( DWORD dwDesiredAccess, BOOL bInheritHandle, LPCWSTR lpName );
3170 __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_OpenEventW( DWORD dwDesiredAccess, BOOL bInheritHandle, LPCWSTR lpName )
3171 {
3172     static FN_OpenEventW *pfn = 0;
3173     if (!pfn)
3174         kPrf2WrapResolve((void **)&pfn, "OpenEventW", &g_Kernel32);
3175     return pfn( dwDesiredAccess, bInheritHandle, lpName );
3176 }
3177
3178 typedef HANDLE WINAPI FN_CreateSemaphoreA( LPSECURITY_ATTRIBUTES lpSemaphoreAttributes, LONG lInitialCount, LONG lMaximumCount, LPCSTR lpName );
3179 __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_CreateSemaphoreA( LPSECURITY_ATTRIBUTES lpSemaphoreAttributes, LONG lInitialCount, LONG lMaximumCount, LPCSTR lpName )
3180 {
3181     static FN_CreateSemaphoreA *pfn = 0;
3182     if (!pfn)
3183         kPrf2WrapResolve((void **)&pfn, "CreateSemaphoreA", &g_Kernel32);
3184     return pfn( lpSemaphoreAttributes, lInitialCount, lMaximumCount, lpName );
3185 }
3186
3187 typedef HANDLE WINAPI FN_CreateSemaphoreW( LPSECURITY_ATTRIBUTES lpSemaphoreAttributes, LONG lInitialCount, LONG lMaximumCount, LPCWSTR lpName );
3188 __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_CreateSemaphoreW( LPSECURITY_ATTRIBUTES lpSemaphoreAttributes, LONG lInitialCount, LONG lMaximumCount, LPCWSTR lpName )
3189 {
3190     static FN_CreateSemaphoreW *pfn = 0;
3191     if (!pfn)
3192         kPrf2WrapResolve((void **)&pfn, "CreateSemaphoreW", &g_Kernel32);
3193     return pfn( lpSemaphoreAttributes, lInitialCount, lMaximumCount, lpName );
3194 }
3195
3196 typedef HANDLE WINAPI FN_OpenSemaphoreA( DWORD dwDesiredAccess, BOOL bInheritHandle, LPCSTR lpName );
3197 __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_OpenSemaphoreA( DWORD dwDesiredAccess, BOOL bInheritHandle, LPCSTR lpName )
3198 {
3199     static FN_OpenSemaphoreA *pfn = 0;
3200     if (!pfn)
3201         kPrf2WrapResolve((void **)&pfn, "OpenSemaphoreA", &g_Kernel32);
3202     return pfn( dwDesiredAccess, bInheritHandle, lpName );
3203 }
3204
3205 typedef HANDLE WINAPI FN_OpenSemaphoreW( DWORD dwDesiredAccess, BOOL bInheritHandle, LPCWSTR lpName );
3206 __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_OpenSemaphoreW( DWORD dwDesiredAccess, BOOL bInheritHandle, LPCWSTR lpName )
3207 {
3208     static FN_OpenSemaphoreW *pfn = 0;
3209     if (!pfn)
3210         kPrf2WrapResolve((void **)&pfn, "OpenSemaphoreW", &g_Kernel32);
3211     return pfn( dwDesiredAccess, bInheritHandle, lpName );
3212 }
3213
3214 typedef HANDLE WINAPI FN_CreateWaitableTimerA( LPSECURITY_ATTRIBUTES lpTimerAttributes, BOOL bManualReset, LPCSTR lpTimerName );
3215 __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_CreateWaitableTimerA( LPSECURITY_ATTRIBUTES lpTimerAttributes, BOOL bManualReset, LPCSTR lpTimerName )
3216 {
3217     static FN_CreateWaitableTimerA *pfn = 0;
3218     if (!pfn)
3219         kPrf2WrapResolve((void **)&pfn, "CreateWaitableTimerA", &g_Kernel32);
3220     return pfn( lpTimerAttributes, bManualReset, lpTimerName );
3221 }
3222
3223 typedef HANDLE WINAPI FN_CreateWaitableTimerW( LPSECURITY_ATTRIBUTES lpTimerAttributes, BOOL bManualReset, LPCWSTR lpTimerName );
3224 __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_CreateWaitableTimerW( LPSECURITY_ATTRIBUTES lpTimerAttributes, BOOL bManualReset, LPCWSTR lpTimerName )
3225 {
3226     static FN_CreateWaitableTimerW *pfn = 0;
3227     if (!pfn)
3228         kPrf2WrapResolve((void **)&pfn, "CreateWaitableTimerW", &g_Kernel32);
3229     return pfn( lpTimerAttributes, bManualReset, lpTimerName );
3230 }
3231
3232 typedef HANDLE WINAPI FN_OpenWaitableTimerA( DWORD dwDesiredAccess, BOOL bInheritHandle, LPCSTR lpTimerName );
3233 __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_OpenWaitableTimerA( DWORD dwDesiredAccess, BOOL bInheritHandle, LPCSTR lpTimerName )
3234 {
3235     static FN_OpenWaitableTimerA *pfn = 0;
3236     if (!pfn)
3237         kPrf2WrapResolve((void **)&pfn, "OpenWaitableTimerA", &g_Kernel32);
3238     return pfn( dwDesiredAccess, bInheritHandle, lpTimerName );
3239 }
3240
3241 typedef HANDLE WINAPI FN_OpenWaitableTimerW( DWORD dwDesiredAccess, BOOL bInheritHandle, LPCWSTR lpTimerName );
3242 __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_OpenWaitableTimerW( DWORD dwDesiredAccess, BOOL bInheritHandle, LPCWSTR lpTimerName )
3243 {
3244     static FN_OpenWaitableTimerW *pfn = 0;
3245     if (!pfn)
3246         kPrf2WrapResolve((void **)&pfn, "OpenWaitableTimerW", &g_Kernel32);
3247     return pfn( dwDesiredAccess, bInheritHandle, lpTimerName );
3248 }
3249
3250 typedef BOOL WINAPI FN_SetWaitableTimer( HANDLE hTimer, const LARGE_INTEGER * lpDueTime, LONG lPeriod, PTIMERAPCROUTINE pfnCompletionRoutine, LPVOID lpArgToCompletionRoutine, BOOL fResume );
3251 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetWaitableTimer( HANDLE hTimer, const LARGE_INTEGER * lpDueTime, LONG lPeriod, PTIMERAPCROUTINE pfnCompletionRoutine, LPVOID lpArgToCompletionRoutine, BOOL fResume )
3252 {
3253     static FN_SetWaitableTimer *pfn = 0;
3254     if (!pfn)
3255         kPrf2WrapResolve((void **)&pfn, "SetWaitableTimer", &g_Kernel32);
3256     return pfn( hTimer, lpDueTime, lPeriod, pfnCompletionRoutine, lpArgToCompletionRoutine, fResume );
3257 }
3258
3259 typedef BOOL WINAPI FN_CancelWaitableTimer( HANDLE hTimer );
3260 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_CancelWaitableTimer( HANDLE hTimer )
3261 {
3262     static FN_CancelWaitableTimer *pfn = 0;
3263     if (!pfn)
3264         kPrf2WrapResolve((void **)&pfn, "CancelWaitableTimer", &g_Kernel32);
3265     return pfn( hTimer );
3266 }
3267
3268 typedef HANDLE WINAPI FN_CreateFileMappingA( HANDLE hFile, LPSECURITY_ATTRIBUTES lpFileMappingAttributes, DWORD flProtect, DWORD dwMaximumSizeHigh, DWORD dwMaximumSizeLow, LPCSTR lpName );
3269 __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_CreateFileMappingA( HANDLE hFile, LPSECURITY_ATTRIBUTES lpFileMappingAttributes, DWORD flProtect, DWORD dwMaximumSizeHigh, DWORD dwMaximumSizeLow, LPCSTR lpName )
3270 {
3271     static FN_CreateFileMappingA *pfn = 0;
3272     if (!pfn)
3273         kPrf2WrapResolve((void **)&pfn, "CreateFileMappingA", &g_Kernel32);
3274     return pfn( hFile, lpFileMappingAttributes, flProtect, dwMaximumSizeHigh, dwMaximumSizeLow, lpName );
3275 }
3276
3277 typedef HANDLE WINAPI FN_CreateFileMappingW( HANDLE hFile, LPSECURITY_ATTRIBUTES lpFileMappingAttributes, DWORD flProtect, DWORD dwMaximumSizeHigh, DWORD dwMaximumSizeLow, LPCWSTR lpName );
3278 __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_CreateFileMappingW( HANDLE hFile, LPSECURITY_ATTRIBUTES lpFileMappingAttributes, DWORD flProtect, DWORD dwMaximumSizeHigh, DWORD dwMaximumSizeLow, LPCWSTR lpName )
3279 {
3280     static FN_CreateFileMappingW *pfn = 0;
3281     if (!pfn)
3282         kPrf2WrapResolve((void **)&pfn, "CreateFileMappingW", &g_Kernel32);
3283     return pfn( hFile, lpFileMappingAttributes, flProtect, dwMaximumSizeHigh, dwMaximumSizeLow, lpName );
3284 }
3285
3286 typedef HANDLE WINAPI FN_OpenFileMappingA( DWORD dwDesiredAccess, BOOL bInheritHandle, LPCSTR lpName );
3287 __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_OpenFileMappingA( DWORD dwDesiredAccess, BOOL bInheritHandle, LPCSTR lpName )
3288 {
3289     static FN_OpenFileMappingA *pfn = 0;
3290     if (!pfn)
3291         kPrf2WrapResolve((void **)&pfn, "OpenFileMappingA", &g_Kernel32);
3292     return pfn( dwDesiredAccess, bInheritHandle, lpName );
3293 }
3294
3295 typedef HANDLE WINAPI FN_OpenFileMappingW( DWORD dwDesiredAccess, BOOL bInheritHandle, LPCWSTR lpName );
3296 __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_OpenFileMappingW( DWORD dwDesiredAccess, BOOL bInheritHandle, LPCWSTR lpName )
3297 {
3298     static FN_OpenFileMappingW *pfn = 0;
3299     if (!pfn)
3300         kPrf2WrapResolve((void **)&pfn, "OpenFileMappingW", &g_Kernel32);
3301     return pfn( dwDesiredAccess, bInheritHandle, lpName );
3302 }
3303
3304 typedef DWORD WINAPI FN_GetLogicalDriveStringsA( DWORD nBufferLength, LPSTR lpBuffer );
3305 __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetLogicalDriveStringsA( DWORD nBufferLength, LPSTR lpBuffer )
3306 {
3307     static FN_GetLogicalDriveStringsA *pfn = 0;
3308     if (!pfn)
3309         kPrf2WrapResolve((void **)&pfn, "GetLogicalDriveStringsA", &g_Kernel32);
3310     return pfn( nBufferLength, lpBuffer );
3311 }
3312
3313 typedef DWORD WINAPI FN_GetLogicalDriveStringsW( DWORD nBufferLength, LPWSTR lpBuffer );
3314 __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetLogicalDriveStringsW( DWORD nBufferLength, LPWSTR lpBuffer )
3315 {
3316     static FN_GetLogicalDriveStringsW *pfn = 0;
3317     if (!pfn)
3318         kPrf2WrapResolve((void **)&pfn, "GetLogicalDriveStringsW", &g_Kernel32);
3319     return pfn( nBufferLength, lpBuffer );
3320 }
3321
3322 typedef HANDLE WINAPI FN_CreateMemoryResourceNotification( MEMORY_RESOURCE_NOTIFICATION_TYPE NotificationType );
3323 __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_CreateMemoryResourceNotification( MEMORY_RESOURCE_NOTIFICATION_TYPE NotificationType )
3324 {
3325     static FN_CreateMemoryResourceNotification *pfn = 0;
3326     if (!pfn)
3327         kPrf2WrapResolve((void **)&pfn, "CreateMemoryResourceNotification", &g_Kernel32);
3328     return pfn( NotificationType );
3329 }
3330
3331 typedef BOOL WINAPI FN_QueryMemoryResourceNotification( HANDLE ResourceNotificationHandle, PBOOL ResourceState );
3332 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_QueryMemoryResourceNotification( HANDLE ResourceNotificationHandle, PBOOL ResourceState )
3333 {
3334     static FN_QueryMemoryResourceNotification *pfn = 0;
3335     if (!pfn)
3336         kPrf2WrapResolve((void **)&pfn, "QueryMemoryResourceNotification", &g_Kernel32);
3337     return pfn( ResourceNotificationHandle, ResourceState );
3338 }
3339
3340 typedef HMODULE WINAPI FN_LoadLibraryA( LPCSTR lpLibFileName );
3341 __declspec(dllexport) HMODULE WINAPI kPrf2Wrap_LoadLibraryA( LPCSTR lpLibFileName )
3342 {
3343     static FN_LoadLibraryA *pfn = 0;
3344     if (!pfn)
3345         kPrf2WrapResolve((void **)&pfn, "LoadLibraryA", &g_Kernel32);
3346     return pfn( lpLibFileName );
3347 }
3348
3349 typedef HMODULE WINAPI FN_LoadLibraryW( LPCWSTR lpLibFileName );
3350 __declspec(dllexport) HMODULE WINAPI kPrf2Wrap_LoadLibraryW( LPCWSTR lpLibFileName )
3351 {
3352     static FN_LoadLibraryW *pfn = 0;
3353     if (!pfn)
3354         kPrf2WrapResolve((void **)&pfn, "LoadLibraryW", &g_Kernel32);
3355     return pfn( lpLibFileName );
3356 }
3357
3358 typedef HMODULE WINAPI FN_LoadLibraryExA( LPCSTR lpLibFileName, HANDLE hFile, DWORD dwFlags );
3359 __declspec(dllexport) HMODULE WINAPI kPrf2Wrap_LoadLibraryExA( LPCSTR lpLibFileName, HANDLE hFile, DWORD dwFlags )
3360 {
3361     static FN_LoadLibraryExA *pfn = 0;
3362     if (!pfn)
3363         kPrf2WrapResolve((void **)&pfn, "LoadLibraryExA", &g_Kernel32);
3364     return pfn( lpLibFileName, hFile, dwFlags );
3365 }
3366
3367 typedef HMODULE WINAPI FN_LoadLibraryExW( LPCWSTR lpLibFileName, HANDLE hFile, DWORD dwFlags );
3368 __declspec(dllexport) HMODULE WINAPI kPrf2Wrap_LoadLibraryExW( LPCWSTR lpLibFileName, HANDLE hFile, DWORD dwFlags )
3369 {
3370     static FN_LoadLibraryExW *pfn = 0;
3371     if (!pfn)
3372         kPrf2WrapResolve((void **)&pfn, "LoadLibraryExW", &g_Kernel32);
3373     return pfn( lpLibFileName, hFile, dwFlags );
3374 }
3375
3376 typedef DWORD WINAPI FN_GetModuleFileNameA( HMODULE hModule, LPCH lpFilename, DWORD nSize );
3377 __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetModuleFileNameA( HMODULE hModule, LPCH lpFilename, DWORD nSize )
3378 {
3379     static FN_GetModuleFileNameA *pfn = 0;
3380     if (!pfn)
3381         kPrf2WrapResolve((void **)&pfn, "GetModuleFileNameA", &g_Kernel32);
3382     return pfn( hModule, lpFilename, nSize );
3383 }
3384
3385 typedef DWORD WINAPI FN_GetModuleFileNameW( HMODULE hModule, LPWCH lpFilename, DWORD nSize );
3386 __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetModuleFileNameW( HMODULE hModule, LPWCH lpFilename, DWORD nSize )
3387 {
3388     static FN_GetModuleFileNameW *pfn = 0;
3389     if (!pfn)
3390         kPrf2WrapResolve((void **)&pfn, "GetModuleFileNameW", &g_Kernel32);
3391     return pfn( hModule, lpFilename, nSize );
3392 }
3393
3394 typedef HMODULE WINAPI FN_GetModuleHandleA( LPCSTR lpModuleName );
3395 __declspec(dllexport) HMODULE WINAPI kPrf2Wrap_GetModuleHandleA( LPCSTR lpModuleName )
3396 {
3397     static FN_GetModuleHandleA *pfn = 0;
3398     if (!pfn)
3399         kPrf2WrapResolve((void **)&pfn, "GetModuleHandleA", &g_Kernel32);
3400     return pfn( lpModuleName );
3401 }
3402
3403 typedef HMODULE WINAPI FN_GetModuleHandleW( LPCWSTR lpModuleName );
3404 __declspec(dllexport) HMODULE WINAPI kPrf2Wrap_GetModuleHandleW( LPCWSTR lpModuleName )
3405 {
3406     static FN_GetModuleHandleW *pfn = 0;
3407     if (!pfn)
3408         kPrf2WrapResolve((void **)&pfn, "GetModuleHandleW", &g_Kernel32);
3409     return pfn( lpModuleName );
3410 }
3411
3412 typedef BOOL WINAPI FN_GetModuleHandleExA( DWORD dwFlags, LPCSTR lpModuleName, HMODULE * phModule );
3413 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetModuleHandleExA( DWORD dwFlags, LPCSTR lpModuleName, HMODULE * phModule )
3414 {
3415     static FN_GetModuleHandleExA *pfn = 0;
3416     if (!pfn)
3417         kPrf2WrapResolve((void **)&pfn, "GetModuleHandleExA", &g_Kernel32);
3418     return pfn( dwFlags, lpModuleName, phModule );
3419 }
3420
3421 typedef BOOL WINAPI FN_GetModuleHandleExW( DWORD dwFlags, LPCWSTR lpModuleName, HMODULE * phModule );
3422 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetModuleHandleExW( DWORD dwFlags, LPCWSTR lpModuleName, HMODULE * phModule )
3423 {
3424     static FN_GetModuleHandleExW *pfn = 0;
3425     if (!pfn)
3426         kPrf2WrapResolve((void **)&pfn, "GetModuleHandleExW", &g_Kernel32);
3427     return pfn( dwFlags, lpModuleName, phModule );
3428 }
3429
3430 typedef BOOL WINAPI FN_NeedCurrentDirectoryForExePathA( LPCSTR ExeName );
3431 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_NeedCurrentDirectoryForExePathA( LPCSTR ExeName )
3432 {
3433     static FN_NeedCurrentDirectoryForExePathA *pfn = 0;
3434     if (!pfn)
3435         kPrf2WrapResolve((void **)&pfn, "NeedCurrentDirectoryForExePathA", &g_Kernel32);
3436     return pfn( ExeName );
3437 }
3438
3439 typedef BOOL WINAPI FN_NeedCurrentDirectoryForExePathW( LPCWSTR ExeName );
3440 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_NeedCurrentDirectoryForExePathW( LPCWSTR ExeName )
3441 {
3442     static FN_NeedCurrentDirectoryForExePathW *pfn = 0;
3443     if (!pfn)
3444         kPrf2WrapResolve((void **)&pfn, "NeedCurrentDirectoryForExePathW", &g_Kernel32);
3445     return pfn( ExeName );
3446 }
3447
3448 typedef BOOL WINAPI FN_CreateProcessA( LPCSTR lpApplicationName, LPSTR lpCommandLine, LPSECURITY_ATTRIBUTES lpProcessAttributes, LPSECURITY_ATTRIBUTES lpThreadAttributes, BOOL bInheritHandles, DWORD dwCreationFlags, LPVOID lpEnvironment, LPCSTR lpCurrentDirectory, LPSTARTUPINFOA lpStartupInfo, LPPROCESS_INFORMATION lpProcessInformation );
3449 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_CreateProcessA( LPCSTR lpApplicationName, LPSTR lpCommandLine, LPSECURITY_ATTRIBUTES lpProcessAttributes, LPSECURITY_ATTRIBUTES lpThreadAttributes, BOOL bInheritHandles, DWORD dwCreationFlags, LPVOID lpEnvironment, LPCSTR lpCurrentDirectory, LPSTARTUPINFOA lpStartupInfo, LPPROCESS_INFORMATION lpProcessInformation )
3450 {
3451     static FN_CreateProcessA *pfn = 0;
3452     if (!pfn)
3453         kPrf2WrapResolve((void **)&pfn, "CreateProcessA", &g_Kernel32);
3454     return pfn( lpApplicationName, lpCommandLine, lpProcessAttributes, lpThreadAttributes, bInheritHandles, dwCreationFlags, lpEnvironment, lpCurrentDirectory, lpStartupInfo, lpProcessInformation );
3455 }
3456
3457 typedef BOOL WINAPI FN_CreateProcessW( LPCWSTR lpApplicationName, LPWSTR lpCommandLine, LPSECURITY_ATTRIBUTES lpProcessAttributes, LPSECURITY_ATTRIBUTES lpThreadAttributes, BOOL bInheritHandles, DWORD dwCreationFlags, LPVOID lpEnvironment, LPCWSTR lpCurrentDirectory, LPSTARTUPINFOW lpStartupInfo, LPPROCESS_INFORMATION lpProcessInformation );
3458 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_CreateProcessW( LPCWSTR lpApplicationName, LPWSTR lpCommandLine, LPSECURITY_ATTRIBUTES lpProcessAttributes, LPSECURITY_ATTRIBUTES lpThreadAttributes, BOOL bInheritHandles, DWORD dwCreationFlags, LPVOID lpEnvironment, LPCWSTR lpCurrentDirectory, LPSTARTUPINFOW lpStartupInfo, LPPROCESS_INFORMATION lpProcessInformation )
3459 {
3460     static FN_CreateProcessW *pfn = 0;
3461     if (!pfn)
3462         kPrf2WrapResolve((void **)&pfn, "CreateProcessW", &g_Kernel32);
3463     return pfn( lpApplicationName, lpCommandLine, lpProcessAttributes, lpThreadAttributes, bInheritHandles, dwCreationFlags, lpEnvironment, lpCurrentDirectory, lpStartupInfo, lpProcessInformation );
3464 }
3465
3466 typedef BOOL WINAPI FN_SetProcessShutdownParameters( DWORD dwLevel, DWORD dwFlags );
3467 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetProcessShutdownParameters( DWORD dwLevel, DWORD dwFlags )
3468 {
3469     static FN_SetProcessShutdownParameters *pfn = 0;
3470     if (!pfn)
3471         kPrf2WrapResolve((void **)&pfn, "SetProcessShutdownParameters", &g_Kernel32);
3472     return pfn( dwLevel, dwFlags );
3473 }
3474
3475 typedef BOOL WINAPI FN_GetProcessShutdownParameters( LPDWORD lpdwLevel, LPDWORD lpdwFlags );
3476 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetProcessShutdownParameters( LPDWORD lpdwLevel, LPDWORD lpdwFlags )
3477 {
3478     static FN_GetProcessShutdownParameters *pfn = 0;
3479     if (!pfn)
3480         kPrf2WrapResolve((void **)&pfn, "GetProcessShutdownParameters", &g_Kernel32);
3481     return pfn( lpdwLevel, lpdwFlags );
3482 }
3483
3484 typedef DWORD WINAPI FN_GetProcessVersion( DWORD ProcessId );
3485 __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetProcessVersion( DWORD ProcessId )
3486 {
3487     static FN_GetProcessVersion *pfn = 0;
3488     if (!pfn)
3489         kPrf2WrapResolve((void **)&pfn, "GetProcessVersion", &g_Kernel32);
3490     return pfn( ProcessId );
3491 }
3492
3493 typedef VOID WINAPI FN_FatalAppExitA( UINT uAction, LPCSTR lpMessageText );
3494 __declspec(dllexport) VOID WINAPI kPrf2Wrap_FatalAppExitA( UINT uAction, LPCSTR lpMessageText )
3495 {
3496     static FN_FatalAppExitA *pfn = 0;
3497     if (!pfn)
3498         kPrf2WrapResolve((void **)&pfn, "FatalAppExitA", &g_Kernel32);
3499     pfn( uAction, lpMessageText );
3500 }
3501
3502 typedef VOID WINAPI FN_FatalAppExitW( UINT uAction, LPCWSTR lpMessageText );
3503 __declspec(dllexport) VOID WINAPI kPrf2Wrap_FatalAppExitW( UINT uAction, LPCWSTR lpMessageText )
3504 {
3505     static FN_FatalAppExitW *pfn = 0;
3506     if (!pfn)
3507         kPrf2WrapResolve((void **)&pfn, "FatalAppExitW", &g_Kernel32);
3508     pfn( uAction, lpMessageText );
3509 }
3510
3511 typedef VOID WINAPI FN_GetStartupInfoA( LPSTARTUPINFOA lpStartupInfo );
3512 __declspec(dllexport) VOID WINAPI kPrf2Wrap_GetStartupInfoA( LPSTARTUPINFOA lpStartupInfo )
3513 {
3514     static FN_GetStartupInfoA *pfn = 0;
3515     if (!pfn)
3516         kPrf2WrapResolve((void **)&pfn, "GetStartupInfoA", &g_Kernel32);
3517     pfn( lpStartupInfo );
3518 }
3519
3520 typedef VOID WINAPI FN_GetStartupInfoW( LPSTARTUPINFOW lpStartupInfo );
3521 __declspec(dllexport) VOID WINAPI kPrf2Wrap_GetStartupInfoW( LPSTARTUPINFOW lpStartupInfo )
3522 {
3523     static FN_GetStartupInfoW *pfn = 0;
3524     if (!pfn)
3525         kPrf2WrapResolve((void **)&pfn, "GetStartupInfoW", &g_Kernel32);
3526     pfn( lpStartupInfo );
3527 }
3528
3529 typedef LPSTR WINAPI FN_GetCommandLineA( VOID );
3530 __declspec(dllexport) LPSTR WINAPI kPrf2Wrap_GetCommandLineA( VOID )
3531 {
3532     static FN_GetCommandLineA *pfn = 0;
3533     if (!pfn)
3534         kPrf2WrapResolve((void **)&pfn, "GetCommandLineA", &g_Kernel32);
3535     return pfn ();
3536 }
3537
3538 typedef LPWSTR WINAPI FN_GetCommandLineW( VOID );
3539 __declspec(dllexport) LPWSTR WINAPI kPrf2Wrap_GetCommandLineW( VOID )
3540 {
3541     static FN_GetCommandLineW *pfn = 0;
3542     if (!pfn)
3543         kPrf2WrapResolve((void **)&pfn, "GetCommandLineW", &g_Kernel32);
3544     return pfn ();
3545 }
3546
3547 typedef DWORD WINAPI FN_GetEnvironmentVariableA( LPCSTR lpName, LPSTR lpBuffer, DWORD nSize );
3548 __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetEnvironmentVariableA( LPCSTR lpName, LPSTR lpBuffer, DWORD nSize )
3549 {
3550     static FN_GetEnvironmentVariableA *pfn = 0;
3551     if (!pfn)
3552         kPrf2WrapResolve((void **)&pfn, "GetEnvironmentVariableA", &g_Kernel32);
3553     return pfn( lpName, lpBuffer, nSize );
3554 }
3555
3556 typedef DWORD WINAPI FN_GetEnvironmentVariableW( LPCWSTR lpName, LPWSTR lpBuffer, DWORD nSize );
3557 __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetEnvironmentVariableW( LPCWSTR lpName, LPWSTR lpBuffer, DWORD nSize )
3558 {
3559     static FN_GetEnvironmentVariableW *pfn = 0;
3560     if (!pfn)
3561         kPrf2WrapResolve((void **)&pfn, "GetEnvironmentVariableW", &g_Kernel32);
3562     return pfn( lpName, lpBuffer, nSize );
3563 }
3564
3565 typedef BOOL WINAPI FN_SetEnvironmentVariableA( LPCSTR lpName, LPCSTR lpValue );
3566 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetEnvironmentVariableA( LPCSTR lpName, LPCSTR lpValue )
3567 {
3568     static FN_SetEnvironmentVariableA *pfn = 0;
3569     if (!pfn)
3570         kPrf2WrapResolve((void **)&pfn, "SetEnvironmentVariableA", &g_Kernel32);
3571     return pfn( lpName, lpValue );
3572 }
3573
3574 typedef BOOL WINAPI FN_SetEnvironmentVariableW( LPCWSTR lpName, LPCWSTR lpValue );
3575 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetEnvironmentVariableW( LPCWSTR lpName, LPCWSTR lpValue )
3576 {
3577     static FN_SetEnvironmentVariableW *pfn = 0;
3578     if (!pfn)
3579         kPrf2WrapResolve((void **)&pfn, "SetEnvironmentVariableW", &g_Kernel32);
3580     return pfn( lpName, lpValue );
3581 }
3582
3583 typedef DWORD WINAPI FN_ExpandEnvironmentStringsA( LPCSTR lpSrc, LPSTR lpDst, DWORD nSize );
3584 __declspec(dllexport) DWORD WINAPI kPrf2Wrap_ExpandEnvironmentStringsA( LPCSTR lpSrc, LPSTR lpDst, DWORD nSize )
3585 {
3586     static FN_ExpandEnvironmentStringsA *pfn = 0;
3587     if (!pfn)
3588         kPrf2WrapResolve((void **)&pfn, "ExpandEnvironmentStringsA", &g_Kernel32);
3589     return pfn( lpSrc, lpDst, nSize );
3590 }
3591
3592 typedef DWORD WINAPI FN_ExpandEnvironmentStringsW( LPCWSTR lpSrc, LPWSTR lpDst, DWORD nSize );
3593 __declspec(dllexport) DWORD WINAPI kPrf2Wrap_ExpandEnvironmentStringsW( LPCWSTR lpSrc, LPWSTR lpDst, DWORD nSize )
3594 {
3595     static FN_ExpandEnvironmentStringsW *pfn = 0;
3596     if (!pfn)
3597         kPrf2WrapResolve((void **)&pfn, "ExpandEnvironmentStringsW", &g_Kernel32);
3598     return pfn( lpSrc, lpDst, nSize );
3599 }
3600
3601 typedef DWORD WINAPI FN_GetFirmwareEnvironmentVariableA( LPCSTR lpName, LPCSTR lpGuid, PVOID pBuffer, DWORD nSize );
3602 __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetFirmwareEnvironmentVariableA( LPCSTR lpName, LPCSTR lpGuid, PVOID pBuffer, DWORD nSize )
3603 {
3604     static FN_GetFirmwareEnvironmentVariableA *pfn = 0;
3605     if (!pfn)
3606         kPrf2WrapResolve((void **)&pfn, "GetFirmwareEnvironmentVariableA", &g_Kernel32);
3607     return pfn( lpName, lpGuid, pBuffer, nSize );
3608 }
3609
3610 typedef DWORD WINAPI FN_GetFirmwareEnvironmentVariableW( LPCWSTR lpName, LPCWSTR lpGuid, PVOID pBuffer, DWORD nSize );
3611 __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetFirmwareEnvironmentVariableW( LPCWSTR lpName, LPCWSTR lpGuid, PVOID pBuffer, DWORD nSize )
3612 {
3613     static FN_GetFirmwareEnvironmentVariableW *pfn = 0;
3614     if (!pfn)
3615         kPrf2WrapResolve((void **)&pfn, "GetFirmwareEnvironmentVariableW", &g_Kernel32);
3616     return pfn( lpName, lpGuid, pBuffer, nSize );
3617 }
3618
3619 typedef BOOL WINAPI FN_SetFirmwareEnvironmentVariableA( LPCSTR lpName, LPCSTR lpGuid, PVOID pValue, DWORD nSize );
3620 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetFirmwareEnvironmentVariableA( LPCSTR lpName, LPCSTR lpGuid, PVOID pValue, DWORD nSize )
3621 {
3622     static FN_SetFirmwareEnvironmentVariableA *pfn = 0;
3623     if (!pfn)
3624         kPrf2WrapResolve((void **)&pfn, "SetFirmwareEnvironmentVariableA", &g_Kernel32);
3625     return pfn( lpName, lpGuid, pValue, nSize );
3626 }
3627
3628 typedef BOOL WINAPI FN_SetFirmwareEnvironmentVariableW( LPCWSTR lpName, LPCWSTR lpGuid, PVOID pValue, DWORD nSize );
3629 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetFirmwareEnvironmentVariableW( LPCWSTR lpName, LPCWSTR lpGuid, PVOID pValue, DWORD nSize )
3630 {
3631     static FN_SetFirmwareEnvironmentVariableW *pfn = 0;
3632     if (!pfn)
3633         kPrf2WrapResolve((void **)&pfn, "SetFirmwareEnvironmentVariableW", &g_Kernel32);
3634     return pfn( lpName, lpGuid, pValue, nSize );
3635 }
3636
3637 typedef VOID WINAPI FN_OutputDebugStringA( LPCSTR lpOutputString );
3638 __declspec(dllexport) VOID WINAPI kPrf2Wrap_OutputDebugStringA( LPCSTR lpOutputString )
3639 {
3640     static FN_OutputDebugStringA *pfn = 0;
3641     if (!pfn)
3642         kPrf2WrapResolve((void **)&pfn, "OutputDebugStringA", &g_Kernel32);
3643     pfn( lpOutputString );
3644 }
3645
3646 typedef VOID WINAPI FN_OutputDebugStringW( LPCWSTR lpOutputString );
3647 __declspec(dllexport) VOID WINAPI kPrf2Wrap_OutputDebugStringW( LPCWSTR lpOutputString )
3648 {
3649     static FN_OutputDebugStringW *pfn = 0;
3650     if (!pfn)
3651         kPrf2WrapResolve((void **)&pfn, "OutputDebugStringW", &g_Kernel32);
3652     pfn( lpOutputString );
3653 }
3654
3655 typedef HRSRC WINAPI FN_FindResourceA( HMODULE hModule, LPCSTR lpName, LPCSTR lpType );
3656 __declspec(dllexport) HRSRC WINAPI kPrf2Wrap_FindResourceA( HMODULE hModule, LPCSTR lpName, LPCSTR lpType )
3657 {
3658     static FN_FindResourceA *pfn = 0;
3659     if (!pfn)
3660         kPrf2WrapResolve((void **)&pfn, "FindResourceA", &g_Kernel32);
3661     return pfn( hModule, lpName, lpType );
3662 }
3663
3664 typedef HRSRC WINAPI FN_FindResourceW( HMODULE hModule, LPCWSTR lpName, LPCWSTR lpType );
3665 __declspec(dllexport) HRSRC WINAPI kPrf2Wrap_FindResourceW( HMODULE hModule, LPCWSTR lpName, LPCWSTR lpType )
3666 {
3667     static FN_FindResourceW *pfn = 0;
3668     if (!pfn)
3669         kPrf2WrapResolve((void **)&pfn, "FindResourceW", &g_Kernel32);
3670     return pfn( hModule, lpName, lpType );
3671 }
3672
3673 typedef HRSRC WINAPI FN_FindResourceExA( HMODULE hModule, LPCSTR lpType, LPCSTR lpName, WORD wLanguage );
3674 __declspec(dllexport) HRSRC WINAPI kPrf2Wrap_FindResourceExA( HMODULE hModule, LPCSTR lpType, LPCSTR lpName, WORD wLanguage )
3675 {
3676     static FN_FindResourceExA *pfn = 0;
3677     if (!pfn)
3678         kPrf2WrapResolve((void **)&pfn, "FindResourceExA", &g_Kernel32);
3679     return pfn( hModule, lpType, lpName, wLanguage );
3680 }
3681
3682 typedef HRSRC WINAPI FN_FindResourceExW( HMODULE hModule, LPCWSTR lpType, LPCWSTR lpName, WORD wLanguage );
3683 __declspec(dllexport) HRSRC WINAPI kPrf2Wrap_FindResourceExW( HMODULE hModule, LPCWSTR lpType, LPCWSTR lpName, WORD wLanguage )
3684 {
3685     static FN_FindResourceExW *pfn = 0;
3686     if (!pfn)
3687         kPrf2WrapResolve((void **)&pfn, "FindResourceExW", &g_Kernel32);
3688     return pfn( hModule, lpType, lpName, wLanguage );
3689 }
3690
3691 typedef BOOL WINAPI FN_EnumResourceTypesA( HMODULE hModule, ENUMRESTYPEPROCA lpEnumFunc, LONG_PTR lParam );
3692 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_EnumResourceTypesA( HMODULE hModule, ENUMRESTYPEPROCA lpEnumFunc, LONG_PTR lParam )
3693 {
3694     static FN_EnumResourceTypesA *pfn = 0;
3695     if (!pfn)
3696         kPrf2WrapResolve((void **)&pfn, "EnumResourceTypesA", &g_Kernel32);
3697     return pfn( hModule, lpEnumFunc, lParam );
3698 }
3699
3700 typedef BOOL WINAPI FN_EnumResourceTypesW( HMODULE hModule, ENUMRESTYPEPROCW lpEnumFunc, LONG_PTR lParam );
3701 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_EnumResourceTypesW( HMODULE hModule, ENUMRESTYPEPROCW lpEnumFunc, LONG_PTR lParam )
3702 {
3703     static FN_EnumResourceTypesW *pfn = 0;
3704     if (!pfn)
3705         kPrf2WrapResolve((void **)&pfn, "EnumResourceTypesW", &g_Kernel32);
3706     return pfn( hModule, lpEnumFunc, lParam );
3707 }
3708
3709 typedef BOOL WINAPI FN_EnumResourceNamesA( HMODULE hModule, LPCSTR lpType, ENUMRESNAMEPROCA lpEnumFunc, LONG_PTR lParam );
3710 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_EnumResourceNamesA( HMODULE hModule, LPCSTR lpType, ENUMRESNAMEPROCA lpEnumFunc, LONG_PTR lParam )
3711 {
3712     static FN_EnumResourceNamesA *pfn = 0;
3713     if (!pfn)
3714         kPrf2WrapResolve((void **)&pfn, "EnumResourceNamesA", &g_Kernel32);
3715     return pfn( hModule, lpType, lpEnumFunc, lParam );
3716 }
3717
3718 typedef BOOL WINAPI FN_EnumResourceNamesW( HMODULE hModule, LPCWSTR lpType, ENUMRESNAMEPROCW lpEnumFunc, LONG_PTR lParam );
3719 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_EnumResourceNamesW( HMODULE hModule, LPCWSTR lpType, ENUMRESNAMEPROCW lpEnumFunc, LONG_PTR lParam )
3720 {
3721     static FN_EnumResourceNamesW *pfn = 0;
3722     if (!pfn)
3723         kPrf2WrapResolve((void **)&pfn, "EnumResourceNamesW", &g_Kernel32);
3724     return pfn( hModule, lpType, lpEnumFunc, lParam );
3725 }
3726
3727 typedef BOOL WINAPI FN_EnumResourceLanguagesA( HMODULE hModule, LPCSTR lpType, LPCSTR lpName, ENUMRESLANGPROCA lpEnumFunc, LONG_PTR lParam );
3728 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_EnumResourceLanguagesA( HMODULE hModule, LPCSTR lpType, LPCSTR lpName, ENUMRESLANGPROCA lpEnumFunc, LONG_PTR lParam )
3729 {
3730     static FN_EnumResourceLanguagesA *pfn = 0;
3731     if (!pfn)
3732         kPrf2WrapResolve((void **)&pfn, "EnumResourceLanguagesA", &g_Kernel32);
3733     return pfn( hModule, lpType, lpName, lpEnumFunc, lParam );
3734 }
3735
3736 typedef BOOL WINAPI FN_EnumResourceLanguagesW( HMODULE hModule, LPCWSTR lpType, LPCWSTR lpName, ENUMRESLANGPROCW lpEnumFunc, LONG_PTR lParam );
3737 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_EnumResourceLanguagesW( HMODULE hModule, LPCWSTR lpType, LPCWSTR lpName, ENUMRESLANGPROCW lpEnumFunc, LONG_PTR lParam )
3738 {
3739     static FN_EnumResourceLanguagesW *pfn = 0;
3740     if (!pfn)
3741         kPrf2WrapResolve((void **)&pfn, "EnumResourceLanguagesW", &g_Kernel32);
3742     return pfn( hModule, lpType, lpName, lpEnumFunc, lParam );
3743 }
3744
3745 typedef HANDLE WINAPI FN_BeginUpdateResourceA( LPCSTR pFileName, BOOL bDeleteExistingResources );
3746 __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_BeginUpdateResourceA( LPCSTR pFileName, BOOL bDeleteExistingResources )
3747 {
3748     static FN_BeginUpdateResourceA *pfn = 0;
3749     if (!pfn)
3750         kPrf2WrapResolve((void **)&pfn, "BeginUpdateResourceA", &g_Kernel32);
3751     return pfn( pFileName, bDeleteExistingResources );
3752 }
3753
3754 typedef HANDLE WINAPI FN_BeginUpdateResourceW( LPCWSTR pFileName, BOOL bDeleteExistingResources );
3755 __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_BeginUpdateResourceW( LPCWSTR pFileName, BOOL bDeleteExistingResources )
3756 {
3757     static FN_BeginUpdateResourceW *pfn = 0;
3758     if (!pfn)
3759         kPrf2WrapResolve((void **)&pfn, "BeginUpdateResourceW", &g_Kernel32);
3760     return pfn( pFileName, bDeleteExistingResources );
3761 }
3762
3763 typedef BOOL WINAPI FN_UpdateResourceA( HANDLE hUpdate, LPCSTR lpType, LPCSTR lpName, WORD wLanguage, LPVOID lpData, DWORD cb );
3764 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_UpdateResourceA( HANDLE hUpdate, LPCSTR lpType, LPCSTR lpName, WORD wLanguage, LPVOID lpData, DWORD cb )
3765 {
3766     static FN_UpdateResourceA *pfn = 0;
3767     if (!pfn)
3768         kPrf2WrapResolve((void **)&pfn, "UpdateResourceA", &g_Kernel32);
3769     return pfn( hUpdate, lpType, lpName, wLanguage, lpData, cb );
3770 }
3771
3772 typedef BOOL WINAPI FN_UpdateResourceW( HANDLE hUpdate, LPCWSTR lpType, LPCWSTR lpName, WORD wLanguage, LPVOID lpData, DWORD cb );
3773 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_UpdateResourceW( HANDLE hUpdate, LPCWSTR lpType, LPCWSTR lpName, WORD wLanguage, LPVOID lpData, DWORD cb )
3774 {
3775     static FN_UpdateResourceW *pfn = 0;
3776     if (!pfn)
3777         kPrf2WrapResolve((void **)&pfn, "UpdateResourceW", &g_Kernel32);
3778     return pfn( hUpdate, lpType, lpName, wLanguage, lpData, cb );
3779 }
3780
3781 typedef BOOL WINAPI FN_EndUpdateResourceA( HANDLE hUpdate, BOOL fDiscard );
3782 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_EndUpdateResourceA( HANDLE hUpdate, BOOL fDiscard )
3783 {
3784     static FN_EndUpdateResourceA *pfn = 0;
3785     if (!pfn)
3786         kPrf2WrapResolve((void **)&pfn, "EndUpdateResourceA", &g_Kernel32);
3787     return pfn( hUpdate, fDiscard );
3788 }
3789
3790 typedef BOOL WINAPI FN_EndUpdateResourceW( HANDLE hUpdate, BOOL fDiscard );
3791 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_EndUpdateResourceW( HANDLE hUpdate, BOOL fDiscard )
3792 {
3793     static FN_EndUpdateResourceW *pfn = 0;
3794     if (!pfn)
3795         kPrf2WrapResolve((void **)&pfn, "EndUpdateResourceW", &g_Kernel32);
3796     return pfn( hUpdate, fDiscard );
3797 }
3798
3799 typedef ATOM WINAPI FN_GlobalAddAtomA( LPCSTR lpString );
3800 __declspec(dllexport) ATOM WINAPI kPrf2Wrap_GlobalAddAtomA( LPCSTR lpString )
3801 {
3802     static FN_GlobalAddAtomA *pfn = 0;
3803     if (!pfn)
3804         kPrf2WrapResolve((void **)&pfn, "GlobalAddAtomA", &g_Kernel32);
3805     return pfn( lpString );
3806 }
3807
3808 typedef ATOM WINAPI FN_GlobalAddAtomW( LPCWSTR lpString );
3809 __declspec(dllexport) ATOM WINAPI kPrf2Wrap_GlobalAddAtomW( LPCWSTR lpString )
3810 {
3811     static FN_GlobalAddAtomW *pfn = 0;
3812     if (!pfn)
3813         kPrf2WrapResolve((void **)&pfn, "GlobalAddAtomW", &g_Kernel32);
3814     return pfn( lpString );
3815 }
3816
3817 typedef ATOM WINAPI FN_GlobalFindAtomA( LPCSTR lpString );
3818 __declspec(dllexport) ATOM WINAPI kPrf2Wrap_GlobalFindAtomA( LPCSTR lpString )
3819 {
3820     static FN_GlobalFindAtomA *pfn = 0;
3821     if (!pfn)
3822         kPrf2WrapResolve((void **)&pfn, "GlobalFindAtomA", &g_Kernel32);
3823     return pfn( lpString );
3824 }
3825
3826 typedef ATOM WINAPI FN_GlobalFindAtomW( LPCWSTR lpString );
3827 __declspec(dllexport) ATOM WINAPI kPrf2Wrap_GlobalFindAtomW( LPCWSTR lpString )
3828 {
3829     static FN_GlobalFindAtomW *pfn = 0;
3830     if (!pfn)
3831         kPrf2WrapResolve((void **)&pfn, "GlobalFindAtomW", &g_Kernel32);
3832     return pfn( lpString );
3833 }
3834
3835 typedef UINT WINAPI FN_GlobalGetAtomNameA( ATOM nAtom, LPSTR lpBuffer, int nSize );
3836 __declspec(dllexport) UINT WINAPI kPrf2Wrap_GlobalGetAtomNameA( ATOM nAtom, LPSTR lpBuffer, int nSize )
3837 {
3838     static FN_GlobalGetAtomNameA *pfn = 0;
3839     if (!pfn)
3840         kPrf2WrapResolve((void **)&pfn, "GlobalGetAtomNameA", &g_Kernel32);
3841     return pfn( nAtom, lpBuffer, nSize );
3842 }
3843
3844 typedef UINT WINAPI FN_GlobalGetAtomNameW( ATOM nAtom, LPWSTR lpBuffer, int nSize );
3845 __declspec(dllexport) UINT WINAPI kPrf2Wrap_GlobalGetAtomNameW( ATOM nAtom, LPWSTR lpBuffer, int nSize )
3846 {
3847     static FN_GlobalGetAtomNameW *pfn = 0;
3848     if (!pfn)
3849         kPrf2WrapResolve((void **)&pfn, "GlobalGetAtomNameW", &g_Kernel32);
3850     return pfn( nAtom, lpBuffer, nSize );
3851 }
3852
3853 typedef ATOM WINAPI FN_AddAtomA( LPCSTR lpString );
3854 __declspec(dllexport) ATOM WINAPI kPrf2Wrap_AddAtomA( LPCSTR lpString )
3855 {
3856     static FN_AddAtomA *pfn = 0;
3857     if (!pfn)
3858         kPrf2WrapResolve((void **)&pfn, "AddAtomA", &g_Kernel32);
3859     return pfn( lpString );
3860 }
3861
3862 typedef ATOM WINAPI FN_AddAtomW( LPCWSTR lpString );
3863 __declspec(dllexport) ATOM WINAPI kPrf2Wrap_AddAtomW( LPCWSTR lpString )
3864 {
3865     static FN_AddAtomW *pfn = 0;
3866     if (!pfn)
3867         kPrf2WrapResolve((void **)&pfn, "AddAtomW", &g_Kernel32);
3868     return pfn( lpString );
3869 }
3870
3871 typedef ATOM WINAPI FN_FindAtomA( LPCSTR lpString );
3872 __declspec(dllexport) ATOM WINAPI kPrf2Wrap_FindAtomA( LPCSTR lpString )
3873 {
3874     static FN_FindAtomA *pfn = 0;
3875     if (!pfn)
3876         kPrf2WrapResolve((void **)&pfn, "FindAtomA", &g_Kernel32);
3877     return pfn( lpString );
3878 }
3879
3880 typedef ATOM WINAPI FN_FindAtomW( LPCWSTR lpString );
3881 __declspec(dllexport) ATOM WINAPI kPrf2Wrap_FindAtomW( LPCWSTR lpString )
3882 {
3883     static FN_FindAtomW *pfn = 0;
3884     if (!pfn)
3885         kPrf2WrapResolve((void **)&pfn, "FindAtomW", &g_Kernel32);
3886     return pfn( lpString );
3887 }
3888
3889 typedef UINT WINAPI FN_GetAtomNameA( ATOM nAtom, LPSTR lpBuffer, int nSize );
3890 __declspec(dllexport) UINT WINAPI kPrf2Wrap_GetAtomNameA( ATOM nAtom, LPSTR lpBuffer, int nSize )
3891 {
3892     static FN_GetAtomNameA *pfn = 0;
3893     if (!pfn)
3894         kPrf2WrapResolve((void **)&pfn, "GetAtomNameA", &g_Kernel32);
3895     return pfn( nAtom, lpBuffer, nSize );
3896 }
3897
3898 typedef UINT WINAPI FN_GetAtomNameW( ATOM nAtom, LPWSTR lpBuffer, int nSize );
3899 __declspec(dllexport) UINT WINAPI kPrf2Wrap_GetAtomNameW( ATOM nAtom, LPWSTR lpBuffer, int nSize )
3900 {
3901     static FN_GetAtomNameW *pfn = 0;
3902     if (!pfn)
3903         kPrf2WrapResolve((void **)&pfn, "GetAtomNameW", &g_Kernel32);
3904     return pfn( nAtom, lpBuffer, nSize );
3905 }
3906
3907 typedef UINT WINAPI FN_GetProfileIntA( LPCSTR lpAppName, LPCSTR lpKeyName, INT nDefault );
3908 __declspec(dllexport) UINT WINAPI kPrf2Wrap_GetProfileIntA( LPCSTR lpAppName, LPCSTR lpKeyName, INT nDefault )
3909 {
3910     static FN_GetProfileIntA *pfn = 0;
3911     if (!pfn)
3912         kPrf2WrapResolve((void **)&pfn, "GetProfileIntA", &g_Kernel32);
3913     return pfn( lpAppName, lpKeyName, nDefault );
3914 }
3915
3916 typedef UINT WINAPI FN_GetProfileIntW( LPCWSTR lpAppName, LPCWSTR lpKeyName, INT nDefault );
3917 __declspec(dllexport) UINT WINAPI kPrf2Wrap_GetProfileIntW( LPCWSTR lpAppName, LPCWSTR lpKeyName, INT nDefault )
3918 {
3919     static FN_GetProfileIntW *pfn = 0;
3920     if (!pfn)
3921         kPrf2WrapResolve((void **)&pfn, "GetProfileIntW", &g_Kernel32);
3922     return pfn( lpAppName, lpKeyName, nDefault );
3923 }
3924
3925 typedef DWORD WINAPI FN_GetProfileStringA( LPCSTR lpAppName, LPCSTR lpKeyName, LPCSTR lpDefault, LPSTR lpReturnedString, DWORD nSize );
3926 __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetProfileStringA( LPCSTR lpAppName, LPCSTR lpKeyName, LPCSTR lpDefault, LPSTR lpReturnedString, DWORD nSize )
3927 {
3928     static FN_GetProfileStringA *pfn = 0;
3929     if (!pfn)
3930         kPrf2WrapResolve((void **)&pfn, "GetProfileStringA", &g_Kernel32);
3931     return pfn( lpAppName, lpKeyName, lpDefault, lpReturnedString, nSize );
3932 }
3933
3934 typedef DWORD WINAPI FN_GetProfileStringW( LPCWSTR lpAppName, LPCWSTR lpKeyName, LPCWSTR lpDefault, LPWSTR lpReturnedString, DWORD nSize );
3935 __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetProfileStringW( LPCWSTR lpAppName, LPCWSTR lpKeyName, LPCWSTR lpDefault, LPWSTR lpReturnedString, DWORD nSize )
3936 {
3937     static FN_GetProfileStringW *pfn = 0;
3938     if (!pfn)
3939         kPrf2WrapResolve((void **)&pfn, "GetProfileStringW", &g_Kernel32);
3940     return pfn( lpAppName, lpKeyName, lpDefault, lpReturnedString, nSize );
3941 }
3942
3943 typedef BOOL WINAPI FN_WriteProfileStringA( LPCSTR lpAppName, LPCSTR lpKeyName, LPCSTR lpString );
3944 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_WriteProfileStringA( LPCSTR lpAppName, LPCSTR lpKeyName, LPCSTR lpString )
3945 {
3946     static FN_WriteProfileStringA *pfn = 0;
3947     if (!pfn)
3948         kPrf2WrapResolve((void **)&pfn, "WriteProfileStringA", &g_Kernel32);
3949     return pfn( lpAppName, lpKeyName, lpString );
3950 }
3951
3952 typedef BOOL WINAPI FN_WriteProfileStringW( LPCWSTR lpAppName, LPCWSTR lpKeyName, LPCWSTR lpString );
3953 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_WriteProfileStringW( LPCWSTR lpAppName, LPCWSTR lpKeyName, LPCWSTR lpString )
3954 {
3955     static FN_WriteProfileStringW *pfn = 0;
3956     if (!pfn)
3957         kPrf2WrapResolve((void **)&pfn, "WriteProfileStringW", &g_Kernel32);
3958     return pfn( lpAppName, lpKeyName, lpString );
3959 }
3960
3961 typedef DWORD WINAPI FN_GetProfileSectionA( LPCSTR lpAppName, LPSTR lpReturnedString, DWORD nSize );
3962 __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetProfileSectionA( LPCSTR lpAppName, LPSTR lpReturnedString, DWORD nSize )
3963 {
3964     static FN_GetProfileSectionA *pfn = 0;
3965     if (!pfn)
3966         kPrf2WrapResolve((void **)&pfn, "GetProfileSectionA", &g_Kernel32);
3967     return pfn( lpAppName, lpReturnedString, nSize );
3968 }
3969
3970 typedef DWORD WINAPI FN_GetProfileSectionW( LPCWSTR lpAppName, LPWSTR lpReturnedString, DWORD nSize );
3971 __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetProfileSectionW( LPCWSTR lpAppName, LPWSTR lpReturnedString, DWORD nSize )
3972 {
3973     static FN_GetProfileSectionW *pfn = 0;
3974     if (!pfn)
3975         kPrf2WrapResolve((void **)&pfn, "GetProfileSectionW", &g_Kernel32);
3976     return pfn( lpAppName, lpReturnedString, nSize );
3977 }
3978
3979 typedef BOOL WINAPI FN_WriteProfileSectionA( LPCSTR lpAppName, LPCSTR lpString );
3980 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_WriteProfileSectionA( LPCSTR lpAppName, LPCSTR lpString )
3981 {
3982     static FN_WriteProfileSectionA *pfn = 0;
3983     if (!pfn)
3984         kPrf2WrapResolve((void **)&pfn, "WriteProfileSectionA", &g_Kernel32);
3985     return pfn( lpAppName, lpString );
3986 }
3987
3988 typedef BOOL WINAPI FN_WriteProfileSectionW( LPCWSTR lpAppName, LPCWSTR lpString );
3989 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_WriteProfileSectionW( LPCWSTR lpAppName, LPCWSTR lpString )
3990 {
3991     static FN_WriteProfileSectionW *pfn = 0;
3992     if (!pfn)
3993         kPrf2WrapResolve((void **)&pfn, "WriteProfileSectionW", &g_Kernel32);
3994     return pfn( lpAppName, lpString );
3995 }
3996
3997 typedef UINT WINAPI FN_GetPrivateProfileIntA( LPCSTR lpAppName, LPCSTR lpKeyName, INT nDefault, LPCSTR lpFileName );
3998 __declspec(dllexport) UINT WINAPI kPrf2Wrap_GetPrivateProfileIntA( LPCSTR lpAppName, LPCSTR lpKeyName, INT nDefault, LPCSTR lpFileName )
3999 {
4000     static FN_GetPrivateProfileIntA *pfn = 0;
4001     if (!pfn)
4002         kPrf2WrapResolve((void **)&pfn, "GetPrivateProfileIntA", &g_Kernel32);
4003     return pfn( lpAppName, lpKeyName, nDefault, lpFileName );
4004 }
4005
4006 typedef UINT WINAPI FN_GetPrivateProfileIntW( LPCWSTR lpAppName, LPCWSTR lpKeyName, INT nDefault, LPCWSTR lpFileName );
4007 __declspec(dllexport) UINT WINAPI kPrf2Wrap_GetPrivateProfileIntW( LPCWSTR lpAppName, LPCWSTR lpKeyName, INT nDefault, LPCWSTR lpFileName )
4008 {
4009     static FN_GetPrivateProfileIntW *pfn = 0;
4010     if (!pfn)
4011         kPrf2WrapResolve((void **)&pfn, "GetPrivateProfileIntW", &g_Kernel32);
4012     return pfn( lpAppName, lpKeyName, nDefault, lpFileName );
4013 }
4014
4015 typedef DWORD WINAPI FN_GetPrivateProfileStringA( LPCSTR lpAppName, LPCSTR lpKeyName, LPCSTR lpDefault, LPSTR lpReturnedString, DWORD nSize, LPCSTR lpFileName );
4016 __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetPrivateProfileStringA( LPCSTR lpAppName, LPCSTR lpKeyName, LPCSTR lpDefault, LPSTR lpReturnedString, DWORD nSize, LPCSTR lpFileName )
4017 {
4018     static FN_GetPrivateProfileStringA *pfn = 0;
4019     if (!pfn)
4020         kPrf2WrapResolve((void **)&pfn, "GetPrivateProfileStringA", &g_Kernel32);
4021     return pfn( lpAppName, lpKeyName, lpDefault, lpReturnedString, nSize, lpFileName );
4022 }
4023
4024 typedef DWORD WINAPI FN_GetPrivateProfileStringW( LPCWSTR lpAppName, LPCWSTR lpKeyName, LPCWSTR lpDefault, LPWSTR lpReturnedString, DWORD nSize, LPCWSTR lpFileName );
4025 __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetPrivateProfileStringW( LPCWSTR lpAppName, LPCWSTR lpKeyName, LPCWSTR lpDefault, LPWSTR lpReturnedString, DWORD nSize, LPCWSTR lpFileName )
4026 {
4027     static FN_GetPrivateProfileStringW *pfn = 0;
4028     if (!pfn)
4029         kPrf2WrapResolve((void **)&pfn, "GetPrivateProfileStringW", &g_Kernel32);
4030     return pfn( lpAppName, lpKeyName, lpDefault, lpReturnedString, nSize, lpFileName );
4031 }
4032
4033 typedef BOOL WINAPI FN_WritePrivateProfileStringA( LPCSTR lpAppName, LPCSTR lpKeyName, LPCSTR lpString, LPCSTR lpFileName );
4034 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_WritePrivateProfileStringA( LPCSTR lpAppName, LPCSTR lpKeyName, LPCSTR lpString, LPCSTR lpFileName )
4035 {
4036     static FN_WritePrivateProfileStringA *pfn = 0;
4037     if (!pfn)
4038         kPrf2WrapResolve((void **)&pfn, "WritePrivateProfileStringA", &g_Kernel32);
4039     return pfn( lpAppName, lpKeyName, lpString, lpFileName );
4040 }
4041
4042 typedef BOOL WINAPI FN_WritePrivateProfileStringW( LPCWSTR lpAppName, LPCWSTR lpKeyName, LPCWSTR lpString, LPCWSTR lpFileName );
4043 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_WritePrivateProfileStringW( LPCWSTR lpAppName, LPCWSTR lpKeyName, LPCWSTR lpString, LPCWSTR lpFileName )
4044 {
4045     static FN_WritePrivateProfileStringW *pfn = 0;
4046     if (!pfn)
4047         kPrf2WrapResolve((void **)&pfn, "WritePrivateProfileStringW", &g_Kernel32);
4048     return pfn( lpAppName, lpKeyName, lpString, lpFileName );
4049 }
4050
4051 typedef DWORD WINAPI FN_GetPrivateProfileSectionA( LPCSTR lpAppName, LPSTR lpReturnedString, DWORD nSize, LPCSTR lpFileName );
4052 __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetPrivateProfileSectionA( LPCSTR lpAppName, LPSTR lpReturnedString, DWORD nSize, LPCSTR lpFileName )
4053 {
4054     static FN_GetPrivateProfileSectionA *pfn = 0;
4055     if (!pfn)
4056         kPrf2WrapResolve((void **)&pfn, "GetPrivateProfileSectionA", &g_Kernel32);
4057     return pfn( lpAppName, lpReturnedString, nSize, lpFileName );
4058 }
4059
4060 typedef DWORD WINAPI FN_GetPrivateProfileSectionW( LPCWSTR lpAppName, LPWSTR lpReturnedString, DWORD nSize, LPCWSTR lpFileName );
4061 __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetPrivateProfileSectionW( LPCWSTR lpAppName, LPWSTR lpReturnedString, DWORD nSize, LPCWSTR lpFileName )
4062 {
4063     static FN_GetPrivateProfileSectionW *pfn = 0;
4064     if (!pfn)
4065         kPrf2WrapResolve((void **)&pfn, "GetPrivateProfileSectionW", &g_Kernel32);
4066     return pfn( lpAppName, lpReturnedString, nSize, lpFileName );
4067 }
4068
4069 typedef BOOL WINAPI FN_WritePrivateProfileSectionA( LPCSTR lpAppName, LPCSTR lpString, LPCSTR lpFileName );
4070 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_WritePrivateProfileSectionA( LPCSTR lpAppName, LPCSTR lpString, LPCSTR lpFileName )
4071 {
4072     static FN_WritePrivateProfileSectionA *pfn = 0;
4073     if (!pfn)
4074         kPrf2WrapResolve((void **)&pfn, "WritePrivateProfileSectionA", &g_Kernel32);
4075     return pfn( lpAppName, lpString, lpFileName );
4076 }
4077
4078 typedef BOOL WINAPI FN_WritePrivateProfileSectionW( LPCWSTR lpAppName, LPCWSTR lpString, LPCWSTR lpFileName );
4079 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_WritePrivateProfileSectionW( LPCWSTR lpAppName, LPCWSTR lpString, LPCWSTR lpFileName )
4080 {
4081     static FN_WritePrivateProfileSectionW *pfn = 0;
4082     if (!pfn)
4083         kPrf2WrapResolve((void **)&pfn, "WritePrivateProfileSectionW", &g_Kernel32);
4084     return pfn( lpAppName, lpString, lpFileName );
4085 }
4086
4087 typedef DWORD WINAPI FN_GetPrivateProfileSectionNamesA( LPSTR lpszReturnBuffer, DWORD nSize, LPCSTR lpFileName );
4088 __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetPrivateProfileSectionNamesA( LPSTR lpszReturnBuffer, DWORD nSize, LPCSTR lpFileName )
4089 {
4090     static FN_GetPrivateProfileSectionNamesA *pfn = 0;
4091     if (!pfn)
4092         kPrf2WrapResolve((void **)&pfn, "GetPrivateProfileSectionNamesA", &g_Kernel32);
4093     return pfn( lpszReturnBuffer, nSize, lpFileName );
4094 }
4095
4096 typedef DWORD WINAPI FN_GetPrivateProfileSectionNamesW( LPWSTR lpszReturnBuffer, DWORD nSize, LPCWSTR lpFileName );
4097 __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetPrivateProfileSectionNamesW( LPWSTR lpszReturnBuffer, DWORD nSize, LPCWSTR lpFileName )
4098 {
4099     static FN_GetPrivateProfileSectionNamesW *pfn = 0;
4100     if (!pfn)
4101         kPrf2WrapResolve((void **)&pfn, "GetPrivateProfileSectionNamesW", &g_Kernel32);
4102     return pfn( lpszReturnBuffer, nSize, lpFileName );
4103 }
4104
4105 typedef BOOL WINAPI FN_GetPrivateProfileStructA( LPCSTR lpszSection, LPCSTR lpszKey, LPVOID lpStruct, UINT uSizeStruct, LPCSTR szFile );
4106 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetPrivateProfileStructA( LPCSTR lpszSection, LPCSTR lpszKey, LPVOID lpStruct, UINT uSizeStruct, LPCSTR szFile )
4107 {
4108     static FN_GetPrivateProfileStructA *pfn = 0;
4109     if (!pfn)
4110         kPrf2WrapResolve((void **)&pfn, "GetPrivateProfileStructA", &g_Kernel32);
4111     return pfn( lpszSection, lpszKey, lpStruct, uSizeStruct, szFile );
4112 }
4113
4114 typedef BOOL WINAPI FN_GetPrivateProfileStructW( LPCWSTR lpszSection, LPCWSTR lpszKey, LPVOID lpStruct, UINT uSizeStruct, LPCWSTR szFile );
4115 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetPrivateProfileStructW( LPCWSTR lpszSection, LPCWSTR lpszKey, LPVOID lpStruct, UINT uSizeStruct, LPCWSTR szFile )
4116 {
4117     static FN_GetPrivateProfileStructW *pfn = 0;
4118     if (!pfn)
4119         kPrf2WrapResolve((void **)&pfn, "GetPrivateProfileStructW", &g_Kernel32);
4120     return pfn( lpszSection, lpszKey, lpStruct, uSizeStruct, szFile );
4121 }
4122
4123 typedef BOOL WINAPI FN_WritePrivateProfileStructA( LPCSTR lpszSection, LPCSTR lpszKey, LPVOID lpStruct, UINT uSizeStruct, LPCSTR szFile );
4124 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_WritePrivateProfileStructA( LPCSTR lpszSection, LPCSTR lpszKey, LPVOID lpStruct, UINT uSizeStruct, LPCSTR szFile )
4125 {
4126     static FN_WritePrivateProfileStructA *pfn = 0;
4127     if (!pfn)
4128         kPrf2WrapResolve((void **)&pfn, "WritePrivateProfileStructA", &g_Kernel32);
4129     return pfn( lpszSection, lpszKey, lpStruct, uSizeStruct, szFile );
4130 }
4131
4132 typedef BOOL WINAPI FN_WritePrivateProfileStructW( LPCWSTR lpszSection, LPCWSTR lpszKey, LPVOID lpStruct, UINT uSizeStruct, LPCWSTR szFile );
4133 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_WritePrivateProfileStructW( LPCWSTR lpszSection, LPCWSTR lpszKey, LPVOID lpStruct, UINT uSizeStruct, LPCWSTR szFile )
4134 {
4135     static FN_WritePrivateProfileStructW *pfn = 0;
4136     if (!pfn)
4137         kPrf2WrapResolve((void **)&pfn, "WritePrivateProfileStructW", &g_Kernel32);
4138     return pfn( lpszSection, lpszKey, lpStruct, uSizeStruct, szFile );
4139 }
4140
4141 typedef UINT WINAPI FN_GetDriveTypeA( LPCSTR lpRootPathName );
4142 __declspec(dllexport) UINT WINAPI kPrf2Wrap_GetDriveTypeA( LPCSTR lpRootPathName )
4143 {
4144     static FN_GetDriveTypeA *pfn = 0;
4145     if (!pfn)
4146         kPrf2WrapResolve((void **)&pfn, "GetDriveTypeA", &g_Kernel32);
4147     return pfn( lpRootPathName );
4148 }
4149
4150 typedef UINT WINAPI FN_GetDriveTypeW( LPCWSTR lpRootPathName );
4151 __declspec(dllexport) UINT WINAPI kPrf2Wrap_GetDriveTypeW( LPCWSTR lpRootPathName )
4152 {
4153     static FN_GetDriveTypeW *pfn = 0;
4154     if (!pfn)
4155         kPrf2WrapResolve((void **)&pfn, "GetDriveTypeW", &g_Kernel32);
4156     return pfn( lpRootPathName );
4157 }
4158
4159 typedef UINT WINAPI FN_GetSystemDirectoryA( LPSTR lpBuffer, UINT uSize );
4160 __declspec(dllexport) UINT WINAPI kPrf2Wrap_GetSystemDirectoryA( LPSTR lpBuffer, UINT uSize )
4161 {
4162     static FN_GetSystemDirectoryA *pfn = 0;
4163     if (!pfn)
4164         kPrf2WrapResolve((void **)&pfn, "GetSystemDirectoryA", &g_Kernel32);
4165     return pfn( lpBuffer, uSize );
4166 }
4167
4168 typedef UINT WINAPI FN_GetSystemDirectoryW( LPWSTR lpBuffer, UINT uSize );
4169 __declspec(dllexport) UINT WINAPI kPrf2Wrap_GetSystemDirectoryW( LPWSTR lpBuffer, UINT uSize )
4170 {
4171     static FN_GetSystemDirectoryW *pfn = 0;
4172     if (!pfn)
4173         kPrf2WrapResolve((void **)&pfn, "GetSystemDirectoryW", &g_Kernel32);
4174     return pfn( lpBuffer, uSize );
4175 }
4176
4177 typedef DWORD WINAPI FN_GetTempPathA( DWORD nBufferLength, LPSTR lpBuffer );
4178 __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetTempPathA( DWORD nBufferLength, LPSTR lpBuffer )
4179 {
4180     static FN_GetTempPathA *pfn = 0;
4181     if (!pfn)
4182         kPrf2WrapResolve((void **)&pfn, "GetTempPathA", &g_Kernel32);
4183     return pfn( nBufferLength, lpBuffer );
4184 }
4185
4186 typedef DWORD WINAPI FN_GetTempPathW( DWORD nBufferLength, LPWSTR lpBuffer );
4187 __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetTempPathW( DWORD nBufferLength, LPWSTR lpBuffer )
4188 {
4189     static FN_GetTempPathW *pfn = 0;
4190     if (!pfn)
4191         kPrf2WrapResolve((void **)&pfn, "GetTempPathW", &g_Kernel32);
4192     return pfn( nBufferLength, lpBuffer );
4193 }
4194
4195 typedef UINT WINAPI FN_GetTempFileNameA( LPCSTR lpPathName, LPCSTR lpPrefixString, UINT uUnique, LPSTR lpTempFileName );
4196 __declspec(dllexport) UINT WINAPI kPrf2Wrap_GetTempFileNameA( LPCSTR lpPathName, LPCSTR lpPrefixString, UINT uUnique, LPSTR lpTempFileName )
4197 {
4198     static FN_GetTempFileNameA *pfn = 0;
4199     if (!pfn)
4200         kPrf2WrapResolve((void **)&pfn, "GetTempFileNameA", &g_Kernel32);
4201     return pfn( lpPathName, lpPrefixString, uUnique, lpTempFileName );
4202 }
4203
4204 typedef UINT WINAPI FN_GetTempFileNameW( LPCWSTR lpPathName, LPCWSTR lpPrefixString, UINT uUnique, LPWSTR lpTempFileName );
4205 __declspec(dllexport) UINT WINAPI kPrf2Wrap_GetTempFileNameW( LPCWSTR lpPathName, LPCWSTR lpPrefixString, UINT uUnique, LPWSTR lpTempFileName )
4206 {
4207     static FN_GetTempFileNameW *pfn = 0;
4208     if (!pfn)
4209         kPrf2WrapResolve((void **)&pfn, "GetTempFileNameW", &g_Kernel32);
4210     return pfn( lpPathName, lpPrefixString, uUnique, lpTempFileName );
4211 }
4212
4213 typedef UINT WINAPI FN_GetWindowsDirectoryA( LPSTR lpBuffer, UINT uSize );
4214 __declspec(dllexport) UINT WINAPI kPrf2Wrap_GetWindowsDirectoryA( LPSTR lpBuffer, UINT uSize )
4215 {
4216     static FN_GetWindowsDirectoryA *pfn = 0;
4217     if (!pfn)
4218         kPrf2WrapResolve((void **)&pfn, "GetWindowsDirectoryA", &g_Kernel32);
4219     return pfn( lpBuffer, uSize );
4220 }
4221
4222 typedef UINT WINAPI FN_GetWindowsDirectoryW( LPWSTR lpBuffer, UINT uSize );
4223 __declspec(dllexport) UINT WINAPI kPrf2Wrap_GetWindowsDirectoryW( LPWSTR lpBuffer, UINT uSize )
4224 {
4225     static FN_GetWindowsDirectoryW *pfn = 0;
4226     if (!pfn)
4227         kPrf2WrapResolve((void **)&pfn, "GetWindowsDirectoryW", &g_Kernel32);
4228     return pfn( lpBuffer, uSize );
4229 }
4230
4231 typedef UINT WINAPI FN_GetSystemWindowsDirectoryA( LPSTR lpBuffer, UINT uSize );
4232 __declspec(dllexport) UINT WINAPI kPrf2Wrap_GetSystemWindowsDirectoryA( LPSTR lpBuffer, UINT uSize )
4233 {
4234     static FN_GetSystemWindowsDirectoryA *pfn = 0;
4235     if (!pfn)
4236         kPrf2WrapResolve((void **)&pfn, "GetSystemWindowsDirectoryA", &g_Kernel32);
4237     return pfn( lpBuffer, uSize );
4238 }
4239
4240 typedef UINT WINAPI FN_GetSystemWindowsDirectoryW( LPWSTR lpBuffer, UINT uSize );
4241 __declspec(dllexport) UINT WINAPI kPrf2Wrap_GetSystemWindowsDirectoryW( LPWSTR lpBuffer, UINT uSize )
4242 {
4243     static FN_GetSystemWindowsDirectoryW *pfn = 0;
4244     if (!pfn)
4245         kPrf2WrapResolve((void **)&pfn, "GetSystemWindowsDirectoryW", &g_Kernel32);
4246     return pfn( lpBuffer, uSize );
4247 }
4248
4249 typedef UINT WINAPI FN_GetSystemWow64DirectoryA( LPSTR lpBuffer, UINT uSize );
4250 __declspec(dllexport) UINT WINAPI kPrf2Wrap_GetSystemWow64DirectoryA( LPSTR lpBuffer, UINT uSize )
4251 {
4252     static FN_GetSystemWow64DirectoryA *pfn = 0;
4253     if (!pfn)
4254         kPrf2WrapResolve((void **)&pfn, "GetSystemWow64DirectoryA", &g_Kernel32);
4255     return pfn( lpBuffer, uSize );
4256 }
4257
4258 typedef UINT WINAPI FN_GetSystemWow64DirectoryW( LPWSTR lpBuffer, UINT uSize );
4259 __declspec(dllexport) UINT WINAPI kPrf2Wrap_GetSystemWow64DirectoryW( LPWSTR lpBuffer, UINT uSize )
4260 {
4261     static FN_GetSystemWow64DirectoryW *pfn = 0;
4262     if (!pfn)
4263         kPrf2WrapResolve((void **)&pfn, "GetSystemWow64DirectoryW", &g_Kernel32);
4264     return pfn( lpBuffer, uSize );
4265 }
4266
4267 typedef BOOLEAN WINAPI FN_Wow64EnableWow64FsRedirection( BOOLEAN Wow64FsEnableRedirection );
4268 __declspec(dllexport) BOOLEAN WINAPI kPrf2Wrap_Wow64EnableWow64FsRedirection( BOOLEAN Wow64FsEnableRedirection )
4269 {
4270     static FN_Wow64EnableWow64FsRedirection *pfn = 0;
4271     if (!pfn)
4272         kPrf2WrapResolve((void **)&pfn, "Wow64EnableWow64FsRedirection", &g_Kernel32);
4273     return pfn( Wow64FsEnableRedirection );
4274 }
4275
4276 typedef BOOL WINAPI FN_Wow64DisableWow64FsRedirection( PVOID * OldValue );
4277 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_Wow64DisableWow64FsRedirection( PVOID * OldValue )
4278 {
4279     static FN_Wow64DisableWow64FsRedirection *pfn = 0;
4280     if (!pfn)
4281         kPrf2WrapResolve((void **)&pfn, "Wow64DisableWow64FsRedirection", &g_Kernel32);
4282     return pfn( OldValue );
4283 }
4284
4285 typedef BOOL WINAPI FN_Wow64RevertWow64FsRedirection( PVOID OlValue );
4286 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_Wow64RevertWow64FsRedirection( PVOID OlValue )
4287 {
4288     static FN_Wow64RevertWow64FsRedirection *pfn = 0;
4289     if (!pfn)
4290         kPrf2WrapResolve((void **)&pfn, "Wow64RevertWow64FsRedirection", &g_Kernel32);
4291     return pfn( OlValue );
4292 }
4293
4294 typedef BOOL WINAPI FN_SetCurrentDirectoryA( LPCSTR lpPathName );
4295 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetCurrentDirectoryA( LPCSTR lpPathName )
4296 {
4297     static FN_SetCurrentDirectoryA *pfn = 0;
4298     if (!pfn)
4299         kPrf2WrapResolve((void **)&pfn, "SetCurrentDirectoryA", &g_Kernel32);
4300     return pfn( lpPathName );
4301 }
4302
4303 typedef BOOL WINAPI FN_SetCurrentDirectoryW( LPCWSTR lpPathName );
4304 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetCurrentDirectoryW( LPCWSTR lpPathName )
4305 {
4306     static FN_SetCurrentDirectoryW *pfn = 0;
4307     if (!pfn)
4308         kPrf2WrapResolve((void **)&pfn, "SetCurrentDirectoryW", &g_Kernel32);
4309     return pfn( lpPathName );
4310 }
4311
4312 typedef DWORD WINAPI FN_GetCurrentDirectoryA( DWORD nBufferLength, LPSTR lpBuffer );
4313 __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetCurrentDirectoryA( DWORD nBufferLength, LPSTR lpBuffer )
4314 {
4315     static FN_GetCurrentDirectoryA *pfn = 0;
4316     if (!pfn)
4317         kPrf2WrapResolve((void **)&pfn, "GetCurrentDirectoryA", &g_Kernel32);
4318     return pfn( nBufferLength, lpBuffer );
4319 }
4320
4321 typedef DWORD WINAPI FN_GetCurrentDirectoryW( DWORD nBufferLength, LPWSTR lpBuffer );
4322 __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetCurrentDirectoryW( DWORD nBufferLength, LPWSTR lpBuffer )
4323 {
4324     static FN_GetCurrentDirectoryW *pfn = 0;
4325     if (!pfn)
4326         kPrf2WrapResolve((void **)&pfn, "GetCurrentDirectoryW", &g_Kernel32);
4327     return pfn( nBufferLength, lpBuffer );
4328 }
4329
4330 typedef BOOL WINAPI FN_SetDllDirectoryA( LPCSTR lpPathName );
4331 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetDllDirectoryA( LPCSTR lpPathName )
4332 {
4333     static FN_SetDllDirectoryA *pfn = 0;
4334     if (!pfn)
4335         kPrf2WrapResolve((void **)&pfn, "SetDllDirectoryA", &g_Kernel32);
4336     return pfn( lpPathName );
4337 }
4338
4339 typedef BOOL WINAPI FN_SetDllDirectoryW( LPCWSTR lpPathName );
4340 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetDllDirectoryW( LPCWSTR lpPathName )
4341 {
4342     static FN_SetDllDirectoryW *pfn = 0;
4343     if (!pfn)
4344         kPrf2WrapResolve((void **)&pfn, "SetDllDirectoryW", &g_Kernel32);
4345     return pfn( lpPathName );
4346 }
4347
4348 typedef DWORD WINAPI FN_GetDllDirectoryA( DWORD nBufferLength, LPSTR lpBuffer );
4349 __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetDllDirectoryA( DWORD nBufferLength, LPSTR lpBuffer )
4350 {
4351     static FN_GetDllDirectoryA *pfn = 0;
4352     if (!pfn)
4353         kPrf2WrapResolve((void **)&pfn, "GetDllDirectoryA", &g_Kernel32);
4354     return pfn( nBufferLength, lpBuffer );
4355 }
4356
4357 typedef DWORD WINAPI FN_GetDllDirectoryW( DWORD nBufferLength, LPWSTR lpBuffer );
4358 __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetDllDirectoryW( DWORD nBufferLength, LPWSTR lpBuffer )
4359 {
4360     static FN_GetDllDirectoryW *pfn = 0;
4361     if (!pfn)
4362         kPrf2WrapResolve((void **)&pfn, "GetDllDirectoryW", &g_Kernel32);
4363     return pfn( nBufferLength, lpBuffer );
4364 }
4365
4366 typedef BOOL WINAPI FN_GetDiskFreeSpaceA( LPCSTR lpRootPathName, LPDWORD lpSectorsPerCluster, LPDWORD lpBytesPerSector, LPDWORD lpNumberOfFreeClusters, LPDWORD lpTotalNumberOfClusters );
4367 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetDiskFreeSpaceA( LPCSTR lpRootPathName, LPDWORD lpSectorsPerCluster, LPDWORD lpBytesPerSector, LPDWORD lpNumberOfFreeClusters, LPDWORD lpTotalNumberOfClusters )
4368 {
4369     static FN_GetDiskFreeSpaceA *pfn = 0;
4370     if (!pfn)
4371         kPrf2WrapResolve((void **)&pfn, "GetDiskFreeSpaceA", &g_Kernel32);
4372     return pfn( lpRootPathName, lpSectorsPerCluster, lpBytesPerSector, lpNumberOfFreeClusters, lpTotalNumberOfClusters );
4373 }
4374
4375 typedef BOOL WINAPI FN_GetDiskFreeSpaceW( LPCWSTR lpRootPathName, LPDWORD lpSectorsPerCluster, LPDWORD lpBytesPerSector, LPDWORD lpNumberOfFreeClusters, LPDWORD lpTotalNumberOfClusters );
4376 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetDiskFreeSpaceW( LPCWSTR lpRootPathName, LPDWORD lpSectorsPerCluster, LPDWORD lpBytesPerSector, LPDWORD lpNumberOfFreeClusters, LPDWORD lpTotalNumberOfClusters )
4377 {
4378     static FN_GetDiskFreeSpaceW *pfn = 0;
4379     if (!pfn)
4380         kPrf2WrapResolve((void **)&pfn, "GetDiskFreeSpaceW", &g_Kernel32);
4381     return pfn( lpRootPathName, lpSectorsPerCluster, lpBytesPerSector, lpNumberOfFreeClusters, lpTotalNumberOfClusters );
4382 }
4383
4384 typedef BOOL WINAPI FN_GetDiskFreeSpaceExA( LPCSTR lpDirectoryName, PULARGE_INTEGER lpFreeBytesAvailableToCaller, PULARGE_INTEGER lpTotalNumberOfBytes, PULARGE_INTEGER lpTotalNumberOfFreeBytes );
4385 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetDiskFreeSpaceExA( LPCSTR lpDirectoryName, PULARGE_INTEGER lpFreeBytesAvailableToCaller, PULARGE_INTEGER lpTotalNumberOfBytes, PULARGE_INTEGER lpTotalNumberOfFreeBytes )
4386 {
4387     static FN_GetDiskFreeSpaceExA *pfn = 0;
4388     if (!pfn)
4389         kPrf2WrapResolve((void **)&pfn, "GetDiskFreeSpaceExA", &g_Kernel32);
4390     return pfn( lpDirectoryName, lpFreeBytesAvailableToCaller, lpTotalNumberOfBytes, lpTotalNumberOfFreeBytes );
4391 }
4392
4393 typedef BOOL WINAPI FN_GetDiskFreeSpaceExW( LPCWSTR lpDirectoryName, PULARGE_INTEGER lpFreeBytesAvailableToCaller, PULARGE_INTEGER lpTotalNumberOfBytes, PULARGE_INTEGER lpTotalNumberOfFreeBytes );
4394 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetDiskFreeSpaceExW( LPCWSTR lpDirectoryName, PULARGE_INTEGER lpFreeBytesAvailableToCaller, PULARGE_INTEGER lpTotalNumberOfBytes, PULARGE_INTEGER lpTotalNumberOfFreeBytes )
4395 {
4396     static FN_GetDiskFreeSpaceExW *pfn = 0;
4397     if (!pfn)
4398         kPrf2WrapResolve((void **)&pfn, "GetDiskFreeSpaceExW", &g_Kernel32);
4399     return pfn( lpDirectoryName, lpFreeBytesAvailableToCaller, lpTotalNumberOfBytes, lpTotalNumberOfFreeBytes );
4400 }
4401
4402 typedef BOOL WINAPI FN_CreateDirectoryA( LPCSTR lpPathName, LPSECURITY_ATTRIBUTES lpSecurityAttributes );
4403 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_CreateDirectoryA( LPCSTR lpPathName, LPSECURITY_ATTRIBUTES lpSecurityAttributes )
4404 {
4405     static FN_CreateDirectoryA *pfn = 0;
4406     if (!pfn)
4407         kPrf2WrapResolve((void **)&pfn, "CreateDirectoryA", &g_Kernel32);
4408     return pfn( lpPathName, lpSecurityAttributes );
4409 }
4410
4411 typedef BOOL WINAPI FN_CreateDirectoryW( LPCWSTR lpPathName, LPSECURITY_ATTRIBUTES lpSecurityAttributes );
4412 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_CreateDirectoryW( LPCWSTR lpPathName, LPSECURITY_ATTRIBUTES lpSecurityAttributes )
4413 {
4414     static FN_CreateDirectoryW *pfn = 0;
4415     if (!pfn)
4416         kPrf2WrapResolve((void **)&pfn, "CreateDirectoryW", &g_Kernel32);
4417     return pfn( lpPathName, lpSecurityAttributes );
4418 }
4419
4420 typedef BOOL WINAPI FN_CreateDirectoryExA( LPCSTR lpTemplateDirectory, LPCSTR lpNewDirectory, LPSECURITY_ATTRIBUTES lpSecurityAttributes );
4421 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_CreateDirectoryExA( LPCSTR lpTemplateDirectory, LPCSTR lpNewDirectory, LPSECURITY_ATTRIBUTES lpSecurityAttributes )
4422 {
4423     static FN_CreateDirectoryExA *pfn = 0;
4424     if (!pfn)
4425         kPrf2WrapResolve((void **)&pfn, "CreateDirectoryExA", &g_Kernel32);
4426     return pfn( lpTemplateDirectory, lpNewDirectory, lpSecurityAttributes );
4427 }
4428
4429 typedef BOOL WINAPI FN_CreateDirectoryExW( LPCWSTR lpTemplateDirectory, LPCWSTR lpNewDirectory, LPSECURITY_ATTRIBUTES lpSecurityAttributes );
4430 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_CreateDirectoryExW( LPCWSTR lpTemplateDirectory, LPCWSTR lpNewDirectory, LPSECURITY_ATTRIBUTES lpSecurityAttributes )
4431 {
4432     static FN_CreateDirectoryExW *pfn = 0;
4433     if (!pfn)
4434         kPrf2WrapResolve((void **)&pfn, "CreateDirectoryExW", &g_Kernel32);
4435     return pfn( lpTemplateDirectory, lpNewDirectory, lpSecurityAttributes );
4436 }
4437
4438 typedef BOOL WINAPI FN_RemoveDirectoryA( LPCSTR lpPathName );
4439 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_RemoveDirectoryA( LPCSTR lpPathName )
4440 {
4441     static FN_RemoveDirectoryA *pfn = 0;
4442     if (!pfn)
4443         kPrf2WrapResolve((void **)&pfn, "RemoveDirectoryA", &g_Kernel32);
4444     return pfn( lpPathName );
4445 }
4446
4447 typedef BOOL WINAPI FN_RemoveDirectoryW( LPCWSTR lpPathName );
4448 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_RemoveDirectoryW( LPCWSTR lpPathName )
4449 {
4450     static FN_RemoveDirectoryW *pfn = 0;
4451     if (!pfn)
4452         kPrf2WrapResolve((void **)&pfn, "RemoveDirectoryW", &g_Kernel32);
4453     return pfn( lpPathName );
4454 }
4455
4456 typedef DWORD WINAPI FN_GetFullPathNameA( LPCSTR lpFileName, DWORD nBufferLength, LPSTR lpBuffer, LPSTR * lpFilePart );
4457 __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetFullPathNameA( LPCSTR lpFileName, DWORD nBufferLength, LPSTR lpBuffer, LPSTR * lpFilePart )
4458 {
4459     static FN_GetFullPathNameA *pfn = 0;
4460     if (!pfn)
4461         kPrf2WrapResolve((void **)&pfn, "GetFullPathNameA", &g_Kernel32);
4462     return pfn( lpFileName, nBufferLength, lpBuffer, lpFilePart );
4463 }
4464
4465 typedef DWORD WINAPI FN_GetFullPathNameW( LPCWSTR lpFileName, DWORD nBufferLength, LPWSTR lpBuffer, LPWSTR * lpFilePart );
4466 __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetFullPathNameW( LPCWSTR lpFileName, DWORD nBufferLength, LPWSTR lpBuffer, LPWSTR * lpFilePart )
4467 {
4468     static FN_GetFullPathNameW *pfn = 0;
4469     if (!pfn)
4470         kPrf2WrapResolve((void **)&pfn, "GetFullPathNameW", &g_Kernel32);
4471     return pfn( lpFileName, nBufferLength, lpBuffer, lpFilePart );
4472 }
4473
4474 typedef BOOL WINAPI FN_DefineDosDeviceA( DWORD dwFlags, LPCSTR lpDeviceName, LPCSTR lpTargetPath );
4475 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_DefineDosDeviceA( DWORD dwFlags, LPCSTR lpDeviceName, LPCSTR lpTargetPath )
4476 {
4477     static FN_DefineDosDeviceA *pfn = 0;
4478     if (!pfn)
4479         kPrf2WrapResolve((void **)&pfn, "DefineDosDeviceA", &g_Kernel32);
4480     return pfn( dwFlags, lpDeviceName, lpTargetPath );
4481 }
4482
4483 typedef BOOL WINAPI FN_DefineDosDeviceW( DWORD dwFlags, LPCWSTR lpDeviceName, LPCWSTR lpTargetPath );
4484 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_DefineDosDeviceW( DWORD dwFlags, LPCWSTR lpDeviceName, LPCWSTR lpTargetPath )
4485 {
4486     static FN_DefineDosDeviceW *pfn = 0;
4487     if (!pfn)
4488         kPrf2WrapResolve((void **)&pfn, "DefineDosDeviceW", &g_Kernel32);
4489     return pfn( dwFlags, lpDeviceName, lpTargetPath );
4490 }
4491
4492 typedef DWORD WINAPI FN_QueryDosDeviceA( LPCSTR lpDeviceName, LPSTR lpTargetPath, DWORD ucchMax );
4493 __declspec(dllexport) DWORD WINAPI kPrf2Wrap_QueryDosDeviceA( LPCSTR lpDeviceName, LPSTR lpTargetPath, DWORD ucchMax )
4494 {
4495     static FN_QueryDosDeviceA *pfn = 0;
4496     if (!pfn)
4497         kPrf2WrapResolve((void **)&pfn, "QueryDosDeviceA", &g_Kernel32);
4498     return pfn( lpDeviceName, lpTargetPath, ucchMax );
4499 }
4500
4501 typedef DWORD WINAPI FN_QueryDosDeviceW( LPCWSTR lpDeviceName, LPWSTR lpTargetPath, DWORD ucchMax );
4502 __declspec(dllexport) DWORD WINAPI kPrf2Wrap_QueryDosDeviceW( LPCWSTR lpDeviceName, LPWSTR lpTargetPath, DWORD ucchMax )
4503 {
4504     static FN_QueryDosDeviceW *pfn = 0;
4505     if (!pfn)
4506         kPrf2WrapResolve((void **)&pfn, "QueryDosDeviceW", &g_Kernel32);
4507     return pfn( lpDeviceName, lpTargetPath, ucchMax );
4508 }
4509
4510 typedef HANDLE WINAPI FN_CreateFileA( LPCSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode, LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes, HANDLE hTemplateFile );
4511 __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_CreateFileA( LPCSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode, LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes, HANDLE hTemplateFile )
4512 {
4513     static FN_CreateFileA *pfn = 0;
4514     if (!pfn)
4515         kPrf2WrapResolve((void **)&pfn, "CreateFileA", &g_Kernel32);
4516     return pfn( lpFileName, dwDesiredAccess, dwShareMode, lpSecurityAttributes, dwCreationDisposition, dwFlagsAndAttributes, hTemplateFile );
4517 }
4518
4519 typedef HANDLE WINAPI FN_CreateFileW( LPCWSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode, LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes, HANDLE hTemplateFile );
4520 __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_CreateFileW( LPCWSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode, LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes, HANDLE hTemplateFile )
4521 {
4522     static FN_CreateFileW *pfn = 0;
4523     if (!pfn)
4524         kPrf2WrapResolve((void **)&pfn, "CreateFileW", &g_Kernel32);
4525     return pfn( lpFileName, dwDesiredAccess, dwShareMode, lpSecurityAttributes, dwCreationDisposition, dwFlagsAndAttributes, hTemplateFile );
4526 }
4527
4528 typedef HANDLE WINAPI FN_ReOpenFile( HANDLE hOriginalFile, DWORD dwDesiredAccess, DWORD dwShareMode, DWORD dwFlagsAndAttributes );
4529 __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_ReOpenFile( HANDLE hOriginalFile, DWORD dwDesiredAccess, DWORD dwShareMode, DWORD dwFlagsAndAttributes )
4530 {
4531     static FN_ReOpenFile *pfn = 0;
4532     if (!pfn)
4533         kPrf2WrapResolve((void **)&pfn, "ReOpenFile", &g_Kernel32);
4534     return pfn( hOriginalFile, dwDesiredAccess, dwShareMode, dwFlagsAndAttributes );
4535 }
4536
4537 typedef BOOL WINAPI FN_SetFileAttributesA( LPCSTR lpFileName, DWORD dwFileAttributes );
4538 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetFileAttributesA( LPCSTR lpFileName, DWORD dwFileAttributes )
4539 {
4540     static FN_SetFileAttributesA *pfn = 0;
4541     if (!pfn)
4542         kPrf2WrapResolve((void **)&pfn, "SetFileAttributesA", &g_Kernel32);
4543     return pfn( lpFileName, dwFileAttributes );
4544 }
4545
4546 typedef BOOL WINAPI FN_SetFileAttributesW( LPCWSTR lpFileName, DWORD dwFileAttributes );
4547 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetFileAttributesW( LPCWSTR lpFileName, DWORD dwFileAttributes )
4548 {
4549     static FN_SetFileAttributesW *pfn = 0;
4550     if (!pfn)
4551         kPrf2WrapResolve((void **)&pfn, "SetFileAttributesW", &g_Kernel32);
4552     return pfn( lpFileName, dwFileAttributes );
4553 }
4554
4555 typedef DWORD WINAPI FN_GetFileAttributesA( LPCSTR lpFileName );
4556 __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetFileAttributesA( LPCSTR lpFileName )
4557 {
4558     static FN_GetFileAttributesA *pfn = 0;
4559     if (!pfn)
4560         kPrf2WrapResolve((void **)&pfn, "GetFileAttributesA", &g_Kernel32);
4561     return pfn( lpFileName );
4562 }
4563
4564 typedef DWORD WINAPI FN_GetFileAttributesW( LPCWSTR lpFileName );
4565 __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetFileAttributesW( LPCWSTR lpFileName )
4566 {
4567     static FN_GetFileAttributesW *pfn = 0;
4568     if (!pfn)
4569         kPrf2WrapResolve((void **)&pfn, "GetFileAttributesW", &g_Kernel32);
4570     return pfn( lpFileName );
4571 }
4572
4573 typedef BOOL WINAPI FN_GetFileAttributesExA( LPCSTR lpFileName, GET_FILEEX_INFO_LEVELS fInfoLevelId, LPVOID lpFileInformation );
4574 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetFileAttributesExA( LPCSTR lpFileName, GET_FILEEX_INFO_LEVELS fInfoLevelId, LPVOID lpFileInformation )
4575 {
4576     static FN_GetFileAttributesExA *pfn = 0;
4577     if (!pfn)
4578         kPrf2WrapResolve((void **)&pfn, "GetFileAttributesExA", &g_Kernel32);
4579     return pfn( lpFileName, fInfoLevelId, lpFileInformation );
4580 }
4581
4582 typedef BOOL WINAPI FN_GetFileAttributesExW( LPCWSTR lpFileName, GET_FILEEX_INFO_LEVELS fInfoLevelId, LPVOID lpFileInformation );
4583 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetFileAttributesExW( LPCWSTR lpFileName, GET_FILEEX_INFO_LEVELS fInfoLevelId, LPVOID lpFileInformation )
4584 {
4585     static FN_GetFileAttributesExW *pfn = 0;
4586     if (!pfn)
4587         kPrf2WrapResolve((void **)&pfn, "GetFileAttributesExW", &g_Kernel32);
4588     return pfn( lpFileName, fInfoLevelId, lpFileInformation );
4589 }
4590
4591 typedef DWORD WINAPI FN_GetCompressedFileSizeA( LPCSTR lpFileName, LPDWORD lpFileSizeHigh );
4592 __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetCompressedFileSizeA( LPCSTR lpFileName, LPDWORD lpFileSizeHigh )
4593 {
4594     static FN_GetCompressedFileSizeA *pfn = 0;
4595     if (!pfn)
4596         kPrf2WrapResolve((void **)&pfn, "GetCompressedFileSizeA", &g_Kernel32);
4597     return pfn( lpFileName, lpFileSizeHigh );
4598 }
4599
4600 typedef DWORD WINAPI FN_GetCompressedFileSizeW( LPCWSTR lpFileName, LPDWORD lpFileSizeHigh );
4601 __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetCompressedFileSizeW( LPCWSTR lpFileName, LPDWORD lpFileSizeHigh )
4602 {
4603     static FN_GetCompressedFileSizeW *pfn = 0;
4604     if (!pfn)
4605         kPrf2WrapResolve((void **)&pfn, "GetCompressedFileSizeW", &g_Kernel32);
4606     return pfn( lpFileName, lpFileSizeHigh );
4607 }
4608
4609 typedef BOOL WINAPI FN_DeleteFileA( LPCSTR lpFileName );
4610 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_DeleteFileA( LPCSTR lpFileName )
4611 {
4612     static FN_DeleteFileA *pfn = 0;
4613     if (!pfn)
4614         kPrf2WrapResolve((void **)&pfn, "DeleteFileA", &g_Kernel32);
4615     return pfn( lpFileName );
4616 }
4617
4618 typedef BOOL WINAPI FN_DeleteFileW( LPCWSTR lpFileName );
4619 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_DeleteFileW( LPCWSTR lpFileName )
4620 {
4621     static FN_DeleteFileW *pfn = 0;
4622     if (!pfn)
4623         kPrf2WrapResolve((void **)&pfn, "DeleteFileW", &g_Kernel32);
4624     return pfn( lpFileName );
4625 }
4626
4627 typedef BOOL WINAPI FN_CheckNameLegalDOS8Dot3A( LPCSTR lpName, LPSTR lpOemName, DWORD OemNameSize, PBOOL pbNameContainsSpaces , PBOOL pbNameLegal );
4628 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_CheckNameLegalDOS8Dot3A( LPCSTR lpName, LPSTR lpOemName, DWORD OemNameSize, PBOOL pbNameContainsSpaces , PBOOL pbNameLegal )
4629 {
4630     static FN_CheckNameLegalDOS8Dot3A *pfn = 0;
4631     if (!pfn)
4632         kPrf2WrapResolve((void **)&pfn, "CheckNameLegalDOS8Dot3A", &g_Kernel32);
4633     return pfn( lpName, lpOemName, OemNameSize, pbNameContainsSpaces , pbNameLegal );
4634 }
4635
4636 typedef BOOL WINAPI FN_CheckNameLegalDOS8Dot3W( LPCWSTR lpName, LPSTR lpOemName, DWORD OemNameSize, PBOOL pbNameContainsSpaces , PBOOL pbNameLegal );
4637 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_CheckNameLegalDOS8Dot3W( LPCWSTR lpName, LPSTR lpOemName, DWORD OemNameSize, PBOOL pbNameContainsSpaces , PBOOL pbNameLegal )
4638 {
4639     static FN_CheckNameLegalDOS8Dot3W *pfn = 0;
4640     if (!pfn)
4641         kPrf2WrapResolve((void **)&pfn, "CheckNameLegalDOS8Dot3W", &g_Kernel32);
4642     return pfn( lpName, lpOemName, OemNameSize, pbNameContainsSpaces , pbNameLegal );
4643 }
4644
4645 typedef HANDLE WINAPI FN_FindFirstFileExA( LPCSTR lpFileName, FINDEX_INFO_LEVELS fInfoLevelId, LPVOID lpFindFileData, FINDEX_SEARCH_OPS fSearchOp, LPVOID lpSearchFilter, DWORD dwAdditionalFlags );
4646 __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_FindFirstFileExA( LPCSTR lpFileName, FINDEX_INFO_LEVELS fInfoLevelId, LPVOID lpFindFileData, FINDEX_SEARCH_OPS fSearchOp, LPVOID lpSearchFilter, DWORD dwAdditionalFlags )
4647 {
4648     static FN_FindFirstFileExA *pfn = 0;
4649     if (!pfn)
4650         kPrf2WrapResolve((void **)&pfn, "FindFirstFileExA", &g_Kernel32);
4651     return pfn( lpFileName, fInfoLevelId, lpFindFileData, fSearchOp, lpSearchFilter, dwAdditionalFlags );
4652 }
4653
4654 typedef HANDLE WINAPI FN_FindFirstFileExW( LPCWSTR lpFileName, FINDEX_INFO_LEVELS fInfoLevelId, LPVOID lpFindFileData, FINDEX_SEARCH_OPS fSearchOp, LPVOID lpSearchFilter, DWORD dwAdditionalFlags );
4655 __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_FindFirstFileExW( LPCWSTR lpFileName, FINDEX_INFO_LEVELS fInfoLevelId, LPVOID lpFindFileData, FINDEX_SEARCH_OPS fSearchOp, LPVOID lpSearchFilter, DWORD dwAdditionalFlags )
4656 {
4657     static FN_FindFirstFileExW *pfn = 0;
4658     if (!pfn)
4659         kPrf2WrapResolve((void **)&pfn, "FindFirstFileExW", &g_Kernel32);
4660     return pfn( lpFileName, fInfoLevelId, lpFindFileData, fSearchOp, lpSearchFilter, dwAdditionalFlags );
4661 }
4662
4663 typedef HANDLE WINAPI FN_FindFirstFileA( LPCSTR lpFileName, LPWIN32_FIND_DATAA lpFindFileData );
4664 __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_FindFirstFileA( LPCSTR lpFileName, LPWIN32_FIND_DATAA lpFindFileData )
4665 {
4666     static FN_FindFirstFileA *pfn = 0;
4667     if (!pfn)
4668         kPrf2WrapResolve((void **)&pfn, "FindFirstFileA", &g_Kernel32);
4669     return pfn( lpFileName, lpFindFileData );
4670 }
4671
4672 typedef HANDLE WINAPI FN_FindFirstFileW( LPCWSTR lpFileName, LPWIN32_FIND_DATAW lpFindFileData );
4673 __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_FindFirstFileW( LPCWSTR lpFileName, LPWIN32_FIND_DATAW lpFindFileData )
4674 {
4675     static FN_FindFirstFileW *pfn = 0;
4676     if (!pfn)
4677         kPrf2WrapResolve((void **)&pfn, "FindFirstFileW", &g_Kernel32);
4678     return pfn( lpFileName, lpFindFileData );
4679 }
4680
4681 typedef BOOL WINAPI FN_FindNextFileA( HANDLE hFindFile, LPWIN32_FIND_DATAA lpFindFileData );
4682 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_FindNextFileA( HANDLE hFindFile, LPWIN32_FIND_DATAA lpFindFileData )
4683 {
4684     static FN_FindNextFileA *pfn = 0;
4685     if (!pfn)
4686         kPrf2WrapResolve((void **)&pfn, "FindNextFileA", &g_Kernel32);
4687     return pfn( hFindFile, lpFindFileData );
4688 }
4689
4690 typedef BOOL WINAPI FN_FindNextFileW( HANDLE hFindFile, LPWIN32_FIND_DATAW lpFindFileData );
4691 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_FindNextFileW( HANDLE hFindFile, LPWIN32_FIND_DATAW lpFindFileData )
4692 {
4693     static FN_FindNextFileW *pfn = 0;
4694     if (!pfn)
4695         kPrf2WrapResolve((void **)&pfn, "FindNextFileW", &g_Kernel32);
4696     return pfn( hFindFile, lpFindFileData );
4697 }
4698
4699 typedef DWORD WINAPI FN_SearchPathA( LPCSTR lpPath, LPCSTR lpFileName, LPCSTR lpExtension, DWORD nBufferLength, LPSTR lpBuffer, LPSTR * lpFilePart );
4700 __declspec(dllexport) DWORD WINAPI kPrf2Wrap_SearchPathA( LPCSTR lpPath, LPCSTR lpFileName, LPCSTR lpExtension, DWORD nBufferLength, LPSTR lpBuffer, LPSTR * lpFilePart )
4701 {
4702     static FN_SearchPathA *pfn = 0;
4703     if (!pfn)
4704         kPrf2WrapResolve((void **)&pfn, "SearchPathA", &g_Kernel32);
4705     return pfn( lpPath, lpFileName, lpExtension, nBufferLength, lpBuffer, lpFilePart );
4706 }
4707
4708 typedef DWORD WINAPI FN_SearchPathW( LPCWSTR lpPath, LPCWSTR lpFileName, LPCWSTR lpExtension, DWORD nBufferLength, LPWSTR lpBuffer, LPWSTR * lpFilePart );
4709 __declspec(dllexport) DWORD WINAPI kPrf2Wrap_SearchPathW( LPCWSTR lpPath, LPCWSTR lpFileName, LPCWSTR lpExtension, DWORD nBufferLength, LPWSTR lpBuffer, LPWSTR * lpFilePart )
4710 {
4711     static FN_SearchPathW *pfn = 0;
4712     if (!pfn)
4713         kPrf2WrapResolve((void **)&pfn, "SearchPathW", &g_Kernel32);
4714     return pfn( lpPath, lpFileName, lpExtension, nBufferLength, lpBuffer, lpFilePart );
4715 }
4716
4717 typedef BOOL WINAPI FN_CopyFileA( LPCSTR lpExistingFileName, LPCSTR lpNewFileName, BOOL bFailIfExists );
4718 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_CopyFileA( LPCSTR lpExistingFileName, LPCSTR lpNewFileName, BOOL bFailIfExists )
4719 {
4720     static FN_CopyFileA *pfn = 0;
4721     if (!pfn)
4722         kPrf2WrapResolve((void **)&pfn, "CopyFileA", &g_Kernel32);
4723     return pfn( lpExistingFileName, lpNewFileName, bFailIfExists );
4724 }
4725
4726 typedef BOOL WINAPI FN_CopyFileW( LPCWSTR lpExistingFileName, LPCWSTR lpNewFileName, BOOL bFailIfExists );
4727 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_CopyFileW( LPCWSTR lpExistingFileName, LPCWSTR lpNewFileName, BOOL bFailIfExists )
4728 {
4729     static FN_CopyFileW *pfn = 0;
4730     if (!pfn)
4731         kPrf2WrapResolve((void **)&pfn, "CopyFileW", &g_Kernel32);
4732     return pfn( lpExistingFileName, lpNewFileName, bFailIfExists );
4733 }
4734
4735 typedef BOOL WINAPI FN_CopyFileExA( LPCSTR lpExistingFileName, LPCSTR lpNewFileName, LPPROGRESS_ROUTINE lpProgressRoutine, LPVOID lpData, LPBOOL pbCancel, DWORD dwCopyFlags );
4736 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_CopyFileExA( LPCSTR lpExistingFileName, LPCSTR lpNewFileName, LPPROGRESS_ROUTINE lpProgressRoutine, LPVOID lpData, LPBOOL pbCancel, DWORD dwCopyFlags )
4737 {
4738     static FN_CopyFileExA *pfn = 0;
4739     if (!pfn)
4740         kPrf2WrapResolve((void **)&pfn, "CopyFileExA", &g_Kernel32);
4741     return pfn( lpExistingFileName, lpNewFileName, lpProgressRoutine, lpData, pbCancel, dwCopyFlags );
4742 }
4743
4744 typedef BOOL WINAPI FN_CopyFileExW( LPCWSTR lpExistingFileName, LPCWSTR lpNewFileName, LPPROGRESS_ROUTINE lpProgressRoutine, LPVOID lpData, LPBOOL pbCancel, DWORD dwCopyFlags );
4745 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_CopyFileExW( LPCWSTR lpExistingFileName, LPCWSTR lpNewFileName, LPPROGRESS_ROUTINE lpProgressRoutine, LPVOID lpData, LPBOOL pbCancel, DWORD dwCopyFlags )
4746 {
4747     static FN_CopyFileExW *pfn = 0;
4748     if (!pfn)
4749         kPrf2WrapResolve((void **)&pfn, "CopyFileExW", &g_Kernel32);
4750     return pfn( lpExistingFileName, lpNewFileName, lpProgressRoutine, lpData, pbCancel, dwCopyFlags );
4751 }
4752
4753 typedef BOOL WINAPI FN_MoveFileA( LPCSTR lpExistingFileName, LPCSTR lpNewFileName );
4754 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_MoveFileA( LPCSTR lpExistingFileName, LPCSTR lpNewFileName )
4755 {
4756     static FN_MoveFileA *pfn = 0;
4757     if (!pfn)
4758         kPrf2WrapResolve((void **)&pfn, "MoveFileA", &g_Kernel32);
4759     return pfn( lpExistingFileName, lpNewFileName );
4760 }
4761
4762 typedef BOOL WINAPI FN_MoveFileW( LPCWSTR lpExistingFileName, LPCWSTR lpNewFileName );
4763 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_MoveFileW( LPCWSTR lpExistingFileName, LPCWSTR lpNewFileName )
4764 {
4765     static FN_MoveFileW *pfn = 0;
4766     if (!pfn)
4767         kPrf2WrapResolve((void **)&pfn, "MoveFileW", &g_Kernel32);
4768     return pfn( lpExistingFileName, lpNewFileName );
4769 }
4770
4771 typedef BOOL WINAPI FN_MoveFileExA( LPCSTR lpExistingFileName, LPCSTR lpNewFileName, DWORD dwFlags );
4772 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_MoveFileExA( LPCSTR lpExistingFileName, LPCSTR lpNewFileName, DWORD dwFlags )
4773 {
4774     static FN_MoveFileExA *pfn = 0;
4775     if (!pfn)
4776         kPrf2WrapResolve((void **)&pfn, "MoveFileExA", &g_Kernel32);
4777     return pfn( lpExistingFileName, lpNewFileName, dwFlags );
4778 }
4779
4780 typedef BOOL WINAPI FN_MoveFileExW( LPCWSTR lpExistingFileName, LPCWSTR lpNewFileName, DWORD dwFlags );
4781 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_MoveFileExW( LPCWSTR lpExistingFileName, LPCWSTR lpNewFileName, DWORD dwFlags )
4782 {
4783     static FN_MoveFileExW *pfn = 0;
4784     if (!pfn)
4785         kPrf2WrapResolve((void **)&pfn, "MoveFileExW", &g_Kernel32);
4786     return pfn( lpExistingFileName, lpNewFileName, dwFlags );
4787 }
4788
4789 typedef BOOL WINAPI FN_MoveFileWithProgressA( LPCSTR lpExistingFileName, LPCSTR lpNewFileName, LPPROGRESS_ROUTINE lpProgressRoutine, LPVOID lpData, DWORD dwFlags );
4790 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_MoveFileWithProgressA( LPCSTR lpExistingFileName, LPCSTR lpNewFileName, LPPROGRESS_ROUTINE lpProgressRoutine, LPVOID lpData, DWORD dwFlags )
4791 {
4792     static FN_MoveFileWithProgressA *pfn = 0;
4793     if (!pfn)
4794         kPrf2WrapResolve((void **)&pfn, "MoveFileWithProgressA", &g_Kernel32);
4795     return pfn( lpExistingFileName, lpNewFileName, lpProgressRoutine, lpData, dwFlags );
4796 }
4797
4798 typedef BOOL WINAPI FN_MoveFileWithProgressW( LPCWSTR lpExistingFileName, LPCWSTR lpNewFileName, LPPROGRESS_ROUTINE lpProgressRoutine, LPVOID lpData, DWORD dwFlags );
4799 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_MoveFileWithProgressW( LPCWSTR lpExistingFileName, LPCWSTR lpNewFileName, LPPROGRESS_ROUTINE lpProgressRoutine, LPVOID lpData, DWORD dwFlags )
4800 {
4801     static FN_MoveFileWithProgressW *pfn = 0;
4802     if (!pfn)
4803         kPrf2WrapResolve((void **)&pfn, "MoveFileWithProgressW", &g_Kernel32);
4804     return pfn( lpExistingFileName, lpNewFileName, lpProgressRoutine, lpData, dwFlags );
4805 }
4806
4807 typedef BOOL WINAPI FN_ReplaceFileA( LPCSTR lpReplacedFileName, LPCSTR lpReplacementFileName, LPCSTR lpBackupFileName, DWORD dwReplaceFlags, LPVOID lpExclude, LPVOID lpReserved );
4808 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_ReplaceFileA( LPCSTR lpReplacedFileName, LPCSTR lpReplacementFileName, LPCSTR lpBackupFileName, DWORD dwReplaceFlags, LPVOID lpExclude, LPVOID lpReserved )
4809 {
4810     static FN_ReplaceFileA *pfn = 0;
4811     if (!pfn)
4812         kPrf2WrapResolve((void **)&pfn, "ReplaceFileA", &g_Kernel32);
4813     return pfn( lpReplacedFileName, lpReplacementFileName, lpBackupFileName, dwReplaceFlags, lpExclude, lpReserved );
4814 }
4815
4816 typedef BOOL WINAPI FN_ReplaceFileW( LPCWSTR lpReplacedFileName, LPCWSTR lpReplacementFileName, LPCWSTR lpBackupFileName, DWORD dwReplaceFlags, LPVOID lpExclude, LPVOID lpReserved );
4817 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_ReplaceFileW( LPCWSTR lpReplacedFileName, LPCWSTR lpReplacementFileName, LPCWSTR lpBackupFileName, DWORD dwReplaceFlags, LPVOID lpExclude, LPVOID lpReserved )
4818 {
4819     static FN_ReplaceFileW *pfn = 0;
4820     if (!pfn)
4821         kPrf2WrapResolve((void **)&pfn, "ReplaceFileW", &g_Kernel32);
4822     return pfn( lpReplacedFileName, lpReplacementFileName, lpBackupFileName, dwReplaceFlags, lpExclude, lpReserved );
4823 }
4824
4825 typedef BOOL WINAPI FN_CreateHardLinkA( LPCSTR lpFileName, LPCSTR lpExistingFileName, LPSECURITY_ATTRIBUTES lpSecurityAttributes );
4826 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_CreateHardLinkA( LPCSTR lpFileName, LPCSTR lpExistingFileName, LPSECURITY_ATTRIBUTES lpSecurityAttributes )
4827 {
4828     static FN_CreateHardLinkA *pfn = 0;
4829     if (!pfn)
4830         kPrf2WrapResolve((void **)&pfn, "CreateHardLinkA", &g_Kernel32);
4831     return pfn( lpFileName, lpExistingFileName, lpSecurityAttributes );
4832 }
4833
4834 typedef BOOL WINAPI FN_CreateHardLinkW( LPCWSTR lpFileName, LPCWSTR lpExistingFileName, LPSECURITY_ATTRIBUTES lpSecurityAttributes );
4835 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_CreateHardLinkW( LPCWSTR lpFileName, LPCWSTR lpExistingFileName, LPSECURITY_ATTRIBUTES lpSecurityAttributes )
4836 {
4837     static FN_CreateHardLinkW *pfn = 0;
4838     if (!pfn)
4839         kPrf2WrapResolve((void **)&pfn, "CreateHardLinkW", &g_Kernel32);
4840     return pfn( lpFileName, lpExistingFileName, lpSecurityAttributes );
4841 }
4842
4843 typedef HANDLE WINAPI FN_FindFirstStreamW( LPCWSTR lpFileName, STREAM_INFO_LEVELS InfoLevel, LPVOID lpFindStreamData, DWORD dwFlags );
4844 __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_FindFirstStreamW( LPCWSTR lpFileName, STREAM_INFO_LEVELS InfoLevel, LPVOID lpFindStreamData, DWORD dwFlags )
4845 {
4846     static FN_FindFirstStreamW *pfn = 0;
4847     if (!pfn)
4848         kPrf2WrapResolve((void **)&pfn, "FindFirstStreamW", &g_Kernel32);
4849     return pfn( lpFileName, InfoLevel, lpFindStreamData, dwFlags );
4850 }
4851
4852 typedef BOOL APIENTRY FN_FindNextStreamW( HANDLE hFindStream, LPVOID lpFindStreamData );
4853 __declspec(dllexport) BOOL APIENTRY kPrf2Wrap_FindNextStreamW( HANDLE hFindStream, LPVOID lpFindStreamData )
4854 {
4855     static FN_FindNextStreamW *pfn = 0;
4856     if (!pfn)
4857         kPrf2WrapResolve((void **)&pfn, "FindNextStreamW", &g_Kernel32);
4858     return pfn( hFindStream, lpFindStreamData );
4859 }
4860
4861 typedef HANDLE WINAPI FN_CreateNamedPipeA( LPCSTR lpName, DWORD dwOpenMode, DWORD dwPipeMode, DWORD nMaxInstances, DWORD nOutBufferSize, DWORD nInBufferSize, DWORD nDefaultTimeOut, LPSECURITY_ATTRIBUTES lpSecurityAttributes );
4862 __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_CreateNamedPipeA( LPCSTR lpName, DWORD dwOpenMode, DWORD dwPipeMode, DWORD nMaxInstances, DWORD nOutBufferSize, DWORD nInBufferSize, DWORD nDefaultTimeOut, LPSECURITY_ATTRIBUTES lpSecurityAttributes )
4863 {
4864     static FN_CreateNamedPipeA *pfn = 0;
4865     if (!pfn)
4866         kPrf2WrapResolve((void **)&pfn, "CreateNamedPipeA", &g_Kernel32);
4867     return pfn( lpName, dwOpenMode, dwPipeMode, nMaxInstances, nOutBufferSize, nInBufferSize, nDefaultTimeOut, lpSecurityAttributes );
4868 }
4869
4870 typedef HANDLE WINAPI FN_CreateNamedPipeW( LPCWSTR lpName, DWORD dwOpenMode, DWORD dwPipeMode, DWORD nMaxInstances, DWORD nOutBufferSize, DWORD nInBufferSize, DWORD nDefaultTimeOut, LPSECURITY_ATTRIBUTES lpSecurityAttributes );
4871 __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_CreateNamedPipeW( LPCWSTR lpName, DWORD dwOpenMode, DWORD dwPipeMode, DWORD nMaxInstances, DWORD nOutBufferSize, DWORD nInBufferSize, DWORD nDefaultTimeOut, LPSECURITY_ATTRIBUTES lpSecurityAttributes )
4872 {
4873     static FN_CreateNamedPipeW *pfn = 0;
4874     if (!pfn)
4875         kPrf2WrapResolve((void **)&pfn, "CreateNamedPipeW", &g_Kernel32);
4876     return pfn( lpName, dwOpenMode, dwPipeMode, nMaxInstances, nOutBufferSize, nInBufferSize, nDefaultTimeOut, lpSecurityAttributes );
4877 }
4878
4879 typedef BOOL WINAPI FN_GetNamedPipeHandleStateA( HANDLE hNamedPipe, LPDWORD lpState, LPDWORD lpCurInstances, LPDWORD lpMaxCollectionCount, LPDWORD lpCollectDataTimeout, LPSTR lpUserName, DWORD nMaxUserNameSize );
4880 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetNamedPipeHandleStateA( HANDLE hNamedPipe, LPDWORD lpState, LPDWORD lpCurInstances, LPDWORD lpMaxCollectionCount, LPDWORD lpCollectDataTimeout, LPSTR lpUserName, DWORD nMaxUserNameSize )
4881 {
4882     static FN_GetNamedPipeHandleStateA *pfn = 0;
4883     if (!pfn)
4884         kPrf2WrapResolve((void **)&pfn, "GetNamedPipeHandleStateA", &g_Kernel32);
4885     return pfn( hNamedPipe, lpState, lpCurInstances, lpMaxCollectionCount, lpCollectDataTimeout, lpUserName, nMaxUserNameSize );
4886 }
4887
4888 typedef BOOL WINAPI FN_GetNamedPipeHandleStateW( HANDLE hNamedPipe, LPDWORD lpState, LPDWORD lpCurInstances, LPDWORD lpMaxCollectionCount, LPDWORD lpCollectDataTimeout, LPWSTR lpUserName, DWORD nMaxUserNameSize );
4889 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetNamedPipeHandleStateW( HANDLE hNamedPipe, LPDWORD lpState, LPDWORD lpCurInstances, LPDWORD lpMaxCollectionCount, LPDWORD lpCollectDataTimeout, LPWSTR lpUserName, DWORD nMaxUserNameSize )
4890 {
4891     static FN_GetNamedPipeHandleStateW *pfn = 0;
4892     if (!pfn)
4893         kPrf2WrapResolve((void **)&pfn, "GetNamedPipeHandleStateW", &g_Kernel32);
4894     return pfn( hNamedPipe, lpState, lpCurInstances, lpMaxCollectionCount, lpCollectDataTimeout, lpUserName, nMaxUserNameSize );
4895 }
4896
4897 typedef BOOL WINAPI FN_CallNamedPipeA( LPCSTR lpNamedPipeName, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesRead, DWORD nTimeOut );
4898 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_CallNamedPipeA( LPCSTR lpNamedPipeName, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesRead, DWORD nTimeOut )
4899 {
4900     static FN_CallNamedPipeA *pfn = 0;
4901     if (!pfn)
4902         kPrf2WrapResolve((void **)&pfn, "CallNamedPipeA", &g_Kernel32);
4903     return pfn( lpNamedPipeName, lpInBuffer, nInBufferSize, lpOutBuffer, nOutBufferSize, lpBytesRead, nTimeOut );
4904 }
4905
4906 typedef BOOL WINAPI FN_CallNamedPipeW( LPCWSTR lpNamedPipeName, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesRead, DWORD nTimeOut );
4907 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_CallNamedPipeW( LPCWSTR lpNamedPipeName, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesRead, DWORD nTimeOut )
4908 {
4909     static FN_CallNamedPipeW *pfn = 0;
4910     if (!pfn)
4911         kPrf2WrapResolve((void **)&pfn, "CallNamedPipeW", &g_Kernel32);
4912     return pfn( lpNamedPipeName, lpInBuffer, nInBufferSize, lpOutBuffer, nOutBufferSize, lpBytesRead, nTimeOut );
4913 }
4914
4915 typedef BOOL WINAPI FN_WaitNamedPipeA( LPCSTR lpNamedPipeName, DWORD nTimeOut );
4916 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_WaitNamedPipeA( LPCSTR lpNamedPipeName, DWORD nTimeOut )
4917 {
4918     static FN_WaitNamedPipeA *pfn = 0;
4919     if (!pfn)
4920         kPrf2WrapResolve((void **)&pfn, "WaitNamedPipeA", &g_Kernel32);
4921     return pfn( lpNamedPipeName, nTimeOut );
4922 }
4923
4924 typedef BOOL WINAPI FN_WaitNamedPipeW( LPCWSTR lpNamedPipeName, DWORD nTimeOut );
4925 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_WaitNamedPipeW( LPCWSTR lpNamedPipeName, DWORD nTimeOut )
4926 {
4927     static FN_WaitNamedPipeW *pfn = 0;
4928     if (!pfn)
4929         kPrf2WrapResolve((void **)&pfn, "WaitNamedPipeW", &g_Kernel32);
4930     return pfn( lpNamedPipeName, nTimeOut );
4931 }
4932
4933 typedef BOOL WINAPI FN_SetVolumeLabelA( LPCSTR lpRootPathName, LPCSTR lpVolumeName );
4934 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetVolumeLabelA( LPCSTR lpRootPathName, LPCSTR lpVolumeName )
4935 {
4936     static FN_SetVolumeLabelA *pfn = 0;
4937     if (!pfn)
4938         kPrf2WrapResolve((void **)&pfn, "SetVolumeLabelA", &g_Kernel32);
4939     return pfn( lpRootPathName, lpVolumeName );
4940 }
4941
4942 typedef BOOL WINAPI FN_SetVolumeLabelW( LPCWSTR lpRootPathName, LPCWSTR lpVolumeName );
4943 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetVolumeLabelW( LPCWSTR lpRootPathName, LPCWSTR lpVolumeName )
4944 {
4945     static FN_SetVolumeLabelW *pfn = 0;
4946     if (!pfn)
4947         kPrf2WrapResolve((void **)&pfn, "SetVolumeLabelW", &g_Kernel32);
4948     return pfn( lpRootPathName, lpVolumeName );
4949 }
4950
4951 typedef VOID WINAPI FN_SetFileApisToOEM( VOID );
4952 __declspec(dllexport) VOID WINAPI kPrf2Wrap_SetFileApisToOEM( VOID )
4953 {
4954     static FN_SetFileApisToOEM *pfn = 0;
4955     if (!pfn)
4956         kPrf2WrapResolve((void **)&pfn, "SetFileApisToOEM", &g_Kernel32);
4957     pfn ();
4958 }
4959
4960 typedef VOID WINAPI FN_SetFileApisToANSI( VOID );
4961 __declspec(dllexport) VOID WINAPI kPrf2Wrap_SetFileApisToANSI( VOID )
4962 {
4963     static FN_SetFileApisToANSI *pfn = 0;
4964     if (!pfn)
4965         kPrf2WrapResolve((void **)&pfn, "SetFileApisToANSI", &g_Kernel32);
4966     pfn ();
4967 }
4968
4969 typedef BOOL WINAPI FN_AreFileApisANSI( VOID );
4970 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_AreFileApisANSI( VOID )
4971 {
4972     static FN_AreFileApisANSI *pfn = 0;
4973     if (!pfn)
4974         kPrf2WrapResolve((void **)&pfn, "AreFileApisANSI", &g_Kernel32);
4975     return pfn ();
4976 }
4977
4978 typedef BOOL WINAPI FN_GetVolumeInformationA( LPCSTR lpRootPathName, LPSTR lpVolumeNameBuffer, DWORD nVolumeNameSize, LPDWORD lpVolumeSerialNumber, LPDWORD lpMaximumComponentLength, LPDWORD lpFileSystemFlags, LPSTR lpFileSystemNameBuffer, DWORD nFileSystemNameSize );
4979 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetVolumeInformationA( LPCSTR lpRootPathName, LPSTR lpVolumeNameBuffer, DWORD nVolumeNameSize, LPDWORD lpVolumeSerialNumber, LPDWORD lpMaximumComponentLength, LPDWORD lpFileSystemFlags, LPSTR lpFileSystemNameBuffer, DWORD nFileSystemNameSize )
4980 {
4981     static FN_GetVolumeInformationA *pfn = 0;
4982     if (!pfn)
4983         kPrf2WrapResolve((void **)&pfn, "GetVolumeInformationA", &g_Kernel32);
4984     return pfn( lpRootPathName, lpVolumeNameBuffer, nVolumeNameSize, lpVolumeSerialNumber, lpMaximumComponentLength, lpFileSystemFlags, lpFileSystemNameBuffer, nFileSystemNameSize );
4985 }
4986
4987 typedef BOOL WINAPI FN_GetVolumeInformationW( LPCWSTR lpRootPathName, LPWSTR lpVolumeNameBuffer, DWORD nVolumeNameSize, LPDWORD lpVolumeSerialNumber, LPDWORD lpMaximumComponentLength, LPDWORD lpFileSystemFlags, LPWSTR lpFileSystemNameBuffer, DWORD nFileSystemNameSize );
4988 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetVolumeInformationW( LPCWSTR lpRootPathName, LPWSTR lpVolumeNameBuffer, DWORD nVolumeNameSize, LPDWORD lpVolumeSerialNumber, LPDWORD lpMaximumComponentLength, LPDWORD lpFileSystemFlags, LPWSTR lpFileSystemNameBuffer, DWORD nFileSystemNameSize )
4989 {
4990     static FN_GetVolumeInformationW *pfn = 0;
4991     if (!pfn)
4992         kPrf2WrapResolve((void **)&pfn, "GetVolumeInformationW", &g_Kernel32);
4993     return pfn( lpRootPathName, lpVolumeNameBuffer, nVolumeNameSize, lpVolumeSerialNumber, lpMaximumComponentLength, lpFileSystemFlags, lpFileSystemNameBuffer, nFileSystemNameSize );
4994 }
4995
4996 typedef BOOL WINAPI FN_CancelIo( HANDLE hFile );
4997 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_CancelIo( HANDLE hFile )
4998 {
4999     static FN_CancelIo *pfn = 0;
5000     if (!pfn)
5001         kPrf2WrapResolve((void **)&pfn, "CancelIo", &g_Kernel32);
5002     return pfn( hFile );
5003 }
5004
5005 typedef BOOL WINAPI FN_ClearEventLogA( HANDLE hEventLog, LPCSTR lpBackupFileName );
5006 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_ClearEventLogA( HANDLE hEventLog, LPCSTR lpBackupFileName )
5007 {
5008     static FN_ClearEventLogA *pfn = 0;
5009     if (!pfn)
5010         kPrf2WrapResolve((void **)&pfn, "ClearEventLogA", &g_Kernel32);
5011     return pfn( hEventLog, lpBackupFileName );
5012 }
5013
5014 typedef BOOL WINAPI FN_ClearEventLogW( HANDLE hEventLog, LPCWSTR lpBackupFileName );
5015 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_ClearEventLogW( HANDLE hEventLog, LPCWSTR lpBackupFileName )
5016 {
5017     static FN_ClearEventLogW *pfn = 0;
5018     if (!pfn)
5019         kPrf2WrapResolve((void **)&pfn, "ClearEventLogW", &g_Kernel32);
5020     return pfn( hEventLog, lpBackupFileName );
5021 }
5022
5023 typedef BOOL WINAPI FN_BackupEventLogA( HANDLE hEventLog, LPCSTR lpBackupFileName );
5024 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_BackupEventLogA( HANDLE hEventLog, LPCSTR lpBackupFileName )
5025 {
5026     static FN_BackupEventLogA *pfn = 0;
5027     if (!pfn)
5028         kPrf2WrapResolve((void **)&pfn, "BackupEventLogA", &g_Kernel32);
5029     return pfn( hEventLog, lpBackupFileName );
5030 }
5031
5032 typedef BOOL WINAPI FN_BackupEventLogW( HANDLE hEventLog, LPCWSTR lpBackupFileName );
5033 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_BackupEventLogW( HANDLE hEventLog, LPCWSTR lpBackupFileName )
5034 {
5035     static FN_BackupEventLogW *pfn = 0;
5036     if (!pfn)
5037         kPrf2WrapResolve((void **)&pfn, "BackupEventLogW", &g_Kernel32);
5038     return pfn( hEventLog, lpBackupFileName );
5039 }
5040
5041 typedef BOOL WINAPI FN_CloseEventLog( HANDLE hEventLog );
5042 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_CloseEventLog( HANDLE hEventLog )
5043 {
5044     static FN_CloseEventLog *pfn = 0;
5045     if (!pfn)
5046         kPrf2WrapResolve((void **)&pfn, "CloseEventLog", &g_Kernel32);
5047     return pfn( hEventLog );
5048 }
5049
5050 typedef BOOL WINAPI FN_DeregisterEventSource( HANDLE hEventLog );
5051 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_DeregisterEventSource( HANDLE hEventLog )
5052 {
5053     static FN_DeregisterEventSource *pfn = 0;
5054     if (!pfn)
5055         kPrf2WrapResolve((void **)&pfn, "DeregisterEventSource", &g_Kernel32);
5056     return pfn( hEventLog );
5057 }
5058
5059 typedef BOOL WINAPI FN_NotifyChangeEventLog( HANDLE hEventLog, HANDLE hEvent );
5060 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_NotifyChangeEventLog( HANDLE hEventLog, HANDLE hEvent )
5061 {
5062     static FN_NotifyChangeEventLog *pfn = 0;
5063     if (!pfn)
5064         kPrf2WrapResolve((void **)&pfn, "NotifyChangeEventLog", &g_Kernel32);
5065     return pfn( hEventLog, hEvent );
5066 }
5067
5068 typedef BOOL WINAPI FN_GetNumberOfEventLogRecords( HANDLE hEventLog, PDWORD NumberOfRecords );
5069 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetNumberOfEventLogRecords( HANDLE hEventLog, PDWORD NumberOfRecords )
5070 {
5071     static FN_GetNumberOfEventLogRecords *pfn = 0;
5072     if (!pfn)
5073         kPrf2WrapResolve((void **)&pfn, "GetNumberOfEventLogRecords", &g_Kernel32);
5074     return pfn( hEventLog, NumberOfRecords );
5075 }
5076
5077 typedef BOOL WINAPI FN_GetOldestEventLogRecord( HANDLE hEventLog, PDWORD OldestRecord );
5078 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetOldestEventLogRecord( HANDLE hEventLog, PDWORD OldestRecord )
5079 {
5080     static FN_GetOldestEventLogRecord *pfn = 0;
5081     if (!pfn)
5082         kPrf2WrapResolve((void **)&pfn, "GetOldestEventLogRecord", &g_Kernel32);
5083     return pfn( hEventLog, OldestRecord );
5084 }
5085
5086 typedef HANDLE WINAPI FN_OpenEventLogA( LPCSTR lpUNCServerName, LPCSTR lpSourceName );
5087 __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_OpenEventLogA( LPCSTR lpUNCServerName, LPCSTR lpSourceName )
5088 {
5089     static FN_OpenEventLogA *pfn = 0;
5090     if (!pfn)
5091         kPrf2WrapResolve((void **)&pfn, "OpenEventLogA", &g_Kernel32);
5092     return pfn( lpUNCServerName, lpSourceName );
5093 }
5094
5095 typedef HANDLE WINAPI FN_OpenEventLogW( LPCWSTR lpUNCServerName, LPCWSTR lpSourceName );
5096 __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_OpenEventLogW( LPCWSTR lpUNCServerName, LPCWSTR lpSourceName )
5097 {
5098     static FN_OpenEventLogW *pfn = 0;
5099     if (!pfn)
5100         kPrf2WrapResolve((void **)&pfn, "OpenEventLogW", &g_Kernel32);
5101     return pfn( lpUNCServerName, lpSourceName );
5102 }
5103
5104 typedef HANDLE WINAPI FN_RegisterEventSourceA( LPCSTR lpUNCServerName, LPCSTR lpSourceName );
5105 __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_RegisterEventSourceA( LPCSTR lpUNCServerName, LPCSTR lpSourceName )
5106 {
5107     static FN_RegisterEventSourceA *pfn = 0;
5108     if (!pfn)
5109         kPrf2WrapResolve((void **)&pfn, "RegisterEventSourceA", &g_Kernel32);
5110     return pfn( lpUNCServerName, lpSourceName );
5111 }
5112
5113 typedef HANDLE WINAPI FN_RegisterEventSourceW( LPCWSTR lpUNCServerName, LPCWSTR lpSourceName );
5114 __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_RegisterEventSourceW( LPCWSTR lpUNCServerName, LPCWSTR lpSourceName )
5115 {
5116     static FN_RegisterEventSourceW *pfn = 0;
5117     if (!pfn)
5118         kPrf2WrapResolve((void **)&pfn, "RegisterEventSourceW", &g_Kernel32);
5119     return pfn( lpUNCServerName, lpSourceName );
5120 }
5121
5122 typedef HANDLE WINAPI FN_OpenBackupEventLogA( LPCSTR lpUNCServerName, LPCSTR lpFileName );
5123 __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_OpenBackupEventLogA( LPCSTR lpUNCServerName, LPCSTR lpFileName )
5124 {
5125     static FN_OpenBackupEventLogA *pfn = 0;
5126     if (!pfn)
5127         kPrf2WrapResolve((void **)&pfn, "OpenBackupEventLogA", &g_Kernel32);
5128     return pfn( lpUNCServerName, lpFileName );
5129 }
5130
5131 typedef HANDLE WINAPI FN_OpenBackupEventLogW( LPCWSTR lpUNCServerName, LPCWSTR lpFileName );
5132 __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_OpenBackupEventLogW( LPCWSTR lpUNCServerName, LPCWSTR lpFileName )
5133 {
5134     static FN_OpenBackupEventLogW *pfn = 0;
5135     if (!pfn)
5136         kPrf2WrapResolve((void **)&pfn, "OpenBackupEventLogW", &g_Kernel32);
5137     return pfn( lpUNCServerName, lpFileName );
5138 }
5139
5140 typedef BOOL WINAPI FN_ReadEventLogA( HANDLE hEventLog, DWORD dwReadFlags, DWORD dwRecordOffset, LPVOID lpBuffer, DWORD nNumberOfBytesToRead, DWORD * pnBytesRead, DWORD * pnMinNumberOfBytesNeeded );
5141 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_ReadEventLogA( HANDLE hEventLog, DWORD dwReadFlags, DWORD dwRecordOffset, LPVOID lpBuffer, DWORD nNumberOfBytesToRead, DWORD * pnBytesRead, DWORD * pnMinNumberOfBytesNeeded )
5142 {
5143     static FN_ReadEventLogA *pfn = 0;
5144     if (!pfn)
5145         kPrf2WrapResolve((void **)&pfn, "ReadEventLogA", &g_Kernel32);
5146     return pfn( hEventLog, dwReadFlags, dwRecordOffset, lpBuffer, nNumberOfBytesToRead, pnBytesRead, pnMinNumberOfBytesNeeded );
5147 }
5148
5149 typedef BOOL WINAPI FN_ReadEventLogW( HANDLE hEventLog, DWORD dwReadFlags, DWORD dwRecordOffset, LPVOID lpBuffer, DWORD nNumberOfBytesToRead, DWORD * pnBytesRead, DWORD * pnMinNumberOfBytesNeeded );
5150 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_ReadEventLogW( HANDLE hEventLog, DWORD dwReadFlags, DWORD dwRecordOffset, LPVOID lpBuffer, DWORD nNumberOfBytesToRead, DWORD * pnBytesRead, DWORD * pnMinNumberOfBytesNeeded )
5151 {
5152     static FN_ReadEventLogW *pfn = 0;
5153     if (!pfn)
5154         kPrf2WrapResolve((void **)&pfn, "ReadEventLogW", &g_Kernel32);
5155     return pfn( hEventLog, dwReadFlags, dwRecordOffset, lpBuffer, nNumberOfBytesToRead, pnBytesRead, pnMinNumberOfBytesNeeded );
5156 }
5157
5158 typedef BOOL WINAPI FN_ReportEventA( HANDLE hEventLog, WORD wType, WORD wCategory, DWORD dwEventID, PSID lpUserSid, WORD wNumStrings, DWORD dwDataSize, LPCSTR * lpStrings, LPVOID lpRawData );
5159 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_ReportEventA( HANDLE hEventLog, WORD wType, WORD wCategory, DWORD dwEventID, PSID lpUserSid, WORD wNumStrings, DWORD dwDataSize, LPCSTR * lpStrings, LPVOID lpRawData )
5160 {
5161     static FN_ReportEventA *pfn = 0;
5162     if (!pfn)
5163         kPrf2WrapResolve((void **)&pfn, "ReportEventA", &g_Kernel32);
5164     return pfn( hEventLog, wType, wCategory, dwEventID, lpUserSid, wNumStrings, dwDataSize, lpStrings, lpRawData );
5165 }
5166
5167 typedef BOOL WINAPI FN_ReportEventW( HANDLE hEventLog, WORD wType, WORD wCategory, DWORD dwEventID, PSID lpUserSid, WORD wNumStrings, DWORD dwDataSize, LPCWSTR * lpStrings, LPVOID lpRawData );
5168 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_ReportEventW( HANDLE hEventLog, WORD wType, WORD wCategory, DWORD dwEventID, PSID lpUserSid, WORD wNumStrings, DWORD dwDataSize, LPCWSTR * lpStrings, LPVOID lpRawData )
5169 {
5170     static FN_ReportEventW *pfn = 0;
5171     if (!pfn)
5172         kPrf2WrapResolve((void **)&pfn, "ReportEventW", &g_Kernel32);
5173     return pfn( hEventLog, wType, wCategory, dwEventID, lpUserSid, wNumStrings, dwDataSize, lpStrings, lpRawData );
5174 }
5175
5176 typedef BOOL WINAPI FN_GetEventLogInformation( HANDLE hEventLog, DWORD dwInfoLevel, LPVOID lpBuffer, DWORD cbBufSize, LPDWORD pcbBytesNeeded );
5177 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetEventLogInformation( HANDLE hEventLog, DWORD dwInfoLevel, LPVOID lpBuffer, DWORD cbBufSize, LPDWORD pcbBytesNeeded )
5178 {
5179     static FN_GetEventLogInformation *pfn = 0;
5180     if (!pfn)
5181         kPrf2WrapResolve((void **)&pfn, "GetEventLogInformation", &g_Kernel32);
5182     return pfn( hEventLog, dwInfoLevel, lpBuffer, cbBufSize, pcbBytesNeeded );
5183 }
5184
5185 typedef BOOL WINAPI FN_DuplicateToken( HANDLE ExistingTokenHandle, SECURITY_IMPERSONATION_LEVEL ImpersonationLevel, PHANDLE DuplicateTokenHandle );
5186 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_DuplicateToken( HANDLE ExistingTokenHandle, SECURITY_IMPERSONATION_LEVEL ImpersonationLevel, PHANDLE DuplicateTokenHandle )
5187 {
5188     static FN_DuplicateToken *pfn = 0;
5189     if (!pfn)
5190         kPrf2WrapResolve((void **)&pfn, "DuplicateToken", &g_Kernel32);
5191     return pfn( ExistingTokenHandle, ImpersonationLevel, DuplicateTokenHandle );
5192 }
5193
5194 typedef BOOL WINAPI FN_GetKernelObjectSecurity( HANDLE Handle, SECURITY_INFORMATION RequestedInformation, PSECURITY_DESCRIPTOR pSecurityDescriptor, DWORD nLength, LPDWORD lpnLengthNeeded );
5195 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetKernelObjectSecurity( HANDLE Handle, SECURITY_INFORMATION RequestedInformation, PSECURITY_DESCRIPTOR pSecurityDescriptor, DWORD nLength, LPDWORD lpnLengthNeeded )
5196 {
5197     static FN_GetKernelObjectSecurity *pfn = 0;
5198     if (!pfn)
5199         kPrf2WrapResolve((void **)&pfn, "GetKernelObjectSecurity", &g_Kernel32);
5200     return pfn( Handle, RequestedInformation, pSecurityDescriptor, nLength, lpnLengthNeeded );
5201 }
5202
5203 typedef BOOL WINAPI FN_ImpersonateNamedPipeClient( HANDLE hNamedPipe );
5204 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_ImpersonateNamedPipeClient( HANDLE hNamedPipe )
5205 {
5206     static FN_ImpersonateNamedPipeClient *pfn = 0;
5207     if (!pfn)
5208         kPrf2WrapResolve((void **)&pfn, "ImpersonateNamedPipeClient", &g_Kernel32);
5209     return pfn( hNamedPipe );
5210 }
5211
5212 typedef BOOL WINAPI FN_ImpersonateSelf( SECURITY_IMPERSONATION_LEVEL ImpersonationLevel );
5213 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_ImpersonateSelf( SECURITY_IMPERSONATION_LEVEL ImpersonationLevel )
5214 {
5215     static FN_ImpersonateSelf *pfn = 0;
5216     if (!pfn)
5217         kPrf2WrapResolve((void **)&pfn, "ImpersonateSelf", &g_Kernel32);
5218     return pfn( ImpersonationLevel );
5219 }
5220
5221 typedef BOOL WINAPI FN_RevertToSelf( VOID );
5222 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_RevertToSelf( VOID )
5223 {
5224     static FN_RevertToSelf *pfn = 0;
5225     if (!pfn)
5226         kPrf2WrapResolve((void **)&pfn, "RevertToSelf", &g_Kernel32);
5227     return pfn ();
5228 }
5229
5230 typedef BOOL APIENTRY FN_SetThreadToken( PHANDLE Thread, HANDLE Token );
5231 __declspec(dllexport) BOOL APIENTRY kPrf2Wrap_SetThreadToken( PHANDLE Thread, HANDLE Token )
5232 {
5233     static FN_SetThreadToken *pfn = 0;
5234     if (!pfn)
5235         kPrf2WrapResolve((void **)&pfn, "SetThreadToken", &g_Kernel32);
5236     return pfn( Thread, Token );
5237 }
5238
5239 typedef BOOL WINAPI FN_AccessCheck( PSECURITY_DESCRIPTOR pSecurityDescriptor, HANDLE ClientToken, DWORD DesiredAccess, PGENERIC_MAPPING GenericMapping, PPRIVILEGE_SET PrivilegeSet, LPDWORD PrivilegeSetLength, LPDWORD GrantedAccess, LPBOOL AccessStatus );
5240 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_AccessCheck( PSECURITY_DESCRIPTOR pSecurityDescriptor, HANDLE ClientToken, DWORD DesiredAccess, PGENERIC_MAPPING GenericMapping, PPRIVILEGE_SET PrivilegeSet, LPDWORD PrivilegeSetLength, LPDWORD GrantedAccess, LPBOOL AccessStatus )
5241 {
5242     static FN_AccessCheck *pfn = 0;
5243     if (!pfn)
5244         kPrf2WrapResolve((void **)&pfn, "AccessCheck", &g_Kernel32);
5245     return pfn( pSecurityDescriptor, ClientToken, DesiredAccess, GenericMapping, PrivilegeSet, PrivilegeSetLength, GrantedAccess, AccessStatus );
5246 }
5247
5248 typedef BOOL WINAPI FN_AccessCheckByType( PSECURITY_DESCRIPTOR pSecurityDescriptor, PSID PrincipalSelfSid, HANDLE ClientToken, DWORD DesiredAccess, POBJECT_TYPE_LIST ObjectTypeList, DWORD ObjectTypeListLength, PGENERIC_MAPPING GenericMapping, PPRIVILEGE_SET PrivilegeSet, LPDWORD PrivilegeSetLength, LPDWORD GrantedAccess, LPBOOL AccessStatus );
5249 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_AccessCheckByType( PSECURITY_DESCRIPTOR pSecurityDescriptor, PSID PrincipalSelfSid, HANDLE ClientToken, DWORD DesiredAccess, POBJECT_TYPE_LIST ObjectTypeList, DWORD ObjectTypeListLength, PGENERIC_MAPPING GenericMapping, PPRIVILEGE_SET PrivilegeSet, LPDWORD PrivilegeSetLength, LPDWORD GrantedAccess, LPBOOL AccessStatus )
5250 {
5251     static FN_AccessCheckByType *pfn = 0;
5252     if (!pfn)
5253         kPrf2WrapResolve((void **)&pfn, "AccessCheckByType", &g_Kernel32);
5254     return pfn( pSecurityDescriptor, PrincipalSelfSid, ClientToken, DesiredAccess, ObjectTypeList, ObjectTypeListLength, GenericMapping, PrivilegeSet, PrivilegeSetLength, GrantedAccess, AccessStatus );
5255 }
5256
5257 typedef BOOL WINAPI FN_AccessCheckByTypeResultList( PSECURITY_DESCRIPTOR pSecurityDescriptor, PSID PrincipalSelfSid, HANDLE ClientToken, DWORD DesiredAccess, POBJECT_TYPE_LIST ObjectTypeList, DWORD ObjectTypeListLength, PGENERIC_MAPPING GenericMapping, PPRIVILEGE_SET PrivilegeSet, LPDWORD PrivilegeSetLength, LPDWORD GrantedAccessList, LPDWORD AccessStatusList );
5258 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_AccessCheckByTypeResultList( PSECURITY_DESCRIPTOR pSecurityDescriptor, PSID PrincipalSelfSid, HANDLE ClientToken, DWORD DesiredAccess, POBJECT_TYPE_LIST ObjectTypeList, DWORD ObjectTypeListLength, PGENERIC_MAPPING GenericMapping, PPRIVILEGE_SET PrivilegeSet, LPDWORD PrivilegeSetLength, LPDWORD GrantedAccessList, LPDWORD AccessStatusList )
5259 {
5260     static FN_AccessCheckByTypeResultList *pfn = 0;
5261     if (!pfn)
5262         kPrf2WrapResolve((void **)&pfn, "AccessCheckByTypeResultList", &g_Kernel32);
5263     return pfn( pSecurityDescriptor, PrincipalSelfSid, ClientToken, DesiredAccess, ObjectTypeList, ObjectTypeListLength, GenericMapping, PrivilegeSet, PrivilegeSetLength, GrantedAccessList, AccessStatusList );
5264 }
5265
5266 typedef BOOL WINAPI FN_OpenProcessToken( HANDLE ProcessHandle, DWORD DesiredAccess, PHANDLE TokenHandle );
5267 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_OpenProcessToken( HANDLE ProcessHandle, DWORD DesiredAccess, PHANDLE TokenHandle )
5268 {
5269     static FN_OpenProcessToken *pfn = 0;
5270     if (!pfn)
5271         kPrf2WrapResolve((void **)&pfn, "OpenProcessToken", &g_Kernel32);
5272     return pfn( ProcessHandle, DesiredAccess, TokenHandle );
5273 }
5274
5275 typedef BOOL WINAPI FN_OpenThreadToken( HANDLE ThreadHandle, DWORD DesiredAccess, BOOL OpenAsSelf, PHANDLE TokenHandle );
5276 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_OpenThreadToken( HANDLE ThreadHandle, DWORD DesiredAccess, BOOL OpenAsSelf, PHANDLE TokenHandle )
5277 {
5278     static FN_OpenThreadToken *pfn = 0;
5279     if (!pfn)
5280         kPrf2WrapResolve((void **)&pfn, "OpenThreadToken", &g_Kernel32);
5281     return pfn( ThreadHandle, DesiredAccess, OpenAsSelf, TokenHandle );
5282 }
5283
5284 typedef BOOL WINAPI FN_GetTokenInformation( HANDLE TokenHandle, TOKEN_INFORMATION_CLASS TokenInformationClass, LPVOID TokenInformation, DWORD TokenInformationLength, PDWORD ReturnLength );
5285 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetTokenInformation( HANDLE TokenHandle, TOKEN_INFORMATION_CLASS TokenInformationClass, LPVOID TokenInformation, DWORD TokenInformationLength, PDWORD ReturnLength )
5286 {
5287     static FN_GetTokenInformation *pfn = 0;
5288     if (!pfn)
5289         kPrf2WrapResolve((void **)&pfn, "GetTokenInformation", &g_Kernel32);
5290     return pfn( TokenHandle, TokenInformationClass, TokenInformation, TokenInformationLength, ReturnLength );
5291 }
5292
5293 typedef BOOL WINAPI FN_SetTokenInformation( HANDLE TokenHandle, TOKEN_INFORMATION_CLASS TokenInformationClass, LPVOID TokenInformation, DWORD TokenInformationLength );
5294 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetTokenInformation( HANDLE TokenHandle, TOKEN_INFORMATION_CLASS TokenInformationClass, LPVOID TokenInformation, DWORD TokenInformationLength )
5295 {
5296     static FN_SetTokenInformation *pfn = 0;
5297     if (!pfn)
5298         kPrf2WrapResolve((void **)&pfn, "SetTokenInformation", &g_Kernel32);
5299     return pfn( TokenHandle, TokenInformationClass, TokenInformation, TokenInformationLength );
5300 }
5301
5302 typedef BOOL WINAPI FN_AdjustTokenPrivileges( HANDLE TokenHandle, BOOL DisableAllPrivileges, PTOKEN_PRIVILEGES NewState, DWORD BufferLength, PTOKEN_PRIVILEGES PreviousState, PDWORD ReturnLength );
5303 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_AdjustTokenPrivileges( HANDLE TokenHandle, BOOL DisableAllPrivileges, PTOKEN_PRIVILEGES NewState, DWORD BufferLength, PTOKEN_PRIVILEGES PreviousState, PDWORD ReturnLength )
5304 {
5305     static FN_AdjustTokenPrivileges *pfn = 0;
5306     if (!pfn)
5307         kPrf2WrapResolve((void **)&pfn, "AdjustTokenPrivileges", &g_Kernel32);
5308     return pfn( TokenHandle, DisableAllPrivileges, NewState, BufferLength, PreviousState, ReturnLength );
5309 }
5310
5311 typedef BOOL WINAPI FN_AdjustTokenGroups( HANDLE TokenHandle, BOOL ResetToDefault, PTOKEN_GROUPS NewState, DWORD BufferLength, PTOKEN_GROUPS PreviousState, PDWORD ReturnLength );
5312 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_AdjustTokenGroups( HANDLE TokenHandle, BOOL ResetToDefault, PTOKEN_GROUPS NewState, DWORD BufferLength, PTOKEN_GROUPS PreviousState, PDWORD ReturnLength )
5313 {
5314     static FN_AdjustTokenGroups *pfn = 0;
5315     if (!pfn)
5316         kPrf2WrapResolve((void **)&pfn, "AdjustTokenGroups", &g_Kernel32);
5317     return pfn( TokenHandle, ResetToDefault, NewState, BufferLength, PreviousState, ReturnLength );
5318 }
5319
5320 typedef BOOL WINAPI FN_PrivilegeCheck( HANDLE ClientToken, PPRIVILEGE_SET RequiredPrivileges, LPBOOL pfResult );
5321 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_PrivilegeCheck( HANDLE ClientToken, PPRIVILEGE_SET RequiredPrivileges, LPBOOL pfResult )
5322 {
5323     static FN_PrivilegeCheck *pfn = 0;
5324     if (!pfn)
5325         kPrf2WrapResolve((void **)&pfn, "PrivilegeCheck", &g_Kernel32);
5326     return pfn( ClientToken, RequiredPrivileges, pfResult );
5327 }
5328
5329 typedef BOOL WINAPI FN_AccessCheckAndAuditAlarmA( LPCSTR SubsystemName, LPVOID HandleId, LPSTR ObjectTypeName, LPSTR ObjectName, PSECURITY_DESCRIPTOR SecurityDescriptor, DWORD DesiredAccess, PGENERIC_MAPPING GenericMapping, BOOL ObjectCreation, LPDWORD GrantedAccess, LPBOOL AccessStatus, LPBOOL pfGenerateOnClose );
5330 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_AccessCheckAndAuditAlarmA( LPCSTR SubsystemName, LPVOID HandleId, LPSTR ObjectTypeName, LPSTR ObjectName, PSECURITY_DESCRIPTOR SecurityDescriptor, DWORD DesiredAccess, PGENERIC_MAPPING GenericMapping, BOOL ObjectCreation, LPDWORD GrantedAccess, LPBOOL AccessStatus, LPBOOL pfGenerateOnClose )
5331 {
5332     static FN_AccessCheckAndAuditAlarmA *pfn = 0;
5333     if (!pfn)
5334         kPrf2WrapResolve((void **)&pfn, "AccessCheckAndAuditAlarmA", &g_Kernel32);
5335     return pfn( SubsystemName, HandleId, ObjectTypeName, ObjectName, SecurityDescriptor, DesiredAccess, GenericMapping, ObjectCreation, GrantedAccess, AccessStatus, pfGenerateOnClose );
5336 }
5337
5338 typedef BOOL WINAPI FN_AccessCheckAndAuditAlarmW( LPCWSTR SubsystemName, LPVOID HandleId, LPWSTR ObjectTypeName, LPWSTR ObjectName, PSECURITY_DESCRIPTOR SecurityDescriptor, DWORD DesiredAccess, PGENERIC_MAPPING GenericMapping, BOOL ObjectCreation, LPDWORD GrantedAccess, LPBOOL AccessStatus, LPBOOL pfGenerateOnClose );
5339 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_AccessCheckAndAuditAlarmW( LPCWSTR SubsystemName, LPVOID HandleId, LPWSTR ObjectTypeName, LPWSTR ObjectName, PSECURITY_DESCRIPTOR SecurityDescriptor, DWORD DesiredAccess, PGENERIC_MAPPING GenericMapping, BOOL ObjectCreation, LPDWORD GrantedAccess, LPBOOL AccessStatus, LPBOOL pfGenerateOnClose )
5340 {
5341     static FN_AccessCheckAndAuditAlarmW *pfn = 0;
5342     if (!pfn)
5343         kPrf2WrapResolve((void **)&pfn, "AccessCheckAndAuditAlarmW", &g_Kernel32);
5344     return pfn( SubsystemName, HandleId, ObjectTypeName, ObjectName, SecurityDescriptor, DesiredAccess, GenericMapping, ObjectCreation, GrantedAccess, AccessStatus, pfGenerateOnClose );
5345 }
5346
5347 typedef BOOL WINAPI FN_AccessCheckByTypeAndAuditAlarmA( LPCSTR SubsystemName, LPVOID HandleId, LPCSTR ObjectTypeName, LPCSTR ObjectName, PSECURITY_DESCRIPTOR SecurityDescriptor, PSID PrincipalSelfSid, DWORD DesiredAccess, AUDIT_EVENT_TYPE AuditType, DWORD Flags, POBJECT_TYPE_LIST ObjectTypeList, DWORD ObjectTypeListLength, PGENERIC_MAPPING GenericMapping, BOOL ObjectCreation, LPDWORD GrantedAccess, LPBOOL AccessStatus, LPBOOL pfGenerateOnClose );
5348 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_AccessCheckByTypeAndAuditAlarmA( LPCSTR SubsystemName, LPVOID HandleId, LPCSTR ObjectTypeName, LPCSTR ObjectName, PSECURITY_DESCRIPTOR SecurityDescriptor, PSID PrincipalSelfSid, DWORD DesiredAccess, AUDIT_EVENT_TYPE AuditType, DWORD Flags, POBJECT_TYPE_LIST ObjectTypeList, DWORD ObjectTypeListLength, PGENERIC_MAPPING GenericMapping, BOOL ObjectCreation, LPDWORD GrantedAccess, LPBOOL AccessStatus, LPBOOL pfGenerateOnClose )
5349 {
5350     static FN_AccessCheckByTypeAndAuditAlarmA *pfn = 0;
5351     if (!pfn)
5352         kPrf2WrapResolve((void **)&pfn, "AccessCheckByTypeAndAuditAlarmA", &g_Kernel32);
5353     return pfn( SubsystemName, HandleId, ObjectTypeName, ObjectName, SecurityDescriptor, PrincipalSelfSid, DesiredAccess, AuditType, Flags, ObjectTypeList, ObjectTypeListLength, GenericMapping, ObjectCreation, GrantedAccess, AccessStatus, pfGenerateOnClose );
5354 }
5355
5356 typedef BOOL WINAPI FN_AccessCheckByTypeAndAuditAlarmW( LPCWSTR SubsystemName, LPVOID HandleId, LPCWSTR ObjectTypeName, LPCWSTR ObjectName, PSECURITY_DESCRIPTOR SecurityDescriptor, PSID PrincipalSelfSid, DWORD DesiredAccess, AUDIT_EVENT_TYPE AuditType, DWORD Flags, POBJECT_TYPE_LIST ObjectTypeList, DWORD ObjectTypeListLength, PGENERIC_MAPPING GenericMapping, BOOL ObjectCreation, LPDWORD GrantedAccess, LPBOOL AccessStatus, LPBOOL pfGenerateOnClose );
5357 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_AccessCheckByTypeAndAuditAlarmW( LPCWSTR SubsystemName, LPVOID HandleId, LPCWSTR ObjectTypeName, LPCWSTR ObjectName, PSECURITY_DESCRIPTOR SecurityDescriptor, PSID PrincipalSelfSid, DWORD DesiredAccess, AUDIT_EVENT_TYPE AuditType, DWORD Flags, POBJECT_TYPE_LIST ObjectTypeList, DWORD ObjectTypeListLength, PGENERIC_MAPPING GenericMapping, BOOL ObjectCreation, LPDWORD GrantedAccess, LPBOOL AccessStatus, LPBOOL pfGenerateOnClose )
5358 {
5359     static FN_AccessCheckByTypeAndAuditAlarmW *pfn = 0;
5360     if (!pfn)
5361         kPrf2WrapResolve((void **)&pfn, "AccessCheckByTypeAndAuditAlarmW", &g_Kernel32);
5362     return pfn( SubsystemName, HandleId, ObjectTypeName, ObjectName, SecurityDescriptor, PrincipalSelfSid, DesiredAccess, AuditType, Flags, ObjectTypeList, ObjectTypeListLength, GenericMapping, ObjectCreation, GrantedAccess, AccessStatus, pfGenerateOnClose );
5363 }
5364
5365 typedef BOOL WINAPI FN_AccessCheckByTypeResultListAndAuditAlarmA( LPCSTR SubsystemName, LPVOID HandleId, LPCSTR ObjectTypeName, LPCSTR ObjectName, PSECURITY_DESCRIPTOR SecurityDescriptor, PSID PrincipalSelfSid, DWORD DesiredAccess, AUDIT_EVENT_TYPE AuditType, DWORD Flags, POBJECT_TYPE_LIST ObjectTypeList, DWORD ObjectTypeListLength, PGENERIC_MAPPING GenericMapping, BOOL ObjectCreation, LPDWORD GrantedAccess, LPDWORD AccessStatusList, LPBOOL pfGenerateOnClose );
5366 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_AccessCheckByTypeResultListAndAuditAlarmA( LPCSTR SubsystemName, LPVOID HandleId, LPCSTR ObjectTypeName, LPCSTR ObjectName, PSECURITY_DESCRIPTOR SecurityDescriptor, PSID PrincipalSelfSid, DWORD DesiredAccess, AUDIT_EVENT_TYPE AuditType, DWORD Flags, POBJECT_TYPE_LIST ObjectTypeList, DWORD ObjectTypeListLength, PGENERIC_MAPPING GenericMapping, BOOL ObjectCreation, LPDWORD GrantedAccess, LPDWORD AccessStatusList, LPBOOL pfGenerateOnClose )
5367 {
5368     static FN_AccessCheckByTypeResultListAndAuditAlarmA *pfn = 0;
5369     if (!pfn)
5370         kPrf2WrapResolve((void **)&pfn, "AccessCheckByTypeResultListAndAuditAlarmA", &g_Kernel32);
5371     return pfn( SubsystemName, HandleId, ObjectTypeName, ObjectName, SecurityDescriptor, PrincipalSelfSid, DesiredAccess, AuditType, Flags, ObjectTypeList, ObjectTypeListLength, GenericMapping, ObjectCreation, GrantedAccess, AccessStatusList, pfGenerateOnClose );
5372 }
5373
5374 typedef BOOL WINAPI FN_AccessCheckByTypeResultListAndAuditAlarmW( LPCWSTR SubsystemName, LPVOID HandleId, LPCWSTR ObjectTypeName, LPCWSTR ObjectName, PSECURITY_DESCRIPTOR SecurityDescriptor, PSID PrincipalSelfSid, DWORD DesiredAccess, AUDIT_EVENT_TYPE AuditType, DWORD Flags, POBJECT_TYPE_LIST ObjectTypeList, DWORD ObjectTypeListLength, PGENERIC_MAPPING GenericMapping, BOOL ObjectCreation, LPDWORD GrantedAccess, LPDWORD AccessStatusList, LPBOOL pfGenerateOnClose );
5375 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_AccessCheckByTypeResultListAndAuditAlarmW( LPCWSTR SubsystemName, LPVOID HandleId, LPCWSTR ObjectTypeName, LPCWSTR ObjectName, PSECURITY_DESCRIPTOR SecurityDescriptor, PSID PrincipalSelfSid, DWORD DesiredAccess, AUDIT_EVENT_TYPE AuditType, DWORD Flags, POBJECT_TYPE_LIST ObjectTypeList, DWORD ObjectTypeListLength, PGENERIC_MAPPING GenericMapping, BOOL ObjectCreation, LPDWORD GrantedAccess, LPDWORD AccessStatusList, LPBOOL pfGenerateOnClose )
5376 {
5377     static FN_AccessCheckByTypeResultListAndAuditAlarmW *pfn = 0;
5378     if (!pfn)
5379         kPrf2WrapResolve((void **)&pfn, "AccessCheckByTypeResultListAndAuditAlarmW", &g_Kernel32);
5380     return pfn( SubsystemName, HandleId, ObjectTypeName, ObjectName, SecurityDescriptor, PrincipalSelfSid, DesiredAccess, AuditType, Flags, ObjectTypeList, ObjectTypeListLength, GenericMapping, ObjectCreation, GrantedAccess, AccessStatusList, pfGenerateOnClose );
5381 }
5382
5383 typedef BOOL WINAPI FN_AccessCheckByTypeResultListAndAuditAlarmByHandleA( LPCSTR SubsystemName, LPVOID HandleId, HANDLE ClientToken, LPCSTR ObjectTypeName, LPCSTR ObjectName, PSECURITY_DESCRIPTOR SecurityDescriptor, PSID PrincipalSelfSid, DWORD DesiredAccess, AUDIT_EVENT_TYPE AuditType, DWORD Flags, POBJECT_TYPE_LIST ObjectTypeList, DWORD ObjectTypeListLength, PGENERIC_MAPPING GenericMapping, BOOL ObjectCreation, LPDWORD GrantedAccess, LPDWORD AccessStatusList, LPBOOL pfGenerateOnClose );
5384 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_AccessCheckByTypeResultListAndAuditAlarmByHandleA( LPCSTR SubsystemName, LPVOID HandleId, HANDLE ClientToken, LPCSTR ObjectTypeName, LPCSTR ObjectName, PSECURITY_DESCRIPTOR SecurityDescriptor, PSID PrincipalSelfSid, DWORD DesiredAccess, AUDIT_EVENT_TYPE AuditType, DWORD Flags, POBJECT_TYPE_LIST ObjectTypeList, DWORD ObjectTypeListLength, PGENERIC_MAPPING GenericMapping, BOOL ObjectCreation, LPDWORD GrantedAccess, LPDWORD AccessStatusList, LPBOOL pfGenerateOnClose )
5385 {
5386     static FN_AccessCheckByTypeResultListAndAuditAlarmByHandleA *pfn = 0;
5387     if (!pfn)
5388         kPrf2WrapResolve((void **)&pfn, "AccessCheckByTypeResultListAndAuditAlarmByHandleA", &g_Kernel32);
5389     return pfn( SubsystemName, HandleId, ClientToken, ObjectTypeName, ObjectName, SecurityDescriptor, PrincipalSelfSid, DesiredAccess, AuditType, Flags, ObjectTypeList, ObjectTypeListLength, GenericMapping, ObjectCreation, GrantedAccess, AccessStatusList, pfGenerateOnClose );
5390 }
5391
5392 typedef BOOL WINAPI FN_AccessCheckByTypeResultListAndAuditAlarmByHandleW( LPCWSTR SubsystemName, LPVOID HandleId, HANDLE ClientToken, LPCWSTR ObjectTypeName, LPCWSTR ObjectName, PSECURITY_DESCRIPTOR SecurityDescriptor, PSID PrincipalSelfSid, DWORD DesiredAccess, AUDIT_EVENT_TYPE AuditType, DWORD Flags, POBJECT_TYPE_LIST ObjectTypeList, DWORD ObjectTypeListLength, PGENERIC_MAPPING GenericMapping, BOOL ObjectCreation, LPDWORD GrantedAccess, LPDWORD AccessStatusList, LPBOOL pfGenerateOnClose );
5393 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_AccessCheckByTypeResultListAndAuditAlarmByHandleW( LPCWSTR SubsystemName, LPVOID HandleId, HANDLE ClientToken, LPCWSTR ObjectTypeName, LPCWSTR ObjectName, PSECURITY_DESCRIPTOR SecurityDescriptor, PSID PrincipalSelfSid, DWORD DesiredAccess, AUDIT_EVENT_TYPE AuditType, DWORD Flags, POBJECT_TYPE_LIST ObjectTypeList, DWORD ObjectTypeListLength, PGENERIC_MAPPING GenericMapping, BOOL ObjectCreation, LPDWORD GrantedAccess, LPDWORD AccessStatusList, LPBOOL pfGenerateOnClose )
5394 {
5395     static FN_AccessCheckByTypeResultListAndAuditAlarmByHandleW *pfn = 0;
5396     if (!pfn)
5397         kPrf2WrapResolve((void **)&pfn, "AccessCheckByTypeResultListAndAuditAlarmByHandleW", &g_Kernel32);
5398     return pfn( SubsystemName, HandleId, ClientToken, ObjectTypeName, ObjectName, SecurityDescriptor, PrincipalSelfSid, DesiredAccess, AuditType, Flags, ObjectTypeList, ObjectTypeListLength, GenericMapping, ObjectCreation, GrantedAccess, AccessStatusList, pfGenerateOnClose );
5399 }
5400
5401 typedef BOOL WINAPI FN_ObjectOpenAuditAlarmA( LPCSTR SubsystemName, LPVOID HandleId, LPSTR ObjectTypeName, LPSTR ObjectName, PSECURITY_DESCRIPTOR pSecurityDescriptor, HANDLE ClientToken, DWORD DesiredAccess, DWORD GrantedAccess, PPRIVILEGE_SET Privileges, BOOL ObjectCreation, BOOL AccessGranted, LPBOOL GenerateOnClose );
5402 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_ObjectOpenAuditAlarmA( LPCSTR SubsystemName, LPVOID HandleId, LPSTR ObjectTypeName, LPSTR ObjectName, PSECURITY_DESCRIPTOR pSecurityDescriptor, HANDLE ClientToken, DWORD DesiredAccess, DWORD GrantedAccess, PPRIVILEGE_SET Privileges, BOOL ObjectCreation, BOOL AccessGranted, LPBOOL GenerateOnClose )
5403 {
5404     static FN_ObjectOpenAuditAlarmA *pfn = 0;
5405     if (!pfn)
5406         kPrf2WrapResolve((void **)&pfn, "ObjectOpenAuditAlarmA", &g_Kernel32);
5407     return pfn( SubsystemName, HandleId, ObjectTypeName, ObjectName, pSecurityDescriptor, ClientToken, DesiredAccess, GrantedAccess, Privileges, ObjectCreation, AccessGranted, GenerateOnClose );
5408 }
5409
5410 typedef BOOL WINAPI FN_ObjectOpenAuditAlarmW( LPCWSTR SubsystemName, LPVOID HandleId, LPWSTR ObjectTypeName, LPWSTR ObjectName, PSECURITY_DESCRIPTOR pSecurityDescriptor, HANDLE ClientToken, DWORD DesiredAccess, DWORD GrantedAccess, PPRIVILEGE_SET Privileges, BOOL ObjectCreation, BOOL AccessGranted, LPBOOL GenerateOnClose );
5411 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_ObjectOpenAuditAlarmW( LPCWSTR SubsystemName, LPVOID HandleId, LPWSTR ObjectTypeName, LPWSTR ObjectName, PSECURITY_DESCRIPTOR pSecurityDescriptor, HANDLE ClientToken, DWORD DesiredAccess, DWORD GrantedAccess, PPRIVILEGE_SET Privileges, BOOL ObjectCreation, BOOL AccessGranted, LPBOOL GenerateOnClose )
5412 {
5413     static FN_ObjectOpenAuditAlarmW *pfn = 0;
5414     if (!pfn)
5415         kPrf2WrapResolve((void **)&pfn, "ObjectOpenAuditAlarmW", &g_Kernel32);
5416     return pfn( SubsystemName, HandleId, ObjectTypeName, ObjectName, pSecurityDescriptor, ClientToken, DesiredAccess, GrantedAccess, Privileges, ObjectCreation, AccessGranted, GenerateOnClose );
5417 }
5418
5419 typedef BOOL WINAPI FN_ObjectPrivilegeAuditAlarmA( LPCSTR SubsystemName, LPVOID HandleId, HANDLE ClientToken, DWORD DesiredAccess, PPRIVILEGE_SET Privileges, BOOL AccessGranted );
5420 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_ObjectPrivilegeAuditAlarmA( LPCSTR SubsystemName, LPVOID HandleId, HANDLE ClientToken, DWORD DesiredAccess, PPRIVILEGE_SET Privileges, BOOL AccessGranted )
5421 {
5422     static FN_ObjectPrivilegeAuditAlarmA *pfn = 0;
5423     if (!pfn)
5424         kPrf2WrapResolve((void **)&pfn, "ObjectPrivilegeAuditAlarmA", &g_Kernel32);
5425     return pfn( SubsystemName, HandleId, ClientToken, DesiredAccess, Privileges, AccessGranted );
5426 }
5427
5428 typedef BOOL WINAPI FN_ObjectPrivilegeAuditAlarmW( LPCWSTR SubsystemName, LPVOID HandleId, HANDLE ClientToken, DWORD DesiredAccess, PPRIVILEGE_SET Privileges, BOOL AccessGranted );
5429 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_ObjectPrivilegeAuditAlarmW( LPCWSTR SubsystemName, LPVOID HandleId, HANDLE ClientToken, DWORD DesiredAccess, PPRIVILEGE_SET Privileges, BOOL AccessGranted )
5430 {
5431     static FN_ObjectPrivilegeAuditAlarmW *pfn = 0;
5432     if (!pfn)
5433         kPrf2WrapResolve((void **)&pfn, "ObjectPrivilegeAuditAlarmW", &g_Kernel32);
5434     return pfn( SubsystemName, HandleId, ClientToken, DesiredAccess, Privileges, AccessGranted );
5435 }
5436
5437 typedef BOOL WINAPI FN_ObjectCloseAuditAlarmA( LPCSTR SubsystemName, LPVOID HandleId, BOOL GenerateOnClose );
5438 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_ObjectCloseAuditAlarmA( LPCSTR SubsystemName, LPVOID HandleId, BOOL GenerateOnClose )
5439 {
5440     static FN_ObjectCloseAuditAlarmA *pfn = 0;
5441     if (!pfn)
5442         kPrf2WrapResolve((void **)&pfn, "ObjectCloseAuditAlarmA", &g_Kernel32);
5443     return pfn( SubsystemName, HandleId, GenerateOnClose );
5444 }
5445
5446 typedef BOOL WINAPI FN_ObjectCloseAuditAlarmW( LPCWSTR SubsystemName, LPVOID HandleId, BOOL GenerateOnClose );
5447 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_ObjectCloseAuditAlarmW( LPCWSTR SubsystemName, LPVOID HandleId, BOOL GenerateOnClose )
5448 {
5449     static FN_ObjectCloseAuditAlarmW *pfn = 0;
5450     if (!pfn)
5451         kPrf2WrapResolve((void **)&pfn, "ObjectCloseAuditAlarmW", &g_Kernel32);
5452     return pfn( SubsystemName, HandleId, GenerateOnClose );
5453 }
5454
5455 typedef BOOL WINAPI FN_ObjectDeleteAuditAlarmA( LPCSTR SubsystemName, LPVOID HandleId, BOOL GenerateOnClose );
5456 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_ObjectDeleteAuditAlarmA( LPCSTR SubsystemName, LPVOID HandleId, BOOL GenerateOnClose )
5457 {
5458     static FN_ObjectDeleteAuditAlarmA *pfn = 0;
5459     if (!pfn)
5460         kPrf2WrapResolve((void **)&pfn, "ObjectDeleteAuditAlarmA", &g_Kernel32);
5461     return pfn( SubsystemName, HandleId, GenerateOnClose );
5462 }
5463
5464 typedef BOOL WINAPI FN_ObjectDeleteAuditAlarmW( LPCWSTR SubsystemName, LPVOID HandleId, BOOL GenerateOnClose );
5465 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_ObjectDeleteAuditAlarmW( LPCWSTR SubsystemName, LPVOID HandleId, BOOL GenerateOnClose )
5466 {
5467     static FN_ObjectDeleteAuditAlarmW *pfn = 0;
5468     if (!pfn)
5469         kPrf2WrapResolve((void **)&pfn, "ObjectDeleteAuditAlarmW", &g_Kernel32);
5470     return pfn( SubsystemName, HandleId, GenerateOnClose );
5471 }
5472
5473 typedef BOOL WINAPI FN_PrivilegedServiceAuditAlarmA( LPCSTR SubsystemName, LPCSTR ServiceName, HANDLE ClientToken, PPRIVILEGE_SET Privileges, BOOL AccessGranted );
5474 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_PrivilegedServiceAuditAlarmA( LPCSTR SubsystemName, LPCSTR ServiceName, HANDLE ClientToken, PPRIVILEGE_SET Privileges, BOOL AccessGranted )
5475 {
5476     static FN_PrivilegedServiceAuditAlarmA *pfn = 0;
5477     if (!pfn)
5478         kPrf2WrapResolve((void **)&pfn, "PrivilegedServiceAuditAlarmA", &g_Kernel32);
5479     return pfn( SubsystemName, ServiceName, ClientToken, Privileges, AccessGranted );
5480 }
5481
5482 typedef BOOL WINAPI FN_PrivilegedServiceAuditAlarmW( LPCWSTR SubsystemName, LPCWSTR ServiceName, HANDLE ClientToken, PPRIVILEGE_SET Privileges, BOOL AccessGranted );
5483 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_PrivilegedServiceAuditAlarmW( LPCWSTR SubsystemName, LPCWSTR ServiceName, HANDLE ClientToken, PPRIVILEGE_SET Privileges, BOOL AccessGranted )
5484 {
5485     static FN_PrivilegedServiceAuditAlarmW *pfn = 0;
5486     if (!pfn)
5487         kPrf2WrapResolve((void **)&pfn, "PrivilegedServiceAuditAlarmW", &g_Kernel32);
5488     return pfn( SubsystemName, ServiceName, ClientToken, Privileges, AccessGranted );
5489 }
5490
5491 typedef BOOL WINAPI FN_IsWellKnownSid( PSID pSid, WELL_KNOWN_SID_TYPE WellKnownSidType );
5492 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_IsWellKnownSid( PSID pSid, WELL_KNOWN_SID_TYPE WellKnownSidType )
5493 {
5494     static FN_IsWellKnownSid *pfn = 0;
5495     if (!pfn)
5496         kPrf2WrapResolve((void **)&pfn, "IsWellKnownSid", &g_Kernel32);
5497     return pfn( pSid, WellKnownSidType );
5498 }
5499
5500 typedef BOOL WINAPI FN_CreateWellKnownSid( WELL_KNOWN_SID_TYPE WellKnownSidType, PSID DomainSid, PSID pSid, DWORD * cbSid );
5501 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_CreateWellKnownSid( WELL_KNOWN_SID_TYPE WellKnownSidType, PSID DomainSid, PSID pSid, DWORD * cbSid )
5502 {
5503     static FN_CreateWellKnownSid *pfn = 0;
5504     if (!pfn)
5505         kPrf2WrapResolve((void **)&pfn, "CreateWellKnownSid", &g_Kernel32);
5506     return pfn( WellKnownSidType, DomainSid, pSid, cbSid );
5507 }
5508
5509 typedef BOOL WINAPI FN_EqualDomainSid( PSID pSid1, PSID pSid2, BOOL * pfEqual );
5510 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_EqualDomainSid( PSID pSid1, PSID pSid2, BOOL * pfEqual )
5511 {
5512     static FN_EqualDomainSid *pfn = 0;
5513     if (!pfn)
5514         kPrf2WrapResolve((void **)&pfn, "EqualDomainSid", &g_Kernel32);
5515     return pfn( pSid1, pSid2, pfEqual );
5516 }
5517
5518 typedef BOOL WINAPI FN_GetWindowsAccountDomainSid( PSID pSid, PSID pDomainSid, DWORD * cbDomainSid );
5519 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetWindowsAccountDomainSid( PSID pSid, PSID pDomainSid, DWORD * cbDomainSid )
5520 {
5521     static FN_GetWindowsAccountDomainSid *pfn = 0;
5522     if (!pfn)
5523         kPrf2WrapResolve((void **)&pfn, "GetWindowsAccountDomainSid", &g_Kernel32);
5524     return pfn( pSid, pDomainSid, cbDomainSid );
5525 }
5526
5527 typedef BOOL WINAPI FN_IsValidSid( PSID pSid );
5528 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_IsValidSid( PSID pSid )
5529 {
5530     static FN_IsValidSid *pfn = 0;
5531     if (!pfn)
5532         kPrf2WrapResolve((void **)&pfn, "IsValidSid", &g_Kernel32);
5533     return pfn( pSid );
5534 }
5535
5536 typedef BOOL WINAPI FN_EqualSid( PSID pSid1, PSID pSid2 );
5537 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_EqualSid( PSID pSid1, PSID pSid2 )
5538 {
5539     static FN_EqualSid *pfn = 0;
5540     if (!pfn)
5541         kPrf2WrapResolve((void **)&pfn, "EqualSid", &g_Kernel32);
5542     return pfn( pSid1, pSid2 );
5543 }
5544
5545 typedef BOOL WINAPI FN_EqualPrefixSid( PSID pSid1, PSID pSid2 );
5546 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_EqualPrefixSid( PSID pSid1, PSID pSid2 )
5547 {
5548     static FN_EqualPrefixSid *pfn = 0;
5549     if (!pfn)
5550         kPrf2WrapResolve((void **)&pfn, "EqualPrefixSid", &g_Kernel32);
5551     return pfn( pSid1, pSid2 );
5552 }
5553
5554 typedef DWORD WINAPI FN_GetSidLengthRequired( UCHAR nSubAuthorityCount );
5555 __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetSidLengthRequired( UCHAR nSubAuthorityCount )
5556 {
5557     static FN_GetSidLengthRequired *pfn = 0;
5558     if (!pfn)
5559         kPrf2WrapResolve((void **)&pfn, "GetSidLengthRequired", &g_Kernel32);
5560     return pfn( nSubAuthorityCount );
5561 }
5562
5563 typedef BOOL WINAPI FN_AllocateAndInitializeSid( PSID_IDENTIFIER_AUTHORITY pIdentifierAuthority, BYTE nSubAuthorityCount, DWORD nSubAuthority0, DWORD nSubAuthority1, DWORD nSubAuthority2, DWORD nSubAuthority3, DWORD nSubAuthority4, DWORD nSubAuthority5, DWORD nSubAuthority6, DWORD nSubAuthority7, PSID * pSid );
5564 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_AllocateAndInitializeSid( PSID_IDENTIFIER_AUTHORITY pIdentifierAuthority, BYTE nSubAuthorityCount, DWORD nSubAuthority0, DWORD nSubAuthority1, DWORD nSubAuthority2, DWORD nSubAuthority3, DWORD nSubAuthority4, DWORD nSubAuthority5, DWORD nSubAuthority6, DWORD nSubAuthority7, PSID * pSid )
5565 {
5566     static FN_AllocateAndInitializeSid *pfn = 0;
5567     if (!pfn)
5568         kPrf2WrapResolve((void **)&pfn, "AllocateAndInitializeSid", &g_Kernel32);
5569     return pfn( pIdentifierAuthority, nSubAuthorityCount, nSubAuthority0, nSubAuthority1, nSubAuthority2, nSubAuthority3, nSubAuthority4, nSubAuthority5, nSubAuthority6, nSubAuthority7, pSid );
5570 }
5571
5572 typedef PVOID WINAPI FN_FreeSid( PSID pSid );
5573 __declspec(dllexport) PVOID WINAPI kPrf2Wrap_FreeSid( PSID pSid )
5574 {
5575     static FN_FreeSid *pfn = 0;
5576     if (!pfn)
5577         kPrf2WrapResolve((void **)&pfn, "FreeSid", &g_Kernel32);
5578     return pfn( pSid );
5579 }
5580
5581 typedef BOOL WINAPI FN_InitializeSid( PSID Sid, PSID_IDENTIFIER_AUTHORITY pIdentifierAuthority, BYTE nSubAuthorityCount );
5582 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_InitializeSid( PSID Sid, PSID_IDENTIFIER_AUTHORITY pIdentifierAuthority, BYTE nSubAuthorityCount )
5583 {
5584     static FN_InitializeSid *pfn = 0;
5585     if (!pfn)
5586         kPrf2WrapResolve((void **)&pfn, "InitializeSid", &g_Kernel32);
5587     return pfn( Sid, pIdentifierAuthority, nSubAuthorityCount );
5588 }
5589
5590 typedef PSID_IDENTIFIER_AUTHORITY WINAPI FN_GetSidIdentifierAuthority( PSID pSid );
5591 __declspec(dllexport) PSID_IDENTIFIER_AUTHORITY WINAPI kPrf2Wrap_GetSidIdentifierAuthority( PSID pSid )
5592 {
5593     static FN_GetSidIdentifierAuthority *pfn = 0;
5594     if (!pfn)
5595         kPrf2WrapResolve((void **)&pfn, "GetSidIdentifierAuthority", &g_Kernel32);
5596     return pfn( pSid );
5597 }
5598
5599 typedef PDWORD WINAPI FN_GetSidSubAuthority( PSID pSid, DWORD nSubAuthority );
5600 __declspec(dllexport) PDWORD WINAPI kPrf2Wrap_GetSidSubAuthority( PSID pSid, DWORD nSubAuthority )
5601 {
5602     static FN_GetSidSubAuthority *pfn = 0;
5603     if (!pfn)
5604         kPrf2WrapResolve((void **)&pfn, "GetSidSubAuthority", &g_Kernel32);
5605     return pfn( pSid, nSubAuthority );
5606 }
5607
5608 typedef PUCHAR WINAPI FN_GetSidSubAuthorityCount( PSID pSid );
5609 __declspec(dllexport) PUCHAR WINAPI kPrf2Wrap_GetSidSubAuthorityCount( PSID pSid )
5610 {
5611     static FN_GetSidSubAuthorityCount *pfn = 0;
5612     if (!pfn)
5613         kPrf2WrapResolve((void **)&pfn, "GetSidSubAuthorityCount", &g_Kernel32);
5614     return pfn( pSid );
5615 }
5616
5617 typedef DWORD WINAPI FN_GetLengthSid( PSID pSid );
5618 __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetLengthSid( PSID pSid )
5619 {
5620     static FN_GetLengthSid *pfn = 0;
5621     if (!pfn)
5622         kPrf2WrapResolve((void **)&pfn, "GetLengthSid", &g_Kernel32);
5623     return pfn( pSid );
5624 }
5625
5626 typedef BOOL WINAPI FN_CopySid( DWORD nDestinationSidLength, PSID pDestinationSid, PSID pSourceSid );
5627 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_CopySid( DWORD nDestinationSidLength, PSID pDestinationSid, PSID pSourceSid )
5628 {
5629     static FN_CopySid *pfn = 0;
5630     if (!pfn)
5631         kPrf2WrapResolve((void **)&pfn, "CopySid", &g_Kernel32);
5632     return pfn( nDestinationSidLength, pDestinationSid, pSourceSid );
5633 }
5634
5635 typedef BOOL WINAPI FN_AreAllAccessesGranted( DWORD GrantedAccess, DWORD DesiredAccess );
5636 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_AreAllAccessesGranted( DWORD GrantedAccess, DWORD DesiredAccess )
5637 {
5638     static FN_AreAllAccessesGranted *pfn = 0;
5639     if (!pfn)
5640         kPrf2WrapResolve((void **)&pfn, "AreAllAccessesGranted", &g_Kernel32);
5641     return pfn( GrantedAccess, DesiredAccess );
5642 }
5643
5644 typedef BOOL WINAPI FN_AreAnyAccessesGranted( DWORD GrantedAccess, DWORD DesiredAccess );
5645 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_AreAnyAccessesGranted( DWORD GrantedAccess, DWORD DesiredAccess )
5646 {
5647     static FN_AreAnyAccessesGranted *pfn = 0;
5648     if (!pfn)
5649         kPrf2WrapResolve((void **)&pfn, "AreAnyAccessesGranted", &g_Kernel32);
5650     return pfn( GrantedAccess, DesiredAccess );
5651 }
5652
5653 typedef VOID WINAPI FN_MapGenericMask( PDWORD AccessMask, PGENERIC_MAPPING GenericMapping );
5654 __declspec(dllexport) VOID WINAPI kPrf2Wrap_MapGenericMask( PDWORD AccessMask, PGENERIC_MAPPING GenericMapping )
5655 {
5656     static FN_MapGenericMask *pfn = 0;
5657     if (!pfn)
5658         kPrf2WrapResolve((void **)&pfn, "MapGenericMask", &g_Kernel32);
5659     pfn( AccessMask, GenericMapping );
5660 }
5661
5662 typedef BOOL WINAPI FN_IsValidAcl( PACL pAcl );
5663 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_IsValidAcl( PACL pAcl )
5664 {
5665     static FN_IsValidAcl *pfn = 0;
5666     if (!pfn)
5667         kPrf2WrapResolve((void **)&pfn, "IsValidAcl", &g_Kernel32);
5668     return pfn( pAcl );
5669 }
5670
5671 typedef BOOL WINAPI FN_InitializeAcl( PACL pAcl, DWORD nAclLength, DWORD dwAclRevision );
5672 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_InitializeAcl( PACL pAcl, DWORD nAclLength, DWORD dwAclRevision )
5673 {
5674     static FN_InitializeAcl *pfn = 0;
5675     if (!pfn)
5676         kPrf2WrapResolve((void **)&pfn, "InitializeAcl", &g_Kernel32);
5677     return pfn( pAcl, nAclLength, dwAclRevision );
5678 }
5679
5680 typedef BOOL WINAPI FN_GetAclInformation( PACL pAcl, LPVOID pAclInformation, DWORD nAclInformationLength, ACL_INFORMATION_CLASS dwAclInformationClass );
5681 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetAclInformation( PACL pAcl, LPVOID pAclInformation, DWORD nAclInformationLength, ACL_INFORMATION_CLASS dwAclInformationClass )
5682 {
5683     static FN_GetAclInformation *pfn = 0;
5684     if (!pfn)
5685         kPrf2WrapResolve((void **)&pfn, "GetAclInformation", &g_Kernel32);
5686     return pfn( pAcl, pAclInformation, nAclInformationLength, dwAclInformationClass );
5687 }
5688
5689 typedef BOOL WINAPI FN_SetAclInformation( PACL pAcl, LPVOID pAclInformation, DWORD nAclInformationLength, ACL_INFORMATION_CLASS dwAclInformationClass );
5690 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetAclInformation( PACL pAcl, LPVOID pAclInformation, DWORD nAclInformationLength, ACL_INFORMATION_CLASS dwAclInformationClass )
5691 {
5692     static FN_SetAclInformation *pfn = 0;
5693     if (!pfn)
5694         kPrf2WrapResolve((void **)&pfn, "SetAclInformation", &g_Kernel32);
5695     return pfn( pAcl, pAclInformation, nAclInformationLength, dwAclInformationClass );
5696 }
5697
5698 typedef BOOL WINAPI FN_AddAce( PACL pAcl, DWORD dwAceRevision, DWORD dwStartingAceIndex, LPVOID pAceList, DWORD nAceListLength );
5699 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_AddAce( PACL pAcl, DWORD dwAceRevision, DWORD dwStartingAceIndex, LPVOID pAceList, DWORD nAceListLength )
5700 {
5701     static FN_AddAce *pfn = 0;
5702     if (!pfn)
5703         kPrf2WrapResolve((void **)&pfn, "AddAce", &g_Kernel32);
5704     return pfn( pAcl, dwAceRevision, dwStartingAceIndex, pAceList, nAceListLength );
5705 }
5706
5707 typedef BOOL WINAPI FN_DeleteAce( PACL pAcl, DWORD dwAceIndex );
5708 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_DeleteAce( PACL pAcl, DWORD dwAceIndex )
5709 {
5710     static FN_DeleteAce *pfn = 0;
5711     if (!pfn)
5712         kPrf2WrapResolve((void **)&pfn, "DeleteAce", &g_Kernel32);
5713     return pfn( pAcl, dwAceIndex );
5714 }
5715
5716 typedef BOOL WINAPI FN_GetAce( PACL pAcl, DWORD dwAceIndex, LPVOID * pAce );
5717 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetAce( PACL pAcl, DWORD dwAceIndex, LPVOID * pAce )
5718 {
5719     static FN_GetAce *pfn = 0;
5720     if (!pfn)
5721         kPrf2WrapResolve((void **)&pfn, "GetAce", &g_Kernel32);
5722     return pfn( pAcl, dwAceIndex, pAce );
5723 }
5724
5725 typedef BOOL WINAPI FN_AddAccessAllowedAce( PACL pAcl, DWORD dwAceRevision, DWORD AccessMask, PSID pSid );
5726 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_AddAccessAllowedAce( PACL pAcl, DWORD dwAceRevision, DWORD AccessMask, PSID pSid )
5727 {
5728     static FN_AddAccessAllowedAce *pfn = 0;
5729     if (!pfn)
5730         kPrf2WrapResolve((void **)&pfn, "AddAccessAllowedAce", &g_Kernel32);
5731     return pfn( pAcl, dwAceRevision, AccessMask, pSid );
5732 }
5733
5734 typedef BOOL WINAPI FN_AddAccessAllowedAceEx( PACL pAcl, DWORD dwAceRevision, DWORD AceFlags, DWORD AccessMask, PSID pSid );
5735 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_AddAccessAllowedAceEx( PACL pAcl, DWORD dwAceRevision, DWORD AceFlags, DWORD AccessMask, PSID pSid )
5736 {
5737     static FN_AddAccessAllowedAceEx *pfn = 0;
5738     if (!pfn)
5739         kPrf2WrapResolve((void **)&pfn, "AddAccessAllowedAceEx", &g_Kernel32);
5740     return pfn( pAcl, dwAceRevision, AceFlags, AccessMask, pSid );
5741 }
5742
5743 typedef BOOL WINAPI FN_AddAccessDeniedAce( PACL pAcl, DWORD dwAceRevision, DWORD AccessMask, PSID pSid );
5744 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_AddAccessDeniedAce( PACL pAcl, DWORD dwAceRevision, DWORD AccessMask, PSID pSid )
5745 {
5746     static FN_AddAccessDeniedAce *pfn = 0;
5747     if (!pfn)
5748         kPrf2WrapResolve((void **)&pfn, "AddAccessDeniedAce", &g_Kernel32);
5749     return pfn( pAcl, dwAceRevision, AccessMask, pSid );
5750 }
5751
5752 typedef BOOL WINAPI FN_AddAccessDeniedAceEx( PACL pAcl, DWORD dwAceRevision, DWORD AceFlags, DWORD AccessMask, PSID pSid );
5753 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_AddAccessDeniedAceEx( PACL pAcl, DWORD dwAceRevision, DWORD AceFlags, DWORD AccessMask, PSID pSid )
5754 {
5755     static FN_AddAccessDeniedAceEx *pfn = 0;
5756     if (!pfn)
5757         kPrf2WrapResolve((void **)&pfn, "AddAccessDeniedAceEx", &g_Kernel32);
5758     return pfn( pAcl, dwAceRevision, AceFlags, AccessMask, pSid );
5759 }
5760
5761 typedef BOOL WINAPI FN_AddAuditAccessAce( PACL pAcl, DWORD dwAceRevision, DWORD dwAccessMask, PSID pSid, BOOL bAuditSuccess, BOOL bAuditFailure );
5762 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_AddAuditAccessAce( PACL pAcl, DWORD dwAceRevision, DWORD dwAccessMask, PSID pSid, BOOL bAuditSuccess, BOOL bAuditFailure )
5763 {
5764     static FN_AddAuditAccessAce *pfn = 0;
5765     if (!pfn)
5766         kPrf2WrapResolve((void **)&pfn, "AddAuditAccessAce", &g_Kernel32);
5767     return pfn( pAcl, dwAceRevision, dwAccessMask, pSid, bAuditSuccess, bAuditFailure );
5768 }
5769
5770 typedef BOOL WINAPI FN_AddAuditAccessAceEx( PACL pAcl, DWORD dwAceRevision, DWORD AceFlags, DWORD dwAccessMask, PSID pSid, BOOL bAuditSuccess, BOOL bAuditFailure );
5771 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_AddAuditAccessAceEx( PACL pAcl, DWORD dwAceRevision, DWORD AceFlags, DWORD dwAccessMask, PSID pSid, BOOL bAuditSuccess, BOOL bAuditFailure )
5772 {
5773     static FN_AddAuditAccessAceEx *pfn = 0;
5774     if (!pfn)
5775         kPrf2WrapResolve((void **)&pfn, "AddAuditAccessAceEx", &g_Kernel32);
5776     return pfn( pAcl, dwAceRevision, AceFlags, dwAccessMask, pSid, bAuditSuccess, bAuditFailure );
5777 }
5778
5779 typedef BOOL WINAPI FN_AddAccessAllowedObjectAce( PACL pAcl, DWORD dwAceRevision, DWORD AceFlags, DWORD AccessMask, GUID * ObjectTypeGuid, GUID * InheritedObjectTypeGuid, PSID pSid );
5780 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_AddAccessAllowedObjectAce( PACL pAcl, DWORD dwAceRevision, DWORD AceFlags, DWORD AccessMask, GUID * ObjectTypeGuid, GUID * InheritedObjectTypeGuid, PSID pSid )
5781 {
5782     static FN_AddAccessAllowedObjectAce *pfn = 0;
5783     if (!pfn)
5784         kPrf2WrapResolve((void **)&pfn, "AddAccessAllowedObjectAce", &g_Kernel32);
5785     return pfn( pAcl, dwAceRevision, AceFlags, AccessMask, ObjectTypeGuid, InheritedObjectTypeGuid, pSid );
5786 }
5787
5788 typedef BOOL WINAPI FN_AddAccessDeniedObjectAce( PACL pAcl, DWORD dwAceRevision, DWORD AceFlags, DWORD AccessMask, GUID * ObjectTypeGuid, GUID * InheritedObjectTypeGuid, PSID pSid );
5789 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_AddAccessDeniedObjectAce( PACL pAcl, DWORD dwAceRevision, DWORD AceFlags, DWORD AccessMask, GUID * ObjectTypeGuid, GUID * InheritedObjectTypeGuid, PSID pSid )
5790 {
5791     static FN_AddAccessDeniedObjectAce *pfn = 0;
5792     if (!pfn)
5793         kPrf2WrapResolve((void **)&pfn, "AddAccessDeniedObjectAce", &g_Kernel32);
5794     return pfn( pAcl, dwAceRevision, AceFlags, AccessMask, ObjectTypeGuid, InheritedObjectTypeGuid, pSid );
5795 }
5796
5797 typedef BOOL WINAPI FN_AddAuditAccessObjectAce( PACL pAcl, DWORD dwAceRevision, DWORD AceFlags, DWORD AccessMask, GUID * ObjectTypeGuid, GUID * InheritedObjectTypeGuid, PSID pSid, BOOL bAuditSuccess, BOOL bAuditFailure );
5798 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_AddAuditAccessObjectAce( PACL pAcl, DWORD dwAceRevision, DWORD AceFlags, DWORD AccessMask, GUID * ObjectTypeGuid, GUID * InheritedObjectTypeGuid, PSID pSid, BOOL bAuditSuccess, BOOL bAuditFailure )
5799 {
5800     static FN_AddAuditAccessObjectAce *pfn = 0;
5801     if (!pfn)
5802         kPrf2WrapResolve((void **)&pfn, "AddAuditAccessObjectAce", &g_Kernel32);
5803     return pfn( pAcl, dwAceRevision, AceFlags, AccessMask, ObjectTypeGuid, InheritedObjectTypeGuid, pSid, bAuditSuccess, bAuditFailure );
5804 }
5805
5806 typedef BOOL WINAPI FN_FindFirstFreeAce( PACL pAcl, LPVOID * pAce );
5807 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_FindFirstFreeAce( PACL pAcl, LPVOID * pAce )
5808 {
5809     static FN_FindFirstFreeAce *pfn = 0;
5810     if (!pfn)
5811         kPrf2WrapResolve((void **)&pfn, "FindFirstFreeAce", &g_Kernel32);
5812     return pfn( pAcl, pAce );
5813 }
5814
5815 typedef BOOL WINAPI FN_InitializeSecurityDescriptor( PSECURITY_DESCRIPTOR pSecurityDescriptor, DWORD dwRevision );
5816 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_InitializeSecurityDescriptor( PSECURITY_DESCRIPTOR pSecurityDescriptor, DWORD dwRevision )
5817 {
5818     static FN_InitializeSecurityDescriptor *pfn = 0;
5819     if (!pfn)
5820         kPrf2WrapResolve((void **)&pfn, "InitializeSecurityDescriptor", &g_Kernel32);
5821     return pfn( pSecurityDescriptor, dwRevision );
5822 }
5823
5824 typedef BOOL WINAPI FN_IsValidSecurityDescriptor( PSECURITY_DESCRIPTOR pSecurityDescriptor );
5825 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_IsValidSecurityDescriptor( PSECURITY_DESCRIPTOR pSecurityDescriptor )
5826 {
5827     static FN_IsValidSecurityDescriptor *pfn = 0;
5828     if (!pfn)
5829         kPrf2WrapResolve((void **)&pfn, "IsValidSecurityDescriptor", &g_Kernel32);
5830     return pfn( pSecurityDescriptor );
5831 }
5832
5833 typedef DWORD WINAPI FN_GetSecurityDescriptorLength( PSECURITY_DESCRIPTOR pSecurityDescriptor );
5834 __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetSecurityDescriptorLength( PSECURITY_DESCRIPTOR pSecurityDescriptor )
5835 {
5836     static FN_GetSecurityDescriptorLength *pfn = 0;
5837     if (!pfn)
5838         kPrf2WrapResolve((void **)&pfn, "GetSecurityDescriptorLength", &g_Kernel32);
5839     return pfn( pSecurityDescriptor );
5840 }
5841
5842 typedef BOOL WINAPI FN_GetSecurityDescriptorControl( PSECURITY_DESCRIPTOR pSecurityDescriptor, PSECURITY_DESCRIPTOR_CONTROL pControl, LPDWORD lpdwRevision );
5843 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetSecurityDescriptorControl( PSECURITY_DESCRIPTOR pSecurityDescriptor, PSECURITY_DESCRIPTOR_CONTROL pControl, LPDWORD lpdwRevision )
5844 {
5845     static FN_GetSecurityDescriptorControl *pfn = 0;
5846     if (!pfn)
5847         kPrf2WrapResolve((void **)&pfn, "GetSecurityDescriptorControl", &g_Kernel32);
5848     return pfn( pSecurityDescriptor, pControl, lpdwRevision );
5849 }
5850
5851 typedef BOOL WINAPI FN_SetSecurityDescriptorControl( PSECURITY_DESCRIPTOR pSecurityDescriptor, SECURITY_DESCRIPTOR_CONTROL ControlBitsOfInterest, SECURITY_DESCRIPTOR_CONTROL ControlBitsToSet );
5852 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetSecurityDescriptorControl( PSECURITY_DESCRIPTOR pSecurityDescriptor, SECURITY_DESCRIPTOR_CONTROL ControlBitsOfInterest, SECURITY_DESCRIPTOR_CONTROL ControlBitsToSet )
5853 {
5854     static FN_SetSecurityDescriptorControl *pfn = 0;
5855     if (!pfn)
5856         kPrf2WrapResolve((void **)&pfn, "SetSecurityDescriptorControl", &g_Kernel32);
5857     return pfn( pSecurityDescriptor, ControlBitsOfInterest, ControlBitsToSet );
5858 }
5859
5860 typedef BOOL WINAPI FN_SetSecurityDescriptorDacl( PSECURITY_DESCRIPTOR pSecurityDescriptor, BOOL bDaclPresent, PACL pDacl, BOOL bDaclDefaulted );
5861 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetSecurityDescriptorDacl( PSECURITY_DESCRIPTOR pSecurityDescriptor, BOOL bDaclPresent, PACL pDacl, BOOL bDaclDefaulted )
5862 {
5863     static FN_SetSecurityDescriptorDacl *pfn = 0;
5864     if (!pfn)
5865         kPrf2WrapResolve((void **)&pfn, "SetSecurityDescriptorDacl", &g_Kernel32);
5866     return pfn( pSecurityDescriptor, bDaclPresent, pDacl, bDaclDefaulted );
5867 }
5868
5869 typedef BOOL WINAPI FN_GetSecurityDescriptorDacl( PSECURITY_DESCRIPTOR pSecurityDescriptor, LPBOOL lpbDaclPresent, PACL * pDacl, LPBOOL lpbDaclDefaulted );
5870 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetSecurityDescriptorDacl( PSECURITY_DESCRIPTOR pSecurityDescriptor, LPBOOL lpbDaclPresent, PACL * pDacl, LPBOOL lpbDaclDefaulted )
5871 {
5872     static FN_GetSecurityDescriptorDacl *pfn = 0;
5873     if (!pfn)
5874         kPrf2WrapResolve((void **)&pfn, "GetSecurityDescriptorDacl", &g_Kernel32);
5875     return pfn( pSecurityDescriptor, lpbDaclPresent, pDacl, lpbDaclDefaulted );
5876 }
5877
5878 typedef BOOL WINAPI FN_SetSecurityDescriptorSacl( PSECURITY_DESCRIPTOR pSecurityDescriptor, BOOL bSaclPresent, PACL pSacl, BOOL bSaclDefaulted );
5879 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetSecurityDescriptorSacl( PSECURITY_DESCRIPTOR pSecurityDescriptor, BOOL bSaclPresent, PACL pSacl, BOOL bSaclDefaulted )
5880 {
5881     static FN_SetSecurityDescriptorSacl *pfn = 0;
5882     if (!pfn)
5883         kPrf2WrapResolve((void **)&pfn, "SetSecurityDescriptorSacl", &g_Kernel32);
5884     return pfn( pSecurityDescriptor, bSaclPresent, pSacl, bSaclDefaulted );
5885 }
5886
5887 typedef BOOL WINAPI FN_GetSecurityDescriptorSacl( PSECURITY_DESCRIPTOR pSecurityDescriptor, LPBOOL lpbSaclPresent, PACL * pSacl, LPBOOL lpbSaclDefaulted );
5888 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetSecurityDescriptorSacl( PSECURITY_DESCRIPTOR pSecurityDescriptor, LPBOOL lpbSaclPresent, PACL * pSacl, LPBOOL lpbSaclDefaulted )
5889 {
5890     static FN_GetSecurityDescriptorSacl *pfn = 0;
5891     if (!pfn)
5892         kPrf2WrapResolve((void **)&pfn, "GetSecurityDescriptorSacl", &g_Kernel32);
5893     return pfn( pSecurityDescriptor, lpbSaclPresent, pSacl, lpbSaclDefaulted );
5894 }
5895
5896 typedef BOOL WINAPI FN_SetSecurityDescriptorOwner( PSECURITY_DESCRIPTOR pSecurityDescriptor, PSID pOwner, BOOL bOwnerDefaulted );
5897 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetSecurityDescriptorOwner( PSECURITY_DESCRIPTOR pSecurityDescriptor, PSID pOwner, BOOL bOwnerDefaulted )
5898 {
5899     static FN_SetSecurityDescriptorOwner *pfn = 0;
5900     if (!pfn)
5901         kPrf2WrapResolve((void **)&pfn, "SetSecurityDescriptorOwner", &g_Kernel32);
5902     return pfn( pSecurityDescriptor, pOwner, bOwnerDefaulted );
5903 }
5904
5905 typedef BOOL WINAPI FN_GetSecurityDescriptorOwner( PSECURITY_DESCRIPTOR pSecurityDescriptor, PSID * pOwner, LPBOOL lpbOwnerDefaulted );
5906 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetSecurityDescriptorOwner( PSECURITY_DESCRIPTOR pSecurityDescriptor, PSID * pOwner, LPBOOL lpbOwnerDefaulted )
5907 {
5908     static FN_GetSecurityDescriptorOwner *pfn = 0;
5909     if (!pfn)
5910         kPrf2WrapResolve((void **)&pfn, "GetSecurityDescriptorOwner", &g_Kernel32);
5911     return pfn( pSecurityDescriptor, pOwner, lpbOwnerDefaulted );
5912 }
5913
5914 typedef BOOL WINAPI FN_SetSecurityDescriptorGroup( PSECURITY_DESCRIPTOR pSecurityDescriptor, PSID pGroup, BOOL bGroupDefaulted );
5915 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetSecurityDescriptorGroup( PSECURITY_DESCRIPTOR pSecurityDescriptor, PSID pGroup, BOOL bGroupDefaulted )
5916 {
5917     static FN_SetSecurityDescriptorGroup *pfn = 0;
5918     if (!pfn)
5919         kPrf2WrapResolve((void **)&pfn, "SetSecurityDescriptorGroup", &g_Kernel32);
5920     return pfn( pSecurityDescriptor, pGroup, bGroupDefaulted );
5921 }
5922
5923 typedef BOOL WINAPI FN_GetSecurityDescriptorGroup( PSECURITY_DESCRIPTOR pSecurityDescriptor, PSID * pGroup, LPBOOL lpbGroupDefaulted );
5924 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetSecurityDescriptorGroup( PSECURITY_DESCRIPTOR pSecurityDescriptor, PSID * pGroup, LPBOOL lpbGroupDefaulted )
5925 {
5926     static FN_GetSecurityDescriptorGroup *pfn = 0;
5927     if (!pfn)
5928         kPrf2WrapResolve((void **)&pfn, "GetSecurityDescriptorGroup", &g_Kernel32);
5929     return pfn( pSecurityDescriptor, pGroup, lpbGroupDefaulted );
5930 }
5931
5932 typedef DWORD WINAPI FN_SetSecurityDescriptorRMControl( PSECURITY_DESCRIPTOR SecurityDescriptor, PUCHAR RMControl );
5933 __declspec(dllexport) DWORD WINAPI kPrf2Wrap_SetSecurityDescriptorRMControl( PSECURITY_DESCRIPTOR SecurityDescriptor, PUCHAR RMControl )
5934 {
5935     static FN_SetSecurityDescriptorRMControl *pfn = 0;
5936     if (!pfn)
5937         kPrf2WrapResolve((void **)&pfn, "SetSecurityDescriptorRMControl", &g_Kernel32);
5938     return pfn( SecurityDescriptor, RMControl );
5939 }
5940
5941 typedef DWORD WINAPI FN_GetSecurityDescriptorRMControl( PSECURITY_DESCRIPTOR SecurityDescriptor, PUCHAR RMControl );
5942 __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetSecurityDescriptorRMControl( PSECURITY_DESCRIPTOR SecurityDescriptor, PUCHAR RMControl )
5943 {
5944     static FN_GetSecurityDescriptorRMControl *pfn = 0;
5945     if (!pfn)
5946         kPrf2WrapResolve((void **)&pfn, "GetSecurityDescriptorRMControl", &g_Kernel32);
5947     return pfn( SecurityDescriptor, RMControl );
5948 }
5949
5950 typedef BOOL WINAPI FN_CreatePrivateObjectSecurity( PSECURITY_DESCRIPTOR ParentDescriptor, PSECURITY_DESCRIPTOR CreatorDescriptor, PSECURITY_DESCRIPTOR * NewDescriptor, BOOL IsDirectoryObject, HANDLE Token, PGENERIC_MAPPING GenericMapping );
5951 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_CreatePrivateObjectSecurity( PSECURITY_DESCRIPTOR ParentDescriptor, PSECURITY_DESCRIPTOR CreatorDescriptor, PSECURITY_DESCRIPTOR * NewDescriptor, BOOL IsDirectoryObject, HANDLE Token, PGENERIC_MAPPING GenericMapping )
5952 {
5953     static FN_CreatePrivateObjectSecurity *pfn = 0;
5954     if (!pfn)
5955         kPrf2WrapResolve((void **)&pfn, "CreatePrivateObjectSecurity", &g_Kernel32);
5956     return pfn( ParentDescriptor, CreatorDescriptor, NewDescriptor, IsDirectoryObject, Token, GenericMapping );
5957 }
5958
5959 typedef BOOL WINAPI FN_ConvertToAutoInheritPrivateObjectSecurity( PSECURITY_DESCRIPTOR ParentDescriptor, PSECURITY_DESCRIPTOR CurrentSecurityDescriptor, PSECURITY_DESCRIPTOR * NewSecurityDescriptor, GUID * ObjectType, BOOLEAN IsDirectoryObject, PGENERIC_MAPPING GenericMapping );
5960 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_ConvertToAutoInheritPrivateObjectSecurity( PSECURITY_DESCRIPTOR ParentDescriptor, PSECURITY_DESCRIPTOR CurrentSecurityDescriptor, PSECURITY_DESCRIPTOR * NewSecurityDescriptor, GUID * ObjectType, BOOLEAN IsDirectoryObject, PGENERIC_MAPPING GenericMapping )
5961 {
5962     static FN_ConvertToAutoInheritPrivateObjectSecurity *pfn = 0;
5963     if (!pfn)
5964         kPrf2WrapResolve((void **)&pfn, "ConvertToAutoInheritPrivateObjectSecurity", &g_Kernel32);
5965     return pfn( ParentDescriptor, CurrentSecurityDescriptor, NewSecurityDescriptor, ObjectType, IsDirectoryObject, GenericMapping );
5966 }
5967
5968 typedef BOOL WINAPI FN_CreatePrivateObjectSecurityEx( PSECURITY_DESCRIPTOR ParentDescriptor, PSECURITY_DESCRIPTOR CreatorDescriptor, PSECURITY_DESCRIPTOR * NewDescriptor, GUID * ObjectType, BOOL IsContainerObject, ULONG AutoInheritFlags, HANDLE Token, PGENERIC_MAPPING GenericMapping );
5969 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_CreatePrivateObjectSecurityEx( PSECURITY_DESCRIPTOR ParentDescriptor, PSECURITY_DESCRIPTOR CreatorDescriptor, PSECURITY_DESCRIPTOR * NewDescriptor, GUID * ObjectType, BOOL IsContainerObject, ULONG AutoInheritFlags, HANDLE Token, PGENERIC_MAPPING GenericMapping )
5970 {
5971     static FN_CreatePrivateObjectSecurityEx *pfn = 0;
5972     if (!pfn)
5973         kPrf2WrapResolve((void **)&pfn, "CreatePrivateObjectSecurityEx", &g_Kernel32);
5974     return pfn( ParentDescriptor, CreatorDescriptor, NewDescriptor, ObjectType, IsContainerObject, AutoInheritFlags, Token, GenericMapping );
5975 }
5976
5977 typedef BOOL WINAPI FN_CreatePrivateObjectSecurityWithMultipleInheritance( PSECURITY_DESCRIPTOR ParentDescriptor, PSECURITY_DESCRIPTOR CreatorDescriptor, PSECURITY_DESCRIPTOR * NewDescriptor, GUID * *ObjectTypes, ULONG GuidCount, BOOL IsContainerObject, ULONG AutoInheritFlags, HANDLE Token, PGENERIC_MAPPING GenericMapping );
5978 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_CreatePrivateObjectSecurityWithMultipleInheritance( PSECURITY_DESCRIPTOR ParentDescriptor, PSECURITY_DESCRIPTOR CreatorDescriptor, PSECURITY_DESCRIPTOR * NewDescriptor, GUID * *ObjectTypes, ULONG GuidCount, BOOL IsContainerObject, ULONG AutoInheritFlags, HANDLE Token, PGENERIC_MAPPING GenericMapping )
5979 {
5980     static FN_CreatePrivateObjectSecurityWithMultipleInheritance *pfn = 0;
5981     if (!pfn)
5982         kPrf2WrapResolve((void **)&pfn, "CreatePrivateObjectSecurityWithMultipleInheritance", &g_Kernel32);
5983     return pfn( ParentDescriptor, CreatorDescriptor, NewDescriptor, ObjectTypes, GuidCount, IsContainerObject, AutoInheritFlags, Token, GenericMapping );
5984 }
5985
5986 typedef BOOL WINAPI FN_SetPrivateObjectSecurity( SECURITY_INFORMATION SecurityInformation, PSECURITY_DESCRIPTOR ModificationDescriptor, PSECURITY_DESCRIPTOR * ObjectsSecurityDescriptor, PGENERIC_MAPPING GenericMapping, HANDLE Token );
5987 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetPrivateObjectSecurity( SECURITY_INFORMATION SecurityInformation, PSECURITY_DESCRIPTOR ModificationDescriptor, PSECURITY_DESCRIPTOR * ObjectsSecurityDescriptor, PGENERIC_MAPPING GenericMapping, HANDLE Token )
5988 {
5989     static FN_SetPrivateObjectSecurity *pfn = 0;
5990     if (!pfn)
5991         kPrf2WrapResolve((void **)&pfn, "SetPrivateObjectSecurity", &g_Kernel32);
5992     return pfn( SecurityInformation, ModificationDescriptor, ObjectsSecurityDescriptor, GenericMapping, Token );
5993 }
5994
5995 typedef BOOL WINAPI FN_SetPrivateObjectSecurityEx( SECURITY_INFORMATION SecurityInformation, PSECURITY_DESCRIPTOR ModificationDescriptor, PSECURITY_DESCRIPTOR * ObjectsSecurityDescriptor, ULONG AutoInheritFlags, PGENERIC_MAPPING GenericMapping, HANDLE Token );
5996 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetPrivateObjectSecurityEx( SECURITY_INFORMATION SecurityInformation, PSECURITY_DESCRIPTOR ModificationDescriptor, PSECURITY_DESCRIPTOR * ObjectsSecurityDescriptor, ULONG AutoInheritFlags, PGENERIC_MAPPING GenericMapping, HANDLE Token )
5997 {
5998     static FN_SetPrivateObjectSecurityEx *pfn = 0;
5999     if (!pfn)
6000         kPrf2WrapResolve((void **)&pfn, "SetPrivateObjectSecurityEx", &g_Kernel32);
6001     return pfn( SecurityInformation, ModificationDescriptor, ObjectsSecurityDescriptor, AutoInheritFlags, GenericMapping, Token );
6002 }
6003
6004 typedef BOOL WINAPI FN_GetPrivateObjectSecurity( PSECURITY_DESCRIPTOR ObjectDescriptor, SECURITY_INFORMATION SecurityInformation, PSECURITY_DESCRIPTOR ResultantDescriptor, DWORD DescriptorLength, PDWORD ReturnLength );
6005 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetPrivateObjectSecurity( PSECURITY_DESCRIPTOR ObjectDescriptor, SECURITY_INFORMATION SecurityInformation, PSECURITY_DESCRIPTOR ResultantDescriptor, DWORD DescriptorLength, PDWORD ReturnLength )
6006 {
6007     static FN_GetPrivateObjectSecurity *pfn = 0;
6008     if (!pfn)
6009         kPrf2WrapResolve((void **)&pfn, "GetPrivateObjectSecurity", &g_Kernel32);
6010     return pfn( ObjectDescriptor, SecurityInformation, ResultantDescriptor, DescriptorLength, ReturnLength );
6011 }
6012
6013 typedef BOOL WINAPI FN_DestroyPrivateObjectSecurity( PSECURITY_DESCRIPTOR * ObjectDescriptor );
6014 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_DestroyPrivateObjectSecurity( PSECURITY_DESCRIPTOR * ObjectDescriptor )
6015 {
6016     static FN_DestroyPrivateObjectSecurity *pfn = 0;
6017     if (!pfn)
6018         kPrf2WrapResolve((void **)&pfn, "DestroyPrivateObjectSecurity", &g_Kernel32);
6019     return pfn( ObjectDescriptor );
6020 }
6021
6022 typedef BOOL WINAPI FN_MakeSelfRelativeSD( PSECURITY_DESCRIPTOR pAbsoluteSecurityDescriptor, PSECURITY_DESCRIPTOR pSelfRelativeSecurityDescriptor, LPDWORD lpdwBufferLength );
6023 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_MakeSelfRelativeSD( PSECURITY_DESCRIPTOR pAbsoluteSecurityDescriptor, PSECURITY_DESCRIPTOR pSelfRelativeSecurityDescriptor, LPDWORD lpdwBufferLength )
6024 {
6025     static FN_MakeSelfRelativeSD *pfn = 0;
6026     if (!pfn)
6027         kPrf2WrapResolve((void **)&pfn, "MakeSelfRelativeSD", &g_Kernel32);
6028     return pfn( pAbsoluteSecurityDescriptor, pSelfRelativeSecurityDescriptor, lpdwBufferLength );
6029 }
6030
6031 typedef BOOL WINAPI FN_MakeAbsoluteSD( PSECURITY_DESCRIPTOR pSelfRelativeSecurityDescriptor, PSECURITY_DESCRIPTOR pAbsoluteSecurityDescriptor, LPDWORD lpdwAbsoluteSecurityDescriptorSize, PACL pDacl, LPDWORD lpdwDaclSize, PACL pSacl, LPDWORD lpdwSaclSize, PSID pOwner, LPDWORD lpdwOwnerSize, PSID pPrimaryGroup, LPDWORD lpdwPrimaryGroupSize );
6032 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_MakeAbsoluteSD( PSECURITY_DESCRIPTOR pSelfRelativeSecurityDescriptor, PSECURITY_DESCRIPTOR pAbsoluteSecurityDescriptor, LPDWORD lpdwAbsoluteSecurityDescriptorSize, PACL pDacl, LPDWORD lpdwDaclSize, PACL pSacl, LPDWORD lpdwSaclSize, PSID pOwner, LPDWORD lpdwOwnerSize, PSID pPrimaryGroup, LPDWORD lpdwPrimaryGroupSize )
6033 {
6034     static FN_MakeAbsoluteSD *pfn = 0;
6035     if (!pfn)
6036         kPrf2WrapResolve((void **)&pfn, "MakeAbsoluteSD", &g_Kernel32);
6037     return pfn( pSelfRelativeSecurityDescriptor, pAbsoluteSecurityDescriptor, lpdwAbsoluteSecurityDescriptorSize, pDacl, lpdwDaclSize, pSacl, lpdwSaclSize, pOwner, lpdwOwnerSize, pPrimaryGroup, lpdwPrimaryGroupSize );
6038 }
6039
6040 typedef BOOL WINAPI FN_MakeAbsoluteSD2( PSECURITY_DESCRIPTOR pSelfRelativeSecurityDescriptor, LPDWORD lpdwBufferSize );
6041 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_MakeAbsoluteSD2( PSECURITY_DESCRIPTOR pSelfRelativeSecurityDescriptor, LPDWORD lpdwBufferSize )
6042 {
6043     static FN_MakeAbsoluteSD2 *pfn = 0;
6044     if (!pfn)
6045         kPrf2WrapResolve((void **)&pfn, "MakeAbsoluteSD2", &g_Kernel32);
6046     return pfn( pSelfRelativeSecurityDescriptor, lpdwBufferSize );
6047 }
6048
6049 typedef BOOL WINAPI FN_SetFileSecurityA( LPCSTR lpFileName, SECURITY_INFORMATION SecurityInformation, PSECURITY_DESCRIPTOR pSecurityDescriptor );
6050 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetFileSecurityA( LPCSTR lpFileName, SECURITY_INFORMATION SecurityInformation, PSECURITY_DESCRIPTOR pSecurityDescriptor )
6051 {
6052     static FN_SetFileSecurityA *pfn = 0;
6053     if (!pfn)
6054         kPrf2WrapResolve((void **)&pfn, "SetFileSecurityA", &g_Kernel32);
6055     return pfn( lpFileName, SecurityInformation, pSecurityDescriptor );
6056 }
6057
6058 typedef BOOL WINAPI FN_SetFileSecurityW( LPCWSTR lpFileName, SECURITY_INFORMATION SecurityInformation, PSECURITY_DESCRIPTOR pSecurityDescriptor );
6059 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetFileSecurityW( LPCWSTR lpFileName, SECURITY_INFORMATION SecurityInformation, PSECURITY_DESCRIPTOR pSecurityDescriptor )
6060 {
6061     static FN_SetFileSecurityW *pfn = 0;
6062     if (!pfn)
6063         kPrf2WrapResolve((void **)&pfn, "SetFileSecurityW", &g_Kernel32);
6064     return pfn( lpFileName, SecurityInformation, pSecurityDescriptor );
6065 }
6066
6067 typedef BOOL WINAPI FN_GetFileSecurityA( LPCSTR lpFileName, SECURITY_INFORMATION RequestedInformation, PSECURITY_DESCRIPTOR pSecurityDescriptor, DWORD nLength, LPDWORD lpnLengthNeeded );
6068 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetFileSecurityA( LPCSTR lpFileName, SECURITY_INFORMATION RequestedInformation, PSECURITY_DESCRIPTOR pSecurityDescriptor, DWORD nLength, LPDWORD lpnLengthNeeded )
6069 {
6070     static FN_GetFileSecurityA *pfn = 0;
6071     if (!pfn)
6072         kPrf2WrapResolve((void **)&pfn, "GetFileSecurityA", &g_Kernel32);
6073     return pfn( lpFileName, RequestedInformation, pSecurityDescriptor, nLength, lpnLengthNeeded );
6074 }
6075
6076 typedef BOOL WINAPI FN_GetFileSecurityW( LPCWSTR lpFileName, SECURITY_INFORMATION RequestedInformation, PSECURITY_DESCRIPTOR pSecurityDescriptor, DWORD nLength, LPDWORD lpnLengthNeeded );
6077 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetFileSecurityW( LPCWSTR lpFileName, SECURITY_INFORMATION RequestedInformation, PSECURITY_DESCRIPTOR pSecurityDescriptor, DWORD nLength, LPDWORD lpnLengthNeeded )
6078 {
6079     static FN_GetFileSecurityW *pfn = 0;
6080     if (!pfn)
6081         kPrf2WrapResolve((void **)&pfn, "GetFileSecurityW", &g_Kernel32);
6082     return pfn( lpFileName, RequestedInformation, pSecurityDescriptor, nLength, lpnLengthNeeded );
6083 }
6084
6085 typedef BOOL WINAPI FN_SetKernelObjectSecurity( HANDLE Handle, SECURITY_INFORMATION SecurityInformation, PSECURITY_DESCRIPTOR SecurityDescriptor );
6086 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetKernelObjectSecurity( HANDLE Handle, SECURITY_INFORMATION SecurityInformation, PSECURITY_DESCRIPTOR SecurityDescriptor )
6087 {
6088     static FN_SetKernelObjectSecurity *pfn = 0;
6089     if (!pfn)
6090         kPrf2WrapResolve((void **)&pfn, "SetKernelObjectSecurity", &g_Kernel32);
6091     return pfn( Handle, SecurityInformation, SecurityDescriptor );
6092 }
6093
6094 typedef HANDLE WINAPI FN_FindFirstChangeNotificationA( LPCSTR lpPathName, BOOL bWatchSubtree, DWORD dwNotifyFilter );
6095 __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_FindFirstChangeNotificationA( LPCSTR lpPathName, BOOL bWatchSubtree, DWORD dwNotifyFilter )
6096 {
6097     static FN_FindFirstChangeNotificationA *pfn = 0;
6098     if (!pfn)
6099         kPrf2WrapResolve((void **)&pfn, "FindFirstChangeNotificationA", &g_Kernel32);
6100     return pfn( lpPathName, bWatchSubtree, dwNotifyFilter );
6101 }
6102
6103 typedef HANDLE WINAPI FN_FindFirstChangeNotificationW( LPCWSTR lpPathName, BOOL bWatchSubtree, DWORD dwNotifyFilter );
6104 __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_FindFirstChangeNotificationW( LPCWSTR lpPathName, BOOL bWatchSubtree, DWORD dwNotifyFilter )
6105 {
6106     static FN_FindFirstChangeNotificationW *pfn = 0;
6107     if (!pfn)
6108         kPrf2WrapResolve((void **)&pfn, "FindFirstChangeNotificationW", &g_Kernel32);
6109     return pfn( lpPathName, bWatchSubtree, dwNotifyFilter );
6110 }
6111
6112 typedef BOOL WINAPI FN_FindNextChangeNotification( HANDLE hChangeHandle );
6113 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_FindNextChangeNotification( HANDLE hChangeHandle )
6114 {
6115     static FN_FindNextChangeNotification *pfn = 0;
6116     if (!pfn)
6117         kPrf2WrapResolve((void **)&pfn, "FindNextChangeNotification", &g_Kernel32);
6118     return pfn( hChangeHandle );
6119 }
6120
6121 typedef BOOL WINAPI FN_FindCloseChangeNotification( HANDLE hChangeHandle );
6122 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_FindCloseChangeNotification( HANDLE hChangeHandle )
6123 {
6124     static FN_FindCloseChangeNotification *pfn = 0;
6125     if (!pfn)
6126         kPrf2WrapResolve((void **)&pfn, "FindCloseChangeNotification", &g_Kernel32);
6127     return pfn( hChangeHandle );
6128 }
6129
6130 typedef BOOL WINAPI FN_ReadDirectoryChangesW( HANDLE hDirectory, LPVOID lpBuffer, DWORD nBufferLength, BOOL bWatchSubtree, DWORD dwNotifyFilter, LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped, LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine );
6131 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_ReadDirectoryChangesW( HANDLE hDirectory, LPVOID lpBuffer, DWORD nBufferLength, BOOL bWatchSubtree, DWORD dwNotifyFilter, LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped, LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine )
6132 {
6133     static FN_ReadDirectoryChangesW *pfn = 0;
6134     if (!pfn)
6135         kPrf2WrapResolve((void **)&pfn, "ReadDirectoryChangesW", &g_Kernel32);
6136     return pfn( hDirectory, lpBuffer, nBufferLength, bWatchSubtree, dwNotifyFilter, lpBytesReturned, lpOverlapped, lpCompletionRoutine );
6137 }
6138
6139 typedef BOOL WINAPI FN_VirtualLock( LPVOID lpAddress, SIZE_T dwSize );
6140 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_VirtualLock( LPVOID lpAddress, SIZE_T dwSize )
6141 {
6142     static FN_VirtualLock *pfn = 0;
6143     if (!pfn)
6144         kPrf2WrapResolve((void **)&pfn, "VirtualLock", &g_Kernel32);
6145     return pfn( lpAddress, dwSize );
6146 }
6147
6148 typedef BOOL WINAPI FN_VirtualUnlock( LPVOID lpAddress, SIZE_T dwSize );
6149 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_VirtualUnlock( LPVOID lpAddress, SIZE_T dwSize )
6150 {
6151     static FN_VirtualUnlock *pfn = 0;
6152     if (!pfn)
6153         kPrf2WrapResolve((void **)&pfn, "VirtualUnlock", &g_Kernel32);
6154     return pfn( lpAddress, dwSize );
6155 }
6156
6157 typedef LPVOID WINAPI FN_MapViewOfFileEx( HANDLE hFileMappingObject, DWORD dwDesiredAccess, DWORD dwFileOffsetHigh, DWORD dwFileOffsetLow, SIZE_T dwNumberOfBytesToMap, LPVOID lpBaseAddress );
6158 __declspec(dllexport) LPVOID WINAPI kPrf2Wrap_MapViewOfFileEx( HANDLE hFileMappingObject, DWORD dwDesiredAccess, DWORD dwFileOffsetHigh, DWORD dwFileOffsetLow, SIZE_T dwNumberOfBytesToMap, LPVOID lpBaseAddress )
6159 {
6160     static FN_MapViewOfFileEx *pfn = 0;
6161     if (!pfn)
6162         kPrf2WrapResolve((void **)&pfn, "MapViewOfFileEx", &g_Kernel32);
6163     return pfn( hFileMappingObject, dwDesiredAccess, dwFileOffsetHigh, dwFileOffsetLow, dwNumberOfBytesToMap, lpBaseAddress );
6164 }
6165
6166 typedef BOOL WINAPI FN_SetPriorityClass( HANDLE hProcess, DWORD dwPriorityClass );
6167 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetPriorityClass( HANDLE hProcess, DWORD dwPriorityClass )
6168 {
6169     static FN_SetPriorityClass *pfn = 0;
6170     if (!pfn)
6171         kPrf2WrapResolve((void **)&pfn, "SetPriorityClass", &g_Kernel32);
6172     return pfn( hProcess, dwPriorityClass );
6173 }
6174
6175 typedef DWORD WINAPI FN_GetPriorityClass( HANDLE hProcess );
6176 __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetPriorityClass( HANDLE hProcess )
6177 {
6178     static FN_GetPriorityClass *pfn = 0;
6179     if (!pfn)
6180         kPrf2WrapResolve((void **)&pfn, "GetPriorityClass", &g_Kernel32);
6181     return pfn( hProcess );
6182 }
6183
6184 typedef BOOL WINAPI FN_IsBadReadPtr( CONST VOID * lp, UINT_PTR ucb );
6185 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_IsBadReadPtr( CONST VOID * lp, UINT_PTR ucb )
6186 {
6187     static FN_IsBadReadPtr *pfn = 0;
6188     if (!pfn)
6189         kPrf2WrapResolve((void **)&pfn, "IsBadReadPtr", &g_Kernel32);
6190     return pfn( lp, ucb );
6191 }
6192
6193 typedef BOOL WINAPI FN_IsBadWritePtr( LPVOID lp, UINT_PTR ucb );
6194 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_IsBadWritePtr( LPVOID lp, UINT_PTR ucb )
6195 {
6196     static FN_IsBadWritePtr *pfn = 0;
6197     if (!pfn)
6198         kPrf2WrapResolve((void **)&pfn, "IsBadWritePtr", &g_Kernel32);
6199     return pfn( lp, ucb );
6200 }
6201
6202 typedef BOOL WINAPI FN_IsBadHugeReadPtr( CONST VOID * lp, UINT_PTR ucb );
6203 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_IsBadHugeReadPtr( CONST VOID * lp, UINT_PTR ucb )
6204 {
6205     static FN_IsBadHugeReadPtr *pfn = 0;
6206     if (!pfn)
6207         kPrf2WrapResolve((void **)&pfn, "IsBadHugeReadPtr", &g_Kernel32);
6208     return pfn( lp, ucb );
6209 }
6210
6211 typedef BOOL WINAPI FN_IsBadHugeWritePtr( LPVOID lp, UINT_PTR ucb );
6212 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_IsBadHugeWritePtr( LPVOID lp, UINT_PTR ucb )
6213 {
6214     static FN_IsBadHugeWritePtr *pfn = 0;
6215     if (!pfn)
6216         kPrf2WrapResolve((void **)&pfn, "IsBadHugeWritePtr", &g_Kernel32);
6217     return pfn( lp, ucb );
6218 }
6219
6220 typedef BOOL WINAPI FN_IsBadCodePtr( FARPROC lpfn );
6221 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_IsBadCodePtr( FARPROC lpfn )
6222 {
6223     static FN_IsBadCodePtr *pfn = 0;
6224     if (!pfn)
6225         kPrf2WrapResolve((void **)&pfn, "IsBadCodePtr", &g_Kernel32);
6226     return pfn( lpfn );
6227 }
6228
6229 typedef BOOL WINAPI FN_IsBadStringPtrA( LPCSTR lpsz, UINT_PTR ucchMax );
6230 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_IsBadStringPtrA( LPCSTR lpsz, UINT_PTR ucchMax )
6231 {
6232     static FN_IsBadStringPtrA *pfn = 0;
6233     if (!pfn)
6234         kPrf2WrapResolve((void **)&pfn, "IsBadStringPtrA", &g_Kernel32);
6235     return pfn( lpsz, ucchMax );
6236 }
6237
6238 typedef BOOL WINAPI FN_IsBadStringPtrW( LPCWSTR lpsz, UINT_PTR ucchMax );
6239 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_IsBadStringPtrW( LPCWSTR lpsz, UINT_PTR ucchMax )
6240 {
6241     static FN_IsBadStringPtrW *pfn = 0;
6242     if (!pfn)
6243         kPrf2WrapResolve((void **)&pfn, "IsBadStringPtrW", &g_Kernel32);
6244     return pfn( lpsz, ucchMax );
6245 }
6246
6247 typedef BOOL WINAPI FN_LookupAccountSidA( LPCSTR lpSystemName, PSID Sid, LPSTR Name, LPDWORD cchName, LPSTR ReferencedDomainName, LPDWORD cchReferencedDomainName, PSID_NAME_USE peUse );
6248 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_LookupAccountSidA( LPCSTR lpSystemName, PSID Sid, LPSTR Name, LPDWORD cchName, LPSTR ReferencedDomainName, LPDWORD cchReferencedDomainName, PSID_NAME_USE peUse )
6249 {
6250     static FN_LookupAccountSidA *pfn = 0;
6251     if (!pfn)
6252         kPrf2WrapResolve((void **)&pfn, "LookupAccountSidA", &g_Kernel32);
6253     return pfn( lpSystemName, Sid, Name, cchName, ReferencedDomainName, cchReferencedDomainName, peUse );
6254 }
6255
6256 typedef BOOL WINAPI FN_LookupAccountSidW( LPCWSTR lpSystemName, PSID Sid, LPWSTR Name, LPDWORD cchName, LPWSTR ReferencedDomainName, LPDWORD cchReferencedDomainName, PSID_NAME_USE peUse );
6257 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_LookupAccountSidW( LPCWSTR lpSystemName, PSID Sid, LPWSTR Name, LPDWORD cchName, LPWSTR ReferencedDomainName, LPDWORD cchReferencedDomainName, PSID_NAME_USE peUse )
6258 {
6259     static FN_LookupAccountSidW *pfn = 0;
6260     if (!pfn)
6261         kPrf2WrapResolve((void **)&pfn, "LookupAccountSidW", &g_Kernel32);
6262     return pfn( lpSystemName, Sid, Name, cchName, ReferencedDomainName, cchReferencedDomainName, peUse );
6263 }
6264
6265 typedef BOOL WINAPI FN_LookupAccountNameA( LPCSTR lpSystemName, LPCSTR lpAccountName, PSID Sid, LPDWORD cbSid, LPSTR ReferencedDomainName, LPDWORD cchReferencedDomainName, PSID_NAME_USE peUse );
6266 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_LookupAccountNameA( LPCSTR lpSystemName, LPCSTR lpAccountName, PSID Sid, LPDWORD cbSid, LPSTR ReferencedDomainName, LPDWORD cchReferencedDomainName, PSID_NAME_USE peUse )
6267 {
6268     static FN_LookupAccountNameA *pfn = 0;
6269     if (!pfn)
6270         kPrf2WrapResolve((void **)&pfn, "LookupAccountNameA", &g_Kernel32);
6271     return pfn( lpSystemName, lpAccountName, Sid, cbSid, ReferencedDomainName, cchReferencedDomainName, peUse );
6272 }
6273
6274 typedef BOOL WINAPI FN_LookupAccountNameW( LPCWSTR lpSystemName, LPCWSTR lpAccountName, PSID Sid, LPDWORD cbSid, LPWSTR ReferencedDomainName, LPDWORD cchReferencedDomainName, PSID_NAME_USE peUse );
6275 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_LookupAccountNameW( LPCWSTR lpSystemName, LPCWSTR lpAccountName, PSID Sid, LPDWORD cbSid, LPWSTR ReferencedDomainName, LPDWORD cchReferencedDomainName, PSID_NAME_USE peUse )
6276 {
6277     static FN_LookupAccountNameW *pfn = 0;
6278     if (!pfn)
6279         kPrf2WrapResolve((void **)&pfn, "LookupAccountNameW", &g_Kernel32);
6280     return pfn( lpSystemName, lpAccountName, Sid, cbSid, ReferencedDomainName, cchReferencedDomainName, peUse );
6281 }
6282
6283 typedef BOOL WINAPI FN_LookupPrivilegeValueA( LPCSTR lpSystemName, LPCSTR lpName, PLUID lpLuid );
6284 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_LookupPrivilegeValueA( LPCSTR lpSystemName, LPCSTR lpName, PLUID lpLuid )
6285 {
6286     static FN_LookupPrivilegeValueA *pfn = 0;
6287     if (!pfn)
6288         kPrf2WrapResolve((void **)&pfn, "LookupPrivilegeValueA", &g_Kernel32);
6289     return pfn( lpSystemName, lpName, lpLuid );
6290 }
6291
6292 typedef BOOL WINAPI FN_LookupPrivilegeValueW( LPCWSTR lpSystemName, LPCWSTR lpName, PLUID lpLuid );
6293 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_LookupPrivilegeValueW( LPCWSTR lpSystemName, LPCWSTR lpName, PLUID lpLuid )
6294 {
6295     static FN_LookupPrivilegeValueW *pfn = 0;
6296     if (!pfn)
6297         kPrf2WrapResolve((void **)&pfn, "LookupPrivilegeValueW", &g_Kernel32);
6298     return pfn( lpSystemName, lpName, lpLuid );
6299 }
6300
6301 typedef BOOL WINAPI FN_LookupPrivilegeNameA( LPCSTR lpSystemName, PLUID lpLuid, LPSTR lpName, LPDWORD cchName );
6302 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_LookupPrivilegeNameA( LPCSTR lpSystemName, PLUID lpLuid, LPSTR lpName, LPDWORD cchName )
6303 {
6304     static FN_LookupPrivilegeNameA *pfn = 0;
6305     if (!pfn)
6306         kPrf2WrapResolve((void **)&pfn, "LookupPrivilegeNameA", &g_Kernel32);
6307     return pfn( lpSystemName, lpLuid, lpName, cchName );
6308 }
6309
6310 typedef BOOL WINAPI FN_LookupPrivilegeNameW( LPCWSTR lpSystemName, PLUID lpLuid, LPWSTR lpName, LPDWORD cchName );
6311 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_LookupPrivilegeNameW( LPCWSTR lpSystemName, PLUID lpLuid, LPWSTR lpName, LPDWORD cchName )
6312 {
6313     static FN_LookupPrivilegeNameW *pfn = 0;
6314     if (!pfn)
6315         kPrf2WrapResolve((void **)&pfn, "LookupPrivilegeNameW", &g_Kernel32);
6316     return pfn( lpSystemName, lpLuid, lpName, cchName );
6317 }
6318
6319 typedef BOOL WINAPI FN_LookupPrivilegeDisplayNameA( LPCSTR lpSystemName, LPCSTR lpName, LPSTR lpDisplayName, LPDWORD cchDisplayName, LPDWORD lpLanguageId );
6320 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_LookupPrivilegeDisplayNameA( LPCSTR lpSystemName, LPCSTR lpName, LPSTR lpDisplayName, LPDWORD cchDisplayName, LPDWORD lpLanguageId )
6321 {
6322     static FN_LookupPrivilegeDisplayNameA *pfn = 0;
6323     if (!pfn)
6324         kPrf2WrapResolve((void **)&pfn, "LookupPrivilegeDisplayNameA", &g_Kernel32);
6325     return pfn( lpSystemName, lpName, lpDisplayName, cchDisplayName, lpLanguageId );
6326 }
6327
6328 typedef BOOL WINAPI FN_LookupPrivilegeDisplayNameW( LPCWSTR lpSystemName, LPCWSTR lpName, LPWSTR lpDisplayName, LPDWORD cchDisplayName, LPDWORD lpLanguageId );
6329 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_LookupPrivilegeDisplayNameW( LPCWSTR lpSystemName, LPCWSTR lpName, LPWSTR lpDisplayName, LPDWORD cchDisplayName, LPDWORD lpLanguageId )
6330 {
6331     static FN_LookupPrivilegeDisplayNameW *pfn = 0;
6332     if (!pfn)
6333         kPrf2WrapResolve((void **)&pfn, "LookupPrivilegeDisplayNameW", &g_Kernel32);
6334     return pfn( lpSystemName, lpName, lpDisplayName, cchDisplayName, lpLanguageId );
6335 }
6336
6337 typedef BOOL WINAPI FN_AllocateLocallyUniqueId( PLUID Luid );
6338 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_AllocateLocallyUniqueId( PLUID Luid )
6339 {
6340     static FN_AllocateLocallyUniqueId *pfn = 0;
6341     if (!pfn)
6342         kPrf2WrapResolve((void **)&pfn, "AllocateLocallyUniqueId", &g_Kernel32);
6343     return pfn( Luid );
6344 }
6345
6346 typedef BOOL WINAPI FN_BuildCommDCBA( LPCSTR lpDef, LPDCB lpDCB );
6347 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_BuildCommDCBA( LPCSTR lpDef, LPDCB lpDCB )
6348 {
6349     static FN_BuildCommDCBA *pfn = 0;
6350     if (!pfn)
6351         kPrf2WrapResolve((void **)&pfn, "BuildCommDCBA", &g_Kernel32);
6352     return pfn( lpDef, lpDCB );
6353 }
6354
6355 typedef BOOL WINAPI FN_BuildCommDCBW( LPCWSTR lpDef, LPDCB lpDCB );
6356 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_BuildCommDCBW( LPCWSTR lpDef, LPDCB lpDCB )
6357 {
6358     static FN_BuildCommDCBW *pfn = 0;
6359     if (!pfn)
6360         kPrf2WrapResolve((void **)&pfn, "BuildCommDCBW", &g_Kernel32);
6361     return pfn( lpDef, lpDCB );
6362 }
6363
6364 typedef BOOL WINAPI FN_BuildCommDCBAndTimeoutsA( LPCSTR lpDef, LPDCB lpDCB, LPCOMMTIMEOUTS lpCommTimeouts );
6365 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_BuildCommDCBAndTimeoutsA( LPCSTR lpDef, LPDCB lpDCB, LPCOMMTIMEOUTS lpCommTimeouts )
6366 {
6367     static FN_BuildCommDCBAndTimeoutsA *pfn = 0;
6368     if (!pfn)
6369         kPrf2WrapResolve((void **)&pfn, "BuildCommDCBAndTimeoutsA", &g_Kernel32);
6370     return pfn( lpDef, lpDCB, lpCommTimeouts );
6371 }
6372
6373 typedef BOOL WINAPI FN_BuildCommDCBAndTimeoutsW( LPCWSTR lpDef, LPDCB lpDCB, LPCOMMTIMEOUTS lpCommTimeouts );
6374 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_BuildCommDCBAndTimeoutsW( LPCWSTR lpDef, LPDCB lpDCB, LPCOMMTIMEOUTS lpCommTimeouts )
6375 {
6376     static FN_BuildCommDCBAndTimeoutsW *pfn = 0;
6377     if (!pfn)
6378         kPrf2WrapResolve((void **)&pfn, "BuildCommDCBAndTimeoutsW", &g_Kernel32);
6379     return pfn( lpDef, lpDCB, lpCommTimeouts );
6380 }
6381
6382 typedef BOOL WINAPI FN_CommConfigDialogA( LPCSTR lpszName, HWND hWnd, LPCOMMCONFIG lpCC );
6383 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_CommConfigDialogA( LPCSTR lpszName, HWND hWnd, LPCOMMCONFIG lpCC )
6384 {
6385     static FN_CommConfigDialogA *pfn = 0;
6386     if (!pfn)
6387         kPrf2WrapResolve((void **)&pfn, "CommConfigDialogA", &g_Kernel32);
6388     return pfn( lpszName, hWnd, lpCC );
6389 }
6390
6391 typedef BOOL WINAPI FN_CommConfigDialogW( LPCWSTR lpszName, HWND hWnd, LPCOMMCONFIG lpCC );
6392 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_CommConfigDialogW( LPCWSTR lpszName, HWND hWnd, LPCOMMCONFIG lpCC )
6393 {
6394     static FN_CommConfigDialogW *pfn = 0;
6395     if (!pfn)
6396         kPrf2WrapResolve((void **)&pfn, "CommConfigDialogW", &g_Kernel32);
6397     return pfn( lpszName, hWnd, lpCC );
6398 }
6399
6400 typedef BOOL WINAPI FN_GetDefaultCommConfigA( LPCSTR lpszName, LPCOMMCONFIG lpCC, LPDWORD lpdwSize );
6401 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetDefaultCommConfigA( LPCSTR lpszName, LPCOMMCONFIG lpCC, LPDWORD lpdwSize )
6402 {
6403     static FN_GetDefaultCommConfigA *pfn = 0;
6404     if (!pfn)
6405         kPrf2WrapResolve((void **)&pfn, "GetDefaultCommConfigA", &g_Kernel32);
6406     return pfn( lpszName, lpCC, lpdwSize );
6407 }
6408
6409 typedef BOOL WINAPI FN_GetDefaultCommConfigW( LPCWSTR lpszName, LPCOMMCONFIG lpCC, LPDWORD lpdwSize );
6410 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetDefaultCommConfigW( LPCWSTR lpszName, LPCOMMCONFIG lpCC, LPDWORD lpdwSize )
6411 {
6412     static FN_GetDefaultCommConfigW *pfn = 0;
6413     if (!pfn)
6414         kPrf2WrapResolve((void **)&pfn, "GetDefaultCommConfigW", &g_Kernel32);
6415     return pfn( lpszName, lpCC, lpdwSize );
6416 }
6417
6418 typedef BOOL WINAPI FN_SetDefaultCommConfigA( LPCSTR lpszName, LPCOMMCONFIG lpCC, DWORD dwSize );
6419 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetDefaultCommConfigA( LPCSTR lpszName, LPCOMMCONFIG lpCC, DWORD dwSize )
6420 {
6421     static FN_SetDefaultCommConfigA *pfn = 0;
6422     if (!pfn)
6423         kPrf2WrapResolve((void **)&pfn, "SetDefaultCommConfigA", &g_Kernel32);
6424     return pfn( lpszName, lpCC, dwSize );
6425 }
6426
6427 typedef BOOL WINAPI FN_SetDefaultCommConfigW( LPCWSTR lpszName, LPCOMMCONFIG lpCC, DWORD dwSize );
6428 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetDefaultCommConfigW( LPCWSTR lpszName, LPCOMMCONFIG lpCC, DWORD dwSize )
6429 {
6430     static FN_SetDefaultCommConfigW *pfn = 0;
6431     if (!pfn)
6432         kPrf2WrapResolve((void **)&pfn, "SetDefaultCommConfigW", &g_Kernel32);
6433     return pfn( lpszName, lpCC, dwSize );
6434 }
6435
6436 typedef BOOL WINAPI FN_GetComputerNameA( LPSTR lpBuffer, LPDWORD nSize );
6437 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetComputerNameA( LPSTR lpBuffer, LPDWORD nSize )
6438 {
6439     static FN_GetComputerNameA *pfn = 0;
6440     if (!pfn)
6441         kPrf2WrapResolve((void **)&pfn, "GetComputerNameA", &g_Kernel32);
6442     return pfn( lpBuffer, nSize );
6443 }
6444
6445 typedef BOOL WINAPI FN_GetComputerNameW( LPWSTR lpBuffer, LPDWORD nSize );
6446 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetComputerNameW( LPWSTR lpBuffer, LPDWORD nSize )
6447 {
6448     static FN_GetComputerNameW *pfn = 0;
6449     if (!pfn)
6450         kPrf2WrapResolve((void **)&pfn, "GetComputerNameW", &g_Kernel32);
6451     return pfn( lpBuffer, nSize );
6452 }
6453
6454 typedef BOOL WINAPI FN_SetComputerNameA( LPCSTR lpComputerName );
6455 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetComputerNameA( LPCSTR lpComputerName )
6456 {
6457     static FN_SetComputerNameA *pfn = 0;
6458     if (!pfn)
6459         kPrf2WrapResolve((void **)&pfn, "SetComputerNameA", &g_Kernel32);
6460     return pfn( lpComputerName );
6461 }
6462
6463 typedef BOOL WINAPI FN_SetComputerNameW( LPCWSTR lpComputerName );
6464 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetComputerNameW( LPCWSTR lpComputerName )
6465 {
6466     static FN_SetComputerNameW *pfn = 0;
6467     if (!pfn)
6468         kPrf2WrapResolve((void **)&pfn, "SetComputerNameW", &g_Kernel32);
6469     return pfn( lpComputerName );
6470 }
6471
6472 typedef BOOL WINAPI FN_GetComputerNameExA( COMPUTER_NAME_FORMAT NameType, LPSTR lpBuffer, LPDWORD nSize );
6473 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetComputerNameExA( COMPUTER_NAME_FORMAT NameType, LPSTR lpBuffer, LPDWORD nSize )
6474 {
6475     static FN_GetComputerNameExA *pfn = 0;
6476     if (!pfn)
6477         kPrf2WrapResolve((void **)&pfn, "GetComputerNameExA", &g_Kernel32);
6478     return pfn( NameType, lpBuffer, nSize );
6479 }
6480
6481 typedef BOOL WINAPI FN_GetComputerNameExW( COMPUTER_NAME_FORMAT NameType, LPWSTR lpBuffer, LPDWORD nSize );
6482 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetComputerNameExW( COMPUTER_NAME_FORMAT NameType, LPWSTR lpBuffer, LPDWORD nSize )
6483 {
6484     static FN_GetComputerNameExW *pfn = 0;
6485     if (!pfn)
6486         kPrf2WrapResolve((void **)&pfn, "GetComputerNameExW", &g_Kernel32);
6487     return pfn( NameType, lpBuffer, nSize );
6488 }
6489
6490 typedef BOOL WINAPI FN_SetComputerNameExA( COMPUTER_NAME_FORMAT NameType, LPCSTR lpBuffer );
6491 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetComputerNameExA( COMPUTER_NAME_FORMAT NameType, LPCSTR lpBuffer )
6492 {
6493     static FN_SetComputerNameExA *pfn = 0;
6494     if (!pfn)
6495         kPrf2WrapResolve((void **)&pfn, "SetComputerNameExA", &g_Kernel32);
6496     return pfn( NameType, lpBuffer );
6497 }
6498
6499 typedef BOOL WINAPI FN_SetComputerNameExW( COMPUTER_NAME_FORMAT NameType, LPCWSTR lpBuffer );
6500 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetComputerNameExW( COMPUTER_NAME_FORMAT NameType, LPCWSTR lpBuffer )
6501 {
6502     static FN_SetComputerNameExW *pfn = 0;
6503     if (!pfn)
6504         kPrf2WrapResolve((void **)&pfn, "SetComputerNameExW", &g_Kernel32);
6505     return pfn( NameType, lpBuffer );
6506 }
6507
6508 typedef BOOL WINAPI FN_DnsHostnameToComputerNameA( LPCSTR Hostname, LPSTR ComputerName, LPDWORD nSize );
6509 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_DnsHostnameToComputerNameA( LPCSTR Hostname, LPSTR ComputerName, LPDWORD nSize )
6510 {
6511     static FN_DnsHostnameToComputerNameA *pfn = 0;
6512     if (!pfn)
6513         kPrf2WrapResolve((void **)&pfn, "DnsHostnameToComputerNameA", &g_Kernel32);
6514     return pfn( Hostname, ComputerName, nSize );
6515 }
6516
6517 typedef BOOL WINAPI FN_DnsHostnameToComputerNameW( LPCWSTR Hostname, LPWSTR ComputerName, LPDWORD nSize );
6518 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_DnsHostnameToComputerNameW( LPCWSTR Hostname, LPWSTR ComputerName, LPDWORD nSize )
6519 {
6520     static FN_DnsHostnameToComputerNameW *pfn = 0;
6521     if (!pfn)
6522         kPrf2WrapResolve((void **)&pfn, "DnsHostnameToComputerNameW", &g_Kernel32);
6523     return pfn( Hostname, ComputerName, nSize );
6524 }
6525
6526 typedef BOOL WINAPI FN_GetUserNameA( LPSTR lpBuffer, LPDWORD pcbBuffer );
6527 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetUserNameA( LPSTR lpBuffer, LPDWORD pcbBuffer )
6528 {
6529     static FN_GetUserNameA *pfn = 0;
6530     if (!pfn)
6531         kPrf2WrapResolve((void **)&pfn, "GetUserNameA", &g_Kernel32);
6532     return pfn( lpBuffer, pcbBuffer );
6533 }
6534
6535 typedef BOOL WINAPI FN_GetUserNameW( LPWSTR lpBuffer, LPDWORD pcbBuffer );
6536 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetUserNameW( LPWSTR lpBuffer, LPDWORD pcbBuffer )
6537 {
6538     static FN_GetUserNameW *pfn = 0;
6539     if (!pfn)
6540         kPrf2WrapResolve((void **)&pfn, "GetUserNameW", &g_Kernel32);
6541     return pfn( lpBuffer, pcbBuffer );
6542 }
6543
6544 typedef BOOL WINAPI FN_LogonUserA( LPCSTR lpszUsername, LPCSTR lpszDomain, LPCSTR lpszPassword, DWORD dwLogonType, DWORD dwLogonProvider, PHANDLE phToken );
6545 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_LogonUserA( LPCSTR lpszUsername, LPCSTR lpszDomain, LPCSTR lpszPassword, DWORD dwLogonType, DWORD dwLogonProvider, PHANDLE phToken )
6546 {
6547     static FN_LogonUserA *pfn = 0;
6548     if (!pfn)
6549         kPrf2WrapResolve((void **)&pfn, "LogonUserA", &g_Kernel32);
6550     return pfn( lpszUsername, lpszDomain, lpszPassword, dwLogonType, dwLogonProvider, phToken );
6551 }
6552
6553 typedef BOOL WINAPI FN_LogonUserW( LPCWSTR lpszUsername, LPCWSTR lpszDomain, LPCWSTR lpszPassword, DWORD dwLogonType, DWORD dwLogonProvider, PHANDLE phToken );
6554 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_LogonUserW( LPCWSTR lpszUsername, LPCWSTR lpszDomain, LPCWSTR lpszPassword, DWORD dwLogonType, DWORD dwLogonProvider, PHANDLE phToken )
6555 {
6556     static FN_LogonUserW *pfn = 0;
6557     if (!pfn)
6558         kPrf2WrapResolve((void **)&pfn, "LogonUserW", &g_Kernel32);
6559     return pfn( lpszUsername, lpszDomain, lpszPassword, dwLogonType, dwLogonProvider, phToken );
6560 }
6561
6562 typedef BOOL WINAPI FN_LogonUserExA( LPCSTR lpszUsername, LPCSTR lpszDomain, LPCSTR lpszPassword, DWORD dwLogonType, DWORD dwLogonProvider, PHANDLE phToken, PSID * ppLogonSid, PVOID * ppProfileBuffer, LPDWORD pdwProfileLength, PQUOTA_LIMITS pQuotaLimits );
6563 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_LogonUserExA( LPCSTR lpszUsername, LPCSTR lpszDomain, LPCSTR lpszPassword, DWORD dwLogonType, DWORD dwLogonProvider, PHANDLE phToken, PSID * ppLogonSid, PVOID * ppProfileBuffer, LPDWORD pdwProfileLength, PQUOTA_LIMITS pQuotaLimits )
6564 {
6565     static FN_LogonUserExA *pfn = 0;
6566     if (!pfn)
6567         kPrf2WrapResolve((void **)&pfn, "LogonUserExA", &g_Kernel32);
6568     return pfn( lpszUsername, lpszDomain, lpszPassword, dwLogonType, dwLogonProvider, phToken, ppLogonSid, ppProfileBuffer, pdwProfileLength, pQuotaLimits );
6569 }
6570
6571 typedef BOOL WINAPI FN_LogonUserExW( LPCWSTR lpszUsername, LPCWSTR lpszDomain, LPCWSTR lpszPassword, DWORD dwLogonType, DWORD dwLogonProvider, PHANDLE phToken, PSID * ppLogonSid, PVOID * ppProfileBuffer, LPDWORD pdwProfileLength, PQUOTA_LIMITS pQuotaLimits );
6572 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_LogonUserExW( LPCWSTR lpszUsername, LPCWSTR lpszDomain, LPCWSTR lpszPassword, DWORD dwLogonType, DWORD dwLogonProvider, PHANDLE phToken, PSID * ppLogonSid, PVOID * ppProfileBuffer, LPDWORD pdwProfileLength, PQUOTA_LIMITS pQuotaLimits )
6573 {
6574     static FN_LogonUserExW *pfn = 0;
6575     if (!pfn)
6576         kPrf2WrapResolve((void **)&pfn, "LogonUserExW", &g_Kernel32);
6577     return pfn( lpszUsername, lpszDomain, lpszPassword, dwLogonType, dwLogonProvider, phToken, ppLogonSid, ppProfileBuffer, pdwProfileLength, pQuotaLimits );
6578 }
6579
6580 typedef BOOL WINAPI FN_ImpersonateLoggedOnUser( HANDLE hToken );
6581 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_ImpersonateLoggedOnUser( HANDLE hToken )
6582 {
6583     static FN_ImpersonateLoggedOnUser *pfn = 0;
6584     if (!pfn)
6585         kPrf2WrapResolve((void **)&pfn, "ImpersonateLoggedOnUser", &g_Kernel32);
6586     return pfn( hToken );
6587 }
6588
6589 typedef BOOL WINAPI FN_CreateProcessAsUserA( HANDLE hToken, LPCSTR lpApplicationName, LPSTR lpCommandLine, LPSECURITY_ATTRIBUTES lpProcessAttributes, LPSECURITY_ATTRIBUTES lpThreadAttributes, BOOL bInheritHandles, DWORD dwCreationFlags, LPVOID lpEnvironment, LPCSTR lpCurrentDirectory, LPSTARTUPINFOA lpStartupInfo, LPPROCESS_INFORMATION lpProcessInformation );
6590 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_CreateProcessAsUserA( HANDLE hToken, LPCSTR lpApplicationName, LPSTR lpCommandLine, LPSECURITY_ATTRIBUTES lpProcessAttributes, LPSECURITY_ATTRIBUTES lpThreadAttributes, BOOL bInheritHandles, DWORD dwCreationFlags, LPVOID lpEnvironment, LPCSTR lpCurrentDirectory, LPSTARTUPINFOA lpStartupInfo, LPPROCESS_INFORMATION lpProcessInformation )
6591 {
6592     static FN_CreateProcessAsUserA *pfn = 0;
6593     if (!pfn)
6594         kPrf2WrapResolve((void **)&pfn, "CreateProcessAsUserA", &g_Kernel32);
6595     return pfn( hToken, lpApplicationName, lpCommandLine, lpProcessAttributes, lpThreadAttributes, bInheritHandles, dwCreationFlags, lpEnvironment, lpCurrentDirectory, lpStartupInfo, lpProcessInformation );
6596 }
6597
6598 typedef BOOL WINAPI FN_CreateProcessAsUserW( HANDLE hToken, LPCWSTR lpApplicationName, LPWSTR lpCommandLine, LPSECURITY_ATTRIBUTES lpProcessAttributes, LPSECURITY_ATTRIBUTES lpThreadAttributes, BOOL bInheritHandles, DWORD dwCreationFlags, LPVOID lpEnvironment, LPCWSTR lpCurrentDirectory, LPSTARTUPINFOW lpStartupInfo, LPPROCESS_INFORMATION lpProcessInformation );
6599 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_CreateProcessAsUserW( HANDLE hToken, LPCWSTR lpApplicationName, LPWSTR lpCommandLine, LPSECURITY_ATTRIBUTES lpProcessAttributes, LPSECURITY_ATTRIBUTES lpThreadAttributes, BOOL bInheritHandles, DWORD dwCreationFlags, LPVOID lpEnvironment, LPCWSTR lpCurrentDirectory, LPSTARTUPINFOW lpStartupInfo, LPPROCESS_INFORMATION lpProcessInformation )
6600 {
6601     static FN_CreateProcessAsUserW *pfn = 0;
6602     if (!pfn)
6603         kPrf2WrapResolve((void **)&pfn, "CreateProcessAsUserW", &g_Kernel32);
6604     return pfn( hToken, lpApplicationName, lpCommandLine, lpProcessAttributes, lpThreadAttributes, bInheritHandles, dwCreationFlags, lpEnvironment, lpCurrentDirectory, lpStartupInfo, lpProcessInformation );
6605 }
6606
6607 typedef BOOL WINAPI FN_CreateProcessWithLogonW( LPCWSTR lpUsername, LPCWSTR lpDomain, LPCWSTR lpPassword, DWORD dwLogonFlags, LPCWSTR lpApplicationName, LPWSTR lpCommandLine, DWORD dwCreationFlags, LPVOID lpEnvironment, LPCWSTR lpCurrentDirectory, LPSTARTUPINFOW lpStartupInfo, LPPROCESS_INFORMATION lpProcessInformation );
6608 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_CreateProcessWithLogonW( LPCWSTR lpUsername, LPCWSTR lpDomain, LPCWSTR lpPassword, DWORD dwLogonFlags, LPCWSTR lpApplicationName, LPWSTR lpCommandLine, DWORD dwCreationFlags, LPVOID lpEnvironment, LPCWSTR lpCurrentDirectory, LPSTARTUPINFOW lpStartupInfo, LPPROCESS_INFORMATION lpProcessInformation )
6609 {
6610     static FN_CreateProcessWithLogonW *pfn = 0;
6611     if (!pfn)
6612         kPrf2WrapResolve((void **)&pfn, "CreateProcessWithLogonW", &g_Kernel32);
6613     return pfn( lpUsername, lpDomain, lpPassword, dwLogonFlags, lpApplicationName, lpCommandLine, dwCreationFlags, lpEnvironment, lpCurrentDirectory, lpStartupInfo, lpProcessInformation );
6614 }
6615
6616 typedef BOOL WINAPI FN_CreateProcessWithTokenW( HANDLE hToken, DWORD dwLogonFlags, LPCWSTR lpApplicationName, LPWSTR lpCommandLine, DWORD dwCreationFlags, LPVOID lpEnvironment, LPCWSTR lpCurrentDirectory, LPSTARTUPINFOW lpStartupInfo, LPPROCESS_INFORMATION lpProcessInformation );
6617 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_CreateProcessWithTokenW( HANDLE hToken, DWORD dwLogonFlags, LPCWSTR lpApplicationName, LPWSTR lpCommandLine, DWORD dwCreationFlags, LPVOID lpEnvironment, LPCWSTR lpCurrentDirectory, LPSTARTUPINFOW lpStartupInfo, LPPROCESS_INFORMATION lpProcessInformation )
6618 {
6619     static FN_CreateProcessWithTokenW *pfn = 0;
6620     if (!pfn)
6621         kPrf2WrapResolve((void **)&pfn, "CreateProcessWithTokenW", &g_Kernel32);
6622     return pfn( hToken, dwLogonFlags, lpApplicationName, lpCommandLine, dwCreationFlags, lpEnvironment, lpCurrentDirectory, lpStartupInfo, lpProcessInformation );
6623 }
6624
6625 typedef BOOL APIENTRY FN_ImpersonateAnonymousToken( HANDLE ThreadHandle );
6626 __declspec(dllexport) BOOL APIENTRY kPrf2Wrap_ImpersonateAnonymousToken( HANDLE ThreadHandle )
6627 {
6628     static FN_ImpersonateAnonymousToken *pfn = 0;
6629     if (!pfn)
6630         kPrf2WrapResolve((void **)&pfn, "ImpersonateAnonymousToken", &g_Kernel32);
6631     return pfn( ThreadHandle );
6632 }
6633
6634 typedef BOOL WINAPI FN_DuplicateTokenEx( HANDLE hExistingToken, DWORD dwDesiredAccess, LPSECURITY_ATTRIBUTES lpTokenAttributes, SECURITY_IMPERSONATION_LEVEL ImpersonationLevel, TOKEN_TYPE TokenType, PHANDLE phNewToken );
6635 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_DuplicateTokenEx( HANDLE hExistingToken, DWORD dwDesiredAccess, LPSECURITY_ATTRIBUTES lpTokenAttributes, SECURITY_IMPERSONATION_LEVEL ImpersonationLevel, TOKEN_TYPE TokenType, PHANDLE phNewToken )
6636 {
6637     static FN_DuplicateTokenEx *pfn = 0;
6638     if (!pfn)
6639         kPrf2WrapResolve((void **)&pfn, "DuplicateTokenEx", &g_Kernel32);
6640     return pfn( hExistingToken, dwDesiredAccess, lpTokenAttributes, ImpersonationLevel, TokenType, phNewToken );
6641 }
6642
6643 typedef BOOL APIENTRY FN_CreateRestrictedToken( HANDLE ExistingTokenHandle, DWORD Flags, DWORD DisableSidCount, PSID_AND_ATTRIBUTES SidsToDisable, DWORD DeletePrivilegeCount, PLUID_AND_ATTRIBUTES PrivilegesToDelete, DWORD RestrictedSidCount, PSID_AND_ATTRIBUTES SidsToRestrict, PHANDLE NewTokenHandle );
6644 __declspec(dllexport) BOOL APIENTRY kPrf2Wrap_CreateRestrictedToken( HANDLE ExistingTokenHandle, DWORD Flags, DWORD DisableSidCount, PSID_AND_ATTRIBUTES SidsToDisable, DWORD DeletePrivilegeCount, PLUID_AND_ATTRIBUTES PrivilegesToDelete, DWORD RestrictedSidCount, PSID_AND_ATTRIBUTES SidsToRestrict, PHANDLE NewTokenHandle )
6645 {
6646     static FN_CreateRestrictedToken *pfn = 0;
6647     if (!pfn)
6648         kPrf2WrapResolve((void **)&pfn, "CreateRestrictedToken", &g_Kernel32);
6649     return pfn( ExistingTokenHandle, Flags, DisableSidCount, SidsToDisable, DeletePrivilegeCount, PrivilegesToDelete, RestrictedSidCount, SidsToRestrict, NewTokenHandle );
6650 }
6651
6652 typedef BOOL WINAPI FN_IsTokenRestricted( HANDLE TokenHandle );
6653 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_IsTokenRestricted( HANDLE TokenHandle )
6654 {
6655     static FN_IsTokenRestricted *pfn = 0;
6656     if (!pfn)
6657         kPrf2WrapResolve((void **)&pfn, "IsTokenRestricted", &g_Kernel32);
6658     return pfn( TokenHandle );
6659 }
6660
6661 typedef BOOL WINAPI FN_IsTokenUntrusted( HANDLE TokenHandle );
6662 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_IsTokenUntrusted( HANDLE TokenHandle )
6663 {
6664     static FN_IsTokenUntrusted *pfn = 0;
6665     if (!pfn)
6666         kPrf2WrapResolve((void **)&pfn, "IsTokenUntrusted", &g_Kernel32);
6667     return pfn( TokenHandle );
6668 }
6669
6670 typedef BOOL APIENTRY FN_CheckTokenMembership( HANDLE TokenHandle, PSID SidToCheck, PBOOL IsMember );
6671 __declspec(dllexport) BOOL APIENTRY kPrf2Wrap_CheckTokenMembership( HANDLE TokenHandle, PSID SidToCheck, PBOOL IsMember )
6672 {
6673     static FN_CheckTokenMembership *pfn = 0;
6674     if (!pfn)
6675         kPrf2WrapResolve((void **)&pfn, "CheckTokenMembership", &g_Kernel32);
6676     return pfn( TokenHandle, SidToCheck, IsMember );
6677 }
6678
6679 typedef BOOL WINAPI FN_RegisterWaitForSingleObject( PHANDLE phNewWaitObject, HANDLE hObject, WAITORTIMERCALLBACK Callback, PVOID Context, ULONG dwMilliseconds, ULONG dwFlags );
6680 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_RegisterWaitForSingleObject( PHANDLE phNewWaitObject, HANDLE hObject, WAITORTIMERCALLBACK Callback, PVOID Context, ULONG dwMilliseconds, ULONG dwFlags )
6681 {
6682     static FN_RegisterWaitForSingleObject *pfn = 0;
6683     if (!pfn)
6684         kPrf2WrapResolve((void **)&pfn, "RegisterWaitForSingleObject", &g_Kernel32);
6685     return pfn( phNewWaitObject, hObject, Callback, Context, dwMilliseconds, dwFlags );
6686 }
6687
6688 typedef HANDLE WINAPI FN_RegisterWaitForSingleObjectEx( HANDLE hObject, WAITORTIMERCALLBACK Callback, PVOID Context, ULONG dwMilliseconds, ULONG dwFlags );
6689 __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_RegisterWaitForSingleObjectEx( HANDLE hObject, WAITORTIMERCALLBACK Callback, PVOID Context, ULONG dwMilliseconds, ULONG dwFlags )
6690 {
6691     static FN_RegisterWaitForSingleObjectEx *pfn = 0;
6692     if (!pfn)
6693         kPrf2WrapResolve((void **)&pfn, "RegisterWaitForSingleObjectEx", &g_Kernel32);
6694     return pfn( hObject, Callback, Context, dwMilliseconds, dwFlags );
6695 }
6696
6697 typedef BOOL WINAPI FN_UnregisterWait( HANDLE WaitHandle );
6698 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_UnregisterWait( HANDLE WaitHandle )
6699 {
6700     static FN_UnregisterWait *pfn = 0;
6701     if (!pfn)
6702         kPrf2WrapResolve((void **)&pfn, "UnregisterWait", &g_Kernel32);
6703     return pfn( WaitHandle );
6704 }
6705
6706 typedef BOOL WINAPI FN_UnregisterWaitEx( HANDLE WaitHandle, HANDLE CompletionEvent );
6707 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_UnregisterWaitEx( HANDLE WaitHandle, HANDLE CompletionEvent )
6708 {
6709     static FN_UnregisterWaitEx *pfn = 0;
6710     if (!pfn)
6711         kPrf2WrapResolve((void **)&pfn, "UnregisterWaitEx", &g_Kernel32);
6712     return pfn( WaitHandle, CompletionEvent );
6713 }
6714
6715 typedef BOOL WINAPI FN_QueueUserWorkItem( LPTHREAD_START_ROUTINE Function, PVOID Context, ULONG Flags );
6716 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_QueueUserWorkItem( LPTHREAD_START_ROUTINE Function, PVOID Context, ULONG Flags )
6717 {
6718     static FN_QueueUserWorkItem *pfn = 0;
6719     if (!pfn)
6720         kPrf2WrapResolve((void **)&pfn, "QueueUserWorkItem", &g_Kernel32);
6721     return pfn( Function, Context, Flags );
6722 }
6723
6724 typedef BOOL WINAPI FN_BindIoCompletionCallback( HANDLE FileHandle, LPOVERLAPPED_COMPLETION_ROUTINE Function, ULONG Flags );
6725 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_BindIoCompletionCallback( HANDLE FileHandle, LPOVERLAPPED_COMPLETION_ROUTINE Function, ULONG Flags )
6726 {
6727     static FN_BindIoCompletionCallback *pfn = 0;
6728     if (!pfn)
6729         kPrf2WrapResolve((void **)&pfn, "BindIoCompletionCallback", &g_Kernel32);
6730     return pfn( FileHandle, Function, Flags );
6731 }
6732
6733 typedef HANDLE WINAPI FN_CreateTimerQueue( VOID );
6734 __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_CreateTimerQueue( VOID )
6735 {
6736     static FN_CreateTimerQueue *pfn = 0;
6737     if (!pfn)
6738         kPrf2WrapResolve((void **)&pfn, "CreateTimerQueue", &g_Kernel32);
6739     return pfn ();
6740 }
6741
6742 typedef BOOL WINAPI FN_CreateTimerQueueTimer( PHANDLE phNewTimer, HANDLE TimerQueue, WAITORTIMERCALLBACK Callback, PVOID Parameter, DWORD DueTime, DWORD Period, ULONG Flags );
6743 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_CreateTimerQueueTimer( PHANDLE phNewTimer, HANDLE TimerQueue, WAITORTIMERCALLBACK Callback, PVOID Parameter, DWORD DueTime, DWORD Period, ULONG Flags )
6744 {
6745     static FN_CreateTimerQueueTimer *pfn = 0;
6746     if (!pfn)
6747         kPrf2WrapResolve((void **)&pfn, "CreateTimerQueueTimer", &g_Kernel32);
6748     return pfn( phNewTimer, TimerQueue, Callback, Parameter, DueTime, Period, Flags );
6749 }
6750
6751 typedef BOOL WINAPI FN_ChangeTimerQueueTimer( HANDLE TimerQueue, HANDLE Timer, ULONG DueTime, ULONG Period );
6752 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_ChangeTimerQueueTimer( HANDLE TimerQueue, HANDLE Timer, ULONG DueTime, ULONG Period )
6753 {
6754     static FN_ChangeTimerQueueTimer *pfn = 0;
6755     if (!pfn)
6756         kPrf2WrapResolve((void **)&pfn, "ChangeTimerQueueTimer", &g_Kernel32);
6757     return pfn( TimerQueue, Timer, DueTime, Period );
6758 }
6759
6760 typedef BOOL WINAPI FN_DeleteTimerQueueTimer( HANDLE TimerQueue, HANDLE Timer, HANDLE CompletionEvent );
6761 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_DeleteTimerQueueTimer( HANDLE TimerQueue, HANDLE Timer, HANDLE CompletionEvent )
6762 {
6763     static FN_DeleteTimerQueueTimer *pfn = 0;
6764     if (!pfn)
6765         kPrf2WrapResolve((void **)&pfn, "DeleteTimerQueueTimer", &g_Kernel32);
6766     return pfn( TimerQueue, Timer, CompletionEvent );
6767 }
6768
6769 typedef BOOL WINAPI FN_DeleteTimerQueueEx( HANDLE TimerQueue, HANDLE CompletionEvent );
6770 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_DeleteTimerQueueEx( HANDLE TimerQueue, HANDLE CompletionEvent )
6771 {
6772     static FN_DeleteTimerQueueEx *pfn = 0;
6773     if (!pfn)
6774         kPrf2WrapResolve((void **)&pfn, "DeleteTimerQueueEx", &g_Kernel32);
6775     return pfn( TimerQueue, CompletionEvent );
6776 }
6777
6778 typedef HANDLE WINAPI FN_SetTimerQueueTimer( HANDLE TimerQueue, WAITORTIMERCALLBACK Callback, PVOID Parameter, DWORD DueTime, DWORD Period, BOOL PreferIo );
6779 __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_SetTimerQueueTimer( HANDLE TimerQueue, WAITORTIMERCALLBACK Callback, PVOID Parameter, DWORD DueTime, DWORD Period, BOOL PreferIo )
6780 {
6781     static FN_SetTimerQueueTimer *pfn = 0;
6782     if (!pfn)
6783         kPrf2WrapResolve((void **)&pfn, "SetTimerQueueTimer", &g_Kernel32);
6784     return pfn( TimerQueue, Callback, Parameter, DueTime, Period, PreferIo );
6785 }
6786
6787 typedef BOOL WINAPI FN_CancelTimerQueueTimer( HANDLE TimerQueue, HANDLE Timer );
6788 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_CancelTimerQueueTimer( HANDLE TimerQueue, HANDLE Timer )
6789 {
6790     static FN_CancelTimerQueueTimer *pfn = 0;
6791     if (!pfn)
6792         kPrf2WrapResolve((void **)&pfn, "CancelTimerQueueTimer", &g_Kernel32);
6793     return pfn( TimerQueue, Timer );
6794 }
6795
6796 typedef BOOL WINAPI FN_DeleteTimerQueue( HANDLE TimerQueue );
6797 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_DeleteTimerQueue( HANDLE TimerQueue )
6798 {
6799     static FN_DeleteTimerQueue *pfn = 0;
6800     if (!pfn)
6801         kPrf2WrapResolve((void **)&pfn, "DeleteTimerQueue", &g_Kernel32);
6802     return pfn( TimerQueue );
6803 }
6804
6805 typedef BOOL WINAPI FN_GetCurrentHwProfileA( LPHW_PROFILE_INFOA lpHwProfileInfo );
6806 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetCurrentHwProfileA( LPHW_PROFILE_INFOA lpHwProfileInfo )
6807 {
6808     static FN_GetCurrentHwProfileA *pfn = 0;
6809     if (!pfn)
6810         kPrf2WrapResolve((void **)&pfn, "GetCurrentHwProfileA", &g_Kernel32);
6811     return pfn( lpHwProfileInfo );
6812 }
6813
6814 typedef BOOL WINAPI FN_GetCurrentHwProfileW( LPHW_PROFILE_INFOW lpHwProfileInfo );
6815 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetCurrentHwProfileW( LPHW_PROFILE_INFOW lpHwProfileInfo )
6816 {
6817     static FN_GetCurrentHwProfileW *pfn = 0;
6818     if (!pfn)
6819         kPrf2WrapResolve((void **)&pfn, "GetCurrentHwProfileW", &g_Kernel32);
6820     return pfn( lpHwProfileInfo );
6821 }
6822
6823 typedef BOOL WINAPI FN_QueryPerformanceCounter( LARGE_INTEGER * lpPerformanceCount );
6824 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_QueryPerformanceCounter( LARGE_INTEGER * lpPerformanceCount )
6825 {
6826     static FN_QueryPerformanceCounter *pfn = 0;
6827     if (!pfn)
6828         kPrf2WrapResolve((void **)&pfn, "QueryPerformanceCounter", &g_Kernel32);
6829     return pfn( lpPerformanceCount );
6830 }
6831
6832 typedef BOOL WINAPI FN_QueryPerformanceFrequency( LARGE_INTEGER * lpFrequency );
6833 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_QueryPerformanceFrequency( LARGE_INTEGER * lpFrequency )
6834 {
6835     static FN_QueryPerformanceFrequency *pfn = 0;
6836     if (!pfn)
6837         kPrf2WrapResolve((void **)&pfn, "QueryPerformanceFrequency", &g_Kernel32);
6838     return pfn( lpFrequency );
6839 }
6840
6841 typedef BOOL WINAPI FN_GetVersionExA( LPOSVERSIONINFOA lpVersionInformation );
6842 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetVersionExA( LPOSVERSIONINFOA lpVersionInformation )
6843 {
6844     static FN_GetVersionExA *pfn = 0;
6845     if (!pfn)
6846         kPrf2WrapResolve((void **)&pfn, "GetVersionExA", &g_Kernel32);
6847     return pfn( lpVersionInformation );
6848 }
6849
6850 typedef BOOL WINAPI FN_GetVersionExW( LPOSVERSIONINFOW lpVersionInformation );
6851 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetVersionExW( LPOSVERSIONINFOW lpVersionInformation )
6852 {
6853     static FN_GetVersionExW *pfn = 0;
6854     if (!pfn)
6855         kPrf2WrapResolve((void **)&pfn, "GetVersionExW", &g_Kernel32);
6856     return pfn( lpVersionInformation );
6857 }
6858
6859 typedef BOOL WINAPI FN_VerifyVersionInfoA( LPOSVERSIONINFOEXA lpVersionInformation, DWORD dwTypeMask, DWORDLONG dwlConditionMask );
6860 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_VerifyVersionInfoA( LPOSVERSIONINFOEXA lpVersionInformation, DWORD dwTypeMask, DWORDLONG dwlConditionMask )
6861 {
6862     static FN_VerifyVersionInfoA *pfn = 0;
6863     if (!pfn)
6864         kPrf2WrapResolve((void **)&pfn, "VerifyVersionInfoA", &g_Kernel32);
6865     return pfn( lpVersionInformation, dwTypeMask, dwlConditionMask );
6866 }
6867
6868 typedef BOOL WINAPI FN_VerifyVersionInfoW( LPOSVERSIONINFOEXW lpVersionInformation, DWORD dwTypeMask, DWORDLONG dwlConditionMask );
6869 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_VerifyVersionInfoW( LPOSVERSIONINFOEXW lpVersionInformation, DWORD dwTypeMask, DWORDLONG dwlConditionMask )
6870 {
6871     static FN_VerifyVersionInfoW *pfn = 0;
6872     if (!pfn)
6873         kPrf2WrapResolve((void **)&pfn, "VerifyVersionInfoW", &g_Kernel32);
6874     return pfn( lpVersionInformation, dwTypeMask, dwlConditionMask );
6875 }
6876
6877 typedef BOOL WINAPI FN_GetSystemPowerStatus( LPSYSTEM_POWER_STATUS lpSystemPowerStatus );
6878 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetSystemPowerStatus( LPSYSTEM_POWER_STATUS lpSystemPowerStatus )
6879 {
6880     static FN_GetSystemPowerStatus *pfn = 0;
6881     if (!pfn)
6882         kPrf2WrapResolve((void **)&pfn, "GetSystemPowerStatus", &g_Kernel32);
6883     return pfn( lpSystemPowerStatus );
6884 }
6885
6886 typedef BOOL WINAPI FN_SetSystemPowerState( BOOL fSuspend, BOOL fForce );
6887 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetSystemPowerState( BOOL fSuspend, BOOL fForce )
6888 {
6889     static FN_SetSystemPowerState *pfn = 0;
6890     if (!pfn)
6891         kPrf2WrapResolve((void **)&pfn, "SetSystemPowerState", &g_Kernel32);
6892     return pfn( fSuspend, fForce );
6893 }
6894
6895 typedef BOOL WINAPI FN_AllocateUserPhysicalPages( HANDLE hProcess, PULONG_PTR NumberOfPages, PULONG_PTR PageArray );
6896 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_AllocateUserPhysicalPages( HANDLE hProcess, PULONG_PTR NumberOfPages, PULONG_PTR PageArray )
6897 {
6898     static FN_AllocateUserPhysicalPages *pfn = 0;
6899     if (!pfn)
6900         kPrf2WrapResolve((void **)&pfn, "AllocateUserPhysicalPages", &g_Kernel32);
6901     return pfn( hProcess, NumberOfPages, PageArray );
6902 }
6903
6904 typedef BOOL WINAPI FN_FreeUserPhysicalPages( HANDLE hProcess, PULONG_PTR NumberOfPages, PULONG_PTR PageArray );
6905 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_FreeUserPhysicalPages( HANDLE hProcess, PULONG_PTR NumberOfPages, PULONG_PTR PageArray )
6906 {
6907     static FN_FreeUserPhysicalPages *pfn = 0;
6908     if (!pfn)
6909         kPrf2WrapResolve((void **)&pfn, "FreeUserPhysicalPages", &g_Kernel32);
6910     return pfn( hProcess, NumberOfPages, PageArray );
6911 }
6912
6913 typedef BOOL WINAPI FN_MapUserPhysicalPages( PVOID VirtualAddress, ULONG_PTR NumberOfPages, PULONG_PTR PageArray );
6914 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_MapUserPhysicalPages( PVOID VirtualAddress, ULONG_PTR NumberOfPages, PULONG_PTR PageArray )
6915 {
6916     static FN_MapUserPhysicalPages *pfn = 0;
6917     if (!pfn)
6918         kPrf2WrapResolve((void **)&pfn, "MapUserPhysicalPages", &g_Kernel32);
6919     return pfn( VirtualAddress, NumberOfPages, PageArray );
6920 }
6921
6922 typedef BOOL WINAPI FN_MapUserPhysicalPagesScatter( PVOID * VirtualAddresses, ULONG_PTR NumberOfPages, PULONG_PTR PageArray );
6923 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_MapUserPhysicalPagesScatter( PVOID * VirtualAddresses, ULONG_PTR NumberOfPages, PULONG_PTR PageArray )
6924 {
6925     static FN_MapUserPhysicalPagesScatter *pfn = 0;
6926     if (!pfn)
6927         kPrf2WrapResolve((void **)&pfn, "MapUserPhysicalPagesScatter", &g_Kernel32);
6928     return pfn( VirtualAddresses, NumberOfPages, PageArray );
6929 }
6930
6931 typedef HANDLE WINAPI FN_CreateJobObjectA( LPSECURITY_ATTRIBUTES lpJobAttributes, LPCSTR lpName );
6932 __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_CreateJobObjectA( LPSECURITY_ATTRIBUTES lpJobAttributes, LPCSTR lpName )
6933 {
6934     static FN_CreateJobObjectA *pfn = 0;
6935     if (!pfn)
6936         kPrf2WrapResolve((void **)&pfn, "CreateJobObjectA", &g_Kernel32);
6937     return pfn( lpJobAttributes, lpName );
6938 }
6939
6940 typedef HANDLE WINAPI FN_CreateJobObjectW( LPSECURITY_ATTRIBUTES lpJobAttributes, LPCWSTR lpName );
6941 __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_CreateJobObjectW( LPSECURITY_ATTRIBUTES lpJobAttributes, LPCWSTR lpName )
6942 {
6943     static FN_CreateJobObjectW *pfn = 0;
6944     if (!pfn)
6945         kPrf2WrapResolve((void **)&pfn, "CreateJobObjectW", &g_Kernel32);
6946     return pfn( lpJobAttributes, lpName );
6947 }
6948
6949 typedef HANDLE WINAPI FN_OpenJobObjectA( DWORD dwDesiredAccess, BOOL bInheritHandle, LPCSTR lpName );
6950 __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_OpenJobObjectA( DWORD dwDesiredAccess, BOOL bInheritHandle, LPCSTR lpName )
6951 {
6952     static FN_OpenJobObjectA *pfn = 0;
6953     if (!pfn)
6954         kPrf2WrapResolve((void **)&pfn, "OpenJobObjectA", &g_Kernel32);
6955     return pfn( dwDesiredAccess, bInheritHandle, lpName );
6956 }
6957
6958 typedef HANDLE WINAPI FN_OpenJobObjectW( DWORD dwDesiredAccess, BOOL bInheritHandle, LPCWSTR lpName );
6959 __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_OpenJobObjectW( DWORD dwDesiredAccess, BOOL bInheritHandle, LPCWSTR lpName )
6960 {
6961     static FN_OpenJobObjectW *pfn = 0;
6962     if (!pfn)
6963         kPrf2WrapResolve((void **)&pfn, "OpenJobObjectW", &g_Kernel32);
6964     return pfn( dwDesiredAccess, bInheritHandle, lpName );
6965 }
6966
6967 typedef BOOL WINAPI FN_AssignProcessToJobObject( HANDLE hJob, HANDLE hProcess );
6968 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_AssignProcessToJobObject( HANDLE hJob, HANDLE hProcess )
6969 {
6970     static FN_AssignProcessToJobObject *pfn = 0;
6971     if (!pfn)
6972         kPrf2WrapResolve((void **)&pfn, "AssignProcessToJobObject", &g_Kernel32);
6973     return pfn( hJob, hProcess );
6974 }
6975
6976 typedef BOOL WINAPI FN_TerminateJobObject( HANDLE hJob, UINT uExitCode );
6977 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_TerminateJobObject( HANDLE hJob, UINT uExitCode )
6978 {
6979     static FN_TerminateJobObject *pfn = 0;
6980     if (!pfn)
6981         kPrf2WrapResolve((void **)&pfn, "TerminateJobObject", &g_Kernel32);
6982     return pfn( hJob, uExitCode );
6983 }
6984
6985 typedef BOOL WINAPI FN_QueryInformationJobObject( HANDLE hJob, JOBOBJECTINFOCLASS JobObjectInformationClass, LPVOID lpJobObjectInformation, DWORD cbJobObjectInformationLength, LPDWORD lpReturnLength );
6986 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_QueryInformationJobObject( HANDLE hJob, JOBOBJECTINFOCLASS JobObjectInformationClass, LPVOID lpJobObjectInformation, DWORD cbJobObjectInformationLength, LPDWORD lpReturnLength )
6987 {
6988     static FN_QueryInformationJobObject *pfn = 0;
6989     if (!pfn)
6990         kPrf2WrapResolve((void **)&pfn, "QueryInformationJobObject", &g_Kernel32);
6991     return pfn( hJob, JobObjectInformationClass, lpJobObjectInformation, cbJobObjectInformationLength, lpReturnLength );
6992 }
6993
6994 typedef BOOL WINAPI FN_SetInformationJobObject( HANDLE hJob, JOBOBJECTINFOCLASS JobObjectInformationClass, LPVOID lpJobObjectInformation, DWORD cbJobObjectInformationLength );
6995 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetInformationJobObject( HANDLE hJob, JOBOBJECTINFOCLASS JobObjectInformationClass, LPVOID lpJobObjectInformation, DWORD cbJobObjectInformationLength )
6996 {
6997     static FN_SetInformationJobObject *pfn = 0;
6998     if (!pfn)
6999         kPrf2WrapResolve((void **)&pfn, "SetInformationJobObject", &g_Kernel32);
7000     return pfn( hJob, JobObjectInformationClass, lpJobObjectInformation, cbJobObjectInformationLength );
7001 }
7002
7003 typedef BOOL WINAPI FN_IsProcessInJob( HANDLE ProcessHandle, HANDLE JobHandle, PBOOL Result );
7004 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_IsProcessInJob( HANDLE ProcessHandle, HANDLE JobHandle, PBOOL Result )
7005 {
7006     static FN_IsProcessInJob *pfn = 0;
7007     if (!pfn)
7008         kPrf2WrapResolve((void **)&pfn, "IsProcessInJob", &g_Kernel32);
7009     return pfn( ProcessHandle, JobHandle, Result );
7010 }
7011
7012 typedef BOOL WINAPI FN_CreateJobSet( ULONG NumJob, PJOB_SET_ARRAY UserJobSet, ULONG Flags );
7013 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_CreateJobSet( ULONG NumJob, PJOB_SET_ARRAY UserJobSet, ULONG Flags )
7014 {
7015     static FN_CreateJobSet *pfn = 0;
7016     if (!pfn)
7017         kPrf2WrapResolve((void **)&pfn, "CreateJobSet", &g_Kernel32);
7018     return pfn( NumJob, UserJobSet, Flags );
7019 }
7020
7021 typedef PVOID WINAPI FN_AddVectoredExceptionHandler( ULONG First, PVECTORED_EXCEPTION_HANDLER Handler );
7022 __declspec(dllexport) PVOID WINAPI kPrf2Wrap_AddVectoredExceptionHandler( ULONG First, PVECTORED_EXCEPTION_HANDLER Handler )
7023 {
7024     static FN_AddVectoredExceptionHandler *pfn = 0;
7025     if (!pfn)
7026         kPrf2WrapResolve((void **)&pfn, "AddVectoredExceptionHandler", &g_Kernel32);
7027     return pfn( First, Handler );
7028 }
7029
7030 typedef ULONG WINAPI FN_RemoveVectoredExceptionHandler( PVOID Handle );
7031 __declspec(dllexport) ULONG WINAPI kPrf2Wrap_RemoveVectoredExceptionHandler( PVOID Handle )
7032 {
7033     static FN_RemoveVectoredExceptionHandler *pfn = 0;
7034     if (!pfn)
7035         kPrf2WrapResolve((void **)&pfn, "RemoveVectoredExceptionHandler", &g_Kernel32);
7036     return pfn( Handle );
7037 }
7038
7039 typedef PVOID WINAPI FN_AddVectoredContinueHandler( ULONG First, PVECTORED_EXCEPTION_HANDLER Handler );
7040 __declspec(dllexport) PVOID WINAPI kPrf2Wrap_AddVectoredContinueHandler( ULONG First, PVECTORED_EXCEPTION_HANDLER Handler )
7041 {
7042     static FN_AddVectoredContinueHandler *pfn = 0;
7043     if (!pfn)
7044         kPrf2WrapResolve((void **)&pfn, "AddVectoredContinueHandler", &g_Kernel32);
7045     return pfn( First, Handler );
7046 }
7047
7048 typedef ULONG WINAPI FN_RemoveVectoredContinueHandler( PVOID Handle );
7049 __declspec(dllexport) ULONG WINAPI kPrf2Wrap_RemoveVectoredContinueHandler( PVOID Handle )
7050 {
7051     static FN_RemoveVectoredContinueHandler *pfn = 0;
7052     if (!pfn)
7053         kPrf2WrapResolve((void **)&pfn, "RemoveVectoredContinueHandler", &g_Kernel32);
7054     return pfn( Handle );
7055 }
7056
7057 typedef HANDLE WINAPI FN_FindFirstVolumeA( LPSTR lpszVolumeName, DWORD cchBufferLength );
7058 __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_FindFirstVolumeA( LPSTR lpszVolumeName, DWORD cchBufferLength )
7059 {
7060     static FN_FindFirstVolumeA *pfn = 0;
7061     if (!pfn)
7062         kPrf2WrapResolve((void **)&pfn, "FindFirstVolumeA", &g_Kernel32);
7063     return pfn( lpszVolumeName, cchBufferLength );
7064 }
7065
7066 typedef HANDLE WINAPI FN_FindFirstVolumeW( LPWSTR lpszVolumeName, DWORD cchBufferLength );
7067 __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_FindFirstVolumeW( LPWSTR lpszVolumeName, DWORD cchBufferLength )
7068 {
7069     static FN_FindFirstVolumeW *pfn = 0;
7070     if (!pfn)
7071         kPrf2WrapResolve((void **)&pfn, "FindFirstVolumeW", &g_Kernel32);
7072     return pfn( lpszVolumeName, cchBufferLength );
7073 }
7074
7075 typedef BOOL WINAPI FN_FindNextVolumeA( HANDLE hFindVolume, LPSTR lpszVolumeName, DWORD cchBufferLength );
7076 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_FindNextVolumeA( HANDLE hFindVolume, LPSTR lpszVolumeName, DWORD cchBufferLength )
7077 {
7078     static FN_FindNextVolumeA *pfn = 0;
7079     if (!pfn)
7080         kPrf2WrapResolve((void **)&pfn, "FindNextVolumeA", &g_Kernel32);
7081     return pfn( hFindVolume, lpszVolumeName, cchBufferLength );
7082 }
7083
7084 typedef BOOL WINAPI FN_FindNextVolumeW( HANDLE hFindVolume, LPWSTR lpszVolumeName, DWORD cchBufferLength );
7085 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_FindNextVolumeW( HANDLE hFindVolume, LPWSTR lpszVolumeName, DWORD cchBufferLength )
7086 {
7087     static FN_FindNextVolumeW *pfn = 0;
7088     if (!pfn)
7089         kPrf2WrapResolve((void **)&pfn, "FindNextVolumeW", &g_Kernel32);
7090     return pfn( hFindVolume, lpszVolumeName, cchBufferLength );
7091 }
7092
7093 typedef BOOL WINAPI FN_FindVolumeClose( HANDLE hFindVolume );
7094 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_FindVolumeClose( HANDLE hFindVolume )
7095 {
7096     static FN_FindVolumeClose *pfn = 0;
7097     if (!pfn)
7098         kPrf2WrapResolve((void **)&pfn, "FindVolumeClose", &g_Kernel32);
7099     return pfn( hFindVolume );
7100 }
7101
7102 typedef HANDLE WINAPI FN_FindFirstVolumeMountPointA( LPCSTR lpszRootPathName, LPSTR lpszVolumeMountPoint, DWORD cchBufferLength );
7103 __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_FindFirstVolumeMountPointA( LPCSTR lpszRootPathName, LPSTR lpszVolumeMountPoint, DWORD cchBufferLength )
7104 {
7105     static FN_FindFirstVolumeMountPointA *pfn = 0;
7106     if (!pfn)
7107         kPrf2WrapResolve((void **)&pfn, "FindFirstVolumeMountPointA", &g_Kernel32);
7108     return pfn( lpszRootPathName, lpszVolumeMountPoint, cchBufferLength );
7109 }
7110
7111 typedef HANDLE WINAPI FN_FindFirstVolumeMountPointW( LPCWSTR lpszRootPathName, LPWSTR lpszVolumeMountPoint, DWORD cchBufferLength );
7112 __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_FindFirstVolumeMountPointW( LPCWSTR lpszRootPathName, LPWSTR lpszVolumeMountPoint, DWORD cchBufferLength )
7113 {
7114     static FN_FindFirstVolumeMountPointW *pfn = 0;
7115     if (!pfn)
7116         kPrf2WrapResolve((void **)&pfn, "FindFirstVolumeMountPointW", &g_Kernel32);
7117     return pfn( lpszRootPathName, lpszVolumeMountPoint, cchBufferLength );
7118 }
7119
7120 typedef BOOL WINAPI FN_FindNextVolumeMountPointA( HANDLE hFindVolumeMountPoint, LPSTR lpszVolumeMountPoint, DWORD cchBufferLength );
7121 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_FindNextVolumeMountPointA( HANDLE hFindVolumeMountPoint, LPSTR lpszVolumeMountPoint, DWORD cchBufferLength )
7122 {
7123     static FN_FindNextVolumeMountPointA *pfn = 0;
7124     if (!pfn)
7125         kPrf2WrapResolve((void **)&pfn, "FindNextVolumeMountPointA", &g_Kernel32);
7126     return pfn( hFindVolumeMountPoint, lpszVolumeMountPoint, cchBufferLength );
7127 }
7128
7129 typedef BOOL WINAPI FN_FindNextVolumeMountPointW( HANDLE hFindVolumeMountPoint, LPWSTR lpszVolumeMountPoint, DWORD cchBufferLength );
7130 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_FindNextVolumeMountPointW( HANDLE hFindVolumeMountPoint, LPWSTR lpszVolumeMountPoint, DWORD cchBufferLength )
7131 {
7132     static FN_FindNextVolumeMountPointW *pfn = 0;
7133     if (!pfn)
7134         kPrf2WrapResolve((void **)&pfn, "FindNextVolumeMountPointW", &g_Kernel32);
7135     return pfn( hFindVolumeMountPoint, lpszVolumeMountPoint, cchBufferLength );
7136 }
7137
7138 typedef BOOL WINAPI FN_FindVolumeMountPointClose( HANDLE hFindVolumeMountPoint );
7139 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_FindVolumeMountPointClose( HANDLE hFindVolumeMountPoint )
7140 {
7141     static FN_FindVolumeMountPointClose *pfn = 0;
7142     if (!pfn)
7143         kPrf2WrapResolve((void **)&pfn, "FindVolumeMountPointClose", &g_Kernel32);
7144     return pfn( hFindVolumeMountPoint );
7145 }
7146
7147 typedef BOOL WINAPI FN_SetVolumeMountPointA( LPCSTR lpszVolumeMountPoint, LPCSTR lpszVolumeName );
7148 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetVolumeMountPointA( LPCSTR lpszVolumeMountPoint, LPCSTR lpszVolumeName )
7149 {
7150     static FN_SetVolumeMountPointA *pfn = 0;
7151     if (!pfn)
7152         kPrf2WrapResolve((void **)&pfn, "SetVolumeMountPointA", &g_Kernel32);
7153     return pfn( lpszVolumeMountPoint, lpszVolumeName );
7154 }
7155
7156 typedef BOOL WINAPI FN_SetVolumeMountPointW( LPCWSTR lpszVolumeMountPoint, LPCWSTR lpszVolumeName );
7157 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetVolumeMountPointW( LPCWSTR lpszVolumeMountPoint, LPCWSTR lpszVolumeName )
7158 {
7159     static FN_SetVolumeMountPointW *pfn = 0;
7160     if (!pfn)
7161         kPrf2WrapResolve((void **)&pfn, "SetVolumeMountPointW", &g_Kernel32);
7162     return pfn( lpszVolumeMountPoint, lpszVolumeName );
7163 }
7164
7165 typedef BOOL WINAPI FN_DeleteVolumeMountPointA( LPCSTR lpszVolumeMountPoint );
7166 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_DeleteVolumeMountPointA( LPCSTR lpszVolumeMountPoint )
7167 {
7168     static FN_DeleteVolumeMountPointA *pfn = 0;
7169     if (!pfn)
7170         kPrf2WrapResolve((void **)&pfn, "DeleteVolumeMountPointA", &g_Kernel32);
7171     return pfn( lpszVolumeMountPoint );
7172 }
7173
7174 typedef BOOL WINAPI FN_DeleteVolumeMountPointW( LPCWSTR lpszVolumeMountPoint );
7175 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_DeleteVolumeMountPointW( LPCWSTR lpszVolumeMountPoint )
7176 {
7177     static FN_DeleteVolumeMountPointW *pfn = 0;
7178     if (!pfn)
7179         kPrf2WrapResolve((void **)&pfn, "DeleteVolumeMountPointW", &g_Kernel32);
7180     return pfn( lpszVolumeMountPoint );
7181 }
7182
7183 typedef BOOL WINAPI FN_GetVolumeNameForVolumeMountPointA( LPCSTR lpszVolumeMountPoint, LPSTR lpszVolumeName, DWORD cchBufferLength );
7184 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetVolumeNameForVolumeMountPointA( LPCSTR lpszVolumeMountPoint, LPSTR lpszVolumeName, DWORD cchBufferLength )
7185 {
7186     static FN_GetVolumeNameForVolumeMountPointA *pfn = 0;
7187     if (!pfn)
7188         kPrf2WrapResolve((void **)&pfn, "GetVolumeNameForVolumeMountPointA", &g_Kernel32);
7189     return pfn( lpszVolumeMountPoint, lpszVolumeName, cchBufferLength );
7190 }
7191
7192 typedef BOOL WINAPI FN_GetVolumeNameForVolumeMountPointW( LPCWSTR lpszVolumeMountPoint, LPWSTR lpszVolumeName, DWORD cchBufferLength );
7193 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetVolumeNameForVolumeMountPointW( LPCWSTR lpszVolumeMountPoint, LPWSTR lpszVolumeName, DWORD cchBufferLength )
7194 {
7195     static FN_GetVolumeNameForVolumeMountPointW *pfn = 0;
7196     if (!pfn)
7197         kPrf2WrapResolve((void **)&pfn, "GetVolumeNameForVolumeMountPointW", &g_Kernel32);
7198     return pfn( lpszVolumeMountPoint, lpszVolumeName, cchBufferLength );
7199 }
7200
7201 typedef BOOL WINAPI FN_GetVolumePathNameA( LPCSTR lpszFileName, LPSTR lpszVolumePathName, DWORD cchBufferLength );
7202 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetVolumePathNameA( LPCSTR lpszFileName, LPSTR lpszVolumePathName, DWORD cchBufferLength )
7203 {
7204     static FN_GetVolumePathNameA *pfn = 0;
7205     if (!pfn)
7206         kPrf2WrapResolve((void **)&pfn, "GetVolumePathNameA", &g_Kernel32);
7207     return pfn( lpszFileName, lpszVolumePathName, cchBufferLength );
7208 }
7209
7210 typedef BOOL WINAPI FN_GetVolumePathNameW( LPCWSTR lpszFileName, LPWSTR lpszVolumePathName, DWORD cchBufferLength );
7211 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetVolumePathNameW( LPCWSTR lpszFileName, LPWSTR lpszVolumePathName, DWORD cchBufferLength )
7212 {
7213     static FN_GetVolumePathNameW *pfn = 0;
7214     if (!pfn)
7215         kPrf2WrapResolve((void **)&pfn, "GetVolumePathNameW", &g_Kernel32);
7216     return pfn( lpszFileName, lpszVolumePathName, cchBufferLength );
7217 }
7218
7219 typedef BOOL WINAPI FN_GetVolumePathNamesForVolumeNameA( LPCSTR lpszVolumeName, LPCH lpszVolumePathNames, DWORD cchBufferLength, PDWORD lpcchReturnLength );
7220 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetVolumePathNamesForVolumeNameA( LPCSTR lpszVolumeName, LPCH lpszVolumePathNames, DWORD cchBufferLength, PDWORD lpcchReturnLength )
7221 {
7222     static FN_GetVolumePathNamesForVolumeNameA *pfn = 0;
7223     if (!pfn)
7224         kPrf2WrapResolve((void **)&pfn, "GetVolumePathNamesForVolumeNameA", &g_Kernel32);
7225     return pfn( lpszVolumeName, lpszVolumePathNames, cchBufferLength, lpcchReturnLength );
7226 }
7227
7228 typedef BOOL WINAPI FN_GetVolumePathNamesForVolumeNameW( LPCWSTR lpszVolumeName, LPWCH lpszVolumePathNames, DWORD cchBufferLength, PDWORD lpcchReturnLength );
7229 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetVolumePathNamesForVolumeNameW( LPCWSTR lpszVolumeName, LPWCH lpszVolumePathNames, DWORD cchBufferLength, PDWORD lpcchReturnLength )
7230 {
7231     static FN_GetVolumePathNamesForVolumeNameW *pfn = 0;
7232     if (!pfn)
7233         kPrf2WrapResolve((void **)&pfn, "GetVolumePathNamesForVolumeNameW", &g_Kernel32);
7234     return pfn( lpszVolumeName, lpszVolumePathNames, cchBufferLength, lpcchReturnLength );
7235 }
7236
7237 typedef HANDLE WINAPI FN_CreateActCtxA( PCACTCTXA pActCtx );
7238 __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_CreateActCtxA( PCACTCTXA pActCtx )
7239 {
7240     static FN_CreateActCtxA *pfn = 0;
7241     if (!pfn)
7242         kPrf2WrapResolve((void **)&pfn, "CreateActCtxA", &g_Kernel32);
7243     return pfn( pActCtx );
7244 }
7245
7246 typedef HANDLE WINAPI FN_CreateActCtxW( PCACTCTXW pActCtx );
7247 __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_CreateActCtxW( PCACTCTXW pActCtx )
7248 {
7249     static FN_CreateActCtxW *pfn = 0;
7250     if (!pfn)
7251         kPrf2WrapResolve((void **)&pfn, "CreateActCtxW", &g_Kernel32);
7252     return pfn( pActCtx );
7253 }
7254
7255 typedef VOID WINAPI FN_AddRefActCtx( HANDLE hActCtx );
7256 __declspec(dllexport) VOID WINAPI kPrf2Wrap_AddRefActCtx( HANDLE hActCtx )
7257 {
7258     static FN_AddRefActCtx *pfn = 0;
7259     if (!pfn)
7260         kPrf2WrapResolve((void **)&pfn, "AddRefActCtx", &g_Kernel32);
7261     pfn( hActCtx );
7262 }
7263
7264 typedef VOID WINAPI FN_ReleaseActCtx( HANDLE hActCtx );
7265 __declspec(dllexport) VOID WINAPI kPrf2Wrap_ReleaseActCtx( HANDLE hActCtx )
7266 {
7267     static FN_ReleaseActCtx *pfn = 0;
7268     if (!pfn)
7269         kPrf2WrapResolve((void **)&pfn, "ReleaseActCtx", &g_Kernel32);
7270     pfn( hActCtx );
7271 }
7272
7273 typedef BOOL WINAPI FN_ZombifyActCtx( HANDLE hActCtx );
7274 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_ZombifyActCtx( HANDLE hActCtx )
7275 {
7276     static FN_ZombifyActCtx *pfn = 0;
7277     if (!pfn)
7278         kPrf2WrapResolve((void **)&pfn, "ZombifyActCtx", &g_Kernel32);
7279     return pfn( hActCtx );
7280 }
7281
7282 typedef BOOL WINAPI FN_ActivateActCtx( HANDLE hActCtx, ULONG_PTR * lpCookie );
7283 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_ActivateActCtx( HANDLE hActCtx, ULONG_PTR * lpCookie )
7284 {
7285     static FN_ActivateActCtx *pfn = 0;
7286     if (!pfn)
7287         kPrf2WrapResolve((void **)&pfn, "ActivateActCtx", &g_Kernel32);
7288     return pfn( hActCtx, lpCookie );
7289 }
7290
7291 typedef BOOL WINAPI FN_DeactivateActCtx( DWORD dwFlags, ULONG_PTR ulCookie );
7292 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_DeactivateActCtx( DWORD dwFlags, ULONG_PTR ulCookie )
7293 {
7294     static FN_DeactivateActCtx *pfn = 0;
7295     if (!pfn)
7296         kPrf2WrapResolve((void **)&pfn, "DeactivateActCtx", &g_Kernel32);
7297     return pfn( dwFlags, ulCookie );
7298 }
7299
7300 typedef BOOL WINAPI FN_GetCurrentActCtx( HANDLE * lphActCtx );
7301 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetCurrentActCtx( HANDLE * lphActCtx )
7302 {
7303     static FN_GetCurrentActCtx *pfn = 0;
7304     if (!pfn)
7305         kPrf2WrapResolve((void **)&pfn, "GetCurrentActCtx", &g_Kernel32);
7306     return pfn( lphActCtx );
7307 }
7308
7309 typedef BOOL WINAPI FN_FindActCtxSectionStringA( DWORD dwFlags, const GUID * lpExtensionGuid, ULONG ulSectionId, LPCSTR lpStringToFind, PACTCTX_SECTION_KEYED_DATA ReturnedData );
7310 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_FindActCtxSectionStringA( DWORD dwFlags, const GUID * lpExtensionGuid, ULONG ulSectionId, LPCSTR lpStringToFind, PACTCTX_SECTION_KEYED_DATA ReturnedData )
7311 {
7312     static FN_FindActCtxSectionStringA *pfn = 0;
7313     if (!pfn)
7314         kPrf2WrapResolve((void **)&pfn, "FindActCtxSectionStringA", &g_Kernel32);
7315     return pfn( dwFlags, lpExtensionGuid, ulSectionId, lpStringToFind, ReturnedData );
7316 }
7317
7318 typedef BOOL WINAPI FN_FindActCtxSectionStringW( DWORD dwFlags, const GUID * lpExtensionGuid, ULONG ulSectionId, LPCWSTR lpStringToFind, PACTCTX_SECTION_KEYED_DATA ReturnedData );
7319 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_FindActCtxSectionStringW( DWORD dwFlags, const GUID * lpExtensionGuid, ULONG ulSectionId, LPCWSTR lpStringToFind, PACTCTX_SECTION_KEYED_DATA ReturnedData )
7320 {
7321     static FN_FindActCtxSectionStringW *pfn = 0;
7322     if (!pfn)
7323         kPrf2WrapResolve((void **)&pfn, "FindActCtxSectionStringW", &g_Kernel32);
7324     return pfn( dwFlags, lpExtensionGuid, ulSectionId, lpStringToFind, ReturnedData );
7325 }
7326
7327 typedef BOOL WINAPI FN_FindActCtxSectionGuid( DWORD dwFlags, const GUID * lpExtensionGuid, ULONG ulSectionId, const GUID * lpGuidToFind, PACTCTX_SECTION_KEYED_DATA ReturnedData );
7328 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_FindActCtxSectionGuid( DWORD dwFlags, const GUID * lpExtensionGuid, ULONG ulSectionId, const GUID * lpGuidToFind, PACTCTX_SECTION_KEYED_DATA ReturnedData )
7329 {
7330     static FN_FindActCtxSectionGuid *pfn = 0;
7331     if (!pfn)
7332         kPrf2WrapResolve((void **)&pfn, "FindActCtxSectionGuid", &g_Kernel32);
7333     return pfn( dwFlags, lpExtensionGuid, ulSectionId, lpGuidToFind, ReturnedData );
7334 }
7335
7336 typedef BOOL WINAPI FN_QueryActCtxW( DWORD dwFlags, HANDLE hActCtx, PVOID pvSubInstance, ULONG ulInfoClass, PVOID pvBuffer, SIZE_T cbBuffer, SIZE_T * pcbWrittenOrRequired );
7337 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_QueryActCtxW( DWORD dwFlags, HANDLE hActCtx, PVOID pvSubInstance, ULONG ulInfoClass, PVOID pvBuffer, SIZE_T cbBuffer, SIZE_T * pcbWrittenOrRequired )
7338 {
7339     static FN_QueryActCtxW *pfn = 0;
7340     if (!pfn)
7341         kPrf2WrapResolve((void **)&pfn, "QueryActCtxW", &g_Kernel32);
7342     return pfn( dwFlags, hActCtx, pvSubInstance, ulInfoClass, pvBuffer, cbBuffer, pcbWrittenOrRequired );
7343 }
7344
7345 typedef BOOL WINAPI FN_ProcessIdToSessionId( DWORD dwProcessId, DWORD * pSessionId );
7346 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_ProcessIdToSessionId( DWORD dwProcessId, DWORD * pSessionId )
7347 {
7348     static FN_ProcessIdToSessionId *pfn = 0;
7349     if (!pfn)
7350         kPrf2WrapResolve((void **)&pfn, "ProcessIdToSessionId", &g_Kernel32);
7351     return pfn( dwProcessId, pSessionId );
7352 }
7353
7354 typedef DWORD WINAPI FN_WTSGetActiveConsoleSessionId( );
7355 __declspec(dllexport) DWORD WINAPI kPrf2Wrap_WTSGetActiveConsoleSessionId( )
7356 {
7357     static FN_WTSGetActiveConsoleSessionId *pfn = 0;
7358     if (!pfn)
7359         kPrf2WrapResolve((void **)&pfn, "WTSGetActiveConsoleSessionId", &g_Kernel32);
7360     return pfn( );
7361 }
7362
7363 typedef BOOL WINAPI FN_IsWow64Process( HANDLE hProcess, PBOOL Wow64Process );
7364 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_IsWow64Process( HANDLE hProcess, PBOOL Wow64Process )
7365 {
7366     static FN_IsWow64Process *pfn = 0;
7367     if (!pfn)
7368         kPrf2WrapResolve((void **)&pfn, "IsWow64Process", &g_Kernel32);
7369     return pfn( hProcess, Wow64Process );
7370 }
7371
7372 typedef BOOL WINAPI FN_GetLogicalProcessorInformation( PSYSTEM_LOGICAL_PROCESSOR_INFORMATION Buffer, PDWORD ReturnedLength );
7373 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetLogicalProcessorInformation( PSYSTEM_LOGICAL_PROCESSOR_INFORMATION Buffer, PDWORD ReturnedLength )
7374 {
7375     static FN_GetLogicalProcessorInformation *pfn = 0;
7376     if (!pfn)
7377         kPrf2WrapResolve((void **)&pfn, "GetLogicalProcessorInformation", &g_Kernel32);
7378     return pfn( Buffer, ReturnedLength );
7379 }
7380
7381 typedef BOOL WINAPI FN_GetNumaHighestNodeNumber( PULONG HighestNodeNumber );
7382 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetNumaHighestNodeNumber( PULONG HighestNodeNumber )
7383 {
7384     static FN_GetNumaHighestNodeNumber *pfn = 0;
7385     if (!pfn)
7386         kPrf2WrapResolve((void **)&pfn, "GetNumaHighestNodeNumber", &g_Kernel32);
7387     return pfn( HighestNodeNumber );
7388 }
7389
7390 typedef BOOL WINAPI FN_GetNumaProcessorNode( UCHAR Processor, PUCHAR NodeNumber );
7391 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetNumaProcessorNode( UCHAR Processor, PUCHAR NodeNumber )
7392 {
7393     static FN_GetNumaProcessorNode *pfn = 0;
7394     if (!pfn)
7395         kPrf2WrapResolve((void **)&pfn, "GetNumaProcessorNode", &g_Kernel32);
7396     return pfn( Processor, NodeNumber );
7397 }
7398
7399 typedef BOOL WINAPI FN_GetNumaNodeProcessorMask( UCHAR Node, PULONGLONG ProcessorMask );
7400 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetNumaNodeProcessorMask( UCHAR Node, PULONGLONG ProcessorMask )
7401 {
7402     static FN_GetNumaNodeProcessorMask *pfn = 0;
7403     if (!pfn)
7404         kPrf2WrapResolve((void **)&pfn, "GetNumaNodeProcessorMask", &g_Kernel32);
7405     return pfn( Node, ProcessorMask );
7406 }
7407
7408 typedef BOOL WINAPI FN_GetNumaAvailableMemoryNode( UCHAR Node, PULONGLONG AvailableBytes );
7409 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetNumaAvailableMemoryNode( UCHAR Node, PULONGLONG AvailableBytes )
7410 {
7411     static FN_GetNumaAvailableMemoryNode *pfn = 0;
7412     if (!pfn)
7413         kPrf2WrapResolve((void **)&pfn, "GetNumaAvailableMemoryNode", &g_Kernel32);
7414     return pfn( Node, AvailableBytes );
7415 }
7416
7417 typedef BOOL WINAPI FN_PeekConsoleInputA( IN HANDLE hConsoleInput, OUT PINPUT_RECORD lpBuffer, IN DWORD nLength, OUT LPDWORD lpNumberOfEventsRead );
7418 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_PeekConsoleInputA( IN HANDLE hConsoleInput, OUT PINPUT_RECORD lpBuffer, IN DWORD nLength, OUT LPDWORD lpNumberOfEventsRead )
7419 {
7420     static FN_PeekConsoleInputA *pfn = 0;
7421     if (!pfn)
7422         kPrf2WrapResolve((void **)&pfn, "PeekConsoleInputA", &g_Kernel32);
7423     return pfn( hConsoleInput, lpBuffer, nLength, lpNumberOfEventsRead );
7424 }
7425
7426 typedef BOOL WINAPI FN_PeekConsoleInputW( IN HANDLE hConsoleInput, OUT PINPUT_RECORD lpBuffer, IN DWORD nLength, OUT LPDWORD lpNumberOfEventsRead );
7427 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_PeekConsoleInputW( IN HANDLE hConsoleInput, OUT PINPUT_RECORD lpBuffer, IN DWORD nLength, OUT LPDWORD lpNumberOfEventsRead )
7428 {
7429     static FN_PeekConsoleInputW *pfn = 0;
7430     if (!pfn)
7431         kPrf2WrapResolve((void **)&pfn, "PeekConsoleInputW", &g_Kernel32);
7432     return pfn( hConsoleInput, lpBuffer, nLength, lpNumberOfEventsRead );
7433 }
7434
7435 typedef BOOL WINAPI FN_ReadConsoleInputA( IN HANDLE hConsoleInput, OUT PINPUT_RECORD lpBuffer, IN DWORD nLength, OUT LPDWORD lpNumberOfEventsRead );
7436 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_ReadConsoleInputA( IN HANDLE hConsoleInput, OUT PINPUT_RECORD lpBuffer, IN DWORD nLength, OUT LPDWORD lpNumberOfEventsRead )
7437 {
7438     static FN_ReadConsoleInputA *pfn = 0;
7439     if (!pfn)
7440         kPrf2WrapResolve((void **)&pfn, "ReadConsoleInputA", &g_Kernel32);
7441     return pfn( hConsoleInput, lpBuffer, nLength, lpNumberOfEventsRead );
7442 }
7443
7444 typedef BOOL WINAPI FN_ReadConsoleInputW( IN HANDLE hConsoleInput, OUT PINPUT_RECORD lpBuffer, IN DWORD nLength, OUT LPDWORD lpNumberOfEventsRead );
7445 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_ReadConsoleInputW( IN HANDLE hConsoleInput, OUT PINPUT_RECORD lpBuffer, IN DWORD nLength, OUT LPDWORD lpNumberOfEventsRead )
7446 {
7447     static FN_ReadConsoleInputW *pfn = 0;
7448     if (!pfn)
7449         kPrf2WrapResolve((void **)&pfn, "ReadConsoleInputW", &g_Kernel32);
7450     return pfn( hConsoleInput, lpBuffer, nLength, lpNumberOfEventsRead );
7451 }
7452
7453 typedef BOOL WINAPI FN_WriteConsoleInputA( IN HANDLE hConsoleInput, IN CONST INPUT_RECORD * lpBuffer, IN DWORD nLength, OUT LPDWORD lpNumberOfEventsWritten );
7454 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_WriteConsoleInputA( IN HANDLE hConsoleInput, IN CONST INPUT_RECORD * lpBuffer, IN DWORD nLength, OUT LPDWORD lpNumberOfEventsWritten )
7455 {
7456     static FN_WriteConsoleInputA *pfn = 0;
7457     if (!pfn)
7458         kPrf2WrapResolve((void **)&pfn, "WriteConsoleInputA", &g_Kernel32);
7459     return pfn( hConsoleInput, lpBuffer, nLength, lpNumberOfEventsWritten );
7460 }
7461
7462 typedef BOOL WINAPI FN_WriteConsoleInputW( IN HANDLE hConsoleInput, IN CONST INPUT_RECORD * lpBuffer, IN DWORD nLength, OUT LPDWORD lpNumberOfEventsWritten );
7463 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_WriteConsoleInputW( IN HANDLE hConsoleInput, IN CONST INPUT_RECORD * lpBuffer, IN DWORD nLength, OUT LPDWORD lpNumberOfEventsWritten )
7464 {
7465     static FN_WriteConsoleInputW *pfn = 0;
7466     if (!pfn)
7467         kPrf2WrapResolve((void **)&pfn, "WriteConsoleInputW", &g_Kernel32);
7468     return pfn( hConsoleInput, lpBuffer, nLength, lpNumberOfEventsWritten );
7469 }
7470
7471 typedef BOOL WINAPI FN_ReadConsoleOutputA( IN HANDLE hConsoleOutput, OUT PCHAR_INFO lpBuffer, IN COORD dwBufferSize, IN COORD dwBufferCoord, IN OUT PSMALL_RECT lpReadRegion );
7472 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_ReadConsoleOutputA( IN HANDLE hConsoleOutput, OUT PCHAR_INFO lpBuffer, IN COORD dwBufferSize, IN COORD dwBufferCoord, IN OUT PSMALL_RECT lpReadRegion )
7473 {
7474     static FN_ReadConsoleOutputA *pfn = 0;
7475     if (!pfn)
7476         kPrf2WrapResolve((void **)&pfn, "ReadConsoleOutputA", &g_Kernel32);
7477     return pfn( hConsoleOutput, lpBuffer, dwBufferSize, dwBufferCoord, lpReadRegion );
7478 }
7479
7480 typedef BOOL WINAPI FN_ReadConsoleOutputW( IN HANDLE hConsoleOutput, OUT PCHAR_INFO lpBuffer, IN COORD dwBufferSize, IN COORD dwBufferCoord, IN OUT PSMALL_RECT lpReadRegion );
7481 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_ReadConsoleOutputW( IN HANDLE hConsoleOutput, OUT PCHAR_INFO lpBuffer, IN COORD dwBufferSize, IN COORD dwBufferCoord, IN OUT PSMALL_RECT lpReadRegion )
7482 {
7483     static FN_ReadConsoleOutputW *pfn = 0;
7484     if (!pfn)
7485         kPrf2WrapResolve((void **)&pfn, "ReadConsoleOutputW", &g_Kernel32);
7486     return pfn( hConsoleOutput, lpBuffer, dwBufferSize, dwBufferCoord, lpReadRegion );
7487 }
7488
7489 typedef BOOL WINAPI FN_WriteConsoleOutputA( IN HANDLE hConsoleOutput, IN CONST CHAR_INFO * lpBuffer, IN COORD dwBufferSize, IN COORD dwBufferCoord, IN OUT PSMALL_RECT lpWriteRegion );
7490 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_WriteConsoleOutputA( IN HANDLE hConsoleOutput, IN CONST CHAR_INFO * lpBuffer, IN COORD dwBufferSize, IN COORD dwBufferCoord, IN OUT PSMALL_RECT lpWriteRegion )
7491 {
7492     static FN_WriteConsoleOutputA *pfn = 0;
7493     if (!pfn)
7494         kPrf2WrapResolve((void **)&pfn, "WriteConsoleOutputA", &g_Kernel32);
7495     return pfn( hConsoleOutput, lpBuffer, dwBufferSize, dwBufferCoord, lpWriteRegion );
7496 }
7497
7498 typedef BOOL WINAPI FN_WriteConsoleOutputW( IN HANDLE hConsoleOutput, IN CONST CHAR_INFO * lpBuffer, IN COORD dwBufferSize, IN COORD dwBufferCoord, IN OUT PSMALL_RECT lpWriteRegion );
7499 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_WriteConsoleOutputW( IN HANDLE hConsoleOutput, IN CONST CHAR_INFO * lpBuffer, IN COORD dwBufferSize, IN COORD dwBufferCoord, IN OUT PSMALL_RECT lpWriteRegion )
7500 {
7501     static FN_WriteConsoleOutputW *pfn = 0;
7502     if (!pfn)
7503         kPrf2WrapResolve((void **)&pfn, "WriteConsoleOutputW", &g_Kernel32);
7504     return pfn( hConsoleOutput, lpBuffer, dwBufferSize, dwBufferCoord, lpWriteRegion );
7505 }
7506
7507 typedef BOOL WINAPI FN_ReadConsoleOutputCharacterA( IN HANDLE hConsoleOutput, OUT LPSTR lpCharacter, IN DWORD nLength, IN COORD dwReadCoord, OUT LPDWORD lpNumberOfCharsRead );
7508 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_ReadConsoleOutputCharacterA( IN HANDLE hConsoleOutput, OUT LPSTR lpCharacter, IN DWORD nLength, IN COORD dwReadCoord, OUT LPDWORD lpNumberOfCharsRead )
7509 {
7510     static FN_ReadConsoleOutputCharacterA *pfn = 0;
7511     if (!pfn)
7512         kPrf2WrapResolve((void **)&pfn, "ReadConsoleOutputCharacterA", &g_Kernel32);
7513     return pfn( hConsoleOutput, lpCharacter, nLength, dwReadCoord, lpNumberOfCharsRead );
7514 }
7515
7516 typedef BOOL WINAPI FN_ReadConsoleOutputCharacterW( IN HANDLE hConsoleOutput, OUT LPWSTR lpCharacter, IN DWORD nLength, IN COORD dwReadCoord, OUT LPDWORD lpNumberOfCharsRead );
7517 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_ReadConsoleOutputCharacterW( IN HANDLE hConsoleOutput, OUT LPWSTR lpCharacter, IN DWORD nLength, IN COORD dwReadCoord, OUT LPDWORD lpNumberOfCharsRead )
7518 {
7519     static FN_ReadConsoleOutputCharacterW *pfn = 0;
7520     if (!pfn)
7521         kPrf2WrapResolve((void **)&pfn, "ReadConsoleOutputCharacterW", &g_Kernel32);
7522     return pfn( hConsoleOutput, lpCharacter, nLength, dwReadCoord, lpNumberOfCharsRead );
7523 }
7524
7525 typedef BOOL WINAPI FN_ReadConsoleOutputAttribute( IN HANDLE hConsoleOutput, OUT LPWORD lpAttribute, IN DWORD nLength, IN COORD dwReadCoord, OUT LPDWORD lpNumberOfAttrsRead );
7526 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_ReadConsoleOutputAttribute( IN HANDLE hConsoleOutput, OUT LPWORD lpAttribute, IN DWORD nLength, IN COORD dwReadCoord, OUT LPDWORD lpNumberOfAttrsRead )
7527 {
7528     static FN_ReadConsoleOutputAttribute *pfn = 0;
7529     if (!pfn)
7530         kPrf2WrapResolve((void **)&pfn, "ReadConsoleOutputAttribute", &g_Kernel32);
7531     return pfn( hConsoleOutput, lpAttribute, nLength, dwReadCoord, lpNumberOfAttrsRead );
7532 }
7533
7534 typedef BOOL WINAPI FN_WriteConsoleOutputCharacterA( IN HANDLE hConsoleOutput, IN LPCSTR lpCharacter, IN DWORD nLength, IN COORD dwWriteCoord, OUT LPDWORD lpNumberOfCharsWritten );
7535 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_WriteConsoleOutputCharacterA( IN HANDLE hConsoleOutput, IN LPCSTR lpCharacter, IN DWORD nLength, IN COORD dwWriteCoord, OUT LPDWORD lpNumberOfCharsWritten )
7536 {
7537     static FN_WriteConsoleOutputCharacterA *pfn = 0;
7538     if (!pfn)
7539         kPrf2WrapResolve((void **)&pfn, "WriteConsoleOutputCharacterA", &g_Kernel32);
7540     return pfn( hConsoleOutput, lpCharacter, nLength, dwWriteCoord, lpNumberOfCharsWritten );
7541 }
7542
7543 typedef BOOL WINAPI FN_WriteConsoleOutputCharacterW( IN HANDLE hConsoleOutput, IN LPCWSTR lpCharacter, IN DWORD nLength, IN COORD dwWriteCoord, OUT LPDWORD lpNumberOfCharsWritten );
7544 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_WriteConsoleOutputCharacterW( IN HANDLE hConsoleOutput, IN LPCWSTR lpCharacter, IN DWORD nLength, IN COORD dwWriteCoord, OUT LPDWORD lpNumberOfCharsWritten )
7545 {
7546     static FN_WriteConsoleOutputCharacterW *pfn = 0;
7547     if (!pfn)
7548         kPrf2WrapResolve((void **)&pfn, "WriteConsoleOutputCharacterW", &g_Kernel32);
7549     return pfn( hConsoleOutput, lpCharacter, nLength, dwWriteCoord, lpNumberOfCharsWritten );
7550 }
7551
7552 typedef BOOL WINAPI FN_WriteConsoleOutputAttribute( IN HANDLE hConsoleOutput, IN CONST WORD * lpAttribute, IN DWORD nLength, IN COORD dwWriteCoord, OUT LPDWORD lpNumberOfAttrsWritten );
7553 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_WriteConsoleOutputAttribute( IN HANDLE hConsoleOutput, IN CONST WORD * lpAttribute, IN DWORD nLength, IN COORD dwWriteCoord, OUT LPDWORD lpNumberOfAttrsWritten )
7554 {
7555     static FN_WriteConsoleOutputAttribute *pfn = 0;
7556     if (!pfn)
7557         kPrf2WrapResolve((void **)&pfn, "WriteConsoleOutputAttribute", &g_Kernel32);
7558     return pfn( hConsoleOutput, lpAttribute, nLength, dwWriteCoord, lpNumberOfAttrsWritten );
7559 }
7560
7561 typedef BOOL WINAPI FN_FillConsoleOutputCharacterA( IN HANDLE hConsoleOutput, IN CHAR cCharacter, IN DWORD nLength, IN COORD dwWriteCoord, OUT LPDWORD lpNumberOfCharsWritten );
7562 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_FillConsoleOutputCharacterA( IN HANDLE hConsoleOutput, IN CHAR cCharacter, IN DWORD nLength, IN COORD dwWriteCoord, OUT LPDWORD lpNumberOfCharsWritten )
7563 {
7564     static FN_FillConsoleOutputCharacterA *pfn = 0;
7565     if (!pfn)
7566         kPrf2WrapResolve((void **)&pfn, "FillConsoleOutputCharacterA", &g_Kernel32);
7567     return pfn( hConsoleOutput, cCharacter, nLength, dwWriteCoord, lpNumberOfCharsWritten );
7568 }
7569
7570 typedef BOOL WINAPI FN_FillConsoleOutputCharacterW( IN HANDLE hConsoleOutput, IN WCHAR cCharacter, IN DWORD nLength, IN COORD dwWriteCoord, OUT LPDWORD lpNumberOfCharsWritten );
7571 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_FillConsoleOutputCharacterW( IN HANDLE hConsoleOutput, IN WCHAR cCharacter, IN DWORD nLength, IN COORD dwWriteCoord, OUT LPDWORD lpNumberOfCharsWritten )
7572 {
7573     static FN_FillConsoleOutputCharacterW *pfn = 0;
7574     if (!pfn)
7575         kPrf2WrapResolve((void **)&pfn, "FillConsoleOutputCharacterW", &g_Kernel32);
7576     return pfn( hConsoleOutput, cCharacter, nLength, dwWriteCoord, lpNumberOfCharsWritten );
7577 }
7578
7579 typedef BOOL WINAPI FN_FillConsoleOutputAttribute( IN HANDLE hConsoleOutput, IN WORD wAttribute, IN DWORD nLength, IN COORD dwWriteCoord, OUT LPDWORD lpNumberOfAttrsWritten );
7580 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_FillConsoleOutputAttribute( IN HANDLE hConsoleOutput, IN WORD wAttribute, IN DWORD nLength, IN COORD dwWriteCoord, OUT LPDWORD lpNumberOfAttrsWritten )
7581 {
7582     static FN_FillConsoleOutputAttribute *pfn = 0;
7583     if (!pfn)
7584         kPrf2WrapResolve((void **)&pfn, "FillConsoleOutputAttribute", &g_Kernel32);
7585     return pfn( hConsoleOutput, wAttribute, nLength, dwWriteCoord, lpNumberOfAttrsWritten );
7586 }
7587
7588 typedef BOOL WINAPI FN_GetConsoleMode( IN HANDLE hConsoleHandle, OUT LPDWORD lpMode );
7589 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetConsoleMode( IN HANDLE hConsoleHandle, OUT LPDWORD lpMode )
7590 {
7591     static FN_GetConsoleMode *pfn = 0;
7592     if (!pfn)
7593         kPrf2WrapResolve((void **)&pfn, "GetConsoleMode", &g_Kernel32);
7594     return pfn( hConsoleHandle, lpMode );
7595 }
7596
7597 typedef BOOL WINAPI FN_GetNumberOfConsoleInputEvents( IN HANDLE hConsoleInput, OUT LPDWORD lpNumberOfEvents );
7598 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetNumberOfConsoleInputEvents( IN HANDLE hConsoleInput, OUT LPDWORD lpNumberOfEvents )
7599 {
7600     static FN_GetNumberOfConsoleInputEvents *pfn = 0;
7601     if (!pfn)
7602         kPrf2WrapResolve((void **)&pfn, "GetNumberOfConsoleInputEvents", &g_Kernel32);
7603     return pfn( hConsoleInput, lpNumberOfEvents );
7604 }
7605
7606 typedef BOOL WINAPI FN_GetConsoleScreenBufferInfo( IN HANDLE hConsoleOutput, OUT PCONSOLE_SCREEN_BUFFER_INFO lpConsoleScreenBufferInfo );
7607 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetConsoleScreenBufferInfo( IN HANDLE hConsoleOutput, OUT PCONSOLE_SCREEN_BUFFER_INFO lpConsoleScreenBufferInfo )
7608 {
7609     static FN_GetConsoleScreenBufferInfo *pfn = 0;
7610     if (!pfn)
7611         kPrf2WrapResolve((void **)&pfn, "GetConsoleScreenBufferInfo", &g_Kernel32);
7612     return pfn( hConsoleOutput, lpConsoleScreenBufferInfo );
7613 }
7614
7615 typedef COORD WINAPI FN_GetLargestConsoleWindowSize( IN HANDLE hConsoleOutput );
7616 __declspec(dllexport) COORD WINAPI kPrf2Wrap_GetLargestConsoleWindowSize( IN HANDLE hConsoleOutput )
7617 {
7618     static FN_GetLargestConsoleWindowSize *pfn = 0;
7619     if (!pfn)
7620         kPrf2WrapResolve((void **)&pfn, "GetLargestConsoleWindowSize", &g_Kernel32);
7621     return pfn( hConsoleOutput );
7622 }
7623
7624 typedef BOOL WINAPI FN_GetConsoleCursorInfo( IN HANDLE hConsoleOutput, OUT PCONSOLE_CURSOR_INFO lpConsoleCursorInfo );
7625 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetConsoleCursorInfo( IN HANDLE hConsoleOutput, OUT PCONSOLE_CURSOR_INFO lpConsoleCursorInfo )
7626 {
7627     static FN_GetConsoleCursorInfo *pfn = 0;
7628     if (!pfn)
7629         kPrf2WrapResolve((void **)&pfn, "GetConsoleCursorInfo", &g_Kernel32);
7630     return pfn( hConsoleOutput, lpConsoleCursorInfo );
7631 }
7632
7633 typedef BOOL WINAPI FN_GetCurrentConsoleFont( IN HANDLE hConsoleOutput, IN BOOL bMaximumWindow, OUT PCONSOLE_FONT_INFO lpConsoleCurrentFont );
7634 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetCurrentConsoleFont( IN HANDLE hConsoleOutput, IN BOOL bMaximumWindow, OUT PCONSOLE_FONT_INFO lpConsoleCurrentFont )
7635 {
7636     static FN_GetCurrentConsoleFont *pfn = 0;
7637     if (!pfn)
7638         kPrf2WrapResolve((void **)&pfn, "GetCurrentConsoleFont", &g_Kernel32);
7639     return pfn( hConsoleOutput, bMaximumWindow, lpConsoleCurrentFont );
7640 }
7641
7642 typedef COORD WINAPI FN_GetConsoleFontSize( IN HANDLE hConsoleOutput, IN DWORD nFont );
7643 __declspec(dllexport) COORD WINAPI kPrf2Wrap_GetConsoleFontSize( IN HANDLE hConsoleOutput, IN DWORD nFont )
7644 {
7645     static FN_GetConsoleFontSize *pfn = 0;
7646     if (!pfn)
7647         kPrf2WrapResolve((void **)&pfn, "GetConsoleFontSize", &g_Kernel32);
7648     return pfn( hConsoleOutput, nFont );
7649 }
7650
7651 typedef BOOL WINAPI FN_GetConsoleSelectionInfo( OUT PCONSOLE_SELECTION_INFO lpConsoleSelectionInfo );
7652 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetConsoleSelectionInfo( OUT PCONSOLE_SELECTION_INFO lpConsoleSelectionInfo )
7653 {
7654     static FN_GetConsoleSelectionInfo *pfn = 0;
7655     if (!pfn)
7656         kPrf2WrapResolve((void **)&pfn, "GetConsoleSelectionInfo", &g_Kernel32);
7657     return pfn( lpConsoleSelectionInfo );
7658 }
7659
7660 typedef BOOL WINAPI FN_GetNumberOfConsoleMouseButtons( OUT LPDWORD lpNumberOfMouseButtons );
7661 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetNumberOfConsoleMouseButtons( OUT LPDWORD lpNumberOfMouseButtons )
7662 {
7663     static FN_GetNumberOfConsoleMouseButtons *pfn = 0;
7664     if (!pfn)
7665         kPrf2WrapResolve((void **)&pfn, "GetNumberOfConsoleMouseButtons", &g_Kernel32);
7666     return pfn( lpNumberOfMouseButtons );
7667 }
7668
7669 typedef BOOL WINAPI FN_SetConsoleMode( IN HANDLE hConsoleHandle, IN DWORD dwMode );
7670 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetConsoleMode( IN HANDLE hConsoleHandle, IN DWORD dwMode )
7671 {
7672     static FN_SetConsoleMode *pfn = 0;
7673     if (!pfn)
7674         kPrf2WrapResolve((void **)&pfn, "SetConsoleMode", &g_Kernel32);
7675     return pfn( hConsoleHandle, dwMode );
7676 }
7677
7678 typedef BOOL WINAPI FN_SetConsoleActiveScreenBuffer( IN HANDLE hConsoleOutput );
7679 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetConsoleActiveScreenBuffer( IN HANDLE hConsoleOutput )
7680 {
7681     static FN_SetConsoleActiveScreenBuffer *pfn = 0;
7682     if (!pfn)
7683         kPrf2WrapResolve((void **)&pfn, "SetConsoleActiveScreenBuffer", &g_Kernel32);
7684     return pfn( hConsoleOutput );
7685 }
7686
7687 typedef BOOL WINAPI FN_FlushConsoleInputBuffer( IN HANDLE hConsoleInput );
7688 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_FlushConsoleInputBuffer( IN HANDLE hConsoleInput )
7689 {
7690     static FN_FlushConsoleInputBuffer *pfn = 0;
7691     if (!pfn)
7692         kPrf2WrapResolve((void **)&pfn, "FlushConsoleInputBuffer", &g_Kernel32);
7693     return pfn( hConsoleInput );
7694 }
7695
7696 typedef BOOL WINAPI FN_SetConsoleScreenBufferSize( IN HANDLE hConsoleOutput, IN COORD dwSize );
7697 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetConsoleScreenBufferSize( IN HANDLE hConsoleOutput, IN COORD dwSize )
7698 {
7699     static FN_SetConsoleScreenBufferSize *pfn = 0;
7700     if (!pfn)
7701         kPrf2WrapResolve((void **)&pfn, "SetConsoleScreenBufferSize", &g_Kernel32);
7702     return pfn( hConsoleOutput, dwSize );
7703 }
7704
7705 typedef BOOL WINAPI FN_SetConsoleCursorPosition( IN HANDLE hConsoleOutput, IN COORD dwCursorPosition );
7706 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetConsoleCursorPosition( IN HANDLE hConsoleOutput, IN COORD dwCursorPosition )
7707 {
7708     static FN_SetConsoleCursorPosition *pfn = 0;
7709     if (!pfn)
7710         kPrf2WrapResolve((void **)&pfn, "SetConsoleCursorPosition", &g_Kernel32);
7711     return pfn( hConsoleOutput, dwCursorPosition );
7712 }
7713
7714 typedef BOOL WINAPI FN_SetConsoleCursorInfo( IN HANDLE hConsoleOutput, IN CONST CONSOLE_CURSOR_INFO * lpConsoleCursorInfo );
7715 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetConsoleCursorInfo( IN HANDLE hConsoleOutput, IN CONST CONSOLE_CURSOR_INFO * lpConsoleCursorInfo )
7716 {
7717     static FN_SetConsoleCursorInfo *pfn = 0;
7718     if (!pfn)
7719         kPrf2WrapResolve((void **)&pfn, "SetConsoleCursorInfo", &g_Kernel32);
7720     return pfn( hConsoleOutput, lpConsoleCursorInfo );
7721 }
7722
7723 typedef BOOL WINAPI FN_ScrollConsoleScreenBufferA( IN HANDLE hConsoleOutput, IN CONST SMALL_RECT * lpScrollRectangle, IN CONST SMALL_RECT * lpClipRectangle, IN COORD dwDestinationOrigin, IN CONST CHAR_INFO * lpFill );
7724 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_ScrollConsoleScreenBufferA( IN HANDLE hConsoleOutput, IN CONST SMALL_RECT * lpScrollRectangle, IN CONST SMALL_RECT * lpClipRectangle, IN COORD dwDestinationOrigin, IN CONST CHAR_INFO * lpFill )
7725 {
7726     static FN_ScrollConsoleScreenBufferA *pfn = 0;
7727     if (!pfn)
7728         kPrf2WrapResolve((void **)&pfn, "ScrollConsoleScreenBufferA", &g_Kernel32);
7729     return pfn( hConsoleOutput, lpScrollRectangle, lpClipRectangle, dwDestinationOrigin, lpFill );
7730 }
7731
7732 typedef BOOL WINAPI FN_ScrollConsoleScreenBufferW( IN HANDLE hConsoleOutput, IN CONST SMALL_RECT * lpScrollRectangle, IN CONST SMALL_RECT * lpClipRectangle, IN COORD dwDestinationOrigin, IN CONST CHAR_INFO * lpFill );
7733 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_ScrollConsoleScreenBufferW( IN HANDLE hConsoleOutput, IN CONST SMALL_RECT * lpScrollRectangle, IN CONST SMALL_RECT * lpClipRectangle, IN COORD dwDestinationOrigin, IN CONST CHAR_INFO * lpFill )
7734 {
7735     static FN_ScrollConsoleScreenBufferW *pfn = 0;
7736     if (!pfn)
7737         kPrf2WrapResolve((void **)&pfn, "ScrollConsoleScreenBufferW", &g_Kernel32);
7738     return pfn( hConsoleOutput, lpScrollRectangle, lpClipRectangle, dwDestinationOrigin, lpFill );
7739 }
7740
7741 typedef BOOL WINAPI FN_SetConsoleWindowInfo( IN HANDLE hConsoleOutput, IN BOOL bAbsolute, IN CONST SMALL_RECT * lpConsoleWindow );
7742 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetConsoleWindowInfo( IN HANDLE hConsoleOutput, IN BOOL bAbsolute, IN CONST SMALL_RECT * lpConsoleWindow )
7743 {
7744     static FN_SetConsoleWindowInfo *pfn = 0;
7745     if (!pfn)
7746         kPrf2WrapResolve((void **)&pfn, "SetConsoleWindowInfo", &g_Kernel32);
7747     return pfn( hConsoleOutput, bAbsolute, lpConsoleWindow );
7748 }
7749
7750 typedef BOOL WINAPI FN_SetConsoleTextAttribute( IN HANDLE hConsoleOutput, IN WORD wAttributes );
7751 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetConsoleTextAttribute( IN HANDLE hConsoleOutput, IN WORD wAttributes )
7752 {
7753     static FN_SetConsoleTextAttribute *pfn = 0;
7754     if (!pfn)
7755         kPrf2WrapResolve((void **)&pfn, "SetConsoleTextAttribute", &g_Kernel32);
7756     return pfn( hConsoleOutput, wAttributes );
7757 }
7758
7759 typedef BOOL WINAPI FN_SetConsoleCtrlHandler( IN PHANDLER_ROUTINE HandlerRoutine, IN BOOL Add );
7760 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetConsoleCtrlHandler( IN PHANDLER_ROUTINE HandlerRoutine, IN BOOL Add )
7761 {
7762     static FN_SetConsoleCtrlHandler *pfn = 0;
7763     if (!pfn)
7764         kPrf2WrapResolve((void **)&pfn, "SetConsoleCtrlHandler", &g_Kernel32);
7765     return pfn( HandlerRoutine, Add );
7766 }
7767
7768 typedef BOOL WINAPI FN_GenerateConsoleCtrlEvent( IN DWORD dwCtrlEvent, IN DWORD dwProcessGroupId );
7769 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GenerateConsoleCtrlEvent( IN DWORD dwCtrlEvent, IN DWORD dwProcessGroupId )
7770 {
7771     static FN_GenerateConsoleCtrlEvent *pfn = 0;
7772     if (!pfn)
7773         kPrf2WrapResolve((void **)&pfn, "GenerateConsoleCtrlEvent", &g_Kernel32);
7774     return pfn( dwCtrlEvent, dwProcessGroupId );
7775 }
7776
7777 typedef BOOL WINAPI FN_AllocConsole( VOID );
7778 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_AllocConsole( VOID )
7779 {
7780     static FN_AllocConsole *pfn = 0;
7781     if (!pfn)
7782         kPrf2WrapResolve((void **)&pfn, "AllocConsole", &g_Kernel32);
7783     return pfn ();
7784 }
7785
7786 typedef BOOL WINAPI FN_FreeConsole( VOID );
7787 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_FreeConsole( VOID )
7788 {
7789     static FN_FreeConsole *pfn = 0;
7790     if (!pfn)
7791         kPrf2WrapResolve((void **)&pfn, "FreeConsole", &g_Kernel32);
7792     return pfn ();
7793 }
7794
7795 typedef BOOL WINAPI FN_AttachConsole( IN DWORD dwProcessId );
7796 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_AttachConsole( IN DWORD dwProcessId )
7797 {
7798     static FN_AttachConsole *pfn = 0;
7799     if (!pfn)
7800         kPrf2WrapResolve((void **)&pfn, "AttachConsole", &g_Kernel32);
7801     return pfn( dwProcessId );
7802 }
7803
7804 typedef DWORD WINAPI FN_GetConsoleTitleA( OUT LPSTR lpConsoleTitle, IN DWORD nSize );
7805 __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetConsoleTitleA( OUT LPSTR lpConsoleTitle, IN DWORD nSize )
7806 {
7807     static FN_GetConsoleTitleA *pfn = 0;
7808     if (!pfn)
7809         kPrf2WrapResolve((void **)&pfn, "GetConsoleTitleA", &g_Kernel32);
7810     return pfn( lpConsoleTitle, nSize );
7811 }
7812
7813 typedef DWORD WINAPI FN_GetConsoleTitleW( OUT LPWSTR lpConsoleTitle, IN DWORD nSize );
7814 __declspec(dllexport) DWORD WINAPI kPrf2Wrap_GetConsoleTitleW( OUT LPWSTR lpConsoleTitle, IN DWORD nSize )
7815 {
7816     static FN_GetConsoleTitleW *pfn = 0;
7817     if (!pfn)
7818         kPrf2WrapResolve((void **)&pfn, "GetConsoleTitleW", &g_Kernel32);
7819     return pfn( lpConsoleTitle, nSize );
7820 }
7821
7822 typedef BOOL WINAPI FN_SetConsoleTitleA( IN LPCSTR lpConsoleTitle );
7823 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetConsoleTitleA( IN LPCSTR lpConsoleTitle )
7824 {
7825     static FN_SetConsoleTitleA *pfn = 0;
7826     if (!pfn)
7827         kPrf2WrapResolve((void **)&pfn, "SetConsoleTitleA", &g_Kernel32);
7828     return pfn( lpConsoleTitle );
7829 }
7830
7831 typedef BOOL WINAPI FN_SetConsoleTitleW( IN LPCWSTR lpConsoleTitle );
7832 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetConsoleTitleW( IN LPCWSTR lpConsoleTitle )
7833 {
7834     static FN_SetConsoleTitleW *pfn = 0;
7835     if (!pfn)
7836         kPrf2WrapResolve((void **)&pfn, "SetConsoleTitleW", &g_Kernel32);
7837     return pfn( lpConsoleTitle );
7838 }
7839
7840 typedef BOOL WINAPI FN_ReadConsoleA( IN HANDLE hConsoleInput, OUT LPVOID lpBuffer, IN DWORD nNumberOfCharsToRead, OUT LPDWORD lpNumberOfCharsRead, IN LPVOID lpReserved );
7841 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_ReadConsoleA( IN HANDLE hConsoleInput, OUT LPVOID lpBuffer, IN DWORD nNumberOfCharsToRead, OUT LPDWORD lpNumberOfCharsRead, IN LPVOID lpReserved )
7842 {
7843     static FN_ReadConsoleA *pfn = 0;
7844     if (!pfn)
7845         kPrf2WrapResolve((void **)&pfn, "ReadConsoleA", &g_Kernel32);
7846     return pfn( hConsoleInput, lpBuffer, nNumberOfCharsToRead, lpNumberOfCharsRead, lpReserved );
7847 }
7848
7849 typedef BOOL WINAPI FN_ReadConsoleW( IN HANDLE hConsoleInput, OUT LPVOID lpBuffer, IN DWORD nNumberOfCharsToRead, OUT LPDWORD lpNumberOfCharsRead, IN LPVOID lpReserved );
7850 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_ReadConsoleW( IN HANDLE hConsoleInput, OUT LPVOID lpBuffer, IN DWORD nNumberOfCharsToRead, OUT LPDWORD lpNumberOfCharsRead, IN LPVOID lpReserved )
7851 {
7852     static FN_ReadConsoleW *pfn = 0;
7853     if (!pfn)
7854         kPrf2WrapResolve((void **)&pfn, "ReadConsoleW", &g_Kernel32);
7855     return pfn( hConsoleInput, lpBuffer, nNumberOfCharsToRead, lpNumberOfCharsRead, lpReserved );
7856 }
7857
7858 typedef BOOL WINAPI FN_WriteConsoleA( IN HANDLE hConsoleOutput, IN CONST VOID * lpBuffer, IN DWORD nNumberOfCharsToWrite, OUT LPDWORD lpNumberOfCharsWritten, IN LPVOID lpReserved );
7859 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_WriteConsoleA( IN HANDLE hConsoleOutput, IN CONST VOID * lpBuffer, IN DWORD nNumberOfCharsToWrite, OUT LPDWORD lpNumberOfCharsWritten, IN LPVOID lpReserved )
7860 {
7861     static FN_WriteConsoleA *pfn = 0;
7862     if (!pfn)
7863         kPrf2WrapResolve((void **)&pfn, "WriteConsoleA", &g_Kernel32);
7864     return pfn( hConsoleOutput, lpBuffer, nNumberOfCharsToWrite, lpNumberOfCharsWritten, lpReserved );
7865 }
7866
7867 typedef BOOL WINAPI FN_WriteConsoleW( IN HANDLE hConsoleOutput, IN CONST VOID * lpBuffer, IN DWORD nNumberOfCharsToWrite, OUT LPDWORD lpNumberOfCharsWritten, IN LPVOID lpReserved );
7868 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_WriteConsoleW( IN HANDLE hConsoleOutput, IN CONST VOID * lpBuffer, IN DWORD nNumberOfCharsToWrite, OUT LPDWORD lpNumberOfCharsWritten, IN LPVOID lpReserved )
7869 {
7870     static FN_WriteConsoleW *pfn = 0;
7871     if (!pfn)
7872         kPrf2WrapResolve((void **)&pfn, "WriteConsoleW", &g_Kernel32);
7873     return pfn( hConsoleOutput, lpBuffer, nNumberOfCharsToWrite, lpNumberOfCharsWritten, lpReserved );
7874 }
7875
7876 typedef HANDLE WINAPI FN_CreateConsoleScreenBuffer( IN DWORD dwDesiredAccess, IN DWORD dwShareMode, IN CONST SECURITY_ATTRIBUTES * lpSecurityAttributes, IN DWORD dwFlags, IN LPVOID lpScreenBufferData );
7877 __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_CreateConsoleScreenBuffer( IN DWORD dwDesiredAccess, IN DWORD dwShareMode, IN CONST SECURITY_ATTRIBUTES * lpSecurityAttributes, IN DWORD dwFlags, IN LPVOID lpScreenBufferData )
7878 {
7879     static FN_CreateConsoleScreenBuffer *pfn = 0;
7880     if (!pfn)
7881         kPrf2WrapResolve((void **)&pfn, "CreateConsoleScreenBuffer", &g_Kernel32);
7882     return pfn( dwDesiredAccess, dwShareMode, lpSecurityAttributes, dwFlags, lpScreenBufferData );
7883 }
7884
7885 typedef UINT WINAPI FN_GetConsoleCP( VOID );
7886 __declspec(dllexport) UINT WINAPI kPrf2Wrap_GetConsoleCP( VOID )
7887 {
7888     static FN_GetConsoleCP *pfn = 0;
7889     if (!pfn)
7890         kPrf2WrapResolve((void **)&pfn, "GetConsoleCP", &g_Kernel32);
7891     return pfn ();
7892 }
7893
7894 typedef BOOL WINAPI FN_SetConsoleCP( IN UINT wCodePageID );
7895 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetConsoleCP( IN UINT wCodePageID )
7896 {
7897     static FN_SetConsoleCP *pfn = 0;
7898     if (!pfn)
7899         kPrf2WrapResolve((void **)&pfn, "SetConsoleCP", &g_Kernel32);
7900     return pfn( wCodePageID );
7901 }
7902
7903 typedef UINT WINAPI FN_GetConsoleOutputCP( VOID );
7904 __declspec(dllexport) UINT WINAPI kPrf2Wrap_GetConsoleOutputCP( VOID )
7905 {
7906     static FN_GetConsoleOutputCP *pfn = 0;
7907     if (!pfn)
7908         kPrf2WrapResolve((void **)&pfn, "GetConsoleOutputCP", &g_Kernel32);
7909     return pfn ();
7910 }
7911
7912 typedef BOOL WINAPI FN_SetConsoleOutputCP( IN UINT wCodePageID );
7913 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetConsoleOutputCP( IN UINT wCodePageID )
7914 {
7915     static FN_SetConsoleOutputCP *pfn = 0;
7916     if (!pfn)
7917         kPrf2WrapResolve((void **)&pfn, "SetConsoleOutputCP", &g_Kernel32);
7918     return pfn( wCodePageID );
7919 }
7920
7921 typedef BOOL APIENTRY FN_GetConsoleDisplayMode( OUT LPDWORD lpModeFlags );
7922 __declspec(dllexport) BOOL APIENTRY kPrf2Wrap_GetConsoleDisplayMode( OUT LPDWORD lpModeFlags )
7923 {
7924     static FN_GetConsoleDisplayMode *pfn = 0;
7925     if (!pfn)
7926         kPrf2WrapResolve((void **)&pfn, "GetConsoleDisplayMode", &g_Kernel32);
7927     return pfn( lpModeFlags );
7928 }
7929
7930 typedef HWND APIENTRY FN_GetConsoleWindow( VOID );
7931 __declspec(dllexport) HWND APIENTRY kPrf2Wrap_GetConsoleWindow( VOID )
7932 {
7933     static FN_GetConsoleWindow *pfn = 0;
7934     if (!pfn)
7935         kPrf2WrapResolve((void **)&pfn, "GetConsoleWindow", &g_Kernel32);
7936     return pfn ();
7937 }
7938
7939 typedef DWORD APIENTRY FN_GetConsoleProcessList( OUT LPDWORD lpdwProcessList, IN DWORD dwProcessCount );
7940 __declspec(dllexport) DWORD APIENTRY kPrf2Wrap_GetConsoleProcessList( OUT LPDWORD lpdwProcessList, IN DWORD dwProcessCount )
7941 {
7942     static FN_GetConsoleProcessList *pfn = 0;
7943     if (!pfn)
7944         kPrf2WrapResolve((void **)&pfn, "GetConsoleProcessList", &g_Kernel32);
7945     return pfn( lpdwProcessList, dwProcessCount );
7946 }
7947
7948 typedef BOOL APIENTRY FN_AddConsoleAliasA( IN LPSTR Source, IN LPSTR Target, IN LPSTR ExeName );
7949 __declspec(dllexport) BOOL APIENTRY kPrf2Wrap_AddConsoleAliasA( IN LPSTR Source, IN LPSTR Target, IN LPSTR ExeName )
7950 {
7951     static FN_AddConsoleAliasA *pfn = 0;
7952     if (!pfn)
7953         kPrf2WrapResolve((void **)&pfn, "AddConsoleAliasA", &g_Kernel32);
7954     return pfn( Source, Target, ExeName );
7955 }
7956
7957 typedef BOOL APIENTRY FN_AddConsoleAliasW( IN LPWSTR Source, IN LPWSTR Target, IN LPWSTR ExeName );
7958 __declspec(dllexport) BOOL APIENTRY kPrf2Wrap_AddConsoleAliasW( IN LPWSTR Source, IN LPWSTR Target, IN LPWSTR ExeName )
7959 {
7960     static FN_AddConsoleAliasW *pfn = 0;
7961     if (!pfn)
7962         kPrf2WrapResolve((void **)&pfn, "AddConsoleAliasW", &g_Kernel32);
7963     return pfn( Source, Target, ExeName );
7964 }
7965
7966 typedef DWORD APIENTRY FN_GetConsoleAliasA( IN LPSTR Source, OUT LPSTR TargetBuffer, IN DWORD TargetBufferLength, IN LPSTR ExeName );
7967 __declspec(dllexport) DWORD APIENTRY kPrf2Wrap_GetConsoleAliasA( IN LPSTR Source, OUT LPSTR TargetBuffer, IN DWORD TargetBufferLength, IN LPSTR ExeName )
7968 {
7969     static FN_GetConsoleAliasA *pfn = 0;
7970     if (!pfn)
7971         kPrf2WrapResolve((void **)&pfn, "GetConsoleAliasA", &g_Kernel32);
7972     return pfn( Source, TargetBuffer, TargetBufferLength, ExeName );
7973 }
7974
7975 typedef DWORD APIENTRY FN_GetConsoleAliasW( IN LPWSTR Source, OUT LPWSTR TargetBuffer, IN DWORD TargetBufferLength, IN LPWSTR ExeName );
7976 __declspec(dllexport) DWORD APIENTRY kPrf2Wrap_GetConsoleAliasW( IN LPWSTR Source, OUT LPWSTR TargetBuffer, IN DWORD TargetBufferLength, IN LPWSTR ExeName )
7977 {
7978     static FN_GetConsoleAliasW *pfn = 0;
7979     if (!pfn)
7980         kPrf2WrapResolve((void **)&pfn, "GetConsoleAliasW", &g_Kernel32);
7981     return pfn( Source, TargetBuffer, TargetBufferLength, ExeName );
7982 }
7983
7984 typedef DWORD APIENTRY FN_GetConsoleAliasesLengthA( IN LPSTR ExeName );
7985 __declspec(dllexport) DWORD APIENTRY kPrf2Wrap_GetConsoleAliasesLengthA( IN LPSTR ExeName )
7986 {
7987     static FN_GetConsoleAliasesLengthA *pfn = 0;
7988     if (!pfn)
7989         kPrf2WrapResolve((void **)&pfn, "GetConsoleAliasesLengthA", &g_Kernel32);
7990     return pfn( ExeName );
7991 }
7992
7993 typedef DWORD APIENTRY FN_GetConsoleAliasesLengthW( IN LPWSTR ExeName );
7994 __declspec(dllexport) DWORD APIENTRY kPrf2Wrap_GetConsoleAliasesLengthW( IN LPWSTR ExeName )
7995 {
7996     static FN_GetConsoleAliasesLengthW *pfn = 0;
7997     if (!pfn)
7998         kPrf2WrapResolve((void **)&pfn, "GetConsoleAliasesLengthW", &g_Kernel32);
7999     return pfn( ExeName );
8000 }
8001
8002 typedef DWORD APIENTRY FN_GetConsoleAliasExesLengthA( VOID );
8003 __declspec(dllexport) DWORD APIENTRY kPrf2Wrap_GetConsoleAliasExesLengthA( VOID )
8004 {
8005     static FN_GetConsoleAliasExesLengthA *pfn = 0;
8006     if (!pfn)
8007         kPrf2WrapResolve((void **)&pfn, "GetConsoleAliasExesLengthA", &g_Kernel32);
8008     return pfn ();
8009 }
8010
8011 typedef DWORD APIENTRY FN_GetConsoleAliasExesLengthW( VOID );
8012 __declspec(dllexport) DWORD APIENTRY kPrf2Wrap_GetConsoleAliasExesLengthW( VOID )
8013 {
8014     static FN_GetConsoleAliasExesLengthW *pfn = 0;
8015     if (!pfn)
8016         kPrf2WrapResolve((void **)&pfn, "GetConsoleAliasExesLengthW", &g_Kernel32);
8017     return pfn ();
8018 }
8019
8020 typedef DWORD APIENTRY FN_GetConsoleAliasesA( OUT LPSTR AliasBuffer, IN DWORD AliasBufferLength, IN LPSTR ExeName );
8021 __declspec(dllexport) DWORD APIENTRY kPrf2Wrap_GetConsoleAliasesA( OUT LPSTR AliasBuffer, IN DWORD AliasBufferLength, IN LPSTR ExeName )
8022 {
8023     static FN_GetConsoleAliasesA *pfn = 0;
8024     if (!pfn)
8025         kPrf2WrapResolve((void **)&pfn, "GetConsoleAliasesA", &g_Kernel32);
8026     return pfn( AliasBuffer, AliasBufferLength, ExeName );
8027 }
8028
8029 typedef DWORD APIENTRY FN_GetConsoleAliasesW( OUT LPWSTR AliasBuffer, IN DWORD AliasBufferLength, IN LPWSTR ExeName );
8030 __declspec(dllexport) DWORD APIENTRY kPrf2Wrap_GetConsoleAliasesW( OUT LPWSTR AliasBuffer, IN DWORD AliasBufferLength, IN LPWSTR ExeName )
8031 {
8032     static FN_GetConsoleAliasesW *pfn = 0;
8033     if (!pfn)
8034         kPrf2WrapResolve((void **)&pfn, "GetConsoleAliasesW", &g_Kernel32);
8035     return pfn( AliasBuffer, AliasBufferLength, ExeName );
8036 }
8037
8038 typedef DWORD APIENTRY FN_GetConsoleAliasExesA( OUT LPSTR ExeNameBuffer, IN DWORD ExeNameBufferLength );
8039 __declspec(dllexport) DWORD APIENTRY kPrf2Wrap_GetConsoleAliasExesA( OUT LPSTR ExeNameBuffer, IN DWORD ExeNameBufferLength )
8040 {
8041     static FN_GetConsoleAliasExesA *pfn = 0;
8042     if (!pfn)
8043         kPrf2WrapResolve((void **)&pfn, "GetConsoleAliasExesA", &g_Kernel32);
8044     return pfn( ExeNameBuffer, ExeNameBufferLength );
8045 }
8046
8047 typedef DWORD APIENTRY FN_GetConsoleAliasExesW( OUT LPWSTR ExeNameBuffer, IN DWORD ExeNameBufferLength );
8048 __declspec(dllexport) DWORD APIENTRY kPrf2Wrap_GetConsoleAliasExesW( OUT LPWSTR ExeNameBuffer, IN DWORD ExeNameBufferLength )
8049 {
8050     static FN_GetConsoleAliasExesW *pfn = 0;
8051     if (!pfn)
8052         kPrf2WrapResolve((void **)&pfn, "GetConsoleAliasExesW", &g_Kernel32);
8053     return pfn( ExeNameBuffer, ExeNameBufferLength );
8054 }
8055
8056 typedef BOOL WINAPI FN_IsValidCodePage( UINT CodePage );
8057 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_IsValidCodePage( UINT CodePage )
8058 {
8059     static FN_IsValidCodePage *pfn = 0;
8060     if (!pfn)
8061         kPrf2WrapResolve((void **)&pfn, "IsValidCodePage", &g_Kernel32);
8062     return pfn( CodePage );
8063 }
8064
8065 typedef UINT WINAPI FN_GetACP( void );
8066 __declspec(dllexport) UINT WINAPI kPrf2Wrap_GetACP( void )
8067 {
8068     static FN_GetACP *pfn = 0;
8069     if (!pfn)
8070         kPrf2WrapResolve((void **)&pfn, "GetACP", &g_Kernel32);
8071     return pfn ();
8072 }
8073
8074 typedef UINT WINAPI FN_GetOEMCP( void );
8075 __declspec(dllexport) UINT WINAPI kPrf2Wrap_GetOEMCP( void )
8076 {
8077     static FN_GetOEMCP *pfn = 0;
8078     if (!pfn)
8079         kPrf2WrapResolve((void **)&pfn, "GetOEMCP", &g_Kernel32);
8080     return pfn ();
8081 }
8082
8083 typedef BOOL WINAPI FN_GetCPInfo( UINT CodePage, LPCPINFO lpCPInfo );
8084 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetCPInfo( UINT CodePage, LPCPINFO lpCPInfo )
8085 {
8086     static FN_GetCPInfo *pfn = 0;
8087     if (!pfn)
8088         kPrf2WrapResolve((void **)&pfn, "GetCPInfo", &g_Kernel32);
8089     return pfn( CodePage, lpCPInfo );
8090 }
8091
8092 typedef BOOL WINAPI FN_GetCPInfoExA( UINT CodePage, DWORD dwFlags, LPCPINFOEXA lpCPInfoEx );
8093 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetCPInfoExA( UINT CodePage, DWORD dwFlags, LPCPINFOEXA lpCPInfoEx )
8094 {
8095     static FN_GetCPInfoExA *pfn = 0;
8096     if (!pfn)
8097         kPrf2WrapResolve((void **)&pfn, "GetCPInfoExA", &g_Kernel32);
8098     return pfn( CodePage, dwFlags, lpCPInfoEx );
8099 }
8100
8101 typedef BOOL WINAPI FN_GetCPInfoExW( UINT CodePage, DWORD dwFlags, LPCPINFOEXW lpCPInfoEx );
8102 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetCPInfoExW( UINT CodePage, DWORD dwFlags, LPCPINFOEXW lpCPInfoEx )
8103 {
8104     static FN_GetCPInfoExW *pfn = 0;
8105     if (!pfn)
8106         kPrf2WrapResolve((void **)&pfn, "GetCPInfoExW", &g_Kernel32);
8107     return pfn( CodePage, dwFlags, lpCPInfoEx );
8108 }
8109
8110 typedef BOOL WINAPI FN_IsDBCSLeadByte( BYTE TestChar );
8111 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_IsDBCSLeadByte( BYTE TestChar )
8112 {
8113     static FN_IsDBCSLeadByte *pfn = 0;
8114     if (!pfn)
8115         kPrf2WrapResolve((void **)&pfn, "IsDBCSLeadByte", &g_Kernel32);
8116     return pfn( TestChar );
8117 }
8118
8119 typedef BOOL WINAPI FN_IsDBCSLeadByteEx( UINT CodePage, BYTE TestChar );
8120 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_IsDBCSLeadByteEx( UINT CodePage, BYTE TestChar )
8121 {
8122     static FN_IsDBCSLeadByteEx *pfn = 0;
8123     if (!pfn)
8124         kPrf2WrapResolve((void **)&pfn, "IsDBCSLeadByteEx", &g_Kernel32);
8125     return pfn( CodePage, TestChar );
8126 }
8127
8128 typedef int WINAPI FN_MultiByteToWideChar( UINT CodePage, DWORD dwFlags, LPCSTR lpMultiByteStr, int cbMultiByte, LPWSTR lpWideCharStr, int cchWideChar );
8129 __declspec(dllexport) int WINAPI kPrf2Wrap_MultiByteToWideChar( UINT CodePage, DWORD dwFlags, LPCSTR lpMultiByteStr, int cbMultiByte, LPWSTR lpWideCharStr, int cchWideChar )
8130 {
8131     static FN_MultiByteToWideChar *pfn = 0;
8132     if (!pfn)
8133         kPrf2WrapResolve((void **)&pfn, "MultiByteToWideChar", &g_Kernel32);
8134     return pfn( CodePage, dwFlags, lpMultiByteStr, cbMultiByte, lpWideCharStr, cchWideChar );
8135 }
8136
8137 typedef int WINAPI FN_WideCharToMultiByte( UINT CodePage, DWORD dwFlags, LPCWSTR lpWideCharStr, int cchWideChar, LPSTR lpMultiByteStr, int cbMultiByte, LPCSTR lpDefaultChar, LPBOOL lpUsedDefaultChar );
8138 __declspec(dllexport) int WINAPI kPrf2Wrap_WideCharToMultiByte( UINT CodePage, DWORD dwFlags, LPCWSTR lpWideCharStr, int cchWideChar, LPSTR lpMultiByteStr, int cbMultiByte, LPCSTR lpDefaultChar, LPBOOL lpUsedDefaultChar )
8139 {
8140     static FN_WideCharToMultiByte *pfn = 0;
8141     if (!pfn)
8142         kPrf2WrapResolve((void **)&pfn, "WideCharToMultiByte", &g_Kernel32);
8143     return pfn( CodePage, dwFlags, lpWideCharStr, cchWideChar, lpMultiByteStr, cbMultiByte, lpDefaultChar, lpUsedDefaultChar );
8144 }
8145
8146 typedef int WINAPI FN_CompareStringA( LCID Locale, DWORD dwCmpFlags, LPCSTR lpString1, int cchCount1, LPCSTR lpString2, int cchCount2 );
8147 __declspec(dllexport) int WINAPI kPrf2Wrap_CompareStringA( LCID Locale, DWORD dwCmpFlags, LPCSTR lpString1, int cchCount1, LPCSTR lpString2, int cchCount2 )
8148 {
8149     static FN_CompareStringA *pfn = 0;
8150     if (!pfn)
8151         kPrf2WrapResolve((void **)&pfn, "CompareStringA", &g_Kernel32);
8152     return pfn( Locale, dwCmpFlags, lpString1, cchCount1, lpString2, cchCount2 );
8153 }
8154
8155 typedef int WINAPI FN_CompareStringW( LCID Locale, DWORD dwCmpFlags, LPCWSTR lpString1, int cchCount1, LPCWSTR lpString2, int cchCount2 );
8156 __declspec(dllexport) int WINAPI kPrf2Wrap_CompareStringW( LCID Locale, DWORD dwCmpFlags, LPCWSTR lpString1, int cchCount1, LPCWSTR lpString2, int cchCount2 )
8157 {
8158     static FN_CompareStringW *pfn = 0;
8159     if (!pfn)
8160         kPrf2WrapResolve((void **)&pfn, "CompareStringW", &g_Kernel32);
8161     return pfn( Locale, dwCmpFlags, lpString1, cchCount1, lpString2, cchCount2 );
8162 }
8163
8164 typedef int WINAPI FN_LCMapStringA( LCID Locale, DWORD dwMapFlags, LPCSTR lpSrcStr, int cchSrc, LPSTR lpDestStr, int cchDest );
8165 __declspec(dllexport) int WINAPI kPrf2Wrap_LCMapStringA( LCID Locale, DWORD dwMapFlags, LPCSTR lpSrcStr, int cchSrc, LPSTR lpDestStr, int cchDest )
8166 {
8167     static FN_LCMapStringA *pfn = 0;
8168     if (!pfn)
8169         kPrf2WrapResolve((void **)&pfn, "LCMapStringA", &g_Kernel32);
8170     return pfn( Locale, dwMapFlags, lpSrcStr, cchSrc, lpDestStr, cchDest );
8171 }
8172
8173 typedef int WINAPI FN_LCMapStringW( LCID Locale, DWORD dwMapFlags, LPCWSTR lpSrcStr, int cchSrc, LPWSTR lpDestStr, int cchDest );
8174 __declspec(dllexport) int WINAPI kPrf2Wrap_LCMapStringW( LCID Locale, DWORD dwMapFlags, LPCWSTR lpSrcStr, int cchSrc, LPWSTR lpDestStr, int cchDest )
8175 {
8176     static FN_LCMapStringW *pfn = 0;
8177     if (!pfn)
8178         kPrf2WrapResolve((void **)&pfn, "LCMapStringW", &g_Kernel32);
8179     return pfn( Locale, dwMapFlags, lpSrcStr, cchSrc, lpDestStr, cchDest );
8180 }
8181
8182 typedef int WINAPI FN_GetLocaleInfoA( LCID Locale, LCTYPE LCType, LPSTR lpLCData, int cchData );
8183 __declspec(dllexport) int WINAPI kPrf2Wrap_GetLocaleInfoA( LCID Locale, LCTYPE LCType, LPSTR lpLCData, int cchData )
8184 {
8185     static FN_GetLocaleInfoA *pfn = 0;
8186     if (!pfn)
8187         kPrf2WrapResolve((void **)&pfn, "GetLocaleInfoA", &g_Kernel32);
8188     return pfn( Locale, LCType, lpLCData, cchData );
8189 }
8190
8191 typedef int WINAPI FN_GetLocaleInfoW( LCID Locale, LCTYPE LCType, LPWSTR lpLCData, int cchData );
8192 __declspec(dllexport) int WINAPI kPrf2Wrap_GetLocaleInfoW( LCID Locale, LCTYPE LCType, LPWSTR lpLCData, int cchData )
8193 {
8194     static FN_GetLocaleInfoW *pfn = 0;
8195     if (!pfn)
8196         kPrf2WrapResolve((void **)&pfn, "GetLocaleInfoW", &g_Kernel32);
8197     return pfn( Locale, LCType, lpLCData, cchData );
8198 }
8199
8200 typedef BOOL WINAPI FN_SetLocaleInfoA( LCID Locale, LCTYPE LCType, LPCSTR lpLCData );
8201 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetLocaleInfoA( LCID Locale, LCTYPE LCType, LPCSTR lpLCData )
8202 {
8203     static FN_SetLocaleInfoA *pfn = 0;
8204     if (!pfn)
8205         kPrf2WrapResolve((void **)&pfn, "SetLocaleInfoA", &g_Kernel32);
8206     return pfn( Locale, LCType, lpLCData );
8207 }
8208
8209 typedef BOOL WINAPI FN_SetLocaleInfoW( LCID Locale, LCTYPE LCType, LPCWSTR lpLCData );
8210 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetLocaleInfoW( LCID Locale, LCTYPE LCType, LPCWSTR lpLCData )
8211 {
8212     static FN_SetLocaleInfoW *pfn = 0;
8213     if (!pfn)
8214         kPrf2WrapResolve((void **)&pfn, "SetLocaleInfoW", &g_Kernel32);
8215     return pfn( Locale, LCType, lpLCData );
8216 }
8217
8218 typedef int WINAPI FN_GetCalendarInfoA( LCID Locale, CALID Calendar, CALTYPE CalType, LPSTR lpCalData, int cchData, LPDWORD lpValue );
8219 __declspec(dllexport) int WINAPI kPrf2Wrap_GetCalendarInfoA( LCID Locale, CALID Calendar, CALTYPE CalType, LPSTR lpCalData, int cchData, LPDWORD lpValue )
8220 {
8221     static FN_GetCalendarInfoA *pfn = 0;
8222     if (!pfn)
8223         kPrf2WrapResolve((void **)&pfn, "GetCalendarInfoA", &g_Kernel32);
8224     return pfn( Locale, Calendar, CalType, lpCalData, cchData, lpValue );
8225 }
8226
8227 typedef int WINAPI FN_GetCalendarInfoW( LCID Locale, CALID Calendar, CALTYPE CalType, LPWSTR lpCalData, int cchData, LPDWORD lpValue );
8228 __declspec(dllexport) int WINAPI kPrf2Wrap_GetCalendarInfoW( LCID Locale, CALID Calendar, CALTYPE CalType, LPWSTR lpCalData, int cchData, LPDWORD lpValue )
8229 {
8230     static FN_GetCalendarInfoW *pfn = 0;
8231     if (!pfn)
8232         kPrf2WrapResolve((void **)&pfn, "GetCalendarInfoW", &g_Kernel32);
8233     return pfn( Locale, Calendar, CalType, lpCalData, cchData, lpValue );
8234 }
8235
8236 typedef BOOL WINAPI FN_SetCalendarInfoA( LCID Locale, CALID Calendar, CALTYPE CalType, LPCSTR lpCalData );
8237 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetCalendarInfoA( LCID Locale, CALID Calendar, CALTYPE CalType, LPCSTR lpCalData )
8238 {
8239     static FN_SetCalendarInfoA *pfn = 0;
8240     if (!pfn)
8241         kPrf2WrapResolve((void **)&pfn, "SetCalendarInfoA", &g_Kernel32);
8242     return pfn( Locale, Calendar, CalType, lpCalData );
8243 }
8244
8245 typedef BOOL WINAPI FN_SetCalendarInfoW( LCID Locale, CALID Calendar, CALTYPE CalType, LPCWSTR lpCalData );
8246 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetCalendarInfoW( LCID Locale, CALID Calendar, CALTYPE CalType, LPCWSTR lpCalData )
8247 {
8248     static FN_SetCalendarInfoW *pfn = 0;
8249     if (!pfn)
8250         kPrf2WrapResolve((void **)&pfn, "SetCalendarInfoW", &g_Kernel32);
8251     return pfn( Locale, Calendar, CalType, lpCalData );
8252 }
8253
8254 typedef int WINAPI FN_GetTimeFormatA( LCID Locale, DWORD dwFlags, CONST SYSTEMTIME * lpTime, LPCSTR lpFormat, LPSTR lpTimeStr, int cchTime );
8255 __declspec(dllexport) int WINAPI kPrf2Wrap_GetTimeFormatA( LCID Locale, DWORD dwFlags, CONST SYSTEMTIME * lpTime, LPCSTR lpFormat, LPSTR lpTimeStr, int cchTime )
8256 {
8257     static FN_GetTimeFormatA *pfn = 0;
8258     if (!pfn)
8259         kPrf2WrapResolve((void **)&pfn, "GetTimeFormatA", &g_Kernel32);
8260     return pfn( Locale, dwFlags, lpTime, lpFormat, lpTimeStr, cchTime );
8261 }
8262
8263 typedef int WINAPI FN_GetTimeFormatW( LCID Locale, DWORD dwFlags, CONST SYSTEMTIME * lpTime, LPCWSTR lpFormat, LPWSTR lpTimeStr, int cchTime );
8264 __declspec(dllexport) int WINAPI kPrf2Wrap_GetTimeFormatW( LCID Locale, DWORD dwFlags, CONST SYSTEMTIME * lpTime, LPCWSTR lpFormat, LPWSTR lpTimeStr, int cchTime )
8265 {
8266     static FN_GetTimeFormatW *pfn = 0;
8267     if (!pfn)
8268         kPrf2WrapResolve((void **)&pfn, "GetTimeFormatW", &g_Kernel32);
8269     return pfn( Locale, dwFlags, lpTime, lpFormat, lpTimeStr, cchTime );
8270 }
8271
8272 typedef int WINAPI FN_GetDateFormatA( LCID Locale, DWORD dwFlags, CONST SYSTEMTIME * lpDate, LPCSTR lpFormat, LPSTR lpDateStr, int cchDate );
8273 __declspec(dllexport) int WINAPI kPrf2Wrap_GetDateFormatA( LCID Locale, DWORD dwFlags, CONST SYSTEMTIME * lpDate, LPCSTR lpFormat, LPSTR lpDateStr, int cchDate )
8274 {
8275     static FN_GetDateFormatA *pfn = 0;
8276     if (!pfn)
8277         kPrf2WrapResolve((void **)&pfn, "GetDateFormatA", &g_Kernel32);
8278     return pfn( Locale, dwFlags, lpDate, lpFormat, lpDateStr, cchDate );
8279 }
8280
8281 typedef int WINAPI FN_GetDateFormatW( LCID Locale, DWORD dwFlags, CONST SYSTEMTIME * lpDate, LPCWSTR lpFormat, LPWSTR lpDateStr, int cchDate );
8282 __declspec(dllexport) int WINAPI kPrf2Wrap_GetDateFormatW( LCID Locale, DWORD dwFlags, CONST SYSTEMTIME * lpDate, LPCWSTR lpFormat, LPWSTR lpDateStr, int cchDate )
8283 {
8284     static FN_GetDateFormatW *pfn = 0;
8285     if (!pfn)
8286         kPrf2WrapResolve((void **)&pfn, "GetDateFormatW", &g_Kernel32);
8287     return pfn( Locale, dwFlags, lpDate, lpFormat, lpDateStr, cchDate );
8288 }
8289
8290 typedef int WINAPI FN_GetNumberFormatA( LCID Locale, DWORD dwFlags, LPCSTR lpValue, CONST NUMBERFMTA * lpFormat, LPSTR lpNumberStr, int cchNumber );
8291 __declspec(dllexport) int WINAPI kPrf2Wrap_GetNumberFormatA( LCID Locale, DWORD dwFlags, LPCSTR lpValue, CONST NUMBERFMTA * lpFormat, LPSTR lpNumberStr, int cchNumber )
8292 {
8293     static FN_GetNumberFormatA *pfn = 0;
8294     if (!pfn)
8295         kPrf2WrapResolve((void **)&pfn, "GetNumberFormatA", &g_Kernel32);
8296     return pfn( Locale, dwFlags, lpValue, lpFormat, lpNumberStr, cchNumber );
8297 }
8298
8299 typedef int WINAPI FN_GetNumberFormatW( LCID Locale, DWORD dwFlags, LPCWSTR lpValue, CONST NUMBERFMTW * lpFormat, LPWSTR lpNumberStr, int cchNumber );
8300 __declspec(dllexport) int WINAPI kPrf2Wrap_GetNumberFormatW( LCID Locale, DWORD dwFlags, LPCWSTR lpValue, CONST NUMBERFMTW * lpFormat, LPWSTR lpNumberStr, int cchNumber )
8301 {
8302     static FN_GetNumberFormatW *pfn = 0;
8303     if (!pfn)
8304         kPrf2WrapResolve((void **)&pfn, "GetNumberFormatW", &g_Kernel32);
8305     return pfn( Locale, dwFlags, lpValue, lpFormat, lpNumberStr, cchNumber );
8306 }
8307
8308 typedef int WINAPI FN_GetCurrencyFormatA( LCID Locale, DWORD dwFlags, LPCSTR lpValue, CONST CURRENCYFMTA * lpFormat, LPSTR lpCurrencyStr, int cchCurrency );
8309 __declspec(dllexport) int WINAPI kPrf2Wrap_GetCurrencyFormatA( LCID Locale, DWORD dwFlags, LPCSTR lpValue, CONST CURRENCYFMTA * lpFormat, LPSTR lpCurrencyStr, int cchCurrency )
8310 {
8311     static FN_GetCurrencyFormatA *pfn = 0;
8312     if (!pfn)
8313         kPrf2WrapResolve((void **)&pfn, "GetCurrencyFormatA", &g_Kernel32);
8314     return pfn( Locale, dwFlags, lpValue, lpFormat, lpCurrencyStr, cchCurrency );
8315 }
8316
8317 typedef int WINAPI FN_GetCurrencyFormatW( LCID Locale, DWORD dwFlags, LPCWSTR lpValue, CONST CURRENCYFMTW * lpFormat, LPWSTR lpCurrencyStr, int cchCurrency );
8318 __declspec(dllexport) int WINAPI kPrf2Wrap_GetCurrencyFormatW( LCID Locale, DWORD dwFlags, LPCWSTR lpValue, CONST CURRENCYFMTW * lpFormat, LPWSTR lpCurrencyStr, int cchCurrency )
8319 {
8320     static FN_GetCurrencyFormatW *pfn = 0;
8321     if (!pfn)
8322         kPrf2WrapResolve((void **)&pfn, "GetCurrencyFormatW", &g_Kernel32);
8323     return pfn( Locale, dwFlags, lpValue, lpFormat, lpCurrencyStr, cchCurrency );
8324 }
8325
8326 typedef BOOL WINAPI FN_EnumCalendarInfoA( CALINFO_ENUMPROCA lpCalInfoEnumProc, LCID Locale, CALID Calendar, CALTYPE CalType );
8327 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_EnumCalendarInfoA( CALINFO_ENUMPROCA lpCalInfoEnumProc, LCID Locale, CALID Calendar, CALTYPE CalType )
8328 {
8329     static FN_EnumCalendarInfoA *pfn = 0;
8330     if (!pfn)
8331         kPrf2WrapResolve((void **)&pfn, "EnumCalendarInfoA", &g_Kernel32);
8332     return pfn( lpCalInfoEnumProc, Locale, Calendar, CalType );
8333 }
8334
8335 typedef BOOL WINAPI FN_EnumCalendarInfoW( CALINFO_ENUMPROCW lpCalInfoEnumProc, LCID Locale, CALID Calendar, CALTYPE CalType );
8336 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_EnumCalendarInfoW( CALINFO_ENUMPROCW lpCalInfoEnumProc, LCID Locale, CALID Calendar, CALTYPE CalType )
8337 {
8338     static FN_EnumCalendarInfoW *pfn = 0;
8339     if (!pfn)
8340         kPrf2WrapResolve((void **)&pfn, "EnumCalendarInfoW", &g_Kernel32);
8341     return pfn( lpCalInfoEnumProc, Locale, Calendar, CalType );
8342 }
8343
8344 typedef BOOL WINAPI FN_EnumCalendarInfoExA( CALINFO_ENUMPROCEXA lpCalInfoEnumProcEx, LCID Locale, CALID Calendar, CALTYPE CalType );
8345 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_EnumCalendarInfoExA( CALINFO_ENUMPROCEXA lpCalInfoEnumProcEx, LCID Locale, CALID Calendar, CALTYPE CalType )
8346 {
8347     static FN_EnumCalendarInfoExA *pfn = 0;
8348     if (!pfn)
8349         kPrf2WrapResolve((void **)&pfn, "EnumCalendarInfoExA", &g_Kernel32);
8350     return pfn( lpCalInfoEnumProcEx, Locale, Calendar, CalType );
8351 }
8352
8353 typedef BOOL WINAPI FN_EnumCalendarInfoExW( CALINFO_ENUMPROCEXW lpCalInfoEnumProcEx, LCID Locale, CALID Calendar, CALTYPE CalType );
8354 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_EnumCalendarInfoExW( CALINFO_ENUMPROCEXW lpCalInfoEnumProcEx, LCID Locale, CALID Calendar, CALTYPE CalType )
8355 {
8356     static FN_EnumCalendarInfoExW *pfn = 0;
8357     if (!pfn)
8358         kPrf2WrapResolve((void **)&pfn, "EnumCalendarInfoExW", &g_Kernel32);
8359     return pfn( lpCalInfoEnumProcEx, Locale, Calendar, CalType );
8360 }
8361
8362 typedef BOOL WINAPI FN_EnumTimeFormatsA( TIMEFMT_ENUMPROCA lpTimeFmtEnumProc, LCID Locale, DWORD dwFlags );
8363 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_EnumTimeFormatsA( TIMEFMT_ENUMPROCA lpTimeFmtEnumProc, LCID Locale, DWORD dwFlags )
8364 {
8365     static FN_EnumTimeFormatsA *pfn = 0;
8366     if (!pfn)
8367         kPrf2WrapResolve((void **)&pfn, "EnumTimeFormatsA", &g_Kernel32);
8368     return pfn( lpTimeFmtEnumProc, Locale, dwFlags );
8369 }
8370
8371 typedef BOOL WINAPI FN_EnumTimeFormatsW( TIMEFMT_ENUMPROCW lpTimeFmtEnumProc, LCID Locale, DWORD dwFlags );
8372 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_EnumTimeFormatsW( TIMEFMT_ENUMPROCW lpTimeFmtEnumProc, LCID Locale, DWORD dwFlags )
8373 {
8374     static FN_EnumTimeFormatsW *pfn = 0;
8375     if (!pfn)
8376         kPrf2WrapResolve((void **)&pfn, "EnumTimeFormatsW", &g_Kernel32);
8377     return pfn( lpTimeFmtEnumProc, Locale, dwFlags );
8378 }
8379
8380 typedef BOOL WINAPI FN_EnumDateFormatsA( DATEFMT_ENUMPROCA lpDateFmtEnumProc, LCID Locale, DWORD dwFlags );
8381 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_EnumDateFormatsA( DATEFMT_ENUMPROCA lpDateFmtEnumProc, LCID Locale, DWORD dwFlags )
8382 {
8383     static FN_EnumDateFormatsA *pfn = 0;
8384     if (!pfn)
8385         kPrf2WrapResolve((void **)&pfn, "EnumDateFormatsA", &g_Kernel32);
8386     return pfn( lpDateFmtEnumProc, Locale, dwFlags );
8387 }
8388
8389 typedef BOOL WINAPI FN_EnumDateFormatsW( DATEFMT_ENUMPROCW lpDateFmtEnumProc, LCID Locale, DWORD dwFlags );
8390 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_EnumDateFormatsW( DATEFMT_ENUMPROCW lpDateFmtEnumProc, LCID Locale, DWORD dwFlags )
8391 {
8392     static FN_EnumDateFormatsW *pfn = 0;
8393     if (!pfn)
8394         kPrf2WrapResolve((void **)&pfn, "EnumDateFormatsW", &g_Kernel32);
8395     return pfn( lpDateFmtEnumProc, Locale, dwFlags );
8396 }
8397
8398 typedef BOOL WINAPI FN_EnumDateFormatsExA( DATEFMT_ENUMPROCEXA lpDateFmtEnumProcEx, LCID Locale, DWORD dwFlags );
8399 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_EnumDateFormatsExA( DATEFMT_ENUMPROCEXA lpDateFmtEnumProcEx, LCID Locale, DWORD dwFlags )
8400 {
8401     static FN_EnumDateFormatsExA *pfn = 0;
8402     if (!pfn)
8403         kPrf2WrapResolve((void **)&pfn, "EnumDateFormatsExA", &g_Kernel32);
8404     return pfn( lpDateFmtEnumProcEx, Locale, dwFlags );
8405 }
8406
8407 typedef BOOL WINAPI FN_EnumDateFormatsExW( DATEFMT_ENUMPROCEXW lpDateFmtEnumProcEx, LCID Locale, DWORD dwFlags );
8408 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_EnumDateFormatsExW( DATEFMT_ENUMPROCEXW lpDateFmtEnumProcEx, LCID Locale, DWORD dwFlags )
8409 {
8410     static FN_EnumDateFormatsExW *pfn = 0;
8411     if (!pfn)
8412         kPrf2WrapResolve((void **)&pfn, "EnumDateFormatsExW", &g_Kernel32);
8413     return pfn( lpDateFmtEnumProcEx, Locale, dwFlags );
8414 }
8415
8416 typedef BOOL WINAPI FN_IsValidLanguageGroup( LGRPID LanguageGroup, DWORD dwFlags );
8417 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_IsValidLanguageGroup( LGRPID LanguageGroup, DWORD dwFlags )
8418 {
8419     static FN_IsValidLanguageGroup *pfn = 0;
8420     if (!pfn)
8421         kPrf2WrapResolve((void **)&pfn, "IsValidLanguageGroup", &g_Kernel32);
8422     return pfn( LanguageGroup, dwFlags );
8423 }
8424
8425 typedef BOOL WINAPI FN_GetNLSVersion( NLS_FUNCTION Function, LCID Locale, LPNLSVERSIONINFO lpVersionInformation );
8426 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetNLSVersion( NLS_FUNCTION Function, LCID Locale, LPNLSVERSIONINFO lpVersionInformation )
8427 {
8428     static FN_GetNLSVersion *pfn = 0;
8429     if (!pfn)
8430         kPrf2WrapResolve((void **)&pfn, "GetNLSVersion", &g_Kernel32);
8431     return pfn( Function, Locale, lpVersionInformation );
8432 }
8433
8434 typedef BOOL WINAPI FN_IsNLSDefinedString( NLS_FUNCTION Function, DWORD dwFlags, LPNLSVERSIONINFO lpVersionInformation, LPCWSTR lpString, INT cchStr );
8435 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_IsNLSDefinedString( NLS_FUNCTION Function, DWORD dwFlags, LPNLSVERSIONINFO lpVersionInformation, LPCWSTR lpString, INT cchStr )
8436 {
8437     static FN_IsNLSDefinedString *pfn = 0;
8438     if (!pfn)
8439         kPrf2WrapResolve((void **)&pfn, "IsNLSDefinedString", &g_Kernel32);
8440     return pfn( Function, dwFlags, lpVersionInformation, lpString, cchStr );
8441 }
8442
8443 typedef BOOL WINAPI FN_IsValidLocale( LCID Locale, DWORD dwFlags );
8444 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_IsValidLocale( LCID Locale, DWORD dwFlags )
8445 {
8446     static FN_IsValidLocale *pfn = 0;
8447     if (!pfn)
8448         kPrf2WrapResolve((void **)&pfn, "IsValidLocale", &g_Kernel32);
8449     return pfn( Locale, dwFlags );
8450 }
8451
8452 typedef int WINAPI FN_GetGeoInfoA( GEOID Location, GEOTYPE GeoType, LPSTR lpGeoData, int cchData, LANGID LangId );
8453 __declspec(dllexport) int WINAPI kPrf2Wrap_GetGeoInfoA( GEOID Location, GEOTYPE GeoType, LPSTR lpGeoData, int cchData, LANGID LangId )
8454 {
8455     static FN_GetGeoInfoA *pfn = 0;
8456     if (!pfn)
8457         kPrf2WrapResolve((void **)&pfn, "GetGeoInfoA", &g_Kernel32);
8458     return pfn( Location, GeoType, lpGeoData, cchData, LangId );
8459 }
8460
8461 typedef int WINAPI FN_GetGeoInfoW( GEOID Location, GEOTYPE GeoType, LPWSTR lpGeoData, int cchData, LANGID LangId );
8462 __declspec(dllexport) int WINAPI kPrf2Wrap_GetGeoInfoW( GEOID Location, GEOTYPE GeoType, LPWSTR lpGeoData, int cchData, LANGID LangId )
8463 {
8464     static FN_GetGeoInfoW *pfn = 0;
8465     if (!pfn)
8466         kPrf2WrapResolve((void **)&pfn, "GetGeoInfoW", &g_Kernel32);
8467     return pfn( Location, GeoType, lpGeoData, cchData, LangId );
8468 }
8469
8470 typedef BOOL WINAPI FN_EnumSystemGeoID( GEOCLASS GeoClass, GEOID ParentGeoId, GEO_ENUMPROC lpGeoEnumProc );
8471 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_EnumSystemGeoID( GEOCLASS GeoClass, GEOID ParentGeoId, GEO_ENUMPROC lpGeoEnumProc )
8472 {
8473     static FN_EnumSystemGeoID *pfn = 0;
8474     if (!pfn)
8475         kPrf2WrapResolve((void **)&pfn, "EnumSystemGeoID", &g_Kernel32);
8476     return pfn( GeoClass, ParentGeoId, lpGeoEnumProc );
8477 }
8478
8479 typedef GEOID WINAPI FN_GetUserGeoID( GEOCLASS GeoClass );
8480 __declspec(dllexport) GEOID WINAPI kPrf2Wrap_GetUserGeoID( GEOCLASS GeoClass )
8481 {
8482     static FN_GetUserGeoID *pfn = 0;
8483     if (!pfn)
8484         kPrf2WrapResolve((void **)&pfn, "GetUserGeoID", &g_Kernel32);
8485     return pfn( GeoClass );
8486 }
8487
8488 typedef BOOL WINAPI FN_SetUserGeoID( GEOID GeoId );
8489 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetUserGeoID( GEOID GeoId )
8490 {
8491     static FN_SetUserGeoID *pfn = 0;
8492     if (!pfn)
8493         kPrf2WrapResolve((void **)&pfn, "SetUserGeoID", &g_Kernel32);
8494     return pfn( GeoId );
8495 }
8496
8497 typedef LCID WINAPI FN_ConvertDefaultLocale( LCID Locale );
8498 __declspec(dllexport) LCID WINAPI kPrf2Wrap_ConvertDefaultLocale( LCID Locale )
8499 {
8500     static FN_ConvertDefaultLocale *pfn = 0;
8501     if (!pfn)
8502         kPrf2WrapResolve((void **)&pfn, "ConvertDefaultLocale", &g_Kernel32);
8503     return pfn( Locale );
8504 }
8505
8506 typedef LCID WINAPI FN_GetThreadLocale( void );
8507 __declspec(dllexport) LCID WINAPI kPrf2Wrap_GetThreadLocale( void )
8508 {
8509     static FN_GetThreadLocale *pfn = 0;
8510     if (!pfn)
8511         kPrf2WrapResolve((void **)&pfn, "GetThreadLocale", &g_Kernel32);
8512     return pfn ();
8513 }
8514
8515 typedef BOOL WINAPI FN_SetThreadLocale( LCID Locale );
8516 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetThreadLocale( LCID Locale )
8517 {
8518     static FN_SetThreadLocale *pfn = 0;
8519     if (!pfn)
8520         kPrf2WrapResolve((void **)&pfn, "SetThreadLocale", &g_Kernel32);
8521     return pfn( Locale );
8522 }
8523
8524 typedef LANGID WINAPI FN_GetSystemDefaultUILanguage( void );
8525 __declspec(dllexport) LANGID WINAPI kPrf2Wrap_GetSystemDefaultUILanguage( void )
8526 {
8527     static FN_GetSystemDefaultUILanguage *pfn = 0;
8528     if (!pfn)
8529         kPrf2WrapResolve((void **)&pfn, "GetSystemDefaultUILanguage", &g_Kernel32);
8530     return pfn ();
8531 }
8532
8533 typedef LANGID WINAPI FN_GetUserDefaultUILanguage( void );
8534 __declspec(dllexport) LANGID WINAPI kPrf2Wrap_GetUserDefaultUILanguage( void )
8535 {
8536     static FN_GetUserDefaultUILanguage *pfn = 0;
8537     if (!pfn)
8538         kPrf2WrapResolve((void **)&pfn, "GetUserDefaultUILanguage", &g_Kernel32);
8539     return pfn ();
8540 }
8541
8542 typedef LANGID WINAPI FN_GetSystemDefaultLangID( void );
8543 __declspec(dllexport) LANGID WINAPI kPrf2Wrap_GetSystemDefaultLangID( void )
8544 {
8545     static FN_GetSystemDefaultLangID *pfn = 0;
8546     if (!pfn)
8547         kPrf2WrapResolve((void **)&pfn, "GetSystemDefaultLangID", &g_Kernel32);
8548     return pfn ();
8549 }
8550
8551 typedef LANGID WINAPI FN_GetUserDefaultLangID( void );
8552 __declspec(dllexport) LANGID WINAPI kPrf2Wrap_GetUserDefaultLangID( void )
8553 {
8554     static FN_GetUserDefaultLangID *pfn = 0;
8555     if (!pfn)
8556         kPrf2WrapResolve((void **)&pfn, "GetUserDefaultLangID", &g_Kernel32);
8557     return pfn ();
8558 }
8559
8560 typedef LCID WINAPI FN_GetSystemDefaultLCID( void );
8561 __declspec(dllexport) LCID WINAPI kPrf2Wrap_GetSystemDefaultLCID( void )
8562 {
8563     static FN_GetSystemDefaultLCID *pfn = 0;
8564     if (!pfn)
8565         kPrf2WrapResolve((void **)&pfn, "GetSystemDefaultLCID", &g_Kernel32);
8566     return pfn ();
8567 }
8568
8569 typedef LCID WINAPI FN_GetUserDefaultLCID( void );
8570 __declspec(dllexport) LCID WINAPI kPrf2Wrap_GetUserDefaultLCID( void )
8571 {
8572     static FN_GetUserDefaultLCID *pfn = 0;
8573     if (!pfn)
8574         kPrf2WrapResolve((void **)&pfn, "GetUserDefaultLCID", &g_Kernel32);
8575     return pfn ();
8576 }
8577
8578 typedef BOOL WINAPI FN_GetStringTypeExA( LCID Locale, DWORD dwInfoType, LPCSTR lpSrcStr, int cchSrc, LPWORD lpCharType );
8579 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetStringTypeExA( LCID Locale, DWORD dwInfoType, LPCSTR lpSrcStr, int cchSrc, LPWORD lpCharType )
8580 {
8581     static FN_GetStringTypeExA *pfn = 0;
8582     if (!pfn)
8583         kPrf2WrapResolve((void **)&pfn, "GetStringTypeExA", &g_Kernel32);
8584     return pfn( Locale, dwInfoType, lpSrcStr, cchSrc, lpCharType );
8585 }
8586
8587 typedef BOOL WINAPI FN_GetStringTypeExW( LCID Locale, DWORD dwInfoType, LPCWSTR lpSrcStr, int cchSrc, LPWORD lpCharType );
8588 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetStringTypeExW( LCID Locale, DWORD dwInfoType, LPCWSTR lpSrcStr, int cchSrc, LPWORD lpCharType )
8589 {
8590     static FN_GetStringTypeExW *pfn = 0;
8591     if (!pfn)
8592         kPrf2WrapResolve((void **)&pfn, "GetStringTypeExW", &g_Kernel32);
8593     return pfn( Locale, dwInfoType, lpSrcStr, cchSrc, lpCharType );
8594 }
8595
8596 typedef BOOL WINAPI FN_GetStringTypeA( LCID Locale, DWORD dwInfoType, LPCSTR lpSrcStr, int cchSrc, LPWORD lpCharType );
8597 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetStringTypeA( LCID Locale, DWORD dwInfoType, LPCSTR lpSrcStr, int cchSrc, LPWORD lpCharType )
8598 {
8599     static FN_GetStringTypeA *pfn = 0;
8600     if (!pfn)
8601         kPrf2WrapResolve((void **)&pfn, "GetStringTypeA", &g_Kernel32);
8602     return pfn( Locale, dwInfoType, lpSrcStr, cchSrc, lpCharType );
8603 }
8604
8605 typedef BOOL WINAPI FN_GetStringTypeW( DWORD dwInfoType, LPCWSTR lpSrcStr, int cchSrc, LPWORD lpCharType );
8606 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetStringTypeW( DWORD dwInfoType, LPCWSTR lpSrcStr, int cchSrc, LPWORD lpCharType )
8607 {
8608     static FN_GetStringTypeW *pfn = 0;
8609     if (!pfn)
8610         kPrf2WrapResolve((void **)&pfn, "GetStringTypeW", &g_Kernel32);
8611     return pfn( dwInfoType, lpSrcStr, cchSrc, lpCharType );
8612 }
8613
8614 typedef int WINAPI FN_FoldStringA( DWORD dwMapFlags, LPCSTR lpSrcStr, int cchSrc, LPSTR lpDestStr, int cchDest );
8615 __declspec(dllexport) int WINAPI kPrf2Wrap_FoldStringA( DWORD dwMapFlags, LPCSTR lpSrcStr, int cchSrc, LPSTR lpDestStr, int cchDest )
8616 {
8617     static FN_FoldStringA *pfn = 0;
8618     if (!pfn)
8619         kPrf2WrapResolve((void **)&pfn, "FoldStringA", &g_Kernel32);
8620     return pfn( dwMapFlags, lpSrcStr, cchSrc, lpDestStr, cchDest );
8621 }
8622
8623 typedef int WINAPI FN_FoldStringW( DWORD dwMapFlags, LPCWSTR lpSrcStr, int cchSrc, LPWSTR lpDestStr, int cchDest );
8624 __declspec(dllexport) int WINAPI kPrf2Wrap_FoldStringW( DWORD dwMapFlags, LPCWSTR lpSrcStr, int cchSrc, LPWSTR lpDestStr, int cchDest )
8625 {
8626     static FN_FoldStringW *pfn = 0;
8627     if (!pfn)
8628         kPrf2WrapResolve((void **)&pfn, "FoldStringW", &g_Kernel32);
8629     return pfn( dwMapFlags, lpSrcStr, cchSrc, lpDestStr, cchDest );
8630 }
8631
8632 typedef BOOL WINAPI FN_EnumSystemLanguageGroupsA( LANGUAGEGROUP_ENUMPROCA lpLanguageGroupEnumProc, DWORD dwFlags, LONG_PTR lParam );
8633 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_EnumSystemLanguageGroupsA( LANGUAGEGROUP_ENUMPROCA lpLanguageGroupEnumProc, DWORD dwFlags, LONG_PTR lParam )
8634 {
8635     static FN_EnumSystemLanguageGroupsA *pfn = 0;
8636     if (!pfn)
8637         kPrf2WrapResolve((void **)&pfn, "EnumSystemLanguageGroupsA", &g_Kernel32);
8638     return pfn( lpLanguageGroupEnumProc, dwFlags, lParam );
8639 }
8640
8641 typedef BOOL WINAPI FN_EnumSystemLanguageGroupsW( LANGUAGEGROUP_ENUMPROCW lpLanguageGroupEnumProc, DWORD dwFlags, LONG_PTR lParam );
8642 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_EnumSystemLanguageGroupsW( LANGUAGEGROUP_ENUMPROCW lpLanguageGroupEnumProc, DWORD dwFlags, LONG_PTR lParam )
8643 {
8644     static FN_EnumSystemLanguageGroupsW *pfn = 0;
8645     if (!pfn)
8646         kPrf2WrapResolve((void **)&pfn, "EnumSystemLanguageGroupsW", &g_Kernel32);
8647     return pfn( lpLanguageGroupEnumProc, dwFlags, lParam );
8648 }
8649
8650 typedef BOOL WINAPI FN_EnumLanguageGroupLocalesA( LANGGROUPLOCALE_ENUMPROCA lpLangGroupLocaleEnumProc, LGRPID LanguageGroup, DWORD dwFlags, LONG_PTR lParam );
8651 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_EnumLanguageGroupLocalesA( LANGGROUPLOCALE_ENUMPROCA lpLangGroupLocaleEnumProc, LGRPID LanguageGroup, DWORD dwFlags, LONG_PTR lParam )
8652 {
8653     static FN_EnumLanguageGroupLocalesA *pfn = 0;
8654     if (!pfn)
8655         kPrf2WrapResolve((void **)&pfn, "EnumLanguageGroupLocalesA", &g_Kernel32);
8656     return pfn( lpLangGroupLocaleEnumProc, LanguageGroup, dwFlags, lParam );
8657 }
8658
8659 typedef BOOL WINAPI FN_EnumLanguageGroupLocalesW( LANGGROUPLOCALE_ENUMPROCW lpLangGroupLocaleEnumProc, LGRPID LanguageGroup, DWORD dwFlags, LONG_PTR lParam );
8660 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_EnumLanguageGroupLocalesW( LANGGROUPLOCALE_ENUMPROCW lpLangGroupLocaleEnumProc, LGRPID LanguageGroup, DWORD dwFlags, LONG_PTR lParam )
8661 {
8662     static FN_EnumLanguageGroupLocalesW *pfn = 0;
8663     if (!pfn)
8664         kPrf2WrapResolve((void **)&pfn, "EnumLanguageGroupLocalesW", &g_Kernel32);
8665     return pfn( lpLangGroupLocaleEnumProc, LanguageGroup, dwFlags, lParam );
8666 }
8667
8668 typedef BOOL WINAPI FN_EnumUILanguagesA( UILANGUAGE_ENUMPROCA lpUILanguageEnumProc, DWORD dwFlags, LONG_PTR lParam );
8669 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_EnumUILanguagesA( UILANGUAGE_ENUMPROCA lpUILanguageEnumProc, DWORD dwFlags, LONG_PTR lParam )
8670 {
8671     static FN_EnumUILanguagesA *pfn = 0;
8672     if (!pfn)
8673         kPrf2WrapResolve((void **)&pfn, "EnumUILanguagesA", &g_Kernel32);
8674     return pfn( lpUILanguageEnumProc, dwFlags, lParam );
8675 }
8676
8677 typedef BOOL WINAPI FN_EnumUILanguagesW( UILANGUAGE_ENUMPROCW lpUILanguageEnumProc, DWORD dwFlags, LONG_PTR lParam );
8678 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_EnumUILanguagesW( UILANGUAGE_ENUMPROCW lpUILanguageEnumProc, DWORD dwFlags, LONG_PTR lParam )
8679 {
8680     static FN_EnumUILanguagesW *pfn = 0;
8681     if (!pfn)
8682         kPrf2WrapResolve((void **)&pfn, "EnumUILanguagesW", &g_Kernel32);
8683     return pfn( lpUILanguageEnumProc, dwFlags, lParam );
8684 }
8685
8686 typedef BOOL WINAPI FN_EnumSystemLocalesA( LOCALE_ENUMPROCA lpLocaleEnumProc, DWORD dwFlags );
8687 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_EnumSystemLocalesA( LOCALE_ENUMPROCA lpLocaleEnumProc, DWORD dwFlags )
8688 {
8689     static FN_EnumSystemLocalesA *pfn = 0;
8690     if (!pfn)
8691         kPrf2WrapResolve((void **)&pfn, "EnumSystemLocalesA", &g_Kernel32);
8692     return pfn( lpLocaleEnumProc, dwFlags );
8693 }
8694
8695 typedef BOOL WINAPI FN_EnumSystemLocalesW( LOCALE_ENUMPROCW lpLocaleEnumProc, DWORD dwFlags );
8696 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_EnumSystemLocalesW( LOCALE_ENUMPROCW lpLocaleEnumProc, DWORD dwFlags )
8697 {
8698     static FN_EnumSystemLocalesW *pfn = 0;
8699     if (!pfn)
8700         kPrf2WrapResolve((void **)&pfn, "EnumSystemLocalesW", &g_Kernel32);
8701     return pfn( lpLocaleEnumProc, dwFlags );
8702 }
8703
8704 typedef BOOL WINAPI FN_EnumSystemCodePagesA( CODEPAGE_ENUMPROCA lpCodePageEnumProc, DWORD dwFlags );
8705 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_EnumSystemCodePagesA( CODEPAGE_ENUMPROCA lpCodePageEnumProc, DWORD dwFlags )
8706 {
8707     static FN_EnumSystemCodePagesA *pfn = 0;
8708     if (!pfn)
8709         kPrf2WrapResolve((void **)&pfn, "EnumSystemCodePagesA", &g_Kernel32);
8710     return pfn( lpCodePageEnumProc, dwFlags );
8711 }
8712
8713 typedef BOOL WINAPI FN_EnumSystemCodePagesW( CODEPAGE_ENUMPROCW lpCodePageEnumProc, DWORD dwFlags );
8714 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_EnumSystemCodePagesW( CODEPAGE_ENUMPROCW lpCodePageEnumProc, DWORD dwFlags )
8715 {
8716     static FN_EnumSystemCodePagesW *pfn = 0;
8717     if (!pfn)
8718         kPrf2WrapResolve((void **)&pfn, "EnumSystemCodePagesW", &g_Kernel32);
8719     return pfn( lpCodePageEnumProc, dwFlags );
8720 }
8721
8722 typedef DWORD APIENTRY FN_VerFindFileA( DWORD uFlags, LPSTR szFileName, LPSTR szWinDir, LPSTR szAppDir, LPSTR szCurDir, PUINT lpuCurDirLen, LPSTR szDestDir, PUINT lpuDestDirLen );
8723 __declspec(dllexport) DWORD APIENTRY kPrf2Wrap_VerFindFileA( DWORD uFlags, LPSTR szFileName, LPSTR szWinDir, LPSTR szAppDir, LPSTR szCurDir, PUINT lpuCurDirLen, LPSTR szDestDir, PUINT lpuDestDirLen )
8724 {
8725     static FN_VerFindFileA *pfn = 0;
8726     if (!pfn)
8727         kPrf2WrapResolve((void **)&pfn, "VerFindFileA", &g_Kernel32);
8728     return pfn( uFlags, szFileName, szWinDir, szAppDir, szCurDir, lpuCurDirLen, szDestDir, lpuDestDirLen );
8729 }
8730
8731 typedef DWORD APIENTRY FN_VerFindFileW( DWORD uFlags, LPWSTR szFileName, LPWSTR szWinDir, LPWSTR szAppDir, LPWSTR szCurDir, PUINT lpuCurDirLen, LPWSTR szDestDir, PUINT lpuDestDirLen );
8732 __declspec(dllexport) DWORD APIENTRY kPrf2Wrap_VerFindFileW( DWORD uFlags, LPWSTR szFileName, LPWSTR szWinDir, LPWSTR szAppDir, LPWSTR szCurDir, PUINT lpuCurDirLen, LPWSTR szDestDir, PUINT lpuDestDirLen )
8733 {
8734     static FN_VerFindFileW *pfn = 0;
8735     if (!pfn)
8736         kPrf2WrapResolve((void **)&pfn, "VerFindFileW", &g_Kernel32);
8737     return pfn( uFlags, szFileName, szWinDir, szAppDir, szCurDir, lpuCurDirLen, szDestDir, lpuDestDirLen );
8738 }
8739
8740 typedef DWORD APIENTRY FN_VerInstallFileA( DWORD uFlags, LPSTR szSrcFileName, LPSTR szDestFileName, LPSTR szSrcDir, LPSTR szDestDir, LPSTR szCurDir, LPSTR szTmpFile, PUINT lpuTmpFileLen );
8741 __declspec(dllexport) DWORD APIENTRY kPrf2Wrap_VerInstallFileA( DWORD uFlags, LPSTR szSrcFileName, LPSTR szDestFileName, LPSTR szSrcDir, LPSTR szDestDir, LPSTR szCurDir, LPSTR szTmpFile, PUINT lpuTmpFileLen )
8742 {
8743     static FN_VerInstallFileA *pfn = 0;
8744     if (!pfn)
8745         kPrf2WrapResolve((void **)&pfn, "VerInstallFileA", &g_Kernel32);
8746     return pfn( uFlags, szSrcFileName, szDestFileName, szSrcDir, szDestDir, szCurDir, szTmpFile, lpuTmpFileLen );
8747 }
8748
8749 typedef DWORD APIENTRY FN_VerInstallFileW( DWORD uFlags, LPWSTR szSrcFileName, LPWSTR szDestFileName, LPWSTR szSrcDir, LPWSTR szDestDir, LPWSTR szCurDir, LPWSTR szTmpFile, PUINT lpuTmpFileLen );
8750 __declspec(dllexport) DWORD APIENTRY kPrf2Wrap_VerInstallFileW( DWORD uFlags, LPWSTR szSrcFileName, LPWSTR szDestFileName, LPWSTR szSrcDir, LPWSTR szDestDir, LPWSTR szCurDir, LPWSTR szTmpFile, PUINT lpuTmpFileLen )
8751 {
8752     static FN_VerInstallFileW *pfn = 0;
8753     if (!pfn)
8754         kPrf2WrapResolve((void **)&pfn, "VerInstallFileW", &g_Kernel32);
8755     return pfn( uFlags, szSrcFileName, szDestFileName, szSrcDir, szDestDir, szCurDir, szTmpFile, lpuTmpFileLen );
8756 }
8757
8758 typedef DWORD APIENTRY FN_GetFileVersionInfoSizeA( LPCSTR lptstrFilename, LPDWORD lpdwHandle );
8759 __declspec(dllexport) DWORD APIENTRY kPrf2Wrap_GetFileVersionInfoSizeA( LPCSTR lptstrFilename, LPDWORD lpdwHandle )
8760 {
8761     static FN_GetFileVersionInfoSizeA *pfn = 0;
8762     if (!pfn)
8763         kPrf2WrapResolve((void **)&pfn, "GetFileVersionInfoSizeA", &g_Kernel32);
8764     return pfn( lptstrFilename, lpdwHandle );
8765 }
8766
8767 typedef DWORD APIENTRY FN_GetFileVersionInfoSizeW( LPCWSTR lptstrFilename, LPDWORD lpdwHandle );
8768 __declspec(dllexport) DWORD APIENTRY kPrf2Wrap_GetFileVersionInfoSizeW( LPCWSTR lptstrFilename, LPDWORD lpdwHandle )
8769 {
8770     static FN_GetFileVersionInfoSizeW *pfn = 0;
8771     if (!pfn)
8772         kPrf2WrapResolve((void **)&pfn, "GetFileVersionInfoSizeW", &g_Kernel32);
8773     return pfn( lptstrFilename, lpdwHandle );
8774 }
8775
8776 typedef BOOL APIENTRY FN_GetFileVersionInfoA( LPCSTR lptstrFilename, DWORD dwHandle, DWORD dwLen, LPVOID lpData );
8777 __declspec(dllexport) BOOL APIENTRY kPrf2Wrap_GetFileVersionInfoA( LPCSTR lptstrFilename, DWORD dwHandle, DWORD dwLen, LPVOID lpData )
8778 {
8779     static FN_GetFileVersionInfoA *pfn = 0;
8780     if (!pfn)
8781         kPrf2WrapResolve((void **)&pfn, "GetFileVersionInfoA", &g_Kernel32);
8782     return pfn( lptstrFilename, dwHandle, dwLen, lpData );
8783 }
8784
8785 typedef BOOL APIENTRY FN_GetFileVersionInfoW( LPCWSTR lptstrFilename, DWORD dwHandle, DWORD dwLen, LPVOID lpData );
8786 __declspec(dllexport) BOOL APIENTRY kPrf2Wrap_GetFileVersionInfoW( LPCWSTR lptstrFilename, DWORD dwHandle, DWORD dwLen, LPVOID lpData )
8787 {
8788     static FN_GetFileVersionInfoW *pfn = 0;
8789     if (!pfn)
8790         kPrf2WrapResolve((void **)&pfn, "GetFileVersionInfoW", &g_Kernel32);
8791     return pfn( lptstrFilename, dwHandle, dwLen, lpData );
8792 }
8793
8794 typedef DWORD APIENTRY FN_VerLanguageNameA( DWORD wLang, LPSTR szLang, DWORD nSize );
8795 __declspec(dllexport) DWORD APIENTRY kPrf2Wrap_VerLanguageNameA( DWORD wLang, LPSTR szLang, DWORD nSize )
8796 {
8797     static FN_VerLanguageNameA *pfn = 0;
8798     if (!pfn)
8799         kPrf2WrapResolve((void **)&pfn, "VerLanguageNameA", &g_Kernel32);
8800     return pfn( wLang, szLang, nSize );
8801 }
8802
8803 typedef DWORD APIENTRY FN_VerLanguageNameW( DWORD wLang, LPWSTR szLang, DWORD nSize );
8804 __declspec(dllexport) DWORD APIENTRY kPrf2Wrap_VerLanguageNameW( DWORD wLang, LPWSTR szLang, DWORD nSize )
8805 {
8806     static FN_VerLanguageNameW *pfn = 0;
8807     if (!pfn)
8808         kPrf2WrapResolve((void **)&pfn, "VerLanguageNameW", &g_Kernel32);
8809     return pfn( wLang, szLang, nSize );
8810 }
8811
8812 typedef BOOL APIENTRY FN_VerQueryValueA( const LPVOID pBlock, LPSTR lpSubBlock, LPVOID * lplpBuffer, PUINT puLen );
8813 __declspec(dllexport) BOOL APIENTRY kPrf2Wrap_VerQueryValueA( const LPVOID pBlock, LPSTR lpSubBlock, LPVOID * lplpBuffer, PUINT puLen )
8814 {
8815     static FN_VerQueryValueA *pfn = 0;
8816     if (!pfn)
8817         kPrf2WrapResolve((void **)&pfn, "VerQueryValueA", &g_Kernel32);
8818     return pfn( pBlock, lpSubBlock, lplpBuffer, puLen );
8819 }
8820
8821 typedef BOOL APIENTRY FN_VerQueryValueW( const LPVOID pBlock, LPWSTR lpSubBlock, LPVOID * lplpBuffer, PUINT puLen );
8822 __declspec(dllexport) BOOL APIENTRY kPrf2Wrap_VerQueryValueW( const LPVOID pBlock, LPWSTR lpSubBlock, LPVOID * lplpBuffer, PUINT puLen )
8823 {
8824     static FN_VerQueryValueW *pfn = 0;
8825     if (!pfn)
8826         kPrf2WrapResolve((void **)&pfn, "VerQueryValueW", &g_Kernel32);
8827     return pfn( pBlock, lpSubBlock, lplpBuffer, puLen );
8828 }
8829
8830 typedef VOID __cdecl FN_RtlRestoreContext( IN PCONTEXT ContextRecord, IN struct _EXCEPTION_RECORD * ExceptionRecord );
8831 __declspec(dllexport) VOID __cdecl kPrf2Wrap_RtlRestoreContext( IN PCONTEXT ContextRecord, IN struct _EXCEPTION_RECORD * ExceptionRecord )
8832 {
8833     static FN_RtlRestoreContext *pfn = 0;
8834     if (!pfn)
8835         kPrf2WrapResolve((void **)&pfn, "RtlRestoreContext", &g_Kernel32);
8836     pfn( ContextRecord, ExceptionRecord );
8837 }
8838
8839 typedef BOOLEAN __cdecl FN_RtlAddFunctionTable( IN PRUNTIME_FUNCTION FunctionTable, IN DWORD EntryCount, IN DWORD64 BaseAddress );
8840 __declspec(dllexport) BOOLEAN __cdecl kPrf2Wrap_RtlAddFunctionTable( IN PRUNTIME_FUNCTION FunctionTable, IN DWORD EntryCount, IN DWORD64 BaseAddress )
8841 {
8842     static FN_RtlAddFunctionTable *pfn = 0;
8843     if (!pfn)
8844         kPrf2WrapResolve((void **)&pfn, "RtlAddFunctionTable", &g_Kernel32);
8845     return pfn( FunctionTable, EntryCount, BaseAddress );
8846 }
8847
8848 typedef BOOLEAN __cdecl FN_RtlInstallFunctionTableCallback( IN DWORD64 TableIdentifier, IN DWORD64 BaseAddress, IN DWORD Length, IN PGET_RUNTIME_FUNCTION_CALLBACK Callback, IN PVOID Context, IN PCWSTR OutOfProcessCallbackDll );
8849 __declspec(dllexport) BOOLEAN __cdecl kPrf2Wrap_RtlInstallFunctionTableCallback( IN DWORD64 TableIdentifier, IN DWORD64 BaseAddress, IN DWORD Length, IN PGET_RUNTIME_FUNCTION_CALLBACK Callback, IN PVOID Context, IN PCWSTR OutOfProcessCallbackDll )
8850 {
8851     static FN_RtlInstallFunctionTableCallback *pfn = 0;
8852     if (!pfn)
8853         kPrf2WrapResolve((void **)&pfn, "RtlInstallFunctionTableCallback", &g_Kernel32);
8854     return pfn( TableIdentifier, BaseAddress, Length, Callback, Context, OutOfProcessCallbackDll );
8855 }
8856
8857 typedef BOOLEAN __cdecl FN_RtlDeleteFunctionTable( IN PRUNTIME_FUNCTION FunctionTable );
8858 __declspec(dllexport) BOOLEAN __cdecl kPrf2Wrap_RtlDeleteFunctionTable( IN PRUNTIME_FUNCTION FunctionTable )
8859 {
8860     static FN_RtlDeleteFunctionTable *pfn = 0;
8861     if (!pfn)
8862         kPrf2WrapResolve((void **)&pfn, "RtlDeleteFunctionTable", &g_Kernel32);
8863     return pfn( FunctionTable );
8864 }
8865
8866 typedef VOID NTAPI FN_RtlInitializeSListHead( IN PSLIST_HEADER ListHead );
8867 __declspec(dllexport) VOID NTAPI kPrf2Wrap_RtlInitializeSListHead( IN PSLIST_HEADER ListHead )
8868 {
8869     static FN_RtlInitializeSListHead *pfn = 0;
8870     if (!pfn)
8871         kPrf2WrapResolve((void **)&pfn, "RtlInitializeSListHead", &g_Kernel32);
8872     pfn( ListHead );
8873 }
8874
8875 typedef PSLIST_ENTRY NTAPI FN_RtlFirstEntrySList( IN const SLIST_HEADER * ListHead );
8876 __declspec(dllexport) PSLIST_ENTRY NTAPI kPrf2Wrap_RtlFirstEntrySList( IN const SLIST_HEADER * ListHead )
8877 {
8878     static FN_RtlFirstEntrySList *pfn = 0;
8879     if (!pfn)
8880         kPrf2WrapResolve((void **)&pfn, "RtlFirstEntrySList", &g_Kernel32);
8881     return pfn( ListHead );
8882 }
8883
8884 typedef PSLIST_ENTRY NTAPI FN_RtlInterlockedPopEntrySList( IN PSLIST_HEADER ListHead );
8885 __declspec(dllexport) PSLIST_ENTRY NTAPI kPrf2Wrap_RtlInterlockedPopEntrySList( IN PSLIST_HEADER ListHead )
8886 {
8887     static FN_RtlInterlockedPopEntrySList *pfn = 0;
8888     if (!pfn)
8889         kPrf2WrapResolve((void **)&pfn, "RtlInterlockedPopEntrySList", &g_Kernel32);
8890     return pfn( ListHead );
8891 }
8892
8893 typedef PSLIST_ENTRY NTAPI FN_RtlInterlockedPushEntrySList( IN PSLIST_HEADER ListHead, IN PSLIST_ENTRY ListEntry );
8894 __declspec(dllexport) PSLIST_ENTRY NTAPI kPrf2Wrap_RtlInterlockedPushEntrySList( IN PSLIST_HEADER ListHead, IN PSLIST_ENTRY ListEntry )
8895 {
8896     static FN_RtlInterlockedPushEntrySList *pfn = 0;
8897     if (!pfn)
8898         kPrf2WrapResolve((void **)&pfn, "RtlInterlockedPushEntrySList", &g_Kernel32);
8899     return pfn( ListHead, ListEntry );
8900 }
8901
8902 typedef PSLIST_ENTRY NTAPI FN_RtlInterlockedFlushSList( IN PSLIST_HEADER ListHead );
8903 __declspec(dllexport) PSLIST_ENTRY NTAPI kPrf2Wrap_RtlInterlockedFlushSList( IN PSLIST_HEADER ListHead )
8904 {
8905     static FN_RtlInterlockedFlushSList *pfn = 0;
8906     if (!pfn)
8907         kPrf2WrapResolve((void **)&pfn, "RtlInterlockedFlushSList", &g_Kernel32);
8908     return pfn( ListHead );
8909 }
8910
8911 typedef WORD NTAPI FN_RtlQueryDepthSList( IN PSLIST_HEADER ListHead );
8912 __declspec(dllexport) WORD NTAPI kPrf2Wrap_RtlQueryDepthSList( IN PSLIST_HEADER ListHead )
8913 {
8914     static FN_RtlQueryDepthSList *pfn = 0;
8915     if (!pfn)
8916         kPrf2WrapResolve((void **)&pfn, "RtlQueryDepthSList", &g_Kernel32);
8917     return pfn( ListHead );
8918 }
8919
8920 typedef VOID NTAPI FN_RtlCaptureContext( OUT PCONTEXT ContextRecord );
8921 __declspec(dllexport) VOID NTAPI kPrf2Wrap_RtlCaptureContext( OUT PCONTEXT ContextRecord )
8922 {
8923     static FN_RtlCaptureContext *pfn = 0;
8924     if (!pfn)
8925         kPrf2WrapResolve((void **)&pfn, "RtlCaptureContext", &g_Kernel32);
8926     pfn( ContextRecord );
8927 }
8928
8929 typedef SIZE_T NTAPI FN_RtlCompareMemory( const VOID * Source1, const VOID * Source2, SIZE_T Length );
8930 __declspec(dllexport) SIZE_T NTAPI kPrf2Wrap_RtlCompareMemory( const VOID * Source1, const VOID * Source2, SIZE_T Length )
8931 {
8932     static FN_RtlCompareMemory *pfn = 0;
8933     if (!pfn)
8934         kPrf2WrapResolve((void **)&pfn, "RtlCompareMemory", &g_Kernel32);
8935     return pfn( Source1, Source2, Length );
8936 }
8937
8938 typedef ULONGLONG NTAPI FN_VerSetConditionMask( IN ULONGLONG ConditionMask, IN DWORD TypeMask, IN BYTE Condition );
8939 __declspec(dllexport) ULONGLONG NTAPI kPrf2Wrap_VerSetConditionMask( IN ULONGLONG ConditionMask, IN DWORD TypeMask, IN BYTE Condition )
8940 {
8941     static FN_VerSetConditionMask *pfn = 0;
8942     if (!pfn)
8943         kPrf2WrapResolve((void **)&pfn, "VerSetConditionMask", &g_Kernel32);
8944     return pfn( ConditionMask, TypeMask, Condition );
8945 }
8946
8947 typedef DWORD NTAPI FN_RtlSetHeapInformation( IN PVOID HeapHandle, IN HEAP_INFORMATION_CLASS HeapInformationClass, IN PVOID HeapInformation , IN SIZE_T HeapInformationLength );
8948 __declspec(dllexport) DWORD NTAPI kPrf2Wrap_RtlSetHeapInformation( IN PVOID HeapHandle, IN HEAP_INFORMATION_CLASS HeapInformationClass, IN PVOID HeapInformation , IN SIZE_T HeapInformationLength )
8949 {
8950     static FN_RtlSetHeapInformation *pfn = 0;
8951     if (!pfn)
8952         kPrf2WrapResolve((void **)&pfn, "RtlSetHeapInformation", &g_Kernel32);
8953     return pfn( HeapHandle, HeapInformationClass, HeapInformation , HeapInformationLength );
8954 }
8955
8956 typedef DWORD NTAPI FN_RtlQueryHeapInformation( IN PVOID HeapHandle, IN HEAP_INFORMATION_CLASS HeapInformationClass, OUT PVOID HeapInformation , IN SIZE_T HeapInformationLength , OUT PSIZE_T ReturnLength );
8957 __declspec(dllexport) DWORD NTAPI kPrf2Wrap_RtlQueryHeapInformation( IN PVOID HeapHandle, IN HEAP_INFORMATION_CLASS HeapInformationClass, OUT PVOID HeapInformation , IN SIZE_T HeapInformationLength , OUT PSIZE_T ReturnLength )
8958 {
8959     static FN_RtlQueryHeapInformation *pfn = 0;
8960     if (!pfn)
8961         kPrf2WrapResolve((void **)&pfn, "RtlQueryHeapInformation", &g_Kernel32);
8962     return pfn( HeapHandle, HeapInformationClass, HeapInformation , HeapInformationLength , ReturnLength );
8963 }
8964
8965 typedef HANDLE WINAPI FN_CreateToolhelp32Snapshot( DWORD dwFlags, DWORD th32ProcessID );
8966 __declspec(dllexport) HANDLE WINAPI kPrf2Wrap_CreateToolhelp32Snapshot( DWORD dwFlags, DWORD th32ProcessID )
8967 {
8968     static FN_CreateToolhelp32Snapshot *pfn = 0;
8969     if (!pfn)
8970         kPrf2WrapResolve((void **)&pfn, "CreateToolhelp32Snapshot", &g_Kernel32);
8971     return pfn( dwFlags, th32ProcessID );
8972 }
8973
8974 typedef BOOL WINAPI FN_Heap32ListFirst( HANDLE hSnapshot, LPHEAPLIST32 lphl );
8975 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_Heap32ListFirst( HANDLE hSnapshot, LPHEAPLIST32 lphl )
8976 {
8977     static FN_Heap32ListFirst *pfn = 0;
8978     if (!pfn)
8979         kPrf2WrapResolve((void **)&pfn, "Heap32ListFirst", &g_Kernel32);
8980     return pfn( hSnapshot, lphl );
8981 }
8982
8983 typedef BOOL WINAPI FN_Heap32ListNext( HANDLE hSnapshot, LPHEAPLIST32 lphl );
8984 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_Heap32ListNext( HANDLE hSnapshot, LPHEAPLIST32 lphl )
8985 {
8986     static FN_Heap32ListNext *pfn = 0;
8987     if (!pfn)
8988         kPrf2WrapResolve((void **)&pfn, "Heap32ListNext", &g_Kernel32);
8989     return pfn( hSnapshot, lphl );
8990 }
8991
8992 typedef BOOL WINAPI FN_Heap32First( LPHEAPENTRY32 lphe, DWORD th32ProcessID, ULONG_PTR th32HeapID );
8993 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_Heap32First( LPHEAPENTRY32 lphe, DWORD th32ProcessID, ULONG_PTR th32HeapID )
8994 {
8995     static FN_Heap32First *pfn = 0;
8996     if (!pfn)
8997         kPrf2WrapResolve((void **)&pfn, "Heap32First", &g_Kernel32);
8998     return pfn( lphe, th32ProcessID, th32HeapID );
8999 }
9000
9001 typedef BOOL WINAPI FN_Heap32Next( LPHEAPENTRY32 lphe );
9002 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_Heap32Next( LPHEAPENTRY32 lphe )
9003 {
9004     static FN_Heap32Next *pfn = 0;
9005     if (!pfn)
9006         kPrf2WrapResolve((void **)&pfn, "Heap32Next", &g_Kernel32);
9007     return pfn( lphe );
9008 }
9009
9010 typedef BOOL WINAPI FN_Toolhelp32ReadProcessMemory( DWORD th32ProcessID, LPCVOID lpBaseAddress, LPVOID lpBuffer, SIZE_T cbRead, SIZE_T * lpNumberOfBytesRead );
9011 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_Toolhelp32ReadProcessMemory( DWORD th32ProcessID, LPCVOID lpBaseAddress, LPVOID lpBuffer, SIZE_T cbRead, SIZE_T * lpNumberOfBytesRead )
9012 {
9013     static FN_Toolhelp32ReadProcessMemory *pfn = 0;
9014     if (!pfn)
9015         kPrf2WrapResolve((void **)&pfn, "Toolhelp32ReadProcessMemory", &g_Kernel32);
9016     return pfn( th32ProcessID, lpBaseAddress, lpBuffer, cbRead, lpNumberOfBytesRead );
9017 }
9018
9019 typedef BOOL WINAPI FN_Process32FirstW( HANDLE hSnapshot, LPPROCESSENTRY32W lppe );
9020 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_Process32FirstW( HANDLE hSnapshot, LPPROCESSENTRY32W lppe )
9021 {
9022     static FN_Process32FirstW *pfn = 0;
9023     if (!pfn)
9024         kPrf2WrapResolve((void **)&pfn, "Process32FirstW", &g_Kernel32);
9025     return pfn( hSnapshot, lppe );
9026 }
9027
9028 typedef BOOL WINAPI FN_Process32NextW( HANDLE hSnapshot, LPPROCESSENTRY32W lppe );
9029 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_Process32NextW( HANDLE hSnapshot, LPPROCESSENTRY32W lppe )
9030 {
9031     static FN_Process32NextW *pfn = 0;
9032     if (!pfn)
9033         kPrf2WrapResolve((void **)&pfn, "Process32NextW", &g_Kernel32);
9034     return pfn( hSnapshot, lppe );
9035 }
9036
9037 typedef BOOL WINAPI FN_Process32First( HANDLE hSnapshot, LPPROCESSENTRY32 lppe );
9038 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_Process32First( HANDLE hSnapshot, LPPROCESSENTRY32 lppe )
9039 {
9040     static FN_Process32First *pfn = 0;
9041     if (!pfn)
9042         kPrf2WrapResolve((void **)&pfn, "Process32First", &g_Kernel32);
9043     return pfn( hSnapshot, lppe );
9044 }
9045
9046 typedef BOOL WINAPI FN_Process32Next( HANDLE hSnapshot, LPPROCESSENTRY32 lppe );
9047 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_Process32Next( HANDLE hSnapshot, LPPROCESSENTRY32 lppe )
9048 {
9049     static FN_Process32Next *pfn = 0;
9050     if (!pfn)
9051         kPrf2WrapResolve((void **)&pfn, "Process32Next", &g_Kernel32);
9052     return pfn( hSnapshot, lppe );
9053 }
9054
9055 typedef BOOL WINAPI FN_Thread32First( HANDLE hSnapshot, LPTHREADENTRY32 lpte );
9056 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_Thread32First( HANDLE hSnapshot, LPTHREADENTRY32 lpte )
9057 {
9058     static FN_Thread32First *pfn = 0;
9059     if (!pfn)
9060         kPrf2WrapResolve((void **)&pfn, "Thread32First", &g_Kernel32);
9061     return pfn( hSnapshot, lpte );
9062 }
9063
9064 typedef BOOL WINAPI FN_Thread32Next( HANDLE hSnapshot, LPTHREADENTRY32 lpte );
9065 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_Thread32Next( HANDLE hSnapshot, LPTHREADENTRY32 lpte )
9066 {
9067     static FN_Thread32Next *pfn = 0;
9068     if (!pfn)
9069         kPrf2WrapResolve((void **)&pfn, "Thread32Next", &g_Kernel32);
9070     return pfn( hSnapshot, lpte );
9071 }
9072
9073 typedef BOOL WINAPI FN_Module32FirstW( HANDLE hSnapshot, LPMODULEENTRY32W lpme );
9074 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_Module32FirstW( HANDLE hSnapshot, LPMODULEENTRY32W lpme )
9075 {
9076     static FN_Module32FirstW *pfn = 0;
9077     if (!pfn)
9078         kPrf2WrapResolve((void **)&pfn, "Module32FirstW", &g_Kernel32);
9079     return pfn( hSnapshot, lpme );
9080 }
9081
9082 typedef BOOL WINAPI FN_Module32NextW( HANDLE hSnapshot, LPMODULEENTRY32W lpme );
9083 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_Module32NextW( HANDLE hSnapshot, LPMODULEENTRY32W lpme )
9084 {
9085     static FN_Module32NextW *pfn = 0;
9086     if (!pfn)
9087         kPrf2WrapResolve((void **)&pfn, "Module32NextW", &g_Kernel32);
9088     return pfn( hSnapshot, lpme );
9089 }
9090
9091 typedef BOOL WINAPI FN_Module32First( HANDLE hSnapshot, LPMODULEENTRY32 lpme );
9092 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_Module32First( HANDLE hSnapshot, LPMODULEENTRY32 lpme )
9093 {
9094     static FN_Module32First *pfn = 0;
9095     if (!pfn)
9096         kPrf2WrapResolve((void **)&pfn, "Module32First", &g_Kernel32);
9097     return pfn( hSnapshot, lpme );
9098 }
9099
9100 typedef BOOL WINAPI FN_Module32Next( HANDLE hSnapshot, LPMODULEENTRY32 lpme );
9101 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_Module32Next( HANDLE hSnapshot, LPMODULEENTRY32 lpme )
9102 {
9103     static FN_Module32Next *pfn = 0;
9104     if (!pfn)
9105         kPrf2WrapResolve((void **)&pfn, "Module32Next", &g_Kernel32);
9106     return pfn( hSnapshot, lpme );
9107 }
9108
9109 typedef BOOL WINAPI FN_ReplaceFile( LPCSTR lpReplacedFileName, LPCSTR lpReplacementFileName, LPCSTR lpBackupFileName, DWORD dwReplaceFlags, LPVOID lpExclude, LPVOID lpReserved );
9110 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_ReplaceFile( LPCSTR lpReplacedFileName, LPCSTR lpReplacementFileName, LPCSTR lpBackupFileName, DWORD dwReplaceFlags, LPVOID lpExclude, LPVOID lpReserved )
9111 {
9112     static FN_ReplaceFile *pfn = 0;
9113     if (!pfn)
9114         kPrf2WrapResolve((void **)&pfn, "ReplaceFile", &g_Kernel32);
9115     return pfn( lpReplacedFileName, lpReplacementFileName, lpBackupFileName, dwReplaceFlags, lpExclude, lpReserved );
9116 }
9117
9118 typedef BOOL WINAPI FN_SetConsoleCursor( PVOID pvUnknown1, PVOID pvUnknown2 );
9119 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_SetConsoleCursor( PVOID pvUnknown1, PVOID pvUnknown2 )
9120 {
9121     static FN_SetConsoleCursor *pfn = 0;
9122     if (!pfn)
9123         kPrf2WrapResolve((void **)&pfn, "SetConsoleCursor", &g_Kernel32);
9124     return pfn( pvUnknown1, pvUnknown2 );
9125 }
9126
9127 typedef LPCH WINAPI FN_GetEnvironmentStringsA( VOID );
9128 __declspec(dllexport) LPCH WINAPI kPrf2Wrap_GetEnvironmentStringsA( VOID )
9129 {
9130     static FN_GetEnvironmentStringsA *pfn = 0;
9131     if (!pfn)
9132         kPrf2WrapResolve((void **)&pfn, "GetEnvironmentStringsA", &g_Kernel32);
9133     return pfn ();
9134 }
9135
9136 typedef BOOL WINAPI FN_GetBinaryType( LPCSTR lpApplicationName, LPDWORD lpBinaryType );
9137 __declspec(dllexport) BOOL WINAPI kPrf2Wrap_GetBinaryType( LPCSTR lpApplicationName, LPDWORD lpBinaryType )
9138 {
9139     static FN_GetBinaryType *pfn = 0;
9140     if (!pfn)
9141         kPrf2WrapResolve((void **)&pfn, "GetBinaryType", &g_Kernel32);
9142     return pfn( lpApplicationName, lpBinaryType );
9143 }
9144
9145 typedef WORD NTAPI FN_RtlCaptureStackBackTrace( DWORD FramesToSkip, DWORD FramesToCapture, PVOID * BackTrace, PDWORD BackTraceHash );
9146 __declspec(dllexport) WORD NTAPI kPrf2Wrap_RtlCaptureStackBackTrace( DWORD FramesToSkip, DWORD FramesToCapture, PVOID * BackTrace, PDWORD BackTraceHash )
9147 {
9148     static FN_RtlCaptureStackBackTrace *pfn = 0;
9149     if (!pfn)
9150         kPrf2WrapResolve((void **)&pfn, "RtlCaptureStackBackTrace", &g_Kernel32);
9151     return pfn( FramesToSkip, FramesToCapture, BackTrace, BackTraceHash );
9152 }
9153
9154 typedef PVOID FN_RtlFillMemory( PVOID pv, int ch, SIZE_T cb );
9155 __declspec(dllexport) PVOID kPrf2Wrap_RtlFillMemory( PVOID pv, int ch, SIZE_T cb )
9156 {
9157     static FN_RtlFillMemory *pfn = 0;
9158     if (!pfn)
9159         kPrf2WrapResolve((void **)&pfn, "RtlFillMemory", &g_Kernel32);
9160     return pfn( pv, ch, cb );
9161 }
9162
9163 typedef PVOID FN_RtlZeroMemory( PVOID pv, SIZE_T cb );
9164 __declspec(dllexport) PVOID kPrf2Wrap_RtlZeroMemory( PVOID pv, SIZE_T cb )
9165 {
9166     static FN_RtlZeroMemory *pfn = 0;
9167     if (!pfn)
9168         kPrf2WrapResolve((void **)&pfn, "RtlZeroMemory", &g_Kernel32);
9169     return pfn( pv, cb );
9170 }
9171
9172 typedef PVOID FN_RtlMoveMemory( PVOID pvDst, PVOID pvSrc, SIZE_T cb );
9173 __declspec(dllexport) PVOID kPrf2Wrap_RtlMoveMemory( PVOID pvDst, PVOID pvSrc, SIZE_T cb )
9174 {
9175     static FN_RtlMoveMemory *pfn = 0;
9176     if (!pfn)
9177         kPrf2WrapResolve((void **)&pfn, "RtlMoveMemory", &g_Kernel32);
9178     return pfn( pvDst, pvSrc, cb );
9179 }
9180
9181 typedef VOID NTAPI FN_RtlUnwind( PVOID TargetFrame, PVOID TargetIp, PEXCEPTION_RECORD ExceptionRecord, PVOID ReturnValue );
9182 __declspec(dllexport) VOID NTAPI kPrf2Wrap_RtlUnwind( PVOID TargetFrame, PVOID TargetIp, PEXCEPTION_RECORD ExceptionRecord, PVOID ReturnValue )
9183 {
9184     static FN_RtlUnwind *pfn = 0;
9185     if (!pfn)
9186         kPrf2WrapResolve((void **)&pfn, "RtlUnwind", &g_Kernel32);
9187     pfn( TargetFrame, TargetIp, ExceptionRecord, ReturnValue );
9188 }
9189
9190 typedef VOID NTAPI FN_RtlUnwindEx( FRAME_POINTERS TargetFrame, PVOID TargetIp, PEXCEPTION_RECORD ExceptionRecord, PVOID ReturnValue, PCONTEXT ContextRecord, PUNWIND_HISTORY_TABLE HistoryTable );
9191 __declspec(dllexport) VOID NTAPI kPrf2Wrap_RtlUnwindEx( FRAME_POINTERS TargetFrame, PVOID TargetIp, PEXCEPTION_RECORD ExceptionRecord, PVOID ReturnValue, PCONTEXT ContextRecord, PUNWIND_HISTORY_TABLE HistoryTable )
9192 {
9193     static FN_RtlUnwindEx *pfn = 0;
9194     if (!pfn)
9195         kPrf2WrapResolve((void **)&pfn, "RtlUnwindEx", &g_Kernel32);
9196     pfn( TargetFrame, TargetIp, ExceptionRecord, ReturnValue, ContextRecord, HistoryTable );
9197 }
9198
9199 typedef ULONGLONG WINAPI FN_RtlVirtualUnwind( ULONG HandlerType, ULONGLONG ImageBase, ULONGLONG ControlPC, PRUNTIME_FUNCTION FunctionEntry, PCONTEXT ContextRecord, PBOOLEAN InFunction, PFRAME_POINTERS EstablisherFrame, PKNONVOLATILE_CONTEXT_POINTERS ContextPointers );
9200 __declspec(dllexport) ULONGLONG WINAPI kPrf2Wrap_RtlVirtualUnwind( ULONG HandlerType, ULONGLONG ImageBase, ULONGLONG ControlPC, PRUNTIME_FUNCTION FunctionEntry, PCONTEXT ContextRecord, PBOOLEAN InFunction, PFRAME_POINTERS EstablisherFrame, PKNONVOLATILE_CONTEXT_POINTERS ContextPointers )
9201 {
9202     static FN_RtlVirtualUnwind *pfn = 0;
9203     if (!pfn)
9204         kPrf2WrapResolve((void **)&pfn, "RtlVirtualUnwind", &g_Kernel32);
9205     return pfn( HandlerType, ImageBase, ControlPC, FunctionEntry, ContextRecord, InFunction, EstablisherFrame, ContextPointers );
9206 }
9207
9208 typedef PVOID WINAPI FN_RtlPcToFileHeader( PVOID PcValue, PVOID * BaseOfImage );
9209 __declspec(dllexport) PVOID WINAPI kPrf2Wrap_RtlPcToFileHeader( PVOID PcValue, PVOID * BaseOfImage )
9210 {
9211     static FN_RtlPcToFileHeader *pfn = 0;
9212     if (!pfn)
9213         kPrf2WrapResolve((void **)&pfn, "RtlPcToFileHeader", &g_Kernel32);
9214     return pfn( PcValue, BaseOfImage );
9215 }
9216
9217 typedef PVOID WINAPI FN_RtlLookupFunctionEntry( ULONGLONG ControlPC, PULONGLONG ImageBase, PULONGLONG TargetGp );
9218 __declspec(dllexport) PVOID WINAPI kPrf2Wrap_RtlLookupFunctionEntry( ULONGLONG ControlPC, PULONGLONG ImageBase, PULONGLONG TargetGp )
9219 {
9220     static FN_RtlLookupFunctionEntry *pfn = 0;
9221     if (!pfn)
9222         kPrf2WrapResolve((void **)&pfn, "RtlLookupFunctionEntry", &g_Kernel32);
9223     return pfn( ControlPC, ImageBase, TargetGp );
9224 }
9225
9226 typedef void WINAPI FN_RtlRaiseException(PEXCEPTION_RECORD pXcpRec);
9227 __declspec(dllexport) void WINAPI kPrf2Wrap_RtlRaiseException(PEXCEPTION_RECORD pXcpRec)
9228 {
9229     static FN_RtlRaiseException *pfn = 0;
9230     if (!pfn)
9231         kPrf2WrapResolve((void **)&pfn, "RtlRaiseException", &g_Kernel32);
9232     pfn( pXcpRec);
9233 }
9234
9235 typedef int WINAPI FN_uaw_lstrcmpW( LPCUWSTR lpString1, LPCUWSTR lpString2 );
9236 __declspec(dllexport) int WINAPI kPrf2Wrap_uaw_lstrcmpW( LPCUWSTR lpString1, LPCUWSTR lpString2 )
9237 {
9238     static FN_uaw_lstrcmpW *pfn = 0;
9239     if (!pfn)
9240         kPrf2WrapResolve((void **)&pfn, "uaw_lstrcmpW", &g_Kernel32);
9241     return pfn( lpString1, lpString2 );
9242 }
9243
9244 typedef int WINAPI FN_uaw_lstrcmpiW( LPCUWSTR lpString1, LPCUWSTR lpString2 );
9245 __declspec(dllexport) int WINAPI kPrf2Wrap_uaw_lstrcmpiW( LPCUWSTR lpString1, LPCUWSTR lpString2 )
9246 {
9247     static FN_uaw_lstrcmpiW *pfn = 0;
9248     if (!pfn)
9249         kPrf2WrapResolve((void **)&pfn, "uaw_lstrcmpiW", &g_Kernel32);
9250     return pfn( lpString1, lpString2 );
9251 }
9252
9253 typedef int WINAPI FN_uaw_lstrlenW( LPCUWSTR lpString );
9254 __declspec(dllexport) int WINAPI kPrf2Wrap_uaw_lstrlenW( LPCUWSTR lpString )
9255 {
9256     static FN_uaw_lstrlenW *pfn = 0;
9257     if (!pfn)
9258         kPrf2WrapResolve((void **)&pfn, "uaw_lstrlenW", &g_Kernel32);
9259     return pfn( lpString );
9260 }
9261
9262 typedef LPUWSTR WINAPI FN_uaw_wcschr( LPCUWSTR lpString, WCHAR wc );
9263 __declspec(dllexport) LPUWSTR WINAPI kPrf2Wrap_uaw_wcschr( LPCUWSTR lpString, WCHAR wc )
9264 {
9265     static FN_uaw_wcschr *pfn = 0;
9266     if (!pfn)
9267         kPrf2WrapResolve((void **)&pfn, "uaw_wcschr", &g_Kernel32);
9268     return pfn( lpString, wc );
9269 }
9270
9271 typedef LPUWSTR WINAPI FN_uaw_wcscpy( LPUWSTR lpDst, LPCUWSTR lpSrc );
9272 __declspec(dllexport) LPUWSTR WINAPI kPrf2Wrap_uaw_wcscpy( LPUWSTR lpDst, LPCUWSTR lpSrc )
9273 {
9274     static FN_uaw_wcscpy *pfn = 0;
9275     if (!pfn)
9276         kPrf2WrapResolve((void **)&pfn, "uaw_wcscpy", &g_Kernel32);
9277     return pfn( lpDst, lpSrc );
9278 }
9279
9280 typedef int WINAPI FN_uaw_wcsicmp( LPCUWSTR lp1, LPCUWSTR lp2 );
9281 __declspec(dllexport) int WINAPI kPrf2Wrap_uaw_wcsicmp( LPCUWSTR lp1, LPCUWSTR lp2 )
9282 {
9283     static FN_uaw_wcsicmp *pfn = 0;
9284     if (!pfn)
9285         kPrf2WrapResolve((void **)&pfn, "uaw_wcsicmp", &g_Kernel32);
9286     return pfn( lp1, lp2 );
9287 }
9288
9289 typedef SIZE_T WINAPI FN_uaw_wcslen( LPCUWSTR lp1 );
9290 __declspec(dllexport) SIZE_T WINAPI kPrf2Wrap_uaw_wcslen( LPCUWSTR lp1 )
9291 {
9292     static FN_uaw_wcslen *pfn = 0;
9293     if (!pfn)
9294         kPrf2WrapResolve((void **)&pfn, "uaw_wcslen", &g_Kernel32);
9295     return pfn( lp1 );
9296 }
9297
9298 typedef LPUWSTR WINAPI FN_uaw_wcsrchr( LPCUWSTR lpString, WCHAR wc );
9299 __declspec(dllexport) LPUWSTR WINAPI kPrf2Wrap_uaw_wcsrchr( LPCUWSTR lpString, WCHAR wc )
9300 {
9301     static FN_uaw_wcsrchr *pfn = 0;
9302     if (!pfn)
9303         kPrf2WrapResolve((void **)&pfn, "uaw_wcsrchr", &g_Kernel32);
9304     return pfn( lpString, wc );
9305 }
9306
9307 typedef LPSTR WINAPI FN_lstrcat( LPSTR lpString1, LPCSTR lpString2 );
9308 __declspec(dllexport) LPSTR WINAPI kPrf2Wrap_lstrcat( LPSTR lpString1, LPCSTR lpString2 )
9309 {
9310     static FN_lstrcat *pfn = 0;
9311     if (!pfn)
9312         kPrf2WrapResolve((void **)&pfn, "lstrcat", &g_Kernel32);
9313     return pfn( lpString1, lpString2 );
9314 }
9315
9316 typedef int WINAPI FN_lstrcmp( LPCSTR lpString1, LPCSTR lpString2 );
9317 __declspec(dllexport) int WINAPI kPrf2Wrap_lstrcmp( LPCSTR lpString1, LPCSTR lpString2 )
9318 {
9319     static FN_lstrcmp *pfn = 0;
9320     if (!pfn)
9321         kPrf2WrapResolve((void **)&pfn, "lstrcmp", &g_Kernel32);
9322     return pfn( lpString1, lpString2 );
9323 }
9324
9325 typedef int WINAPI FN_lstrcmpi( LPCSTR lpString1, LPCSTR lpString2 );
9326 __declspec(dllexport) int WINAPI kPrf2Wrap_lstrcmpi( LPCSTR lpString1, LPCSTR lpString2 )
9327 {
9328     static FN_lstrcmpi *pfn = 0;
9329     if (!pfn)
9330         kPrf2WrapResolve((void **)&pfn, "lstrcmpi", &g_Kernel32);
9331     return pfn( lpString1, lpString2 );
9332 }
9333
9334 typedef LPSTR WINAPI FN_lstrcpy( LPSTR lpString1, LPCSTR lpString2 );
9335 __declspec(dllexport) LPSTR WINAPI kPrf2Wrap_lstrcpy( LPSTR lpString1, LPCSTR lpString2 )
9336 {
9337     static FN_lstrcpy *pfn = 0;
9338     if (!pfn)
9339         kPrf2WrapResolve((void **)&pfn, "lstrcpy", &g_Kernel32);
9340     return pfn( lpString1, lpString2 );
9341 }
9342
9343 typedef LPSTR WINAPI FN_lstrcpyn( LPSTR lpString1, LPCSTR lpString2, int iMaxLength );
9344 __declspec(dllexport) LPSTR WINAPI kPrf2Wrap_lstrcpyn( LPSTR lpString1, LPCSTR lpString2, int iMaxLength )
9345 {
9346     static FN_lstrcpyn *pfn = 0;
9347     if (!pfn)
9348         kPrf2WrapResolve((void **)&pfn, "lstrcpyn", &g_Kernel32);
9349     return pfn( lpString1, lpString2, iMaxLength );
9350 }
9351
9352 typedef int WINAPI FN_lstrlen( LPCSTR lpString );
9353 __declspec(dllexport) int WINAPI kPrf2Wrap_lstrlen( LPCSTR lpString )
9354 {
9355     static FN_lstrlen *pfn = 0;
9356     if (!pfn)
9357         kPrf2WrapResolve((void **)&pfn, "lstrlen", &g_Kernel32);
9358     return pfn( lpString );
9359 }
9360