Large-scale renaming of all Win32 functions and types to use the
standard Windows names.

diff --git a/loader/dos/module.c b/loader/dos/module.c
index 7de55e4..69a1aa5 100644
--- a/loader/dos/module.c
+++ b/loader/dos/module.c
@@ -49,7 +49,7 @@
 
 static void MZ_InitPSP( LPVOID lpPSP, LPCSTR cmdline, WORD env )
 {
- PDB*psp=lpPSP;
+ PDB16*psp=lpPSP;
  const char*cmd=cmdline?strchr(cmdline,' '):NULL;
 
  psp->int20=0x20CD; /* int 20 */
@@ -230,7 +230,7 @@
 #endif
   old_com=1; /* assume .COM file */
   image_start=0;
-  image_size=GetFileSize(FILE_GetHandle32(hFile),NULL);
+  image_size=GetFileSize(FILE_GetHandle(hFile),NULL);
   min_size=0x10000; max_size=0x100000;
   mz_header.e_crlc=0;
   mz_header.e_ss=0; mz_header.e_sp=0xFFFE;
@@ -411,13 +411,13 @@
  return lpDosTask->hModule;
 }
 
-HINSTANCE16 MZ_CreateProcess( LPCSTR name, LPCSTR cmdline, LPCSTR env, BOOL32 inherit,
-                              LPSTARTUPINFO32A startup, LPPROCESS_INFORMATION info )
+HINSTANCE16 MZ_CreateProcess( LPCSTR name, LPCSTR cmdline, LPCSTR env, BOOL inherit,
+                              LPSTARTUPINFOA startup, LPPROCESS_INFORMATION info )
 {
  LPDOSTASK lpDosTask = NULL; /* keep gcc from complaining */
  HMODULE16 hModule;
  HINSTANCE16 hInstance;
- PDB32 *pdb = PROCESS_Current();
+ PDB *pdb = PROCESS_Current();
  TDB *pTask = (TDB*)GlobalLock16( GetCurrentTask() );
  NE_MODULE *pModule = pTask ? NE_GetPtr( pTask->hModule ) : NULL;
  HFILE16 hFile;
@@ -494,8 +494,8 @@
 
 #else /* !MZ_SUPPORTED */
 
-HINSTANCE16 MZ_CreateProcess( LPCSTR name, LPCSTR cmdline, LPCSTR env, BOOL32 inherit,
-                              LPSTARTUPINFO32A startup, LPPROCESS_INFORMATION info )
+HINSTANCE16 MZ_CreateProcess( LPCSTR name, LPCSTR cmdline, LPCSTR env, BOOL inherit,
+                              LPSTARTUPINFOA startup, LPPROCESS_INFORMATION info )
 {
  WARN(module,"DOS executables not supported on this architecture\n");
  return (HMODULE16)11;  /* invalid exe */
diff --git a/loader/elf.c b/loader/elf.c
index 2365537..853ae06 100644
--- a/loader/elf.c
+++ b/loader/elf.c
@@ -31,7 +31,7 @@
 	PIMAGE_NT_HEADERS	nth;
 	PIMAGE_SECTION_HEADER	sh;
 	WINE_MODREF *wm;
-	HMODULE32 hmod;
+	HMODULE hmod;
 
 	wm=(WINE_MODREF*)HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*wm) );
 	wm->type = MODULE32_ELF;
@@ -43,7 +43,7 @@
 	wm->modname = HEAP_strdupA( GetProcessHeap(), 0, modname );
 	wm->longname = HEAP_strdupA( GetProcessHeap(), 0, libname );
 
-	hmod = (HMODULE32)HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, 
+	hmod = (HMODULE)HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, 
                                      sizeof(IMAGE_DOS_HEADER) + 
                                      sizeof(IMAGE_NT_HEADERS) +
                                      sizeof(IMAGE_SECTION_HEADER) + 100 );
@@ -96,7 +96,7 @@
 
 #include <dlfcn.h>
 
-HMODULE32 ELF_LoadLibraryEx32A( LPCSTR libname, HANDLE32 hf, DWORD flags )
+HMODULE ELF_LoadLibraryExA( LPCSTR libname, HANDLE hf, DWORD flags )
 {
 	WINE_MODREF	*wm;
 	char		*modname,*s,*t,*x;
@@ -144,7 +144,7 @@
 	return wm->module;
 }
 
-FARPROC32 ELF_FindExportedFunction( WINE_MODREF *wm, LPCSTR funcName) 
+FARPROC ELF_FindExportedFunction( WINE_MODREF *wm, LPCSTR funcName) 
 {
 	LPVOID			fun;
 	int			i,nrofargs = 0;
@@ -153,7 +153,7 @@
 	assert(wm->type == MODULE32_ELF);
 	if (!HIWORD(funcName)) {
 		ERR(win32,"Can't import from UNIX dynamic libs by ordinal, sorry.\n");
-		return (FARPROC32)0;
+		return (FARPROC)0;
 	}
 	fun = dlsym(wm->binfmt.elf.dlhandle,funcName);
 	/* we sometimes have an excess '_' at the beginning of the name */
@@ -234,24 +234,24 @@
 			/* filled out by entrycode */
 		stub->oldret	  = 0xdeadbeef;
 		stub->ret2	  = 0xc3;
-		fun=(FARPROC32)stub;
+		fun=(FARPROC)stub;
 	}
 	if (!fun) {
 		FIXME(win32,"function %s not found: %s\n",funcName,dlerror());
 		return fun;
 	}
-	fun = SNOOP_GetProcAddress32(wm->module,funcName,stub-wm->binfmt.elf.stubs,fun);
-	return (FARPROC32)fun;
+	fun = SNOOP_GetProcAddress(wm->module,funcName,stub-wm->binfmt.elf.stubs,fun);
+	return (FARPROC)fun;
 }
 #else
 
-HMODULE32 ELF_LoadLibraryEx32A( LPCSTR libname, HANDLE32 hf, DWORD flags)
+HMODULE ELF_LoadLibraryExA( LPCSTR libname, HANDLE hf, DWORD flags)
 {
 	return 0;
 }
-FARPROC32 ELF_FindExportedFunction( WINE_MODREF *wm, LPCSTR funcName) 
+FARPROC ELF_FindExportedFunction( WINE_MODREF *wm, LPCSTR funcName) 
 {
-	return (FARPROC32)0;
+	return (FARPROC)0;
 }
 
 #endif
diff --git a/loader/libres.c b/loader/libres.c
index c1485db..d2ed8a1 100644
--- a/loader/libres.c
+++ b/loader/libres.c
@@ -34,7 +34,7 @@
 /**********************************************************************
  *	    LIBRES_FindResource
  */
-HRSRC32 LIBRES_FindResource( HINSTANCE32 hModule, LPCWSTR name, LPCWSTR type )
+HRSRC LIBRES_FindResource( HINSTANCE hModule, LPCWSTR name, LPCWSTR type )
 {
   int nameid=0,typeid;
   ResListE* ResBlock;
@@ -77,12 +77,12 @@
     for(Res=ResBlock->Resources; *Res; Res++)
       if(name)
       {
-	if((*Res)->restype==typeid && !lstrncmpi32W((LPCWSTR)((*Res)->resname+1), name, *((*Res)->resname)))
-	  return (HRSRC32)*Res;
+	if((*Res)->restype==typeid && !lstrncmpiW((LPCWSTR)((*Res)->resname+1), name, *((*Res)->resname)))
+	  return (HRSRC)*Res;
       }
       else
 	if((*Res)->restype==typeid && (*Res)->resid==nameid)
-	  return (HRSRC32)*Res;
+	  return (HRSRC)*Res;
   return 0;
 }
 
@@ -90,16 +90,16 @@
 /**********************************************************************
  *	    LIBRES_LoadResource    
  */
-HGLOBAL32 LIBRES_LoadResource( HINSTANCE32 hModule, HRSRC32 hRsrc )
+HGLOBAL LIBRES_LoadResource( HINSTANCE hModule, HRSRC hRsrc )
 {
-  return (HGLOBAL32)(((wrc_resource32_t*)hRsrc)->data);
+  return (HGLOBAL)(((wrc_resource32_t*)hRsrc)->data);
 }
 
 
 /**********************************************************************
  *	    LIBRES_SizeofResource    
  */
-DWORD LIBRES_SizeofResource( HINSTANCE32 hModule, HRSRC32 hRsrc )
+DWORD LIBRES_SizeofResource( HINSTANCE hModule, HRSRC hRsrc )
 {
   return (DWORD)(((wrc_resource32_t*)hRsrc)->datasize);
 }
diff --git a/loader/main.c b/loader/main.c
index 106452a..761b324 100644
--- a/loader/main.c
+++ b/loader/main.c
@@ -50,7 +50,7 @@
 /***********************************************************************
  *           Main initialisation routine
  */
-BOOL32 MAIN_MainInit(void)
+BOOL MAIN_MainInit(void)
 {
     /* Set server debug level */
     /* To fool make_debug: TRACE(server) */
@@ -95,9 +95,9 @@
 /***********************************************************************
  *           KERNEL initialisation routine
  */
-BOOL32 WINAPI MAIN_KernelInit(HINSTANCE32 hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
+BOOL WINAPI MAIN_KernelInit(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
 {
-    static BOOL32 initDone = FALSE;
+    static BOOL initDone = FALSE;
 
     HMODULE16 hModule;
 
@@ -111,7 +111,7 @@
         WORD cs, ds;
 
         /* Initialize KERNEL.178 (__WINFLAGS) with the correct flags value */
-        NE_SetEntryPoint( hModule, 178, GetWinFlags() );
+        NE_SetEntryPoint( hModule, 178, GetWinFlags16() );
 
         /* Initialize KERNEL.454/455 (__FLATCS/__FLATDS) */
         GET_CS(cs); GET_DS(ds);
@@ -146,7 +146,7 @@
 /***********************************************************************
  *           GDI initialisation routine
  */
-BOOL32 WINAPI MAIN_GdiInit(HINSTANCE32 hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
+BOOL WINAPI MAIN_GdiInit(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
 {
     NE_MODULE *pModule;
 
@@ -156,13 +156,13 @@
     pModule = NE_GetPtr( GetModuleHandle16( "GDI" ) );
     if ( pModule )
     {
-        GDI_HeapSel = GlobalHandleToSel( (NE_SEG_TABLE( pModule ) + 
+        GDI_HeapSel = GlobalHandleToSel16( (NE_SEG_TABLE( pModule ) + 
                                           pModule->dgroup - 1)->hSeg );
     }
     else
     {
         GDI_HeapSel = GlobalAlloc16( GMEM_FIXED, GDI_HEAP_SIZE );
-        LocalInit( GDI_HeapSel, 0, GDI_HEAP_SIZE-1 );
+        LocalInit16( GDI_HeapSel, 0, GDI_HEAP_SIZE-1 );
     }
 
     if (!TWEAK_Init()) return FALSE;
@@ -180,7 +180,7 @@
 /***********************************************************************
  *           USER initialisation routine
  */
-BOOL32 WINAPI MAIN_UserInit(HINSTANCE32 hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
+BOOL WINAPI MAIN_UserInit(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
 {
     NE_MODULE *pModule;
     int queueSize;
@@ -191,13 +191,13 @@
     pModule = NE_GetPtr( GetModuleHandle16( "USER" ) );
     if ( pModule )
     {
-        USER_HeapSel = GlobalHandleToSel( (NE_SEG_TABLE( pModule ) + 
+        USER_HeapSel = GlobalHandleToSel16( (NE_SEG_TABLE( pModule ) + 
                                            pModule->dgroup - 1)->hSeg );
     }
     else
     {
         USER_HeapSel = GlobalAlloc16( GMEM_FIXED, 0x10000 );
-        LocalInit( USER_HeapSel, 0, 0xffff );
+        LocalInit16( USER_HeapSel, 0, 0xffff );
     }
 
      /* Global atom table initialisation */
@@ -232,15 +232,15 @@
     if (!TWEAK_CheckConfiguration()) return FALSE;
 
     /* Create system message queue */
-    queueSize = GetProfileInt32A( "windows", "TypeAhead", 120 );
+    queueSize = GetProfileIntA( "windows", "TypeAhead", 120 );
     if (!QUEUE_CreateSysMsgQueue( queueSize )) return FALSE;
 
     /* Set double click time */
-    SetDoubleClickTime32( GetProfileInt32A("windows","DoubleClickSpeed",452) );
+    SetDoubleClickTime( GetProfileIntA("windows","DoubleClickSpeed",452) );
 
     /* Create task message queue for the initial task */
-    queueSize = GetProfileInt32A( "windows", "DefaultQueueSize", 8 );
-    if (!SetMessageQueue32( queueSize )) return FALSE;
+    queueSize = GetProfileIntA( "windows", "DefaultQueueSize", 8 );
+    if (!SetMessageQueue( queueSize )) return FALSE;
 
     /* Create desktop window */
     if (!WIN_CreateDesktopWindow()) return FALSE;
@@ -261,7 +261,7 @@
 /***********************************************************************
  *           Winelib initialisation routine
  */
-HINSTANCE32 MAIN_WinelibInit( int *argc, char *argv[] )
+HINSTANCE MAIN_WinelibInit( int *argc, char *argv[] )
 {
     WINE_MODREF *wm;
     NE_MODULE *pModule;
diff --git a/loader/module.c b/loader/module.c
index 916ce5d..a771e6f 100644
--- a/loader/module.c
+++ b/loader/module.c
@@ -29,14 +29,14 @@
 #include "debug.h"
 #include "callback.h"
 
-extern BOOL32 THREAD_InitDone;
+extern BOOL THREAD_InitDone;
 
 
 /*************************************************************************
  *		MODULE32_LookupHMODULE
  * looks for the referenced HMODULE in the current process
  */
-WINE_MODREF *MODULE32_LookupHMODULE( HMODULE32 hmod )
+WINE_MODREF *MODULE32_LookupHMODULE( HMODULE hmod )
 {
     WINE_MODREF	*wm;
 
@@ -107,9 +107,9 @@
            wm->module, type, lpReserved );
 }
 
-void MODULE_InitializeDLLs( HMODULE32 root, DWORD type, LPVOID lpReserved )
+void MODULE_InitializeDLLs( HMODULE root, DWORD type, LPVOID lpReserved )
 {
-    BOOL32 inProgress = FALSE;
+    BOOL inProgress = FALSE;
     WINE_MODREF *wm;
 
     /* Grab the process critical section to protect the recursion flags */
@@ -176,18 +176,18 @@
  *
  * Create a dummy NE module for Win32 or Winelib.
  */
-HMODULE32 MODULE_CreateDummyModule( const OFSTRUCT *ofs, LPCSTR modName )
+HMODULE MODULE_CreateDummyModule( const OFSTRUCT *ofs, LPCSTR modName )
 {
-    HMODULE32 hModule;
+    HMODULE hModule;
     NE_MODULE *pModule;
     SEGTABLEENTRY *pSegment;
     char *pStr,*s;
     int len;
     const char* basename;
 
-    INT32 of_size = sizeof(OFSTRUCT) - sizeof(ofs->szPathName)
+    INT of_size = sizeof(OFSTRUCT) - sizeof(ofs->szPathName)
                     + strlen(ofs->szPathName) + 1;
-    INT32 size = sizeof(NE_MODULE) +
+    INT size = sizeof(NE_MODULE) +
                  /* loaded file info */
                  of_size +
                  /* segment table: DS,CS */
@@ -198,9 +198,9 @@
                  8;
 
     hModule = GlobalAlloc16( GMEM_MOVEABLE | GMEM_ZEROINIT, size );
-    if (!hModule) return (HMODULE32)11;  /* invalid exe */
+    if (!hModule) return (HMODULE)11;  /* invalid exe */
 
-    FarSetOwner( hModule, hModule );
+    FarSetOwner16( hModule, hModule );
     pModule = (NE_MODULE *)GlobalLock16( hModule );
 
     /* Set all used entries */
@@ -276,34 +276,34 @@
     if (__winelib)
     {
         /* FIXME: hack for Winelib */
-        extern LRESULT ColorDlgProc(HWND16,UINT16,WPARAM16,LPARAM);
-        extern LRESULT FileOpenDlgProc(HWND16,UINT16,WPARAM16,LPARAM);
-        extern LRESULT FileSaveDlgProc(HWND16,UINT16,WPARAM16,LPARAM);
+        extern LRESULT ColorDlgProc16(HWND16,UINT16,WPARAM16,LPARAM);
+        extern LRESULT FileOpenDlgProc16(HWND16,UINT16,WPARAM16,LPARAM);
+        extern LRESULT FileSaveDlgProc16(HWND16,UINT16,WPARAM16,LPARAM);
         extern LRESULT FindTextDlgProc16(HWND16,UINT16,WPARAM16,LPARAM);
-        extern LRESULT PrintDlgProc(HWND16,UINT16,WPARAM16,LPARAM);
-        extern LRESULT PrintSetupDlgProc(HWND16,UINT16,WPARAM16,LPARAM);
+        extern LRESULT PrintDlgProc16(HWND16,UINT16,WPARAM16,LPARAM);
+        extern LRESULT PrintSetupDlgProc16(HWND16,UINT16,WPARAM16,LPARAM);
         extern LRESULT ReplaceTextDlgProc16(HWND16,UINT16,WPARAM16,LPARAM);
 
         if (!strcmp(name,"ColorDlgProc"))
-            return (FARPROC16)ColorDlgProc;
+            return (FARPROC16)ColorDlgProc16;
         if (!strcmp(name,"FileOpenDlgProc"))
-            return (FARPROC16)FileOpenDlgProc;
+            return (FARPROC16)FileOpenDlgProc16;
         if (!strcmp(name,"FileSaveDlgProc"))
-            return (FARPROC16)FileSaveDlgProc;
+            return (FARPROC16)FileSaveDlgProc16;
         if (!strcmp(name,"FindTextDlgProc"))
             return (FARPROC16)FindTextDlgProc16;
         if (!strcmp(name,"PrintDlgProc"))
-            return (FARPROC16)PrintDlgProc;
+            return (FARPROC16)PrintDlgProc16;
         if (!strcmp(name,"PrintSetupDlgProc"))
-            return (FARPROC16)PrintSetupDlgProc;
+            return (FARPROC16)PrintSetupDlgProc16;
         if (!strcmp(name,"ReplaceTextDlgProc"))
             return (FARPROC16)ReplaceTextDlgProc16;
         if (!strcmp(name,"DefResourceHandler"))
             return (FARPROC16)NE_DefResourceHandler;
         if (!strcmp(name,"LoadDIBIconHandler"))
-            return (FARPROC16)LoadDIBIconHandler;
+            return (FARPROC16)LoadDIBIconHandler16;
         if (!strcmp(name,"LoadDIBCursorHandler"))
-            return (FARPROC16)LoadDIBCursorHandler;
+            return (FARPROC16)LoadDIBCursorHandler16;
         FIXME(module,"No mapping for %s(), add one in library/miscstubs.c\n",name);
         assert( FALSE );
         return NULL;
@@ -311,7 +311,7 @@
     else
     {
         WORD ordinal;
-        static HMODULE32 hModule = 0;
+        static HMODULE hModule = 0;
 
         if (!hModule) hModule = GetModuleHandle16( "WPROCS" );
         ordinal = NE_GetOrdinal( hModule, name );
@@ -337,7 +337,7 @@
  *	the module handle if found
  * 	0 if not
  */
-HMODULE32 MODULE_FindModule32(
+HMODULE MODULE_FindModule(
 	LPCSTR path	/* [in] pathname of module/library to be found */
 ) {
     LPSTR	filename;
@@ -408,7 +408,7 @@
  *	    NE_CreateProcess
  */
 static HINSTANCE16 NE_CreateProcess( LPCSTR name, LPCSTR cmd_line, LPCSTR env, 
-                                     BOOL32 inherit, LPSTARTUPINFO32A startup, 
+                                     BOOL inherit, LPSTARTUPINFOA startup, 
                                      LPPROCESS_INFORMATION info )
 {
     HINSTANCE16 hInstance, hPrevInstance;
@@ -442,14 +442,14 @@
  */
 HINSTANCE16 WINAPI LoadModule16( LPCSTR name, LPVOID paramBlock )
 {
-    LOADPARAMS *params;
+    LOADPARAMS16 *params;
     LPSTR cmd_line, new_cmd_line;
     LPCVOID env = NULL;
-    STARTUPINFO32A startup;
+    STARTUPINFOA startup;
     PROCESS_INFORMATION info;
     HINSTANCE16 hInstance, hPrevInstance;
     NE_MODULE *pModule;
-    PDB32 *pdb;
+    PDB *pdb;
 
     /* Load module */
 
@@ -465,7 +465,7 @@
 
     pModule->flags |= NE_FFLAGS_GUI;  /* FIXME: is this necessary? */
 
-    params = (LOADPARAMS *)paramBlock;
+    params = (LOADPARAMS16 *)paramBlock;
     cmd_line = (LPSTR)PTR_SEG_TO_LIN( params->cmdLine );
     if (!cmd_line) cmd_line = "";
     else if (*cmd_line) cmd_line++;  /* skip the length byte */
@@ -507,13 +507,13 @@
 /**********************************************************************
  *	    LoadModule32    (KERNEL32.499)
  */
-HINSTANCE32 WINAPI LoadModule32( LPCSTR name, LPVOID paramBlock ) 
+HINSTANCE WINAPI LoadModule( LPCSTR name, LPVOID paramBlock ) 
 {
-    LOADPARAMS32 *params = (LOADPARAMS32 *)paramBlock;
+    LOADPARAMS *params = (LOADPARAMS *)paramBlock;
     PROCESS_INFORMATION info;
-    STARTUPINFO32A startup;
-    HINSTANCE32 hInstance;
-    PDB32 *pdb;
+    STARTUPINFOA startup;
+    HINSTANCE hInstance;
+    PDB *pdb;
     TDB *tdb;
 
     memset( &startup, '\0', sizeof(startup) );
@@ -521,7 +521,7 @@
     startup.dwFlags = STARTF_USESHOWWINDOW;
     startup.wShowWindow = params->lpCmdShow? params->lpCmdShow[1] : 0;
 
-    if (!CreateProcess32A( name, params->lpCmdLine,
+    if (!CreateProcessA( name, params->lpCmdLine,
                            NULL, NULL, FALSE, 0, params->lpEnvAddress,
                            NULL, &startup, &info ))
         return GetLastError();  /* guaranteed to be < 32 */
@@ -541,17 +541,17 @@
 /**********************************************************************
  *       CreateProcess32A          (KERNEL32.171)
  */
-BOOL32 WINAPI CreateProcess32A( LPCSTR lpApplicationName, LPSTR lpCommandLine, 
+BOOL WINAPI CreateProcessA( LPCSTR lpApplicationName, LPSTR lpCommandLine, 
                                 LPSECURITY_ATTRIBUTES lpProcessAttributes,
                                 LPSECURITY_ATTRIBUTES lpThreadAttributes,
-                                BOOL32 bInheritHandles, DWORD dwCreationFlags,
+                                BOOL bInheritHandles, DWORD dwCreationFlags,
                                 LPVOID lpEnvironment, LPCSTR lpCurrentDirectory,
-                                LPSTARTUPINFO32A lpStartupInfo,
+                                LPSTARTUPINFOA lpStartupInfo,
                                 LPPROCESS_INFORMATION lpProcessInfo )
 {
     HINSTANCE16 hInstance;
     LPCSTR cmdline;
-    PDB32 *pdb;
+    PDB *pdb;
     char name[256];
 
     /* Get name and command line */
@@ -565,7 +565,7 @@
     cmdline = lpCommandLine? lpCommandLine : lpApplicationName;
 
     if (lpApplicationName)
-        lstrcpyn32A(name, lpApplicationName, sizeof(name) - 4);
+        lstrcpynA(name, lpApplicationName, sizeof(name) - 4);
     else {
         char	*ptr;
         int	len;
@@ -575,10 +575,10 @@
 	do {
 	    len = (ptr? ptr-lpCommandLine : strlen(lpCommandLine)) + 1;
 	    if (len > sizeof(name) - 4) len = sizeof(name) - 4;
-	    lstrcpyn32A(name, lpCommandLine, len);
+	    lstrcpynA(name, lpCommandLine, len);
 	    if (!strchr(name, '\\') && !strchr(name, '.'))
 		strcat(name, ".exe");
-	    if (GetFileAttributes32A(name)!=-1)
+	    if (GetFileAttributesA(name)!=-1)
 	    	break;
 	    /* if there is a space and no file found yet, include the word
 	     * up to the next space too. If there is no next space, just
@@ -590,7 +590,7 @@
 	        ptr = strchr(lpCommandLine, ' ');
 		len = (ptr? ptr-lpCommandLine : strlen(lpCommandLine)) + 1;
 		if (len > sizeof(name) - 4) len = sizeof(name) - 4;
-		lstrcpyn32A(name, lpCommandLine, len);
+		lstrcpynA(name, lpCommandLine, len);
 		break;
 	    }
 	} while (1);
@@ -699,21 +699,21 @@
  * NOTES
  *  lpReserved is not converted
  */
-BOOL32 WINAPI CreateProcess32W( LPCWSTR lpApplicationName, LPWSTR lpCommandLine, 
+BOOL WINAPI CreateProcessW( LPCWSTR lpApplicationName, LPWSTR lpCommandLine, 
                                 LPSECURITY_ATTRIBUTES lpProcessAttributes,
                                 LPSECURITY_ATTRIBUTES lpThreadAttributes,
-                                BOOL32 bInheritHandles, DWORD dwCreationFlags,
+                                BOOL bInheritHandles, DWORD dwCreationFlags,
                                 LPVOID lpEnvironment, LPCWSTR lpCurrentDirectory,
-                                LPSTARTUPINFO32W lpStartupInfo,
+                                LPSTARTUPINFOW lpStartupInfo,
                                 LPPROCESS_INFORMATION lpProcessInfo )
-{   BOOL32 ret;
-    STARTUPINFO32A StartupInfoA;
+{   BOOL ret;
+    STARTUPINFOA StartupInfoA;
     
     LPSTR lpApplicationNameA = HEAP_strdupWtoA (GetProcessHeap(),0,lpApplicationName);
     LPSTR lpCommandLineA = HEAP_strdupWtoA (GetProcessHeap(),0,lpCommandLine);
     LPSTR lpCurrentDirectoryA = HEAP_strdupWtoA (GetProcessHeap(),0,lpCurrentDirectory);
 
-    memcpy (&StartupInfoA, lpStartupInfo, sizeof(STARTUPINFO32A));
+    memcpy (&StartupInfoA, lpStartupInfo, sizeof(STARTUPINFOA));
     StartupInfoA.lpDesktop = HEAP_strdupWtoA (GetProcessHeap(),0,lpStartupInfo->lpDesktop);
     StartupInfoA.lpTitle = HEAP_strdupWtoA (GetProcessHeap(),0,lpStartupInfo->lpTitle);
 
@@ -722,7 +722,7 @@
     if (lpStartupInfo->lpReserved)
       FIXME(win32,"StartupInfo.lpReserved is used, please report (%s)\n", debugstr_w(lpStartupInfo->lpReserved));
       
-    ret = CreateProcess32A(  lpApplicationNameA,  lpCommandLineA, 
+    ret = CreateProcessA(  lpApplicationNameA,  lpCommandLineA, 
                              lpProcessAttributes, lpThreadAttributes,
                              bInheritHandles, dwCreationFlags,
                              lpEnvironment, lpCurrentDirectoryA,
@@ -739,19 +739,19 @@
 /***********************************************************************
  *              GetModuleHandle         (KERNEL32.237)
  */
-HMODULE32 WINAPI GetModuleHandle32A(LPCSTR module)
+HMODULE WINAPI GetModuleHandleA(LPCSTR module)
 {
     if (module == NULL)
     	return PROCESS_Current()->exe_modref->module;
     else
-	return MODULE_FindModule32( module );
+	return MODULE_FindModule( module );
 }
 
-HMODULE32 WINAPI GetModuleHandle32W(LPCWSTR module)
+HMODULE WINAPI GetModuleHandleW(LPCWSTR module)
 {
-    HMODULE32 hModule;
+    HMODULE hModule;
     LPSTR modulea = HEAP_strdupWtoA( GetProcessHeap(), 0, module );
-    hModule = GetModuleHandle32A( modulea );
+    hModule = GetModuleHandleA( modulea );
     HeapFree( GetProcessHeap(), 0, modulea );
     return hModule;
 }
@@ -760,8 +760,8 @@
 /***********************************************************************
  *              GetModuleFileName32A      (KERNEL32.235)
  */
-DWORD WINAPI GetModuleFileName32A( 
-	HMODULE32 hModule,	/* [in] module handle (32bit) */
+DWORD WINAPI GetModuleFileNameA( 
+	HMODULE hModule,	/* [in] module handle (32bit) */
 	LPSTR lpFileName,	/* [out] filenamebuffer */
         DWORD size		/* [in] size of filenamebuffer */
 ) {                   
@@ -771,9 +771,9 @@
     	return 0;
 
     if (PE_HEADER(wm->module)->OptionalHeader.MajorOperatingSystemVersion >= 4.0)
-      lstrcpyn32A( lpFileName, wm->longname, size );
+      lstrcpynA( lpFileName, wm->longname, size );
     else
-      lstrcpyn32A( lpFileName, wm->shortname, size );
+      lstrcpynA( lpFileName, wm->shortname, size );
        
     TRACE(module, "%s\n", lpFileName );
     return strlen(lpFileName);
@@ -783,11 +783,11 @@
 /***********************************************************************
  *              GetModuleFileName32W      (KERNEL32.236)
  */
-DWORD WINAPI GetModuleFileName32W( HMODULE32 hModule, LPWSTR lpFileName,
+DWORD WINAPI GetModuleFileNameW( HMODULE hModule, LPWSTR lpFileName,
                                    DWORD size )
 {
     LPSTR fnA = (char*)HeapAlloc( GetProcessHeap(), 0, size );
-    DWORD res = GetModuleFileName32A( hModule, fnA, size );
+    DWORD res = GetModuleFileNameA( hModule, fnA, size );
     lstrcpynAtoW( lpFileName, fnA, size );
     HeapFree( GetProcessHeap(), 0, fnA );
     return res;
@@ -798,20 +798,20 @@
  *           LoadLibraryEx32W   (KERNEL.513)
  * FIXME
  */
-HMODULE32 WINAPI LoadLibraryEx32W16( LPCSTR libname, HANDLE16 hf,
+HMODULE WINAPI LoadLibraryEx32W16( LPCSTR libname, HANDLE16 hf,
                                        DWORD flags )
 {
     TRACE(module,"(%s,%d,%08lx)\n",libname,hf,flags);
-    return LoadLibraryEx32A(libname, hf,flags);
+    return LoadLibraryExA(libname, hf,flags);
 }
 
 /***********************************************************************
  *           LoadLibraryEx32A   (KERNEL32)
  */
-HMODULE32 WINAPI LoadLibraryEx32A(LPCSTR libname,HFILE32 hfile,DWORD flags)
+HMODULE WINAPI LoadLibraryExA(LPCSTR libname,HFILE hfile,DWORD flags)
 {
-    HMODULE32 hmod;
-    hmod = MODULE_LoadLibraryEx32A( libname, hfile, flags );
+    HMODULE hmod;
+    hmod = MODULE_LoadLibraryExA( libname, hfile, flags );
 
     /* at least call not the dllmain...*/
     if ( DONT_RESOLVE_DLL_REFERENCES==flags || LOAD_LIBRARY_AS_DATAFILE==flags )
@@ -826,39 +826,39 @@
     return hmod;
 }
 
-HMODULE32 MODULE_LoadLibraryEx32A( LPCSTR libname, HFILE32 hfile, DWORD flags )
+HMODULE MODULE_LoadLibraryExA( LPCSTR libname, HFILE hfile, DWORD flags )
 {
-    HMODULE32 hmod;
+    HMODULE hmod;
     
-    hmod = ELF_LoadLibraryEx32A( libname, hfile, flags );
+    hmod = ELF_LoadLibraryExA( libname, hfile, flags );
     if (hmod) return hmod;
 
-    hmod = PE_LoadLibraryEx32A( libname, hfile, flags );
+    hmod = PE_LoadLibraryExA( libname, hfile, flags );
     return hmod;
 }
 
 /***********************************************************************
  *           LoadLibraryA         (KERNEL32)
  */
-HMODULE32 WINAPI LoadLibrary32A(LPCSTR libname) {
-	return LoadLibraryEx32A(libname,0,0);
+HMODULE WINAPI LoadLibraryA(LPCSTR libname) {
+	return LoadLibraryExA(libname,0,0);
 }
 
 /***********************************************************************
  *           LoadLibraryW         (KERNEL32)
  */
-HMODULE32 WINAPI LoadLibrary32W(LPCWSTR libnameW)
+HMODULE WINAPI LoadLibraryW(LPCWSTR libnameW)
 {
-    return LoadLibraryEx32W(libnameW,0,0);
+    return LoadLibraryExW(libnameW,0,0);
 }
 
 /***********************************************************************
  *           LoadLibraryExW       (KERNEL32)
  */
-HMODULE32 WINAPI LoadLibraryEx32W(LPCWSTR libnameW,HFILE32 hfile,DWORD flags)
+HMODULE WINAPI LoadLibraryExW(LPCWSTR libnameW,HFILE hfile,DWORD flags)
 {
     LPSTR libnameA = HEAP_strdupWtoA( GetProcessHeap(), 0, libnameW );
-    HMODULE32 ret = LoadLibraryEx32A( libnameA , hfile, flags );
+    HMODULE ret = LoadLibraryExA( libnameA , hfile, flags );
 
     HeapFree( GetProcessHeap(), 0, libnameA );
     return ret;
@@ -867,7 +867,7 @@
 /***********************************************************************
  *           FreeLibrary
  */
-BOOL32 WINAPI FreeLibrary32(HINSTANCE32 hLibModule)
+BOOL WINAPI FreeLibrary(HINSTANCE hLibModule)
 {
     FIXME(module,"(0x%08x): stub\n", hLibModule);
     return TRUE;  /* FIXME */
@@ -879,9 +879,9 @@
  *
  * FIXME: rough guesswork, don't know what "Private" means
  */
-HINSTANCE32 WINAPI PrivateLoadLibrary(LPCSTR libname)
+HINSTANCE WINAPI PrivateLoadLibrary(LPCSTR libname)
 {
-        return (HINSTANCE32)LoadLibrary16(libname);
+        return (HINSTANCE)LoadLibrary16(libname);
 }
 
 
@@ -891,7 +891,7 @@
  *
  * FIXME: rough guesswork, don't know what "Private" means
  */
-void WINAPI PrivateFreeLibrary(HINSTANCE32 handle)
+void WINAPI PrivateFreeLibrary(HINSTANCE handle)
 {
 	FreeLibrary16((HINSTANCE16)handle);
 }
@@ -902,19 +902,19 @@
  */
 HINSTANCE16 WINAPI WinExec16( LPCSTR lpCmdLine, UINT16 nCmdShow )
 {
-    return WinExec32( lpCmdLine, nCmdShow );
+    return WinExec( lpCmdLine, nCmdShow );
 }
 
 
 /***********************************************************************
  *           WinExec32   (KERNEL32.566)
  */
-HINSTANCE32 WINAPI WinExec32( LPCSTR lpCmdLine, UINT32 nCmdShow )
+HINSTANCE WINAPI WinExec( LPCSTR lpCmdLine, UINT nCmdShow )
 {
-    HINSTANCE32 handle = 2;
+    HINSTANCE handle = 2;
     char *p, filename[256];
     int  spacelimit = 0, exhausted = 0;
-    LOADPARAMS32 params;
+    LOADPARAMS params;
     UINT16 paramCmdShow[2];
 
     if (!lpCmdLine)
@@ -939,7 +939,7 @@
 
 	/* Build the filename and command-line */
 
-	lstrcpyn32A(filename, lpCmdLine,
+	lstrcpynA(filename, lpCmdLine,
 		    sizeof(filename) - 4 /* for extension */);
 
 	/* Keep grabbing characters until end-of-string, tab, or until the
@@ -966,7 +966,7 @@
 
 	if (!__winelib)
 	{
-            handle = LoadModule32( filename, &params );
+            handle = LoadModule( filename, &params );
 	    if (handle == 2)  /* file not found */
 	    {
 		/* Check that the original file name did not have a suffix */
@@ -976,7 +976,7 @@
 		{
 		    p = filename + strlen(filename);
 		    strcpy( p, ".exe" );
-                    handle = LoadModule32( filename, &params );
+                    handle = LoadModule( filename, &params );
                     *p = '\0';  /* Remove extension */
 		}
 	    }
@@ -1058,7 +1058,7 @@
  *           WIN32_GetProcAddress16   (KERNEL32.36)
  * Get procaddress in 16bit module from win32... (kernel32 undoc. ordinal func)
  */
-FARPROC16 WINAPI WIN32_GetProcAddress16( HMODULE32 hModule, LPCSTR name )
+FARPROC16 WINAPI WIN32_GetProcAddress16( HMODULE hModule, LPCSTR name )
 {
     WORD	ordinal;
     FARPROC16	ret;
@@ -1084,7 +1084,7 @@
     }
     if (!ordinal) return (FARPROC16)0;
     ret = NE_GetEntryPoint( hModule, ordinal );
-    TRACE(module,"returning %08x\n",(UINT32)ret);
+    TRACE(module,"returning %08x\n",(UINT)ret);
     return ret;
 }
 
@@ -1115,7 +1115,7 @@
 
     ret = NE_GetEntryPoint( hModule, ordinal );
 
-    TRACE(module, "returning %08x\n", (UINT32)ret );
+    TRACE(module, "returning %08x\n", (UINT)ret );
     return ret;
 }
 
@@ -1123,26 +1123,26 @@
 /***********************************************************************
  *           GetProcAddress32   		(KERNEL32.257)
  */
-FARPROC32 WINAPI GetProcAddress32( HMODULE32 hModule, LPCSTR function )
+FARPROC WINAPI GetProcAddress( HMODULE hModule, LPCSTR function )
 {
-    return MODULE_GetProcAddress32( hModule, function, TRUE );
+    return MODULE_GetProcAddress( hModule, function, TRUE );
 }
 
 /***********************************************************************
  *           WIN16_GetProcAddress32   		(KERNEL.453)
  */
-FARPROC32 WINAPI WIN16_GetProcAddress32( HMODULE32 hModule, LPCSTR function )
+FARPROC WINAPI GetProcAddress32_16( HMODULE hModule, LPCSTR function )
 {
-    return MODULE_GetProcAddress32( hModule, function, FALSE );
+    return MODULE_GetProcAddress( hModule, function, FALSE );
 }
 
 /***********************************************************************
  *           MODULE_GetProcAddress32   		(internal)
  */
-FARPROC32 MODULE_GetProcAddress32( 
-	HMODULE32 hModule, 	/* [in] current module handle */
+FARPROC MODULE_GetProcAddress( 
+	HMODULE hModule, 	/* [in] current module handle */
 	LPCSTR function,	/* [in] function to be looked up */
-	BOOL32 snoop )
+	BOOL snoop )
 {
     WINE_MODREF	*wm = MODULE32_LookupHMODULE( hModule );
 
@@ -1151,7 +1151,7 @@
     else
 	TRACE(win32,"(%08lx,%p)\n",(DWORD)hModule,function);
     if (!wm)
-        return (FARPROC32)0;
+        return (FARPROC)0;
     switch (wm->type)
     {
     case MODULE32_PE:
@@ -1160,7 +1160,7 @@
     	return ELF_FindExportedFunction( wm, function);
     default:
     	ERR(module,"wine_modref type %d not handled.\n",wm->type);
-    	return (FARPROC32)0;
+    	return (FARPROC)0;
     }
 }
 
@@ -1168,7 +1168,7 @@
 /***********************************************************************
  *           RtlImageNtHeaders   (NTDLL)
  */
-PIMAGE_NT_HEADERS WINAPI RtlImageNtHeader(HMODULE32 hModule)
+PIMAGE_NT_HEADERS WINAPI RtlImageNtHeader(HMODULE hModule)
 {
     /* basically:
      * return  hModule+(((IMAGE_DOS_HEADER*)hModule)->e_lfanew); 
@@ -1195,14 +1195,14 @@
 } GPHANDLERDEF;
 #pragma pack(4)
 
-SEGPTR WINAPI HasGPHandler( SEGPTR address )
+SEGPTR WINAPI HasGPHandler16( SEGPTR address )
 {
     HMODULE16 hModule;
     int gpOrdinal;
     SEGPTR gpPtr;
     GPHANDLERDEF *gpHandler;
    
-    if (    (hModule = FarGetOwner( SELECTOROF(address) )) != 0
+    if (    (hModule = FarGetOwner16( SELECTOROF(address) )) != 0
          && (gpOrdinal = NE_GetOrdinal( hModule, "__GP" )) != 0
          && (gpPtr = (SEGPTR)NE_GetEntryPointEx( hModule, gpOrdinal, FALSE )) != 0
          && !IsBadReadPtr16( gpPtr, sizeof(GPHANDLERDEF) )
diff --git a/loader/ne/convert.c b/loader/ne/convert.c
index a342072..e421236 100644
--- a/loader/ne/convert.c
+++ b/loader/ne/convert.c
@@ -42,8 +42,8 @@
     case 0xffff:  ((WORD *)p)++; *((BYTE *)dialog16)++ = 0xff; 
                   *((WORD *)dialog16)++ = *((WORD *)p)++; break;
     default:      lstrcpyWtoA( (LPSTR)dialog16, (LPWSTR)p );
-                  ((LPSTR)dialog16) += lstrlen32A( (LPSTR)dialog16 ) + 1;
-                  ((LPWSTR)p) += lstrlen32W( (LPWSTR)p ) + 1;
+                  ((LPSTR)dialog16) += lstrlenA( (LPSTR)dialog16 ) + 1;
+                  ((LPWSTR)p) += lstrlenW( (LPWSTR)p ) + 1;
                   break;
     }
 
@@ -54,15 +54,15 @@
     case 0xffff:  ((WORD *)p)++; *((BYTE *)dialog16)++ = 0xff; 
                   *((WORD *)dialog16)++ = *((WORD *)p)++; break;
     default:      lstrcpyWtoA( (LPSTR)dialog16, (LPWSTR)p );
-                  ((LPSTR)dialog16) += lstrlen32A( (LPSTR)dialog16 ) + 1;
-                  ((LPWSTR)p) += lstrlen32W( (LPWSTR)p ) + 1;
+                  ((LPSTR)dialog16) += lstrlenA( (LPSTR)dialog16 ) + 1;
+                  ((LPWSTR)p) += lstrlenW( (LPWSTR)p ) + 1;
                   break;
     }
 
     /* Transfer window caption */
     lstrcpyWtoA( (LPSTR)dialog16, (LPWSTR)p );
-    ((LPSTR)dialog16) += lstrlen32A( (LPSTR)dialog16 ) + 1;
-    ((LPWSTR)p) += lstrlen32W( (LPWSTR)p ) + 1;
+    ((LPSTR)dialog16) += lstrlenA( (LPSTR)dialog16 ) + 1;
+    ((LPWSTR)p) += lstrlenW( (LPWSTR)p ) + 1;
 
     /* Transfer font info */
     if (style & DS_SETFONT)
@@ -74,8 +74,8 @@
             *((WORD *)dialog16)++ = *((WORD *)p)++; /* italic */
         }
         lstrcpyWtoA( (LPSTR)dialog16, (LPWSTR)p );  /* faceName */
-        ((LPSTR)dialog16) += lstrlen32A( (LPSTR)dialog16 ) + 1;
-        ((LPWSTR)p) += lstrlen32W( (LPWSTR)p ) + 1;
+        ((LPSTR)dialog16) += lstrlenA( (LPSTR)dialog16 ) + 1;
+        ((LPWSTR)p) += lstrlenW( (LPWSTR)p ) + 1;
     }
 
     /* Transfer dialog items */
@@ -116,8 +116,8 @@
         case 0xffff:  ((WORD *)p)++; 
                       *((BYTE *)dialog16)++ = (BYTE)*((WORD *)p)++; break;
         default:      lstrcpyWtoA( (LPSTR)dialog16, (LPWSTR)p );
-                      ((LPSTR)dialog16) += lstrlen32A( (LPSTR)dialog16 ) + 1;
-                      ((LPWSTR)p) += lstrlen32W( (LPWSTR)p ) + 1;
+                      ((LPSTR)dialog16) += lstrlenA( (LPSTR)dialog16 ) + 1;
+                      ((LPWSTR)p) += lstrlenW( (LPWSTR)p ) + 1;
                       break;
         }
 
@@ -128,8 +128,8 @@
         case 0xffff:  ((WORD *)p)++; *((BYTE *)dialog16)++ = 0xff; 
                       *((WORD *)dialog16)++ = *((WORD *)p)++; break;
         default:      lstrcpyWtoA( (LPSTR)dialog16, (LPWSTR)p );
-                      ((LPSTR)dialog16) += lstrlen32A( (LPSTR)dialog16 ) + 1;
-                      ((LPWSTR)p) += lstrlen32W( (LPWSTR)p ) + 1;
+                      ((LPSTR)dialog16) += lstrlenA( (LPSTR)dialog16 ) + 1;
+                      ((LPWSTR)p) += lstrlenW( (LPWSTR)p ) + 1;
                       break;
         }
        
@@ -155,7 +155,7 @@
 /**********************************************************************
  *	    GetDialog32Size   (KERNEL.618)
  */
-WORD WINAPI GetDialog32Size( LPVOID dialog32 )
+WORD WINAPI GetDialog32Size16( LPVOID dialog32 )
 {
     LPVOID p = dialog32;
     WORD nbItems, data, dialogEx;
@@ -183,7 +183,7 @@
     {
     case 0x0000:  ((WORD *)p)++; break;
     case 0xffff:  ((WORD *)p) += 2; break;
-    default:      ((LPWSTR)p) += lstrlen32W( (LPWSTR)p ) + 1; break;
+    default:      ((LPWSTR)p) += lstrlenW( (LPWSTR)p ) + 1; break;
     }
 
     /* Skip class name */
@@ -191,11 +191,11 @@
     {
     case 0x0000:  ((WORD *)p)++; break;
     case 0xffff:  ((WORD *)p) += 2; break;
-    default:      ((LPWSTR)p) += lstrlen32W( (LPWSTR)p ) + 1; break;
+    default:      ((LPWSTR)p) += lstrlenW( (LPWSTR)p ) + 1; break;
     }
 
     /* Skip window caption */
-    ((LPWSTR)p) += lstrlen32W( (LPWSTR)p ) + 1; 
+    ((LPWSTR)p) += lstrlenW( (LPWSTR)p ) + 1; 
 
     /* Skip font info */
     if (style & DS_SETFONT)
@@ -206,7 +206,7 @@
             ((WORD *)p)++; /* weight */
             ((WORD *)p)++; /* italic */
         }
-        ((LPWSTR)p) += lstrlen32W( (LPWSTR)p ) + 1;  /* faceName */
+        ((LPWSTR)p) += lstrlenW( (LPWSTR)p ) + 1;  /* faceName */
     }
 
     /* Skip dialog items */
@@ -242,7 +242,7 @@
         {
         case 0x0000:  ((WORD *)p)++; break;
         case 0xffff:  ((WORD *)p) += 2; break;
-        default:      ((LPWSTR)p) += lstrlen32W( (LPWSTR)p ) + 1; break;
+        default:      ((LPWSTR)p) += lstrlenW( (LPWSTR)p ) + 1; break;
         }
 
         /* Skip window name */
@@ -250,7 +250,7 @@
         {
         case 0x0000:  ((WORD *)p)++; break;
         case 0xffff:  ((WORD *)p) += 2; break;
-        default:      ((LPWSTR)p) += lstrlen32W( (LPWSTR)p ) + 1; break;
+        default:      ((LPWSTR)p) += lstrlenW( (LPWSTR)p ) + 1; break;
         }
        
         /* Skip data */
@@ -291,8 +291,8 @@
                 level++;
        
             lstrcpyWtoA( (LPSTR)menu16, (LPWSTR)p );
-            ((LPSTR)menu16) += lstrlen32A( (LPSTR)menu16 ) + 1;
-            ((LPWSTR)p) += lstrlen32W( (LPWSTR)p ) + 1;
+            ((LPSTR)menu16) += lstrlenA( (LPSTR)menu16 ) + 1;
+            ((LPWSTR)p) += lstrlenW( (LPWSTR)p ) + 1;
 
             if ( flags & MF_END )
                 level--;
@@ -305,8 +305,8 @@
             flags = *((BYTE *)menu16)++ = (BYTE)*((WORD *)p)++;  
        
             lstrcpyWtoA( (LPSTR)menu16, (LPWSTR)p );
-            ((LPSTR)menu16) += lstrlen32A( (LPSTR)menu16 ) + 1;
-            ((LPWSTR)p) += lstrlen32W( (LPWSTR)p ) + 1;
+            ((LPSTR)menu16) += lstrlenA( (LPSTR)menu16 ) + 1;
+            ((LPWSTR)p) += lstrlenW( (LPWSTR)p ) + 1;
 
             /* align on DWORD boundary (32-bit only) */
             p = (LPVOID)((((int)p) + 3) & ~3);
@@ -326,7 +326,7 @@
 /**********************************************************************
  *	    GetMenu32Size   (KERNEL.617)
  */
-WORD WINAPI GetMenu32Size( LPVOID menu32 )
+WORD WINAPI GetMenu32Size16( LPVOID menu32 )
 {
     LPVOID p = menu32;
     WORD version, headersize, flags, level = 1;
@@ -344,7 +344,7 @@
             else
                 level++;
        
-            ((LPWSTR)p) += lstrlen32W( (LPWSTR)p ) + 1;
+            ((LPWSTR)p) += lstrlenW( (LPWSTR)p ) + 1;
 
             if ( flags & MF_END )
                 level--;
@@ -356,7 +356,7 @@
             ((DWORD *)p)++; /* ID */
             flags = *((WORD *)p)++; 
        
-            ((LPWSTR)p) += lstrlen32W( (LPWSTR)p ) + 1;
+            ((LPWSTR)p) += lstrlenW( (LPWSTR)p ) + 1;
 
             /* align on DWORD boundary (32-bit only) */
             p = (LPVOID)((((int)p) + 3) & ~3);
diff --git a/loader/ne/module.c b/loader/ne/module.c
index c68c784..f8c53c2 100644
--- a/loader/ne/module.c
+++ b/loader/ne/module.c
@@ -33,8 +33,8 @@
 
 static NE_MODULE *pCachedModule = 0;  /* Module cached by NE_OpenFile */
 
-static HMODULE16 NE_LoadBuiltin(LPCSTR name,BOOL32 force) { return 0; }
-HMODULE16 (*fnBUILTIN_LoadModule)(LPCSTR name,BOOL32 force) = NE_LoadBuiltin;
+static HMODULE16 NE_LoadBuiltin(LPCSTR name,BOOL force) { return 0; }
+HMODULE16 (*fnBUILTIN_LoadModule)(LPCSTR name,BOOL force) = NE_LoadBuiltin;
 
 
 /***********************************************************************
@@ -131,7 +131,7 @@
         for (i = 0; i < pModule->modref_count; i++, pword++)
         {
             char name[10];
-            GetModuleName( *pword, name, sizeof(name) );
+            GetModuleName16( *pword, name, sizeof(name) );
 	    DUMP( "%d: %04x -> '%s'\n", i, *pword, name );
         }
     }
@@ -249,7 +249,7 @@
       /* Now copy and uppercase the string */
 
     strcpy( buffer, name );
-    CharUpper32A( buffer );
+    CharUpperA( buffer );
     len = strlen( buffer );
 
       /* First search the resident names */
@@ -340,7 +340,7 @@
     }
 
     if (sel == 0xfe) sel = 0xffff;  /* constant entry */
-    else sel = GlobalHandleToSel(NE_SEG_TABLE(pModule)[sel-1].hSeg);
+    else sel = GlobalHandleToSel16(NE_SEG_TABLE(pModule)[sel-1].hSeg);
     if (sel==0xffff)
 	return (FARPROC16)PTR_SEG_OFF_TO_SEGPTR( sel, offset );
     if (!snoop || !fnSNOOP16_GetProcAddress16)
@@ -399,11 +399,11 @@
 /***********************************************************************
  *           NE_OpenFile
  */
-HANDLE32 NE_OpenFile( NE_MODULE *pModule )
+HANDLE NE_OpenFile( NE_MODULE *pModule )
 {
     char *name;
 
-    static HANDLE32 cachedfd = -1;
+    static HANDLE cachedfd = -1;
 
     TRACE( module, "(%p) cache: mod=%p fd=%d\n",
            pModule, pCachedModule, cachedfd );
@@ -411,7 +411,7 @@
     CloseHandle( cachedfd );
     pCachedModule = pModule;
     name = NE_MODULE_NAME( pModule );
-    if ((cachedfd = CreateFile32A( name, GENERIC_READ, FILE_SHARE_READ,
+    if ((cachedfd = CreateFileA( name, GENERIC_READ, FILE_SHARE_READ,
                                    NULL, OPEN_EXISTING, 0, -1 )) == -1)
         MSG( "Can't open file '%s' for module %04x\n", name, pModule->self );
     else
@@ -482,7 +482,7 @@
 
     hModule = GlobalAlloc16( GMEM_FIXED | GMEM_ZEROINIT, size );
     if (!hModule) return (HMODULE16)11;  /* invalid exe */
-    FarSetOwner( hModule, hModule );
+    FarSetOwner16( hModule, hModule );
     pModule = (NE_MODULE *)GlobalLock16( hModule );
     memcpy( pModule, &ne_header, sizeof(ne_header) );
     pModule->count = 0;
@@ -686,7 +686,7 @@
  *
  * Load all DLLs implicitly linked to a module.
  */
-static BOOL32 NE_LoadDLLs( NE_MODULE *pModule )
+static BOOL NE_LoadDLLs( NE_MODULE *pModule )
 {
     int i;
     WORD *pModRef = (WORD *)((char *)pModule + pModule->modref_table);
@@ -748,7 +748,7 @@
  * Implementation of LoadModule16().
  */
 HINSTANCE16 NE_LoadModule( LPCSTR name, HINSTANCE16 *hPrevInstance,
-                           BOOL32 implicit, BOOL32 lib_only )
+                           BOOL implicit, BOOL lib_only )
 {
     HMODULE16 hModule;
     HINSTANCE16 hInstance;
@@ -801,7 +801,7 @@
     if (!NE_CreateSegments( pModule ) ||
         !(hInstance = NE_CreateInstance( pModule, NULL, lib_only )))
     {
-        GlobalFreeAll( hModule );
+        GlobalFreeAll16( hModule );
         return 8;  /* Insufficient memory */
     }
 
@@ -891,7 +891,7 @@
  *
  * Implementation of FreeModule16().
  */
-static BOOL16 NE_FreeModule( HMODULE16 hModule, BOOL32 call_wep )
+static BOOL16 NE_FreeModule( HMODULE16 hModule, BOOL call_wep )
 {
     HMODULE16 *hPrevModule;
     NE_MODULE *pModule;
@@ -950,7 +950,7 @@
 
     /* Free the module storage */
 
-    GlobalFreeAll( hModule );
+    GlobalFreeAll16( hModule );
 
     /* Remove module from cache */
 
@@ -981,7 +981,7 @@
 /**********************************************************************
  *	    GetModuleName    (KERNEL.27)
  */
-BOOL16 WINAPI GetModuleName( HINSTANCE16 hinst, LPSTR buf, INT16 count )
+BOOL16 WINAPI GetModuleName16( HINSTANCE16 hinst, LPSTR buf, INT16 count )
 {
     NE_MODULE *pModule;
     BYTE *p;
@@ -1001,7 +1001,7 @@
 /**********************************************************************
  *	    GetModuleUsage    (KERNEL.48)
  */
-INT16 WINAPI GetModuleUsage( HINSTANCE16 hModule )
+INT16 WINAPI GetModuleUsage16( HINSTANCE16 hModule )
 {
     NE_MODULE *pModule = NE_GetPtr( hModule );
     return pModule ? pModule->count : 0;
@@ -1011,7 +1011,7 @@
 /**********************************************************************
  *	    GetExpWinVer    (KERNEL.167)
  */
-WORD WINAPI GetExpWinVer( HMODULE16 hModule )
+WORD WINAPI GetExpWinVer16( HMODULE16 hModule )
 {
     NE_MODULE *pModule = NE_GetPtr( hModule );
     return pModule ? pModule->expected_version : 0;
@@ -1028,7 +1028,7 @@
 
     if (!hModule) hModule = GetCurrentTask();
     if (!(pModule = NE_GetPtr( hModule ))) return 0;
-    lstrcpyn32A( lpFileName, NE_MODULE_NAME(pModule), nSize );
+    lstrcpynA( lpFileName, NE_MODULE_NAME(pModule), nSize );
     TRACE(module, "%s\n", lpFileName );
     return strlen(lpFileName);
 }
@@ -1073,10 +1073,10 @@
         if (!(modulename = strrchr( modulepath, '\\' )))
             modulename = modulepath;
         else modulename++;
-        if (!lstrcmpi32A( modulename, filename )) return hModule;
+        if (!lstrcmpiA( modulename, filename )) return hModule;
 
         name_table = (BYTE *)pModule + pModule->name_table;
-        if ((*name_table == len) && !lstrncmpi32A(filename, name_table+1, len))
+        if ((*name_table == len) && !lstrncmpiA(filename, name_table+1, len))
             return hModule;
         hModule = pModule->next;
     }
@@ -1087,17 +1087,17 @@
 /**********************************************************************
  *	    ModuleFirst    (TOOLHELP.59)
  */
-BOOL16 WINAPI ModuleFirst( MODULEENTRY *lpme )
+BOOL16 WINAPI ModuleFirst16( MODULEENTRY *lpme )
 {
     lpme->wNext = hFirstModule;
-    return ModuleNext( lpme );
+    return ModuleNext16( lpme );
 }
 
 
 /**********************************************************************
  *	    ModuleNext    (TOOLHELP.60)
  */
-BOOL16 WINAPI ModuleNext( MODULEENTRY *lpme )
+BOOL16 WINAPI ModuleNext16( MODULEENTRY *lpme )
 {
     NE_MODULE *pModule;
     char *name;
@@ -1109,7 +1109,7 @@
     lpme->szModule[min(*name, MAX_MODULE_NAME)] = '\0';
     lpme->hModule = lpme->wNext;
     lpme->wcUsage = pModule->count;
-    lstrcpyn32A( lpme->szExePath, NE_MODULE_NAME(pModule), sizeof(lpme->szExePath) );
+    lstrcpynA( lpme->szExePath, NE_MODULE_NAME(pModule), sizeof(lpme->szExePath) );
     lpme->wNext = pModule->next;
     return TRUE;
 }
@@ -1118,27 +1118,27 @@
 /**********************************************************************
  *	    ModuleFindName    (TOOLHELP.61)
  */
-BOOL16 WINAPI ModuleFindName( MODULEENTRY *lpme, LPCSTR name )
+BOOL16 WINAPI ModuleFindName16( MODULEENTRY *lpme, LPCSTR name )
 {
     lpme->wNext = GetModuleHandle16( name );
-    return ModuleNext( lpme );
+    return ModuleNext16( lpme );
 }
 
 
 /**********************************************************************
  *	    ModuleFindHandle    (TOOLHELP.62)
  */
-BOOL16 WINAPI ModuleFindHandle( MODULEENTRY *lpme, HMODULE16 hModule )
+BOOL16 WINAPI ModuleFindHandle16( MODULEENTRY *lpme, HMODULE16 hModule )
 {
     hModule = GetExePtr( hModule );
     lpme->wNext = hModule;
-    return ModuleNext( lpme );
+    return ModuleNext16( lpme );
 }
 
 /***************************************************************************
  *		MapHModuleLS			(KERNEL32.520)
  */
-HMODULE16 WINAPI MapHModuleLS(HMODULE32 hmod) {
+HMODULE16 WINAPI MapHModuleLS(HMODULE hmod) {
 	NE_MODULE	*pModule;
 
 	if (!hmod)
@@ -1157,7 +1157,7 @@
 /***************************************************************************
  *		MapHModuleSL			(KERNEL32.521)
  */
-HMODULE32 WINAPI MapHModuleSL(HMODULE16 hmod) {
+HMODULE WINAPI MapHModuleSL(HMODULE16 hmod) {
 	NE_MODULE	*pModule;
 
 	if (!hmod) {
diff --git a/loader/ne/resource.c b/loader/ne/resource.c
index 06e740d..359f6c9 100644
--- a/loader/ne/resource.c
+++ b/loader/ne/resource.c
@@ -63,7 +63,7 @@
                 if (p[1] & 0x8000)
                 {
                     if (!HIWORD(typeId)) continue;
-                    if (lstrcmpi32A( typeId,
+                    if (lstrcmpiA( typeId,
                                      (char *)(p + 3) )) continue;
                 }
                 else if (HIWORD(typeId) || (((DWORD)typeId & ~0x8000)!= p[1]))
@@ -74,7 +74,7 @@
                 if (p[2] & 0x8000)
                 {
                     if (!HIWORD(resId)) continue;
-                    if (lstrcmpi32A( resId,
+                    if (lstrcmpiA( resId,
                                (char*)(p+3)+strlen((char*)(p+3))+1 )) continue;
                     
                 }
@@ -113,7 +113,7 @@
 	    if (!(pTypeInfo->type_id & 0x8000))
 	    {
 		BYTE *p = pResTab + pTypeInfo->type_id;
-		if ((*p == len) && !lstrncmpi32A( p+1, str, len ))
+		if ((*p == len) && !lstrncmpiA( p+1, str, len ))
 		{
 		    TRACE(resource, "  Found type '%s'\n", str );
 		    return pTypeInfo;
@@ -160,7 +160,7 @@
         {
             if (pNameInfo->id & 0x8000) continue;
             p = pResTab + pNameInfo->id;
-            if ((*p == len) && !lstrncmpi32A( p+1, str, len ))
+            if ((*p == len) && !lstrncmpiA( p+1, str, len ))
                 return pNameInfo;
         }
     }
@@ -183,7 +183,7 @@
 HGLOBAL16 WINAPI NE_DefResourceHandler( HGLOBAL16 hMemObj, HMODULE16 hModule,
                                         HRSRC16 hRsrc )
 {
-    HANDLE32 fd;
+    HANDLE fd;
     NE_MODULE* pModule = NE_GetPtr( hModule );
     if (pModule && (fd = NE_OpenFile( pModule )) >= 0)
     {
@@ -197,7 +197,7 @@
 	if( hMemObj )
 	    handle = GlobalReAlloc16( hMemObj, pNameInfo->length << sizeShift, 0 );
 	else
-	    handle = AllocResource( hModule, hRsrc, 0 );
+	    handle = AllocResource16( hModule, hRsrc, 0 );
 
 	if( handle )
 	{
@@ -216,7 +216,7 @@
  *
  * Fill in 'resloader' fields in the resource table.
  */
-BOOL32 NE_InitResourceHandler( HMODULE16 hModule )
+BOOL NE_InitResourceHandler( HMODULE16 hModule )
 {
     NE_MODULE *pModule = NE_GetPtr( hModule );
     NE_TYPEINFO *pTypeInfo = (NE_TYPEINFO *)((char *)pModule + pModule->res_table + 2);
@@ -237,7 +237,7 @@
 /**********************************************************************
  *	SetResourceHandler	(KERNEL.43)
  */
-FARPROC16 WINAPI SetResourceHandler( HMODULE16 hModule, SEGPTR typeId,
+FARPROC16 WINAPI SetResourceHandler16( HMODULE16 hModule, SEGPTR typeId,
                                      FARPROC16 resourceHandler )
 {
     FARPROC16 prevHandler = NULL;
@@ -333,7 +333,7 @@
 /**********************************************************************
  *	    AllocResource    (KERNEL.66)
  */
-HGLOBAL16 WINAPI AllocResource( HMODULE16 hModule, HRSRC16 hRsrc, DWORD size)
+HGLOBAL16 WINAPI AllocResource16( HMODULE16 hModule, HRSRC16 hRsrc, DWORD size)
 {
     NE_NAMEINFO *pNameInfo=NULL;
     WORD sizeShift;
@@ -356,7 +356,7 @@
  *
  * Check Schulman, p. 232 for details
  */
-HGLOBAL16 WINAPI DirectResAlloc( HINSTANCE16 hInstance, WORD wType,
+HGLOBAL16 WINAPI DirectResAlloc16( HINSTANCE16 hInstance, WORD wType,
                                  UINT16 wSize )
 {
     TRACE(resource,"(%04x,%04x,%04x)\n",
diff --git a/loader/ne/segment.c b/loader/ne/segment.c
index 0fd0605..ef7b842 100644
--- a/loader/ne/segment.c
+++ b/loader/ne/segment.c
@@ -28,7 +28,7 @@
 #include "debug.h"
 #include "xmalloc.h"
 
-#define SEL(x) GlobalHandleToSel(x)
+#define SEL(x) GlobalHandleToSel16(x)
 
 /***********************************************************************
  *           NE_GetRelocAddrName
@@ -51,14 +51,14 @@
 /***********************************************************************
  *           NE_LoadSegment
  */
-BOOL32 NE_LoadSegment( NE_MODULE *pModule, WORD segnum )
+BOOL NE_LoadSegment( NE_MODULE *pModule, WORD segnum )
 {
     SEGTABLEENTRY *pSegTable, *pSeg;
     WORD *pModuleTable;
     WORD count, i, offset, next_offset;
     HMODULE16 module;
     FARPROC16 address = 0;
-    HFILE32 hf;
+    HFILE hf;
     DWORD res;
     struct relocation_entry_s *rep, *reloc_entries;
     BYTE *func_name;
@@ -94,7 +94,7 @@
         DWORD oldstack;
  	WORD old_hSeg, new_hSeg;
         THDB *thdb = THREAD_Current();
-        HFILE32 hFile32;
+        HFILE hFile32;
         HFILE16 hFile16;
 
  	selfloadheader = (SELFLOADHEADER *)
@@ -130,12 +130,12 @@
  	    memcpy(PTR_SEG_OFF_TO_LIN(SEL(old_hSeg),0),
  		   PTR_SEG_OFF_TO_LIN(SEL(new_hSeg),0), 
  		   pSeg->minsize ? pSeg->minsize : 0x10000);
- 	    FreeSelector(SEL(new_hSeg));
+ 	    FreeSelector16(SEL(new_hSeg));
  	    pSeg->hSeg = old_hSeg;
  	    TRACE(module, "New hSeg allocated for dgroup segment:Old=%d,New=%d\n", 
                 old_hSeg, new_hSeg);
  	  } else {
- 	    FreeSelector(SEL(pSeg->hSeg));
+ 	    FreeSelector16(SEL(pSeg->hSeg));
  	    pSeg->hSeg = new_hSeg;
  	  }
  	} 
@@ -308,7 +308,7 @@
 	if (rep->address_type > NE_RADDR_OFFSET32)
         {
             char module[10];
-            GetModuleName( pModule->self, module, sizeof(module) );
+            GetModuleName16( pModule->self, module, sizeof(module) );
             ERR( fixup, "WARNING: module %s: unknown reloc addr type = 0x%02x. Please report.\n",
                  module, rep->address_type );
         }
@@ -387,14 +387,14 @@
 /***********************************************************************
  *           NE_LoadAllSegments
  */
-BOOL32 NE_LoadAllSegments( NE_MODULE *pModule )
+BOOL NE_LoadAllSegments( NE_MODULE *pModule )
 {
     int i;
     SEGTABLEENTRY * pSegTable = (SEGTABLEENTRY *) NE_SEG_TABLE(pModule);
 
     if (pModule->flags & NE_FFLAGS_SELFLOAD)
     {
-        HFILE32 hf;
+        HFILE hf;
         HFILE16 hFile16;
         /* Handle self loading modules */
         SELFLOADHEADER *selfloadheader;
@@ -413,7 +413,7 @@
         selfloadheader->EntryAddrProc = NE_GetEntryPoint(hselfload,27);
         selfloadheader->MyAlloc  = NE_GetEntryPoint(hselfload,28);
         selfloadheader->SetOwner = NE_GetEntryPoint(GetModuleHandle16("KERNEL"),403);
-        pModule->self_loading_sel = GlobalHandleToSel(GLOBAL_Alloc(GMEM_ZEROINIT, 0xFF00, pModule->self, FALSE, FALSE, FALSE));
+        pModule->self_loading_sel = GlobalHandleToSel16(GLOBAL_Alloc(GMEM_ZEROINIT, 0xFF00, pModule->self, FALSE, FALSE, FALSE));
         oldstack = thdb->cur_stack;
         thdb->cur_stack = PTR_SEG_OFF_TO_SEGPTR(pModule->self_loading_sel,
                                                 0xff00 - sizeof(*stack16Top) );
@@ -459,7 +459,7 @@
  */
 
 /* It does nothing */
-DWORD WINAPI PatchCodeHandle(HANDLE16 hSel)
+DWORD WINAPI PatchCodeHandle16(HANDLE16 hSel)
 {
     FIXME(module,"(%04x): stub.\n",hSel);
     return (DWORD)NULL;
@@ -606,7 +606,7 @@
  *
  * Call the DLL initialization code
  */
-static BOOL32 NE_InitDLL( TDB* pTask, NE_MODULE *pModule )
+static BOOL NE_InitDLL( TDB* pTask, NE_MODULE *pModule )
 {
     SEGTABLEENTRY *pSegTable;
     WORD hInst, ds, heap;
@@ -741,7 +741,7 @@
  * If lib_only is TRUE, handle the module like a library even if it is a .EXE
  */
 HINSTANCE16 NE_CreateInstance( NE_MODULE *pModule, HINSTANCE16 *prev,
-                               BOOL32 lib_only )
+                               BOOL lib_only )
 {
     SEGTABLEENTRY *pSegment;
     int minsize;
@@ -812,20 +812,20 @@
     if (	(wFlags & NE_SEGFLAGS_EXECUTEONLY) ||
     		!(wFlags & NE_SEGFLAGS_DATA)
     ) {
-        WORD hSel = GlobalHandleToSel(hMem);
-        WORD access = SelectorAccessRights(hSel,0,0);
+        WORD hSel = GlobalHandleToSel16(hMem);
+        WORD access = SelectorAccessRights16(hSel,0,0);
 
 	access |= 2<<2; /* SEGMENT_CODE */
-	SelectorAccessRights(hSel,1,access);
+	SelectorAccessRights16(hSel,1,access);
     }
-    return MAKELONG( hMem, GlobalHandleToSel(hMem) );
+    return MAKELONG( hMem, GlobalHandleToSel16(hMem) );
 }
 
 
 /***********************************************************************
  *           NE_CreateSegments
  */
-BOOL32 NE_CreateSegments( NE_MODULE *pModule )
+BOOL NE_CreateSegments( NE_MODULE *pModule )
 {
     SEGTABLEENTRY *pSegment;
     int i, minsize;
@@ -857,7 +857,7 @@
 /**********************************************************************
  *	    IsSharedSelector    (KERNEL.345)
  */
-BOOL16 WINAPI IsSharedSelector( HANDLE16 selector )
+BOOL16 WINAPI IsSharedSelector16( HANDLE16 selector )
 {
     /* Check whether the selector belongs to a DLL */
     NE_MODULE *pModule = NE_GetPtr( selector );
diff --git a/loader/pe_image.c b/loader/pe_image.c
index accf038..619fea6 100644
--- a/loader/pe_image.c
+++ b/loader/pe_image.c
@@ -63,7 +63,7 @@
 
 #define AdjustPtr(ptr,delta) ((char *)(ptr) + (delta))
 
-void dump_exports( HMODULE32 hModule )
+void dump_exports( HMODULE hModule )
 { 
   char		*Module;
   int		i, j;
@@ -115,10 +115,10 @@
  * If it is a ordinal:
  *	- use ordinal-pe_export->Base as offset into the functionlist
  */
-FARPROC32 PE_FindExportedFunction( 
+FARPROC PE_FindExportedFunction( 
 	WINE_MODREF *wm,	/* [in] WINE modreference */
 	LPCSTR funcName,	/* [in] function name */
-        BOOL32 snoop )
+        BOOL snoop )
 {
 	u_short				* ordinal;
 	u_long				* function;
@@ -159,8 +159,8 @@
                             addr = function[*ordinal];
                             if (!addr) return NULL;
                             if ((addr < rva_start) || (addr >= rva_end))
-				return snoop? SNOOP_GetProcAddress32(wm->module,ename,*ordinal,(FARPROC32)RVA(addr))
-                                            : (FARPROC32)RVA(addr);
+				return snoop? SNOOP_GetProcAddress(wm->module,ename,*ordinal,(FARPROC)RVA(addr))
+                                            : (FARPROC)RVA(addr);
                             forward = (char *)RVA(addr);
                             break;
 			}
@@ -189,13 +189,13 @@
 		    	ename = "";
 		}
 		if ((addr < rva_start) || (addr >= rva_end))
-			return snoop? SNOOP_GetProcAddress32(wm->module,ename,(DWORD)funcName-exports->Base,(FARPROC32)RVA(addr))
-                                    : (FARPROC32)RVA(addr);
+			return snoop? SNOOP_GetProcAddress(wm->module,ename,(DWORD)funcName-exports->Base,(FARPROC)RVA(addr))
+                                    : (FARPROC)RVA(addr);
 		forward = (char *)RVA(addr);
 	}
 	if (forward)
         {
-                HMODULE32 hMod;
+                HMODULE hMod;
 		char module[256];
 		char *end = strchr(forward, '.');
 
@@ -203,9 +203,9 @@
 		assert(end-forward<256);
 		strncpy(module, forward, (end - forward));
 		module[end-forward] = 0;
-                hMod = MODULE_FindModule32( module );
+                hMod = MODULE_FindModule( module );
 		assert(hMod);
-		return MODULE_GetProcAddress32( hMod, end + 1, snoop );
+		return MODULE_GetProcAddress( hMod, end + 1, snoop );
 	}
 	return NULL;
 }
@@ -255,7 +255,7 @@
      */
  
     for (i = 0, pe_imp = pem->pe_import; pe_imp->Name ; pe_imp++) {
-    	HMODULE32		hImpModule;
+    	HMODULE		hImpModule;
 	IMAGE_IMPORT_BY_NAME	*pe_name;
 	PIMAGE_THUNK_DATA	import_list,thunk_list;
  	char			*name = (char *) RVA(pe_imp->Name);
@@ -264,7 +264,7 @@
 		break;
 
 	/* don't use MODULE_Load, Win32 creates new task differently */
-	hImpModule = MODULE_LoadLibraryEx32A( name, 0, 0 );
+	hImpModule = MODULE_LoadLibraryExA( name, 0, 0 );
 	if (!hImpModule) {
 	    char *p,buffer[2000];
 	    
@@ -273,7 +273,7 @@
 	    if (!(p = strrchr (buffer, '\\')))
 		p = buffer;
 	    strcpy (p + 1, name);
-	    hImpModule = MODULE_LoadLibraryEx32A( buffer, 0, 0 );
+	    hImpModule = MODULE_LoadLibraryExA( buffer, 0, 0 );
 	}
 	if (!hImpModule) {
 	    ERR (module, "Module %s not found\n", name);
@@ -295,24 +295,24 @@
 		    int ordinal = IMAGE_ORDINAL(import_list->u1.Ordinal);
 
 		    TRACE(win32, "--- Ordinal %s,%d\n", name, ordinal);
-		    thunk_list->u1.Function=MODULE_GetProcAddress32(
+		    thunk_list->u1.Function=MODULE_GetProcAddress(
                         hImpModule, (LPCSTR)ordinal, TRUE
 		    );
 		    if (!thunk_list->u1.Function) {
 			ERR(win32,"No implementation for %s.%d, setting to 0xdeadbeef\n",
 				name, ordinal);
-                        thunk_list->u1.Function = (FARPROC32)0xdeadbeef;
+                        thunk_list->u1.Function = (FARPROC)0xdeadbeef;
 		    }
 		} else {		/* import by name */
 		    pe_name = (PIMAGE_IMPORT_BY_NAME)RVA(import_list->u1.AddressOfData);
 		    TRACE(win32, "--- %s %s.%d\n", pe_name->Name, name, pe_name->Hint);
-		    thunk_list->u1.Function=MODULE_GetProcAddress32(
+		    thunk_list->u1.Function=MODULE_GetProcAddress(
                         hImpModule, pe_name->Name, TRUE
 		    );
 		    if (!thunk_list->u1.Function) {
 			ERR(win32,"No implementation for %s.%d(%s), setting to 0xdeadbeef\n",
 				name,pe_name->Hint,pe_name->Name);
-                        thunk_list->u1.Function = (FARPROC32)0xdeadbeef;
+                        thunk_list->u1.Function = (FARPROC)0xdeadbeef;
 		    }
 		}
 		import_list++;
@@ -327,25 +327,25 @@
 		    int ordinal = IMAGE_ORDINAL(thunk_list->u1.Ordinal);
 
 		    TRACE(win32,"--- Ordinal %s.%d\n",name,ordinal);
-		    thunk_list->u1.Function=MODULE_GetProcAddress32(
+		    thunk_list->u1.Function=MODULE_GetProcAddress(
                         hImpModule, (LPCSTR) ordinal, TRUE
 		    );
 		    if (!thunk_list->u1.Function) {
 			ERR(win32, "No implementation for %s.%d, setting to 0xdeadbeef\n",
 				name,ordinal);
-                        thunk_list->u1.Function = (FARPROC32)0xdeadbeef;
+                        thunk_list->u1.Function = (FARPROC)0xdeadbeef;
 		    }
 		} else {
 		    pe_name=(PIMAGE_IMPORT_BY_NAME) RVA(thunk_list->u1.AddressOfData);
 		    TRACE(win32,"--- %s %s.%d\n",
 		   		  pe_name->Name,name,pe_name->Hint);
-		    thunk_list->u1.Function=MODULE_GetProcAddress32(
+		    thunk_list->u1.Function=MODULE_GetProcAddress(
                         hImpModule, pe_name->Name, TRUE
 		    );
 		    if (!thunk_list->u1.Function) {
 		    	ERR(win32, "No implementation for %s.%d, setting to 0xdeadbeef\n",
 				name, pe_name->Hint);
-                        thunk_list->u1.Function = (FARPROC32)0xdeadbeef;
+                        thunk_list->u1.Function = (FARPROC)0xdeadbeef;
 		    }
 		}
 		thunk_list++;
@@ -355,7 +355,7 @@
     return 0;
 }
 
-static int calc_vma_size( HMODULE32 hModule )
+static int calc_vma_size( HMODULE hModule )
 {
     int i,vma_size = 0;
     IMAGE_SECTION_HEADER *pe_seg = PE_SECTIONS(hModule);
@@ -452,11 +452,11 @@
  * BUT we have to map the whole image anyway, for Win32 programs sometimes
  * want to access them. (HMODULE32 point to the start of it)
  */
-HMODULE32 PE_LoadImage( LPCSTR name, OFSTRUCT *ofs, LPCSTR *modName )
+HMODULE PE_LoadImage( LPCSTR name, OFSTRUCT *ofs, LPCSTR *modName )
 {
-    HMODULE32	hModule;
-    HFILE32	hFile;
-    HANDLE32	mapping;
+    HMODULE	hModule;
+    HFILE	hFile;
+    HANDLE	mapping;
 
     IMAGE_NT_HEADERS *nt;
     IMAGE_SECTION_HEADER *pe_sec;
@@ -472,8 +472,8 @@
     if (!strchr( p, '.' )) strcat( dllname, ".DLL" ); 
 
     /* Open PE file */
-    hFile = OpenFile32( dllname, ofs, OF_READ | OF_SHARE_DENY_WRITE );
-    if ( hFile == HFILE_ERROR32 )
+    hFile = OpenFile( dllname, ofs, OF_READ | OF_SHARE_DENY_WRITE );
+    if ( hFile == HFILE_ERROR )
     {
         WARN( win32, "OpenFile error %ld\n", GetLastError() );
         return 2;
@@ -484,7 +484,7 @@
     	file_size = bhfi.nFileSizeLow; /* FIXME: 64 bit */
 
     /* Map the PE file somewhere */
-    mapping = CreateFileMapping32A( hFile, NULL, PAGE_READONLY | SEC_COMMIT,
+    mapping = CreateFileMappingA( hFile, NULL, PAGE_READONLY | SEC_COMMIT,
                                     0, 0, NULL );
     CloseHandle( hFile );
     if (!mapping)
@@ -492,7 +492,7 @@
         WARN( win32, "CreateFileMapping error %ld\n", GetLastError() );
         return 0;
     }
-    hModule = (HMODULE32)MapViewOfFile( mapping, FILE_MAP_READ, 0, 0, 0 );
+    hModule = (HMODULE)MapViewOfFile( mapping, FILE_MAP_READ, 0, 0, 0 );
     CloseHandle( mapping );
     if (!hModule)
     {
@@ -638,7 +638,7 @@
 
     /* We don't need the orignal mapping any more */
     UnmapViewOfFile( (LPVOID)hModule );
-    return (HMODULE32)load_addr;
+    return (HMODULE)load_addr;
 
 error:
     UnmapViewOfFile( (LPVOID)hModule );
@@ -658,8 +658,8 @@
  * Note: This routine must always be called in the context of the
  *       process that is to own the module to be created.
  */
-WINE_MODREF *PE_CreateModule( HMODULE32 hModule, 
-                              OFSTRUCT *ofs, DWORD flags, BOOL32 builtin )
+WINE_MODREF *PE_CreateModule( HMODULE hModule, 
+                              OFSTRUCT *ofs, DWORD flags, BOOL builtin )
 {
     DWORD load_addr = (DWORD)hModule;  /* for RVA */
     IMAGE_NT_HEADERS *nt = PE_HEADER(hModule);
@@ -749,9 +749,9 @@
     }
     wm->modname = HEAP_strdupA( GetProcessHeap(), 0, modname );
 
-    result = GetLongPathName32A( ofs->szPathName, NULL, 0 );
+    result = GetLongPathNameA( ofs->szPathName, NULL, 0 );
     wm->longname = (char *)HeapAlloc( GetProcessHeap(), 0, result+1 );
-    GetLongPathName32A( ofs->szPathName, wm->longname, result+1 );
+    GetLongPathNameA( ofs->szPathName, wm->longname, result+1 );
 
     wm->shortname = HEAP_strdupA( GetProcessHeap(), 0, ofs->szPathName );
 
@@ -801,19 +801,19 @@
  * The PE Library Loader frontend. 
  * FIXME: handle the flags.
  */
-HMODULE32 PE_LoadLibraryEx32A (LPCSTR name, 
-                               HFILE32 hFile, DWORD flags)
+HMODULE PE_LoadLibraryExA (LPCSTR name, 
+                               HFILE hFile, DWORD flags)
 {
     LPCSTR	modName = NULL;
     OFSTRUCT	ofs;
-    HMODULE32	hModule32;
+    HMODULE	hModule32;
     HMODULE16	hModule16;
     NE_MODULE	*pModule;
     WINE_MODREF	*wm;
-    BOOL32	builtin;
+    BOOL	builtin;
 
     /* Check for already loaded module */
-    if ((hModule32 = MODULE_FindModule32( name ))) 
+    if ((hModule32 = MODULE_FindModule( name ))) 
         return hModule32;
 
     /* try to load builtin, enabled modules first */
@@ -858,16 +858,16 @@
  * due to the PROCESS_Create stuff.
  */
 HINSTANCE16 PE_CreateProcess( LPCSTR name, LPCSTR cmd_line,
-                              LPCSTR env, BOOL32 inherit, LPSTARTUPINFO32A startup,
+                              LPCSTR env, BOOL inherit, LPSTARTUPINFOA startup,
                               LPPROCESS_INFORMATION info )
 {
     LPCSTR modName = NULL;
     HMODULE16 hModule16;
-    HMODULE32 hModule32;
+    HMODULE hModule32;
     HINSTANCE16 hInstance;
     NE_MODULE *pModule;
     OFSTRUCT ofs;
-    PDB32 *process;
+    PDB *process;
 
     /* Load file */
     if ((hModule32 = PE_LoadImage( name, &ofs, &modName )) < 32)
@@ -897,7 +897,7 @@
 /*********************************************************************
  * PE_UnloadImage [internal]
  */
-int PE_UnloadImage( HMODULE32 hModule )
+int PE_UnloadImage( HMODULE hModule )
 {
 	FIXME(win32,"stub.\n");
 	/* free resources, image, unmap */
@@ -934,7 +934,7 @@
     if ((PE_HEADER(wm->module)->FileHeader.Characteristics & IMAGE_FILE_DLL) &&
         (PE_HEADER(wm->module)->OptionalHeader.AddressOfEntryPoint)
     ) {
-        DLLENTRYPROC32 entry = (void*)RVA_PTR( wm->module,OptionalHeader.AddressOfEntryPoint );
+        DLLENTRYPROC entry = (void*)RVA_PTR( wm->module,OptionalHeader.AddressOfEntryPoint );
         TRACE(relay, "CallTo32(entryproc=%p,module=%08x,type=%ld,res=%p)\n",
                        entry, wm->module, type, lpReserved );
 
@@ -957,7 +957,7 @@
 	DWORD			size,datasize;
 	LPVOID			mem;
 	PIMAGE_TLS_DIRECTORY	pdir;
-	PDB32			*pdb = thdb->process;
+	PDB			*pdb = thdb->process;
         int delta;
 	
 	for (wm = pdb->modref_list;wm;wm=wm->next) {
@@ -997,7 +997,7 @@
  *		DisableThreadLibraryCalls (KERNEL32.74)
  * Don't call DllEntryPoint for DLL_THREAD_{ATTACH,DETACH} if set.
  */
-BOOL32 WINAPI DisableThreadLibraryCalls(HMODULE32 hModule)
+BOOL WINAPI DisableThreadLibraryCalls(HMODULE hModule)
 {
 	WINE_MODREF	*wm;
 
diff --git a/loader/pe_resource.c b/loader/pe_resource.c
index 531b71b..1b4c58a 100644
--- a/loader/pe_resource.c
+++ b/loader/pe_resource.c
@@ -30,7 +30,7 @@
  * small helper function to get a PE_MODREF from a passed HMODULE32
  */
 static PE_MODREF*
-HMODULE32toPE_MODREF(HMODULE32 hmod) {
+HMODULE32toPE_MODREF(HMODULE hmod) {
 	WINE_MODREF	*wm;
 
 	wm = MODULE32_LookupHMODULE( hmod );
@@ -47,7 +47,7 @@
  */
 PIMAGE_RESOURCE_DIRECTORY GetResDirEntryW(PIMAGE_RESOURCE_DIRECTORY resdirptr,
 					   LPCWSTR name,DWORD root,
-					   BOOL32 allowdefault)
+					   BOOL allowdefault)
 {
     int entrynum;
     PIMAGE_RESOURCE_DIRECTORY_ENTRY entryTable;
@@ -63,7 +63,7 @@
 	entryTable = (PIMAGE_RESOURCE_DIRECTORY_ENTRY) (
 			(BYTE *) resdirptr + 
                         sizeof(IMAGE_RESOURCE_DIRECTORY));
-	namelen = lstrlen32W(name);
+	namelen = lstrlenW(name);
 	for (entrynum = 0; entrynum < resdirptr->NumberOfNamedEntries; entrynum++)
 	{
 		PIMAGE_RESOURCE_DIR_STRING_U str =
@@ -71,7 +71,7 @@
 			entryTable[entrynum].u1.s.NameOffset);
 		if(namelen != str->Length)
 			continue;
-		if(lstrncmpi32W(name,str->NameString,str->Length)==0)
+		if(lstrncmpiW(name,str->NameString,str->Length)==0)
 			return (PIMAGE_RESOURCE_DIRECTORY) (
 				root +
 				entryTable[entrynum].u2.s.OffsetToDirectory);
@@ -101,7 +101,7 @@
  */
 PIMAGE_RESOURCE_DIRECTORY GetResDirEntryA( PIMAGE_RESOURCE_DIRECTORY resdirptr,
 					   LPCSTR name, DWORD root,
-					   BOOL32 allowdefault )
+					   BOOL allowdefault )
 {
     PIMAGE_RESOURCE_DIRECTORY retv;
     LPWSTR nameW = HIWORD(name)? HEAP_strdupAtoW( GetProcessHeap(), 0, name ) 
@@ -117,12 +117,12 @@
 /**********************************************************************
  *	    PE_FindResourceEx32W
  */
-HANDLE32 PE_FindResourceEx32W(
+HANDLE PE_FindResourceExW(
 	WINE_MODREF *wm,LPCWSTR name,LPCWSTR type,WORD lang
 ) {
     PIMAGE_RESOURCE_DIRECTORY resdirptr;
     DWORD root;
-    HANDLE32 result;
+    HANDLE result;
     PE_MODREF	*pem = &(wm->binfmt.pe);
 
     if (!pem || !pem->pe_resource)
@@ -134,10 +134,10 @@
 	return 0;
     if ((resdirptr = GetResDirEntryW(resdirptr, name, root, FALSE)) == NULL)
 	return 0;
-    result = (HANDLE32)GetResDirEntryW(resdirptr, (LPCWSTR)(UINT32)lang, root, FALSE);
+    result = (HANDLE)GetResDirEntryW(resdirptr, (LPCWSTR)(UINT)lang, root, FALSE);
 	/* Try LANG_NEUTRAL, too */
     if(!result)
-        return (HANDLE32)GetResDirEntryW(resdirptr, (LPCWSTR)0, root, TRUE);
+        return (HANDLE)GetResDirEntryW(resdirptr, (LPCWSTR)0, root, TRUE);
     return result;
 }
 
@@ -145,18 +145,18 @@
 /**********************************************************************
  *	    PE_LoadResource32
  */
-HANDLE32 PE_LoadResource32( WINE_MODREF *wm, HANDLE32 hRsrc )
+HANDLE PE_LoadResource( WINE_MODREF *wm, HANDLE hRsrc )
 {
     if (!hRsrc || !wm || wm->type!=MODULE32_PE)
     	return 0;
-    return (HANDLE32) (wm->module + ((PIMAGE_RESOURCE_DATA_ENTRY)hRsrc)->OffsetToData);
+    return (HANDLE) (wm->module + ((PIMAGE_RESOURCE_DATA_ENTRY)hRsrc)->OffsetToData);
 }
 
 
 /**********************************************************************
  *	    PE_SizeofResource32
  */
-DWORD PE_SizeofResource32( HINSTANCE32 hModule, HANDLE32 hRsrc )
+DWORD PE_SizeofResource( HINSTANCE hModule, HANDLE hRsrc )
 {
     /* we don't need hModule */
     if (!hRsrc)
@@ -167,14 +167,14 @@
 /**********************************************************************
  *	    PE_EnumResourceTypes32A
  */
-BOOL32
-PE_EnumResourceTypes32A(HMODULE32 hmod,ENUMRESTYPEPROC32A lpfun,LONG lparam) {
+BOOL
+PE_EnumResourceTypesA(HMODULE hmod,ENUMRESTYPEPROCA lpfun,LONG lparam) {
     PE_MODREF	*pem = HMODULE32toPE_MODREF(hmod);
     int		i;
     PIMAGE_RESOURCE_DIRECTORY		resdir;
     PIMAGE_RESOURCE_DIRECTORY_ENTRY	et;
-    BOOL32	ret;
-    HANDLE32	heap = GetProcessHeap();	
+    BOOL	ret;
+    HANDLE	heap = GetProcessHeap();	
 
     if (!pem || !pem->pe_resource)
     	return FALSE;
@@ -201,13 +201,13 @@
 /**********************************************************************
  *	    PE_EnumResourceTypes32W
  */
-BOOL32
-PE_EnumResourceTypes32W(HMODULE32 hmod,ENUMRESTYPEPROC32W lpfun,LONG lparam) {
+BOOL
+PE_EnumResourceTypesW(HMODULE hmod,ENUMRESTYPEPROCW lpfun,LONG lparam) {
     PE_MODREF	*pem = HMODULE32toPE_MODREF(hmod);
     int		i;
     PIMAGE_RESOURCE_DIRECTORY		resdir;
     PIMAGE_RESOURCE_DIRECTORY_ENTRY	et;
-    BOOL32	ret;
+    BOOL	ret;
 
     if (!pem || !pem->pe_resource)
     	return FALSE;
@@ -232,16 +232,16 @@
 /**********************************************************************
  *	    PE_EnumResourceNames32A
  */
-BOOL32
-PE_EnumResourceNames32A(
-	HMODULE32 hmod,LPCSTR type,ENUMRESNAMEPROC32A lpfun,LONG lparam
+BOOL
+PE_EnumResourceNamesA(
+	HMODULE hmod,LPCSTR type,ENUMRESNAMEPROCA lpfun,LONG lparam
 ) {
     PE_MODREF	*pem = HMODULE32toPE_MODREF(hmod);
     int		i;
     PIMAGE_RESOURCE_DIRECTORY		resdir;
     PIMAGE_RESOURCE_DIRECTORY_ENTRY	et;
-    BOOL32	ret;
-    HANDLE32	heap = GetProcessHeap();	
+    BOOL	ret;
+    HANDLE	heap = GetProcessHeap();	
     LPWSTR	typeW;
 
     if (!pem || !pem->pe_resource)
@@ -276,15 +276,15 @@
 /**********************************************************************
  *	    PE_EnumResourceNames32W
  */
-BOOL32
-PE_EnumResourceNames32W(
-	HMODULE32 hmod,LPCWSTR type,ENUMRESNAMEPROC32W lpfun,LONG lparam
+BOOL
+PE_EnumResourceNamesW(
+	HMODULE hmod,LPCWSTR type,ENUMRESNAMEPROCW lpfun,LONG lparam
 ) {
     PE_MODREF	*pem = HMODULE32toPE_MODREF(hmod);
     int		i;
     PIMAGE_RESOURCE_DIRECTORY		resdir;
     PIMAGE_RESOURCE_DIRECTORY_ENTRY	et;
-    BOOL32	ret;
+    BOOL	ret;
 
     if (!pem || !pem->pe_resource)
     	return FALSE;
@@ -311,17 +311,17 @@
 /**********************************************************************
  *	    PE_EnumResourceNames32A
  */
-BOOL32
-PE_EnumResourceLanguages32A(
-	HMODULE32 hmod,LPCSTR name,LPCSTR type,ENUMRESLANGPROC32A lpfun,
+BOOL
+PE_EnumResourceLanguagesA(
+	HMODULE hmod,LPCSTR name,LPCSTR type,ENUMRESLANGPROCA lpfun,
 	LONG lparam
 ) {
     PE_MODREF	*pem = HMODULE32toPE_MODREF(hmod);
     int		i;
     PIMAGE_RESOURCE_DIRECTORY		resdir;
     PIMAGE_RESOURCE_DIRECTORY_ENTRY	et;
-    BOOL32	ret;
-    HANDLE32	heap = GetProcessHeap();	
+    BOOL	ret;
+    HANDLE	heap = GetProcessHeap();	
     LPWSTR	nameW,typeW;
 
     if (!pem || !pem->pe_resource)
@@ -360,16 +360,16 @@
 /**********************************************************************
  *	    PE_EnumResourceLanguages32W
  */
-BOOL32
-PE_EnumResourceLanguages32W(
-	HMODULE32 hmod,LPCWSTR name,LPCWSTR type,ENUMRESLANGPROC32W lpfun,
+BOOL
+PE_EnumResourceLanguagesW(
+	HMODULE hmod,LPCWSTR name,LPCWSTR type,ENUMRESLANGPROCW lpfun,
 	LONG lparam
 ) {
     PE_MODREF	*pem = HMODULE32toPE_MODREF(hmod);
     int		i;
     PIMAGE_RESOURCE_DIRECTORY		resdir;
     PIMAGE_RESOURCE_DIRECTORY_ENTRY	et;
-    BOOL32	ret;
+    BOOL	ret;
 
     if (!pem || !pem->pe_resource)
     	return FALSE;
diff --git a/loader/resource.c b/loader/resource.c
index 38b2dd7..55c0722 100644
--- a/loader/resource.c
+++ b/loader/resource.c
@@ -36,7 +36,7 @@
 
 typedef struct _HRSRC_ELEM
 {
-    HANDLE32 hRsrc;
+    HANDLE hRsrc;
     WORD     type;
 } HRSRC_ELEM;
 
@@ -50,7 +50,7 @@
 /**********************************************************************
  *          MapHRsrc32To16
  */
-static HRSRC16 MapHRsrc32To16( NE_MODULE *pModule, HANDLE32 hRsrc32, WORD type )
+static HRSRC16 MapHRsrc32To16( NE_MODULE *pModule, HANDLE hRsrc32, WORD type )
 {
     HRSRC_MAP *map = (HRSRC_MAP *)pModule->hRsrcMap;
     HRSRC_ELEM *newElem;
@@ -99,7 +99,7 @@
 /**********************************************************************
  *          MapHRsrc16To32
  */
-static HANDLE32 MapHRsrc16To32( NE_MODULE *pModule, HRSRC16 hRsrc16 )
+static HANDLE MapHRsrc16To32( NE_MODULE *pModule, HRSRC16 hRsrc16 )
 {
     HRSRC_MAP *map = (HRSRC_MAP *)pModule->hRsrcMap;
     if ( !map || !hRsrc16 || (int)hRsrc16 > map->nUsed ) return 0;
@@ -131,7 +131,7 @@
 
     if ( pModule->module32 )
     {
-        HANDLE32 hRsrc32 = FindResource32A( pModule->module32, nameStr, typeStr );
+        HANDLE hRsrc32 = FindResourceA( pModule->module32, nameStr, typeStr );
         return MapHRsrc32To16( pModule, hRsrc32, HIWORD(type)? 0 : type );
     }
 
@@ -141,19 +141,19 @@
 /**********************************************************************
  *	    FindResource32A    (KERNEL32.128)
  */
-HANDLE32 WINAPI FindResource32A( HMODULE32 hModule, LPCSTR name, LPCSTR type)
+HANDLE WINAPI FindResourceA( HMODULE hModule, LPCSTR name, LPCSTR type)
 {
-    return FindResourceEx32A(hModule,type,name,WINE_LanguageId);
+    return FindResourceExA(hModule,type,name,WINE_LanguageId);
 }
 
 /**********************************************************************
  *	    FindResourceEx32A    (KERNEL32.129)
  */
-HANDLE32 WINAPI FindResourceEx32A( HMODULE32 hModule, LPCSTR type, LPCSTR name,
+HANDLE WINAPI FindResourceExA( HMODULE hModule, LPCSTR type, LPCSTR name,
 				   WORD lang
 ) {
     LPWSTR xname,xtype;
-    HANDLE32 ret;
+    HANDLE ret;
 
     if (HIWORD((DWORD)name))
         xname = HEAP_strdupAtoW( GetProcessHeap(), 0, name );
@@ -163,7 +163,7 @@
         xtype = HEAP_strdupAtoW( GetProcessHeap(), 0, type);
     else
         xtype = (LPWSTR)type;
-    ret = FindResourceEx32W( hModule, xtype, xname, lang );
+    ret = FindResourceExW( hModule, xtype, xname, lang );
     if (HIWORD((DWORD)name)) HeapFree( GetProcessHeap(), 0, xname );
     if (HIWORD((DWORD)type)) HeapFree( GetProcessHeap(), 0, xtype );
     return ret;
@@ -173,23 +173,23 @@
 /**********************************************************************
  *	    FindResourceEx32W    (KERNEL32.130)
  */
-HRSRC32 WINAPI FindResourceEx32W( HMODULE32 hModule, LPCWSTR type,
+HRSRC WINAPI FindResourceExW( HMODULE hModule, LPCWSTR type,
                                   LPCWSTR name, WORD lang )
 {
     WINE_MODREF	*wm = MODULE32_LookupHMODULE( hModule );
-    HRSRC32	hrsrc;
+    HRSRC	hrsrc;
 
     TRACE(resource, "module=%08x(%s) type=%s name=%s\n",
 	  hModule, wm->modname,
 	  debugres_w (type),
 	  debugres_w (name));
 
-    if (!wm) return (HRSRC32)0;
+    if (!wm) return (HRSRC)0;
 
     switch (wm->type) 
     {
     case MODULE32_PE:
-        hrsrc = PE_FindResourceEx32W(wm,name,type,lang);
+        hrsrc = PE_FindResourceExW(wm,name,type,lang);
         break;
 
     case MODULE32_ELF:
@@ -198,7 +198,7 @@
 	
     default:
         ERR(module,"unknown module type %d\n",wm->type);
-        return (HRSRC32)0;
+        return (HRSRC)0;
     }
 
     if ( !hrsrc )
@@ -212,9 +212,9 @@
 /**********************************************************************
  *	    FindResource32W    (KERNEL32.131)
  */
-HRSRC32 WINAPI FindResource32W(HINSTANCE32 hModule, LPCWSTR name, LPCWSTR type)
+HRSRC WINAPI FindResourceW(HINSTANCE hModule, LPCWSTR name, LPCWSTR type)
 {
-    return FindResourceEx32W(hModule,type,name,WINE_LanguageId);
+    return FindResourceExW(hModule,type,name,WINE_LanguageId);
 }
 
 /**********************************************************************
@@ -227,11 +227,11 @@
 
     if ( pModule->module32 )
     {
-        HANDLE32 hRsrc32 = MapHRsrc16To32( pModule, hRsrc );
+        HANDLE hRsrc32 = MapHRsrc16To32( pModule, hRsrc );
         WORD type = MapHRsrc16ToType( pModule, hRsrc );
-        HGLOBAL32 image = LoadResource32( pModule->module32, hRsrc32 );
-        DWORD size = SizeofResource32( pModule->module32, hRsrc32 );
-        LPVOID bits = LockResource32( image );
+        HGLOBAL image = LoadResource( pModule->module32, hRsrc32 );
+        DWORD size = SizeofResource( pModule->module32, hRsrc32 );
+        LPVOID bits = LockResource( image );
 
         return NE_LoadPEResource( pModule, type, bits, size );
     }
@@ -246,9 +246,9 @@
  * RETURNS
  *	pointer into the mapped resource of the passed module
  */
-HGLOBAL32 WINAPI LoadResource32( 
-	HINSTANCE32 hModule,	/* [in] module handle */
-	HRSRC32 hRsrc )		/* [in] resource handle */
+HGLOBAL WINAPI LoadResource( 
+	HINSTANCE hModule,	/* [in] module handle */
+	HRSRC hRsrc )		/* [in] resource handle */
 {
     WINE_MODREF	*wm = MODULE32_LookupHMODULE( hModule );
 
@@ -263,7 +263,7 @@
     switch (wm->type) 
     {
     case MODULE32_PE:
-        return PE_LoadResource32(wm,hRsrc);
+        return PE_LoadResource(wm,hRsrc);
 
     case MODULE32_ELF:
         return LIBRES_LoadResource( hModule, hRsrc );
@@ -294,7 +294,7 @@
 /**********************************************************************
  *	    LockResource32    (KERNEL32.384)
  */
-LPVOID WINAPI LockResource32( HGLOBAL32 handle )
+LPVOID WINAPI LockResource( HGLOBAL handle )
 {
     return (LPVOID)handle;
 }
@@ -305,7 +305,7 @@
  */
 BOOL16 WINAPI FreeResource16( HGLOBAL16 handle )
 {
-    NE_MODULE *pModule = NE_GetPtr( FarGetOwner(handle) );
+    NE_MODULE *pModule = NE_GetPtr( FarGetOwner16(handle) );
     if ( !pModule ) return handle;
 
     if ( pModule->module32 )
@@ -317,7 +317,7 @@
 /**********************************************************************
  *	    FreeResource32    (KERNEL32.145)
  */
-BOOL32 WINAPI FreeResource32( HGLOBAL32 handle )
+BOOL WINAPI FreeResource( HGLOBAL handle )
 {
     /* no longer used in Win32 */
     return TRUE;
@@ -333,8 +333,8 @@
 
     if ( pModule->module32 )
     {
-        HANDLE32 hRsrc32 = MapHRsrc16To32( pModule, hRsrc );
-        HFILE32 hFile32 = AccessResource32( pModule->module32, hRsrc32 );
+        HANDLE hRsrc32 = MapHRsrc16To32( pModule, hRsrc );
+        HFILE hFile32 = AccessResource( pModule->module32, hRsrc32 );
         return FILE_AllocDosHandle( hFile32 );
     }
 
@@ -344,7 +344,7 @@
 /**********************************************************************
  *	    AccessResource32    (KERNEL32.64)
  */
-INT32 WINAPI AccessResource32( HMODULE32 hModule, HRSRC32 hRsrc )
+INT WINAPI AccessResource( HMODULE hModule, HRSRC hRsrc )
 {
     FIXME(resource,"(module=%08x res=%08x),not implemented\n", hModule, hRsrc);
     return 0;
@@ -361,8 +361,8 @@
 
     if ( pModule->module32 )
     {
-        HANDLE32 hRsrc32 = MapHRsrc16To32( pModule, hRsrc );
-        return SizeofResource32( hModule, hRsrc32 );
+        HANDLE hRsrc32 = MapHRsrc16To32( pModule, hRsrc );
+        return SizeofResource( hModule, hRsrc32 );
     }
 
     return NE_SizeofResource( pModule, hRsrc );
@@ -371,7 +371,7 @@
 /**********************************************************************
  *	    SizeofResource32    (KERNEL32.522)
  */
-DWORD WINAPI SizeofResource32( HINSTANCE32 hModule, HRSRC32 hRsrc )
+DWORD WINAPI SizeofResource( HINSTANCE hModule, HRSRC hRsrc )
 {
     WINE_MODREF	*wm = MODULE32_LookupHMODULE( hModule );
 
@@ -381,7 +381,7 @@
     switch (wm->type)
     {
     case MODULE32_PE:
-        return PE_SizeofResource32(hModule,hRsrc);
+        return PE_SizeofResource(hModule,hRsrc);
 
     case MODULE32_ELF:
         return LIBRES_SizeofResource( hModule, hRsrc );
@@ -426,10 +426,10 @@
  * 04:	WORD	IDval		
  * 06:	WORD	pad		(to DWORD boundary)
  */
-HACCEL32 WINAPI LoadAccelerators32W(HINSTANCE32 instance,LPCWSTR lpTableName)
+HACCEL WINAPI LoadAcceleratorsW(HINSTANCE instance,LPCWSTR lpTableName)
 {
-    HRSRC32 hRsrc;
-    HACCEL32 hMem,hRetval=0;
+    HRSRC hRsrc;
+    HACCEL hMem,hRetval=0;
     DWORD size;
 
     if (HIWORD(lpTableName))
@@ -439,12 +439,12 @@
         TRACE(accel, "%p 0x%04x\n",
                        (LPVOID)instance, LOWORD(lpTableName) );
 
-    if (!(hRsrc = FindResource32W( instance, lpTableName, RT_ACCELERATOR32W )))
+    if (!(hRsrc = FindResourceW( instance, lpTableName, RT_ACCELERATORW )))
     {
       WARN(accel, "couldn't find accelerator table resource\n");
     } else {
-      hMem = LoadResource32( instance, hRsrc );
-      size = SizeofResource32( instance, hRsrc );
+      hMem = LoadResource( instance, hRsrc );
+      size = SizeofResource( instance, hRsrc );
       if(size>=sizeof(PE_ACCEL))
       {
 	LPPE_ACCEL accel_table = (LPPE_ACCEL) hMem;
@@ -465,15 +465,15 @@
     return hRetval;
 }
 
-HACCEL32 WINAPI LoadAccelerators32A(HINSTANCE32 instance,LPCSTR lpTableName)
+HACCEL WINAPI LoadAcceleratorsA(HINSTANCE instance,LPCSTR lpTableName)
 {
 	LPWSTR	 uni;
-	HACCEL32 result;
+	HACCEL result;
 	if (HIWORD(lpTableName))
 		uni = HEAP_strdupAtoW( GetProcessHeap(), 0, lpTableName );
 	else
 		uni = (LPWSTR)lpTableName;
-	result = LoadAccelerators32W(instance,uni);
+	result = LoadAcceleratorsW(instance,uni);
 	if (HIWORD(uni)) HeapFree( GetProcessHeap(), 0, uni);
 	return result;
 }
@@ -481,9 +481,9 @@
 /**********************************************************************
  *             CopyAcceleratorTable32A   (USER32.58)
  */
-INT32 WINAPI CopyAcceleratorTable32A(HACCEL32 src, LPACCEL32 dst, INT32 entries)
+INT WINAPI CopyAcceleratorTableA(HACCEL src, LPACCEL dst, INT entries)
 {
-  return CopyAcceleratorTable32W(src, dst, entries);
+  return CopyAcceleratorTableW(src, dst, entries);
 }
 
 /**********************************************************************
@@ -491,16 +491,16 @@
  *
  * By mortene@pvv.org 980321
  */
-INT32 WINAPI CopyAcceleratorTable32W(HACCEL32 src, LPACCEL32 dst,
-				     INT32 entries)
+INT WINAPI CopyAcceleratorTableW(HACCEL src, LPACCEL dst,
+				     INT entries)
 {
   int i,xsize;
   LPACCEL16 accel = (LPACCEL16)GlobalLock16(src);
-  BOOL32 done = FALSE;
+  BOOL done = FALSE;
 
   /* Do parameter checking to avoid the explosions and the screaming
      as far as possible. */
-  if((dst && (entries < 1)) || (src == (HACCEL32)NULL) || !accel) {
+  if((dst && (entries < 1)) || (src == (HACCEL)NULL) || !accel) {
     WARN(accel, "Application sent invalid parameters (%p %p %d).\n",
 	 (LPVOID)src, (LPVOID)dst, entries);
     return 0;
@@ -545,9 +545,9 @@
  *
  * By mortene@pvv.org 980321
  */
-HACCEL32 WINAPI CreateAcceleratorTable32A(LPACCEL32 lpaccel, INT32 cEntries)
+HACCEL WINAPI CreateAcceleratorTableA(LPACCEL lpaccel, INT cEntries)
 {
-  HACCEL32	hAccel;
+  HACCEL	hAccel;
   LPACCEL16	accel;
   int		i;
 
@@ -557,7 +557,7 @@
     WARN(accel, "Application sent invalid parameters (%p %d).\n",
 	 lpaccel, cEntries);
     SetLastError(ERROR_INVALID_PARAMETER);
-    return (HACCEL32)NULL;
+    return (HACCEL)NULL;
   }
   FIXME(accel, "should check that the accelerator descriptions are valid,"
 	" return NULL and SetLastError() if not.\n");
@@ -570,7 +570,7 @@
   if(!hAccel) {
     ERR(accel, "Out of memory.\n");
     SetLastError(ERROR_NOT_ENOUGH_MEMORY);
-    return (HACCEL32)NULL;
+    return (HACCEL)NULL;
   }
   accel = GlobalLock16(hAccel);
   for (i=0;i<cEntries;i++) {
@@ -598,7 +598,7 @@
  *
  * RETURNS STD
  */
-BOOL32 WINAPI DestroyAcceleratorTable( HACCEL32 handle )
+BOOL WINAPI DestroyAcceleratorTable( HACCEL handle )
 {
     FIXME(accel, "(0x%x): stub\n", handle);
     /* FIXME: GlobalFree16(handle); */
@@ -654,27 +654,27 @@
 /**********************************************************************
  *	LoadString32W		(USER32.376)
  */
-INT32 WINAPI LoadString32W( HINSTANCE32 instance, UINT32 resource_id,
-                            LPWSTR buffer, INT32 buflen )
+INT WINAPI LoadStringW( HINSTANCE instance, UINT resource_id,
+                            LPWSTR buffer, INT buflen )
 {
-    HGLOBAL32 hmem;
-    HRSRC32 hrsrc;
+    HGLOBAL hmem;
+    HRSRC hrsrc;
     WCHAR *p;
     int string_num;
     int i;
 
     if (HIWORD(resource_id)==0xFFFF) /* netscape 3 passes this */
-	resource_id = (UINT32)(-((INT32)resource_id));
+	resource_id = (UINT)(-((INT)resource_id));
     TRACE(resource, "instance = %04x, id = %04x, buffer = %08x, "
 	   "length = %d\n", instance, (int)resource_id, (int) buffer, buflen);
 
-    hrsrc = FindResource32W( instance, (LPCWSTR)((resource_id>>4)+1),
-                             RT_STRING32W );
+    hrsrc = FindResourceW( instance, (LPCWSTR)((resource_id>>4)+1),
+                             RT_STRINGW );
     if (!hrsrc) return 0;
-    hmem = LoadResource32( instance, hrsrc );
+    hmem = LoadResource( instance, hrsrc );
     if (!hmem) return 0;
     
-    p = LockResource32(hmem);
+    p = LockResource(hmem);
     string_num = resource_id & 0x000f;
     for (i = 0; i < string_num; i++)
 	p += *p + 1;
@@ -704,20 +704,20 @@
 /**********************************************************************
  *	LoadString32A	(USER32.375)
  */
-INT32 WINAPI LoadString32A( HINSTANCE32 instance, UINT32 resource_id,
-                            LPSTR buffer, INT32 buflen )
+INT WINAPI LoadStringA( HINSTANCE instance, UINT resource_id,
+                            LPSTR buffer, INT buflen )
 {
-    INT32 retval;
+    INT retval;
     LPWSTR buffer2 = NULL;
     if (buffer && buflen)
 	buffer2 = HeapAlloc( GetProcessHeap(), 0, buflen * 2 );
-    retval = LoadString32W(instance,resource_id,buffer2,buflen);
+    retval = LoadStringW(instance,resource_id,buffer2,buflen);
 
     if (buffer2)
     {
 	if (retval) {
 	    lstrcpynWtoA( buffer, buffer2, buflen );
-	    retval = lstrlen32A( buffer );
+	    retval = lstrlenA( buffer );
 	}
 	else
 	    *buffer = 0;
@@ -751,11 +751,11 @@
 /**********************************************************************
  *	LoadMessage32A		(internal)
  */
-INT32 WINAPI LoadMessage32A( HMODULE32 instance, UINT32 id, WORD lang,
-                      LPSTR buffer, INT32 buflen )
+INT WINAPI LoadMessageA( HMODULE instance, UINT id, WORD lang,
+                      LPSTR buffer, INT buflen )
 {
-    HGLOBAL32	hmem;
-    HRSRC32	hrsrc;
+    HGLOBAL	hmem;
+    HRSRC	hrsrc;
     BYTE	*p;
     int		nrofentries,i,slen;
     struct	_subentry {
@@ -772,12 +772,12 @@
     TRACE(resource, "instance = %08lx, id = %08lx, buffer = %p, length = %ld\n", (DWORD)instance, (DWORD)id, buffer, (DWORD)buflen);
 
     /*FIXME: I am not sure about the '1' ... But I've only seen those entries*/
-    hrsrc = FindResourceEx32W(instance,RT_MESSAGELIST32W,(LPWSTR)1,lang);
+    hrsrc = FindResourceExW(instance,RT_MESSAGELISTW,(LPWSTR)1,lang);
     if (!hrsrc) return 0;
-    hmem = LoadResource32( instance, hrsrc );
+    hmem = LoadResource( instance, hrsrc );
     if (!hmem) return 0;
     
-    p = LockResource32(hmem);
+    p = LockResource(hmem);
     nrofentries = *(DWORD*)p;
     stre = NULL;
     se = (struct _subentry*)(p+4);
@@ -802,7 +802,7 @@
     if (buffer == NULL)
 	return slen; /* different to LoadString */
     if (i>0) {
-	lstrcpyn32A(buffer,stre->str,i);
+	lstrcpynA(buffer,stre->str,i);
 	buffer[i]=0;
     } else {
 	if (buflen>1) {
@@ -818,19 +818,19 @@
 /**********************************************************************
  *	LoadMessage32W	(internal)
  */
-INT32 WINAPI LoadMessage32W( HMODULE32 instance, UINT32 id, WORD lang,
-                      LPWSTR buffer, INT32 buflen )
+INT WINAPI LoadMessageW( HMODULE instance, UINT id, WORD lang,
+                      LPWSTR buffer, INT buflen )
 {
-    INT32 retval;
+    INT retval;
     LPSTR buffer2 = NULL;
     if (buffer && buflen)
 	buffer2 = HeapAlloc( GetProcessHeap(), 0, buflen );
-    retval = LoadMessage32A(instance,id,lang,buffer2,buflen);
+    retval = LoadMessageA(instance,id,lang,buffer2,buflen);
     if (buffer)
     {
 	if (retval) {
 	    lstrcpynAtoW( buffer, buffer2, buflen );
-	    retval = lstrlen32W( buffer );
+	    retval = lstrlenW( buffer );
 	}
 	HeapFree( GetProcessHeap(), 0, buffer2 );
     }
@@ -841,59 +841,59 @@
 /**********************************************************************
  *	EnumResourceTypesA	(KERNEL32.90)
  */
-BOOL32 WINAPI EnumResourceTypes32A( HMODULE32 hmodule,ENUMRESTYPEPROC32A lpfun,
+BOOL WINAPI EnumResourceTypesA( HMODULE hmodule,ENUMRESTYPEPROCA lpfun,
                                     LONG lParam)
 {
 	/* FIXME: move WINE_MODREF stuff here */
-    return PE_EnumResourceTypes32A(hmodule,lpfun,lParam);
+    return PE_EnumResourceTypesA(hmodule,lpfun,lParam);
 }
 
 /**********************************************************************
  *	EnumResourceTypesW	(KERNEL32.91)
  */
-BOOL32 WINAPI EnumResourceTypes32W( HMODULE32 hmodule,ENUMRESTYPEPROC32W lpfun,
+BOOL WINAPI EnumResourceTypesW( HMODULE hmodule,ENUMRESTYPEPROCW lpfun,
                                     LONG lParam)
 {
 	/* FIXME: move WINE_MODREF stuff here */
-    return PE_EnumResourceTypes32W(hmodule,lpfun,lParam);
+    return PE_EnumResourceTypesW(hmodule,lpfun,lParam);
 }
 
 /**********************************************************************
  *	EnumResourceNamesA	(KERNEL32.88)
  */
-BOOL32 WINAPI EnumResourceNames32A( HMODULE32 hmodule, LPCSTR type,
-                                    ENUMRESNAMEPROC32A lpfun, LONG lParam )
+BOOL WINAPI EnumResourceNamesA( HMODULE hmodule, LPCSTR type,
+                                    ENUMRESNAMEPROCA lpfun, LONG lParam )
 {
 	/* FIXME: move WINE_MODREF stuff here */
-    return PE_EnumResourceNames32A(hmodule,type,lpfun,lParam);
+    return PE_EnumResourceNamesA(hmodule,type,lpfun,lParam);
 }
 /**********************************************************************
  *	EnumResourceNamesW	(KERNEL32.89)
  */
-BOOL32 WINAPI EnumResourceNames32W( HMODULE32 hmodule, LPCWSTR type,
-                                    ENUMRESNAMEPROC32W lpfun, LONG lParam )
+BOOL WINAPI EnumResourceNamesW( HMODULE hmodule, LPCWSTR type,
+                                    ENUMRESNAMEPROCW lpfun, LONG lParam )
 {
 	/* FIXME: move WINE_MODREF stuff here */
-    return PE_EnumResourceNames32W(hmodule,type,lpfun,lParam);
+    return PE_EnumResourceNamesW(hmodule,type,lpfun,lParam);
 }
 
 /**********************************************************************
  *	EnumResourceLanguagesA	(KERNEL32.86)
  */
-BOOL32 WINAPI EnumResourceLanguages32A( HMODULE32 hmodule, LPCSTR type,
-                                        LPCSTR name, ENUMRESLANGPROC32A lpfun,
+BOOL WINAPI EnumResourceLanguagesA( HMODULE hmodule, LPCSTR type,
+                                        LPCSTR name, ENUMRESLANGPROCA lpfun,
                                         LONG lParam)
 {
 	/* FIXME: move WINE_MODREF stuff here */
-    return PE_EnumResourceLanguages32A(hmodule,type,name,lpfun,lParam);
+    return PE_EnumResourceLanguagesA(hmodule,type,name,lpfun,lParam);
 }
 /**********************************************************************
  *	EnumResourceLanguagesW	(KERNEL32.87)
  */
-BOOL32 WINAPI EnumResourceLanguages32W( HMODULE32 hmodule, LPCWSTR type,
-                                        LPCWSTR name, ENUMRESLANGPROC32W lpfun,
+BOOL WINAPI EnumResourceLanguagesW( HMODULE hmodule, LPCWSTR type,
+                                        LPCWSTR name, ENUMRESLANGPROCW lpfun,
                                         LONG lParam)
 {
 	/* FIXME: move WINE_MODREF stuff here */
-    return PE_EnumResourceLanguages32W(hmodule,type,name,lpfun,lParam);
+    return PE_EnumResourceLanguagesW(hmodule,type,name,lpfun,lParam);
 }
diff --git a/loader/signal.c b/loader/signal.c
index 8e4d863..2851fb0 100644
--- a/loader/signal.c
+++ b/loader/signal.c
@@ -41,7 +41,7 @@
 
 void (*fnWINE_Debugger)(int,SIGCONTEXT*) = NULL;
 void (*ctx_debug_call)(int sig,CONTEXT*ctx)=NULL;
-BOOL32 (*fnINSTR_EmulateInstruction)(SIGCONTEXT*ctx)=NULL;
+BOOL (*fnINSTR_EmulateInstruction)(SIGCONTEXT*ctx)=NULL;
 
 #ifdef __i386__
 
@@ -191,7 +191,7 @@
 /**********************************************************************
  *              SIGNAL_MaskAsyncEvents
  */
-void SIGNAL_MaskAsyncEvents( BOOL32 flag )
+void SIGNAL_MaskAsyncEvents( BOOL flag )
 {
   sigprocmask( (flag) ? SIG_BLOCK : SIG_UNBLOCK , &async_signal_set, NULL);
 }
@@ -291,7 +291,7 @@
 /**********************************************************************
  *		SIGNAL_Init
  */
-BOOL32 SIGNAL_Init(void)
+BOOL SIGNAL_Init(void)
 {
 #ifdef HAVE_WORKING_SIGALTSTACK
     struct sigaltstack ss;
diff --git a/loader/task.c b/loader/task.c
index 84d90c9..6f90cd7 100644
--- a/loader/task.c
+++ b/loader/task.c
@@ -59,7 +59,7 @@
 
 static void TASK_YieldToSystem(TDB*);
 
-extern BOOL32 THREAD_InitDone;
+extern BOOL THREAD_InitDone;
 
 
 /***********************************************************************
@@ -197,7 +197,7 @@
  *
  * Free a MakeProcInstance() thunk.
  */
-static BOOL32 TASK_FreeThunk( HTASK16 hTask, SEGPTR thunk )
+static BOOL TASK_FreeThunk( HTASK16 hTask, SEGPTR thunk )
 {
     TDB *pTask;
     THUNKS *pThunk;
@@ -260,7 +260,7 @@
 		AllocConsole();
 
         if (pModule->heap_size)
-            LocalInit( pTask->hInstance, 0, pModule->heap_size );
+            LocalInit16( pTask->hInstance, 0, pModule->heap_size );
 
         MODULE_InitializeDLLs( 0, DLL_PROCESS_ATTACH, (LPVOID)-1 );
         TRACE(relay, "(entryproc=%p)\n", entry );
@@ -278,7 +278,7 @@
 
         while ( thdb->exit_code == 0x103 )
         {
-            WaitEvent( 0 );
+            WaitEvent16( 0 );
             QUEUE_Signal( pTask->hSelf );
         }
 
@@ -308,8 +308,8 @@
         CONTEXT context;
 
         memset( &context, 0, sizeof(context) );
-        CS_reg(&context)  = GlobalHandleToSel(pSegTable[pModule->cs - 1].hSeg);
-        DS_reg(&context)  = GlobalHandleToSel(pSegTable[pModule->dgroup - 1].hSeg);
+        CS_reg(&context)  = GlobalHandleToSel16(pSegTable[pModule->cs - 1].hSeg);
+        DS_reg(&context)  = GlobalHandleToSel16(pSegTable[pModule->dgroup - 1].hSeg);
         ES_reg(&context)  = pTask->hPDB;
         EIP_reg(&context) = pModule->ip;
         EBX_reg(&context) = pModule->stack_size;
@@ -347,7 +347,7 @@
     char name[10];
     STACK16FRAME *frame16;
     STACK32FRAME *frame32;
-    PDB32 *pdb32 = thdb->process;
+    PDB *pdb32 = thdb->process;
     SEGTABLEENTRY *pSegTable = NE_SEG_TABLE( pModule );
 
       /* Allocate the task structure */
@@ -378,7 +378,7 @@
     pTask->thdb          = thdb;
     pTask->curdrive      = DRIVE_GetCurrentDrive() | 0x80;
     strcpy( pTask->curdir, "\\" );
-    lstrcpyn32A( pTask->curdir + 1, DRIVE_GetDosCwd( DRIVE_GetCurrentDrive() ),
+    lstrcpynA( pTask->curdir + 1, DRIVE_GetDosCwd( DRIVE_GetCurrentDrive() ),
                  sizeof(pTask->curdir) - 1 );
 
       /* Create the thunks block */
@@ -387,12 +387,12 @@
 
       /* Copy the module name */
 
-    GetModuleName( pModule->self, name, sizeof(name) );
+    GetModuleName16( pModule->self, name, sizeof(name) );
     strncpy( pTask->module_name, name, sizeof(pTask->module_name) );
 
       /* Allocate a selector for the PDB */
 
-    pTask->hPDB = GLOBAL_CreateBlock( GMEM_FIXED, &pTask->pdb, sizeof(PDB),
+    pTask->hPDB = GLOBAL_CreateBlock( GMEM_FIXED, &pTask->pdb, sizeof(PDB16),
                                     pModule->self, FALSE, FALSE, FALSE, NULL );
 
       /* Fill the PDB */
@@ -405,8 +405,8 @@
     pTask->pdb.savedint23 = INT_GetPMHandler( 0x23 );
     pTask->pdb.savedint24 = INT_GetPMHandler( 0x24 );
     pTask->pdb.fileHandlesPtr =
-        PTR_SEG_OFF_TO_SEGPTR( GlobalHandleToSel(pTask->hPDB),
-                               (int)&((PDB *)0)->fileHandles );
+        PTR_SEG_OFF_TO_SEGPTR( GlobalHandleToSel16(pTask->hPDB),
+                               (int)&((PDB16 *)0)->fileHandles );
     pTask->pdb.hFileHandles = 0;
     memset( pTask->pdb.fileHandles, 0xff, sizeof(pTask->pdb.fileHandles) );
     pTask->pdb.environment    = pdb32->env_db->env_sel;
@@ -417,12 +417,12 @@
     cmd_line = pdb32->env_db->cmd_line;
     while (*cmd_line && (*cmd_line != ' ') && (*cmd_line != '\t')) cmd_line++;
     while ((*cmd_line == ' ') || (*cmd_line == '\t')) cmd_line++;
-    lstrcpyn32A( pTask->pdb.cmdLine+1, cmd_line, sizeof(pTask->pdb.cmdLine)-1);
+    lstrcpynA( pTask->pdb.cmdLine+1, cmd_line, sizeof(pTask->pdb.cmdLine)-1);
     pTask->pdb.cmdLine[0] = strlen( pTask->pdb.cmdLine + 1 );
 
       /* Get the compatibility flags */
 
-    pTask->compat_flags = GetProfileInt32A( "Compatibility", name, 0 );
+    pTask->compat_flags = GetProfileIntA( "Compatibility", name, 0 );
 
       /* Allocate a code segment alias for the TDB */
 
@@ -432,7 +432,7 @@
 
       /* Set the owner of the environment block */
 
-    FarSetOwner( pTask->pdb.environment, pTask->hPDB );
+    FarSetOwner16( pTask->pdb.environment, pTask->hPDB );
 
       /* Default DTA overwrites command-line */
 
@@ -509,7 +509,7 @@
        the main process somehow (NOT YET IMPLEMENTED!) */
 
     if ( THREAD_IsWin16( THREAD_Current() ) )
-        OldYield();
+        OldYield16();
     else
         /* wake-up the scheduler waiting in EVENT_WaitNetEvent */
         EVENT_WakeUp();
@@ -550,7 +550,7 @@
     /* Free all memory used by this task (including the 32-bit stack, */
     /* the environment block and the thunk segments). */
 
-    GlobalFreeAll( hPDB );
+    GlobalFreeAll16( hPDB );
 }
 
 
@@ -657,12 +657,12 @@
  *   
  *       It must not call functions that may yield control.
  */
-BOOL32 TASK_Reschedule(void)
+BOOL TASK_Reschedule(void)
 {
     TDB *pOldTask = NULL, *pNewTask;
     HTASK16 hTask = 0;
     STACK16FRAME *newframe16;
-    BOOL32 pending = FALSE;
+    BOOL pending = FALSE;
 
     /* Get the initial task up and running */
     if (!hCurrentTask && GetCurrentTask())
@@ -851,7 +851,7 @@
  *
  * Called by the application startup code.
  */
-void WINAPI InitTask( CONTEXT *context )
+void WINAPI InitTask16( CONTEXT *context )
 {
     TDB *pTask;
     NE_MODULE *pModule;
@@ -901,7 +901,7 @@
     /* Initialize the local heap */
     if ( pModule->heap_size )
     {
-        LocalInit( pTask->hInstance, 0, pModule->heap_size );
+        LocalInit16( pTask->hInstance, 0, pModule->heap_size );
     }    
 
     /* Initialize the INSTANCEDATA structure */
@@ -919,7 +919,7 @@
 /***********************************************************************
  *           WaitEvent  (KERNEL.30)
  */
-BOOL16 WINAPI WaitEvent( HTASK16 hTask )
+BOOL16 WINAPI WaitEvent16( HTASK16 hTask )
 {
     TDB *pTask;
 
@@ -949,7 +949,7 @@
 /***********************************************************************
  *           PostEvent  (KERNEL.31)
  */
-void WINAPI PostEvent( HTASK16 hTask )
+void WINAPI PostEvent16( HTASK16 hTask )
 {
     TDB *pTask;
 
@@ -969,7 +969,7 @@
 /***********************************************************************
  *           SetPriority  (KERNEL.32)
  */
-void WINAPI SetPriority( HTASK16 hTask, INT16 delta )
+void WINAPI SetPriority16( HTASK16 hTask, INT16 delta )
 {
     TDB *pTask;
     INT16 newpriority;
@@ -990,7 +990,7 @@
 /***********************************************************************
  *           LockCurrentTask  (KERNEL.33)
  */
-HTASK16 WINAPI LockCurrentTask( BOOL16 bLock )
+HTASK16 WINAPI LockCurrentTask16( BOOL16 bLock )
 {
     if (bLock) hLockedTask = GetCurrentTask();
     else hLockedTask = 0;
@@ -1001,7 +1001,7 @@
 /***********************************************************************
  *           IsTaskLocked  (KERNEL.122)
  */
-HTASK16 WINAPI IsTaskLocked(void)
+HTASK16 WINAPI IsTaskLocked16(void)
 {
     return hLockedTask;
 }
@@ -1010,7 +1010,7 @@
 /***********************************************************************
  *           OldYield  (KERNEL.117)
  */
-void WINAPI OldYield(void)
+void WINAPI OldYield16(void)
 {
     TDB *pCurTask = (TDB *)GlobalLock16( GetCurrentTask() );
 
@@ -1029,7 +1029,7 @@
 /***********************************************************************
  *           DirectedYield  (KERNEL.150)
  */
-void WINAPI DirectedYield( HTASK16 hTask )
+void WINAPI DirectedYield16( HTASK16 hTask )
 {
     TDB *pCurTask = (TDB *)GlobalLock16( GetCurrentTask() );
 
@@ -1042,7 +1042,7 @@
     TRACE(task, "%04x: DirectedYield(%04x)\n", pCurTask->hSelf, hTask );
 
     pCurTask->hYieldTo = hTask;
-    OldYield();
+    OldYield16();
 
     TRACE(task, "%04x: back from DirectedYield(%04x)\n", pCurTask->hSelf, hTask );
 }
@@ -1061,8 +1061,8 @@
     }
 
     if (pCurTask) pCurTask->hYieldTo = 0;
-    if (pCurTask && pCurTask->hQueue) Callout.UserYield();
-    else OldYield();
+    if (pCurTask && pCurTask->hQueue) Callout.UserYield16();
+    else OldYield16();
 }
 
 /***********************************************************************
@@ -1126,7 +1126,7 @@
 /**********************************************************************
  *	    GetCodeHandle    (KERNEL.93)
  */
-HANDLE16 WINAPI GetCodeHandle( FARPROC16 proc )
+HANDLE16 WINAPI GetCodeHandle16( FARPROC16 proc )
 {
     HANDLE16 handle;
     BYTE *thunk = (BYTE *)PTR_SEG_TO_LIN( proc );
@@ -1146,7 +1146,7 @@
 /**********************************************************************
  *	    GetCodeInfo    (KERNEL.104)
  */
-VOID WINAPI GetCodeInfo( FARPROC16 proc, SEGINFO *segInfo )
+VOID WINAPI GetCodeInfo16( FARPROC16 proc, SEGINFO *segInfo )
 {
     BYTE *thunk = (BYTE *)PTR_SEG_TO_LIN( proc );
     NE_MODULE *pModule = NULL;
@@ -1165,7 +1165,7 @@
 
         if ( pModule )
             for ( segNr = 0; segNr < pModule->seg_count; segNr++, pSeg++ )
-                if ( GlobalHandleToSel(pSeg->hSeg) == selector )
+                if ( GlobalHandleToSel16(pSeg->hSeg) == selector )
                     break;
 
         if ( pModule && segNr >= pModule->seg_count )
@@ -1203,7 +1203,7 @@
 /***********************************************************************
  *           SetTaskQueue  (KERNEL.34)
  */
-HQUEUE16 WINAPI SetTaskQueue( HTASK16 hTask, HQUEUE16 hQueue )
+HQUEUE16 WINAPI SetTaskQueue16( HTASK16 hTask, HQUEUE16 hQueue )
 {
     HQUEUE16 hPrev;
     TDB *pTask;
@@ -1223,7 +1223,7 @@
 /***********************************************************************
  *           GetTaskQueue  (KERNEL.35)
  */
-HQUEUE16 WINAPI GetTaskQueue( HTASK16 hTask )
+HQUEUE16 WINAPI GetTaskQueue16( HTASK16 hTask )
 {
     TDB *pTask;
 
@@ -1235,7 +1235,7 @@
 /***********************************************************************
  *           SetThreadQueue  (KERNEL.463)
  */
-HQUEUE16 WINAPI SetThreadQueue( DWORD thread, HQUEUE16 hQueue )
+HQUEUE16 WINAPI SetThreadQueue16( DWORD thread, HQUEUE16 hQueue )
 {
     THDB *thdb = thread? THREAD_IdToTHDB( thread ) : THREAD_Current();
     HQUEUE16 oldQueue = thdb? thdb->teb.queue : 0;
@@ -1244,8 +1244,8 @@
     {
         thdb->teb.queue = hQueue;
 
-        if ( GetTaskQueue( thdb->process->task ) == oldQueue )
-            SetTaskQueue( thdb->process->task, hQueue );
+        if ( GetTaskQueue16( thdb->process->task ) == oldQueue )
+            SetTaskQueue16( thdb->process->task, hQueue );
     }
 
     return oldQueue;
@@ -1254,14 +1254,14 @@
 /***********************************************************************
  *           GetThreadQueue  (KERNEL.464)
  */
-HQUEUE16 WINAPI GetThreadQueue( DWORD thread )
+HQUEUE16 WINAPI GetThreadQueue16( DWORD thread )
 {
     THDB *thdb = NULL;
     if ( !thread )
         thdb = THREAD_Current();
     else if ( HIWORD(thread) )
         thdb = THREAD_IdToTHDB( thread );
-    else if ( IsTask( (HTASK16)thread ) )
+    else if ( IsTask16( (HTASK16)thread ) )
         thdb = ((TDB *)GlobalLock16( (HANDLE16)thread ))->thdb;
 
     return (HQUEUE16)(thdb? thdb->teb.queue : 0);
@@ -1270,14 +1270,14 @@
 /***********************************************************************
  *           SetFastQueue  (KERNEL.624)
  */
-VOID WINAPI SetFastQueue( DWORD thread, HANDLE32 hQueue )
+VOID WINAPI SetFastQueue16( DWORD thread, HANDLE hQueue )
 {
     THDB *thdb = NULL;
     if ( !thread )
         thdb = THREAD_Current();
     else if ( HIWORD(thread) )
         thdb = THREAD_IdToTHDB( thread );
-    else if ( IsTask( (HTASK16)thread ) )
+    else if ( IsTask16( (HTASK16)thread ) )
         thdb = ((TDB *)GlobalLock16( (HANDLE16)thread ))->thdb;
 
     if ( thdb ) thdb->teb.queue = (HQUEUE16) hQueue;
@@ -1286,24 +1286,24 @@
 /***********************************************************************
  *           GetFastQueue  (KERNEL.625)
  */
-HANDLE32 WINAPI GetFastQueue( void )
+HANDLE WINAPI GetFastQueue16( void )
 {
     THDB *thdb = THREAD_Current();
     if (!thdb) return 0;
 
     if (!thdb->teb.queue)
-        Callout.InitThreadInput( 0, THREAD_IsWin16(thdb)? 4 : 5 );
+        Callout.InitThreadInput16( 0, THREAD_IsWin16(thdb)? 4 : 5 );
 
     if (!thdb->teb.queue)
         FIXME( task, "(): should initialize thread-local queue, expect failure!\n" );
 
-    return (HANDLE32)thdb->teb.queue;
+    return (HANDLE)thdb->teb.queue;
 }
 
 /***********************************************************************
  *           SwitchStackTo   (KERNEL.108)
  */
-void WINAPI SwitchStackTo( WORD seg, WORD ptr, WORD top )
+void WINAPI SwitchStackTo16( WORD seg, WORD ptr, WORD top )
 {
     TDB *pTask;
     STACK16FRAME *oldFrame, *newFrame;
@@ -1348,7 +1348,7 @@
 /***********************************************************************
  *           SwitchStackBack   (KERNEL.109)
  */
-void WINAPI SwitchStackBack( CONTEXT *context )
+void WINAPI SwitchStackBack16( CONTEXT *context )
 {
     TDB *pTask;
     STACK16FRAME *oldFrame, *newFrame;
@@ -1394,18 +1394,18 @@
 /***********************************************************************
  *           GetTaskQueueDS  (KERNEL.118)
  */
-void WINAPI GetTaskQueueDS( CONTEXT *context )
+void WINAPI GetTaskQueueDS16( CONTEXT *context )
 {
-    DS_reg(context) = GlobalHandleToSel( GetTaskQueue(0) );
+    DS_reg(context) = GlobalHandleToSel16( GetTaskQueue16(0) );
 }
 
 
 /***********************************************************************
  *           GetTaskQueueES  (KERNEL.119)
  */
-void WINAPI GetTaskQueueES( CONTEXT *context )
+void WINAPI GetTaskQueueES16( CONTEXT *context )
 {
-    ES_reg(context) = GlobalHandleToSel( GetTaskQueue(0) );
+    ES_reg(context) = GlobalHandleToSel16( GetTaskQueue16(0) );
 }
 
 
@@ -1430,7 +1430,7 @@
  *
  * UNDOC: returns PSP of KERNEL in high word
  */
-DWORD WINAPI GetCurrentPDB(void)
+DWORD WINAPI GetCurrentPDB16(void)
 {
     TDB *pTask;
 
@@ -1442,7 +1442,7 @@
 /***********************************************************************
  *           GetInstanceData   (KERNEL.54)
  */
-INT16 WINAPI GetInstanceData( HINSTANCE16 instance, WORD buffer, INT16 len )
+INT16 WINAPI GetInstanceData16( HINSTANCE16 instance, WORD buffer, INT16 len )
 {
     char *ptr = (char *)GlobalLock16( instance );
     if (!ptr || !len) return 0;
@@ -1455,7 +1455,7 @@
 /***********************************************************************
  *           GetExeVersion   (KERNEL.105)
  */
-WORD WINAPI GetExeVersion(void)
+WORD WINAPI GetExeVersion16(void)
 {
     TDB *pTask;
 
@@ -1483,7 +1483,7 @@
 /***********************************************************************
  *           SetErrorMode32   (KERNEL32.486)
  */
-UINT32 WINAPI SetErrorMode32( UINT32 mode )
+UINT WINAPI SetErrorMode( UINT mode )
 {
     return SetErrorMode16( (UINT16)mode );
 }
@@ -1492,7 +1492,7 @@
 /***********************************************************************
  *           GetDOSEnvironment   (KERNEL.131)
  */
-SEGPTR WINAPI GetDOSEnvironment(void)
+SEGPTR WINAPI GetDOSEnvironment16(void)
 {
     TDB *pTask;
 
@@ -1504,7 +1504,7 @@
 /***********************************************************************
  *           GetNumTasks   (KERNEL.152)
  */
-UINT16 WINAPI GetNumTasks(void)
+UINT16 WINAPI GetNumTasks16(void)
 {
     return nTaskCount;
 }
@@ -1516,7 +1516,7 @@
  * Note: this function apparently returns a DWORD with LOWORD == HIWORD.
  * I don't think we need to bother with this.
  */
-HINSTANCE16 WINAPI GetTaskDS(void)
+HINSTANCE16 WINAPI GetTaskDS16(void)
 {
     TDB *pTask;
 
@@ -1527,7 +1527,7 @@
 /***********************************************************************
  *           GetDummyModuleHandleDS   (KERNEL.602)
  */
-VOID WINAPI GetDummyModuleHandleDS( CONTEXT *context )
+VOID WINAPI GetDummyModuleHandleDS16( CONTEXT *context )
 {
     TDB *pTask;
     WORD selector;
@@ -1536,7 +1536,7 @@
     if (!(pTask = (TDB *)GlobalLock16( GetCurrentTask() ))) return;
     if (!(pTask->flags & TDBF_WIN32)) return;
 
-    selector = GlobalHandleToSel( pTask->hModule );
+    selector = GlobalHandleToSel16( pTask->hModule );
     DS_reg( context ) = selector;
     AX_reg( context ) = selector;
 }
@@ -1544,7 +1544,7 @@
 /***********************************************************************
  *           IsTask   (KERNEL.320)
  */
-BOOL16 WINAPI IsTask( HTASK16 hTask )
+BOOL16 WINAPI IsTask16( HTASK16 hTask )
 {
     TDB *pTask;
 
@@ -1575,7 +1575,7 @@
 /***********************************************************************
  *           SetSigHandler   (KERNEL.140)
  */
-WORD WINAPI SetSigHandler( FARPROC16 newhandler, FARPROC16* oldhandler,
+WORD WINAPI SetSigHandler16( FARPROC16 newhandler, FARPROC16* oldhandler,
                            UINT16 *oldmode, UINT16 newmode, UINT16 flag )
 {
     FIXME(task,"(%p,%p,%p,%d,%d), unimplemented.\n",
@@ -1603,7 +1603,7 @@
  * Note that GlobalNotify does _not_ return the old NotifyProc
  * -- contrary to LocalNotify !!
  */
-VOID WINAPI GlobalNotify( FARPROC16 proc )
+VOID WINAPI GlobalNotify16( FARPROC16 proc )
 {
     TDB *pTask;
 
@@ -1640,7 +1640,7 @@
 
       /* Check the owner for module handle */
 
-    owner = FarGetOwner( handle );
+    owner = FarGetOwner16( handle );
     if (!(ptr = GlobalLock16( owner ))) return 0;
     if (((NE_MODULE *)ptr)->magic == IMAGE_OS2_SIGNATURE) return owner;
 
@@ -1682,17 +1682,17 @@
 /***********************************************************************
  *           TaskFirst   (TOOLHELP.63)
  */
-BOOL16 WINAPI TaskFirst( TASKENTRY *lpte )
+BOOL16 WINAPI TaskFirst16( TASKENTRY *lpte )
 {
     lpte->hNext = hFirstTask;
-    return TaskNext( lpte );
+    return TaskNext16( lpte );
 }
 
 
 /***********************************************************************
  *           TaskNext   (TOOLHELP.64)
  */
-BOOL16 WINAPI TaskNext( TASKENTRY *lpte )
+BOOL16 WINAPI TaskNext16( TASKENTRY *lpte )
 {
     TDB *pTask;
     INSTANCEDATA *pInstData;
@@ -1724,10 +1724,10 @@
 /***********************************************************************
  *           TaskFindHandle   (TOOLHELP.65)
  */
-BOOL16 WINAPI TaskFindHandle( TASKENTRY *lpte, HTASK16 hTask )
+BOOL16 WINAPI TaskFindHandle16( TASKENTRY *lpte, HTASK16 hTask )
 {
     lpte->hNext = hTask;
-    return TaskNext( lpte );
+    return TaskNext16( lpte );
 }
 
 
@@ -1736,14 +1736,14 @@
  */
 DWORD WINAPI GetAppCompatFlags16( HTASK16 hTask )
 {
-    return GetAppCompatFlags32( hTask );
+    return GetAppCompatFlags( hTask );
 }
 
 
 /***********************************************************************
  *           GetAppCompatFlags32   (USER32.206)
  */
-DWORD WINAPI GetAppCompatFlags32( HTASK32 hTask )
+DWORD WINAPI GetAppCompatFlags( HTASK hTask )
 {
     TDB *pTask;