diff --git a/dlls/msacm32/internal.c b/dlls/msacm32/internal.c
index e06d9e1..b1485e4 100644
--- a/dlls/msacm32/internal.c
+++ b/dlls/msacm32/internal.c
@@ -16,34 +16,34 @@
 
 /**********************************************************************/
 
-HANDLE32 MSACM_hHeap32 = (HANDLE32) NULL;
-PWINE_ACMDRIVERID32 MSACM_pFirstACMDriverID32 = NULL;
-PWINE_ACMDRIVERID32 MSACM_pLastACMDriverID32 = NULL;
+HANDLE MSACM_hHeap = (HANDLE) NULL;
+PWINE_ACMDRIVERID MSACM_pFirstACMDriverID = NULL;
+PWINE_ACMDRIVERID MSACM_pLastACMDriverID = NULL;
 
 /***********************************************************************
  *           MSACM_RegisterDriver32() 
  */
-PWINE_ACMDRIVERID32 MSACM_RegisterDriver32(
+PWINE_ACMDRIVERID MSACM_RegisterDriver(
   LPSTR pszDriverAlias, LPSTR pszFileName,
-  PWINE_ACMLOCALDRIVER32 pLocalDriver)
+  PWINE_ACMLOCALDRIVER pLocalDriver)
 {
-  PWINE_ACMDRIVERID32 padid;
-  padid = (PWINE_ACMDRIVERID32) HeapAlloc(
-    MSACM_hHeap32, 0, sizeof(WINE_ACMDRIVERID32)
+  PWINE_ACMDRIVERID padid;
+  padid = (PWINE_ACMDRIVERID) HeapAlloc(
+    MSACM_hHeap, 0, sizeof(WINE_ACMDRIVERID)
   );
   padid->pszDriverAlias = 
-    HEAP_strdupA(MSACM_hHeap32, 0, pszDriverAlias);
+    HEAP_strdupA(MSACM_hHeap, 0, pszDriverAlias);
   padid->pszFileName = 
-    HEAP_strdupA(MSACM_hHeap32, 0, pszFileName);
+    HEAP_strdupA(MSACM_hHeap, 0, pszFileName);
   padid->pACMLocalDriver = pLocalDriver; 
   padid->bEnabled = TRUE;
   padid->pACMDriver = NULL;
   padid->pNextACMDriverID = NULL;
   padid->pPreviousACMDriverID = 
-    MSACM_pLastACMDriverID32;
-  MSACM_pLastACMDriverID32 = padid;
-  if(!MSACM_pFirstACMDriverID32)
-    MSACM_pFirstACMDriverID32 = padid;
+    MSACM_pLastACMDriverID;
+  MSACM_pLastACMDriverID = padid;
+  if(!MSACM_pFirstACMDriverID)
+    MSACM_pFirstACMDriverID = padid;
 
   return padid;
 }
@@ -51,9 +51,9 @@
 /***********************************************************************
  *           MSACM_RegisterAllDrivers32() 
  */
-void MSACM_RegisterAllDrivers32()
+void MSACM_RegisterAllDrivers()
 {
-  PWINE_ACMBUILTINDRIVER32 pbd;
+  PWINE_ACMBUILTINDRIVER pbd;
   LPSTR pszBuffer;
   DWORD dwBufferLength;
 
@@ -61,33 +61,33 @@
    *  What if the user edits system.ini while the program is running?
    *  Does Windows handle that?
    */
-  if(!MSACM_pFirstACMDriverID32)
+  if(!MSACM_pFirstACMDriverID)
     return;
 
   /* FIXME: Do not work! How do I determine the section length? */
   dwBufferLength = 
-    GetPrivateProfileSection32A("drivers32", NULL, 0, "system.ini");
+    GetPrivateProfileSectionA("drivers32", NULL, 0, "system.ini");
 
   pszBuffer = (LPSTR) HeapAlloc(
-    MSACM_hHeap32, 0, dwBufferLength
+    MSACM_hHeap, 0, dwBufferLength
   );
-  if(GetPrivateProfileSection32A(
+  if(GetPrivateProfileSectionA(
     "drivers32", pszBuffer, dwBufferLength, "system.ini"))
     {
       char *s = pszBuffer;
       while(*s)
 	{
-	  if(!lstrncmpi32A("MSACM.", s, 6))
+	  if(!lstrncmpiA("MSACM.", s, 6))
 	    {
 	      char *s2 = s;
 	      while(*s2 != '\0' && *s2 != '=') s2++;
 	      if(*s2)
 		{
 		  *s2++='\0';
-		  MSACM_RegisterDriver32(s, s2, NULL);
+		  MSACM_RegisterDriver(s, s2, NULL);
 		}
 	    }  
-	  s += lstrlen32A(s) + 1; /* Either next char or \0 */
+	  s += lstrlenA(s) + 1; /* Either next char or \0 */
 	}
     }
 
@@ -96,34 +96,34 @@
    *   when the external drivers was. 
    */
 
-  pbd = MSACM_BuiltinDrivers32;
+  pbd = MSACM_BuiltinDrivers;
   while(pbd->pszDriverAlias)
     {
-      PWINE_ACMLOCALDRIVER32 pld;
-      pld = HeapAlloc(MSACM_hHeap32, 0, sizeof(WINE_ACMLOCALDRIVER32));
+      PWINE_ACMLOCALDRIVER pld;
+      pld = HeapAlloc(MSACM_hHeap, 0, sizeof(WINE_ACMLOCALDRIVER));
       pld->pfnDriverProc = pbd->pfnDriverProc;
-      MSACM_RegisterDriver32(pbd->pszDriverAlias, NULL, pld);
+      MSACM_RegisterDriver(pbd->pszDriverAlias, NULL, pld);
       pbd++;
     }
-   HeapFree(MSACM_hHeap32, 0, pszBuffer);
+   HeapFree(MSACM_hHeap, 0, pszBuffer);
 }
 
 /***********************************************************************
  *           MSACM_UnregisterDriver32()
  */
-PWINE_ACMDRIVERID32 MSACM_UnregisterDriver32(PWINE_ACMDRIVERID32 p)
+PWINE_ACMDRIVERID MSACM_UnregisterDriver(PWINE_ACMDRIVERID p)
 {
-  PWINE_ACMDRIVERID32 pNextACMDriverID;
+  PWINE_ACMDRIVERID pNextACMDriverID;
 
   if(p->pACMDriver)
-    acmDriverClose32((HACMDRIVER32) p->pACMDriver, 0);
+    acmDriverClose((HACMDRIVER) p->pACMDriver, 0);
 
   if(p->pszDriverAlias)
-    HeapFree(MSACM_hHeap32, 0, p->pszDriverAlias);
+    HeapFree(MSACM_hHeap, 0, p->pszDriverAlias);
   if(p->pszFileName)
-    HeapFree(MSACM_hHeap32, 0, p->pszFileName);
+    HeapFree(MSACM_hHeap, 0, p->pszFileName);
   if(p->pACMLocalDriver)
-    HeapFree(MSACM_hHeap32, 0, p->pACMLocalDriver);
+    HeapFree(MSACM_hHeap, 0, p->pACMLocalDriver);
 
   if(p->pPreviousACMDriverID)
     p->pPreviousACMDriverID->pNextACMDriverID = p->pNextACMDriverID;
@@ -132,7 +132,7 @@
 
   pNextACMDriverID = p->pNextACMDriverID;
 
-  HeapFree(MSACM_hHeap32, 0, p);
+  HeapFree(MSACM_hHeap, 0, p);
 
   return pNextACMDriverID;
 }
@@ -142,34 +142,34 @@
  * FIXME
  *   Where should this function be called?
  */
-void MSACM_UnregisterAllDrivers32()
+void MSACM_UnregisterAllDrivers()
 {
-  PWINE_ACMDRIVERID32 p = MSACM_pFirstACMDriverID32;
-  while(p) p = MSACM_UnregisterDriver32(p);
+  PWINE_ACMDRIVERID p = MSACM_pFirstACMDriverID;
+  while(p) p = MSACM_UnregisterDriver(p);
 }
 
 /***********************************************************************
  *           MSACM_GetDriverID32() 
  */
-PWINE_ACMDRIVERID32 MSACM_GetDriverID32(HACMDRIVERID32 hDriverID)
+PWINE_ACMDRIVERID MSACM_GetDriverID(HACMDRIVERID hDriverID)
 {
-  return (PWINE_ACMDRIVERID32) hDriverID;
+  return (PWINE_ACMDRIVERID) hDriverID;
 }
 
 /***********************************************************************
  *           MSACM_GetDriver32()
  */
-PWINE_ACMDRIVER32 MSACM_GetDriver32(HACMDRIVER32 hDriver)
+PWINE_ACMDRIVER MSACM_GetDriver(HACMDRIVER hDriver)
 {
-  return (PWINE_ACMDRIVER32) hDriver;
+  return (PWINE_ACMDRIVER) hDriver;
 }
 
 /***********************************************************************
  *           MSACM_GetObj32()
  */
-PWINE_ACMOBJ32 MSACM_GetObj32(HACMOBJ32 hObj)
+PWINE_ACMOBJ MSACM_GetObj(HACMOBJ hObj)
 {
-  return (PWINE_ACMOBJ32) hObj;
+  return (PWINE_ACMOBJ) hObj;
 }
 
 /***********************************************************************
@@ -178,21 +178,21 @@
  *  This function should be integrated with OpenDriver,
  *  renamed and moved there.
  */
-HDRVR32 MSACM_OpenDriverProc32(DRIVERPROC32 pfnDriverProc)
+HDRVR MSACM_OpenDriverProc(DRIVERPROC pfnDriverProc)
 {
 #if 0
-  LPDRIVERITEM32A pDrvr;
+  LPDRIVERITEMA pDrvr;
 
   /* FIXME: This is a very bad solution */
-  pDrvr = (LPDRIVERITEM32A) HeapAlloc(MSACM_hHeap32, HEAP_ZERO_MEMORY, sizeof(DRIVERITEM32A));
+  pDrvr = (LPDRIVERITEMA) HeapAlloc(MSACM_hHeap, HEAP_ZERO_MEMORY, sizeof(DRIVERITEMA));
   pDrvr->count = 1;
   pDrvr->driverproc = pfnDriverProc;
   
   /* FIXME: Send DRV_OPEN among others to DriverProc */
 
-  return (HDRVR32) pDrvr;
+  return (HDRVR) pDrvr;
 #else
-  return (HDRVR32) 0;
+  return (HDRVR) 0;
 #endif
 }