source: trunk/mkspecs/os2-g++/API_FPU_CW_Wrappers.h@ 720

/* Generated by API_FPU_CW_Wrappers.awk from os2emx.h      */
/* See http://svn.netlabs.org/qt4/ticket/105 for more info */

/*
 * Some OS/2 PM API calls modify the FPU Control Word,
 * but forget to restore it.
 *
 * This can result in unexpected XCPT_FLOAT_INVALID_OPCODE or
 * XCPT_FLOAT_INVALID_OPERATION exceptions. To avoid this, we create
 * wrappers for each API call that restore the FPU Control Word
 * after the API call back to the value expected by C/C++ programs.
 */

#ifndef API_FPU_CW_WRAPPERS_H
#define API_FPU_CW_WRAPPERS_H

inline void __FPU_CW_Restore()
{
    asm("pushl %%eax\n\t"       /* Dummy for storing control word */
        "fstcw 0(%%esp)\n\t"    /* Store control word into memory */
        "orw $5, 0(%%esp)\n\t"  /* Set EM_INVALID (0x1) | EM_ZERODIVIDE (0x4) */
        "fldcw 0(%%esp)\n\t"    /* Load control word back */
        "popl %%eax\n\t"
        ::: "eax");
}

inline BOOL APIENTRY __FPU_CW_WinCancelShutdown (HMQ hmq, BOOL fCancelAlways)
{
    BOOL ret = WinCancelShutdown (hmq, fCancelAlways);
    __FPU_CW_Restore();
    return ret;
}
#define WinCancelShutdown __FPU_CW_WinCancelShutdown

inline HMQ APIENTRY __FPU_CW_WinCreateMsgQueue (HAB hab, LONG cmsg)
{
    HMQ ret = WinCreateMsgQueue (hab, cmsg);
    __FPU_CW_Restore();
    return ret;
}
#define WinCreateMsgQueue __FPU_CW_WinCreateMsgQueue

inline BOOL APIENTRY __FPU_CW_WinDestroyMsgQueue (HMQ hmq)
{
    BOOL ret = WinDestroyMsgQueue (hmq);
    __FPU_CW_Restore();
    return ret;
}
#define WinDestroyMsgQueue __FPU_CW_WinDestroyMsgQueue

inline MRESULT APIENTRY __FPU_CW_WinDispatchMsg (HAB hab, PQMSG pqmsg)
{
    MRESULT ret = WinDispatchMsg (hab, pqmsg);
    __FPU_CW_Restore();
    return ret;
}
#define WinDispatchMsg __FPU_CW_WinDispatchMsg

inline BOOL APIENTRY __FPU_CW_WinGetMsg (HAB hab, PQMSG pqmsg, HWND hwndFilter, ULONG msgFilterFirst,    ULONG msgFilterLast)
{
    BOOL ret = WinGetMsg (hab, pqmsg, hwndFilter, msgFilterFirst,    msgFilterLast);
    __FPU_CW_Restore();
    return ret;
}
#define WinGetMsg __FPU_CW_WinGetMsg

inline BOOL APIENTRY __FPU_CW_WinLockInput (HMQ hmq, ULONG fLock)
{
    BOOL ret = WinLockInput (hmq, fLock);
    __FPU_CW_Restore();
    return ret;
}
#define WinLockInput __FPU_CW_WinLockInput

inline BOOL APIENTRY __FPU_CW_WinPeekMsg (HAB hab, PQMSG pqmsg, HWND hwndFilter, ULONG msgFilterFirst,    ULONG msgFilterLast, ULONG fl)
{
    BOOL ret = WinPeekMsg (hab, pqmsg, hwndFilter, msgFilterFirst,    msgFilterLast, fl);
    __FPU_CW_Restore();
    return ret;
}
#define WinPeekMsg __FPU_CW_WinPeekMsg

inline BOOL APIENTRY __FPU_CW_WinPostMsg (HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
{
    BOOL ret = WinPostMsg (hwnd, msg, mp1, mp2);
    __FPU_CW_Restore();
    return ret;
}
#define WinPostMsg __FPU_CW_WinPostMsg

inline HMQ APIENTRY __FPU_CW_WinQueueFromID (HAB hab, PID pid, TID tid)
{
    HMQ ret = WinQueueFromID (hab, pid, tid);
    __FPU_CW_Restore();
    return ret;
}
#define WinQueueFromID __FPU_CW_WinQueueFromID

inline BOOL APIENTRY __FPU_CW_WinQueryQueueInfo (HMQ hmq, PMQINFO pmqi, ULONG cbCopy)
{
    BOOL ret = WinQueryQueueInfo (hmq, pmqi, cbCopy);
    __FPU_CW_Restore();
    return ret;
}
#define WinQueryQueueInfo __FPU_CW_WinQueryQueueInfo

inline HMQ APIENTRY __FPU_CW_WinQuerySendMsg (HAB hab, HMQ hmqSender, HMQ hmqReceiver, PQMSG pqmsg)
{
    HMQ ret = WinQuerySendMsg (hab, hmqSender, hmqReceiver, pqmsg);
    __FPU_CW_Restore();
    return ret;
}
#define WinQuerySendMsg __FPU_CW_WinQuerySendMsg

inline BOOL APIENTRY __FPU_CW_WinRegisterUserDatatype (HAB hab, LONG datatype, LONG count, PLONG types)
{
    BOOL ret = WinRegisterUserDatatype (hab, datatype, count, types);
    __FPU_CW_Restore();
    return ret;
}
#define WinRegisterUserDatatype __FPU_CW_WinRegisterUserDatatype

inline BOOL APIENTRY __FPU_CW_WinRegisterUserMsg (HAB hab, ULONG msgid, LONG datatype1, LONG dir1,    LONG datatype2, LONG dir2, LONG datatyper)
{
    BOOL ret = WinRegisterUserMsg (hab, msgid, datatype1, dir1,    datatype2, dir2, datatyper);
    __FPU_CW_Restore();
    return ret;
}
#define WinRegisterUserMsg __FPU_CW_WinRegisterUserMsg

inline BOOL APIENTRY __FPU_CW_WinReplyMsg (HAB hab, HMQ hmqSender, HMQ hmqReceiver, MRESULT mresult)
{
    BOOL ret = WinReplyMsg (hab, hmqSender, hmqReceiver, mresult);
    __FPU_CW_Restore();
    return ret;
}
#define WinReplyMsg __FPU_CW_WinReplyMsg

inline MRESULT APIENTRY __FPU_CW_WinSendMsg (HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
{
    MRESULT ret = WinSendMsg (hwnd, msg, mp1, mp2);
    __FPU_CW_Restore();
    return ret;
}
#define WinSendMsg __FPU_CW_WinSendMsg

inline BOOL APIENTRY __FPU_CW_WinSetMsgMode (HAB hab, PCSZ classname, LONG control)
{
    BOOL ret = WinSetMsgMode (hab, classname, control);
    __FPU_CW_Restore();
    return ret;
}
#define WinSetMsgMode __FPU_CW_WinSetMsgMode

inline BOOL APIENTRY __FPU_CW_WinSetSynchroMode (HAB hab, LONG mode)
{
    BOOL ret = WinSetSynchroMode (hab, mode);
    __FPU_CW_Restore();
    return ret;
}
#define WinSetSynchroMode __FPU_CW_WinSetSynchroMode

inline BOOL APIENTRY __FPU_CW_WinThreadAssocQueue (HAB hab, HMQ hmq)
{
    BOOL ret = WinThreadAssocQueue (hab, hmq);
    __FPU_CW_Restore();
    return ret;
}
#define WinThreadAssocQueue __FPU_CW_WinThreadAssocQueue

inline BOOL APIENTRY __FPU_CW_WinWakeThread (HMQ hmq)
{
    BOOL ret = WinWakeThread (hmq);
    __FPU_CW_Restore();
    return ret;
}
#define WinWakeThread __FPU_CW_WinWakeThread

inline HWND APIENTRY __FPU_CW_WinCreateWindow (HWND hwndParent, PCSZ pszClass, PCSZ pszName,    ULONG flStyle, LONG x, LONG y, LONG cx, LONG cy, HWND hwndOwner,    HWND hwndInsertBehind, ULONG id, PVOID pCtlData, PVOID pPresParams)
{
    HWND ret = WinCreateWindow (hwndParent, pszClass, pszName,    flStyle, x, y, cx, cy, hwndOwner,    hwndInsertBehind, id, pCtlData, pPresParams);
    __FPU_CW_Restore();
    return ret;
}
#define WinCreateWindow __FPU_CW_WinCreateWindow

inline BOOL APIENTRY __FPU_CW_WinDrawBitmap (HPS hpsDst, HBITMAP hbm, __const__ RECTL *pwrcSrc,    __const__ POINTL *pptlDst, LONG clrFore, LONG clrBack, ULONG fl)
{
    BOOL ret = WinDrawBitmap (hpsDst, hbm, pwrcSrc,    pptlDst, clrFore, clrBack, fl);
    __FPU_CW_Restore();
    return ret;
}
#define WinDrawBitmap __FPU_CW_WinDrawBitmap

inline BOOL APIENTRY __FPU_CW_WinDrawBorder (HPS hps, __const__ RECTL *prcl, LONG cx, LONG cy,    LONG clrFore, LONG clrBack, ULONG flCmd)
{
    BOOL ret = WinDrawBorder (hps, prcl, cx, cy,    clrFore, clrBack, flCmd);
    __FPU_CW_Restore();
    return ret;
}
#define WinDrawBorder __FPU_CW_WinDrawBorder

inline LONG APIENTRY __FPU_CW_WinDrawText (HPS hps, LONG cchText, PCCH lpchText, PRECTL prcl,    LONG clrFore, LONG clrBack, ULONG flCmd)
{
    LONG ret = WinDrawText (hps, cchText, lpchText, prcl,    clrFore, clrBack, flCmd);
    __FPU_CW_Restore();
    return ret;
}
#define WinDrawText __FPU_CW_WinDrawText

inline BOOL APIENTRY __FPU_CW_WinEnableWindow (HWND hwnd, BOOL fEnable)
{
    BOOL ret = WinEnableWindow (hwnd, fEnable);
    __FPU_CW_Restore();
    return ret;
}
#define WinEnableWindow __FPU_CW_WinEnableWindow

inline BOOL APIENTRY __FPU_CW_WinEnableWindowUpdate (HWND hwnd, BOOL fEnable)
{
    BOOL ret = WinEnableWindowUpdate (hwnd, fEnable);
    __FPU_CW_Restore();
    return ret;
}
#define WinEnableWindowUpdate __FPU_CW_WinEnableWindowUpdate

inline BOOL APIENTRY __FPU_CW_WinInvalidateRect (HWND hwnd, __const__ RECTL *prcl,    BOOL fIncludeChildren)
{
    BOOL ret = WinInvalidateRect (hwnd, prcl,    fIncludeChildren);
    __FPU_CW_Restore();
    return ret;
}
#define WinInvalidateRect __FPU_CW_WinInvalidateRect

inline BOOL APIENTRY __FPU_CW_WinInvalidateRegion (HWND hwnd, HRGN hrgn, BOOL fIncludeChildren)
{
    BOOL ret = WinInvalidateRegion (hwnd, hrgn, fIncludeChildren);
    __FPU_CW_Restore();
    return ret;
}
#define WinInvalidateRegion __FPU_CW_WinInvalidateRegion

inline BOOL APIENTRY __FPU_CW_WinInvertRect (HPS hps, __const__ RECTL *prcl)
{
    BOOL ret = WinInvertRect (hps, prcl);
    __FPU_CW_Restore();
    return ret;
}
#define WinInvertRect __FPU_CW_WinInvertRect

inline BOOL APIENTRY __FPU_CW_WinIsChild (HWND hwnd, HWND hwndParent)
{
    BOOL ret = WinIsChild (hwnd, hwndParent);
    __FPU_CW_Restore();
    return ret;
}
#define WinIsChild __FPU_CW_WinIsChild

inline BOOL APIENTRY __FPU_CW_WinIsWindow (HAB hab, HWND hwnd)
{
    BOOL ret = WinIsWindow (hab, hwnd);
    __FPU_CW_Restore();
    return ret;
}
#define WinIsWindow __FPU_CW_WinIsWindow

inline BOOL APIENTRY __FPU_CW_WinIsWindowEnabled (HWND hwnd)
{
    BOOL ret = WinIsWindowEnabled (hwnd);
    __FPU_CW_Restore();
    return ret;
}
#define WinIsWindowEnabled __FPU_CW_WinIsWindowEnabled

inline BOOL APIENTRY __FPU_CW_WinIsWindowVisible (HWND hwnd)
{
    BOOL ret = WinIsWindowVisible (hwnd);
    __FPU_CW_Restore();
    return ret;
}
#define WinIsWindowVisible __FPU_CW_WinIsWindowVisible

inline LONG APIENTRY __FPU_CW_WinLoadMessage (HAB hab, HMODULE hmod, ULONG id, LONG cchMax,    PSZ pchBuffer)
{
    LONG ret = WinLoadMessage (hab, hmod, id, cchMax,    pchBuffer);
    __FPU_CW_Restore();
    return ret;
}
#define WinLoadMessage __FPU_CW_WinLoadMessage

inline LONG APIENTRY __FPU_CW_WinLoadString (HAB hab, HMODULE hmod, ULONG id, LONG cchMax,    PSZ pchBuffer)
{
    LONG ret = WinLoadString (hab, hmod, id, cchMax,    pchBuffer);
    __FPU_CW_Restore();
    return ret;
}
#define WinLoadString __FPU_CW_WinLoadString

inline LONG APIENTRY __FPU_CW_WinMultWindowFromIDs (HWND hwndParent, PHWND prghwnd, ULONG idFirst,    ULONG idLast)
{
    LONG ret = WinMultWindowFromIDs (hwndParent, prghwnd, idFirst,    idLast);
    __FPU_CW_Restore();
    return ret;
}
#define WinMultWindowFromIDs __FPU_CW_WinMultWindowFromIDs

inline HWND APIENTRY __FPU_CW_WinQueryDesktopWindow (HAB hab, HDC hdc)
{
    HWND ret = WinQueryDesktopWindow (hab, hdc);
    __FPU_CW_Restore();
    return ret;
}
#define WinQueryDesktopWindow __FPU_CW_WinQueryDesktopWindow

inline HWND APIENTRY __FPU_CW_WinQueryObjectWindow (HWND hwndDesktop)
{
    HWND ret = WinQueryObjectWindow (hwndDesktop);
    __FPU_CW_Restore();
    return ret;
}
#define WinQueryObjectWindow __FPU_CW_WinQueryObjectWindow

inline HPOINTER APIENTRY __FPU_CW_WinQueryPointer (HWND hwndDesktop)
{
    HPOINTER ret = WinQueryPointer (hwndDesktop);
    __FPU_CW_Restore();
    return ret;
}
#define WinQueryPointer __FPU_CW_WinQueryPointer

inline HWND APIENTRY __FPU_CW_WinQueryWindow (HWND hwnd, LONG cmd)
{
    HWND ret = WinQueryWindow (hwnd, cmd);
    __FPU_CW_Restore();
    return ret;
}
#define WinQueryWindow __FPU_CW_WinQueryWindow

inline BOOL APIENTRY __FPU_CW_WinQueryWindowPos (HWND hwnd, PSWP pswp)
{
    BOOL ret = WinQueryWindowPos (hwnd, pswp);
    __FPU_CW_Restore();
    return ret;
}
#define WinQueryWindowPos __FPU_CW_WinQueryWindowPos

inline BOOL APIENTRY __FPU_CW_WinQueryWindowProcess (HWND hwnd, PPID ppid, PTID ptid)
{
    BOOL ret = WinQueryWindowProcess (hwnd, ppid, ptid);
    __FPU_CW_Restore();
    return ret;
}
#define WinQueryWindowProcess __FPU_CW_WinQueryWindowProcess

inline LONG APIENTRY __FPU_CW_WinQueryWindowText (HWND hwnd, LONG cchBufferMax, PCH pchBuffer)
{
    LONG ret = WinQueryWindowText (hwnd, cchBufferMax, pchBuffer);
    __FPU_CW_Restore();
    return ret;
}
#define WinQueryWindowText __FPU_CW_WinQueryWindowText

inline LONG APIENTRY __FPU_CW_WinQueryWindowTextLength (HWND hwnd)
{
    LONG ret = WinQueryWindowTextLength (hwnd);
    __FPU_CW_Restore();
    return ret;
}
#define WinQueryWindowTextLength __FPU_CW_WinQueryWindowTextLength

inline BOOL APIENTRY __FPU_CW_WinSetMultWindowPos (HAB hab, __const__ SWP *pswp, ULONG cswp)
{
    BOOL ret = WinSetMultWindowPos (hab, pswp, cswp);
    __FPU_CW_Restore();
    return ret;
}
#define WinSetMultWindowPos __FPU_CW_WinSetMultWindowPos

inline BOOL APIENTRY __FPU_CW_WinSetOwner (HWND hwnd, HWND hwndNewOwner)
{
    BOOL ret = WinSetOwner (hwnd, hwndNewOwner);
    __FPU_CW_Restore();
    return ret;
}
#define WinSetOwner __FPU_CW_WinSetOwner

inline BOOL APIENTRY __FPU_CW_WinSetParent (HWND hwnd, HWND hwndNewParent, BOOL fRedraw)
{
    BOOL ret = WinSetParent (hwnd, hwndNewParent, fRedraw);
    __FPU_CW_Restore();
    return ret;
}
#define WinSetParent __FPU_CW_WinSetParent

inline BOOL APIENTRY __FPU_CW_WinSetWindowPos (HWND hwnd, HWND hwndInsertBehind, LONG x, LONG y,    LONG cx, LONG cy, ULONG fl)
{
    BOOL ret = WinSetWindowPos (hwnd, hwndInsertBehind, x, y,    cx, cy, fl);
    __FPU_CW_Restore();
    return ret;
}
#define WinSetWindowPos __FPU_CW_WinSetWindowPos

inline BOOL APIENTRY __FPU_CW_WinSetWindowText (HWND hwnd, PCSZ pszText)
{
    BOOL ret = WinSetWindowText (hwnd, pszText);
    __FPU_CW_Restore();
    return ret;
}
#define WinSetWindowText __FPU_CW_WinSetWindowText

inline BOOL APIENTRY __FPU_CW_WinUpdateWindow (HWND hwnd)
{
    BOOL ret = WinUpdateWindow (hwnd);
    __FPU_CW_Restore();
    return ret;
}
#define WinUpdateWindow __FPU_CW_WinUpdateWindow

inline HWND APIENTRY __FPU_CW_WinWindowFromID (HWND hwndParent, ULONG id)
{
    HWND ret = WinWindowFromID (hwndParent, id);
    __FPU_CW_Restore();
    return ret;
}
#define WinWindowFromID __FPU_CW_WinWindowFromID

inline HWND APIENTRY __FPU_CW_WinCreateStdWindow (HWND hwndParent, ULONG flStyle,    PULONG pflCreateFlags, PCSZ pszClientClass, PCSZ pszTitle,    ULONG styleClient, HMODULE hmod, ULONG idResources, PHWND phwndClient)
{
    HWND ret = WinCreateStdWindow (hwndParent, flStyle,    pflCreateFlags, pszClientClass, pszTitle,    styleClient, hmod, idResources, phwndClient);
    __FPU_CW_Restore();
    return ret;
}
#define WinCreateStdWindow __FPU_CW_WinCreateStdWindow

inline BOOL APIENTRY __FPU_CW_WinCalcFrameRect (HWND hwndFrame, PRECTL prcl, BOOL fClient)
{
    BOOL ret = WinCalcFrameRect (hwndFrame, prcl, fClient);
    __FPU_CW_Restore();
    return ret;
}
#define WinCalcFrameRect __FPU_CW_WinCalcFrameRect

inline BOOL APIENTRY __FPU_CW_WinCreateFrameControls (HWND hwndFrame, PFRAMECDATA pfcdata,    PCSZ pszTitle)
{
    BOOL ret = WinCreateFrameControls (hwndFrame, pfcdata,    pszTitle);
    __FPU_CW_Restore();
    return ret;
}
#define WinCreateFrameControls __FPU_CW_WinCreateFrameControls

inline BOOL APIENTRY __FPU_CW_WinFlashWindow (HWND hwndFrame, BOOL fFlash)
{
    BOOL ret = WinFlashWindow (hwndFrame, fFlash);
    __FPU_CW_Restore();
    return ret;
}
#define WinFlashWindow __FPU_CW_WinFlashWindow

inline BOOL APIENTRY __FPU_CW_WinGetMaxPosition (HWND hwnd, PSWP pswp)
{
    BOOL ret = WinGetMaxPosition (hwnd, pswp);
    __FPU_CW_Restore();
    return ret;
}
#define WinGetMaxPosition __FPU_CW_WinGetMaxPosition

inline BOOL APIENTRY __FPU_CW_WinGetMinPosition (HWND hwnd, PSWP pswp, __const__ POINTL *pptl)
{
    BOOL ret = WinGetMinPosition (hwnd, pswp, pptl);
    __FPU_CW_Restore();
    return ret;
}
#define WinGetMinPosition __FPU_CW_WinGetMinPosition

inline BOOL APIENTRY __FPU_CW_WinSaveWindowPos (HSAVEWP hsvwp, PSWP pswp, ULONG cswp)
{
    BOOL ret = WinSaveWindowPos (hsvwp, pswp, cswp);
    __FPU_CW_Restore();
    return ret;
}
#define WinSaveWindowPos __FPU_CW_WinSaveWindowPos

inline HPS APIENTRY __FPU_CW_WinBeginPaint (HWND hwnd, HPS hps, PRECTL prclPaint)
{
    HPS ret = WinBeginPaint (hwnd, hps, prclPaint);
    __FPU_CW_Restore();
    return ret;
}
#define WinBeginPaint __FPU_CW_WinBeginPaint

inline MRESULT APIENTRY __FPU_CW_WinDefWindowProc (HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
{
    MRESULT ret = WinDefWindowProc (hwnd, msg, mp1, mp2);
    __FPU_CW_Restore();
    return ret;
}
#define WinDefWindowProc __FPU_CW_WinDefWindowProc

inline BOOL APIENTRY __FPU_CW_WinDestroyWindow (HWND hwnd)
{
    BOOL ret = WinDestroyWindow (hwnd);
    __FPU_CW_Restore();
    return ret;
}
#define WinDestroyWindow __FPU_CW_WinDestroyWindow

inline BOOL APIENTRY __FPU_CW_WinEndPaint (HPS hps)
{
    BOOL ret = WinEndPaint (hps);
    __FPU_CW_Restore();
    return ret;
}
#define WinEndPaint __FPU_CW_WinEndPaint

inline BOOL APIENTRY __FPU_CW_WinFillRect (HPS hps, __const__ RECTL *prcl, LONG lColor)
{
    BOOL ret = WinFillRect (hps, prcl, lColor);
    __FPU_CW_Restore();
    return ret;
}
#define WinFillRect __FPU_CW_WinFillRect

inline HPS APIENTRY __FPU_CW_WinGetClipPS (HWND hwnd, HWND hwndClip, ULONG fl)
{
    HPS ret = WinGetClipPS (hwnd, hwndClip, fl);
    __FPU_CW_Restore();
    return ret;
}
#define WinGetClipPS __FPU_CW_WinGetClipPS

inline HPS APIENTRY __FPU_CW_WinGetPS (HWND hwnd)
{
    HPS ret = WinGetPS (hwnd);
    __FPU_CW_Restore();
    return ret;
}
#define WinGetPS __FPU_CW_WinGetPS

inline HAB APIENTRY __FPU_CW_WinInitialize (ULONG fsOptions)
{
    HAB ret = WinInitialize (fsOptions);
    __FPU_CW_Restore();
    return ret;
}
#define WinInitialize __FPU_CW_WinInitialize

inline BOOL APIENTRY __FPU_CW_WinIsWindowShowing (HWND hwnd)
{
    BOOL ret = WinIsWindowShowing (hwnd);
    __FPU_CW_Restore();
    return ret;
}
#define WinIsWindowShowing __FPU_CW_WinIsWindowShowing

inline HDC APIENTRY __FPU_CW_WinOpenWindowDC (HWND hwnd)
{
    HDC ret = WinOpenWindowDC (hwnd);
    __FPU_CW_Restore();
    return ret;
}
#define WinOpenWindowDC __FPU_CW_WinOpenWindowDC

inline HAB APIENTRY __FPU_CW_WinQueryAnchorBlock (HWND hwnd)
{
    HAB ret = WinQueryAnchorBlock (hwnd);
    __FPU_CW_Restore();
    return ret;
}
#define WinQueryAnchorBlock __FPU_CW_WinQueryAnchorBlock

inline ULONG APIENTRY __FPU_CW_WinQueryVersion (HAB hab)
{
    ULONG ret = WinQueryVersion (hab);
    __FPU_CW_Restore();
    return ret;
}
#define WinQueryVersion __FPU_CW_WinQueryVersion

inline BOOL APIENTRY __FPU_CW_WinQueryWindowRect (HWND hwnd, PRECTL prclDest)
{
    BOOL ret = WinQueryWindowRect (hwnd, prclDest);
    __FPU_CW_Restore();
    return ret;
}
#define WinQueryWindowRect __FPU_CW_WinQueryWindowRect

inline BOOL APIENTRY __FPU_CW_WinRegisterClass (HAB hab, PCSZ pszClassName, PFNWP pfnWndProc,    ULONG flStyle, ULONG cbWindowData)
{
    BOOL ret = WinRegisterClass (hab, pszClassName, pfnWndProc,    flStyle, cbWindowData);
    __FPU_CW_Restore();
    return ret;
}
#define WinRegisterClass __FPU_CW_WinRegisterClass

inline BOOL APIENTRY __FPU_CW_WinReleasePS (HPS hps)
{
    BOOL ret = WinReleasePS (hps);
    __FPU_CW_Restore();
    return ret;
}
#define WinReleasePS __FPU_CW_WinReleasePS

inline LONG APIENTRY __FPU_CW_WinScrollWindow (HWND hwnd, LONG dx, LONG dy, __const__ RECTL *prclScroll,    __const__ RECTL *prclClip, HRGN hrgnUpdate, PRECTL prclUpdate,    ULONG rgfsw)
{
    LONG ret = WinScrollWindow (hwnd, dx, dy, prclScroll,    prclClip, hrgnUpdate, prclUpdate,    rgfsw);
    __FPU_CW_Restore();
    return ret;
}
#define WinScrollWindow __FPU_CW_WinScrollWindow

inline BOOL APIENTRY __FPU_CW_WinSetActiveWindow (HWND hwndDesktop, HWND hwnd)
{
    BOOL ret = WinSetActiveWindow (hwndDesktop, hwnd);
    __FPU_CW_Restore();
    return ret;
}
#define WinSetActiveWindow __FPU_CW_WinSetActiveWindow

inline BOOL APIENTRY __FPU_CW_WinShowWindow (HWND hwnd, BOOL fShow)
{
    BOOL ret = WinShowWindow (hwnd, fShow);
    __FPU_CW_Restore();
    return ret;
}
#define WinShowWindow __FPU_CW_WinShowWindow

inline BOOL APIENTRY __FPU_CW_WinTerminate (HAB hab)
{
    BOOL ret = WinTerminate (hab);
    __FPU_CW_Restore();
    return ret;
}
#define WinTerminate __FPU_CW_WinTerminate

inline HENUM APIENTRY __FPU_CW_WinBeginEnumWindows (HWND hwnd)
{
    HENUM ret = WinBeginEnumWindows (hwnd);
    __FPU_CW_Restore();
    return ret;
}
#define WinBeginEnumWindows __FPU_CW_WinBeginEnumWindows

inline BOOL APIENTRY __FPU_CW_WinEndEnumWindows (HENUM henum)
{
    BOOL ret = WinEndEnumWindows (henum);
    __FPU_CW_Restore();
    return ret;
}
#define WinEndEnumWindows __FPU_CW_WinEndEnumWindows

inline LONG APIENTRY __FPU_CW_WinExcludeUpdateRegion (HPS hps, HWND hwnd)
{
    LONG ret = WinExcludeUpdateRegion (hps, hwnd);
    __FPU_CW_Restore();
    return ret;
}
#define WinExcludeUpdateRegion __FPU_CW_WinExcludeUpdateRegion

inline HWND APIENTRY __FPU_CW_WinGetNextWindow (HENUM henum)
{
    HWND ret = WinGetNextWindow (henum);
    __FPU_CW_Restore();
    return ret;
}
#define WinGetNextWindow __FPU_CW_WinGetNextWindow

inline HPS APIENTRY __FPU_CW_WinGetScreenPS (HWND hwndDesktop)
{
    HPS ret = WinGetScreenPS (hwndDesktop);
    __FPU_CW_Restore();
    return ret;
}
#define WinGetScreenPS __FPU_CW_WinGetScreenPS

inline BOOL APIENTRY __FPU_CW_WinIsThreadActive (HAB hab)
{
    BOOL ret = WinIsThreadActive (hab);
    __FPU_CW_Restore();
    return ret;
}
#define WinIsThreadActive __FPU_CW_WinIsThreadActive

inline BOOL APIENTRY __FPU_CW_WinLockVisRegions (HWND hwndDesktop, BOOL fLock)
{
    BOOL ret = WinLockVisRegions (hwndDesktop, fLock);
    __FPU_CW_Restore();
    return ret;
}
#define WinLockVisRegions __FPU_CW_WinLockVisRegions

inline BOOL APIENTRY __FPU_CW_WinLockWindowUpdate (HWND hwndDesktop, HWND hwndLockUpdate)
{
    BOOL ret = WinLockWindowUpdate (hwndDesktop, hwndLockUpdate);
    __FPU_CW_Restore();
    return ret;
}
#define WinLockWindowUpdate __FPU_CW_WinLockWindowUpdate

inline BOOL APIENTRY __FPU_CW_WinMapWindowPoints (HWND hwndFrom, HWND hwndTo, PPOINTL prgptl,    LONG cwpt)
{
    BOOL ret = WinMapWindowPoints (hwndFrom, hwndTo, prgptl,    cwpt);
    __FPU_CW_Restore();
    return ret;
}
#define WinMapWindowPoints __FPU_CW_WinMapWindowPoints

inline HWND APIENTRY __FPU_CW_WinQueryActiveWindow (HWND hwndDesktop)
{
    HWND ret = WinQueryActiveWindow (hwndDesktop);
    __FPU_CW_Restore();
    return ret;
}
#define WinQueryActiveWindow __FPU_CW_WinQueryActiveWindow

inline BOOL APIENTRY __FPU_CW_WinQueryClassInfo (HAB hab, PCSZ pszClassName, PCLASSINFO pClassInfo)
{
    BOOL ret = WinQueryClassInfo (hab, pszClassName, pClassInfo);
    __FPU_CW_Restore();
    return ret;
}
#define WinQueryClassInfo __FPU_CW_WinQueryClassInfo

inline LONG APIENTRY __FPU_CW_WinQueryClassName (HWND hwnd, LONG cchMax, PCH pch)
{
    LONG ret = WinQueryClassName (hwnd, cchMax, pch);
    __FPU_CW_Restore();
    return ret;
}
#define WinQueryClassName __FPU_CW_WinQueryClassName

inline BOOL APIENTRY __FPU_CW_WinQueryUpdateRect (HWND hwnd, PRECTL prcl)
{
    BOOL ret = WinQueryUpdateRect (hwnd, prcl);
    __FPU_CW_Restore();
    return ret;
}
#define WinQueryUpdateRect __FPU_CW_WinQueryUpdateRect

inline LONG APIENTRY __FPU_CW_WinQueryUpdateRegion (HWND hwnd, HRGN hrgn)
{
    LONG ret = WinQueryUpdateRegion (hwnd, hrgn);
    __FPU_CW_Restore();
    return ret;
}
#define WinQueryUpdateRegion __FPU_CW_WinQueryUpdateRegion

inline HWND APIENTRY __FPU_CW_WinQuerySysModalWindow (HWND hwndDesktop)
{
    HWND ret = WinQuerySysModalWindow (hwndDesktop);
    __FPU_CW_Restore();
    return ret;
}
#define WinQuerySysModalWindow __FPU_CW_WinQuerySysModalWindow

inline HDC APIENTRY __FPU_CW_WinQueryWindowDC (HWND hwnd)
{
    HDC ret = WinQueryWindowDC (hwnd);
    __FPU_CW_Restore();
    return ret;
}
#define WinQueryWindowDC __FPU_CW_WinQueryWindowDC

inline PVOID APIENTRY __FPU_CW_WinQueryWindowPtr (HWND hwnd, LONG index)
{
    PVOID ret = WinQueryWindowPtr (hwnd, index);
    __FPU_CW_Restore();
    return ret;
}
#define WinQueryWindowPtr __FPU_CW_WinQueryWindowPtr

inline ULONG APIENTRY __FPU_CW_WinQueryWindowULong (HWND hwnd, LONG index)
{
    ULONG ret = WinQueryWindowULong (hwnd, index);
    __FPU_CW_Restore();
    return ret;
}
#define WinQueryWindowULong __FPU_CW_WinQueryWindowULong

inline USHORT APIENTRY __FPU_CW_WinQueryWindowUShort (HWND hwnd, LONG index)
{
    USHORT ret = WinQueryWindowUShort (hwnd, index);
    __FPU_CW_Restore();
    return ret;
}
#define WinQueryWindowUShort __FPU_CW_WinQueryWindowUShort

inline BOOL APIENTRY __FPU_CW_WinSetSysModalWindow (HWND hwndDesktop, HWND hwnd)
{
    BOOL ret = WinSetSysModalWindow (hwndDesktop, hwnd);
    __FPU_CW_Restore();
    return ret;
}
#define WinSetSysModalWindow __FPU_CW_WinSetSysModalWindow

inline BOOL APIENTRY __FPU_CW_WinSetWindowBits (HWND hwnd, LONG index, ULONG flData, ULONG flMask)
{
    BOOL ret = WinSetWindowBits (hwnd, index, flData, flMask);
    __FPU_CW_Restore();
    return ret;
}
#define WinSetWindowBits __FPU_CW_WinSetWindowBits

inline BOOL APIENTRY __FPU_CW_WinSetWindowPtr (HWND hwnd, LONG index, PVOID p)
{
    BOOL ret = WinSetWindowPtr (hwnd, index, p);
    __FPU_CW_Restore();
    return ret;
}
#define WinSetWindowPtr __FPU_CW_WinSetWindowPtr

inline BOOL APIENTRY __FPU_CW_WinSetWindowULong (HWND hwnd, LONG index, ULONG ul)
{
    BOOL ret = WinSetWindowULong (hwnd, index, ul);
    __FPU_CW_Restore();
    return ret;
}
#define WinSetWindowULong __FPU_CW_WinSetWindowULong

inline BOOL APIENTRY __FPU_CW_WinSetWindowUShort (HWND hwnd, LONG index, USHORT us)
{
    BOOL ret = WinSetWindowUShort (hwnd, index, us);
    __FPU_CW_Restore();
    return ret;
}
#define WinSetWindowUShort __FPU_CW_WinSetWindowUShort

inline PFNWP APIENTRY __FPU_CW_WinSubclassWindow (HWND hwnd, PFNWP pfnwp)
{
    PFNWP ret = WinSubclassWindow (hwnd, pfnwp);
    __FPU_CW_Restore();
    return ret;
}
#define WinSubclassWindow __FPU_CW_WinSubclassWindow

inline BOOL APIENTRY __FPU_CW_WinValidateRect (HWND hwnd, __const__ RECTL *prcl, BOOL fIncludeChildren)
{
    BOOL ret = WinValidateRect (hwnd, prcl, fIncludeChildren);
    __FPU_CW_Restore();
    return ret;
}
#define WinValidateRect __FPU_CW_WinValidateRect

inline BOOL APIENTRY __FPU_CW_WinValidateRegion (HWND hwnd, HRGN hrgn, BOOL fIncludeChildren)
{
    BOOL ret = WinValidateRegion (hwnd, hrgn, fIncludeChildren);
    __FPU_CW_Restore();
    return ret;
}
#define WinValidateRegion __FPU_CW_WinValidateRegion

inline HWND APIENTRY __FPU_CW_WinWindowFromDC (HDC hdc)
{
    HWND ret = WinWindowFromDC (hdc);
    __FPU_CW_Restore();
    return ret;
}
#define WinWindowFromDC __FPU_CW_WinWindowFromDC

inline HWND APIENTRY __FPU_CW_WinWindowFromPoint (HWND hwnd, __const__ POINTL *pptl, BOOL fChildren)
{
    HWND ret = WinWindowFromPoint (hwnd, pptl, fChildren);
    __FPU_CW_Restore();
    return ret;
}
#define WinWindowFromPoint __FPU_CW_WinWindowFromPoint

inline ULONG APIENTRY __FPU_CW_WinCopyAccelTable (HACCEL haccel, PACCELTABLE pAccelTable,    ULONG cbCopyMax)
{
    ULONG ret = WinCopyAccelTable (haccel, pAccelTable,    cbCopyMax);
    __FPU_CW_Restore();
    return ret;
}
#define WinCopyAccelTable __FPU_CW_WinCopyAccelTable

inline HACCEL APIENTRY __FPU_CW_WinCreateAccelTable (HAB hab, PACCELTABLE pAccelTable)
{
    HACCEL ret = WinCreateAccelTable (hab, pAccelTable);
    __FPU_CW_Restore();
    return ret;
}
#define WinCreateAccelTable __FPU_CW_WinCreateAccelTable

inline BOOL APIENTRY __FPU_CW_WinDestroyAccelTable (HACCEL haccel)
{
    BOOL ret = WinDestroyAccelTable (haccel);
    __FPU_CW_Restore();
    return ret;
}
#define WinDestroyAccelTable __FPU_CW_WinDestroyAccelTable

inline HACCEL APIENTRY __FPU_CW_WinLoadAccelTable (HAB hab, HMODULE hmod, ULONG idAccelTable)
{
    HACCEL ret = WinLoadAccelTable (hab, hmod, idAccelTable);
    __FPU_CW_Restore();
    return ret;
}
#define WinLoadAccelTable __FPU_CW_WinLoadAccelTable

inline HACCEL APIENTRY __FPU_CW_WinQueryAccelTable (HAB hab, HWND hwndFrame)
{
    HACCEL ret = WinQueryAccelTable (hab, hwndFrame);
    __FPU_CW_Restore();
    return ret;
}
#define WinQueryAccelTable __FPU_CW_WinQueryAccelTable

inline BOOL APIENTRY __FPU_CW_WinSetAccelTable (HAB hab, HACCEL haccel, HWND hwndFrame)
{
    BOOL ret = WinSetAccelTable (hab, haccel, hwndFrame);
    __FPU_CW_Restore();
    return ret;
}
#define WinSetAccelTable __FPU_CW_WinSetAccelTable

inline BOOL APIENTRY __FPU_CW_WinTranslateAccel (HAB hab, HWND hwnd, HACCEL haccel, PQMSG pqmsg)
{
    BOOL ret = WinTranslateAccel (hab, hwnd, haccel, pqmsg);
    __FPU_CW_Restore();
    return ret;
}
#define WinTranslateAccel __FPU_CW_WinTranslateAccel

inline ATOM APIENTRY __FPU_CW_WinAddAtom (HATOMTBL hAtomTbl, PCSZ pszAtomName)
{
    ATOM ret = WinAddAtom (hAtomTbl, pszAtomName);
    __FPU_CW_Restore();
    return ret;
}
#define WinAddAtom __FPU_CW_WinAddAtom

inline HATOMTBL APIENTRY __FPU_CW_WinCreateAtomTable (ULONG cbInitial, ULONG cBuckets)
{
    HATOMTBL ret = WinCreateAtomTable (cbInitial, cBuckets);
    __FPU_CW_Restore();
    return ret;
}
#define WinCreateAtomTable __FPU_CW_WinCreateAtomTable

inline ATOM APIENTRY __FPU_CW_WinDeleteAtom (HATOMTBL hAtomTbl, ATOM atom)
{
    ATOM ret = WinDeleteAtom (hAtomTbl, atom);
    __FPU_CW_Restore();
    return ret;
}
#define WinDeleteAtom __FPU_CW_WinDeleteAtom

inline HATOMTBL APIENTRY __FPU_CW_WinDestroyAtomTable (HATOMTBL hAtomTbl)
{
    HATOMTBL ret = WinDestroyAtomTable (hAtomTbl);
    __FPU_CW_Restore();
    return ret;
}
#define WinDestroyAtomTable __FPU_CW_WinDestroyAtomTable

inline ATOM APIENTRY __FPU_CW_WinFindAtom (HATOMTBL hAtomTbl, PCSZ pszAtomName)
{
    ATOM ret = WinFindAtom (hAtomTbl, pszAtomName);
    __FPU_CW_Restore();
    return ret;
}
#define WinFindAtom __FPU_CW_WinFindAtom

inline ULONG APIENTRY __FPU_CW_WinQueryAtomLength (HATOMTBL hAtomTbl, ATOM atom)
{
    ULONG ret = WinQueryAtomLength (hAtomTbl, atom);
    __FPU_CW_Restore();
    return ret;
}
#define WinQueryAtomLength __FPU_CW_WinQueryAtomLength

inline ULONG APIENTRY __FPU_CW_WinQueryAtomName (HATOMTBL hAtomTbl, ATOM atom, PSZ pchBuffer,    ULONG cchBufferMax)
{
    ULONG ret = WinQueryAtomName (hAtomTbl, atom, pchBuffer,    cchBufferMax);
    __FPU_CW_Restore();
    return ret;
}
#define WinQueryAtomName __FPU_CW_WinQueryAtomName

inline ULONG APIENTRY __FPU_CW_WinQueryAtomUsage (HATOMTBL hAtomTbl, ATOM atom)
{
    ULONG ret = WinQueryAtomUsage (hAtomTbl, atom);
    __FPU_CW_Restore();
    return ret;
}
#define WinQueryAtomUsage __FPU_CW_WinQueryAtomUsage

inline HATOMTBL APIENTRY __FPU_CW_WinQuerySystemAtomTable (VOID)
{
    HATOMTBL ret = WinQuerySystemAtomTable ();
    __FPU_CW_Restore();
    return ret;
}
#define WinQuerySystemAtomTable __FPU_CW_WinQuerySystemAtomTable

inline BOOL APIENTRY __FPU_CW_WinCloseClipbrd (HAB hab)
{
    BOOL ret = WinCloseClipbrd (hab);
    __FPU_CW_Restore();
    return ret;
}
#define WinCloseClipbrd __FPU_CW_WinCloseClipbrd

inline BOOL APIENTRY __FPU_CW_WinEmptyClipbrd (HAB hab)
{
    BOOL ret = WinEmptyClipbrd (hab);
    __FPU_CW_Restore();
    return ret;
}
#define WinEmptyClipbrd __FPU_CW_WinEmptyClipbrd

inline ULONG APIENTRY __FPU_CW_WinEnumClipbrdFmts (HAB hab, ULONG fmt)
{
    ULONG ret = WinEnumClipbrdFmts (hab, fmt);
    __FPU_CW_Restore();
    return ret;
}
#define WinEnumClipbrdFmts __FPU_CW_WinEnumClipbrdFmts

inline BOOL APIENTRY __FPU_CW_WinOpenClipbrd (HAB hab)
{
    BOOL ret = WinOpenClipbrd (hab);
    __FPU_CW_Restore();
    return ret;
}
#define WinOpenClipbrd __FPU_CW_WinOpenClipbrd

inline ULONG APIENTRY __FPU_CW_WinQueryClipbrdData (HAB hab, ULONG fmt)
{
    ULONG ret = WinQueryClipbrdData (hab, fmt);
    __FPU_CW_Restore();
    return ret;
}
#define WinQueryClipbrdData __FPU_CW_WinQueryClipbrdData

inline BOOL APIENTRY __FPU_CW_WinQueryClipbrdFmtInfo (HAB hab, ULONG fmt, PULONG prgfFmtInfo)
{
    BOOL ret = WinQueryClipbrdFmtInfo (hab, fmt, prgfFmtInfo);
    __FPU_CW_Restore();
    return ret;
}
#define WinQueryClipbrdFmtInfo __FPU_CW_WinQueryClipbrdFmtInfo

inline HWND APIENTRY __FPU_CW_WinQueryClipbrdOwner (HAB hab)
{
    HWND ret = WinQueryClipbrdOwner (hab);
    __FPU_CW_Restore();
    return ret;
}
#define WinQueryClipbrdOwner __FPU_CW_WinQueryClipbrdOwner

inline HWND APIENTRY __FPU_CW_WinQueryClipbrdViewer (HAB hab)
{
    HWND ret = WinQueryClipbrdViewer (hab);
    __FPU_CW_Restore();
    return ret;
}
#define WinQueryClipbrdViewer __FPU_CW_WinQueryClipbrdViewer

inline BOOL APIENTRY __FPU_CW_WinSetClipbrdData (HAB hab, ULONG ulData, ULONG fmt, ULONG rgfFmtInfo)
{
    BOOL ret = WinSetClipbrdData (hab, ulData, fmt, rgfFmtInfo);
    __FPU_CW_Restore();
    return ret;
}
#define WinSetClipbrdData __FPU_CW_WinSetClipbrdData

inline BOOL APIENTRY __FPU_CW_WinSetClipbrdOwner (HAB hab, HWND hwnd)
{
    BOOL ret = WinSetClipbrdOwner (hab, hwnd);
    __FPU_CW_Restore();
    return ret;
}
#define WinSetClipbrdOwner __FPU_CW_WinSetClipbrdOwner

inline BOOL APIENTRY __FPU_CW_WinSetClipbrdViewer (HAB hab, HWND hwndNewClipViewer)
{
    BOOL ret = WinSetClipbrdViewer (hab, hwndNewClipViewer);
    __FPU_CW_Restore();
    return ret;
}
#define WinSetClipbrdViewer __FPU_CW_WinSetClipbrdViewer

inline BOOL APIENTRY __FPU_CW_WinDdeInitiate (HWND hwndClient, PCSZ pszAppName, PCSZ pszTopicName,    __const__ CONVCONTEXT *pcctxt)
{
    BOOL ret = WinDdeInitiate (hwndClient, pszAppName, pszTopicName,    pcctxt);
    __FPU_CW_Restore();
    return ret;
}
#define WinDdeInitiate __FPU_CW_WinDdeInitiate

inline BOOL APIENTRY __FPU_CW_WinDdePostMsg (HWND hwndTo, HWND hwndFrom, ULONG wm,    __const__ DDESTRUCT *pddest, ULONG flOptions)
{
    BOOL ret = WinDdePostMsg (hwndTo, hwndFrom, wm,    pddest, flOptions);
    __FPU_CW_Restore();
    return ret;
}
#define WinDdePostMsg __FPU_CW_WinDdePostMsg

inline MRESULT APIENTRY __FPU_CW_WinDdeRespond (HWND hwndClient, HWND hwndServer, PCSZ pszAppName,    PCSZ pszTopicName, __const__ CONVCONTEXT *pcctxt)
{
    MRESULT ret = WinDdeRespond (hwndClient, hwndServer, pszAppName,    pszTopicName, pcctxt);
    __FPU_CW_Restore();
    return ret;
}
#define WinDdeRespond __FPU_CW_WinDdeRespond

inline ULONG APIENTRY __FPU_CW_WinCompareStrings (HAB hab, ULONG idcp, ULONG idcc, PCSZ psz1,    PCSZ psz2, ULONG reserved)
{
    ULONG ret = WinCompareStrings (hab, idcp, idcc, psz1,    psz2, reserved);
    __FPU_CW_Restore();
    return ret;
}
#define WinCompareStrings __FPU_CW_WinCompareStrings

inline UCHAR APIENTRY __FPU_CW_WinCpTranslateChar (HAB hab, ULONG cpSrc, UCHAR chSrc, ULONG cpDst)
{
    UCHAR ret = WinCpTranslateChar (hab, cpSrc, chSrc, cpDst);
    __FPU_CW_Restore();
    return ret;
}
#define WinCpTranslateChar __FPU_CW_WinCpTranslateChar

inline BOOL APIENTRY __FPU_CW_WinCpTranslateString (HAB hab, ULONG cpSrc, PCSZ pszSrc, ULONG cpDst,    ULONG cchDestMax, PSZ pchDest)
{
    BOOL ret = WinCpTranslateString (hab, cpSrc, pszSrc, cpDst,    cchDestMax, pchDest);
    __FPU_CW_Restore();
    return ret;
}
#define WinCpTranslateString __FPU_CW_WinCpTranslateString

inline PSZ APIENTRY __FPU_CW_WinNextChar (HAB hab, ULONG idcp, ULONG idcc, PCSZ psz)
{
    PSZ ret = WinNextChar (hab, idcp, idcc, psz);
    __FPU_CW_Restore();
    return ret;
}
#define WinNextChar __FPU_CW_WinNextChar

inline PSZ APIENTRY __FPU_CW_WinPrevChar (HAB hab, ULONG idcp, ULONG idcc, PCSZ pszStart,    PCSZ psz)
{
    PSZ ret = WinPrevChar (hab, idcp, idcc, pszStart,    psz);
    __FPU_CW_Restore();
    return ret;
}
#define WinPrevChar __FPU_CW_WinPrevChar

inline ULONG APIENTRY __FPU_CW_WinQueryCp (HMQ hmq)
{
    ULONG ret = WinQueryCp (hmq);
    __FPU_CW_Restore();
    return ret;
}
#define WinQueryCp __FPU_CW_WinQueryCp

inline ULONG APIENTRY __FPU_CW_WinQueryCpList (HAB hab, ULONG ccpMax, PULONG prgcp)
{
    ULONG ret = WinQueryCpList (hab, ccpMax, prgcp);
    __FPU_CW_Restore();
    return ret;
}
#define WinQueryCpList __FPU_CW_WinQueryCpList

inline BOOL APIENTRY __FPU_CW_WinSetCp (HMQ hmq, ULONG idCodePage)
{
    BOOL ret = WinSetCp (hmq, idCodePage);
    __FPU_CW_Restore();
    return ret;
}
#define WinSetCp __FPU_CW_WinSetCp

inline ULONG APIENTRY __FPU_CW_WinUpper (HAB hab, ULONG idcp, ULONG idcc, PSZ psz)
{
    ULONG ret = WinUpper (hab, idcp, idcc, psz);
    __FPU_CW_Restore();
    return ret;
}
#define WinUpper __FPU_CW_WinUpper

inline ULONG APIENTRY __FPU_CW_WinUpperChar (HAB hab, ULONG idcp, ULONG idcc, ULONG c)
{
    ULONG ret = WinUpperChar (hab, idcp, idcc, c);
    __FPU_CW_Restore();
    return ret;
}
#define WinUpperChar __FPU_CW_WinUpperChar

inline BOOL APIENTRY __FPU_CW_WinCreateCursor (HWND hwnd, LONG x, LONG y, LONG cx, LONG cy,    ULONG fs, PRECTL prclClip)
{
    BOOL ret = WinCreateCursor (hwnd, x, y, cx, cy,    fs, prclClip);
    __FPU_CW_Restore();
    return ret;
}
#define WinCreateCursor __FPU_CW_WinCreateCursor

inline BOOL APIENTRY __FPU_CW_WinDestroyCursor (HWND hwnd)
{
    BOOL ret = WinDestroyCursor (hwnd);
    __FPU_CW_Restore();
    return ret;
}
#define WinDestroyCursor __FPU_CW_WinDestroyCursor

inline BOOL APIENTRY __FPU_CW_WinShowCursor (HWND hwnd, BOOL fShow)
{
    BOOL ret = WinShowCursor (hwnd, fShow);
    __FPU_CW_Restore();
    return ret;
}
#define WinShowCursor __FPU_CW_WinShowCursor

inline BOOL APIENTRY __FPU_CW_WinQueryCursorInfo (HWND hwndDesktop, PCURSORINFO pCursorInfo)
{
    BOOL ret = WinQueryCursorInfo (hwndDesktop, pCursorInfo);
    __FPU_CW_Restore();
    return ret;
}
#define WinQueryCursorInfo __FPU_CW_WinQueryCursorInfo

inline BOOL APIENTRY __FPU_CW_WinQueryDesktopBkgnd (HWND hwndDesktop, PDESKTOP pdsk)
{
    BOOL ret = WinQueryDesktopBkgnd (hwndDesktop, pdsk);
    __FPU_CW_Restore();
    return ret;
}
#define WinQueryDesktopBkgnd __FPU_CW_WinQueryDesktopBkgnd

inline HBITMAP APIENTRY __FPU_CW_WinSetDesktopBkgnd (HWND hwndDesktop, __const__ DESKTOP *pdskNew)
{
    HBITMAP ret = WinSetDesktopBkgnd (hwndDesktop, pdskNew);
    __FPU_CW_Restore();
    return ret;
}
#define WinSetDesktopBkgnd __FPU_CW_WinSetDesktopBkgnd

inline BOOL APIENTRY __FPU_CW_WinAlarm (HWND hwndDesktop, ULONG rgfType)
{
    BOOL ret = WinAlarm (hwndDesktop, rgfType);
    __FPU_CW_Restore();
    return ret;
}
#define WinAlarm __FPU_CW_WinAlarm

inline MRESULT APIENTRY __FPU_CW_WinDefDlgProc (HWND hwndDlg, ULONG msg, MPARAM mp1, MPARAM mp2)
{
    MRESULT ret = WinDefDlgProc (hwndDlg, msg, mp1, mp2);
    __FPU_CW_Restore();
    return ret;
}
#define WinDefDlgProc __FPU_CW_WinDefDlgProc

inline BOOL APIENTRY __FPU_CW_WinDismissDlg (HWND hwndDlg, ULONG usResult)
{
    BOOL ret = WinDismissDlg (hwndDlg, usResult);
    __FPU_CW_Restore();
    return ret;
}
#define WinDismissDlg __FPU_CW_WinDismissDlg

inline ULONG APIENTRY __FPU_CW_WinDlgBox (HWND hwndParent, HWND hwndOwner, PFNWP pfnDlgProc,    HMODULE hmod, ULONG idDlg, PVOID pCreateParams)
{
    ULONG ret = WinDlgBox (hwndParent, hwndOwner, pfnDlgProc,    hmod, idDlg, pCreateParams);
    __FPU_CW_Restore();
    return ret;
}
#define WinDlgBox __FPU_CW_WinDlgBox

inline BOOL APIENTRY __FPU_CW_WinGetDlgMsg (HWND hwndDlg, PQMSG pqmsg)
{
    BOOL ret = WinGetDlgMsg (hwndDlg, pqmsg);
    __FPU_CW_Restore();
    return ret;
}
#define WinGetDlgMsg __FPU_CW_WinGetDlgMsg

inline HWND APIENTRY __FPU_CW_WinLoadDlg (HWND hwndParent, HWND hwndOwner, PFNWP pfnDlgProc,    HMODULE hmod, ULONG idDlg, PVOID pCreateParams)
{
    HWND ret = WinLoadDlg (hwndParent, hwndOwner, pfnDlgProc,    hmod, idDlg, pCreateParams);
    __FPU_CW_Restore();
    return ret;
}
#define WinLoadDlg __FPU_CW_WinLoadDlg

inline ULONG APIENTRY __FPU_CW_WinMessageBox (HWND hwndParent, HWND hwndOwner, PCSZ pszText,    PCSZ pszCaption, ULONG idWindow, ULONG flStyle)
{
    ULONG ret = WinMessageBox (hwndParent, hwndOwner, pszText,    pszCaption, idWindow, flStyle);
    __FPU_CW_Restore();
    return ret;
}
#define WinMessageBox __FPU_CW_WinMessageBox

inline ULONG APIENTRY __FPU_CW_WinMessageBox2 (HWND hwndParent, HWND hwndOwner, PCSZ pszText,    PCSZ pszCaption, ULONG idWindow, PMB2INFO pmb2info)
{
    ULONG ret = WinMessageBox2 (hwndParent, hwndOwner, pszText,    pszCaption, idWindow, pmb2info);
    __FPU_CW_Restore();
    return ret;
}
#define WinMessageBox2 __FPU_CW_WinMessageBox2

inline BOOL APIENTRY __FPU_CW_WinQueryDlgItemShort (HWND hwndDlg, ULONG idItem, PSHORT pResult,    BOOL fSigned)
{
    BOOL ret = WinQueryDlgItemShort (hwndDlg, idItem, pResult,    fSigned);
    __FPU_CW_Restore();
    return ret;
}
#define WinQueryDlgItemShort __FPU_CW_WinQueryDlgItemShort

inline ULONG APIENTRY __FPU_CW_WinQueryDlgItemText (HWND hwndDlg, ULONG idItem, LONG cchBufferMax,    PSZ pchBuffer)
{
    ULONG ret = WinQueryDlgItemText (hwndDlg, idItem, cchBufferMax,    pchBuffer);
    __FPU_CW_Restore();
    return ret;
}
#define WinQueryDlgItemText __FPU_CW_WinQueryDlgItemText

inline LONG APIENTRY __FPU_CW_WinQueryDlgItemTextLength (HWND hwndDlg, ULONG idItem)
{
    LONG ret = WinQueryDlgItemTextLength (hwndDlg, idItem);
    __FPU_CW_Restore();
    return ret;
}
#define WinQueryDlgItemTextLength __FPU_CW_WinQueryDlgItemTextLength

inline BOOL APIENTRY __FPU_CW_WinSetDlgItemShort (HWND hwndDlg, ULONG idItem, USHORT usValue,    BOOL fSigned)
{
    BOOL ret = WinSetDlgItemShort (hwndDlg, idItem, usValue,    fSigned);
    __FPU_CW_Restore();
    return ret;
}
#define WinSetDlgItemShort __FPU_CW_WinSetDlgItemShort

inline BOOL APIENTRY __FPU_CW_WinSetDlgItemText (HWND hwndDlg, ULONG idItem, PCSZ pszText)
{
    BOOL ret = WinSetDlgItemText (hwndDlg, idItem, pszText);
    __FPU_CW_Restore();
    return ret;
}
#define WinSetDlgItemText __FPU_CW_WinSetDlgItemText

inline HWND APIENTRY __FPU_CW_WinCreateDlg (HWND hwndParent, HWND hwndOwner, PFNWP pfnDlgProc,    PDLGTEMPLATE pdlgt, PVOID pCreateParams)
{
    HWND ret = WinCreateDlg (hwndParent, hwndOwner, pfnDlgProc,    pdlgt, pCreateParams);
    __FPU_CW_Restore();
    return ret;
}
#define WinCreateDlg __FPU_CW_WinCreateDlg

inline HWND APIENTRY __FPU_CW_WinEnumDlgItem (HWND hwndDlg, HWND hwnd, ULONG code)
{
    HWND ret = WinEnumDlgItem (hwndDlg, hwnd, code);
    __FPU_CW_Restore();
    return ret;
}
#define WinEnumDlgItem __FPU_CW_WinEnumDlgItem

inline BOOL APIENTRY __FPU_CW_WinMapDlgPoints (HWND hwndDlg, PPOINTL prgwptl, ULONG cwpt,    BOOL fCalcWindowCoords)
{
    BOOL ret = WinMapDlgPoints (hwndDlg, prgwptl, cwpt,    fCalcWindowCoords);
    __FPU_CW_Restore();
    return ret;
}
#define WinMapDlgPoints __FPU_CW_WinMapDlgPoints

inline ULONG APIENTRY __FPU_CW_WinProcessDlg (HWND hwndDlg)
{
    ULONG ret = WinProcessDlg (hwndDlg);
    __FPU_CW_Restore();
    return ret;
}
#define WinProcessDlg __FPU_CW_WinProcessDlg

inline MRESULT APIENTRY __FPU_CW_WinSendDlgItemMsg (HWND hwndDlg, ULONG idItem, ULONG msg,    MPARAM mp1, MPARAM mp2)
{
    MRESULT ret = WinSendDlgItemMsg (hwndDlg, idItem, msg,    mp1, mp2);
    __FPU_CW_Restore();
    return ret;
}
#define WinSendDlgItemMsg __FPU_CW_WinSendDlgItemMsg

inline LONG APIENTRY __FPU_CW_WinSubstituteStrings (HWND hwnd, PCSZ pszSrc, LONG cchDstMax,    PSZ pszDst)
{
    LONG ret = WinSubstituteStrings (hwnd, pszSrc, cchDstMax,    pszDst);
    __FPU_CW_Restore();
    return ret;
}
#define WinSubstituteStrings __FPU_CW_WinSubstituteStrings

inline ERRORID APIENTRY __FPU_CW_WinGetLastError (HAB hab)
{
    ERRORID ret = WinGetLastError (hab);
    __FPU_CW_Restore();
    return ret;
}
#define WinGetLastError __FPU_CW_WinGetLastError

inline BOOL APIENTRY __FPU_CW_WinFreeErrorInfo (PERRINFO perrinfo)
{
    BOOL ret = WinFreeErrorInfo (perrinfo);
    __FPU_CW_Restore();
    return ret;
}
#define WinFreeErrorInfo __FPU_CW_WinFreeErrorInfo

inline PERRINFO APIENTRY __FPU_CW_WinGetErrorInfo (HAB hab)
{
    PERRINFO ret = WinGetErrorInfo (hab);
    __FPU_CW_Restore();
    return ret;
}
#define WinGetErrorInfo __FPU_CW_WinGetErrorInfo

inline BOOL APIENTRY __FPU_CW_WinCallMsgFilter (HAB hab, PQMSG pqmsg, ULONG msgf)
{
    BOOL ret = WinCallMsgFilter (hab, pqmsg, msgf);
    __FPU_CW_Restore();
    return ret;
}
#define WinCallMsgFilter __FPU_CW_WinCallMsgFilter

inline BOOL APIENTRY __FPU_CW_WinReleaseHook (HAB hab, HMQ hmq, LONG iHook, PFN pfnHook, HMODULE hmod)
{
    BOOL ret = WinReleaseHook (hab, hmq, iHook, pfnHook, hmod);
    __FPU_CW_Restore();
    return ret;
}
#define WinReleaseHook __FPU_CW_WinReleaseHook

inline BOOL APIENTRY __FPU_CW_WinSetHook (HAB hab, HMQ hmq, LONG iHook, PFN pfnHook, HMODULE hmod)
{
    BOOL ret = WinSetHook (hab, hmq, iHook, pfnHook, hmod);
    __FPU_CW_Restore();
    return ret;
}
#define WinSetHook __FPU_CW_WinSetHook

inline BOOL APIENTRY __FPU_CW_WinFocusChange (HWND hwndDesktop, HWND hwndSetFocus, ULONG flFocusChange)
{
    BOOL ret = WinFocusChange (hwndDesktop, hwndSetFocus, flFocusChange);
    __FPU_CW_Restore();
    return ret;
}
#define WinFocusChange __FPU_CW_WinFocusChange

inline BOOL APIENTRY __FPU_CW_WinLockupSystem (HAB hab)
{
    BOOL ret = WinLockupSystem (hab);
    __FPU_CW_Restore();
    return ret;
}
#define WinLockupSystem __FPU_CW_WinLockupSystem

inline BOOL APIENTRY __FPU_CW_WinSetFocus (HWND hwndDesktop, HWND hwndSetFocus)
{
    BOOL ret = WinSetFocus (hwndDesktop, hwndSetFocus);
    __FPU_CW_Restore();
    return ret;
}
#define WinSetFocus __FPU_CW_WinSetFocus

inline BOOL APIENTRY __FPU_CW_WinUnlockSystem (HAB hab, PCSZ pszPassword)
{
    BOOL ret = WinUnlockSystem (hab, pszPassword);
    __FPU_CW_Restore();
    return ret;
}
#define WinUnlockSystem __FPU_CW_WinUnlockSystem

inline BOOL APIENTRY __FPU_CW_WinCheckInput (HAB hab)
{
    BOOL ret = WinCheckInput (hab);
    __FPU_CW_Restore();
    return ret;
}
#define WinCheckInput __FPU_CW_WinCheckInput

inline BOOL APIENTRY __FPU_CW_WinEnablePhysInput (HWND hwndDesktop, BOOL fEnable)
{
    BOOL ret = WinEnablePhysInput (hwndDesktop, fEnable);
    __FPU_CW_Restore();
    return ret;
}
#define WinEnablePhysInput __FPU_CW_WinEnablePhysInput

inline LONG APIENTRY __FPU_CW_WinGetKeyState (HWND hwndDesktop, LONG vkey)
{
    LONG ret = WinGetKeyState (hwndDesktop, vkey);
    __FPU_CW_Restore();
    return ret;
}
#define WinGetKeyState __FPU_CW_WinGetKeyState

inline LONG APIENTRY __FPU_CW_WinGetPhysKeyState (HWND hwndDesktop, LONG sc)
{
    LONG ret = WinGetPhysKeyState (hwndDesktop, sc);
    __FPU_CW_Restore();
    return ret;
}
#define WinGetPhysKeyState __FPU_CW_WinGetPhysKeyState

inline BOOL APIENTRY __FPU_CW_WinIsPhysInputEnabled (HWND hwndDesktop)
{
    BOOL ret = WinIsPhysInputEnabled (hwndDesktop);
    __FPU_CW_Restore();
    return ret;
}
#define WinIsPhysInputEnabled __FPU_CW_WinIsPhysInputEnabled

inline HWND APIENTRY __FPU_CW_WinQueryCapture (HWND hwndDesktop)
{
    HWND ret = WinQueryCapture (hwndDesktop);
    __FPU_CW_Restore();
    return ret;
}
#define WinQueryCapture __FPU_CW_WinQueryCapture

inline HWND APIENTRY __FPU_CW_WinQueryFocus (HWND hwndDesktop)
{
    HWND ret = WinQueryFocus (hwndDesktop);
    __FPU_CW_Restore();
    return ret;
}
#define WinQueryFocus __FPU_CW_WinQueryFocus

inline ULONG APIENTRY __FPU_CW_WinQueryVisibleRegion (HWND hwnd, HRGN hrgn)
{
    ULONG ret = WinQueryVisibleRegion (hwnd, hrgn);
    __FPU_CW_Restore();
    return ret;
}
#define WinQueryVisibleRegion __FPU_CW_WinQueryVisibleRegion

inline BOOL APIENTRY __FPU_CW_WinSetCapture (HWND hwndDesktop, HWND hwnd)
{
    BOOL ret = WinSetCapture (hwndDesktop, hwnd);
    __FPU_CW_Restore();
    return ret;
}
#define WinSetCapture __FPU_CW_WinSetCapture

inline BOOL APIENTRY __FPU_CW_WinSetKeyboardStateTable (HWND hwndDesktop, PBYTE pKeyStateTable,    BOOL fSet)
{
    BOOL ret = WinSetKeyboardStateTable (hwndDesktop, pKeyStateTable,    fSet);
    __FPU_CW_Restore();
    return ret;
}
#define WinSetKeyboardStateTable __FPU_CW_WinSetKeyboardStateTable

inline BOOL APIENTRY __FPU_CW_WinSetVisibleRegionNotify (HWND hwnd, BOOL fEnable)
{
    BOOL ret = WinSetVisibleRegionNotify (hwnd, fEnable);
    __FPU_CW_Restore();
    return ret;
}
#define WinSetVisibleRegionNotify __FPU_CW_WinSetVisibleRegionNotify

inline BOOL APIENTRY __FPU_CW_WinDeleteLibrary (HAB hab, HLIB libhandle)
{
    BOOL ret = WinDeleteLibrary (hab, libhandle);
    __FPU_CW_Restore();
    return ret;
}
#define WinDeleteLibrary __FPU_CW_WinDeleteLibrary

inline BOOL APIENTRY __FPU_CW_WinDeleteProcedure (HAB hab, PFNWP wndproc)
{
    BOOL ret = WinDeleteProcedure (hab, wndproc);
    __FPU_CW_Restore();
    return ret;
}
#define WinDeleteProcedure __FPU_CW_WinDeleteProcedure

inline HLIB APIENTRY __FPU_CW_WinLoadLibrary (HAB hab, PCSZ libname)
{
    HLIB ret = WinLoadLibrary (hab, libname);
    __FPU_CW_Restore();
    return ret;
}
#define WinLoadLibrary __FPU_CW_WinLoadLibrary

inline PFNWP APIENTRY __FPU_CW_WinLoadProcedure (HAB hab, HLIB libhandle, PSZ procname)
{
    PFNWP ret = WinLoadProcedure (hab, libhandle, procname);
    __FPU_CW_Restore();
    return ret;
}
#define WinLoadProcedure __FPU_CW_WinLoadProcedure

inline HWND APIENTRY __FPU_CW_WinCreateMenu (HWND hwndParent, CPVOID lpmt)
{
    HWND ret = WinCreateMenu (hwndParent, lpmt);
    __FPU_CW_Restore();
    return ret;
}
#define WinCreateMenu __FPU_CW_WinCreateMenu

inline HWND APIENTRY __FPU_CW_WinLoadMenu (HWND hwndFrame, HMODULE hmod, ULONG idMenu)
{
    HWND ret = WinLoadMenu (hwndFrame, hmod, idMenu);
    __FPU_CW_Restore();
    return ret;
}
#define WinLoadMenu __FPU_CW_WinLoadMenu

inline BOOL APIENTRY __FPU_CW_WinPopupMenu (HWND hwndParent, HWND hwndOwner, HWND hwndMenu,    LONG x, LONG y, LONG idItem, ULONG fs)
{
    BOOL ret = WinPopupMenu (hwndParent, hwndOwner, hwndMenu,    x, y, idItem, fs);
    __FPU_CW_Restore();
    return ret;
}
#define WinPopupMenu __FPU_CW_WinPopupMenu

inline BOOL APIENTRY __FPU_CW_WinBroadcastMsg (HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2, ULONG rgf)
{
    BOOL ret = WinBroadcastMsg (hwnd, msg, mp1, mp2, rgf);
    __FPU_CW_Restore();
    return ret;
}
#define WinBroadcastMsg __FPU_CW_WinBroadcastMsg

inline BOOL APIENTRY __FPU_CW_WinInSendMsg (HAB hab)
{
    BOOL ret = WinInSendMsg (hab);
    __FPU_CW_Restore();
    return ret;
}
#define WinInSendMsg __FPU_CW_WinInSendMsg

inline BOOL APIENTRY __FPU_CW_WinPostQueueMsg (HMQ hmq, ULONG msg, MPARAM mp1, MPARAM mp2)
{
    BOOL ret = WinPostQueueMsg (hmq, msg, mp1, mp2);
    __FPU_CW_Restore();
    return ret;
}
#define WinPostQueueMsg __FPU_CW_WinPostQueueMsg

inline BOOL APIENTRY __FPU_CW_WinQueryMsgPos (HAB hab, PPOINTL pptl)
{
    BOOL ret = WinQueryMsgPos (hab, pptl);
    __FPU_CW_Restore();
    return ret;
}
#define WinQueryMsgPos __FPU_CW_WinQueryMsgPos

inline ULONG APIENTRY __FPU_CW_WinQueryMsgTime (HAB hab)
{
    ULONG ret = WinQueryMsgTime (hab);
    __FPU_CW_Restore();
    return ret;
}
#define WinQueryMsgTime __FPU_CW_WinQueryMsgTime

inline ULONG APIENTRY __FPU_CW_WinQueryQueueStatus (HWND hwndDesktop)
{
    ULONG ret = WinQueryQueueStatus (hwndDesktop);
    __FPU_CW_Restore();
    return ret;
}
#define WinQueryQueueStatus __FPU_CW_WinQueryQueueStatus

inline ULONG APIENTRY __FPU_CW_WinRequestMutexSem (HMTX hmtx, ULONG ulTimeout)
{
    ULONG ret = WinRequestMutexSem (hmtx, ulTimeout);
    __FPU_CW_Restore();
    return ret;
}
#define WinRequestMutexSem __FPU_CW_WinRequestMutexSem

inline BOOL APIENTRY __FPU_CW_WinSetClassMsgInterest (HAB hab, PCSZ pszClassName, ULONG msg_class,    LONG control)
{
    BOOL ret = WinSetClassMsgInterest (hab, pszClassName, msg_class,    control);
    __FPU_CW_Restore();
    return ret;
}
#define WinSetClassMsgInterest __FPU_CW_WinSetClassMsgInterest

inline BOOL APIENTRY __FPU_CW_WinSetMsgInterest (HWND hwnd, ULONG msg_class, LONG control)
{
    BOOL ret = WinSetMsgInterest (hwnd, msg_class, control);
    __FPU_CW_Restore();
    return ret;
}
#define WinSetMsgInterest __FPU_CW_WinSetMsgInterest

inline ULONG APIENTRY __FPU_CW_WinWaitEventSem (HEV hev, ULONG ulTimeout)
{
    ULONG ret = WinWaitEventSem (hev, ulTimeout);
    __FPU_CW_Restore();
    return ret;
}
#define WinWaitEventSem __FPU_CW_WinWaitEventSem

inline BOOL APIENTRY __FPU_CW_WinWaitMsg (HAB hab, ULONG msgFirst, ULONG msgLast)
{
    BOOL ret = WinWaitMsg (hab, msgFirst, msgLast);
    __FPU_CW_Restore();
    return ret;
}
#define WinWaitMsg __FPU_CW_WinWaitMsg

inline ULONG APIENTRY __FPU_CW_WinWaitMuxWaitSem (HMUX hmux, ULONG ulTimeout, PULONG pulUser)
{
    ULONG ret = WinWaitMuxWaitSem (hmux, ulTimeout, pulUser);
    __FPU_CW_Restore();
    return ret;
}
#define WinWaitMuxWaitSem __FPU_CW_WinWaitMuxWaitSem

inline LONG APIENTRY __FPU_CW_WinRealizePalette (HWND hwnd, HPS hps, PULONG pcclr)
{
    LONG ret = WinRealizePalette (hwnd, hps, pcclr);
    __FPU_CW_Restore();
    return ret;
}
#define WinRealizePalette __FPU_CW_WinRealizePalette

inline HPOINTER APIENTRY __FPU_CW_WinCreatePointer (HWND hwndDesktop, HBITMAP hbmPointer, BOOL fPointer,    LONG xHotspot, LONG yHotspot)
{
    HPOINTER ret = WinCreatePointer (hwndDesktop, hbmPointer, fPointer,    xHotspot, yHotspot);
    __FPU_CW_Restore();
    return ret;
}
#define WinCreatePointer __FPU_CW_WinCreatePointer

inline HPOINTER APIENTRY __FPU_CW_WinCreatePointerIndirect (HWND hwndDesktop,    __const__ POINTERINFO *pptri)
{
    HPOINTER ret = WinCreatePointerIndirect (hwndDesktop,    pptri);
    __FPU_CW_Restore();
    return ret;
}
#define WinCreatePointerIndirect __FPU_CW_WinCreatePointerIndirect

inline BOOL APIENTRY __FPU_CW_WinDestroyPointer (HPOINTER hptr)
{
    BOOL ret = WinDestroyPointer (hptr);
    __FPU_CW_Restore();
    return ret;
}
#define WinDestroyPointer __FPU_CW_WinDestroyPointer

inline BOOL APIENTRY __FPU_CW_WinDrawPointer (HPS hps, LONG x, LONG y, HPOINTER hptr, ULONG fs)
{
    BOOL ret = WinDrawPointer (hps, x, y, hptr, fs);
    __FPU_CW_Restore();
    return ret;
}
#define WinDrawPointer __FPU_CW_WinDrawPointer

inline HBITMAP APIENTRY __FPU_CW_WinGetSysBitmap (HWND hwndDesktop, ULONG ibm)
{
    HBITMAP ret = WinGetSysBitmap (hwndDesktop, ibm);
    __FPU_CW_Restore();
    return ret;
}
#define WinGetSysBitmap __FPU_CW_WinGetSysBitmap

inline HPOINTER APIENTRY __FPU_CW_WinLoadPointer (HWND hwndDesktop, HMODULE hmod, ULONG idres)
{
    HPOINTER ret = WinLoadPointer (hwndDesktop, hmod, idres);
    __FPU_CW_Restore();
    return ret;
}
#define WinLoadPointer __FPU_CW_WinLoadPointer

inline BOOL APIENTRY __FPU_CW_WinLockPointerUpdate (HWND hwndDesktop, HPOINTER hptrNew,    ULONG ulTimeInterval)
{
    BOOL ret = WinLockPointerUpdate (hwndDesktop, hptrNew,    ulTimeInterval);
    __FPU_CW_Restore();
    return ret;
}
#define WinLockPointerUpdate __FPU_CW_WinLockPointerUpdate

inline BOOL APIENTRY __FPU_CW_WinQueryPointerPos (HWND hwndDesktop, PPOINTL pptl)
{
    BOOL ret = WinQueryPointerPos (hwndDesktop, pptl);
    __FPU_CW_Restore();
    return ret;
}
#define WinQueryPointerPos __FPU_CW_WinQueryPointerPos

inline BOOL APIENTRY __FPU_CW_WinQueryPointerInfo (HPOINTER hptr, PPOINTERINFO pPointerInfo)
{
    BOOL ret = WinQueryPointerInfo (hptr, pPointerInfo);
    __FPU_CW_Restore();
    return ret;
}
#define WinQueryPointerInfo __FPU_CW_WinQueryPointerInfo

inline HPOINTER APIENTRY __FPU_CW_WinQuerySysPointer (HWND hwndDesktop, LONG lId, BOOL fCopy)
{
    HPOINTER ret = WinQuerySysPointer (hwndDesktop, lId, fCopy);
    __FPU_CW_Restore();
    return ret;
}
#define WinQuerySysPointer __FPU_CW_WinQuerySysPointer

inline BOOL APIENTRY __FPU_CW_WinQuerySysPointerData (HWND hwndDesktop, ULONG ulId,    PICONINFO pIconInfo)
{
    BOOL ret = WinQuerySysPointerData (hwndDesktop, ulId,    pIconInfo);
    __FPU_CW_Restore();
    return ret;
}
#define WinQuerySysPointerData __FPU_CW_WinQuerySysPointerData

inline BOOL APIENTRY __FPU_CW_WinSetPointer (HWND hwndDesktop, HPOINTER hptrNew)
{
    BOOL ret = WinSetPointer (hwndDesktop, hptrNew);
    __FPU_CW_Restore();
    return ret;
}
#define WinSetPointer __FPU_CW_WinSetPointer

inline BOOL APIENTRY __FPU_CW_WinSetPointerOwner (HPOINTER hptr, PID pid, BOOL fDestroy)
{
    BOOL ret = WinSetPointerOwner (hptr, pid, fDestroy);
    __FPU_CW_Restore();
    return ret;
}
#define WinSetPointerOwner __FPU_CW_WinSetPointerOwner

inline BOOL APIENTRY __FPU_CW_WinSetPointerPos (HWND hwndDesktop, LONG x, LONG y)
{
    BOOL ret = WinSetPointerPos (hwndDesktop, x, y);
    __FPU_CW_Restore();
    return ret;
}
#define WinSetPointerPos __FPU_CW_WinSetPointerPos

inline BOOL APIENTRY __FPU_CW_WinSetSysPointerData (HWND hwndDesktop, ULONG ulId,    __const__ ICONINFO *pIconInfo)
{
    BOOL ret = WinSetSysPointerData (hwndDesktop, ulId,    pIconInfo);
    __FPU_CW_Restore();
    return ret;
}
#define WinSetSysPointerData __FPU_CW_WinSetSysPointerData

inline BOOL APIENTRY __FPU_CW_WinShowPointer (HWND hwndDesktop, BOOL fShow)
{
    BOOL ret = WinShowPointer (hwndDesktop, fShow);
    __FPU_CW_Restore();
    return ret;
}
#define WinShowPointer __FPU_CW_WinShowPointer

inline BOOL APIENTRY __FPU_CW_WinCopyRect (HAB hab, PRECTL prclDst, __const__ RECTL *prclSrc)
{
    BOOL ret = WinCopyRect (hab, prclDst, prclSrc);
    __FPU_CW_Restore();
    return ret;
}
#define WinCopyRect __FPU_CW_WinCopyRect

inline BOOL APIENTRY __FPU_CW_WinEqualRect (HAB hab, __const__ RECTL *prcl1, __const__ RECTL *prcl2)
{
    BOOL ret = WinEqualRect (hab, prcl1, prcl2);
    __FPU_CW_Restore();
    return ret;
}
#define WinEqualRect __FPU_CW_WinEqualRect

inline BOOL APIENTRY __FPU_CW_WinInflateRect (HAB hab, PRECTL prcl, LONG cx, LONG cy)
{
    BOOL ret = WinInflateRect (hab, prcl, cx, cy);
    __FPU_CW_Restore();
    return ret;
}
#define WinInflateRect __FPU_CW_WinInflateRect

inline BOOL APIENTRY __FPU_CW_WinIntersectRect (HAB hab, PRECTL prclDst, __const__ RECTL *prclSrc1,    __const__ RECTL *prclSrc2)
{
    BOOL ret = WinIntersectRect (hab, prclDst, prclSrc1,    prclSrc2);
    __FPU_CW_Restore();
    return ret;
}
#define WinIntersectRect __FPU_CW_WinIntersectRect

inline BOOL APIENTRY __FPU_CW_WinIsRectEmpty (HAB hab, __const__ RECTL *prcl)
{
    BOOL ret = WinIsRectEmpty (hab, prcl);
    __FPU_CW_Restore();
    return ret;
}
#define WinIsRectEmpty __FPU_CW_WinIsRectEmpty

inline BOOL APIENTRY __FPU_CW_WinMakePoints (HAB hab, PPOINTL pwpt, ULONG cwpt)
{
    BOOL ret = WinMakePoints (hab, pwpt, cwpt);
    __FPU_CW_Restore();
    return ret;
}
#define WinMakePoints __FPU_CW_WinMakePoints

inline BOOL APIENTRY __FPU_CW_WinMakeRect (HAB hab, PRECTL pwrc)
{
    BOOL ret = WinMakeRect (hab, pwrc);
    __FPU_CW_Restore();
    return ret;
}
#define WinMakeRect __FPU_CW_WinMakeRect

inline BOOL APIENTRY __FPU_CW_WinOffsetRect (HAB hab, PRECTL prcl, LONG cx, LONG cy)
{
    BOOL ret = WinOffsetRect (hab, prcl, cx, cy);
    __FPU_CW_Restore();
    return ret;
}
#define WinOffsetRect __FPU_CW_WinOffsetRect

inline BOOL APIENTRY __FPU_CW_WinPtInRect (HAB hab, __const__ RECTL *prcl, __const__ POINTL *pptl)
{
    BOOL ret = WinPtInRect (hab, prcl, pptl);
    __FPU_CW_Restore();
    return ret;
}
#define WinPtInRect __FPU_CW_WinPtInRect

inline BOOL APIENTRY __FPU_CW_WinSetRect (HAB hab, PRECTL prcl, LONG xLeft, LONG yBottom, LONG xRight,    LONG yTop)
{
    BOOL ret = WinSetRect (hab, prcl, xLeft, yBottom, xRight,    yTop);
    __FPU_CW_Restore();
    return ret;
}
#define WinSetRect __FPU_CW_WinSetRect

inline BOOL APIENTRY __FPU_CW_WinSetRectEmpty (HAB hab, PRECTL prcl)
{
    BOOL ret = WinSetRectEmpty (hab, prcl);
    __FPU_CW_Restore();
    return ret;
}
#define WinSetRectEmpty __FPU_CW_WinSetRectEmpty

inline BOOL APIENTRY __FPU_CW_WinSubtractRect (HAB hab, PRECTL prclDst, __const__ RECTL *prclSrc1,    __const__ RECTL *prclSrc2)
{
    BOOL ret = WinSubtractRect (hab, prclDst, prclSrc1,    prclSrc2);
    __FPU_CW_Restore();
    return ret;
}
#define WinSubtractRect __FPU_CW_WinSubtractRect

inline BOOL APIENTRY __FPU_CW_WinUnionRect (HAB hab, PRECTL prclDst, __const__ RECTL *prclSrc1,    __const__ RECTL *prclSrc2)
{
    BOOL ret = WinUnionRect (hab, prclDst, prclSrc1,    prclSrc2);
    __FPU_CW_Restore();
    return ret;
}
#define WinUnionRect __FPU_CW_WinUnionRect

inline LONG APIENTRY __FPU_CW_WinQueryControlColors (HWND hwnd, LONG clrType, ULONG flCtlColor,    ULONG cCtlColor, PCTLCOLOR pCtlColor)
{
    LONG ret = WinQueryControlColors (hwnd, clrType, flCtlColor,    cCtlColor, pCtlColor);
    __FPU_CW_Restore();
    return ret;
}
#define WinQueryControlColors __FPU_CW_WinQueryControlColors

inline ULONG APIENTRY __FPU_CW_WinQueryPresParam (HWND hwnd, ULONG id1, ULONG id2, PULONG pulId,    ULONG cbBuf, PVOID pbBuf, ULONG fs)
{
    ULONG ret = WinQueryPresParam (hwnd, id1, id2, pulId,    cbBuf, pbBuf, fs);
    __FPU_CW_Restore();
    return ret;
}
#define WinQueryPresParam __FPU_CW_WinQueryPresParam

inline LONG APIENTRY __FPU_CW_WinQuerySysColor (HWND hwndDesktop, LONG clr, LONG lReserved)
{
    LONG ret = WinQuerySysColor (hwndDesktop, clr, lReserved);
    __FPU_CW_Restore();
    return ret;
}
#define WinQuerySysColor __FPU_CW_WinQuerySysColor

inline LONG APIENTRY __FPU_CW_WinQuerySysValue (HWND hwndDesktop, LONG iSysValue)
{
    LONG ret = WinQuerySysValue (hwndDesktop, iSysValue);
    __FPU_CW_Restore();
    return ret;
}
#define WinQuerySysValue __FPU_CW_WinQuerySysValue

inline BOOL APIENTRY __FPU_CW_WinRemovePresParam (HWND hwnd, ULONG id)
{
    BOOL ret = WinRemovePresParam (hwnd, id);
    __FPU_CW_Restore();
    return ret;
}
#define WinRemovePresParam __FPU_CW_WinRemovePresParam

inline LONG APIENTRY __FPU_CW_WinSetControlColors (HWND hwnd, LONG clrType, ULONG flCtlColor,    ULONG cCtlColor, PCTLCOLOR pCtlColor)
{
    LONG ret = WinSetControlColors (hwnd, clrType, flCtlColor,    cCtlColor, pCtlColor);
    __FPU_CW_Restore();
    return ret;
}
#define WinSetControlColors __FPU_CW_WinSetControlColors

inline BOOL APIENTRY __FPU_CW_WinSetPresParam (HWND hwnd, ULONG id, ULONG cbParam, PVOID pbParam)
{
    BOOL ret = WinSetPresParam (hwnd, id, cbParam, pbParam);
    __FPU_CW_Restore();
    return ret;
}
#define WinSetPresParam __FPU_CW_WinSetPresParam

inline BOOL APIENTRY __FPU_CW_WinSetSysColors (HWND hwndDesktop, ULONG flOptions, ULONG flFormat,    LONG clrFirst, ULONG cclr, __const__ LONG *pclr)
{
    BOOL ret = WinSetSysColors (hwndDesktop, flOptions, flFormat,    clrFirst, cclr, pclr);
    __FPU_CW_Restore();
    return ret;
}
#define WinSetSysColors __FPU_CW_WinSetSysColors

inline BOOL APIENTRY __FPU_CW_WinSetSysValue (HWND hwndDesktop, LONG iSysValue, LONG lValue)
{
    BOOL ret = WinSetSysValue (hwndDesktop, iSysValue, lValue);
    __FPU_CW_Restore();
    return ret;
}
#define WinSetSysValue __FPU_CW_WinSetSysValue

inline PFN APIENTRY __FPU_CW_WinQueryClassThunkProc (PCSZ pszClassname)
{
    PFN ret = WinQueryClassThunkProc (pszClassname);
    __FPU_CW_Restore();
    return ret;
}
#define WinQueryClassThunkProc __FPU_CW_WinQueryClassThunkProc

inline LONG APIENTRY __FPU_CW_WinQueryWindowModel (HWND hwnd)
{
    LONG ret = WinQueryWindowModel (hwnd);
    __FPU_CW_Restore();
    return ret;
}
#define WinQueryWindowModel __FPU_CW_WinQueryWindowModel

inline PFN APIENTRY __FPU_CW_WinQueryWindowThunkProc (HWND hwnd)
{
    PFN ret = WinQueryWindowThunkProc (hwnd);
    __FPU_CW_Restore();
    return ret;
}
#define WinQueryWindowThunkProc __FPU_CW_WinQueryWindowThunkProc

inline BOOL APIENTRY __FPU_CW_WinSetClassThunkProc (PCSZ pszClassname, PFN pfnThunkProc)
{
    BOOL ret = WinSetClassThunkProc (pszClassname, pfnThunkProc);
    __FPU_CW_Restore();
    return ret;
}
#define WinSetClassThunkProc __FPU_CW_WinSetClassThunkProc

inline BOOL APIENTRY __FPU_CW_WinSetWindowThunkProc (HWND hwnd, PFN pfnThunkProc)
{
    BOOL ret = WinSetWindowThunkProc (hwnd, pfnThunkProc);
    __FPU_CW_Restore();
    return ret;
}
#define WinSetWindowThunkProc __FPU_CW_WinSetWindowThunkProc

inline ULONG APIENTRY  __FPU_CW_WinGetCurrentTime (HAB hab)
{
    ULONG ret = WinGetCurrentTime (hab);
    __FPU_CW_Restore();
    return ret;
}
#define WinGetCurrentTime __FPU_CW_WinGetCurrentTime

inline ULONG APIENTRY __FPU_CW_WinStartTimer (HAB hab, HWND hwnd, ULONG idTimer, ULONG dtTimeout)
{
    ULONG ret = WinStartTimer (hab, hwnd, idTimer, dtTimeout);
    __FPU_CW_Restore();
    return ret;
}
#define WinStartTimer __FPU_CW_WinStartTimer

inline BOOL APIENTRY __FPU_CW_WinStopTimer (HAB hab, HWND hwnd, ULONG idTimer)
{
    BOOL ret = WinStopTimer (hab, hwnd, idTimer);
    __FPU_CW_Restore();
    return ret;
}
#define WinStopTimer __FPU_CW_WinStopTimer

inline BOOL APIENTRY __FPU_CW_WinShowTrackRect (HWND hwnd, BOOL fShow)
{
    BOOL ret = WinShowTrackRect (hwnd, fShow);
    __FPU_CW_Restore();
    return ret;
}
#define WinShowTrackRect __FPU_CW_WinShowTrackRect

inline BOOL APIENTRY __FPU_CW_WinTrackRect (HWND hwnd, HPS hps, PTRACKINFO pti)
{
    BOOL ret = WinTrackRect (hwnd, hps, pti);
    __FPU_CW_Restore();
    return ret;
}
#define WinTrackRect __FPU_CW_WinTrackRect

inline LONG APIENTRY __FPU_CW_GpiAnimatePalette (HPAL hpal, ULONG ulFormat, ULONG ulStart,    ULONG ulCount, __const__ ULONG *aulTable)
{
    LONG ret = GpiAnimatePalette (hpal, ulFormat, ulStart,    ulCount, aulTable);
    __FPU_CW_Restore();
    return ret;
}
#define GpiAnimatePalette __FPU_CW_GpiAnimatePalette

inline BOOL APIENTRY __FPU_CW_GpiBeginArea (HPS hps, ULONG flOptions)
{
    BOOL ret = GpiBeginArea (hps, flOptions);
    __FPU_CW_Restore();
    return ret;
}
#define GpiBeginArea __FPU_CW_GpiBeginArea

inline BOOL APIENTRY __FPU_CW_GpiBeginElement (HPS hps, LONG lType, PCSZ pszDesc)
{
    BOOL ret = GpiBeginElement (hps, lType, pszDesc);
    __FPU_CW_Restore();
    return ret;
}
#define GpiBeginElement __FPU_CW_GpiBeginElement

inline BOOL APIENTRY __FPU_CW_GpiBeginPath (HPS hps, LONG lPath)
{
    BOOL ret = GpiBeginPath (hps, lPath);
    __FPU_CW_Restore();
    return ret;
}
#define GpiBeginPath __FPU_CW_GpiBeginPath

inline LONG APIENTRY __FPU_CW_GpiBox (HPS hps, LONG lControl, __const__ POINTL *pptlPoint, LONG lHRound,    LONG lVRound)
{
    LONG ret = GpiBox (hps, lControl, pptlPoint, lHRound,    lVRound);
    __FPU_CW_Restore();
    return ret;
}
#define GpiBox __FPU_CW_GpiBox

inline LONG APIENTRY __FPU_CW_GpiCallSegmentMatrix (HPS hps, LONG lSegment, LONG lCount,    __const__ MATRIXLF *pmatlfArray, LONG lOptions)
{
    LONG ret = GpiCallSegmentMatrix (hps, lSegment, lCount,    pmatlfArray, lOptions);
    __FPU_CW_Restore();
    return ret;
}
#define GpiCallSegmentMatrix __FPU_CW_GpiCallSegmentMatrix

inline LONG APIENTRY __FPU_CW_GpiCharString (HPS hps, LONG lCount, PCCH pchString)
{
    LONG ret = GpiCharString (hps, lCount, pchString);
    __FPU_CW_Restore();
    return ret;
}
#define GpiCharString __FPU_CW_GpiCharString

inline LONG APIENTRY __FPU_CW_GpiCharStringAt (HPS hps, __const__ POINTL *pptlPoint, LONG lCount,     PCCH pchString)
{
    LONG ret = GpiCharStringAt (hps, pptlPoint, lCount,     pchString);
    __FPU_CW_Restore();
    return ret;
}
#define GpiCharStringAt __FPU_CW_GpiCharStringAt

inline LONG APIENTRY __FPU_CW_GpiCharStringPos (HPS hps, __const__ RECTL *prclRect, ULONG flOptions,    LONG lCount, PCCH pchString, __const__ LONG *alAdx)
{
    LONG ret = GpiCharStringPos (hps, prclRect, flOptions,    lCount, pchString, alAdx);
    __FPU_CW_Restore();
    return ret;
}
#define GpiCharStringPos __FPU_CW_GpiCharStringPos

inline LONG APIENTRY  __FPU_CW_GpiCharStringPosAt (HPS hps, __const__ POINTL *pptlStart,    __const__ RECTL *prclRect, ULONG flOptions, LONG lCount, PCCH pchString,    __const__ LONG *alAdx)
{
    LONG ret = GpiCharStringPosAt (hps, pptlStart,    prclRect, flOptions, lCount, pchString,    alAdx);
    __FPU_CW_Restore();
    return ret;
}
#define GpiCharStringPosAt __FPU_CW_GpiCharStringPosAt

inline BOOL APIENTRY __FPU_CW_GpiCloseFigure (HPS hps)
{
    BOOL ret = GpiCloseFigure (hps);
    __FPU_CW_Restore();
    return ret;
}
#define GpiCloseFigure __FPU_CW_GpiCloseFigure

inline LONG APIENTRY __FPU_CW_GpiCombineRegion (HPS hps, HRGN hrgnDest, HRGN hrgnSrc1, HRGN hrgnSrc2,    LONG lMode)
{
    LONG ret = GpiCombineRegion (hps, hrgnDest, hrgnSrc1, hrgnSrc2,    lMode);
    __FPU_CW_Restore();
    return ret;
}
#define GpiCombineRegion __FPU_CW_GpiCombineRegion

inline BOOL APIENTRY __FPU_CW_GpiComment (HPS hps, LONG lLength, __const__ BYTE *pbData)
{
    BOOL ret = GpiComment (hps, lLength, pbData);
    __FPU_CW_Restore();
    return ret;
}
#define GpiComment __FPU_CW_GpiComment

inline BOOL APIENTRY __FPU_CW_GpiConvert (HPS hps, LONG lSrc, LONG lTarg, LONG lCount,    PPOINTL aptlPoints)
{
    BOOL ret = GpiConvert (hps, lSrc, lTarg, lCount,    aptlPoints);
    __FPU_CW_Restore();
    return ret;
}
#define GpiConvert __FPU_CW_GpiConvert

inline BOOL APIENTRY __FPU_CW_GpiConvertWithMatrix (HPS hps, LONG lCountp, PPOINTL aptlPoints,    LONG lCount, __const__ MATRIXLF *pmatlfArray)
{
    BOOL ret = GpiConvertWithMatrix (hps, lCountp, aptlPoints,    lCount, pmatlfArray);
    __FPU_CW_Restore();
    return ret;
}
#define GpiConvertWithMatrix __FPU_CW_GpiConvertWithMatrix

inline HMF APIENTRY __FPU_CW_GpiCopyMetaFile (HMF hmf)
{
    HMF ret = GpiCopyMetaFile (hmf);
    __FPU_CW_Restore();
    return ret;
}
#define GpiCopyMetaFile __FPU_CW_GpiCopyMetaFile

inline BOOL APIENTRY __FPU_CW_GpiCreateLogColorTable (HPS hps, ULONG flOptions, LONG lFormat,    LONG lStart, LONG lCount, __const__ LONG *alTable)
{
    BOOL ret = GpiCreateLogColorTable (hps, flOptions, lFormat,    lStart, lCount, alTable);
    __FPU_CW_Restore();
    return ret;
}
#define GpiCreateLogColorTable __FPU_CW_GpiCreateLogColorTable

inline LONG APIENTRY __FPU_CW_GpiCreateLogFont (HPS hps, __const__ STR8 *pName, LONG lLcid,    __const__ FATTRS *pfatAttrs)
{
    LONG ret = GpiCreateLogFont (hps, pName, lLcid,    pfatAttrs);
    __FPU_CW_Restore();
    return ret;
}
#define GpiCreateLogFont __FPU_CW_GpiCreateLogFont

inline HPAL APIENTRY __FPU_CW_GpiCreatePalette (HAB hab, ULONG flOptions, ULONG ulFormat,    ULONG ulCount, __const__ ULONG *aulTable)
{
    HPAL ret = GpiCreatePalette (hab, flOptions, ulFormat,    ulCount, aulTable);
    __FPU_CW_Restore();
    return ret;
}
#define GpiCreatePalette __FPU_CW_GpiCreatePalette

inline HRGN APIENTRY __FPU_CW_GpiCreateRegion (HPS hps, LONG lCount, __const__ RECTL *arclRectangles)
{
    HRGN ret = GpiCreateRegion (hps, lCount, arclRectangles);
    __FPU_CW_Restore();
    return ret;
}
#define GpiCreateRegion __FPU_CW_GpiCreateRegion

inline BOOL APIENTRY __FPU_CW_GpiDeleteElement (HPS hps)
{
    BOOL ret = GpiDeleteElement (hps);
    __FPU_CW_Restore();
    return ret;
}
#define GpiDeleteElement __FPU_CW_GpiDeleteElement

inline BOOL APIENTRY __FPU_CW_GpiDeleteElementRange (HPS hps, LONG lFirstElement, LONG lLastElement)
{
    BOOL ret = GpiDeleteElementRange (hps, lFirstElement, lLastElement);
    __FPU_CW_Restore();
    return ret;
}
#define GpiDeleteElementRange __FPU_CW_GpiDeleteElementRange

inline BOOL APIENTRY __FPU_CW_GpiDeleteElementsBetweenLabels (HPS hps, LONG lFirstLabel,    LONG lLastLabel)
{
    BOOL ret = GpiDeleteElementsBetweenLabels (hps, lFirstLabel,    lLastLabel);
    __FPU_CW_Restore();
    return ret;
}
#define GpiDeleteElementsBetweenLabels __FPU_CW_GpiDeleteElementsBetweenLabels

inline BOOL APIENTRY __FPU_CW_GpiDeleteMetaFile (HMF hmf)
{
    BOOL ret = GpiDeleteMetaFile (hmf);
    __FPU_CW_Restore();
    return ret;
}
#define GpiDeleteMetaFile __FPU_CW_GpiDeleteMetaFile

inline BOOL APIENTRY __FPU_CW_GpiDeletePalette (HPAL hpal)
{
    BOOL ret = GpiDeletePalette (hpal);
    __FPU_CW_Restore();
    return ret;
}
#define GpiDeletePalette __FPU_CW_GpiDeletePalette

inline BOOL APIENTRY __FPU_CW_GpiDeleteSetId (HPS hps, LONG lLcid)
{
    BOOL ret = GpiDeleteSetId (hps, lLcid);
    __FPU_CW_Restore();
    return ret;
}
#define GpiDeleteSetId __FPU_CW_GpiDeleteSetId

inline BOOL APIENTRY __FPU_CW_GpiDestroyRegion (HPS hps, HRGN hrgn)
{
    BOOL ret = GpiDestroyRegion (hps, hrgn);
    __FPU_CW_Restore();
    return ret;
}
#define GpiDestroyRegion __FPU_CW_GpiDestroyRegion

inline LONG APIENTRY __FPU_CW_GpiElement (HPS hps, LONG lType, PCSZ pszDesc, LONG lLength,    __const__ BYTE *pbData)
{
    LONG ret = GpiElement (hps, lType, pszDesc, lLength,    pbData);
    __FPU_CW_Restore();
    return ret;
}
#define GpiElement __FPU_CW_GpiElement

inline LONG APIENTRY __FPU_CW_GpiEndArea (HPS hps)
{
    LONG ret = GpiEndArea (hps);
    __FPU_CW_Restore();
    return ret;
}
#define GpiEndArea __FPU_CW_GpiEndArea

inline BOOL APIENTRY __FPU_CW_GpiEndElement (HPS hps)
{
    BOOL ret = GpiEndElement (hps);
    __FPU_CW_Restore();
    return ret;
}
#define GpiEndElement __FPU_CW_GpiEndElement

inline BOOL APIENTRY __FPU_CW_GpiEndPath (HPS hps)
{
    BOOL ret = GpiEndPath (hps);
    __FPU_CW_Restore();
    return ret;
}
#define GpiEndPath __FPU_CW_GpiEndPath

inline LONG APIENTRY __FPU_CW_GpiEqualRegion (HPS hps, HRGN hrgnSrc1, HRGN hrgnSrc2)
{
    LONG ret = GpiEqualRegion (hps, hrgnSrc1, hrgnSrc2);
    __FPU_CW_Restore();
    return ret;
}
#define GpiEqualRegion __FPU_CW_GpiEqualRegion

inline LONG APIENTRY __FPU_CW_GpiExcludeClipRectangle (HPS hps, __const__ RECTL *prclRectangle)
{
    LONG ret = GpiExcludeClipRectangle (hps, prclRectangle);
    __FPU_CW_Restore();
    return ret;
}
#define GpiExcludeClipRectangle __FPU_CW_GpiExcludeClipRectangle

inline LONG APIENTRY __FPU_CW_GpiFillPath (HPS hps, LONG lPath, LONG lOptions)
{
    LONG ret = GpiFillPath (hps, lPath, lOptions);
    __FPU_CW_Restore();
    return ret;
}
#define GpiFillPath __FPU_CW_GpiFillPath

inline LONG APIENTRY __FPU_CW_GpiFrameRegion (HPS hps, HRGN hrgn, __const__ SIZEL *thickness)
{
    LONG ret = GpiFrameRegion (hps, hrgn, thickness);
    __FPU_CW_Restore();
    return ret;
}
#define GpiFrameRegion __FPU_CW_GpiFrameRegion

inline LONG APIENTRY __FPU_CW_GpiFullArc (HPS hps, LONG lControl, FIXED fxMultiplier)
{
    LONG ret = GpiFullArc (hps, lControl, fxMultiplier);
    __FPU_CW_Restore();
    return ret;
}
#define GpiFullArc __FPU_CW_GpiFullArc

inline LONG APIENTRY __FPU_CW_GpiImage (HPS hps, LONG lFormat, __const__ SIZEL *psizlImageSize,    LONG lLength, __const__ BYTE *pbData)
{
    LONG ret = GpiImage (hps, lFormat, psizlImageSize,    lLength, pbData);
    __FPU_CW_Restore();
    return ret;
}
#define GpiImage __FPU_CW_GpiImage

inline LONG APIENTRY __FPU_CW_GpiIntersectClipRectangle (HPS hps, __const__ RECTL *prclRectangle)
{
    LONG ret = GpiIntersectClipRectangle (hps, prclRectangle);
    __FPU_CW_Restore();
    return ret;
}
#define GpiIntersectClipRectangle __FPU_CW_GpiIntersectClipRectangle

inline BOOL APIENTRY __FPU_CW_GpiLabel (HPS hps, LONG lLabel)
{
    BOOL ret = GpiLabel (hps, lLabel);
    __FPU_CW_Restore();
    return ret;
}
#define GpiLabel __FPU_CW_GpiLabel

inline LONG APIENTRY __FPU_CW_GpiLine (HPS hps, __const__ POINTL *pptlEndPoint)
{
    LONG ret = GpiLine (hps, pptlEndPoint);
    __FPU_CW_Restore();
    return ret;
}
#define GpiLine __FPU_CW_GpiLine

inline BOOL APIENTRY __FPU_CW_GpiLoadFonts (HAB hab, PCSZ pszFilename)
{
    BOOL ret = GpiLoadFonts (hab, pszFilename);
    __FPU_CW_Restore();
    return ret;
}
#define GpiLoadFonts __FPU_CW_GpiLoadFonts

inline HMF APIENTRY __FPU_CW_GpiLoadMetaFile (HAB hab, PCSZ pszFilename)
{
    HMF ret = GpiLoadMetaFile (hab, pszFilename);
    __FPU_CW_Restore();
    return ret;
}
#define GpiLoadMetaFile __FPU_CW_GpiLoadMetaFile

inline BOOL APIENTRY __FPU_CW_GpiLoadPublicFonts (HAB hab, PCSZ pszFileName)
{
    BOOL ret = GpiLoadPublicFonts (hab, pszFileName);
    __FPU_CW_Restore();
    return ret;
}
#define GpiLoadPublicFonts __FPU_CW_GpiLoadPublicFonts

inline LONG APIENTRY __FPU_CW_GpiMarker (HPS hps, __const__ POINTL *pptlPoint)
{
    LONG ret = GpiMarker (hps, pptlPoint);
    __FPU_CW_Restore();
    return ret;
}
#define GpiMarker __FPU_CW_GpiMarker

inline BOOL APIENTRY __FPU_CW_GpiModifyPath (HPS hps, LONG lPath, LONG lMode)
{
    BOOL ret = GpiModifyPath (hps, lPath, lMode);
    __FPU_CW_Restore();
    return ret;
}
#define GpiModifyPath __FPU_CW_GpiModifyPath

inline BOOL APIENTRY __FPU_CW_GpiMove (HPS hps, __const__ POINTL *pptlPoint)
{
    BOOL ret = GpiMove (hps, pptlPoint);
    __FPU_CW_Restore();
    return ret;
}
#define GpiMove __FPU_CW_GpiMove

inline LONG APIENTRY __FPU_CW_GpiOffsetClipRegion (HPS hps, __const__ POINTL *pptlPoint)
{
    LONG ret = GpiOffsetClipRegion (hps, pptlPoint);
    __FPU_CW_Restore();
    return ret;
}
#define GpiOffsetClipRegion __FPU_CW_GpiOffsetClipRegion

inline BOOL APIENTRY __FPU_CW_GpiOffsetElementPointer (HPS hps, LONG loffset)
{
    BOOL ret = GpiOffsetElementPointer (hps, loffset);
    __FPU_CW_Restore();
    return ret;
}
#define GpiOffsetElementPointer __FPU_CW_GpiOffsetElementPointer

inline BOOL APIENTRY __FPU_CW_GpiOffsetRegion (HPS hps, HRGN Hrgn, __const__ POINTL *pptlOffset)
{
    BOOL ret = GpiOffsetRegion (hps, Hrgn, pptlOffset);
    __FPU_CW_Restore();
    return ret;
}
#define GpiOffsetRegion __FPU_CW_GpiOffsetRegion

inline LONG APIENTRY __FPU_CW_GpiOutlinePath (HPS hps, LONG lPath, LONG lOptions)
{
    LONG ret = GpiOutlinePath (hps, lPath, lOptions);
    __FPU_CW_Restore();
    return ret;
}
#define GpiOutlinePath __FPU_CW_GpiOutlinePath

inline LONG APIENTRY __FPU_CW_GpiPaintRegion (HPS hps, HRGN hrgn)
{
    LONG ret = GpiPaintRegion (hps, hrgn);
    __FPU_CW_Restore();
    return ret;
}
#define GpiPaintRegion __FPU_CW_GpiPaintRegion

inline LONG APIENTRY __FPU_CW_GpiPartialArc (HPS hps, __const__ POINTL *pptlCenter, FIXED fxMultiplier,    FIXED fxStartAngle, FIXED fxSweepAngle)
{
    LONG ret = GpiPartialArc (hps, pptlCenter, fxMultiplier,    fxStartAngle, fxSweepAngle);
    __FPU_CW_Restore();
    return ret;
}
#define GpiPartialArc __FPU_CW_GpiPartialArc

inline HRGN APIENTRY __FPU_CW_GpiPathToRegion (HPS GpiH, LONG lPath, LONG lOptions)
{
    HRGN ret = GpiPathToRegion (GpiH, lPath, lOptions);
    __FPU_CW_Restore();
    return ret;
}
#define GpiPathToRegion __FPU_CW_GpiPathToRegion

inline LONG APIENTRY __FPU_CW_GpiPlayMetaFile (HPS hps, HMF hmf, LONG lCount1,    __const__ LONG *alOptarray, PLONG plSegCount, LONG lCount2, PSZ pszDesc)
{
    LONG ret = GpiPlayMetaFile (hps, hmf, lCount1,    alOptarray, plSegCount, lCount2, pszDesc);
    __FPU_CW_Restore();
    return ret;
}
#define GpiPlayMetaFile __FPU_CW_GpiPlayMetaFile

inline LONG APIENTRY __FPU_CW_GpiPointArc (HPS hps, __const__ POINTL *pptl2)
{
    LONG ret = GpiPointArc (hps, pptl2);
    __FPU_CW_Restore();
    return ret;
}
#define GpiPointArc __FPU_CW_GpiPointArc

inline LONG APIENTRY __FPU_CW_GpiPolyFillet (HPS hps, LONG lCount, __const__ POINTL *aptlPoints)
{
    LONG ret = GpiPolyFillet (hps, lCount, aptlPoints);
    __FPU_CW_Restore();
    return ret;
}
#define GpiPolyFillet __FPU_CW_GpiPolyFillet

inline LONG APIENTRY __FPU_CW_GpiPolyFilletSharp (HPS hps, LONG lCount, __const__ POINTL *aptlPoints,    __const__ FIXED *afxPoints)
{
    LONG ret = GpiPolyFilletSharp (hps, lCount, aptlPoints,    afxPoints);
    __FPU_CW_Restore();
    return ret;
}
#define GpiPolyFilletSharp __FPU_CW_GpiPolyFilletSharp

inline LONG APIENTRY __FPU_CW_GpiPolygons (HPS hps, ULONG ulCount, __const__ POLYGON *paplgn,    ULONG flOptions, ULONG flModel)
{
    LONG ret = GpiPolygons (hps, ulCount, paplgn,    flOptions, flModel);
    __FPU_CW_Restore();
    return ret;
}
#define GpiPolygons __FPU_CW_GpiPolygons

inline LONG APIENTRY __FPU_CW_GpiPolyLine (HPS hps, LONG lCount, __const__ POINTL *aptlPoints)
{
    LONG ret = GpiPolyLine (hps, lCount, aptlPoints);
    __FPU_CW_Restore();
    return ret;
}
#define GpiPolyLine __FPU_CW_GpiPolyLine

inline LONG APIENTRY __FPU_CW_GpiPolyLineDisjoint (HPS hps, LONG lCount, __const__ POINTL *aptlPoints)
{
    LONG ret = GpiPolyLineDisjoint (hps, lCount, aptlPoints);
    __FPU_CW_Restore();
    return ret;
}
#define GpiPolyLineDisjoint __FPU_CW_GpiPolyLineDisjoint

inline LONG APIENTRY __FPU_CW_GpiPolyMarker (HPS hps, LONG lCount, __const__ POINTL *aptlPoints)
{
    LONG ret = GpiPolyMarker (hps, lCount, aptlPoints);
    __FPU_CW_Restore();
    return ret;
}
#define GpiPolyMarker __FPU_CW_GpiPolyMarker

inline LONG APIENTRY __FPU_CW_GpiPolySpline (HPS hps, LONG lCount, __const__ POINTL *aptlPoints)
{
    LONG ret = GpiPolySpline (hps, lCount, aptlPoints);
    __FPU_CW_Restore();
    return ret;
}
#define GpiPolySpline __FPU_CW_GpiPolySpline

inline BOOL APIENTRY __FPU_CW_GpiPop (HPS hps, LONG lCount)
{
    BOOL ret = GpiPop (hps, lCount);
    __FPU_CW_Restore();
    return ret;
}
#define GpiPop __FPU_CW_GpiPop

inline LONG APIENTRY __FPU_CW_GpiPtInRegion (HPS hps, HRGN hrgn, __const__ POINTL *pptlPoint)
{
    LONG ret = GpiPtInRegion (hps, hrgn, pptlPoint);
    __FPU_CW_Restore();
    return ret;
}
#define GpiPtInRegion __FPU_CW_GpiPtInRegion

inline LONG APIENTRY __FPU_CW_GpiPtVisible (HPS hps, __const__ POINTL *pptlPoint)
{
    LONG ret = GpiPtVisible (hps, pptlPoint);
    __FPU_CW_Restore();
    return ret;
}
#define GpiPtVisible __FPU_CW_GpiPtVisible

inline BOOL APIENTRY __FPU_CW_GpiQueryArcParams (HPS hps, PARCPARAMS parcpArcParams)
{
    BOOL ret = GpiQueryArcParams (hps, parcpArcParams);
    __FPU_CW_Restore();
    return ret;
}
#define GpiQueryArcParams __FPU_CW_GpiQueryArcParams

inline LONG APIENTRY __FPU_CW_GpiQueryAttrMode (HPS hps)
{
    LONG ret = GpiQueryAttrMode (hps);
    __FPU_CW_Restore();
    return ret;
}
#define GpiQueryAttrMode __FPU_CW_GpiQueryAttrMode

inline LONG APIENTRY __FPU_CW_GpiQueryAttrs (HPS hps, LONG lPrimType, ULONG flAttrMask,    PBUNDLE ppbunAttrs)
{
    LONG ret = GpiQueryAttrs (hps, lPrimType, flAttrMask,    ppbunAttrs);
    __FPU_CW_Restore();
    return ret;
}
#define GpiQueryAttrs __FPU_CW_GpiQueryAttrs

inline LONG APIENTRY __FPU_CW_GpiQueryBackColor (HPS hps)
{
    LONG ret = GpiQueryBackColor (hps);
    __FPU_CW_Restore();
    return ret;
}
#define GpiQueryBackColor __FPU_CW_GpiQueryBackColor

inline LONG APIENTRY __FPU_CW_GpiQueryBackMix (HPS hps)
{
    LONG ret = GpiQueryBackMix (hps);
    __FPU_CW_Restore();
    return ret;
}
#define GpiQueryBackMix __FPU_CW_GpiQueryBackMix

inline BOOL APIENTRY __FPU_CW_GpiQueryCharAngle (HPS hps, PGRADIENTL pgradlAngle)
{
    BOOL ret = GpiQueryCharAngle (hps, pgradlAngle);
    __FPU_CW_Restore();
    return ret;
}
#define GpiQueryCharAngle __FPU_CW_GpiQueryCharAngle

inline BOOL APIENTRY __FPU_CW_GpiQueryCharBox (HPS hps, PSIZEF psizfxSize)
{
    BOOL ret = GpiQueryCharBox (hps, psizfxSize);
    __FPU_CW_Restore();
    return ret;
}
#define GpiQueryCharBox __FPU_CW_GpiQueryCharBox

inline BOOL APIENTRY __FPU_CW_GpiQueryCharBreakExtra (HPS hps, PFIXED BreakExtra)
{
    BOOL ret = GpiQueryCharBreakExtra (hps, BreakExtra);
    __FPU_CW_Restore();
    return ret;
}
#define GpiQueryCharBreakExtra __FPU_CW_GpiQueryCharBreakExtra

inline LONG APIENTRY __FPU_CW_GpiQueryCharDirection (HPS hps)
{
    LONG ret = GpiQueryCharDirection (hps);
    __FPU_CW_Restore();
    return ret;
}
#define GpiQueryCharDirection __FPU_CW_GpiQueryCharDirection

inline BOOL APIENTRY __FPU_CW_GpiQueryCharExtra (HPS hps, PFIXED Extra)
{
    BOOL ret = GpiQueryCharExtra (hps, Extra);
    __FPU_CW_Restore();
    return ret;
}
#define GpiQueryCharExtra __FPU_CW_GpiQueryCharExtra

inline LONG APIENTRY __FPU_CW_GpiQueryCharMode (HPS hps)
{
    LONG ret = GpiQueryCharMode (hps);
    __FPU_CW_Restore();
    return ret;
}
#define GpiQueryCharMode __FPU_CW_GpiQueryCharMode

inline LONG APIENTRY __FPU_CW_GpiQueryCharSet (HPS hps)
{
    LONG ret = GpiQueryCharSet (hps);
    __FPU_CW_Restore();
    return ret;
}
#define GpiQueryCharSet __FPU_CW_GpiQueryCharSet

inline BOOL APIENTRY __FPU_CW_GpiQueryCharShear (HPS hps, PPOINTL pptlShear)
{
    BOOL ret = GpiQueryCharShear (hps, pptlShear);
    __FPU_CW_Restore();
    return ret;
}
#define GpiQueryCharShear __FPU_CW_GpiQueryCharShear

inline BOOL APIENTRY __FPU_CW_GpiQueryCharStringPos (HPS hps, ULONG flOptions, LONG lCount,    PCCH pchString, PLONG alXincrements, PPOINTL aptlPositions)
{
    BOOL ret = GpiQueryCharStringPos (hps, flOptions, lCount,    pchString, alXincrements, aptlPositions);
    __FPU_CW_Restore();
    return ret;
}
#define GpiQueryCharStringPos __FPU_CW_GpiQueryCharStringPos

inline BOOL APIENTRY __FPU_CW_GpiQueryCharStringPosAt (HPS hps, PPOINTL pptlStart, ULONG flOptions,    LONG lCount, PCCH pchString, PLONG alXincrements, PPOINTL aptlPositions)
{
    BOOL ret = GpiQueryCharStringPosAt (hps, pptlStart, flOptions,    lCount, pchString, alXincrements, aptlPositions);
    __FPU_CW_Restore();
    return ret;
}
#define GpiQueryCharStringPosAt __FPU_CW_GpiQueryCharStringPosAt

inline LONG APIENTRY __FPU_CW_GpiQueryClipBox (HPS hps, PRECTL prclBound)
{
    LONG ret = GpiQueryClipBox (hps, prclBound);
    __FPU_CW_Restore();
    return ret;
}
#define GpiQueryClipBox __FPU_CW_GpiQueryClipBox

inline HRGN APIENTRY __FPU_CW_GpiQueryClipRegion (HPS hps)
{
    HRGN ret = GpiQueryClipRegion (hps);
    __FPU_CW_Restore();
    return ret;
}
#define GpiQueryClipRegion __FPU_CW_GpiQueryClipRegion

inline LONG APIENTRY __FPU_CW_GpiQueryColor (HPS hps)
{
    LONG ret = GpiQueryColor (hps);
    __FPU_CW_Restore();
    return ret;
}
#define GpiQueryColor __FPU_CW_GpiQueryColor

inline BOOL APIENTRY __FPU_CW_GpiQueryColorData (HPS hps, LONG lCount, PLONG alArray)
{
    BOOL ret = GpiQueryColorData (hps, lCount, alArray);
    __FPU_CW_Restore();
    return ret;
}
#define GpiQueryColorData __FPU_CW_GpiQueryColorData

inline LONG APIENTRY __FPU_CW_GpiQueryColorIndex (HPS hps, ULONG flOptions, LONG lRgbColor)
{
    LONG ret = GpiQueryColorIndex (hps, flOptions, lRgbColor);
    __FPU_CW_Restore();
    return ret;
}
#define GpiQueryColorIndex __FPU_CW_GpiQueryColorIndex

inline ULONG APIENTRY __FPU_CW_GpiQueryCp (HPS hps)
{
    ULONG ret = GpiQueryCp (hps);
    __FPU_CW_Restore();
    return ret;
}
#define GpiQueryCp __FPU_CW_GpiQueryCp

inline BOOL APIENTRY __FPU_CW_GpiQueryCurrentPosition (HPS hps, PPOINTL pptlPoint)
{
    BOOL ret = GpiQueryCurrentPosition (hps, pptlPoint);
    __FPU_CW_Restore();
    return ret;
}
#define GpiQueryCurrentPosition __FPU_CW_GpiQueryCurrentPosition

inline BOOL APIENTRY __FPU_CW_GpiQueryDefArcParams (HPS hps, PARCPARAMS parcpArcParams)
{
    BOOL ret = GpiQueryDefArcParams (hps, parcpArcParams);
    __FPU_CW_Restore();
    return ret;
}
#define GpiQueryDefArcParams __FPU_CW_GpiQueryDefArcParams

inline BOOL APIENTRY __FPU_CW_GpiQueryDefAttrs (HPS hps, LONG lPrimType, ULONG flAttrMask,    PBUNDLE ppbunAttrs)
{
    BOOL ret = GpiQueryDefAttrs (hps, lPrimType, flAttrMask,    ppbunAttrs);
    __FPU_CW_Restore();
    return ret;
}
#define GpiQueryDefAttrs __FPU_CW_GpiQueryDefAttrs

inline BOOL APIENTRY __FPU_CW_GpiQueryDefCharBox (HPS hps, PSIZEL psizlSize)
{
    BOOL ret = GpiQueryDefCharBox (hps, psizlSize);
    __FPU_CW_Restore();
    return ret;
}
#define GpiQueryDefCharBox __FPU_CW_GpiQueryDefCharBox

inline BOOL APIENTRY __FPU_CW_GpiQueryDefTag (HPS hps, PLONG plTag)
{
    BOOL ret = GpiQueryDefTag (hps, plTag);
    __FPU_CW_Restore();
    return ret;
}
#define GpiQueryDefTag __FPU_CW_GpiQueryDefTag

inline BOOL APIENTRY __FPU_CW_GpiQueryDefViewingLimits (HPS hps, PRECTL prclLimits)
{
    BOOL ret = GpiQueryDefViewingLimits (hps, prclLimits);
    __FPU_CW_Restore();
    return ret;
}
#define GpiQueryDefViewingLimits __FPU_CW_GpiQueryDefViewingLimits

inline BOOL APIENTRY __FPU_CW_GpiQueryDefaultViewMatrix (HPS hps, LONG lCount, PMATRIXLF pmatlfArray)
{
    BOOL ret = GpiQueryDefaultViewMatrix (hps, lCount, pmatlfArray);
    __FPU_CW_Restore();
    return ret;
}
#define GpiQueryDefaultViewMatrix __FPU_CW_GpiQueryDefaultViewMatrix

inline LONG APIENTRY __FPU_CW_GpiQueryEditMode (HPS hps)
{
    LONG ret = GpiQueryEditMode (hps);
    __FPU_CW_Restore();
    return ret;
}
#define GpiQueryEditMode __FPU_CW_GpiQueryEditMode

inline LONG APIENTRY __FPU_CW_GpiQueryElement (HPS hps, LONG lOff, LONG lMaxLength, PBYTE pbData)
{
    LONG ret = GpiQueryElement (hps, lOff, lMaxLength, pbData);
    __FPU_CW_Restore();
    return ret;
}
#define GpiQueryElement __FPU_CW_GpiQueryElement

inline LONG APIENTRY __FPU_CW_GpiQueryElementPointer (HPS hps)
{
    LONG ret = GpiQueryElementPointer (hps);
    __FPU_CW_Restore();
    return ret;
}
#define GpiQueryElementPointer __FPU_CW_GpiQueryElementPointer

inline LONG APIENTRY __FPU_CW_GpiQueryElementType (HPS hps, PLONG plType, LONG lLength, PSZ pszData)
{
    LONG ret = GpiQueryElementType (hps, plType, lLength, pszData);
    __FPU_CW_Restore();
    return ret;
}
#define GpiQueryElementType __FPU_CW_GpiQueryElementType

inline ULONG APIENTRY __FPU_CW_GpiQueryFaceString (HPS PS, PCSZ FamilyName, PFACENAMEDESC attrs,    LONG length, PSZ CompoundFaceName)
{
    ULONG ret = GpiQueryFaceString (PS, FamilyName, attrs,    length, CompoundFaceName);
    __FPU_CW_Restore();
    return ret;
}
#define GpiQueryFaceString __FPU_CW_GpiQueryFaceString

inline ULONG APIENTRY __FPU_CW_GpiQueryFontAction (HAB anchor, ULONG options)
{
    ULONG ret = GpiQueryFontAction (anchor, options);
    __FPU_CW_Restore();
    return ret;
}
#define GpiQueryFontAction __FPU_CW_GpiQueryFontAction

inline LONG APIENTRY __FPU_CW_GpiQueryFontFileDescriptions (HAB hab, PCSZ pszFilename, PLONG plCount,    PFFDESCS affdescsNames)
{
    LONG ret = GpiQueryFontFileDescriptions (hab, pszFilename, plCount,    affdescsNames);
    __FPU_CW_Restore();
    return ret;
}
#define GpiQueryFontFileDescriptions __FPU_CW_GpiQueryFontFileDescriptions

inline BOOL APIENTRY __FPU_CW_GpiQueryFontMetrics (HPS hps, LONG lMetricsLength,    PFONTMETRICS pfmMetrics)
{
    BOOL ret = GpiQueryFontMetrics (hps, lMetricsLength,    pfmMetrics);
    __FPU_CW_Restore();
    return ret;
}
#define GpiQueryFontMetrics __FPU_CW_GpiQueryFontMetrics

inline LONG APIENTRY __FPU_CW_GpiQueryFonts (HPS hps, ULONG flOptions, PCSZ pszFacename,    PLONG plReqFonts, LONG lMetricsLength, PFONTMETRICS afmMetrics)
{
    LONG ret = GpiQueryFonts (hps, flOptions, pszFacename,    plReqFonts, lMetricsLength, afmMetrics);
    __FPU_CW_Restore();
    return ret;
}
#define GpiQueryFonts __FPU_CW_GpiQueryFonts

inline LONG APIENTRY __FPU_CW_GpiQueryFullFontFileDescs (HAB hab, PCSZ pszFilename, PLONG plCount,    PVOID pNames, PLONG plNamesBuffLength)
{
    LONG ret = GpiQueryFullFontFileDescs (hab, pszFilename, plCount,    pNames, plNamesBuffLength);
    __FPU_CW_Restore();
    return ret;
}
#define GpiQueryFullFontFileDescs __FPU_CW_GpiQueryFullFontFileDescs

inline BOOL APIENTRY __FPU_CW_GpiQueryGraphicsField (HPS hps, PRECTL prclField)
{
    BOOL ret = GpiQueryGraphicsField (hps, prclField);
    __FPU_CW_Restore();
    return ret;
}
#define GpiQueryGraphicsField __FPU_CW_GpiQueryGraphicsField

inline LONG APIENTRY __FPU_CW_GpiQueryKerningPairs (HPS hps, LONG lCount, PKERNINGPAIRS akrnprData)
{
    LONG ret = GpiQueryKerningPairs (hps, lCount, akrnprData);
    __FPU_CW_Restore();
    return ret;
}
#define GpiQueryKerningPairs __FPU_CW_GpiQueryKerningPairs

inline LONG APIENTRY __FPU_CW_GpiQueryLineEnd (HPS hps)
{
    LONG ret = GpiQueryLineEnd (hps);
    __FPU_CW_Restore();
    return ret;
}
#define GpiQueryLineEnd __FPU_CW_GpiQueryLineEnd

inline LONG APIENTRY __FPU_CW_GpiQueryLineJoin (HPS hps)
{
    LONG ret = GpiQueryLineJoin (hps);
    __FPU_CW_Restore();
    return ret;
}
#define GpiQueryLineJoin __FPU_CW_GpiQueryLineJoin

inline LONG APIENTRY __FPU_CW_GpiQueryLineType (HPS hps)
{
    LONG ret = GpiQueryLineType (hps);
    __FPU_CW_Restore();
    return ret;
}
#define GpiQueryLineType __FPU_CW_GpiQueryLineType

inline FIXED APIENTRY __FPU_CW_GpiQueryLineWidth (HPS hps)
{
    FIXED ret = GpiQueryLineWidth (hps);
    __FPU_CW_Restore();
    return ret;
}
#define GpiQueryLineWidth __FPU_CW_GpiQueryLineWidth

inline LONG APIENTRY __FPU_CW_GpiQueryLineWidthGeom (HPS hps)
{
    LONG ret = GpiQueryLineWidthGeom (hps);
    __FPU_CW_Restore();
    return ret;
}
#define GpiQueryLineWidthGeom __FPU_CW_GpiQueryLineWidthGeom

inline LONG APIENTRY __FPU_CW_GpiQueryLogColorTable (HPS hps, ULONG flOptions, LONG lStart, LONG lCount,    PLONG alArray)
{
    LONG ret = GpiQueryLogColorTable (hps, flOptions, lStart, lCount,    alArray);
    __FPU_CW_Restore();
    return ret;
}
#define GpiQueryLogColorTable __FPU_CW_GpiQueryLogColorTable

inline BOOL APIENTRY __FPU_CW_GpiQueryLogicalFont (HPS PS, LONG lcid, PSTR8 name, PFATTRS attrs,    LONG length)
{
    BOOL ret = GpiQueryLogicalFont (PS, lcid, name, attrs,    length);
    __FPU_CW_Restore();
    return ret;
}
#define GpiQueryLogicalFont __FPU_CW_GpiQueryLogicalFont

inline LONG APIENTRY __FPU_CW_GpiQueryMarker (HPS hps)
{
    LONG ret = GpiQueryMarker (hps);
    __FPU_CW_Restore();
    return ret;
}
#define GpiQueryMarker __FPU_CW_GpiQueryMarker

inline BOOL APIENTRY __FPU_CW_GpiQueryMarkerBox (HPS hps, PSIZEF psizfxSize)
{
    BOOL ret = GpiQueryMarkerBox (hps, psizfxSize);
    __FPU_CW_Restore();
    return ret;
}
#define GpiQueryMarkerBox __FPU_CW_GpiQueryMarkerBox

inline LONG APIENTRY __FPU_CW_GpiQueryMarkerSet (HPS hps)
{
    LONG ret = GpiQueryMarkerSet (hps);
    __FPU_CW_Restore();
    return ret;
}
#define GpiQueryMarkerSet __FPU_CW_GpiQueryMarkerSet

inline BOOL APIENTRY __FPU_CW_GpiQueryMetaFileBits (HMF hmf, LONG lOffset, LONG lLength, PBYTE pbData)
{
    BOOL ret = GpiQueryMetaFileBits (hmf, lOffset, lLength, pbData);
    __FPU_CW_Restore();
    return ret;
}
#define GpiQueryMetaFileBits __FPU_CW_GpiQueryMetaFileBits

inline LONG APIENTRY __FPU_CW_GpiQueryMetaFileLength (HMF hmf)
{
    LONG ret = GpiQueryMetaFileLength (hmf);
    __FPU_CW_Restore();
    return ret;
}
#define GpiQueryMetaFileLength __FPU_CW_GpiQueryMetaFileLength

inline LONG APIENTRY __FPU_CW_GpiQueryMix (HPS hps)
{
    LONG ret = GpiQueryMix (hps);
    __FPU_CW_Restore();
    return ret;
}
#define GpiQueryMix __FPU_CW_GpiQueryMix

inline BOOL APIENTRY __FPU_CW_GpiQueryModelTransformMatrix (HPS hps, LONG lCount,    PMATRIXLF pmatlfArray)
{
    BOOL ret = GpiQueryModelTransformMatrix (hps, lCount,    pmatlfArray);
    __FPU_CW_Restore();
    return ret;
}
#define GpiQueryModelTransformMatrix __FPU_CW_GpiQueryModelTransformMatrix

inline LONG APIENTRY __FPU_CW_GpiQueryNearestColor (HPS hps, ULONG flOptions, LONG lRgbIn)
{
    LONG ret = GpiQueryNearestColor (hps, flOptions, lRgbIn);
    __FPU_CW_Restore();
    return ret;
}
#define GpiQueryNearestColor __FPU_CW_GpiQueryNearestColor

inline LONG APIENTRY __FPU_CW_GpiQueryNumberSetIds (HPS hps)
{
    LONG ret = GpiQueryNumberSetIds (hps);
    __FPU_CW_Restore();
    return ret;
}
#define GpiQueryNumberSetIds __FPU_CW_GpiQueryNumberSetIds

inline BOOL APIENTRY __FPU_CW_GpiQueryPageViewport (HPS hps, PRECTL prclViewport)
{
    BOOL ret = GpiQueryPageViewport (hps, prclViewport);
    __FPU_CW_Restore();
    return ret;
}
#define GpiQueryPageViewport __FPU_CW_GpiQueryPageViewport

inline HPAL APIENTRY __FPU_CW_GpiQueryPalette (HPS hps)
{
    HPAL ret = GpiQueryPalette (hps);
    __FPU_CW_Restore();
    return ret;
}
#define GpiQueryPalette __FPU_CW_GpiQueryPalette

inline LONG APIENTRY __FPU_CW_GpiQueryPaletteInfo (HPAL hpal, HPS  hps, ULONG flOptions,    ULONG ulStart, ULONG ulCount, PULONG aulArray)
{
    LONG ret = GpiQueryPaletteInfo (hpal, hps, flOptions,    ulStart, ulCount, aulArray);
    __FPU_CW_Restore();
    return ret;
}
#define GpiQueryPaletteInfo __FPU_CW_GpiQueryPaletteInfo

inline LONG APIENTRY __FPU_CW_GpiQueryPattern (HPS hps)
{
    LONG ret = GpiQueryPattern (hps);
    __FPU_CW_Restore();
    return ret;
}
#define GpiQueryPattern __FPU_CW_GpiQueryPattern

inline BOOL APIENTRY __FPU_CW_GpiQueryPatternRefPoint (HPS hps, PPOINTL pptlRefPoint)
{
    BOOL ret = GpiQueryPatternRefPoint (hps, pptlRefPoint);
    __FPU_CW_Restore();
    return ret;
}
#define GpiQueryPatternRefPoint __FPU_CW_GpiQueryPatternRefPoint

inline LONG APIENTRY __FPU_CW_GpiQueryPatternSet (HPS hps)
{
    LONG ret = GpiQueryPatternSet (hps);
    __FPU_CW_Restore();
    return ret;
}
#define GpiQueryPatternSet __FPU_CW_GpiQueryPatternSet

inline LONG APIENTRY __FPU_CW_GpiQueryRealColors (HPS hps, ULONG flOptions, LONG lStart, LONG lCount,    PLONG alColors)
{
    LONG ret = GpiQueryRealColors (hps, flOptions, lStart, lCount,    alColors);
    __FPU_CW_Restore();
    return ret;
}
#define GpiQueryRealColors __FPU_CW_GpiQueryRealColors

inline LONG APIENTRY __FPU_CW_GpiQueryRegionBox (HPS hps, HRGN hrgn, PRECTL prclBound)
{
    LONG ret = GpiQueryRegionBox (hps, hrgn, prclBound);
    __FPU_CW_Restore();
    return ret;
}
#define GpiQueryRegionBox __FPU_CW_GpiQueryRegionBox

inline BOOL APIENTRY __FPU_CW_GpiQueryRegionRects (HPS hps, HRGN hrgn, PRECTL prclBound,    PRGNRECT prgnrcControl, PRECTL prclRect)
{
    BOOL ret = GpiQueryRegionRects (hps, hrgn, prclBound,    prgnrcControl, prclRect);
    __FPU_CW_Restore();
    return ret;
}
#define GpiQueryRegionRects __FPU_CW_GpiQueryRegionRects

inline LONG APIENTRY __FPU_CW_GpiQueryRGBColor (HPS hps, ULONG flOptions, LONG lColorIndex)
{
    LONG ret = GpiQueryRGBColor (hps, flOptions, lColorIndex);
    __FPU_CW_Restore();
    return ret;
}
#define GpiQueryRGBColor __FPU_CW_GpiQueryRGBColor

inline BOOL APIENTRY __FPU_CW_GpiQuerySegmentTransformMatrix (HPS hps, LONG lSegid, LONG lCount,    PMATRIXLF pmatlfArray)
{
    BOOL ret = GpiQuerySegmentTransformMatrix (hps, lSegid, lCount,    pmatlfArray);
    __FPU_CW_Restore();
    return ret;
}
#define GpiQuerySegmentTransformMatrix __FPU_CW_GpiQuerySegmentTransformMatrix

inline BOOL APIENTRY __FPU_CW_GpiQuerySetIds (HPS hps, LONG lCount, PLONG alTypes, PSTR8 aNames,    PLONG allcids)
{
    BOOL ret = GpiQuerySetIds (hps, lCount, alTypes, aNames,    allcids);
    __FPU_CW_Restore();
    return ret;
}
#define GpiQuerySetIds __FPU_CW_GpiQuerySetIds

inline BOOL APIENTRY __FPU_CW_GpiQueryTextAlignment (HPS hps, PLONG plHoriz, PLONG plVert)
{
    BOOL ret = GpiQueryTextAlignment (hps, plHoriz, plVert);
    __FPU_CW_Restore();
    return ret;
}
#define GpiQueryTextAlignment __FPU_CW_GpiQueryTextAlignment

inline BOOL APIENTRY __FPU_CW_GpiQueryTextBox (HPS hps, LONG lCount1, PCH pchString, LONG lCount2,    PPOINTL aptlPoints)
{
    BOOL ret = GpiQueryTextBox (hps, lCount1, pchString, lCount2,    aptlPoints);
    __FPU_CW_Restore();
    return ret;
}
#define GpiQueryTextBox __FPU_CW_GpiQueryTextBox

inline BOOL APIENTRY __FPU_CW_GpiQueryViewingLimits (HPS hps, PRECTL prclLimits)
{
    BOOL ret = GpiQueryViewingLimits (hps, prclLimits);
    __FPU_CW_Restore();
    return ret;
}
#define GpiQueryViewingLimits __FPU_CW_GpiQueryViewingLimits

inline BOOL APIENTRY __FPU_CW_GpiQueryViewingTransformMatrix (HPS hps, LONG lCount,    PMATRIXLF pmatlfArray)
{
    BOOL ret = GpiQueryViewingTransformMatrix (hps, lCount,    pmatlfArray);
    __FPU_CW_Restore();
    return ret;
}
#define GpiQueryViewingTransformMatrix __FPU_CW_GpiQueryViewingTransformMatrix

inline BOOL APIENTRY __FPU_CW_GpiQueryWidthTable (HPS hps, LONG lFirstChar, LONG lCount, PLONG alData)
{
    BOOL ret = GpiQueryWidthTable (hps, lFirstChar, lCount, alData);
    __FPU_CW_Restore();
    return ret;
}
#define GpiQueryWidthTable __FPU_CW_GpiQueryWidthTable

inline LONG APIENTRY __FPU_CW_GpiRectInRegion (HPS hps, HRGN hrgn, __const__ RECTL *prclRect)
{
    LONG ret = GpiRectInRegion (hps, hrgn, prclRect);
    __FPU_CW_Restore();
    return ret;
}
#define GpiRectInRegion __FPU_CW_GpiRectInRegion

inline LONG APIENTRY __FPU_CW_GpiRectVisible (HPS hps, __const__ RECTL *prclRectangle)
{
    LONG ret = GpiRectVisible (hps, prclRectangle);
    __FPU_CW_Restore();
    return ret;
}
#define GpiRectVisible __FPU_CW_GpiRectVisible

inline BOOL APIENTRY __FPU_CW_GpiRotate (HPS hps, PMATRIXLF pmatlfArray, LONG lOptions, FIXED fxAngle,    __const__ POINTL *pptlCenter)
{
    BOOL ret = GpiRotate (hps, pmatlfArray, lOptions, fxAngle,    pptlCenter);
    __FPU_CW_Restore();
    return ret;
}
#define GpiRotate __FPU_CW_GpiRotate

inline BOOL APIENTRY __FPU_CW_GpiSaveMetaFile (HMF hmf, PCSZ pszFilename)
{
    BOOL ret = GpiSaveMetaFile (hmf, pszFilename);
    __FPU_CW_Restore();
    return ret;
}
#define GpiSaveMetaFile __FPU_CW_GpiSaveMetaFile

inline BOOL APIENTRY __FPU_CW_GpiScale (HPS hps, PMATRIXLF pmfatlfArray, LONG lOptions,    __const__ FIXED *afxScale, __const__ POINTL *pptlCenter)
{
    BOOL ret = GpiScale (hps, pmfatlfArray, lOptions,    afxScale, pptlCenter);
    __FPU_CW_Restore();
    return ret;
}
#define GpiScale __FPU_CW_GpiScale

inline HPAL APIENTRY __FPU_CW_GpiSelectPalette (HPS hps, HPAL hpal)
{
    HPAL ret = GpiSelectPalette (hps, hpal);
    __FPU_CW_Restore();
    return ret;
}
#define GpiSelectPalette __FPU_CW_GpiSelectPalette

inline BOOL APIENTRY __FPU_CW_GpiSetArcParams (HPS hps, __const__ ARCPARAMS *parcpArcParams)
{
    BOOL ret = GpiSetArcParams (hps, parcpArcParams);
    __FPU_CW_Restore();
    return ret;
}
#define GpiSetArcParams __FPU_CW_GpiSetArcParams

inline BOOL APIENTRY __FPU_CW_GpiSetAttrMode (HPS hps, LONG lMode)
{
    BOOL ret = GpiSetAttrMode (hps, lMode);
    __FPU_CW_Restore();
    return ret;
}
#define GpiSetAttrMode __FPU_CW_GpiSetAttrMode

inline BOOL APIENTRY __FPU_CW_GpiSetAttrs (HPS hps, LONG lPrimType, ULONG flAttrMask, ULONG flDefMask,    __const__ VOID *ppbunAttrs)
{
    BOOL ret = GpiSetAttrs (hps, lPrimType, flAttrMask, flDefMask,    ppbunAttrs);
    __FPU_CW_Restore();
    return ret;
}
#define GpiSetAttrs __FPU_CW_GpiSetAttrs

inline BOOL APIENTRY __FPU_CW_GpiSetBackColor (HPS hps, LONG lColor)
{
    BOOL ret = GpiSetBackColor (hps, lColor);
    __FPU_CW_Restore();
    return ret;
}
#define GpiSetBackColor __FPU_CW_GpiSetBackColor

inline BOOL APIENTRY __FPU_CW_GpiSetBackMix (HPS hps, LONG lMixMode)
{
    BOOL ret = GpiSetBackMix (hps, lMixMode);
    __FPU_CW_Restore();
    return ret;
}
#define GpiSetBackMix __FPU_CW_GpiSetBackMix

inline BOOL APIENTRY __FPU_CW_GpiSetCharAngle (HPS hps, __const__ GRADIENTL *pgradlAngle)
{
    BOOL ret = GpiSetCharAngle (hps, pgradlAngle);
    __FPU_CW_Restore();
    return ret;
}
#define GpiSetCharAngle __FPU_CW_GpiSetCharAngle

inline BOOL APIENTRY __FPU_CW_GpiSetCharBox (HPS hps, __const__ SIZEF *psizfxBox)
{
    BOOL ret = GpiSetCharBox (hps, psizfxBox);
    __FPU_CW_Restore();
    return ret;
}
#define GpiSetCharBox __FPU_CW_GpiSetCharBox

inline BOOL APIENTRY __FPU_CW_GpiSetCharBreakExtra (HPS hps, FIXED BreakExtra)
{
    BOOL ret = GpiSetCharBreakExtra (hps, BreakExtra);
    __FPU_CW_Restore();
    return ret;
}
#define GpiSetCharBreakExtra __FPU_CW_GpiSetCharBreakExtra

inline BOOL APIENTRY __FPU_CW_GpiSetCharDirection (HPS hps, LONG lDirection)
{
    BOOL ret = GpiSetCharDirection (hps, lDirection);
    __FPU_CW_Restore();
    return ret;
}
#define GpiSetCharDirection __FPU_CW_GpiSetCharDirection

inline BOOL APIENTRY __FPU_CW_GpiSetCharExtra (HPS hps, FIXED  Extra)
{
    BOOL ret = GpiSetCharExtra (hps, Extra);
    __FPU_CW_Restore();
    return ret;
}
#define GpiSetCharExtra __FPU_CW_GpiSetCharExtra

inline BOOL APIENTRY __FPU_CW_GpiSetCharMode (HPS hps, LONG lMode)
{
    BOOL ret = GpiSetCharMode (hps, lMode);
    __FPU_CW_Restore();
    return ret;
}
#define GpiSetCharMode __FPU_CW_GpiSetCharMode

inline BOOL APIENTRY __FPU_CW_GpiSetCharSet (HPS hps, LONG llcid)
{
    BOOL ret = GpiSetCharSet (hps, llcid);
    __FPU_CW_Restore();
    return ret;
}
#define GpiSetCharSet __FPU_CW_GpiSetCharSet

inline BOOL APIENTRY __FPU_CW_GpiSetCharShear (HPS hps, __const__ POINTL *pptlAngle)
{
    BOOL ret = GpiSetCharShear (hps, pptlAngle);
    __FPU_CW_Restore();
    return ret;
}
#define GpiSetCharShear __FPU_CW_GpiSetCharShear

inline BOOL APIENTRY __FPU_CW_GpiSetClipPath (HPS hps, LONG lPath, LONG lOptions)
{
    BOOL ret = GpiSetClipPath (hps, lPath, lOptions);
    __FPU_CW_Restore();
    return ret;
}
#define GpiSetClipPath __FPU_CW_GpiSetClipPath

inline LONG APIENTRY __FPU_CW_GpiSetClipRegion (HPS hps, HRGN hrgn, PHRGN phrgnOld)
{
    LONG ret = GpiSetClipRegion (hps, hrgn, phrgnOld);
    __FPU_CW_Restore();
    return ret;
}
#define GpiSetClipRegion __FPU_CW_GpiSetClipRegion

inline BOOL APIENTRY __FPU_CW_GpiSetColor (HPS hps, LONG lColor)
{
    BOOL ret = GpiSetColor (hps, lColor);
    __FPU_CW_Restore();
    return ret;
}
#define GpiSetColor __FPU_CW_GpiSetColor

inline BOOL APIENTRY __FPU_CW_GpiSetCp (HPS hps, ULONG ulCodePage)
{
    BOOL ret = GpiSetCp (hps, ulCodePage);
    __FPU_CW_Restore();
    return ret;
}
#define GpiSetCp __FPU_CW_GpiSetCp

inline BOOL APIENTRY __FPU_CW_GpiSetCurrentPosition (HPS hps, __const__ POINTL *pptlPoint)
{
    BOOL ret = GpiSetCurrentPosition (hps, pptlPoint);
    __FPU_CW_Restore();
    return ret;
}
#define GpiSetCurrentPosition __FPU_CW_GpiSetCurrentPosition

inline BOOL APIENTRY __FPU_CW_GpiSetDefArcParams (HPS hps, __const__ ARCPARAMS *parcpArcParams)
{
    BOOL ret = GpiSetDefArcParams (hps, parcpArcParams);
    __FPU_CW_Restore();
    return ret;
}
#define GpiSetDefArcParams __FPU_CW_GpiSetDefArcParams

inline BOOL APIENTRY __FPU_CW_GpiSetDefAttrs (HPS hps, LONG lPrimType, ULONG flAttrMask,    __const__ VOID *ppbunAttrs)
{
    BOOL ret = GpiSetDefAttrs (hps, lPrimType, flAttrMask,    ppbunAttrs);
    __FPU_CW_Restore();
    return ret;
}
#define GpiSetDefAttrs __FPU_CW_GpiSetDefAttrs

inline BOOL APIENTRY __FPU_CW_GpiSetDefaultViewMatrix (HPS hps, LONG lCount,    __const__ MATRIXLF *pmatlfarray, LONG lOptions)
{
    BOOL ret = GpiSetDefaultViewMatrix (hps, lCount,    pmatlfarray, lOptions);
    __FPU_CW_Restore();
    return ret;
}
#define GpiSetDefaultViewMatrix __FPU_CW_GpiSetDefaultViewMatrix

inline BOOL APIENTRY __FPU_CW_GpiSetDefTag (HPS hps, LONG lTag)
{
    BOOL ret = GpiSetDefTag (hps, lTag);
    __FPU_CW_Restore();
    return ret;
}
#define GpiSetDefTag __FPU_CW_GpiSetDefTag

inline BOOL APIENTRY __FPU_CW_GpiSetDefViewingLimits (HPS hps, __const__ RECTL *prclLimits)
{
    BOOL ret = GpiSetDefViewingLimits (hps, prclLimits);
    __FPU_CW_Restore();
    return ret;
}
#define GpiSetDefViewingLimits __FPU_CW_GpiSetDefViewingLimits

inline BOOL APIENTRY __FPU_CW_GpiSetEditMode (HPS hps, LONG lMode)
{
    BOOL ret = GpiSetEditMode (hps, lMode);
    __FPU_CW_Restore();
    return ret;
}
#define GpiSetEditMode __FPU_CW_GpiSetEditMode

inline BOOL APIENTRY __FPU_CW_GpiSetElementPointer (HPS hps, LONG lElement)
{
    BOOL ret = GpiSetElementPointer (hps, lElement);
    __FPU_CW_Restore();
    return ret;
}
#define GpiSetElementPointer __FPU_CW_GpiSetElementPointer

inline BOOL APIENTRY __FPU_CW_GpiSetElementPointerAtLabel (HPS hps, LONG lLabel)
{
    BOOL ret = GpiSetElementPointerAtLabel (hps, lLabel);
    __FPU_CW_Restore();
    return ret;
}
#define GpiSetElementPointerAtLabel __FPU_CW_GpiSetElementPointerAtLabel

inline BOOL APIENTRY __FPU_CW_GpiSetGraphicsField (HPS hps, __const__ RECTL *prclField)
{
    BOOL ret = GpiSetGraphicsField (hps, prclField);
    __FPU_CW_Restore();
    return ret;
}
#define GpiSetGraphicsField __FPU_CW_GpiSetGraphicsField

inline BOOL APIENTRY __FPU_CW_GpiSetLineEnd (HPS hps, LONG lLineEnd)
{
    BOOL ret = GpiSetLineEnd (hps, lLineEnd);
    __FPU_CW_Restore();
    return ret;
}
#define GpiSetLineEnd __FPU_CW_GpiSetLineEnd

inline BOOL APIENTRY __FPU_CW_GpiSetLineJoin (HPS hps, LONG lLineJoin)
{
    BOOL ret = GpiSetLineJoin (hps, lLineJoin);
    __FPU_CW_Restore();
    return ret;
}
#define GpiSetLineJoin __FPU_CW_GpiSetLineJoin

inline BOOL APIENTRY __FPU_CW_GpiSetLineType (HPS hps, LONG lLineType)
{
    BOOL ret = GpiSetLineType (hps, lLineType);
    __FPU_CW_Restore();
    return ret;
}
#define GpiSetLineType __FPU_CW_GpiSetLineType

inline BOOL APIENTRY __FPU_CW_GpiSetLineWidth (HPS hps, FIXED fxLineWidth)
{
    BOOL ret = GpiSetLineWidth (hps, fxLineWidth);
    __FPU_CW_Restore();
    return ret;
}
#define GpiSetLineWidth __FPU_CW_GpiSetLineWidth

inline BOOL APIENTRY __FPU_CW_GpiSetLineWidthGeom (HPS hps, LONG lLineWidth)
{
    BOOL ret = GpiSetLineWidthGeom (hps, lLineWidth);
    __FPU_CW_Restore();
    return ret;
}
#define GpiSetLineWidthGeom __FPU_CW_GpiSetLineWidthGeom

inline BOOL APIENTRY __FPU_CW_GpiSetMarker (HPS hps, LONG lSymbol)
{
    BOOL ret = GpiSetMarker (hps, lSymbol);
    __FPU_CW_Restore();
    return ret;
}
#define GpiSetMarker __FPU_CW_GpiSetMarker

inline BOOL APIENTRY __FPU_CW_GpiSetMarkerBox (HPS hps, __const__ SIZEF *psizfxSize)
{
    BOOL ret = GpiSetMarkerBox (hps, psizfxSize);
    __FPU_CW_Restore();
    return ret;
}
#define GpiSetMarkerBox __FPU_CW_GpiSetMarkerBox

inline BOOL APIENTRY __FPU_CW_GpiSetMarkerSet (HPS hps, LONG lSet)
{
    BOOL ret = GpiSetMarkerSet (hps, lSet);
    __FPU_CW_Restore();
    return ret;
}
#define GpiSetMarkerSet __FPU_CW_GpiSetMarkerSet

inline BOOL APIENTRY __FPU_CW_GpiSetMetaFileBits (HMF hmf, LONG lOffset, LONG lLength,    __const__ BYTE *pbBuffer)
{
    BOOL ret = GpiSetMetaFileBits (hmf, lOffset, lLength,    pbBuffer);
    __FPU_CW_Restore();
    return ret;
}
#define GpiSetMetaFileBits __FPU_CW_GpiSetMetaFileBits

inline BOOL APIENTRY __FPU_CW_GpiSetMix (HPS hps, LONG lMixMode)
{
    BOOL ret = GpiSetMix (hps, lMixMode);
    __FPU_CW_Restore();
    return ret;
}
#define GpiSetMix __FPU_CW_GpiSetMix

inline BOOL APIENTRY __FPU_CW_GpiSetModelTransformMatrix (HPS hps, LONG lCount,    __const__ MATRIXLF *pmatlfArray, LONG lOptions)
{
    BOOL ret = GpiSetModelTransformMatrix (hps, lCount,    pmatlfArray, lOptions);
    __FPU_CW_Restore();
    return ret;
}
#define GpiSetModelTransformMatrix __FPU_CW_GpiSetModelTransformMatrix

inline BOOL APIENTRY __FPU_CW_GpiSetPageViewport (HPS hps, __const__ RECTL *prclViewport)
{
    BOOL ret = GpiSetPageViewport (hps, prclViewport);
    __FPU_CW_Restore();
    return ret;
}
#define GpiSetPageViewport __FPU_CW_GpiSetPageViewport

inline BOOL APIENTRY __FPU_CW_GpiSetPaletteEntries (HPAL hpal, ULONG ulFormat, ULONG ulStart,    ULONG ulCount, __const__ ULONG *aulTable)
{
    BOOL ret = GpiSetPaletteEntries (hpal, ulFormat, ulStart,    ulCount, aulTable);
    __FPU_CW_Restore();
    return ret;
}
#define GpiSetPaletteEntries __FPU_CW_GpiSetPaletteEntries

inline BOOL APIENTRY __FPU_CW_GpiSetPattern (HPS hps, LONG lPatternSymbol)
{
    BOOL ret = GpiSetPattern (hps, lPatternSymbol);
    __FPU_CW_Restore();
    return ret;
}
#define GpiSetPattern __FPU_CW_GpiSetPattern

inline BOOL APIENTRY __FPU_CW_GpiSetPatternRefPoint (HPS hps, __const__ POINTL *pptlRefPoint)
{
    BOOL ret = GpiSetPatternRefPoint (hps, pptlRefPoint);
    __FPU_CW_Restore();
    return ret;
}
#define GpiSetPatternRefPoint __FPU_CW_GpiSetPatternRefPoint

inline BOOL APIENTRY __FPU_CW_GpiSetPatternSet (HPS hps, LONG lSet)
{
    BOOL ret = GpiSetPatternSet (hps, lSet);
    __FPU_CW_Restore();
    return ret;
}
#define GpiSetPatternSet __FPU_CW_GpiSetPatternSet

inline BOOL APIENTRY __FPU_CW_GpiSetRegion (HPS hps, HRGN hrgn, LONG lcount,    __const__ RECTL *arclRectangles)
{
    BOOL ret = GpiSetRegion (hps, hrgn, lcount,    arclRectangles);
    __FPU_CW_Restore();
    return ret;
}
#define GpiSetRegion __FPU_CW_GpiSetRegion

inline BOOL APIENTRY __FPU_CW_GpiSetSegmentTransformMatrix (HPS hps, LONG lSegid, LONG lCount,    __const__ MATRIXLF *pmatlfarray, LONG lOptions)
{
    BOOL ret = GpiSetSegmentTransformMatrix (hps, lSegid, lCount,    pmatlfarray, lOptions);
    __FPU_CW_Restore();
    return ret;
}
#define GpiSetSegmentTransformMatrix __FPU_CW_GpiSetSegmentTransformMatrix

inline BOOL APIENTRY __FPU_CW_GpiSetTextAlignment (HPS hps, LONG lHoriz, LONG lVert)
{
    BOOL ret = GpiSetTextAlignment (hps, lHoriz, lVert);
    __FPU_CW_Restore();
    return ret;
}
#define GpiSetTextAlignment __FPU_CW_GpiSetTextAlignment

inline BOOL APIENTRY __FPU_CW_GpiSetViewingLimits (HPS hps, __const__ RECTL *prclLimits)
{
    BOOL ret = GpiSetViewingLimits (hps, prclLimits);
    __FPU_CW_Restore();
    return ret;
}
#define GpiSetViewingLimits __FPU_CW_GpiSetViewingLimits

inline BOOL APIENTRY __FPU_CW_GpiSetViewingTransformMatrix (HPS hps, LONG lCount,    __const__ MATRIXLF *pmatlfArray, LONG lOptions)
{
    BOOL ret = GpiSetViewingTransformMatrix (hps, lCount,    pmatlfArray, lOptions);
    __FPU_CW_Restore();
    return ret;
}
#define GpiSetViewingTransformMatrix __FPU_CW_GpiSetViewingTransformMatrix

inline LONG APIENTRY __FPU_CW_GpiStrokePath (HPS hps, LONG lPath, ULONG flOptions)
{
    LONG ret = GpiStrokePath (hps, lPath, flOptions);
    __FPU_CW_Restore();
    return ret;
}
#define GpiStrokePath __FPU_CW_GpiStrokePath

inline BOOL APIENTRY __FPU_CW_GpiTranslate (HPS hps, PMATRIXLF pmatlfArray, LONG lOptions,    __const__ POINTL *pptlTranslation)
{
    BOOL ret = GpiTranslate (hps, pmatlfArray, lOptions,    pptlTranslation);
    __FPU_CW_Restore();
    return ret;
}
#define GpiTranslate __FPU_CW_GpiTranslate

inline BOOL APIENTRY __FPU_CW_GpiUnloadFonts (HAB hab, PCSZ pszFilename)
{
    BOOL ret = GpiUnloadFonts (hab, pszFilename);
    __FPU_CW_Restore();
    return ret;
}
#define GpiUnloadFonts __FPU_CW_GpiUnloadFonts

inline BOOL APIENTRY __FPU_CW_GpiUnloadPublicFonts (HAB hab, PCSZ pszFilename)
{
    BOOL ret = GpiUnloadPublicFonts (hab, pszFilename);
    __FPU_CW_Restore();
    return ret;
}
#define GpiUnloadPublicFonts __FPU_CW_GpiUnloadPublicFonts

inline LONG APIENTRY __FPU_CW_GpiBitBlt (HPS hpsTarget, HPS hpsSource, LONG lCount,    __const__ POINTL *aptlPoints, LONG lRop, ULONG flOptions)
{
    LONG ret = GpiBitBlt (hpsTarget, hpsSource, lCount,    aptlPoints, lRop, flOptions);
    __FPU_CW_Restore();
    return ret;
}
#define GpiBitBlt __FPU_CW_GpiBitBlt

inline BOOL APIENTRY __FPU_CW_GpiDeleteBitmap (HBITMAP hbm)
{
    BOOL ret = GpiDeleteBitmap (hbm);
    __FPU_CW_Restore();
    return ret;
}
#define GpiDeleteBitmap __FPU_CW_GpiDeleteBitmap

inline HBITMAP APIENTRY __FPU_CW_GpiLoadBitmap (HPS hps, HMODULE Resource, ULONG idBitmap,    LONG lWidth, LONG lHeight)
{
    HBITMAP ret = GpiLoadBitmap (hps, Resource, idBitmap,    lWidth, lHeight);
    __FPU_CW_Restore();
    return ret;
}
#define GpiLoadBitmap __FPU_CW_GpiLoadBitmap

inline HBITMAP APIENTRY __FPU_CW_GpiSetBitmap (HPS hps, HBITMAP hbm)
{
    HBITMAP ret = GpiSetBitmap (hps, hbm);
    __FPU_CW_Restore();
    return ret;
}
#define GpiSetBitmap __FPU_CW_GpiSetBitmap

inline LONG APIENTRY __FPU_CW_GpiWCBitBlt (HPS hpsTarget, HBITMAP hbmSource, LONG lCount,    __const__ POINTL *aptlPoints, LONG lRop, ULONG flOptions)
{
    LONG ret = GpiWCBitBlt (hpsTarget, hbmSource, lCount,    aptlPoints, lRop, flOptions);
    __FPU_CW_Restore();
    return ret;
}
#define GpiWCBitBlt __FPU_CW_GpiWCBitBlt

inline HBITMAP APIENTRY __FPU_CW_GpiCreateBitmap (HPS hps, __const__ BITMAPINFOHEADER2 *pbmpNew,    ULONG flOptions, __const__ BYTE *pbInitData,    __const__ BITMAPINFO2 *pbmiInfoTable)
{
    HBITMAP ret = GpiCreateBitmap (hps, pbmpNew,    flOptions, pbInitData,    pbmiInfoTable);
    __FPU_CW_Restore();
    return ret;
}
#define GpiCreateBitmap __FPU_CW_GpiCreateBitmap

inline LONG APIENTRY __FPU_CW_GpiDrawBits (HPS hps, __const__ VOID *pBits,    __const__ BITMAPINFO2 *pbmiInfoTable, LONG lCount,    __const__ POINTL *aptlPoints, LONG lRop, ULONG flOptions)
{
    LONG ret = GpiDrawBits (hps, pBits,    pbmiInfoTable, lCount,    aptlPoints, lRop, flOptions);
    __FPU_CW_Restore();
    return ret;
}
#define GpiDrawBits __FPU_CW_GpiDrawBits

inline LONG APIENTRY __FPU_CW_GpiFloodFill (HPS hps, LONG lOptions, LONG lColor)
{
    LONG ret = GpiFloodFill (hps, lOptions, lColor);
    __FPU_CW_Restore();
    return ret;
}
#define GpiFloodFill __FPU_CW_GpiFloodFill

inline LONG APIENTRY __FPU_CW_GpiQueryBitmapBits (HPS hps, LONG lScanStart, LONG lScans, PBYTE pbBuffer,    PBITMAPINFO2 pbmiInfoTable)
{
    LONG ret = GpiQueryBitmapBits (hps, lScanStart, lScans, pbBuffer,    pbmiInfoTable);
    __FPU_CW_Restore();
    return ret;
}
#define GpiQueryBitmapBits __FPU_CW_GpiQueryBitmapBits

inline BOOL APIENTRY __FPU_CW_GpiQueryBitmapDimension (HBITMAP hbm, PSIZEL psizlBitmapDimension)
{
    BOOL ret = GpiQueryBitmapDimension (hbm, psizlBitmapDimension);
    __FPU_CW_Restore();
    return ret;
}
#define GpiQueryBitmapDimension __FPU_CW_GpiQueryBitmapDimension

inline HBITMAP APIENTRY __FPU_CW_GpiQueryBitmapHandle (HPS hps, LONG lLcid)
{
    HBITMAP ret = GpiQueryBitmapHandle (hps, lLcid);
    __FPU_CW_Restore();
    return ret;
}
#define GpiQueryBitmapHandle __FPU_CW_GpiQueryBitmapHandle

inline BOOL APIENTRY __FPU_CW_GpiQueryBitmapInfoHeader (HBITMAP hbm, PBITMAPINFOHEADER2 pbmpData)
{
    BOOL ret = GpiQueryBitmapInfoHeader (hbm, pbmpData);
    __FPU_CW_Restore();
    return ret;
}
#define GpiQueryBitmapInfoHeader __FPU_CW_GpiQueryBitmapInfoHeader

inline BOOL APIENTRY __FPU_CW_GpiQueryBitmapParameters (HBITMAP hbm, PBITMAPINFOHEADER pbmpData)
{
    BOOL ret = GpiQueryBitmapParameters (hbm, pbmpData);
    __FPU_CW_Restore();
    return ret;
}
#define GpiQueryBitmapParameters __FPU_CW_GpiQueryBitmapParameters

inline BOOL APIENTRY __FPU_CW_GpiQueryDeviceBitmapFormats (HPS hps, LONG lCount, PLONG alArray)
{
    BOOL ret = GpiQueryDeviceBitmapFormats (hps, lCount, alArray);
    __FPU_CW_Restore();
    return ret;
}
#define GpiQueryDeviceBitmapFormats __FPU_CW_GpiQueryDeviceBitmapFormats

inline LONG APIENTRY  __FPU_CW_GpiSetBitmapBits (HPS hps, LONG lScanStart, LONG lScans,    __const__ BYTE *pbBuffer, __const__ BITMAPINFO2 *pbmiInfoTable)
{
    LONG ret = GpiSetBitmapBits (hps, lScanStart, lScans,    pbBuffer, pbmiInfoTable);
    __FPU_CW_Restore();
    return ret;
}
#define GpiSetBitmapBits __FPU_CW_GpiSetBitmapBits

inline LONG APIENTRY __FPU_CW_GpiQueryPel (HPS hps, PPOINTL pptlPoint)
{
    LONG ret = GpiQueryPel (hps, pptlPoint);
    __FPU_CW_Restore();
    return ret;
}
#define GpiQueryPel __FPU_CW_GpiQueryPel

inline BOOL APIENTRY __FPU_CW_GpiSetBitmapDimension (HBITMAP hbm,    __const__ SIZEL *psizlBitmapDimension)
{
    BOOL ret = GpiSetBitmapDimension (hbm,    psizlBitmapDimension);
    __FPU_CW_Restore();
    return ret;
}
#define GpiSetBitmapDimension __FPU_CW_GpiSetBitmapDimension

inline BOOL APIENTRY __FPU_CW_GpiSetBitmapId (HPS hps, HBITMAP hbm, LONG lLcid)
{
    BOOL ret = GpiSetBitmapId (hps, hbm, lLcid);
    __FPU_CW_Restore();
    return ret;
}
#define GpiSetBitmapId __FPU_CW_GpiSetBitmapId

inline LONG APIENTRY __FPU_CW_GpiSetPel (HPS hps, __const__ POINTL *pptlPoint)
{
    LONG ret = GpiSetPel (hps, pptlPoint);
    __FPU_CW_Restore();
    return ret;
}
#define GpiSetPel __FPU_CW_GpiSetPel

inline BOOL APIENTRY __FPU_CW_GpiAssociate (HPS hps, HDC hdc)
{
    BOOL ret = GpiAssociate (hps, hdc);
    __FPU_CW_Restore();
    return ret;
}
#define GpiAssociate __FPU_CW_GpiAssociate

inline HPS APIENTRY __FPU_CW_GpiCreatePS (HAB hab, HDC hdc, PSIZEL psizlSize, ULONG flOptions)
{
    HPS ret = GpiCreatePS (hab, hdc, psizlSize, flOptions);
    __FPU_CW_Restore();
    return ret;
}
#define GpiCreatePS __FPU_CW_GpiCreatePS

inline BOOL APIENTRY __FPU_CW_GpiDestroyPS (HPS hps)
{
    BOOL ret = GpiDestroyPS (hps);
    __FPU_CW_Restore();
    return ret;
}
#define GpiDestroyPS __FPU_CW_GpiDestroyPS

inline BOOL APIENTRY __FPU_CW_GpiErase (HPS hps)
{
    BOOL ret = GpiErase (hps);
    __FPU_CW_Restore();
    return ret;
}
#define GpiErase __FPU_CW_GpiErase

inline HDC APIENTRY __FPU_CW_GpiQueryDevice (HPS hps)
{
    HDC ret = GpiQueryDevice (hps);
    __FPU_CW_Restore();
    return ret;
}
#define GpiQueryDevice __FPU_CW_GpiQueryDevice

inline BOOL APIENTRY __FPU_CW_GpiRestorePS (HPS hps, LONG lPSid)
{
    BOOL ret = GpiRestorePS (hps, lPSid);
    __FPU_CW_Restore();
    return ret;
}
#define GpiRestorePS __FPU_CW_GpiRestorePS

inline LONG APIENTRY __FPU_CW_GpiSavePS (HPS hps)
{
    LONG ret = GpiSavePS (hps);
    __FPU_CW_Restore();
    return ret;
}
#define GpiSavePS __FPU_CW_GpiSavePS

inline LONG APIENTRY __FPU_CW_GpiErrorSegmentData (HPS hps, PLONG plSegment, PLONG plContext)
{
    LONG ret = GpiErrorSegmentData (hps, plSegment, plContext);
    __FPU_CW_Restore();
    return ret;
}
#define GpiErrorSegmentData __FPU_CW_GpiErrorSegmentData

inline LONG APIENTRY __FPU_CW_GpiQueryDrawControl (HPS hps, LONG lControl)
{
    LONG ret = GpiQueryDrawControl (hps, lControl);
    __FPU_CW_Restore();
    return ret;
}
#define GpiQueryDrawControl __FPU_CW_GpiQueryDrawControl

inline LONG APIENTRY __FPU_CW_GpiQueryDrawingMode (HPS hps)
{
    LONG ret = GpiQueryDrawingMode (hps);
    __FPU_CW_Restore();
    return ret;
}
#define GpiQueryDrawingMode __FPU_CW_GpiQueryDrawingMode

inline ULONG APIENTRY __FPU_CW_GpiQueryPS (HPS hps, PSIZEL psizlSize)
{
    ULONG ret = GpiQueryPS (hps, psizlSize);
    __FPU_CW_Restore();
    return ret;
}
#define GpiQueryPS __FPU_CW_GpiQueryPS

inline BOOL APIENTRY __FPU_CW_GpiResetPS (HPS hps, ULONG flOptions)
{
    BOOL ret = GpiResetPS (hps, flOptions);
    __FPU_CW_Restore();
    return ret;
}
#define GpiResetPS __FPU_CW_GpiResetPS

inline LONG APIENTRY __FPU_CW_GpiQueryStopDraw (HPS hps)
{
    LONG ret = GpiQueryStopDraw (hps);
    __FPU_CW_Restore();
    return ret;
}
#define GpiQueryStopDraw __FPU_CW_GpiQueryStopDraw

inline BOOL APIENTRY __FPU_CW_GpiSetDrawControl (HPS hps, LONG lControl, LONG lValue)
{
    BOOL ret = GpiSetDrawControl (hps, lControl, lValue);
    __FPU_CW_Restore();
    return ret;
}
#define GpiSetDrawControl __FPU_CW_GpiSetDrawControl

inline BOOL APIENTRY __FPU_CW_GpiSetDrawingMode (HPS hps, LONG lMode)
{
    BOOL ret = GpiSetDrawingMode (hps, lMode);
    __FPU_CW_Restore();
    return ret;
}
#define GpiSetDrawingMode __FPU_CW_GpiSetDrawingMode

inline BOOL APIENTRY __FPU_CW_GpiSetPS (HPS hps, __const__ SIZEL *psizlsize, ULONG flOptions)
{
    BOOL ret = GpiSetPS (hps, psizlsize, flOptions);
    __FPU_CW_Restore();
    return ret;
}
#define GpiSetPS __FPU_CW_GpiSetPS

inline BOOL APIENTRY __FPU_CW_GpiSetStopDraw (HPS hps, LONG lValue)
{
    BOOL ret = GpiSetStopDraw (hps, lValue);
    __FPU_CW_Restore();
    return ret;
}
#define GpiSetStopDraw __FPU_CW_GpiSetStopDraw

inline LONG APIENTRY __FPU_CW_GpiCorrelateChain (HPS hps, LONG lType, __const__ POINTL *pptlPick,    LONG lMaxHits, LONG lMaxDepth, PLONG pl2)
{
    LONG ret = GpiCorrelateChain (hps, lType, pptlPick,    lMaxHits, lMaxDepth, pl2);
    __FPU_CW_Restore();
    return ret;
}
#define GpiCorrelateChain __FPU_CW_GpiCorrelateChain

inline LONG APIENTRY __FPU_CW_GpiCorrelateFrom (HPS hps, LONG lFirstSegment, LONG lLastSegment,    LONG lType, __const__ POINTL *pptlPick, LONG lMaxHits, LONG lMaxDepth,    PLONG plSegTag)
{
    LONG ret = GpiCorrelateFrom (hps, lFirstSegment, lLastSegment,    lType, pptlPick, lMaxHits, lMaxDepth,    plSegTag);
    __FPU_CW_Restore();
    return ret;
}
#define GpiCorrelateFrom __FPU_CW_GpiCorrelateFrom

inline LONG APIENTRY __FPU_CW_GpiCorrelateSegment (HPS hps, LONG lSegment, LONG lType,    __const__ POINTL *pptlPick, LONG lMaxHits, LONG lMaxDepth, PLONG alSegTag)
{
    LONG ret = GpiCorrelateSegment (hps, lSegment, lType,    pptlPick, lMaxHits, lMaxDepth, alSegTag);
    __FPU_CW_Restore();
    return ret;
}
#define GpiCorrelateSegment __FPU_CW_GpiCorrelateSegment

inline BOOL APIENTRY __FPU_CW_GpiQueryBoundaryData (HPS hps, PRECTL prclBoundary)
{
    BOOL ret = GpiQueryBoundaryData (hps, prclBoundary);
    __FPU_CW_Restore();
    return ret;
}
#define GpiQueryBoundaryData __FPU_CW_GpiQueryBoundaryData

inline BOOL APIENTRY __FPU_CW_GpiQueryPickAperturePosition (HPS hps, PPOINTL pptlPoint)
{
    BOOL ret = GpiQueryPickAperturePosition (hps, pptlPoint);
    __FPU_CW_Restore();
    return ret;
}
#define GpiQueryPickAperturePosition __FPU_CW_GpiQueryPickAperturePosition

inline BOOL APIENTRY __FPU_CW_GpiQueryPickApertureSize (HPS hps, PSIZEL psizlSize)
{
    BOOL ret = GpiQueryPickApertureSize (hps, psizlSize);
    __FPU_CW_Restore();
    return ret;
}
#define GpiQueryPickApertureSize __FPU_CW_GpiQueryPickApertureSize

inline BOOL APIENTRY __FPU_CW_GpiQueryTag (HPS hps, PLONG plTag)
{
    BOOL ret = GpiQueryTag (hps, plTag);
    __FPU_CW_Restore();
    return ret;
}
#define GpiQueryTag __FPU_CW_GpiQueryTag

inline BOOL APIENTRY __FPU_CW_GpiResetBoundaryData (HPS hps)
{
    BOOL ret = GpiResetBoundaryData (hps);
    __FPU_CW_Restore();
    return ret;
}
#define GpiResetBoundaryData __FPU_CW_GpiResetBoundaryData

inline BOOL APIENTRY __FPU_CW_GpiSetPickAperturePosition (HPS hps, __const__ POINTL *pptlPick)
{
    BOOL ret = GpiSetPickAperturePosition (hps, pptlPick);
    __FPU_CW_Restore();
    return ret;
}
#define GpiSetPickAperturePosition __FPU_CW_GpiSetPickAperturePosition

inline BOOL APIENTRY __FPU_CW_GpiSetPickApertureSize (HPS hps, LONG lOptions,    __const__ SIZEL *psizlSize)
{
    BOOL ret = GpiSetPickApertureSize (hps, lOptions,    psizlSize);
    __FPU_CW_Restore();
    return ret;
}
#define GpiSetPickApertureSize __FPU_CW_GpiSetPickApertureSize

inline BOOL APIENTRY __FPU_CW_GpiSetTag (HPS hps, LONG lTag)
{
    BOOL ret = GpiSetTag (hps, lTag);
    __FPU_CW_Restore();
    return ret;
}
#define GpiSetTag __FPU_CW_GpiSetTag

inline BOOL APIENTRY __FPU_CW_GpiBeginInkPath (HPS hps, LONG lPath, ULONG flOptions)
{
    BOOL ret = GpiBeginInkPath (hps, lPath, flOptions);
    __FPU_CW_Restore();
    return ret;
}
#define GpiBeginInkPath __FPU_CW_GpiBeginInkPath

inline BOOL APIENTRY __FPU_CW_GpiEndInkPath (HPS hps, ULONG flOptions)
{
    BOOL ret = GpiEndInkPath (hps, flOptions);
    __FPU_CW_Restore();
    return ret;
}
#define GpiEndInkPath __FPU_CW_GpiEndInkPath

inline LONG APIENTRY __FPU_CW_GpiStrokeInkPath (HPS hps, LONG lPath, LONG lCount,    __const__ POINTL *aptlPoints, ULONG flOptions)
{
    LONG ret = GpiStrokeInkPath (hps, lPath, lCount,    aptlPoints, flOptions);
    __FPU_CW_Restore();
    return ret;
}
#define GpiStrokeInkPath __FPU_CW_GpiStrokeInkPath

inline BOOL APIENTRY __FPU_CW_GpiCloseSegment (HPS hps)
{
    BOOL ret = GpiCloseSegment (hps);
    __FPU_CW_Restore();
    return ret;
}
#define GpiCloseSegment __FPU_CW_GpiCloseSegment

inline BOOL APIENTRY __FPU_CW_GpiDeleteSegment (HPS hps, LONG lSegid)
{
    BOOL ret = GpiDeleteSegment (hps, lSegid);
    __FPU_CW_Restore();
    return ret;
}
#define GpiDeleteSegment __FPU_CW_GpiDeleteSegment

inline BOOL APIENTRY __FPU_CW_GpiDeleteSegments (HPS hps, LONG lFirstSegment, LONG lLastSegment)
{
    BOOL ret = GpiDeleteSegments (hps, lFirstSegment, lLastSegment);
    __FPU_CW_Restore();
    return ret;
}
#define GpiDeleteSegments __FPU_CW_GpiDeleteSegments

inline BOOL APIENTRY __FPU_CW_GpiDrawChain (HPS hps)
{
    BOOL ret = GpiDrawChain (hps);
    __FPU_CW_Restore();
    return ret;
}
#define GpiDrawChain __FPU_CW_GpiDrawChain

inline BOOL APIENTRY __FPU_CW_GpiDrawDynamics (HPS hps)
{
    BOOL ret = GpiDrawDynamics (hps);
    __FPU_CW_Restore();
    return ret;
}
#define GpiDrawDynamics __FPU_CW_GpiDrawDynamics

inline BOOL APIENTRY __FPU_CW_GpiDrawFrom (HPS hps, LONG lFirstSegment, LONG lLastSegment)
{
    BOOL ret = GpiDrawFrom (hps, lFirstSegment, lLastSegment);
    __FPU_CW_Restore();
    return ret;
}
#define GpiDrawFrom __FPU_CW_GpiDrawFrom

inline BOOL APIENTRY __FPU_CW_GpiDrawSegment (HPS hps, LONG lSegment)
{
    BOOL ret = GpiDrawSegment (hps, lSegment);
    __FPU_CW_Restore();
    return ret;
}
#define GpiDrawSegment __FPU_CW_GpiDrawSegment

inline LONG APIENTRY __FPU_CW_GpiGetData (HPS hps, LONG lSegid, PLONG plOffset, LONG lFormat,    LONG lLength, PBYTE pbData)
{
    LONG ret = GpiGetData (hps, lSegid, plOffset, lFormat,    lLength, pbData);
    __FPU_CW_Restore();
    return ret;
}
#define GpiGetData __FPU_CW_GpiGetData

inline BOOL APIENTRY __FPU_CW_GpiOpenSegment (HPS hps, LONG lSegment)
{
    BOOL ret = GpiOpenSegment (hps, lSegment);
    __FPU_CW_Restore();
    return ret;
}
#define GpiOpenSegment __FPU_CW_GpiOpenSegment

inline LONG APIENTRY __FPU_CW_GpiPutData (HPS hps, LONG lFormat, PLONG plCount, __const__ BYTE *pbData)
{
    LONG ret = GpiPutData (hps, lFormat, plCount, pbData);
    __FPU_CW_Restore();
    return ret;
}
#define GpiPutData __FPU_CW_GpiPutData

inline LONG APIENTRY __FPU_CW_GpiQueryInitialSegmentAttrs (HPS hps, LONG lAttribute)
{
    LONG ret = GpiQueryInitialSegmentAttrs (hps, lAttribute);
    __FPU_CW_Restore();
    return ret;
}
#define GpiQueryInitialSegmentAttrs __FPU_CW_GpiQueryInitialSegmentAttrs

inline LONG APIENTRY __FPU_CW_GpiQuerySegmentAttrs (HPS hps, LONG lSegid, LONG lAttribute)
{
    LONG ret = GpiQuerySegmentAttrs (hps, lSegid, lAttribute);
    __FPU_CW_Restore();
    return ret;
}
#define GpiQuerySegmentAttrs __FPU_CW_GpiQuerySegmentAttrs

inline LONG APIENTRY __FPU_CW_GpiQuerySegmentNames (HPS hps, LONG lFirstSegid, LONG lLastSegid,    LONG lMax, PLONG alSegids)
{
    LONG ret = GpiQuerySegmentNames (hps, lFirstSegid, lLastSegid,    lMax, alSegids);
    __FPU_CW_Restore();
    return ret;
}
#define GpiQuerySegmentNames __FPU_CW_GpiQuerySegmentNames

inline LONG APIENTRY __FPU_CW_GpiQuerySegmentPriority (HPS hps, LONG lRefSegid, LONG lOrder)
{
    LONG ret = GpiQuerySegmentPriority (hps, lRefSegid, lOrder);
    __FPU_CW_Restore();
    return ret;
}
#define GpiQuerySegmentPriority __FPU_CW_GpiQuerySegmentPriority

inline BOOL APIENTRY __FPU_CW_GpiRemoveDynamics (HPS hps, LONG lFirstSegid, LONG lLastSegid)
{
    BOOL ret = GpiRemoveDynamics (hps, lFirstSegid, lLastSegid);
    __FPU_CW_Restore();
    return ret;
}
#define GpiRemoveDynamics __FPU_CW_GpiRemoveDynamics

inline BOOL APIENTRY __FPU_CW_GpiSetInitialSegmentAttrs (HPS hps, LONG lAttribute, LONG lValue)
{
    BOOL ret = GpiSetInitialSegmentAttrs (hps, lAttribute, lValue);
    __FPU_CW_Restore();
    return ret;
}
#define GpiSetInitialSegmentAttrs __FPU_CW_GpiSetInitialSegmentAttrs

inline BOOL APIENTRY __FPU_CW_GpiSetSegmentAttrs (HPS hps, LONG lSegid, LONG lAttribute, LONG lValue)
{
    BOOL ret = GpiSetSegmentAttrs (hps, lSegid, lAttribute, lValue);
    __FPU_CW_Restore();
    return ret;
}
#define GpiSetSegmentAttrs __FPU_CW_GpiSetSegmentAttrs

inline BOOL APIENTRY __FPU_CW_GpiSetSegmentPriority (HPS hps, LONG lSegid, LONG lRefSegid, LONG lOrder)
{
    BOOL ret = GpiSetSegmentPriority (hps, lSegid, lRefSegid, lOrder);
    __FPU_CW_Restore();
    return ret;
}
#define GpiSetSegmentPriority __FPU_CW_GpiSetSegmentPriority

inline HAPP APIENTRY __FPU_CW_WinStartApp (HWND hwndNotify, PPROGDETAILS pDetails,    PCSZ pszParams, PVOID Reserved, ULONG fbOptions)
{
    HAPP ret = WinStartApp (hwndNotify, pDetails,    pszParams, Reserved, fbOptions);
    __FPU_CW_Restore();
    return ret;
}
#define WinStartApp __FPU_CW_WinStartApp

inline BOOL APIENTRY __FPU_CW_WinTerminateApp (HAPP happ)
{
    BOOL ret = WinTerminateApp (happ);
    __FPU_CW_Restore();
    return ret;
}
#define WinTerminateApp __FPU_CW_WinTerminateApp

inline HSWITCH APIENTRY __FPU_CW_WinAddSwitchEntry (__const__ SWCNTRL *pswctl)
{
    HSWITCH ret = WinAddSwitchEntry (pswctl);
    __FPU_CW_Restore();
    return ret;
}
#define WinAddSwitchEntry __FPU_CW_WinAddSwitchEntry

inline ULONG APIENTRY __FPU_CW_WinRemoveSwitchEntry (HSWITCH hsw)
{
    ULONG ret = WinRemoveSwitchEntry (hsw);
    __FPU_CW_Restore();
    return ret;
}
#define WinRemoveSwitchEntry __FPU_CW_WinRemoveSwitchEntry

inline ULONG APIENTRY __FPU_CW_WinChangeSwitchEntry (HSWITCH hsw, __const__ SWCNTRL *pswctl)
{
    ULONG ret = WinChangeSwitchEntry (hsw, pswctl);
    __FPU_CW_Restore();
    return ret;
}
#define WinChangeSwitchEntry __FPU_CW_WinChangeSwitchEntry

inline HSWITCH APIENTRY __FPU_CW_WinCreateSwitchEntry (HAB hab, __const__ SWCNTRL *pswctl)
{
    HSWITCH ret = WinCreateSwitchEntry (hab, pswctl);
    __FPU_CW_Restore();
    return ret;
}
#define WinCreateSwitchEntry __FPU_CW_WinCreateSwitchEntry

inline ULONG APIENTRY __FPU_CW_WinQuerySessionTitle (HAB hab, ULONG usSession, PSZ pszTitle,    ULONG usTitlelen)
{
    ULONG ret = WinQuerySessionTitle (hab, usSession, pszTitle,    usTitlelen);
    __FPU_CW_Restore();
    return ret;
}
#define WinQuerySessionTitle __FPU_CW_WinQuerySessionTitle

inline ULONG APIENTRY __FPU_CW_WinQuerySwitchEntry (HSWITCH hsw, PSWCNTRL pswctl)
{
    ULONG ret = WinQuerySwitchEntry (hsw, pswctl);
    __FPU_CW_Restore();
    return ret;
}
#define WinQuerySwitchEntry __FPU_CW_WinQuerySwitchEntry

inline HSWITCH APIENTRY __FPU_CW_WinQuerySwitchHandle (HWND hwnd, PID pid)
{
    HSWITCH ret = WinQuerySwitchHandle (hwnd, pid);
    __FPU_CW_Restore();
    return ret;
}
#define WinQuerySwitchHandle __FPU_CW_WinQuerySwitchHandle

inline ULONG APIENTRY __FPU_CW_WinQuerySwitchList (HAB hab, PSWBLOCK pswblk, ULONG usDataLength)
{
    ULONG ret = WinQuerySwitchList (hab, pswblk, usDataLength);
    __FPU_CW_Restore();
    return ret;
}
#define WinQuerySwitchList __FPU_CW_WinQuerySwitchList

inline ULONG APIENTRY __FPU_CW_WinQueryTaskSizePos (HAB hab, ULONG usScreenGroup, PSWP pswp)
{
    ULONG ret = WinQueryTaskSizePos (hab, usScreenGroup, pswp);
    __FPU_CW_Restore();
    return ret;
}
#define WinQueryTaskSizePos __FPU_CW_WinQueryTaskSizePos

inline ULONG APIENTRY __FPU_CW_WinQueryTaskTitle (ULONG usSession, PSZ pszTitle, ULONG usTitlelen)
{
    ULONG ret = WinQueryTaskTitle (usSession, pszTitle, usTitlelen);
    __FPU_CW_Restore();
    return ret;
}
#define WinQueryTaskTitle __FPU_CW_WinQueryTaskTitle

inline ULONG APIENTRY __FPU_CW_WinSwitchToProgram (HSWITCH hsw)
{
    ULONG ret = WinSwitchToProgram (hsw);
    __FPU_CW_Restore();
    return ret;
}
#define WinSwitchToProgram __FPU_CW_WinSwitchToProgram

inline MRESULT APIENTRY __FPU_CW_WinDefFileDlgProc (HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
{
    MRESULT ret = WinDefFileDlgProc (hwnd, msg, mp1, mp2);
    __FPU_CW_Restore();
    return ret;
}
#define WinDefFileDlgProc __FPU_CW_WinDefFileDlgProc

inline HWND APIENTRY __FPU_CW_WinFileDlg (HWND hwndP, HWND hwndO, PFILEDLG pfild)
{
    HWND ret = WinFileDlg (hwndP, hwndO, pfild);
    __FPU_CW_Restore();
    return ret;
}
#define WinFileDlg __FPU_CW_WinFileDlg

inline BOOL APIENTRY __FPU_CW_WinFreeFileDlgList (PAPSZ papszFQFilename)
{
    BOOL ret = WinFreeFileDlgList (papszFQFilename);
    __FPU_CW_Restore();
    return ret;
}
#define WinFreeFileDlgList __FPU_CW_WinFreeFileDlgList

inline HWND APIENTRY __FPU_CW_WinFontDlg (HWND hwndP, HWND hwndO, PFONTDLG pfntd)
{
    HWND ret = WinFontDlg (hwndP, hwndO, pfntd);
    __FPU_CW_Restore();
    return ret;
}
#define WinFontDlg __FPU_CW_WinFontDlg

inline MRESULT APIENTRY __FPU_CW_WinDefFontDlgProc (HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
{
    MRESULT ret = WinDefFontDlgProc (hwnd, msg, mp1, mp2);
    __FPU_CW_Restore();
    return ret;
}
#define WinDefFontDlgProc __FPU_CW_WinDefFontDlgProc

inline HOBJECT APIENTRY __FPU_CW_WinCopyObject (HOBJECT hObjectofObject, HOBJECT hObjectofDest,    ULONG ulReserved)
{
    HOBJECT ret = WinCopyObject (hObjectofObject, hObjectofDest,    ulReserved);
    __FPU_CW_Restore();
    return ret;
}
#define WinCopyObject __FPU_CW_WinCopyObject

inline HOBJECT APIENTRY __FPU_CW_WinCreateObject (PCSZ pszClassName, PCSZ pszTitle, PCSZ pszSetupString,    PCSZ pszLocation, ULONG ulFlags)
{
    HOBJECT ret = WinCreateObject (pszClassName, pszTitle, pszSetupString,    pszLocation, ulFlags);
    __FPU_CW_Restore();
    return ret;
}
#define WinCreateObject __FPU_CW_WinCreateObject

inline HOBJECT APIENTRY __FPU_CW_WinCreateShadow (HOBJECT hObjectofObject, HOBJECT hObjectofDest,    ULONG ulReserved)
{
    HOBJECT ret = WinCreateShadow (hObjectofObject, hObjectofDest,    ulReserved);
    __FPU_CW_Restore();
    return ret;
}
#define WinCreateShadow __FPU_CW_WinCreateShadow

inline BOOL APIENTRY __FPU_CW_WinDeregisterObjectClass (PCSZ pszClassName)
{
    BOOL ret = WinDeregisterObjectClass (pszClassName);
    __FPU_CW_Restore();
    return ret;
}
#define WinDeregisterObjectClass __FPU_CW_WinDeregisterObjectClass

inline BOOL APIENTRY __FPU_CW_WinDestroyObject (HOBJECT hObject)
{
    BOOL ret = WinDestroyObject (hObject);
    __FPU_CW_Restore();
    return ret;
}
#define WinDestroyObject __FPU_CW_WinDestroyObject

inline BOOL APIENTRY __FPU_CW_WinEnumObjectClasses (POBJCLASS pObjClass, PULONG pulSize)
{
    BOOL ret = WinEnumObjectClasses (pObjClass, pulSize);
    __FPU_CW_Restore();
    return ret;
}
#define WinEnumObjectClasses __FPU_CW_WinEnumObjectClasses

inline BOOL APIENTRY __FPU_CW_WinIsSOMDDReady (VOID)
{
    BOOL ret = WinIsSOMDDReady ();
    __FPU_CW_Restore();
    return ret;
}
#define WinIsSOMDDReady __FPU_CW_WinIsSOMDDReady

inline BOOL APIENTRY __FPU_CW_WinIsWPDServerReady (VOID)
{
    BOOL ret = WinIsWPDServerReady ();
    __FPU_CW_Restore();
    return ret;
}
#define WinIsWPDServerReady __FPU_CW_WinIsWPDServerReady

inline HOBJECT APIENTRY __FPU_CW_WinMoveObject (HOBJECT hObjectofObject, HOBJECT hObjectofDest,    ULONG ulReserved)
{
    HOBJECT ret = WinMoveObject (hObjectofObject, hObjectofDest,    ulReserved);
    __FPU_CW_Restore();
    return ret;
}
#define WinMoveObject __FPU_CW_WinMoveObject

inline BOOL APIENTRY __FPU_CW_WinOpenObject (HOBJECT hObject, ULONG ulView, BOOL fFlag)
{
    BOOL ret = WinOpenObject (hObject, ulView, fFlag);
    __FPU_CW_Restore();
    return ret;
}
#define WinOpenObject __FPU_CW_WinOpenObject

inline BOOL APIENTRY __FPU_CW_WinQueryActiveDesktopPathname (PSZ pszPathName, ULONG ulSize)
{
    BOOL ret = WinQueryActiveDesktopPathname (pszPathName, ulSize);
    __FPU_CW_Restore();
    return ret;
}
#define WinQueryActiveDesktopPathname __FPU_CW_WinQueryActiveDesktopPathname

inline HOBJECT APIENTRY __FPU_CW_WinQueryObject (PCSZ pszObjectID)
{
    HOBJECT ret = WinQueryObject (pszObjectID);
    __FPU_CW_Restore();
    return ret;
}
#define WinQueryObject __FPU_CW_WinQueryObject

inline BOOL APIENTRY __FPU_CW_WinQueryObjectPath (HOBJECT hobject, PSZ pszPathName, ULONG ulSize)
{
    BOOL ret = WinQueryObjectPath (hobject, pszPathName, ulSize);
    __FPU_CW_Restore();
    return ret;
}
#define WinQueryObjectPath __FPU_CW_WinQueryObjectPath

inline BOOL APIENTRY __FPU_CW_WinRegisterObjectClass (PCSZ pszClassName, PCSZ pszModName)
{
    BOOL ret = WinRegisterObjectClass (pszClassName, pszModName);
    __FPU_CW_Restore();
    return ret;
}
#define WinRegisterObjectClass __FPU_CW_WinRegisterObjectClass

inline BOOL APIENTRY __FPU_CW_WinReplaceObjectClass (PCSZ pszOldClassName, PCSZ pszNewClassName,    BOOL fReplace)
{
    BOOL ret = WinReplaceObjectClass (pszOldClassName, pszNewClassName,    fReplace);
    __FPU_CW_Restore();
    return ret;
}
#define WinReplaceObjectClass __FPU_CW_WinReplaceObjectClass

inline ULONG APIENTRY __FPU_CW_WinRestartSOMDD (BOOL fState)
{
    ULONG ret = WinRestartSOMDD (fState);
    __FPU_CW_Restore();
    return ret;
}
#define WinRestartSOMDD __FPU_CW_WinRestartSOMDD

inline ULONG APIENTRY __FPU_CW_WinRestartWPDServer (BOOL fState)
{
    ULONG ret = WinRestartWPDServer (fState);
    __FPU_CW_Restore();
    return ret;
}
#define WinRestartWPDServer __FPU_CW_WinRestartWPDServer

inline BOOL APIENTRY __FPU_CW_WinSaveObject (HOBJECT hObject, BOOL fAsync)
{
    BOOL ret = WinSaveObject (hObject, fAsync);
    __FPU_CW_Restore();
    return ret;
}
#define WinSaveObject __FPU_CW_WinSaveObject

inline BOOL APIENTRY __FPU_CW_WinSetObjectData (HOBJECT hObject, PCSZ pszSetupString)
{
    BOOL ret = WinSetObjectData (hObject, pszSetupString);
    __FPU_CW_Restore();
    return ret;
}
#define WinSetObjectData __FPU_CW_WinSetObjectData

inline BOOL APIENTRY __FPU_CW_WinFreeFileIcon (HPOINTER hptr)
{
    BOOL ret = WinFreeFileIcon (hptr);
    __FPU_CW_Restore();
    return ret;
}
#define WinFreeFileIcon __FPU_CW_WinFreeFileIcon

inline HPOINTER APIENTRY __FPU_CW_WinLoadFileIcon (PCSZ pszFileName, BOOL fPrivate)
{
    HPOINTER ret = WinLoadFileIcon (pszFileName, fPrivate);
    __FPU_CW_Restore();
    return ret;
}
#define WinLoadFileIcon __FPU_CW_WinLoadFileIcon

inline BOOL APIENTRY __FPU_CW_WinRestoreWindowPos (PCSZ pszAppName, PCSZ pszKeyName, HWND hwnd)
{
    BOOL ret = WinRestoreWindowPos (pszAppName, pszKeyName, hwnd);
    __FPU_CW_Restore();
    return ret;
}
#define WinRestoreWindowPos __FPU_CW_WinRestoreWindowPos

inline BOOL APIENTRY __FPU_CW_WinSetFileIcon (PCSZ pszFileName, __const__ ICONINFO *pIconInfo)
{
    BOOL ret = WinSetFileIcon (pszFileName, pIconInfo);
    __FPU_CW_Restore();
    return ret;
}
#define WinSetFileIcon __FPU_CW_WinSetFileIcon

inline BOOL APIENTRY __FPU_CW_WinShutdownSystem (HAB hab, HMQ hmq)
{
    BOOL ret = WinShutdownSystem (hab, hmq);
    __FPU_CW_Restore();
    return ret;
}
#define WinShutdownSystem __FPU_CW_WinShutdownSystem

inline BOOL APIENTRY __FPU_CW_WinStoreWindowPos (PCSZ pszAppName, PCSZ pszKeyName, HWND hwnd)
{
    BOOL ret = WinStoreWindowPos (pszAppName, pszKeyName, hwnd);
    __FPU_CW_Restore();
    return ret;
}
#define WinStoreWindowPos __FPU_CW_WinStoreWindowPos

inline BOOL APIENTRY __FPU_CW_WinAssociateHelpInstance (HWND hwndHelpInstance, HWND hwndApp)
{
    BOOL ret = WinAssociateHelpInstance (hwndHelpInstance, hwndApp);
    __FPU_CW_Restore();
    return ret;
}
#define WinAssociateHelpInstance __FPU_CW_WinAssociateHelpInstance

inline HWND APIENTRY __FPU_CW_WinCreateHelpInstance (HAB hab, PHELPINIT phinitHMInitStructure)
{
    HWND ret = WinCreateHelpInstance (hab, phinitHMInitStructure);
    __FPU_CW_Restore();
    return ret;
}
#define WinCreateHelpInstance __FPU_CW_WinCreateHelpInstance

inline BOOL APIENTRY __FPU_CW_WinCreateHelpTable (HWND hwndHelpInstance,    __const__ HELPTABLE *phtHelpTable)
{
    BOOL ret = WinCreateHelpTable (hwndHelpInstance,    phtHelpTable);
    __FPU_CW_Restore();
    return ret;
}
#define WinCreateHelpTable __FPU_CW_WinCreateHelpTable

inline BOOL APIENTRY __FPU_CW_WinDestroyHelpInstance (HWND hwndHelpInstance)
{
    BOOL ret = WinDestroyHelpInstance (hwndHelpInstance);
    __FPU_CW_Restore();
    return ret;
}
#define WinDestroyHelpInstance __FPU_CW_WinDestroyHelpInstance

inline BOOL APIENTRY __FPU_CW_WinLoadHelpTable (HWND hwndHelpInstance, ULONG idHelpTable,    HMODULE Module)
{
    BOOL ret = WinLoadHelpTable (hwndHelpInstance, idHelpTable,    Module);
    __FPU_CW_Restore();
    return ret;
}
#define WinLoadHelpTable __FPU_CW_WinLoadHelpTable

inline HWND APIENTRY __FPU_CW_WinQueryHelpInstance (HWND hwndApp)
{
    HWND ret = WinQueryHelpInstance (hwndApp);
    __FPU_CW_Restore();
    return ret;
}
#define WinQueryHelpInstance __FPU_CW_WinQueryHelpInstance

inline MRESULT APIENTRY __FPU_CW_WinDefAVioWindowProc (HWND hwnd, USHORT msg, ULONG mp1, ULONG mp2)
{
    MRESULT ret = WinDefAVioWindowProc (hwnd, msg, mp1, mp2);
    __FPU_CW_Restore();
    return ret;
}
#define WinDefAVioWindowProc __FPU_CW_WinDefAVioWindowProc

#endif // API_FPU_CW_WRAPPERS_H