/* $Id: os2wrap.h,v 1.3 1999-06-19 10:53:12 sandervl Exp $ */
#ifndef __OS2WRAP_H__
#define __OS2WRAP_H__

#include <os2.h>
#include <os2sel.h>
#include <os2newapi.h>

#ifdef INCL_DOSMEMMGR
inline ULONG  _DosAllocMem(PPVOID a, ULONG b, ULONG c)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosAllocMem(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  DosAllocMem
#define DosAllocMem _DosAllocMem

inline ULONG APIENTRY _DosAllocSharedMem(PPVOID a, PCSZ b, ULONG c, ULONG d)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosAllocSharedMem(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  DosAllocSharedMem
#define DosAllocSharedMem _DosAllocSharedMem

inline ULONG APIENTRY _DosFreeMem(PVOID a)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosFreeMem(a);
    SetFS(sel);

    return yyrc;
} 

#undef  DosFreeMem
#define DosFreeMem _DosFreeMem

inline ULONG APIENTRY _DosGetNamedSharedMem(PPVOID a, PCSZ b, ULONG c)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosGetNamedSharedMem(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  DosGetNamedSharedMem
#define DosGetNamedSharedMem _DosGetNamedSharedMem

inline ULONG APIENTRY _DosGetSharedMem(PVOID a, ULONG b)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosGetSharedMem(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  DosGetSharedMem
#define DosGetSharedMem _DosGetSharedMem

inline ULONG APIENTRY _DosGiveSharedMem(PVOID a, PID b, ULONG c)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosGiveSharedMem(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  DosGiveSharedMem
#define DosGiveSharedMem _DosGiveSharedMem

inline ULONG APIENTRY _DosQueryMem(PVOID a, PULONG b, PULONG c)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosQueryMem(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  DosQueryMem
#define DosQueryMem _DosQueryMem

inline ULONG APIENTRY _DosSetMem(PVOID a, ULONG b, ULONG c)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosSetMem(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  DosSetMem
#define DosSetMem _DosSetMem

inline ULONG APIENTRY _DosSubAllocMem(PVOID a, PPVOID b, ULONG c)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosSubAllocMem(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  DosSubAllocMem
#define DosSubAllocMem _DosSubAllocMem

inline ULONG APIENTRY _DosSubFreeMem(PVOID a, PVOID b, ULONG c)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosSubFreeMem(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  DosSubFreeMem
#define DosSubFreeMem _DosSubFreeMem

inline ULONG APIENTRY _DosSubSetMem(PVOID a, ULONG b, ULONG c)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosSubSetMem(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  DosSubSetMem
#define DosSubSetMem _DosSubSetMem

inline ULONG APIENTRY _DosSubUnsetMem(PVOID a)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosSubUnsetMem(a);
    SetFS(sel);

    return yyrc;
} 

#undef  DosSubUnsetMem
#define DosSubUnsetMem _DosSubUnsetMem

#endif
#ifdef INCL_DOSFILEMGR
inline ULONG APIENTRY _DosCancelLockRequest(HFILE a, PFILELOCK b)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosCancelLockRequest(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  DosCancelLockRequest
#define DosCancelLockRequest _DosCancelLockRequest

inline ULONG APIENTRY _DosClose(HFILE a)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosClose(a);
    SetFS(sel);

    return yyrc;
} 

#undef  DosClose
#define DosClose _DosClose

inline ULONG APIENTRY _DosCopy(PCSZ a, PCSZ b, ULONG c)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosCopy(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  DosCopy
#define DosCopy _DosCopy

inline ULONG APIENTRY _DosCreateDir(PCSZ a, PEAOP2 b)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosCreateDir(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  DosCreateDir
#define DosCreateDir _DosCreateDir

inline ULONG APIENTRY _DosDelete(PCSZ a)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosDelete(a);
    SetFS(sel);

    return yyrc;
} 

#undef  DosDelete
#define DosDelete _DosDelete

inline ULONG APIENTRY _DosDeleteDir(PCSZ a)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosDeleteDir(a);
    SetFS(sel);

    return yyrc;
} 

#undef  DosDeleteDir
#define DosDeleteDir _DosDeleteDir

inline ULONG APIENTRY _DosDupHandle(HFILE a, PHFILE b)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosDupHandle(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  DosDupHandle
#define DosDupHandle _DosDupHandle

inline ULONG APIENTRY _DosEditName(ULONG a, PCSZ b, PCSZ c, PBYTE d, ULONG e)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosEditName(a, b, c, d, e);
    SetFS(sel);

    return yyrc;
} 

#undef  DosEditName
#define DosEditName _DosEditName

inline ULONG APIENTRY _DosEnumAttribute(ULONG a, PVOID b, ULONG c, PVOID d, ULONG e, PULONG f, ULONG g)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosEnumAttribute(a, b, c, d, e, f, g);
    SetFS(sel);

    return yyrc;
} 

#undef  DosEnumAttribute
#define DosEnumAttribute _DosEnumAttribute

inline ULONG APIENTRY _DosFindClose(HDIR a)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosFindClose(a);
    SetFS(sel);

    return yyrc;
} 

#undef  DosFindClose
#define DosFindClose _DosFindClose

inline ULONG APIENTRY _DosFindFirst(PCSZ a, PHDIR b, ULONG c, PVOID d, ULONG e, PULONG f, ULONG g)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosFindFirst(a, b, c, d, e, f, g);
    SetFS(sel);

    return yyrc;
} 

#undef  DosFindFirst
#define DosFindFirst _DosFindFirst

inline ULONG APIENTRY _DosFindNext(HDIR a, PVOID b, ULONG c, PULONG d)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosFindNext(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  DosFindNext
#define DosFindNext _DosFindNext

inline ULONG APIENTRY _DosForceDelete(PCSZ a)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosForceDelete(a);
    SetFS(sel);

    return yyrc;
} 

#undef  DosForceDelete
#define DosForceDelete _DosForceDelete

inline ULONG APIENTRY _DosFSAttach(PCSZ a, PCSZ b, PVOID c, ULONG d, ULONG e)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosFSAttach(a, b, c, d, e);
    SetFS(sel);

    return yyrc;
} 

#undef  DosFSAttach
#define DosFSAttach _DosFSAttach

inline ULONG APIENTRY _DosFSCtl(PVOID a, ULONG b, PULONG c, PVOID d, ULONG e, PULONG f, ULONG g, PCSZ h, HFILE i, ULONG j)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosFSCtl(a, b, c, d, e, f, g, h, i, j);
    SetFS(sel);

    return yyrc;
} 

#undef  DosFSCtl
#define DosFSCtl _DosFSCtl

inline ULONG APIENTRY _DosMove(PCSZ a, PCSZ b)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosMove(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  DosMove
#define DosMove _DosMove

inline ULONG APIENTRY _DosOpen(PCSZ a, PHFILE b, PULONG c, ULONG d, ULONG e, ULONG f, ULONG g, PEAOP2 h)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosOpen(a, b, c, d, e, f, g, h);
    SetFS(sel);

    return yyrc;
} 

#undef  DosOpen
#define DosOpen _DosOpen

inline ULONG APIENTRY _DosProtectClose(HFILE a, FHLOCK b)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosProtectClose(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  DosProtectClose
#define DosProtectClose _DosProtectClose

inline ULONG APIENTRY _DosProtectEnumAttribute(ULONG a, PVOID b, ULONG c, PVOID d, ULONG e, PULONG f, ULONG g, FHLOCK h)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosProtectEnumAttribute(a, b, c, d, e, f, g, h);
    SetFS(sel);

    return yyrc;
} 

#undef  DosProtectEnumAttribute
#define DosProtectEnumAttribute _DosProtectEnumAttribute

inline ULONG APIENTRY _DosProtectOpen(PCSZ a, PHFILE b, PULONG c, ULONG d, ULONG e, ULONG f, ULONG g, PEAOP2 h, PFHLOCK i)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosProtectOpen(a, b, c, d, e, f, g, h, i);
    SetFS(sel);

    return yyrc;
} 

#undef  DosProtectOpen
#define DosProtectOpen _DosProtectOpen

inline ULONG APIENTRY _DosProtectQueryFHState(HFILE a, PULONG b, FHLOCK c)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosProtectQueryFHState(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  DosProtectQueryFHState
#define DosProtectQueryFHState _DosProtectQueryFHState

inline ULONG APIENTRY _DosProtectQueryFileInfo(HFILE a, ULONG b, PVOID c, ULONG d, FHLOCK e)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosProtectQueryFileInfo(a, b, c, d, e);
    SetFS(sel);

    return yyrc;
} 

#undef  DosProtectQueryFileInfo
#define DosProtectQueryFileInfo _DosProtectQueryFileInfo

inline ULONG APIENTRY _DosProtectRead(HFILE a, PVOID b, ULONG c, PULONG d, FHLOCK e)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosProtectRead(a, b, c, d, e);
    SetFS(sel);

    return yyrc;
} 

#undef  DosProtectRead
#define DosProtectRead _DosProtectRead

inline ULONG APIENTRY _DosProtectSetFHState(HFILE a, ULONG b, FHLOCK c)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosProtectSetFHState(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  DosProtectSetFHState
#define DosProtectSetFHState _DosProtectSetFHState

inline ULONG APIENTRY _DosProtectSetFileInfo(HFILE a, ULONG b, PVOID c, ULONG d, FHLOCK e)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosProtectSetFileInfo(a, b, c, d, e);
    SetFS(sel);

    return yyrc;
} 

#undef  DosProtectSetFileInfo
#define DosProtectSetFileInfo _DosProtectSetFileInfo

inline ULONG APIENTRY _DosProtectSetFileLocks(HFILE a, PFILELOCK b, PFILELOCK c, ULONG d, ULONG e, FHLOCK f)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosProtectSetFileLocks(a, b, c, d, e, f);
    SetFS(sel);

    return yyrc;
} 

#undef  DosProtectSetFileLocks
#define DosProtectSetFileLocks _DosProtectSetFileLocks

inline ULONG APIENTRY _DosProtectSetFilePtr(HFILE a, LONG b, ULONG c, PULONG d, FHLOCK e)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosProtectSetFilePtr(a, b, c, d, e);
    SetFS(sel);

    return yyrc;
} 

#undef  DosProtectSetFilePtr
#define DosProtectSetFilePtr _DosProtectSetFilePtr

inline ULONG APIENTRY _DosProtectSetFileSize(HFILE a, ULONG b, FHLOCK c)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosProtectSetFileSize(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  DosProtectSetFileSize
#define DosProtectSetFileSize _DosProtectSetFileSize

inline ULONG APIENTRY _DosProtectWrite(HFILE a, PVOID b, ULONG c, PULONG d, FHLOCK e)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosProtectWrite(a, b, c, d, e);
    SetFS(sel);

    return yyrc;
} 

#undef  DosProtectWrite
#define DosProtectWrite _DosProtectWrite

inline ULONG APIENTRY _DosQueryCurrentDir(ULONG a, PBYTE b, PULONG c)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosQueryCurrentDir(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  DosQueryCurrentDir
#define DosQueryCurrentDir _DosQueryCurrentDir

inline ULONG APIENTRY _DosQueryCurrentDisk(PULONG a, PULONG b)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosQueryCurrentDisk(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  DosQueryCurrentDisk
#define DosQueryCurrentDisk _DosQueryCurrentDisk

inline ULONG APIENTRY _DosQueryFHState(HFILE a, PULONG b)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosQueryFHState(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  DosQueryFHState
#define DosQueryFHState _DosQueryFHState

inline ULONG APIENTRY _DosQueryFileInfo(HFILE a, ULONG b, PVOID c, ULONG d)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosQueryFileInfo(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  DosQueryFileInfo
#define DosQueryFileInfo _DosQueryFileInfo

inline ULONG APIENTRY _DosQueryFSAttach(PCSZ a, ULONG b, ULONG c, PFSQBUFFER2 d, PULONG e)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosQueryFSAttach(a, b, c, d, e);
    SetFS(sel);

    return yyrc;
} 

#undef  DosQueryFSAttach
#define DosQueryFSAttach _DosQueryFSAttach

inline ULONG APIENTRY _DosQueryFSInfo(ULONG a, ULONG b, PVOID c, ULONG d)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosQueryFSInfo(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  DosQueryFSInfo
#define DosQueryFSInfo _DosQueryFSInfo

inline ULONG APIENTRY _DosQueryHType(HFILE a, PULONG b, PULONG c)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosQueryHType(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  DosQueryHType
#define DosQueryHType _DosQueryHType

inline ULONG APIENTRY _DosQueryPathInfo(PCSZ a, ULONG b, PVOID c, ULONG d)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosQueryPathInfo(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  DosQueryPathInfo
#define DosQueryPathInfo _DosQueryPathInfo

inline ULONG APIENTRY _DosQueryVerify(PBOOL32 a)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosQueryVerify(a);
    SetFS(sel);

    return yyrc;
} 

#undef  DosQueryVerify
#define DosQueryVerify _DosQueryVerify

inline ULONG APIENTRY _DosRead(HFILE a, PVOID b, ULONG c, PULONG d)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosRead(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  DosRead
#define DosRead _DosRead

inline ULONG APIENTRY _DosResetBuffer(HFILE a)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosResetBuffer(a);
    SetFS(sel);

    return yyrc;
} 

#undef  DosResetBuffer
#define DosResetBuffer _DosResetBuffer

inline ULONG APIENTRY _DosSetCurrentDir(PCSZ a)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosSetCurrentDir(a);
    SetFS(sel);

    return yyrc;
} 

#undef  DosSetCurrentDir
#define DosSetCurrentDir _DosSetCurrentDir

inline ULONG APIENTRY _DosSetDefaultDisk(ULONG a)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosSetDefaultDisk(a);
    SetFS(sel);

    return yyrc;
} 

#undef  DosSetDefaultDisk
#define DosSetDefaultDisk _DosSetDefaultDisk

inline ULONG APIENTRY _DosSetFHState(HFILE a, ULONG b)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosSetFHState(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  DosSetFHState
#define DosSetFHState _DosSetFHState

inline ULONG APIENTRY _DosSetFileInfo(HFILE a, ULONG b, PVOID c, ULONG d)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosSetFileInfo(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  DosSetFileInfo
#define DosSetFileInfo _DosSetFileInfo

inline ULONG APIENTRY _DosSetFileLocks(HFILE a, PFILELOCK b, PFILELOCK c, ULONG d, ULONG e)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosSetFileLocks(a, b, c, d, e);
    SetFS(sel);

    return yyrc;
} 

#undef  DosSetFileLocks
#define DosSetFileLocks _DosSetFileLocks

inline ULONG APIENTRY _DosSetFilePtr(HFILE a, LONG b, ULONG c, PULONG d)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosSetFilePtr(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  DosSetFilePtr
#define DosSetFilePtr _DosSetFilePtr

inline ULONG APIENTRY _DosSetFileSize(HFILE a, ULONG b)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosSetFileSize(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  DosSetFileSize
#define DosSetFileSize _DosSetFileSize

inline ULONG APIENTRY _DosSetFSInfo(ULONG a, ULONG b, PVOID c, ULONG d)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosSetFSInfo(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  DosSetFSInfo
#define DosSetFSInfo _DosSetFSInfo

inline ULONG APIENTRY _DosSetMaxFH(ULONG a)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosSetMaxFH(a);
    SetFS(sel);

    return yyrc;
} 

#undef  DosSetMaxFH
#define DosSetMaxFH _DosSetMaxFH

inline ULONG APIENTRY _DosSetPathInfo(PCSZ a, ULONG b, PVOID c, ULONG d, ULONG e)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosSetPathInfo(a, b, c, d, e);
    SetFS(sel);

    return yyrc;
} 

#undef  DosSetPathInfo
#define DosSetPathInfo _DosSetPathInfo

inline ULONG APIENTRY _DosSetRelMaxFH(PLONG a, PULONG b)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosSetRelMaxFH(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  DosSetRelMaxFH
#define DosSetRelMaxFH _DosSetRelMaxFH

inline ULONG APIENTRY _DosSetVerify(BOOL32 a)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosSetVerify(a);
    SetFS(sel);

    return yyrc;
} 

#undef  DosSetVerify
#define DosSetVerify _DosSetVerify

inline ULONG APIENTRY _DosShutdown(ULONG a)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosShutdown(a);
    SetFS(sel);

    return yyrc;
} 

#undef  DosShutdown
#define DosShutdown _DosShutdown

inline ULONG APIENTRY _DosWrite(HFILE a, PVOID b, ULONG c, PULONG d)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosWrite(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  DosWrite
#define DosWrite _DosWrite

#endif
#ifdef INCL_DOSMISC
inline ULONG APIENTRY _DosSearchPath(ULONG a, PCSZ b, PCSZ c, PBYTE d, ULONG e)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosSearchPath(a, b, c, d, e);
    SetFS(sel);

    return yyrc;
} 

#undef  DosSearchPath
#define DosSearchPath _DosSearchPath

#endif
#ifdef INCL_DOSDEVICES
inline ULONG APIENTRY _DosDevConfig(PVOID a, ULONG b)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosDevConfig(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  DosDevConfig
#define DosDevConfig _DosDevConfig

inline ULONG APIENTRY _DosDevIOCtl(HFILE a, ULONG b, ULONG c, PVOID d, ULONG e, PULONG f, PVOID g, ULONG h, PULONG i)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosDevIOCtl(a, b, c, d, e, f, g, h, i);
    SetFS(sel);

    return yyrc;
} 

#undef  DosDevIOCtl
#define DosDevIOCtl _DosDevIOCtl

inline ULONG APIENTRY _DosPhysicalDisk(ULONG a, PVOID b, ULONG c, PVOID d, ULONG e)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosPhysicalDisk(a, b, c, d, e);
    SetFS(sel);

    return yyrc;
} 

#undef  DosPhysicalDisk
#define DosPhysicalDisk _DosPhysicalDisk

#endif
#ifdef INCL_DOSNLS
inline ULONG APIENTRY _DosMapCase(ULONG a, PCOUNTRYCODE b, PCHAR c)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosMapCase(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  DosMapCase
#define DosMapCase _DosMapCase

inline ULONG APIENTRY _DosQueryCollate(ULONG a, PCOUNTRYCODE b, PCHAR c, PULONG d)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosQueryCollate(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  DosQueryCollate
#define DosQueryCollate _DosQueryCollate

inline ULONG APIENTRY _DosQueryCp(ULONG a, PULONG b, PULONG c)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosQueryCp(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  DosQueryCp
#define DosQueryCp _DosQueryCp

inline ULONG APIENTRY _DosQueryCtryInfo(ULONG a, PCOUNTRYCODE b, PCOUNTRYINFO c, PULONG d)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosQueryCtryInfo(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  DosQueryCtryInfo
#define DosQueryCtryInfo _DosQueryCtryInfo

inline ULONG APIENTRY _DosQueryDBCSEnv(ULONG a, PCOUNTRYCODE b, PCHAR c)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosQueryDBCSEnv(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  DosQueryDBCSEnv
#define DosQueryDBCSEnv _DosQueryDBCSEnv

inline ULONG APIENTRY _DosSetProcessCp(ULONG a)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosSetProcessCp(a);
    SetFS(sel);

    return yyrc;
} 

#undef  DosSetProcessCp
#define DosSetProcessCp _DosSetProcessCp

#endif
#ifdef INCL_DOSMODULEMGR
inline ULONG APIENTRY _DosFreeModule(HMODULE a)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosFreeModule(a);
    SetFS(sel);

    return yyrc;
} 

#undef  DosFreeModule
#define DosFreeModule _DosFreeModule

inline ULONG APIENTRY _DosLoadModule(PSZ a, ULONG b, PCSZ c, PHMODULE d)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosLoadModule(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  DosLoadModule
#define DosLoadModule _DosLoadModule

inline ULONG APIENTRY _DosQueryModuleHandle(PCSZ a, PHMODULE b)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosQueryModuleHandle(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  DosQueryModuleHandle
#define DosQueryModuleHandle _DosQueryModuleHandle

inline ULONG APIENTRY _DosQueryModuleName(HMODULE a, ULONG b, PCHAR c)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosQueryModuleName(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  DosQueryModuleName
#define DosQueryModuleName _DosQueryModuleName

inline ULONG APIENTRY _DosQueryProcAddr(HMODULE a, ULONG b, PCSZ c, PFN *d)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosQueryProcAddr(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  DosQueryProcAddr
#define DosQueryProcAddr _DosQueryProcAddr

inline ULONG APIENTRY _DosQueryProcType(HMODULE a, ULONG b, PCSZ c, PULONG d)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosQueryProcType(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  DosQueryProcType
#define DosQueryProcType _DosQueryProcType

#endif
#ifdef INCL_DOSRESOURCES
inline ULONG APIENTRY _DosFreeResource(PVOID a)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosFreeResource(a);
    SetFS(sel);

    return yyrc;
} 

#undef  DosFreeResource
#define DosFreeResource _DosFreeResource

inline ULONG APIENTRY _DosGetResource(HMODULE a, ULONG b, ULONG c, PPVOID d)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosGetResource(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  DosGetResource
#define DosGetResource _DosGetResource

inline ULONG APIENTRY _DosQueryResourceSize(HMODULE a, ULONG b, ULONG c, PULONG d)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosQueryResourceSize(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  DosQueryResourceSize
#define DosQueryResourceSize _DosQueryResourceSize

#endif
#ifdef INCL_DOSPROCESS
inline ULONG APIENTRY _DosBeep(ULONG a, ULONG b)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosBeep(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  DosBeep
#define DosBeep _DosBeep

inline VOID APIENTRY _DosExit(ULONG a, ULONG b)
{
 USHORT sel = GetFS();

    DosExit(a, b);
    SetFS(sel);
} 

#undef  DosExit
#define DosExit _DosExit

inline ULONG APIENTRY _DosAllocThreadLocalMemory(ULONG a, PULONG *b)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosAllocThreadLocalMemory(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  DosAllocThreadLocalMemory
#define DosAllocThreadLocalMemory _DosAllocThreadLocalMemory

inline ULONG APIENTRY _DosCreateThread(PTID a, PFNTHREAD b, ULONG c, ULONG d, ULONG e)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosCreateThread(a, b, c, d, e);
    SetFS(sel);

    return yyrc;
} 

#undef  DosCreateThread
#define DosCreateThread _DosCreateThread

inline ULONG APIENTRY _DosEnterCritSec()
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosEnterCritSec();
    SetFS(sel);

    return yyrc;
} 

#undef  DosEnterCritSec
#define DosEnterCritSec _DosEnterCritSec

inline ULONG APIENTRY _DosExecPgm(PCHAR a, LONG b, ULONG c, PCSZ d, PCSZ e, PRESULTCODES f, PCSZ g)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosExecPgm(a, b, c, d, e, f, g);
    SetFS(sel);

    return yyrc;
} 

#undef  DosExecPgm
#define DosExecPgm _DosExecPgm

inline ULONG APIENTRY _DosExitCritSec()
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosExitCritSec();
    SetFS(sel);

    return yyrc;
} 

#undef  DosExitCritSec
#define DosExitCritSec _DosExitCritSec

inline ULONG APIENTRY _DosExitList(ULONG a, PFNEXITLIST b)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosExitList(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  DosExitList
#define DosExitList _DosExitList

inline ULONG APIENTRY _DosFreeThreadLocalMemory(ULONG *a)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosFreeThreadLocalMemory(a);
    SetFS(sel);

    return yyrc;
} 

#undef  DosFreeThreadLocalMemory
#define DosFreeThreadLocalMemory _DosFreeThreadLocalMemory

inline ULONG APIENTRY _DosGetInfoBlocks(PTIB *a, PPIB *b)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosGetInfoBlocks(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  DosGetInfoBlocks
#define DosGetInfoBlocks _DosGetInfoBlocks

inline ULONG APIENTRY _DosKillProcess(ULONG a, PID b)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosKillProcess(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  DosKillProcess
#define DosKillProcess _DosKillProcess

inline ULONG APIENTRY _DosKillThread(TID a)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosKillThread(a);
    SetFS(sel);

    return yyrc;
} 

#undef  DosKillThread
#define DosKillThread _DosKillThread

inline ULONG APIENTRY _DosResumeThread(TID a)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosResumeThread(a);
    SetFS(sel);

    return yyrc;
} 

#undef  DosResumeThread
#define DosResumeThread _DosResumeThread

inline ULONG APIENTRY _DosSetPriority(ULONG a, ULONG b, LONG c, ULONG d)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosSetPriority(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  DosSetPriority
#define DosSetPriority _DosSetPriority

inline ULONG APIENTRY _DosSleep(ULONG a)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosSleep(a);
    SetFS(sel);

    return yyrc;
} 

#undef  DosSleep
#define DosSleep _DosSleep

inline ULONG APIENTRY _DosSuspendThread(TID a)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosSuspendThread(a);
    SetFS(sel);

    return yyrc;
} 

#undef  DosSuspendThread
#define DosSuspendThread _DosSuspendThread

inline ULONG APIENTRY _DosWaitChild(ULONG a, ULONG b, PRESULTCODES c, PPID d, PID e)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosWaitChild(a, b, c, d, e);
    SetFS(sel);

    return yyrc;
} 

#undef  DosWaitChild
#define DosWaitChild _DosWaitChild

inline ULONG APIENTRY _DosWaitThread(PTID a, ULONG b)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosWaitThread(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  DosWaitThread
#define DosWaitThread _DosWaitThread

#endif
#ifdef INCL_DOSSESMGR
inline ULONG APIENTRY _DosQueryAppType(PCSZ a, PULONG b)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosQueryAppType(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  DosQueryAppType
#define DosQueryAppType _DosQueryAppType

inline ULONG APIENTRY _DosSelectSession(ULONG a)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosSelectSession(a);
    SetFS(sel);

    return yyrc;
} 

#undef  DosSelectSession
#define DosSelectSession _DosSelectSession

inline ULONG APIENTRY _DosSetSession(ULONG a, PSTATUSDATA b)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosSetSession(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  DosSetSession
#define DosSetSession _DosSetSession

inline ULONG APIENTRY _DosStartSession(PSTARTDATA a, PULONG b, PPID c)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosStartSession(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  DosStartSession
#define DosStartSession _DosStartSession

inline ULONG APIENTRY _DosStopSession(ULONG a, ULONG b)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosStopSession(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  DosStopSession
#define DosStopSession _DosStopSession

#endif
#ifdef INCL_DOSSEMAPHORES
inline ULONG APIENTRY _DosCloseEventSem(HEV a)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosCloseEventSem(a);
    SetFS(sel);

    return yyrc;
} 

#undef  DosCloseEventSem
#define DosCloseEventSem _DosCloseEventSem

inline ULONG APIENTRY _DosCreateEventSem(PCSZ a, PHEV b, ULONG c, BOOL32 d)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosCreateEventSem(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  DosCreateEventSem
#define DosCreateEventSem _DosCreateEventSem

inline ULONG APIENTRY _DosOpenEventSem(PCSZ a, PHEV b)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosOpenEventSem(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  DosOpenEventSem
#define DosOpenEventSem _DosOpenEventSem

inline ULONG APIENTRY _DosPostEventSem(HEV a)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosPostEventSem(a);
    SetFS(sel);

    return yyrc;
} 

#undef  DosPostEventSem
#define DosPostEventSem _DosPostEventSem

inline ULONG APIENTRY _DosQueryEventSem(HEV a, PULONG b)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosQueryEventSem(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  DosQueryEventSem
#define DosQueryEventSem _DosQueryEventSem

inline ULONG APIENTRY _DosResetEventSem(HEV a, PULONG b)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosResetEventSem(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  DosResetEventSem
#define DosResetEventSem _DosResetEventSem

inline ULONG APIENTRY _DosWaitEventSem(HEV a, ULONG b)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosWaitEventSem(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  DosWaitEventSem
#define DosWaitEventSem _DosWaitEventSem

inline ULONG APIENTRY _DosCloseMutexSem(HMTX a)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosCloseMutexSem(a);
    SetFS(sel);

    return yyrc;
} 

#undef  DosCloseMutexSem
#define DosCloseMutexSem _DosCloseMutexSem

inline ULONG APIENTRY _DosCreateMutexSem(PCSZ a, PHMTX b, ULONG c, BOOL32 d)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosCreateMutexSem(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  DosCreateMutexSem
#define DosCreateMutexSem _DosCreateMutexSem

inline ULONG APIENTRY _DosOpenMutexSem(PCSZ a, PHMTX b)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosOpenMutexSem(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  DosOpenMutexSem
#define DosOpenMutexSem _DosOpenMutexSem

inline ULONG APIENTRY _DosQueryMutexSem(HMTX a, PPID b, PTID c, PULONG d)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosQueryMutexSem(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  DosQueryMutexSem
#define DosQueryMutexSem _DosQueryMutexSem

inline ULONG APIENTRY _DosReleaseMutexSem(HMTX a)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosReleaseMutexSem(a);
    SetFS(sel);

    return yyrc;
} 

#undef  DosReleaseMutexSem
#define DosReleaseMutexSem _DosReleaseMutexSem

inline ULONG APIENTRY _DosRequestMutexSem(HMTX a, ULONG b)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosRequestMutexSem(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  DosRequestMutexSem
#define DosRequestMutexSem _DosRequestMutexSem

inline ULONG APIENTRY _DosAddMuxWaitSem(HMUX a, PSEMRECORD b)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosAddMuxWaitSem(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  DosAddMuxWaitSem
#define DosAddMuxWaitSem _DosAddMuxWaitSem

inline ULONG APIENTRY _DosCloseMuxWaitSem(HMUX a)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosCloseMuxWaitSem(a);
    SetFS(sel);

    return yyrc;
} 

#undef  DosCloseMuxWaitSem
#define DosCloseMuxWaitSem _DosCloseMuxWaitSem

inline ULONG APIENTRY _DosCreateMuxWaitSem(PCSZ a, PHMUX b, ULONG c, PSEMRECORD d, ULONG e)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosCreateMuxWaitSem(a, b, c, d, e);
    SetFS(sel);

    return yyrc;
} 

#undef  DosCreateMuxWaitSem
#define DosCreateMuxWaitSem _DosCreateMuxWaitSem

inline ULONG APIENTRY _DosDeleteMuxWaitSem(HMUX a, HSEM b)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosDeleteMuxWaitSem(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  DosDeleteMuxWaitSem
#define DosDeleteMuxWaitSem _DosDeleteMuxWaitSem

inline ULONG APIENTRY _DosOpenMuxWaitSem(PCSZ a, PHMUX b)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosOpenMuxWaitSem(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  DosOpenMuxWaitSem
#define DosOpenMuxWaitSem _DosOpenMuxWaitSem

inline ULONG APIENTRY _DosQueryMuxWaitSem(HMUX a, PULONG b, PSEMRECORD c, PULONG d)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosQueryMuxWaitSem(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  DosQueryMuxWaitSem
#define DosQueryMuxWaitSem _DosQueryMuxWaitSem

inline ULONG APIENTRY _DosWaitMuxWaitSem(HMUX a, ULONG b, PULONG c)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosWaitMuxWaitSem(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  DosWaitMuxWaitSem
#define DosWaitMuxWaitSem _DosWaitMuxWaitSem

#endif
#ifdef INCL_DOSNMPIPES
inline ULONG APIENTRY _DosCallNPipe(PCSZ a, PVOID b, ULONG c, PVOID d, ULONG e, PULONG f, ULONG g)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosCallNPipe(a, b, c, d, e, f, g);
    SetFS(sel);

    return yyrc;
} 

#undef  DosCallNPipe
#define DosCallNPipe _DosCallNPipe

inline ULONG APIENTRY _DosConnectNPipe(HPIPE a)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosConnectNPipe(a);
    SetFS(sel);

    return yyrc;
} 

#undef  DosConnectNPipe
#define DosConnectNPipe _DosConnectNPipe

inline ULONG APIENTRY _DosCreateNPipe(PCSZ a, PHPIPE b, ULONG c, ULONG d, ULONG e, ULONG f, ULONG g)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosCreateNPipe(a, b, c, d, e, f, g);
    SetFS(sel);

    return yyrc;
} 

#undef  DosCreateNPipe
#define DosCreateNPipe _DosCreateNPipe

inline ULONG APIENTRY _DosDisConnectNPipe(HPIPE a)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosDisConnectNPipe(a);
    SetFS(sel);

    return yyrc;
} 

#undef  DosDisConnectNPipe
#define DosDisConnectNPipe _DosDisConnectNPipe

inline ULONG APIENTRY _DosPeekNPipe(HPIPE a, PVOID b, ULONG c, PULONG d, PAVAILDATA e, PULONG f)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosPeekNPipe(a, b, c, d, e, f);
    SetFS(sel);

    return yyrc;
} 

#undef  DosPeekNPipe
#define DosPeekNPipe _DosPeekNPipe

inline ULONG APIENTRY _DosQueryNPHState(HPIPE a, PULONG b)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosQueryNPHState(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  DosQueryNPHState
#define DosQueryNPHState _DosQueryNPHState

inline ULONG APIENTRY _DosQueryNPipeInfo(HPIPE a, ULONG b, PVOID c, ULONG d)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosQueryNPipeInfo(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  DosQueryNPipeInfo
#define DosQueryNPipeInfo _DosQueryNPipeInfo

inline ULONG APIENTRY _DosQueryNPipeSemState(HSEM a, PPIPESEMSTATE b, ULONG c)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosQueryNPipeSemState(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  DosQueryNPipeSemState
#define DosQueryNPipeSemState _DosQueryNPipeSemState

inline ULONG APIENTRY _DosRawReadNPipe(PCSZ a, ULONG b, PULONG c, PVOID d)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosRawReadNPipe(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  DosRawReadNPipe
#define DosRawReadNPipe _DosRawReadNPipe

inline ULONG APIENTRY _DosRawWriteNPipe(PCSZ a, ULONG b)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosRawWriteNPipe(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  DosRawWriteNPipe
#define DosRawWriteNPipe _DosRawWriteNPipe

inline ULONG APIENTRY _DosSetNPHState(HPIPE a, ULONG b)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosSetNPHState(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  DosSetNPHState
#define DosSetNPHState _DosSetNPHState

inline ULONG APIENTRY _DosSetNPipeSem(HPIPE a, HSEM b, ULONG c)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosSetNPipeSem(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  DosSetNPipeSem
#define DosSetNPipeSem _DosSetNPipeSem

inline ULONG APIENTRY _DosTransactNPipe(HPIPE a, PVOID b, ULONG c, PVOID d, ULONG e, PULONG f)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosTransactNPipe(a, b, c, d, e, f);
    SetFS(sel);

    return yyrc;
} 

#undef  DosTransactNPipe
#define DosTransactNPipe _DosTransactNPipe

inline ULONG APIENTRY _DosWaitNPipe(PCSZ a, ULONG b)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosWaitNPipe(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  DosWaitNPipe
#define DosWaitNPipe _DosWaitNPipe

inline ULONG APIENTRY _DosCreatePipe(PHFILE a, PHFILE b, ULONG c)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosCreatePipe(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  DosCreatePipe
#define DosCreatePipe _DosCreatePipe

#endif
#ifdef INCL_DOSQUEUES
inline ULONG APIENTRY _DosCloseQueue(HQUEUE a)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosCloseQueue(a);
    SetFS(sel);

    return yyrc;
} 

#undef  DosCloseQueue
#define DosCloseQueue _DosCloseQueue

inline ULONG APIENTRY _DosCreateQueue(PHQUEUE a, ULONG b, PCSZ c)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosCreateQueue(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  DosCreateQueue
#define DosCreateQueue _DosCreateQueue

inline ULONG APIENTRY _DosOpenQueue(PPID a, PHQUEUE b, PCSZ c)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosOpenQueue(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  DosOpenQueue
#define DosOpenQueue _DosOpenQueue

inline ULONG APIENTRY _DosPeekQueue(HQUEUE a, PREQUESTDATA b, PULONG c, PPVOID d, PULONG e, BOOL32 f, PBYTE g, HEV h)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosPeekQueue(a, b, c, d, e, f, g, h);
    SetFS(sel);

    return yyrc;
} 

#undef  DosPeekQueue
#define DosPeekQueue _DosPeekQueue

inline ULONG APIENTRY _DosPurgeQueue(HQUEUE a)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosPurgeQueue(a);
    SetFS(sel);

    return yyrc;
} 

#undef  DosPurgeQueue
#define DosPurgeQueue _DosPurgeQueue

inline ULONG APIENTRY _DosQueryQueue(HQUEUE a, PULONG b)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosQueryQueue(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  DosQueryQueue
#define DosQueryQueue _DosQueryQueue

inline ULONG APIENTRY _DosReadQueue(HQUEUE a, PREQUESTDATA b, PULONG c, PPVOID d, ULONG e, BOOL32 f, PBYTE g, HEV h)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosReadQueue(a, b, c, d, e, f, g, h);
    SetFS(sel);

    return yyrc;
} 

#undef  DosReadQueue
#define DosReadQueue _DosReadQueue

inline ULONG APIENTRY _DosWriteQueue(HQUEUE a, ULONG b, ULONG c, PVOID d, ULONG e)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosWriteQueue(a, b, c, d, e);
    SetFS(sel);

    return yyrc;
} 

#undef  DosWriteQueue
#define DosWriteQueue _DosWriteQueue

#endif
#ifdef INCL_DOSEXCEPTIONS
inline ULONG APIENTRY _DosAcknowledgeSignalException(ULONG a)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosAcknowledgeSignalException(a);
    SetFS(sel);

    return yyrc;
} 

#undef  DosAcknowledgeSignalException
#define DosAcknowledgeSignalException _DosAcknowledgeSignalException

inline ULONG APIENTRY _DosEnterMustComplete(PULONG a)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosEnterMustComplete(a);
    SetFS(sel);

    return yyrc;
} 

#undef  DosEnterMustComplete
#define DosEnterMustComplete _DosEnterMustComplete

inline ULONG APIENTRY _DosExitMustComplete(PULONG a)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosExitMustComplete(a);
    SetFS(sel);

    return yyrc;
} 

#undef  DosExitMustComplete
#define DosExitMustComplete _DosExitMustComplete

inline ULONG APIENTRY _DosQueryThreadContext(TID a, ULONG b, PCONTEXTRECORD c)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosQueryThreadContext(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  DosQueryThreadContext
#define DosQueryThreadContext _DosQueryThreadContext

inline ULONG APIENTRY _DosRaiseException(PEXCEPTIONREPORTRECORD a)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosRaiseException(a);
    SetFS(sel);

    return yyrc;
} 

#undef  DosRaiseException
#define DosRaiseException _DosRaiseException

inline ULONG APIENTRY _DosSendSignalException(PID a, ULONG b)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosSendSignalException(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  DosSendSignalException
#define DosSendSignalException _DosSendSignalException

inline ULONG APIENTRY _DosSetExceptionHandler(PEXCEPTIONREGISTRATIONRECORD a)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosSetExceptionHandler(a);
    SetFS(sel);

    return yyrc;
} 

#undef  DosSetExceptionHandler
#define DosSetExceptionHandler _DosSetExceptionHandler

inline ULONG APIENTRY _DosSetSignalExceptionFocus(BOOL32 a, PULONG b)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosSetSignalExceptionFocus(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  DosSetSignalExceptionFocus
#define DosSetSignalExceptionFocus _DosSetSignalExceptionFocus

inline ULONG APIENTRY _DosUnsetExceptionHandler(PEXCEPTIONREGISTRATIONRECORD a)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosUnsetExceptionHandler(a);
    SetFS(sel);

    return yyrc;
} 

#undef  DosUnsetExceptionHandler
#define DosUnsetExceptionHandler _DosUnsetExceptionHandler

inline ULONG APIENTRY _DosUnwindException(PEXCEPTIONREGISTRATIONRECORD a, PVOID b, PEXCEPTIONREPORTRECORD c)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosUnwindException(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  DosUnwindException
#define DosUnwindException _DosUnwindException

#endif
#ifdef INCL_DOSMISC
inline ULONG APIENTRY _DosQuerySysInfo(ULONG a, ULONG b, PVOID c, ULONG d)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosQuerySysInfo(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  DosQuerySysInfo
#define DosQuerySysInfo _DosQuerySysInfo

inline ULONG APIENTRY _DosScanEnv(PCSZ a, PCSZ *b)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosScanEnv(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  DosScanEnv
#define DosScanEnv _DosScanEnv

inline ULONG APIENTRY _DosQueryRASInfo(ULONG a, PPVOID b)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosQueryRASInfo(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  DosQueryRASInfo
#define DosQueryRASInfo _DosQueryRASInfo

#endif
#ifdef INCL_DOSDATETIME
inline ULONG APIENTRY _DosGetDateTime(PDATETIME a)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosGetDateTime(a);
    SetFS(sel);

    return yyrc;
} 

#undef  DosGetDateTime
#define DosGetDateTime _DosGetDateTime

inline ULONG APIENTRY _DosSetDateTime(PDATETIME a)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosSetDateTime(a);
    SetFS(sel);

    return yyrc;
} 

#undef  DosSetDateTime
#define DosSetDateTime _DosSetDateTime

inline ULONG APIENTRY _DosAsyncTimer(ULONG a, HSEM b, PHTIMER c)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosAsyncTimer(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  DosAsyncTimer
#define DosAsyncTimer _DosAsyncTimer

inline ULONG APIENTRY _DosStartTimer(ULONG a, HSEM b, PHTIMER c)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosStartTimer(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  DosStartTimer
#define DosStartTimer _DosStartTimer

inline ULONG APIENTRY _DosStopTimer(HTIMER a)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosStopTimer(a);
    SetFS(sel);

    return yyrc;
} 

#undef  DosStopTimer
#define DosStopTimer _DosStopTimer

#endif
#ifdef DosTmrQueryFreq
inline ULONG APIENTRY _DosTmrQueryFreq(PULONG a)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosTmrQueryFreq(a);
    SetFS(sel);

    return yyrc;
} 

#undef  DosTmrQueryFreq
#define DosTmrQueryFreq _DosTmrQueryFreq

inline ULONG APIENTRY _DosTmrQueryTime(PQWORD a)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosTmrQueryTime(a);
    SetFS(sel);

    return yyrc;
} 

#undef  DosTmrQueryTime
#define DosTmrQueryTime _DosTmrQueryTime

#endif
#ifdef INCL_DOSMVDM
inline ULONG APIENTRY _DosCloseVDD(HVDD a)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosCloseVDD(a);
    SetFS(sel);

    return yyrc;
} 

#undef  DosCloseVDD
#define DosCloseVDD _DosCloseVDD

inline ULONG APIENTRY _DosOpenVDD(PCSZ a, PHVDD b)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosOpenVDD(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  DosOpenVDD
#define DosOpenVDD _DosOpenVDD

inline ULONG APIENTRY _DosQueryDOSProperty(SGID a, PCSZ b, ULONG c, PSZ d)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosQueryDOSProperty(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  DosQueryDOSProperty
#define DosQueryDOSProperty _DosQueryDOSProperty

inline ULONG APIENTRY _DosRequestVDD(HVDD a, SGID b, ULONG c, ULONG d, PVOID e, ULONG f, PVOID g)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosRequestVDD(a, b, c, d, e, f, g);
    SetFS(sel);

    return yyrc;
} 

#undef  DosRequestVDD
#define DosRequestVDD _DosRequestVDD

inline ULONG APIENTRY _DosSetDOSProperty(SGID a, PCSZ b, ULONG c, PCSZ d)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosSetDOSProperty(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  DosSetDOSProperty
#define DosSetDOSProperty _DosSetDOSProperty

#endif
#ifdef INCL_DOSPROCESS
inline ULONG APIENTRY _DosDebug(uDB_t *a)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosDebug(a);
    SetFS(sel);

    return yyrc;
} 

#undef  DosDebug
#define DosDebug _DosDebug

#endif
#ifdef INCL_DOSMISC
inline ULONG APIENTRY _DosGetMessage(PCHAR *a, ULONG b, PCHAR c, ULONG d, ULONG e, PCSZ f, PULONG g)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosGetMessage(a, b, c, d, e, f, g);
    SetFS(sel);

    return yyrc;
} 

#undef  DosGetMessage
#define DosGetMessage _DosGetMessage

inline ULONG APIENTRY _DosInsertMessage(PCHAR *a, ULONG b, PCSZ c, ULONG d, PCHAR e, ULONG f, PULONG g)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosInsertMessage(a, b, c, d, e, f, g);
    SetFS(sel);

    return yyrc;
} 

#undef  DosInsertMessage
#define DosInsertMessage _DosInsertMessage

inline ULONG APIENTRY _DosPutMessage(HFILE a, ULONG b, PCHAR c)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosPutMessage(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  DosPutMessage
#define DosPutMessage _DosPutMessage

inline ULONG APIENTRY _DosQueryMessageCP(PCHAR a, ULONG b, PCSZ c, PULONG d)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosQueryMessageCP(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  DosQueryMessageCP
#define DosQueryMessageCP _DosQueryMessageCP

#endif
#ifdef INCL_DOSRAS
inline ULONG APIENTRY _DosDumpProcess(ULONG a, ULONG b, PID c)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosDumpProcess(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  DosDumpProcess
#define DosDumpProcess _DosDumpProcess

inline ULONG APIENTRY _DosForceSystemDump(ULONG a)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosForceSystemDump(a);
    SetFS(sel);

    return yyrc;
} 

#undef  DosForceSystemDump
#define DosForceSystemDump _DosForceSystemDump

inline ULONG APIENTRY _DosQueryRASInfo(ULONG a, PPVOID b)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosQueryRASInfo(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  DosQueryRASInfo
#define DosQueryRASInfo _DosQueryRASInfo

inline ULONG APIENTRY _DosSuppressPopUps(ULONG a, ULONG b)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DosSuppressPopUps(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  DosSuppressPopUps
#define DosSuppressPopUps _DosSuppressPopUps

#endif
#ifdef INCL_RXSUBCOM
inline ULONG APIENTRY _RexxDeregisterSubcom(PCSZ a, PCSZ b)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = RexxDeregisterSubcom(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  RexxDeregisterSubcom
#define RexxDeregisterSubcom _RexxDeregisterSubcom

inline ULONG APIENTRY _RexxQuerySubcom(PCSZ a, PCSZ b, PUSHORT c, PUCHAR d)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = RexxQuerySubcom(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  RexxQuerySubcom
#define RexxQuerySubcom _RexxQuerySubcom

inline ULONG APIENTRY _RexxRegisterSubcomDll(PCSZ a, PCSZ b, PCSZ c, PUCHAR d, ULONG e)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = RexxRegisterSubcomDll(a, b, c, d, e);
    SetFS(sel);

    return yyrc;
} 

#undef  RexxRegisterSubcomDll
#define RexxRegisterSubcomDll _RexxRegisterSubcomDll

inline ULONG APIENTRY _RexxRegisterSubcomExe(PCSZ a, PFN b, PUCHAR c)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = RexxRegisterSubcomExe(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  RexxRegisterSubcomExe
#define RexxRegisterSubcomExe _RexxRegisterSubcomExe

#endif
#ifdef INCL_RXSHV
inline ULONG APIENTRY _RexxVariablePool(PSHVBLOCK a)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = RexxVariablePool(a);
    SetFS(sel);

    return yyrc;
} 

#undef  RexxVariablePool
#define RexxVariablePool _RexxVariablePool

#endif
#ifdef INCL_RXFUNC
inline ULONG APIENTRY _RexxDeregisterFunction(PCSZ a)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = RexxDeregisterFunction(a);
    SetFS(sel);

    return yyrc;
} 

#undef  RexxDeregisterFunction
#define RexxDeregisterFunction _RexxDeregisterFunction

inline ULONG APIENTRY _RexxQueryFunction(PCSZ a)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = RexxQueryFunction(a);
    SetFS(sel);

    return yyrc;
} 

#undef  RexxQueryFunction
#define RexxQueryFunction _RexxQueryFunction

inline ULONG APIENTRY _RexxRegisterFunctionDll(PCSZ a, PCSZ b, PCSZ c)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = RexxRegisterFunctionDll(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  RexxRegisterFunctionDll
#define RexxRegisterFunctionDll _RexxRegisterFunctionDll

inline ULONG APIENTRY _RexxRegisterFunctionExe(PCSZ a, RexxFunctionHandler *b)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = RexxRegisterFunctionExe(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  RexxRegisterFunctionExe
#define RexxRegisterFunctionExe _RexxRegisterFunctionExe

#endif
#ifdef INCL_RXSYSEXIT
inline ULONG APIENTRY _RexxDeregisterExit(PCSZ a, PCSZ b)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = RexxDeregisterExit(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  RexxDeregisterExit
#define RexxDeregisterExit _RexxDeregisterExit

inline ULONG APIENTRY _RexxQueryExit(PCSZ a, PCSZ b, PUSHORT c, PUCHAR d)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = RexxQueryExit(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  RexxQueryExit
#define RexxQueryExit _RexxQueryExit

inline ULONG APIENTRY _RexxRegisterExitDll(PCSZ a, PCSZ b, PCSZ c, PUCHAR d, ULONG e)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = RexxRegisterExitDll(a, b, c, d, e);
    SetFS(sel);

    return yyrc;
} 

#undef  RexxRegisterExitDll
#define RexxRegisterExitDll _RexxRegisterExitDll

inline ULONG APIENTRY _RexxRegisterExitExe(PCSZ a, PFN b, PUCHAR c)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = RexxRegisterExitExe(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  RexxRegisterExitExe
#define RexxRegisterExitExe _RexxRegisterExitExe

#endif
#ifdef INCL_RXARI
inline ULONG APIENTRY _RexxResetTrace(PID a, TID b)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = RexxResetTrace(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  RexxResetTrace
#define RexxResetTrace _RexxResetTrace

inline ULONG APIENTRY _RexxSetHalt(PID a, TID b)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = RexxSetHalt(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  RexxSetHalt
#define RexxSetHalt _RexxSetHalt

inline ULONG APIENTRY _RexxSetTrace(PID a, TID b)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = RexxSetTrace(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  RexxSetTrace
#define RexxSetTrace _RexxSetTrace

#endif
#ifdef INCL_RXMACRO
inline ULONG APIENTRY _RexxAddMacro(PCSZ a, PCSZ b, ULONG c)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = RexxAddMacro(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  RexxAddMacro
#define RexxAddMacro _RexxAddMacro

inline ULONG APIENTRY _RexxClearMacroSpace()
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = RexxClearMacroSpace();
    SetFS(sel);

    return yyrc;
} 

#undef  RexxClearMacroSpace
#define RexxClearMacroSpace _RexxClearMacroSpace

inline ULONG APIENTRY _RexxDropMacro(PCSZ a)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = RexxDropMacro(a);
    SetFS(sel);

    return yyrc;
} 

#undef  RexxDropMacro
#define RexxDropMacro _RexxDropMacro

inline ULONG APIENTRY _RexxLoadMacroSpace(ULONG a, PCSZ *b, PCSZ c)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = RexxLoadMacroSpace(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  RexxLoadMacroSpace
#define RexxLoadMacroSpace _RexxLoadMacroSpace

inline ULONG APIENTRY _RexxQueryMacro(PCSZ a, PUSHORT b)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = RexxQueryMacro(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  RexxQueryMacro
#define RexxQueryMacro _RexxQueryMacro

inline ULONG APIENTRY _RexxReorderMacro(PCSZ a, ULONG b)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = RexxReorderMacro(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  RexxReorderMacro
#define RexxReorderMacro _RexxReorderMacro

inline ULONG APIENTRY _RexxSaveMacroSpace(ULONG a, PCSZ *b, PCSZ c)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = RexxSaveMacroSpace(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  RexxSaveMacroSpace
#define RexxSaveMacroSpace _RexxSaveMacroSpace

inline LONG APIENTRY _RexxStart(LONG a, PRXSTRING b, PCSZ c, PRXSTRING d, PCSZ e, LONG f, PRXSYSEXIT g, PSHORT h, PRXSTRING i)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = RexxStart(a, b, c, d, e, f, g, h, i);
    SetFS(sel);

    return yyrc;
} 

#undef  RexxStart
#define RexxStart _RexxStart

#endif
#ifdef INCL_WIN
#ifdef INCL_WINMESSAGEMGR
inline BOOL APIENTRY _WinCancelShutdown(HMQ a, BOOL b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinCancelShutdown(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  WinCancelShutdown
#define WinCancelShutdown _WinCancelShutdown

inline HMQ APIENTRY _WinCreateMsgQueue(HAB a, LONG b)
{
 HMQ yyrc;
 USHORT sel = GetFS();

    yyrc = WinCreateMsgQueue(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  WinCreateMsgQueue
#define WinCreateMsgQueue _WinCreateMsgQueue

inline BOOL APIENTRY _WinDestroyMsgQueue(HMQ a)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinDestroyMsgQueue(a);
    SetFS(sel);

    return yyrc;
} 

#undef  WinDestroyMsgQueue
#define WinDestroyMsgQueue _WinDestroyMsgQueue

inline MRESULT APIENTRY _WinDispatchMsg(HAB a, PQMSG b)
{
 MRESULT yyrc;
 USHORT sel = GetFS();

    yyrc = WinDispatchMsg(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  WinDispatchMsg
#define WinDispatchMsg _WinDispatchMsg

inline BOOL APIENTRY _WinGetMsg(HAB a, PQMSG b, HWND c, ULONG d, ULONG e)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinGetMsg(a, b, c, d, e);
    SetFS(sel);

    return yyrc;
} 

#undef  WinGetMsg
#define WinGetMsg _WinGetMsg

inline BOOL APIENTRY _WinLockInput(HMQ a, ULONG b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinLockInput(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  WinLockInput
#define WinLockInput _WinLockInput

inline BOOL APIENTRY _WinPeekMsg(HAB a, PQMSG b, HWND c, ULONG d, ULONG e, ULONG f)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinPeekMsg(a, b, c, d, e, f);
    SetFS(sel);

    return yyrc;
} 

#undef  WinPeekMsg
#define WinPeekMsg _WinPeekMsg

inline BOOL APIENTRY _WinPostMsg(HWND a, ULONG b, MPARAM c, MPARAM d)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinPostMsg(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  WinPostMsg
#define WinPostMsg _WinPostMsg

inline HMQ APIENTRY _WinQueueFromID(HAB a, PID b, TID c)
{
 HMQ yyrc;
 USHORT sel = GetFS();

    yyrc = WinQueueFromID(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  WinQueueFromID
#define WinQueueFromID _WinQueueFromID

inline BOOL APIENTRY _WinQueryQueueInfo(HMQ a, PMQINFO b, ULONG c)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinQueryQueueInfo(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  WinQueryQueueInfo
#define WinQueryQueueInfo _WinQueryQueueInfo

inline HMQ APIENTRY _WinQuerySendMsg(HAB a, HMQ b, HMQ c, PQMSG d)
{
 HMQ yyrc;
 USHORT sel = GetFS();

    yyrc = WinQuerySendMsg(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  WinQuerySendMsg
#define WinQuerySendMsg _WinQuerySendMsg

inline BOOL APIENTRY _WinRegisterUserDatatype(HAB a, LONG b, LONG c, PLONG d)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinRegisterUserDatatype(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  WinRegisterUserDatatype
#define WinRegisterUserDatatype _WinRegisterUserDatatype

inline BOOL APIENTRY _WinRegisterUserMsg(HAB a, ULONG b, LONG c, LONG d, LONG e, LONG f, LONG g)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinRegisterUserMsg(a, b, c, d, e, f, g);
    SetFS(sel);

    return yyrc;
} 

#undef  WinRegisterUserMsg
#define WinRegisterUserMsg _WinRegisterUserMsg

inline BOOL APIENTRY _WinReplyMsg(HAB a, HMQ b, HMQ c, MRESULT d)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinReplyMsg(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  WinReplyMsg
#define WinReplyMsg _WinReplyMsg

inline MRESULT APIENTRY _WinSendMsg(HWND a, ULONG b, MPARAM c, MPARAM d)
{
 MRESULT yyrc;
 USHORT sel = GetFS();

    yyrc = WinSendMsg(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  WinSendMsg
#define WinSendMsg _WinSendMsg

inline BOOL APIENTRY _WinSetMsgMode(HAB a, PCSZ b, LONG c)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinSetMsgMode(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  WinSetMsgMode
#define WinSetMsgMode _WinSetMsgMode

inline BOOL APIENTRY _WinSetSynchroMode(HAB a, LONG b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinSetSynchroMode(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  WinSetSynchroMode
#define WinSetSynchroMode _WinSetSynchroMode

inline BOOL APIENTRY _WinThreadAssocQueue(HAB a, HMQ b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinThreadAssocQueue(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  WinThreadAssocQueue
#define WinThreadAssocQueue _WinThreadAssocQueue

inline BOOL APIENTRY _WinWakeThread(HMQ a)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinWakeThread(a);
    SetFS(sel);

    return yyrc;
} 

#undef  WinWakeThread
#define WinWakeThread _WinWakeThread

#endif
inline HWND APIENTRY _WinCreateWindow(HWND a, PCSZ b, PCSZ c, ULONG d, LONG e, LONG f, LONG g, LONG h, HWND i, HWND j, ULONG k, PVOID l, PVOID m)
{
 HWND yyrc;
 USHORT sel = GetFS();

    yyrc = WinCreateWindow(a, b, c, d, e, f, g, h, i, j, k, l, m);
    SetFS(sel);

    return yyrc;
} 

#undef  WinCreateWindow
#define WinCreateWindow _WinCreateWindow

inline BOOL APIENTRY _WinDrawBitmap(HPS a, HBITMAP b, PRECTL c, PPOINTL d, LONG e, LONG f, ULONG g)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinDrawBitmap(a, b, c, d, e, f, g);
    SetFS(sel);

    return yyrc;
} 

#undef  WinDrawBitmap
#define WinDrawBitmap _WinDrawBitmap

inline BOOL APIENTRY _WinDrawBorder(HPS a, PRECTL b, LONG c, LONG d, LONG e, LONG f, ULONG g)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinDrawBorder(a, b, c, d, e, f, g);
    SetFS(sel);

    return yyrc;
} 

#undef  WinDrawBorder
#define WinDrawBorder _WinDrawBorder

inline LONG APIENTRY _WinDrawText(HPS a, LONG b, PCH c, PRECTL d, LONG e, LONG f, ULONG g)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = WinDrawText(a, b, c, d, e, f, g);
    SetFS(sel);

    return yyrc;
} 

#undef  WinDrawText
#define WinDrawText _WinDrawText

inline BOOL APIENTRY _WinEnableWindow(HWND a, BOOL b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinEnableWindow(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  WinEnableWindow
#define WinEnableWindow _WinEnableWindow

inline BOOL APIENTRY _WinEnableWindowUpdate(HWND a, BOOL b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinEnableWindowUpdate(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  WinEnableWindowUpdate
#define WinEnableWindowUpdate _WinEnableWindowUpdate

inline BOOL APIENTRY _WinInvalidateRect(HWND a, PRECTL b, BOOL c)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinInvalidateRect(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  WinInvalidateRect
#define WinInvalidateRect _WinInvalidateRect

inline BOOL APIENTRY _WinInvalidateRegion(HWND a, HRGN b, BOOL c)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinInvalidateRegion(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  WinInvalidateRegion
#define WinInvalidateRegion _WinInvalidateRegion

inline BOOL APIENTRY _WinInvertRect(HPS a, PRECTL b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinInvertRect(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  WinInvertRect
#define WinInvertRect _WinInvertRect

inline BOOL APIENTRY _WinIsChild(HWND a, HWND b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinIsChild(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  WinIsChild
#define WinIsChild _WinIsChild

inline BOOL APIENTRY _WinIsWindow(HAB a, HWND b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinIsWindow(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  WinIsWindow
#define WinIsWindow _WinIsWindow

inline BOOL APIENTRY _WinIsWindowEnabled(HWND a)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinIsWindowEnabled(a);
    SetFS(sel);

    return yyrc;
} 

#undef  WinIsWindowEnabled
#define WinIsWindowEnabled _WinIsWindowEnabled

inline BOOL APIENTRY _WinIsWindowVisible(HWND a)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinIsWindowVisible(a);
    SetFS(sel);

    return yyrc;
} 

#undef  WinIsWindowVisible
#define WinIsWindowVisible _WinIsWindowVisible

inline LONG APIENTRY _WinLoadMessage(HAB a, HMODULE b, ULONG c, LONG d, PSZ e)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = WinLoadMessage(a, b, c, d, e);
    SetFS(sel);

    return yyrc;
} 

#undef  WinLoadMessage
#define WinLoadMessage _WinLoadMessage

inline LONG APIENTRY _WinLoadString(HAB a, HMODULE b, ULONG c, LONG d, PSZ e)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = WinLoadString(a, b, c, d, e);
    SetFS(sel);

    return yyrc;
} 

#undef  WinLoadString
#define WinLoadString _WinLoadString

inline LONG APIENTRY _WinMultWindowFromIDs(HWND a, PHWND b, ULONG c, ULONG d)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = WinMultWindowFromIDs(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  WinMultWindowFromIDs
#define WinMultWindowFromIDs _WinMultWindowFromIDs

inline HWND APIENTRY _WinQueryDesktopWindow(HAB a, HDC b)
{
 HWND yyrc;
 USHORT sel = GetFS();

    yyrc = WinQueryDesktopWindow(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  WinQueryDesktopWindow
#define WinQueryDesktopWindow _WinQueryDesktopWindow

inline HWND APIENTRY _WinQueryObjectWindow(HWND a)
{
 HWND yyrc;
 USHORT sel = GetFS();

    yyrc = WinQueryObjectWindow(a);
    SetFS(sel);

    return yyrc;
} 

#undef  WinQueryObjectWindow
#define WinQueryObjectWindow _WinQueryObjectWindow

inline HPOINTER APIENTRY _WinQueryPointer(HWND a)
{
 HPOINTER yyrc;
 USHORT sel = GetFS();

    yyrc = WinQueryPointer(a);
    SetFS(sel);

    return yyrc;
} 

#undef  WinQueryPointer
#define WinQueryPointer _WinQueryPointer

inline HWND APIENTRY _WinQueryWindow(HWND a, LONG b)
{
 HWND yyrc;
 USHORT sel = GetFS();

    yyrc = WinQueryWindow(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  WinQueryWindow
#define WinQueryWindow _WinQueryWindow

inline BOOL APIENTRY _WinQueryWindowPos(HWND a, PSWP b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinQueryWindowPos(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  WinQueryWindowPos
#define WinQueryWindowPos _WinQueryWindowPos

inline BOOL APIENTRY _WinQueryWindowProcess(HWND a, PPID b, PTID c)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinQueryWindowProcess(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  WinQueryWindowProcess
#define WinQueryWindowProcess _WinQueryWindowProcess

inline LONG APIENTRY _WinQueryWindowText(HWND a, LONG b, PCH c)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = WinQueryWindowText(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  WinQueryWindowText
#define WinQueryWindowText _WinQueryWindowText

inline LONG APIENTRY _WinQueryWindowTextLength(HWND a)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = WinQueryWindowTextLength(a);
    SetFS(sel);

    return yyrc;
} 

#undef  WinQueryWindowTextLength
#define WinQueryWindowTextLength _WinQueryWindowTextLength

inline BOOL APIENTRY _WinSetMultWindowPos(HAB a, PSWP b, ULONG c)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinSetMultWindowPos(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  WinSetMultWindowPos
#define WinSetMultWindowPos _WinSetMultWindowPos

inline BOOL APIENTRY _WinSetOwner(HWND a, HWND b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinSetOwner(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  WinSetOwner
#define WinSetOwner _WinSetOwner

inline BOOL APIENTRY _WinSetParent(HWND a, HWND b, BOOL c)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinSetParent(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  WinSetParent
#define WinSetParent _WinSetParent

inline BOOL APIENTRY _WinSetWindowPos(HWND a, HWND b, LONG c, LONG d, LONG e, LONG f, ULONG g)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinSetWindowPos(a, b, c, d, e, f, g);
    SetFS(sel);

    return yyrc;
} 

#undef  WinSetWindowPos
#define WinSetWindowPos _WinSetWindowPos

inline BOOL APIENTRY _WinSetWindowText(HWND a, PCSZ b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinSetWindowText(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  WinSetWindowText
#define WinSetWindowText _WinSetWindowText

inline BOOL APIENTRY _WinUpdateWindow(HWND a)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinUpdateWindow(a);
    SetFS(sel);

    return yyrc;
} 

#undef  WinUpdateWindow
#define WinUpdateWindow _WinUpdateWindow

inline HWND APIENTRY _WinWindowFromID(HWND a, ULONG b)
{
 HWND yyrc;
 USHORT sel = GetFS();

    yyrc = WinWindowFromID(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  WinWindowFromID
#define WinWindowFromID _WinWindowFromID

#ifdef INCL_WINFRAMEMGR
inline HWND APIENTRY _WinCreateStdWindow(HWND a, ULONG b, PULONG c, PCSZ d, PCSZ e, ULONG f, HMODULE g, ULONG h, PHWND i)
{
 HWND yyrc;
 USHORT sel = GetFS();

    yyrc = WinCreateStdWindow(a, b, c, d, e, f, g, h, i);
    SetFS(sel);

    return yyrc;
} 

#undef  WinCreateStdWindow
#define WinCreateStdWindow _WinCreateStdWindow

inline BOOL APIENTRY _WinCalcFrameRect(HWND a, PRECTL b, BOOL c)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinCalcFrameRect(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  WinCalcFrameRect
#define WinCalcFrameRect _WinCalcFrameRect

inline BOOL APIENTRY _WinCreateFrameControls(HWND a, PFRAMECDATA b, PCSZ c)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinCreateFrameControls(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  WinCreateFrameControls
#define WinCreateFrameControls _WinCreateFrameControls

inline BOOL APIENTRY _WinFlashWindow(HWND a, BOOL b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinFlashWindow(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  WinFlashWindow
#define WinFlashWindow _WinFlashWindow

inline BOOL APIENTRY _WinGetMaxPosition(HWND a, PSWP b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinGetMaxPosition(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  WinGetMaxPosition
#define WinGetMaxPosition _WinGetMaxPosition

inline BOOL APIENTRY _WinGetMinPosition(HWND a, PSWP b, PPOINTL c)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinGetMinPosition(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  WinGetMinPosition
#define WinGetMinPosition _WinGetMinPosition

inline BOOL APIENTRY _WinSaveWindowPos(HSAVEWP a, PSWP b, ULONG c)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinSaveWindowPos(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  WinSaveWindowPos
#define WinSaveWindowPos _WinSaveWindowPos

#endif
#ifdef INCL_WINWINDOWMGR
inline HPS APIENTRY _WinBeginPaint(HWND a, HPS b, PRECTL c)
{
 HPS yyrc;
 USHORT sel = GetFS();

    yyrc = WinBeginPaint(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  WinBeginPaint
#define WinBeginPaint _WinBeginPaint

inline MRESULT APIENTRY _WinDefWindowProc(HWND a, ULONG b, MPARAM c, MPARAM d)
{
 MRESULT yyrc;
 USHORT sel = GetFS();

    yyrc = WinDefWindowProc(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  WinDefWindowProc
#define WinDefWindowProc _WinDefWindowProc

inline BOOL APIENTRY _WinDestroyWindow(HWND a)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinDestroyWindow(a);
    SetFS(sel);

    return yyrc;
} 

#undef  WinDestroyWindow
#define WinDestroyWindow _WinDestroyWindow

inline BOOL APIENTRY _WinEndPaint(HPS a)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinEndPaint(a);
    SetFS(sel);

    return yyrc;
} 

#undef  WinEndPaint
#define WinEndPaint _WinEndPaint

inline BOOL APIENTRY _WinFillRect(HPS a, PRECTL b, LONG c)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinFillRect(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  WinFillRect
#define WinFillRect _WinFillRect

inline HPS APIENTRY _WinGetClipPS(HWND a, HWND b, ULONG c)
{
 HPS yyrc;
 USHORT sel = GetFS();

    yyrc = WinGetClipPS(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  WinGetClipPS
#define WinGetClipPS _WinGetClipPS

inline HPS APIENTRY _WinGetPS(HWND a)
{
 HPS yyrc;
 USHORT sel = GetFS();

    yyrc = WinGetPS(a);
    SetFS(sel);

    return yyrc;
} 

#undef  WinGetPS
#define WinGetPS _WinGetPS

inline HAB APIENTRY _WinInitialize(ULONG a)
{
 HAB yyrc;
 USHORT sel = GetFS();

    yyrc = WinInitialize(a);
    SetFS(sel);

    return yyrc;
} 

#undef  WinInitialize
#define WinInitialize _WinInitialize

inline BOOL APIENTRY _WinIsWindowShowing(HWND a)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinIsWindowShowing(a);
    SetFS(sel);

    return yyrc;
} 

#undef  WinIsWindowShowing
#define WinIsWindowShowing _WinIsWindowShowing

inline HDC APIENTRY _WinOpenWindowDC(HWND a)
{
 HDC yyrc;
 USHORT sel = GetFS();

    yyrc = WinOpenWindowDC(a);
    SetFS(sel);

    return yyrc;
} 

#undef  WinOpenWindowDC
#define WinOpenWindowDC _WinOpenWindowDC

inline HAB APIENTRY _WinQueryAnchorBlock(HWND a)
{
 HAB yyrc;
 USHORT sel = GetFS();

    yyrc = WinQueryAnchorBlock(a);
    SetFS(sel);

    return yyrc;
} 

#undef  WinQueryAnchorBlock
#define WinQueryAnchorBlock _WinQueryAnchorBlock

inline ULONG APIENTRY _WinQueryVersion(HAB a)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = WinQueryVersion(a);
    SetFS(sel);

    return yyrc;
} 

#undef  WinQueryVersion
#define WinQueryVersion _WinQueryVersion

inline BOOL APIENTRY _WinQueryWindowRect(HWND a, PRECTL b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinQueryWindowRect(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  WinQueryWindowRect
#define WinQueryWindowRect _WinQueryWindowRect

inline BOOL APIENTRY _WinRegisterClass(HAB a, PCSZ b, PFNWP c, ULONG d, ULONG e)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinRegisterClass(a, b, c, d, e);
    SetFS(sel);

    return yyrc;
} 

#undef  WinRegisterClass
#define WinRegisterClass _WinRegisterClass

inline BOOL APIENTRY _WinReleasePS(HPS a)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinReleasePS(a);
    SetFS(sel);

    return yyrc;
} 

#undef  WinReleasePS
#define WinReleasePS _WinReleasePS

inline LONG APIENTRY _WinScrollWindow(HWND a, LONG b, LONG c, PRECTL d, PRECTL e, HRGN f, PRECTL g, ULONG h)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = WinScrollWindow(a, b, c, d, e, f, g, h);
    SetFS(sel);

    return yyrc;
} 

#undef  WinScrollWindow
#define WinScrollWindow _WinScrollWindow

inline BOOL APIENTRY _WinSetActiveWindow(HWND a, HWND b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinSetActiveWindow(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  WinSetActiveWindow
#define WinSetActiveWindow _WinSetActiveWindow

inline BOOL APIENTRY _WinShowWindow(HWND a, BOOL b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinShowWindow(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  WinShowWindow
#define WinShowWindow _WinShowWindow

inline BOOL APIENTRY _WinTerminate(HAB a)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinTerminate(a);
    SetFS(sel);

    return yyrc;
} 

#undef  WinTerminate
#define WinTerminate _WinTerminate

#endif
#ifdef INCL_WINWINDOWMGR
inline HENUM APIENTRY _WinBeginEnumWindows(HWND a)
{
 HENUM yyrc;
 USHORT sel = GetFS();

    yyrc = WinBeginEnumWindows(a);
    SetFS(sel);

    return yyrc;
} 

#undef  WinBeginEnumWindows
#define WinBeginEnumWindows _WinBeginEnumWindows

inline BOOL APIENTRY _WinEndEnumWindows(HENUM a)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinEndEnumWindows(a);
    SetFS(sel);

    return yyrc;
} 

#undef  WinEndEnumWindows
#define WinEndEnumWindows _WinEndEnumWindows

inline LONG APIENTRY _WinExcludeUpdateRegion(HPS a, HWND b)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = WinExcludeUpdateRegion(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  WinExcludeUpdateRegion
#define WinExcludeUpdateRegion _WinExcludeUpdateRegion

inline HWND APIENTRY _WinGetNextWindow(HENUM a)
{
 HWND yyrc;
 USHORT sel = GetFS();

    yyrc = WinGetNextWindow(a);
    SetFS(sel);

    return yyrc;
} 

#undef  WinGetNextWindow
#define WinGetNextWindow _WinGetNextWindow

inline HPS APIENTRY _WinGetScreenPS(HWND a)
{
 HPS yyrc;
 USHORT sel = GetFS();

    yyrc = WinGetScreenPS(a);
    SetFS(sel);

    return yyrc;
} 

#undef  WinGetScreenPS
#define WinGetScreenPS _WinGetScreenPS

inline BOOL APIENTRY _WinIsThreadActive(HAB a)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinIsThreadActive(a);
    SetFS(sel);

    return yyrc;
} 

#undef  WinIsThreadActive
#define WinIsThreadActive _WinIsThreadActive

inline BOOL APIENTRY _WinLockVisRegions(HWND a, BOOL b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinLockVisRegions(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  WinLockVisRegions
#define WinLockVisRegions _WinLockVisRegions

inline BOOL APIENTRY _WinLockWindowUpdate(HWND a, HWND b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinLockWindowUpdate(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  WinLockWindowUpdate
#define WinLockWindowUpdate _WinLockWindowUpdate

inline BOOL APIENTRY _WinMapWindowPoints(HWND a, HWND b, PPOINTL c, LONG d)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinMapWindowPoints(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  WinMapWindowPoints
#define WinMapWindowPoints _WinMapWindowPoints

inline HWND APIENTRY _WinQueryActiveWindow(HWND a)
{
 HWND yyrc;
 USHORT sel = GetFS();

    yyrc = WinQueryActiveWindow(a);
    SetFS(sel);

    return yyrc;
} 

#undef  WinQueryActiveWindow
#define WinQueryActiveWindow _WinQueryActiveWindow

inline BOOL APIENTRY _WinQueryClassInfo(HAB a, PCSZ b, PCLASSINFO c)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinQueryClassInfo(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  WinQueryClassInfo
#define WinQueryClassInfo _WinQueryClassInfo

inline LONG APIENTRY _WinQueryClassName(HWND a, LONG b, PCH c)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = WinQueryClassName(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  WinQueryClassName
#define WinQueryClassName _WinQueryClassName

inline BOOL APIENTRY _WinQueryUpdateRect(HWND a, PRECTL b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinQueryUpdateRect(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  WinQueryUpdateRect
#define WinQueryUpdateRect _WinQueryUpdateRect

inline LONG APIENTRY _WinQueryUpdateRegion(HWND a, HRGN b)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = WinQueryUpdateRegion(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  WinQueryUpdateRegion
#define WinQueryUpdateRegion _WinQueryUpdateRegion

inline HWND APIENTRY _WinQuerySysModalWindow(HWND a)
{
 HWND yyrc;
 USHORT sel = GetFS();

    yyrc = WinQuerySysModalWindow(a);
    SetFS(sel);

    return yyrc;
} 

#undef  WinQuerySysModalWindow
#define WinQuerySysModalWindow _WinQuerySysModalWindow

inline HDC APIENTRY _WinQueryWindowDC(HWND a)
{
 HDC yyrc;
 USHORT sel = GetFS();

    yyrc = WinQueryWindowDC(a);
    SetFS(sel);

    return yyrc;
} 

#undef  WinQueryWindowDC
#define WinQueryWindowDC _WinQueryWindowDC

inline PVOID APIENTRY _WinQueryWindowPtr(HWND a, LONG b)
{
 PVOID yyrc;
 USHORT sel = GetFS();

    yyrc = WinQueryWindowPtr(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  WinQueryWindowPtr
#define WinQueryWindowPtr _WinQueryWindowPtr

inline ULONG APIENTRY _WinQueryWindowULong(HWND a, LONG b)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = WinQueryWindowULong(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  WinQueryWindowULong
#define WinQueryWindowULong _WinQueryWindowULong

inline USHORT APIENTRY _WinQueryWindowUShort(HWND a, LONG b)
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = WinQueryWindowUShort(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  WinQueryWindowUShort
#define WinQueryWindowUShort _WinQueryWindowUShort

inline BOOL APIENTRY _WinSetSysModalWindow(HWND a, HWND b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinSetSysModalWindow(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  WinSetSysModalWindow
#define WinSetSysModalWindow _WinSetSysModalWindow

inline BOOL APIENTRY _WinSetWindowBits(HWND a, LONG b, ULONG c, ULONG d)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinSetWindowBits(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  WinSetWindowBits
#define WinSetWindowBits _WinSetWindowBits

inline BOOL APIENTRY _WinSetWindowPtr(HWND a, LONG b, PVOID c)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinSetWindowPtr(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  WinSetWindowPtr
#define WinSetWindowPtr _WinSetWindowPtr

inline BOOL APIENTRY _WinSetWindowULong(HWND a, LONG b, ULONG c)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinSetWindowULong(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  WinSetWindowULong
#define WinSetWindowULong _WinSetWindowULong

inline BOOL APIENTRY _WinSetWindowUShort(HWND a, LONG b, USHORT c)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinSetWindowUShort(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  WinSetWindowUShort
#define WinSetWindowUShort _WinSetWindowUShort

inline PFNWP APIENTRY _WinSubclassWindow(HWND a, PFNWP b)
{
 PFNWP yyrc;
 USHORT sel = GetFS();

    yyrc = WinSubclassWindow(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  WinSubclassWindow
#define WinSubclassWindow _WinSubclassWindow

inline BOOL APIENTRY _WinValidateRect(HWND a, PRECTL b, BOOL c)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinValidateRect(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  WinValidateRect
#define WinValidateRect _WinValidateRect

inline BOOL APIENTRY _WinValidateRegion(HWND a, HRGN b, BOOL c)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinValidateRegion(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  WinValidateRegion
#define WinValidateRegion _WinValidateRegion

inline HWND APIENTRY _WinWindowFromDC(HDC a)
{
 HWND yyrc;
 USHORT sel = GetFS();

    yyrc = WinWindowFromDC(a);
    SetFS(sel);

    return yyrc;
} 

#undef  WinWindowFromDC
#define WinWindowFromDC _WinWindowFromDC

inline HWND APIENTRY _WinWindowFromPoint(HWND a, PPOINTL b, BOOL c)
{
 HWND yyrc;
 USHORT sel = GetFS();

    yyrc = WinWindowFromPoint(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  WinWindowFromPoint
#define WinWindowFromPoint _WinWindowFromPoint

#endif
#ifdef INCL_WINACCELERATORS
inline ULONG APIENTRY _WinCopyAccelTable(HACCEL a, PACCELTABLE b, ULONG c)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = WinCopyAccelTable(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  WinCopyAccelTable
#define WinCopyAccelTable _WinCopyAccelTable

inline HACCEL APIENTRY _WinCreateAccelTable(HAB a, PACCELTABLE b)
{
 HACCEL yyrc;
 USHORT sel = GetFS();

    yyrc = WinCreateAccelTable(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  WinCreateAccelTable
#define WinCreateAccelTable _WinCreateAccelTable

inline BOOL APIENTRY _WinDestroyAccelTable(HACCEL a)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinDestroyAccelTable(a);
    SetFS(sel);

    return yyrc;
} 

#undef  WinDestroyAccelTable
#define WinDestroyAccelTable _WinDestroyAccelTable

inline HACCEL APIENTRY _WinLoadAccelTable(HAB a, HMODULE b, ULONG c)
{
 HACCEL yyrc;
 USHORT sel = GetFS();

    yyrc = WinLoadAccelTable(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  WinLoadAccelTable
#define WinLoadAccelTable _WinLoadAccelTable

inline HACCEL APIENTRY _WinQueryAccelTable(HAB a, HWND b)
{
 HACCEL yyrc;
 USHORT sel = GetFS();

    yyrc = WinQueryAccelTable(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  WinQueryAccelTable
#define WinQueryAccelTable _WinQueryAccelTable

inline BOOL APIENTRY _WinSetAccelTable(HAB a, HACCEL b, HWND c)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinSetAccelTable(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  WinSetAccelTable
#define WinSetAccelTable _WinSetAccelTable

inline BOOL APIENTRY _WinTranslateAccel(HAB a, HWND b, HACCEL c, PQMSG d)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinTranslateAccel(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  WinTranslateAccel
#define WinTranslateAccel _WinTranslateAccel

#endif
#ifdef INCL_WINATOM
inline ATOM APIENTRY _WinAddAtom(HATOMTBL a, PCSZ b)
{
 ATOM yyrc;
 USHORT sel = GetFS();

    yyrc = WinAddAtom(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  WinAddAtom
#define WinAddAtom _WinAddAtom

inline HATOMTBL APIENTRY _WinCreateAtomTable(ULONG a, ULONG b)
{
 HATOMTBL yyrc;
 USHORT sel = GetFS();

    yyrc = WinCreateAtomTable(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  WinCreateAtomTable
#define WinCreateAtomTable _WinCreateAtomTable

inline ATOM APIENTRY _WinDeleteAtom(HATOMTBL a, ATOM b)
{
 ATOM yyrc;
 USHORT sel = GetFS();

    yyrc = WinDeleteAtom(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  WinDeleteAtom
#define WinDeleteAtom _WinDeleteAtom

inline HATOMTBL APIENTRY _WinDestroyAtomTable(HATOMTBL a)
{
 HATOMTBL yyrc;
 USHORT sel = GetFS();

    yyrc = WinDestroyAtomTable(a);
    SetFS(sel);

    return yyrc;
} 

#undef  WinDestroyAtomTable
#define WinDestroyAtomTable _WinDestroyAtomTable

inline ATOM APIENTRY _WinFindAtom(HATOMTBL a, PCSZ b)
{
 ATOM yyrc;
 USHORT sel = GetFS();

    yyrc = WinFindAtom(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  WinFindAtom
#define WinFindAtom _WinFindAtom

inline ULONG APIENTRY _WinQueryAtomLength(HATOMTBL a, ATOM b)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = WinQueryAtomLength(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  WinQueryAtomLength
#define WinQueryAtomLength _WinQueryAtomLength

inline ULONG APIENTRY _WinQueryAtomName(HATOMTBL a, ATOM b, PSZ c, ULONG d)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = WinQueryAtomName(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  WinQueryAtomName
#define WinQueryAtomName _WinQueryAtomName

inline ULONG APIENTRY _WinQueryAtomUsage(HATOMTBL a, ATOM b)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = WinQueryAtomUsage(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  WinQueryAtomUsage
#define WinQueryAtomUsage _WinQueryAtomUsage

inline HATOMTBL APIENTRY _WinQuerySystemAtomTable()
{
 HATOMTBL yyrc;
 USHORT sel = GetFS();

    yyrc = WinQuerySystemAtomTable();
    SetFS(sel);

    return yyrc;
} 

#undef  WinQuerySystemAtomTable
#define WinQuerySystemAtomTable _WinQuerySystemAtomTable

#endif
#ifdef INCL_WINCLIPBOARD
inline BOOL APIENTRY _WinCloseClipbrd(HAB a)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinCloseClipbrd(a);
    SetFS(sel);

    return yyrc;
} 

#undef  WinCloseClipbrd
#define WinCloseClipbrd _WinCloseClipbrd

inline BOOL APIENTRY _WinEmptyClipbrd(HAB a)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinEmptyClipbrd(a);
    SetFS(sel);

    return yyrc;
} 

#undef  WinEmptyClipbrd
#define WinEmptyClipbrd _WinEmptyClipbrd

inline ULONG APIENTRY _WinEnumClipbrdFmts(HAB a, ULONG b)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = WinEnumClipbrdFmts(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  WinEnumClipbrdFmts
#define WinEnumClipbrdFmts _WinEnumClipbrdFmts

inline BOOL APIENTRY _WinOpenClipbrd(HAB a)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinOpenClipbrd(a);
    SetFS(sel);

    return yyrc;
} 

#undef  WinOpenClipbrd
#define WinOpenClipbrd _WinOpenClipbrd

inline ULONG APIENTRY _WinQueryClipbrdData(HAB a, ULONG b)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = WinQueryClipbrdData(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  WinQueryClipbrdData
#define WinQueryClipbrdData _WinQueryClipbrdData

inline BOOL APIENTRY _WinQueryClipbrdFmtInfo(HAB a, ULONG b, PULONG c)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinQueryClipbrdFmtInfo(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  WinQueryClipbrdFmtInfo
#define WinQueryClipbrdFmtInfo _WinQueryClipbrdFmtInfo

inline HWND APIENTRY _WinQueryClipbrdOwner(HAB a)
{
 HWND yyrc;
 USHORT sel = GetFS();

    yyrc = WinQueryClipbrdOwner(a);
    SetFS(sel);

    return yyrc;
} 

#undef  WinQueryClipbrdOwner
#define WinQueryClipbrdOwner _WinQueryClipbrdOwner

inline HWND APIENTRY _WinQueryClipbrdViewer(HAB a)
{
 HWND yyrc;
 USHORT sel = GetFS();

    yyrc = WinQueryClipbrdViewer(a);
    SetFS(sel);

    return yyrc;
} 

#undef  WinQueryClipbrdViewer
#define WinQueryClipbrdViewer _WinQueryClipbrdViewer

inline BOOL APIENTRY _WinSetClipbrdData(HAB a, ULONG b, ULONG c, ULONG d)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinSetClipbrdData(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  WinSetClipbrdData
#define WinSetClipbrdData _WinSetClipbrdData

inline BOOL APIENTRY _WinSetClipbrdOwner(HAB a, HWND b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinSetClipbrdOwner(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  WinSetClipbrdOwner
#define WinSetClipbrdOwner _WinSetClipbrdOwner

inline BOOL APIENTRY _WinSetClipbrdViewer(HAB a, HWND b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinSetClipbrdViewer(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  WinSetClipbrdViewer
#define WinSetClipbrdViewer _WinSetClipbrdViewer

#endif
#ifdef INCL_WINDDE
inline BOOL APIENTRY _WinDdeInitiate(HWND a, PCSZ b, PCSZ c, PCONVCONTEXT d)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinDdeInitiate(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  WinDdeInitiate
#define WinDdeInitiate _WinDdeInitiate

inline BOOL APIENTRY _WinDdePostMsg(HWND a, HWND b, ULONG c, PDDESTRUCT d, ULONG e)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinDdePostMsg(a, b, c, d, e);
    SetFS(sel);

    return yyrc;
} 

#undef  WinDdePostMsg
#define WinDdePostMsg _WinDdePostMsg

inline MRESULT APIENTRY _WinDdeRespond(HWND a, HWND b, PCSZ c, PCSZ d, PCONVCONTEXT e)
{
 MRESULT yyrc;
 USHORT sel = GetFS();

    yyrc = WinDdeRespond(a, b, c, d, e);
    SetFS(sel);

    return yyrc;
} 

#undef  WinDdeRespond
#define WinDdeRespond _WinDdeRespond

#endif
#ifdef INCL_WINCOUNTRY
inline ULONG APIENTRY _WinCompareStrings(HAB a, ULONG b, ULONG c, PCSZ d, PCSZ e, ULONG f)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = WinCompareStrings(a, b, c, d, e, f);
    SetFS(sel);

    return yyrc;
} 

#undef  WinCompareStrings
#define WinCompareStrings _WinCompareStrings

inline UCHAR APIENTRY _WinCpTranslateChar(HAB a, ULONG b, UCHAR c, ULONG d)
{
 UCHAR yyrc;
 USHORT sel = GetFS();

    yyrc = WinCpTranslateChar(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  WinCpTranslateChar
#define WinCpTranslateChar _WinCpTranslateChar

inline BOOL APIENTRY _WinCpTranslateString(HAB a, ULONG b, PCSZ c, ULONG d, ULONG e, PSZ f)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinCpTranslateString(a, b, c, d, e, f);
    SetFS(sel);

    return yyrc;
} 

#undef  WinCpTranslateString
#define WinCpTranslateString _WinCpTranslateString

inline PCSZ APIENTRY _WinNextChar(HAB a, ULONG b, ULONG c, PCSZ d)
{
 PCSZ yyrc;
 USHORT sel = GetFS();

    yyrc = WinNextChar(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  WinNextChar
#define WinNextChar _WinNextChar

inline PCSZ APIENTRY _WinPrevChar(HAB a, ULONG b, ULONG c, PCSZ d, PCSZ e)
{
 PCSZ yyrc;
 USHORT sel = GetFS();

    yyrc = WinPrevChar(a, b, c, d, e);
    SetFS(sel);

    return yyrc;
} 

#undef  WinPrevChar
#define WinPrevChar _WinPrevChar

inline ULONG APIENTRY _WinQueryCp(HMQ a)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = WinQueryCp(a);
    SetFS(sel);

    return yyrc;
} 

#undef  WinQueryCp
#define WinQueryCp _WinQueryCp

inline ULONG APIENTRY _WinQueryCpList(HAB a, ULONG b, PULONG c)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = WinQueryCpList(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  WinQueryCpList
#define WinQueryCpList _WinQueryCpList

inline BOOL APIENTRY _WinSetCp(HMQ a, ULONG b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinSetCp(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  WinSetCp
#define WinSetCp _WinSetCp

inline ULONG APIENTRY _WinUpper(HAB a, ULONG b, ULONG c, PSZ d)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = WinUpper(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  WinUpper
#define WinUpper _WinUpper

inline ULONG APIENTRY _WinUpperChar(HAB a, ULONG b, ULONG c, ULONG d)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = WinUpperChar(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  WinUpperChar
#define WinUpperChar _WinUpperChar

#endif
#ifdef INCL_WINCURSORS
inline BOOL APIENTRY _WinCreateCursor(HWND a, LONG b, LONG c, LONG d, LONG e, ULONG f, PRECTL g)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinCreateCursor(a, b, c, d, e, f, g);
    SetFS(sel);

    return yyrc;
} 

#undef  WinCreateCursor
#define WinCreateCursor _WinCreateCursor

inline BOOL APIENTRY _WinDestroyCursor(HWND a)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinDestroyCursor(a);
    SetFS(sel);

    return yyrc;
} 

#undef  WinDestroyCursor
#define WinDestroyCursor _WinDestroyCursor

inline BOOL APIENTRY _WinShowCursor(HWND a, BOOL b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinShowCursor(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  WinShowCursor
#define WinShowCursor _WinShowCursor

inline BOOL APIENTRY _WinQueryCursorInfo(HWND a, PCURSORINFO b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinQueryCursorInfo(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  WinQueryCursorInfo
#define WinQueryCursorInfo _WinQueryCursorInfo

#endif
#ifdef INCL_WINDESKTOP
inline BOOL APIENTRY _WinQueryDesktopBkgnd(HWND a, PDESKTOP b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinQueryDesktopBkgnd(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  WinQueryDesktopBkgnd
#define WinQueryDesktopBkgnd _WinQueryDesktopBkgnd

inline HBITMAP APIENTRY _WinSetDesktopBkgnd(HWND a, PDESKTOP b)
{
 HBITMAP yyrc;
 USHORT sel = GetFS();

    yyrc = WinSetDesktopBkgnd(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  WinSetDesktopBkgnd
#define WinSetDesktopBkgnd _WinSetDesktopBkgnd

#endif
#ifdef INCL_WINDIALOGS
inline BOOL APIENTRY _WinAlarm(HWND a, ULONG b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinAlarm(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  WinAlarm
#define WinAlarm _WinAlarm

inline MRESULT APIENTRY _WinDefDlgProc(HWND a, ULONG b, MPARAM c, MPARAM d)
{
 MRESULT yyrc;
 USHORT sel = GetFS();

    yyrc = WinDefDlgProc(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  WinDefDlgProc
#define WinDefDlgProc _WinDefDlgProc

inline BOOL APIENTRY _WinDismissDlg(HWND a, ULONG b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinDismissDlg(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  WinDismissDlg
#define WinDismissDlg _WinDismissDlg

inline ULONG APIENTRY _WinDlgBox(HWND a, HWND b, PFNWP c, HMODULE d, ULONG e, PVOID f)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = WinDlgBox(a, b, c, d, e, f);
    SetFS(sel);

    return yyrc;
} 

#undef  WinDlgBox
#define WinDlgBox _WinDlgBox

inline BOOL APIENTRY _WinGetDlgMsg(HWND a, PQMSG b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinGetDlgMsg(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  WinGetDlgMsg
#define WinGetDlgMsg _WinGetDlgMsg

inline HWND APIENTRY _WinLoadDlg(HWND a, HWND b, PFNWP c, HMODULE d, ULONG e, PVOID f)
{
 HWND yyrc;
 USHORT sel = GetFS();

    yyrc = WinLoadDlg(a, b, c, d, e, f);
    SetFS(sel);

    return yyrc;
} 

#undef  WinLoadDlg
#define WinLoadDlg _WinLoadDlg

inline ULONG APIENTRY _WinMessageBox(HWND a, HWND b, PCSZ c, PCSZ d, ULONG e, ULONG f)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = WinMessageBox(a, b, c, d, e, f);
    SetFS(sel);

    return yyrc;
} 

#undef  WinMessageBox
#define WinMessageBox _WinMessageBox

inline ULONG APIENTRY _WinMessageBox2(HWND a, HWND b, PSZ c, PSZ d, ULONG e, PMB2INFO f)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = WinMessageBox2(a, b, c, d, e, f);
    SetFS(sel);

    return yyrc;
} 

#undef  WinMessageBox2
#define WinMessageBox2 _WinMessageBox2

inline BOOL APIENTRY _WinQueryDlgItemShort(HWND a, ULONG b, PSHORT c, BOOL d)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinQueryDlgItemShort(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  WinQueryDlgItemShort
#define WinQueryDlgItemShort _WinQueryDlgItemShort

inline ULONG APIENTRY _WinQueryDlgItemText(HWND a, ULONG b, LONG c, PSZ d)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = WinQueryDlgItemText(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  WinQueryDlgItemText
#define WinQueryDlgItemText _WinQueryDlgItemText

inline LONG APIENTRY _WinQueryDlgItemTextLength(HWND a, ULONG b)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = WinQueryDlgItemTextLength(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  WinQueryDlgItemTextLength
#define WinQueryDlgItemTextLength _WinQueryDlgItemTextLength

inline BOOL APIENTRY _WinSetDlgItemShort(HWND a, ULONG b, USHORT c, BOOL d)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinSetDlgItemShort(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  WinSetDlgItemShort
#define WinSetDlgItemShort _WinSetDlgItemShort

inline BOOL APIENTRY _WinSetDlgItemText(HWND a, ULONG b, PCSZ c)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinSetDlgItemText(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  WinSetDlgItemText
#define WinSetDlgItemText _WinSetDlgItemText

inline HWND APIENTRY _WinCreateDlg(HWND a, HWND b, PFNWP c, PDLGTEMPLATE d, PVOID e)
{
 HWND yyrc;
 USHORT sel = GetFS();

    yyrc = WinCreateDlg(a, b, c, d, e);
    SetFS(sel);

    return yyrc;
} 

#undef  WinCreateDlg
#define WinCreateDlg _WinCreateDlg

inline HWND APIENTRY _WinEnumDlgItem(HWND a, HWND b, ULONG c)
{
 HWND yyrc;
 USHORT sel = GetFS();

    yyrc = WinEnumDlgItem(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  WinEnumDlgItem
#define WinEnumDlgItem _WinEnumDlgItem

inline BOOL APIENTRY _WinMapDlgPoints(HWND a, PPOINTL b, ULONG c, BOOL d)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinMapDlgPoints(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  WinMapDlgPoints
#define WinMapDlgPoints _WinMapDlgPoints

inline ULONG APIENTRY _WinProcessDlg(HWND a)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = WinProcessDlg(a);
    SetFS(sel);

    return yyrc;
} 

#undef  WinProcessDlg
#define WinProcessDlg _WinProcessDlg

inline MRESULT APIENTRY _WinSendDlgItemMsg(HWND a, ULONG b, ULONG c, MPARAM d, MPARAM e)
{
 MRESULT yyrc;
 USHORT sel = GetFS();

    yyrc = WinSendDlgItemMsg(a, b, c, d, e);
    SetFS(sel);

    return yyrc;
} 

#undef  WinSendDlgItemMsg
#define WinSendDlgItemMsg _WinSendDlgItemMsg

inline LONG APIENTRY _WinSubstituteStrings(HWND a, PCSZ b, LONG c, PSZ d)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = WinSubstituteStrings(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  WinSubstituteStrings
#define WinSubstituteStrings _WinSubstituteStrings

#endif
#ifdef INCL_WINERRORS
inline ERRORID APIENTRY _WinGetLastError(HAB a)
{
 ERRORID yyrc;
 USHORT sel = GetFS();

    yyrc = WinGetLastError(a);
    SetFS(sel);

    return yyrc;
} 

#undef  WinGetLastError
#define WinGetLastError _WinGetLastError

inline BOOL APIENTRY _WinFreeErrorInfo(PERRINFO a)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinFreeErrorInfo(a);
    SetFS(sel);

    return yyrc;
} 

#undef  WinFreeErrorInfo
#define WinFreeErrorInfo _WinFreeErrorInfo

inline PERRINFO APIENTRY _WinGetErrorInfo(HAB a)
{
 PERRINFO yyrc;
 USHORT sel = GetFS();

    yyrc = WinGetErrorInfo(a);
    SetFS(sel);

    return yyrc;
} 

#undef  WinGetErrorInfo
#define WinGetErrorInfo _WinGetErrorInfo

#endif
#ifdef INCL_WINHOOKS
inline BOOL APIENTRY _WinCallMsgFilter(HAB a, PQMSG b, ULONG c)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinCallMsgFilter(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  WinCallMsgFilter
#define WinCallMsgFilter _WinCallMsgFilter

inline BOOL APIENTRY _WinReleaseHook(HAB a, HMQ b, LONG c, PFN d, HMODULE e)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinReleaseHook(a, b, c, d, e);
    SetFS(sel);

    return yyrc;
} 

#undef  WinReleaseHook
#define WinReleaseHook _WinReleaseHook

inline BOOL APIENTRY _WinSetHook(HAB a, HMQ b, LONG c, PFN d, HMODULE e)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinSetHook(a, b, c, d, e);
    SetFS(sel);

    return yyrc;
} 

#undef  WinSetHook
#define WinSetHook _WinSetHook

#endif
#ifdef INCL_WININPUT
inline BOOL APIENTRY _WinFocusChange(HWND a, HWND b, ULONG c)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinFocusChange(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  WinFocusChange
#define WinFocusChange _WinFocusChange

inline BOOL APIENTRY _WinLockupSystem(HAB a)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinLockupSystem(a);
    SetFS(sel);

    return yyrc;
} 

#undef  WinLockupSystem
#define WinLockupSystem _WinLockupSystem

inline BOOL APIENTRY _WinSetFocus(HWND a, HWND b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinSetFocus(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  WinSetFocus
#define WinSetFocus _WinSetFocus

inline BOOL APIENTRY _WinUnlockSystem(HAB a, PSZ b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinUnlockSystem(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  WinUnlockSystem
#define WinUnlockSystem _WinUnlockSystem

inline BOOL APIENTRY _WinCheckInput(HAB a)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinCheckInput(a);
    SetFS(sel);

    return yyrc;
} 

#undef  WinCheckInput
#define WinCheckInput _WinCheckInput

inline BOOL APIENTRY _WinEnablePhysInput(HWND a, BOOL b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinEnablePhysInput(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  WinEnablePhysInput
#define WinEnablePhysInput _WinEnablePhysInput

inline LONG APIENTRY _WinGetKeyState(HWND a, LONG b)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = WinGetKeyState(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  WinGetKeyState
#define WinGetKeyState _WinGetKeyState

inline LONG APIENTRY _WinGetPhysKeyState(HWND a, LONG b)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = WinGetPhysKeyState(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  WinGetPhysKeyState
#define WinGetPhysKeyState _WinGetPhysKeyState

inline BOOL APIENTRY _WinIsPhysInputEnabled(HWND a)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinIsPhysInputEnabled(a);
    SetFS(sel);

    return yyrc;
} 

#undef  WinIsPhysInputEnabled
#define WinIsPhysInputEnabled _WinIsPhysInputEnabled

inline HWND APIENTRY _WinQueryCapture(HWND a)
{
 HWND yyrc;
 USHORT sel = GetFS();

    yyrc = WinQueryCapture(a);
    SetFS(sel);

    return yyrc;
} 

#undef  WinQueryCapture
#define WinQueryCapture _WinQueryCapture

inline HWND APIENTRY _WinQueryFocus(HWND a)
{
 HWND yyrc;
 USHORT sel = GetFS();

    yyrc = WinQueryFocus(a);
    SetFS(sel);

    return yyrc;
} 

#undef  WinQueryFocus
#define WinQueryFocus _WinQueryFocus

inline ULONG APIENTRY _WinQueryVisibleRegion(HWND a, HRGN b)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = WinQueryVisibleRegion(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  WinQueryVisibleRegion
#define WinQueryVisibleRegion _WinQueryVisibleRegion

inline BOOL APIENTRY _WinSetCapture(HWND a, HWND b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinSetCapture(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  WinSetCapture
#define WinSetCapture _WinSetCapture

inline BOOL APIENTRY _WinSetKeyboardStateTable(HWND a, PBYTE b, BOOL c)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinSetKeyboardStateTable(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  WinSetKeyboardStateTable
#define WinSetKeyboardStateTable _WinSetKeyboardStateTable

inline BOOL APIENTRY _WinSetVisibleRegionNotify(HWND a, BOOL b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinSetVisibleRegionNotify(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  WinSetVisibleRegionNotify
#define WinSetVisibleRegionNotify _WinSetVisibleRegionNotify

#endif
#ifdef INCL_WINLOAD
inline BOOL APIENTRY _WinDeleteLibrary(HAB a, HLIB b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinDeleteLibrary(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  WinDeleteLibrary
#define WinDeleteLibrary _WinDeleteLibrary

inline BOOL APIENTRY _WinDeleteProcedure(HAB a, PFNWP b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinDeleteProcedure(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  WinDeleteProcedure
#define WinDeleteProcedure _WinDeleteProcedure

inline HLIB APIENTRY _WinLoadLibrary(HAB a, PCSZ b)
{
 HLIB yyrc;
 USHORT sel = GetFS();

    yyrc = WinLoadLibrary(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  WinLoadLibrary
#define WinLoadLibrary _WinLoadLibrary

inline PFNWP APIENTRY _WinLoadProcedure(HAB a, HLIB b, PSZ c)
{
 PFNWP yyrc;
 USHORT sel = GetFS();

    yyrc = WinLoadProcedure(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  WinLoadProcedure
#define WinLoadProcedure _WinLoadProcedure

#endif
#ifdef INCL_WINMENUS
inline HWND APIENTRY _WinCreateMenu(HWND a, PVOID b)
{
 HWND yyrc;
 USHORT sel = GetFS();

    yyrc = WinCreateMenu(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  WinCreateMenu
#define WinCreateMenu _WinCreateMenu

inline HWND APIENTRY _WinLoadMenu(HWND a, HMODULE b, ULONG c)
{
 HWND yyrc;
 USHORT sel = GetFS();

    yyrc = WinLoadMenu(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  WinLoadMenu
#define WinLoadMenu _WinLoadMenu

inline BOOL APIENTRY _WinPopupMenu(HWND a, HWND b, HWND c, LONG d, LONG e, LONG f, ULONG g)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinPopupMenu(a, b, c, d, e, f, g);
    SetFS(sel);

    return yyrc;
} 

#undef  WinPopupMenu
#define WinPopupMenu _WinPopupMenu

#endif
#ifdef INCL_WINMESSAGEMGR
inline BOOL APIENTRY _WinBroadcastMsg(HWND a, ULONG b, MPARAM c, MPARAM d, ULONG e)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinBroadcastMsg(a, b, c, d, e);
    SetFS(sel);

    return yyrc;
} 

#undef  WinBroadcastMsg
#define WinBroadcastMsg _WinBroadcastMsg

inline BOOL APIENTRY _WinInSendMsg(HAB a)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinInSendMsg(a);
    SetFS(sel);

    return yyrc;
} 

#undef  WinInSendMsg
#define WinInSendMsg _WinInSendMsg

inline BOOL APIENTRY _WinPostQueueMsg(HMQ a, ULONG b, MPARAM c, MPARAM d)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinPostQueueMsg(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  WinPostQueueMsg
#define WinPostQueueMsg _WinPostQueueMsg

inline BOOL APIENTRY _WinQueryMsgPos(HAB a, PPOINTL b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinQueryMsgPos(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  WinQueryMsgPos
#define WinQueryMsgPos _WinQueryMsgPos

inline ULONG APIENTRY _WinQueryMsgTime(HAB a)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = WinQueryMsgTime(a);
    SetFS(sel);

    return yyrc;
} 

#undef  WinQueryMsgTime
#define WinQueryMsgTime _WinQueryMsgTime

inline ULONG APIENTRY _WinQueryQueueStatus(HWND a)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = WinQueryQueueStatus(a);
    SetFS(sel);

    return yyrc;
} 

#undef  WinQueryQueueStatus
#define WinQueryQueueStatus _WinQueryQueueStatus

inline ULONG APIENTRY _WinRequestMutexSem(HMTX a, ULONG b)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = WinRequestMutexSem(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  WinRequestMutexSem
#define WinRequestMutexSem _WinRequestMutexSem

inline BOOL APIENTRY _WinSetClassMsgInterest(HAB a, PCSZ b, ULONG c, LONG d)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinSetClassMsgInterest(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  WinSetClassMsgInterest
#define WinSetClassMsgInterest _WinSetClassMsgInterest

inline BOOL APIENTRY _WinSetMsgInterest(HWND a, ULONG b, LONG c)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinSetMsgInterest(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  WinSetMsgInterest
#define WinSetMsgInterest _WinSetMsgInterest

inline ULONG APIENTRY _WinWaitEventSem(HEV a, ULONG b)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = WinWaitEventSem(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  WinWaitEventSem
#define WinWaitEventSem _WinWaitEventSem

inline BOOL APIENTRY _WinWaitMsg(HAB a, ULONG b, ULONG c)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinWaitMsg(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  WinWaitMsg
#define WinWaitMsg _WinWaitMsg

inline ULONG APIENTRY _WinWaitMuxWaitSem(HMUX a, ULONG b, PULONG c)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = WinWaitMuxWaitSem(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  WinWaitMuxWaitSem
#define WinWaitMuxWaitSem _WinWaitMuxWaitSem

#endif
#ifdef INCL_WINPALETTE
inline LONG APIENTRY _WinRealizePalette(HWND a, HPS b, PULONG c)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = WinRealizePalette(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  WinRealizePalette
#define WinRealizePalette _WinRealizePalette

#endif
#ifdef INCL_WINPOINTERS
inline HPOINTER APIENTRY _WinCreatePointer(HWND a, HBITMAP b, BOOL c, LONG d, LONG e)
{
 HPOINTER yyrc;
 USHORT sel = GetFS();

    yyrc = WinCreatePointer(a, b, c, d, e);
    SetFS(sel);

    return yyrc;
} 

#undef  WinCreatePointer
#define WinCreatePointer _WinCreatePointer

inline HPOINTER APIENTRY _WinCreatePointerIndirect(HWND a, PPOINTERINFO b)
{
 HPOINTER yyrc;
 USHORT sel = GetFS();

    yyrc = WinCreatePointerIndirect(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  WinCreatePointerIndirect
#define WinCreatePointerIndirect _WinCreatePointerIndirect

inline BOOL APIENTRY _WinDestroyPointer(HPOINTER a)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinDestroyPointer(a);
    SetFS(sel);

    return yyrc;
} 

#undef  WinDestroyPointer
#define WinDestroyPointer _WinDestroyPointer

inline BOOL APIENTRY _WinDrawPointer(HPS a, LONG b, LONG c, HPOINTER d, ULONG e)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinDrawPointer(a, b, c, d, e);
    SetFS(sel);

    return yyrc;
} 

#undef  WinDrawPointer
#define WinDrawPointer _WinDrawPointer

inline HBITMAP APIENTRY _WinGetSysBitmap(HWND a, ULONG b)
{
 HBITMAP yyrc;
 USHORT sel = GetFS();

    yyrc = WinGetSysBitmap(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  WinGetSysBitmap
#define WinGetSysBitmap _WinGetSysBitmap

inline HPOINTER APIENTRY _WinLoadPointer(HWND a, HMODULE b, ULONG c)
{
 HPOINTER yyrc;
 USHORT sel = GetFS();

    yyrc = WinLoadPointer(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  WinLoadPointer
#define WinLoadPointer _WinLoadPointer

inline BOOL APIENTRY _WinLockPointerUpdate(HWND a, HPOINTER b, ULONG c)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinLockPointerUpdate(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  WinLockPointerUpdate
#define WinLockPointerUpdate _WinLockPointerUpdate

inline BOOL APIENTRY _WinQueryPointerPos(HWND a, PPOINTL b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinQueryPointerPos(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  WinQueryPointerPos
#define WinQueryPointerPos _WinQueryPointerPos

inline BOOL APIENTRY _WinQueryPointerInfo(HPOINTER a, PPOINTERINFO b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinQueryPointerInfo(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  WinQueryPointerInfo
#define WinQueryPointerInfo _WinQueryPointerInfo

inline HPOINTER APIENTRY _WinQuerySysPointer(HWND a, LONG b, BOOL c)
{
 HPOINTER yyrc;
 USHORT sel = GetFS();

    yyrc = WinQuerySysPointer(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  WinQuerySysPointer
#define WinQuerySysPointer _WinQuerySysPointer

inline BOOL APIENTRY _WinQuerySysPointerData(HWND a, ULONG b, PICONINFO c)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinQuerySysPointerData(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  WinQuerySysPointerData
#define WinQuerySysPointerData _WinQuerySysPointerData

inline BOOL APIENTRY _WinSetPointer(HWND a, HPOINTER b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinSetPointer(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  WinSetPointer
#define WinSetPointer _WinSetPointer

inline BOOL APIENTRY _WinSetPointerOwner(HPOINTER a, PID b, BOOL c)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinSetPointerOwner(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  WinSetPointerOwner
#define WinSetPointerOwner _WinSetPointerOwner

inline BOOL APIENTRY _WinSetPointerPos(HWND a, LONG b, LONG c)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinSetPointerPos(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  WinSetPointerPos
#define WinSetPointerPos _WinSetPointerPos

inline BOOL APIENTRY _WinSetSysPointerData(HWND a, ULONG b, PICONINFO c)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinSetSysPointerData(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  WinSetSysPointerData
#define WinSetSysPointerData _WinSetSysPointerData

inline BOOL APIENTRY _WinShowPointer(HWND a, BOOL b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinShowPointer(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  WinShowPointer
#define WinShowPointer _WinShowPointer

#endif
#ifdef INCL_WINRECTANGLES
inline BOOL APIENTRY _WinCopyRect(HAB a, PRECTL b, PRECTL c)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinCopyRect(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  WinCopyRect
#define WinCopyRect _WinCopyRect

inline BOOL APIENTRY _WinEqualRect(HAB a, PRECTL b, PRECTL c)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinEqualRect(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  WinEqualRect
#define WinEqualRect _WinEqualRect

inline BOOL APIENTRY _WinInflateRect(HAB a, PRECTL b, LONG c, LONG d)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinInflateRect(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  WinInflateRect
#define WinInflateRect _WinInflateRect

inline BOOL APIENTRY _WinIntersectRect(HAB a, PRECTL b, PRECTL c, PRECTL d)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinIntersectRect(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  WinIntersectRect
#define WinIntersectRect _WinIntersectRect

inline BOOL APIENTRY _WinIsRectEmpty(HAB a, PRECTL b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinIsRectEmpty(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  WinIsRectEmpty
#define WinIsRectEmpty _WinIsRectEmpty

inline BOOL APIENTRY _WinMakePoints(HAB a, PPOINTL b, ULONG c)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinMakePoints(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  WinMakePoints
#define WinMakePoints _WinMakePoints

inline BOOL APIENTRY _WinMakeRect(HAB a, PRECTL b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinMakeRect(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  WinMakeRect
#define WinMakeRect _WinMakeRect

inline BOOL APIENTRY _WinOffsetRect(HAB a, PRECTL b, LONG c, LONG d)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinOffsetRect(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  WinOffsetRect
#define WinOffsetRect _WinOffsetRect

inline BOOL APIENTRY _WinPtInRect(HAB a, PRECTL b, PPOINTL c)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinPtInRect(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  WinPtInRect
#define WinPtInRect _WinPtInRect

inline BOOL APIENTRY _WinSetRect(HAB a, PRECTL b, LONG c, LONG d, LONG e, LONG f)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinSetRect(a, b, c, d, e, f);
    SetFS(sel);

    return yyrc;
} 

#undef  WinSetRect
#define WinSetRect _WinSetRect

inline BOOL APIENTRY _WinSetRectEmpty(HAB a, PRECTL b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinSetRectEmpty(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  WinSetRectEmpty
#define WinSetRectEmpty _WinSetRectEmpty

inline BOOL APIENTRY _WinSubtractRect(HAB a, PRECTL b, PRECTL c, PRECTL d)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinSubtractRect(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  WinSubtractRect
#define WinSubtractRect _WinSubtractRect

inline BOOL APIENTRY _WinUnionRect(HAB a, PRECTL b, PRECTL c, PRECTL d)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinUnionRect(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  WinUnionRect
#define WinUnionRect _WinUnionRect

#endif
#ifdef INCL_WINSYS
inline LONG APIENTRY _WinQueryControlColors(HWND a, LONG b, ULONG c, ULONG d, PCTLCOLOR e)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = WinQueryControlColors(a, b, c, d, e);
    SetFS(sel);

    return yyrc;
} 

#undef  WinQueryControlColors
#define WinQueryControlColors _WinQueryControlColors

inline ULONG APIENTRY _WinQueryPresParam(HWND a, ULONG b, ULONG c, PULONG d, ULONG e, PVOID f, ULONG g)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = WinQueryPresParam(a, b, c, d, e, f, g);
    SetFS(sel);

    return yyrc;
} 

#undef  WinQueryPresParam
#define WinQueryPresParam _WinQueryPresParam

inline LONG APIENTRY _WinQuerySysColor(HWND a, LONG b, LONG c)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = WinQuerySysColor(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  WinQuerySysColor
#define WinQuerySysColor _WinQuerySysColor

inline LONG APIENTRY _WinQuerySysValue(HWND a, LONG b)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = WinQuerySysValue(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  WinQuerySysValue
#define WinQuerySysValue _WinQuerySysValue

inline BOOL APIENTRY _WinRemovePresParam(HWND a, ULONG b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinRemovePresParam(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  WinRemovePresParam
#define WinRemovePresParam _WinRemovePresParam

inline LONG APIENTRY _WinSetControlColors(HWND a, LONG b, ULONG c, ULONG d, PCTLCOLOR e)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = WinSetControlColors(a, b, c, d, e);
    SetFS(sel);

    return yyrc;
} 

#undef  WinSetControlColors
#define WinSetControlColors _WinSetControlColors

inline BOOL APIENTRY _WinSetPresParam(HWND a, ULONG b, ULONG c, PVOID d)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinSetPresParam(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  WinSetPresParam
#define WinSetPresParam _WinSetPresParam

inline BOOL APIENTRY _WinSetSysColors(HWND a, ULONG b, ULONG c, LONG d, ULONG e, PLONG f)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinSetSysColors(a, b, c, d, e, f);
    SetFS(sel);

    return yyrc;
} 

#undef  WinSetSysColors
#define WinSetSysColors _WinSetSysColors

inline BOOL APIENTRY _WinSetSysValue(HWND a, LONG b, LONG c)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinSetSysValue(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  WinSetSysValue
#define WinSetSysValue _WinSetSysValue

#endif
#ifdef INCL_WINTHUNKAPI
inline PFN APIENTRY _WinQueryClassThunkProc(PCSZ a)
{
 PFN yyrc;
 USHORT sel = GetFS();

    yyrc = WinQueryClassThunkProc(a);
    SetFS(sel);

    return yyrc;
} 

#undef  WinQueryClassThunkProc
#define WinQueryClassThunkProc _WinQueryClassThunkProc

inline LONG APIENTRY _WinQueryWindowModel(HWND a)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = WinQueryWindowModel(a);
    SetFS(sel);

    return yyrc;
} 

#undef  WinQueryWindowModel
#define WinQueryWindowModel _WinQueryWindowModel

inline PFN APIENTRY _WinQueryWindowThunkProc(HWND a)
{
 PFN yyrc;
 USHORT sel = GetFS();

    yyrc = WinQueryWindowThunkProc(a);
    SetFS(sel);

    return yyrc;
} 

#undef  WinQueryWindowThunkProc
#define WinQueryWindowThunkProc _WinQueryWindowThunkProc

inline BOOL APIENTRY _WinSetClassThunkProc(PCSZ a, PFN b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinSetClassThunkProc(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  WinSetClassThunkProc
#define WinSetClassThunkProc _WinSetClassThunkProc

inline BOOL APIENTRY _WinSetWindowThunkProc(HWND a, PFN b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinSetWindowThunkProc(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  WinSetWindowThunkProc
#define WinSetWindowThunkProc _WinSetWindowThunkProc

#endif
#ifdef INCL_WINTIMER
inline ULONG APIENTRY _WinGetCurrentTime(HAB a)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = WinGetCurrentTime(a);
    SetFS(sel);

    return yyrc;
} 

#undef  WinGetCurrentTime
#define WinGetCurrentTime _WinGetCurrentTime

inline ULONG APIENTRY _WinStartTimer(HAB a, HWND b, ULONG c, ULONG d)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = WinStartTimer(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  WinStartTimer
#define WinStartTimer _WinStartTimer

inline BOOL APIENTRY _WinStopTimer(HAB a, HWND b, ULONG c)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinStopTimer(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  WinStopTimer
#define WinStopTimer _WinStopTimer

#endif
#ifdef INCL_WINTRACKRECT
inline BOOL APIENTRY _WinShowTrackRect(HWND a, BOOL b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinShowTrackRect(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  WinShowTrackRect
#define WinShowTrackRect _WinShowTrackRect

inline BOOL APIENTRY _WinTrackRect(HWND a, HPS b, PTRACKINFO c)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinTrackRect(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  WinTrackRect
#define WinTrackRect _WinTrackRect

#endif
#endif
#ifdef INCL_GPI
inline LONG APIENTRY _GpiAnimatePalette(HPAL a, ULONG b, ULONG c, ULONG d, PULONG e)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiAnimatePalette(a, b, c, d, e);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiAnimatePalette
#define GpiAnimatePalette _GpiAnimatePalette

inline BOOL APIENTRY _GpiBeginArea(HPS a, ULONG b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiBeginArea(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiBeginArea
#define GpiBeginArea _GpiBeginArea

inline BOOL APIENTRY _GpiBeginElement(HPS a, LONG b, PCSZ c)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiBeginElement(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiBeginElement
#define GpiBeginElement _GpiBeginElement

inline BOOL APIENTRY _GpiBeginPath(HPS a, LONG b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiBeginPath(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiBeginPath
#define GpiBeginPath _GpiBeginPath

inline LONG APIENTRY _GpiBox(HPS a, LONG b, PPOINTL c, LONG d, LONG e)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiBox(a, b, c, d, e);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiBox
#define GpiBox _GpiBox

inline LONG APIENTRY _GpiCallSegmentMatrix(HPS a, LONG b, LONG c, PMATRIXLF d, LONG e)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiCallSegmentMatrix(a, b, c, d, e);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiCallSegmentMatrix
#define GpiCallSegmentMatrix _GpiCallSegmentMatrix

inline LONG APIENTRY _GpiCharString(HPS a, LONG b, PCH c)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiCharString(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiCharString
#define GpiCharString _GpiCharString

inline LONG APIENTRY _GpiCharStringAt(HPS a, PPOINTL b, LONG c, PCH d)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiCharStringAt(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiCharStringAt
#define GpiCharStringAt _GpiCharStringAt

inline LONG APIENTRY _GpiCharStringPos(HPS a, PRECTL b, ULONG c, LONG d, PCH e, PLONG f)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiCharStringPos(a, b, c, d, e, f);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiCharStringPos
#define GpiCharStringPos _GpiCharStringPos

inline LONG APIENTRY _GpiCharStringPosAt(HPS a, PPOINTL b, PRECTL c, ULONG d, LONG e, PCH f, PLONG g)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiCharStringPosAt(a, b, c, d, e, f, g);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiCharStringPosAt
#define GpiCharStringPosAt _GpiCharStringPosAt

inline BOOL APIENTRY _GpiCloseFigure(HPS a)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiCloseFigure(a);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiCloseFigure
#define GpiCloseFigure _GpiCloseFigure

inline LONG APIENTRY _GpiCombineRegion(HPS a, HRGN b, HRGN c, HRGN d, LONG e)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiCombineRegion(a, b, c, d, e);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiCombineRegion
#define GpiCombineRegion _GpiCombineRegion

inline BOOL APIENTRY _GpiComment(HPS a, LONG b, PBYTE c)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiComment(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiComment
#define GpiComment _GpiComment

inline BOOL APIENTRY _GpiConvert(HPS a, LONG b, LONG c, LONG d, PPOINTL e)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiConvert(a, b, c, d, e);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiConvert
#define GpiConvert _GpiConvert

inline BOOL APIENTRY _GpiConvertWithMatrix(HPS a, LONG b, PPOINTL c, LONG d, PMATRIXLF e)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiConvertWithMatrix(a, b, c, d, e);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiConvertWithMatrix
#define GpiConvertWithMatrix _GpiConvertWithMatrix

inline HMF APIENTRY _GpiCopyMetaFile(HMF a)
{
 HMF yyrc;
 USHORT sel = GetFS();

    yyrc = GpiCopyMetaFile(a);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiCopyMetaFile
#define GpiCopyMetaFile _GpiCopyMetaFile

inline BOOL APIENTRY _GpiCreateLogColorTable(HPS a, ULONG b, LONG c, LONG d, LONG e, PLONG f)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiCreateLogColorTable(a, b, c, d, e, f);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiCreateLogColorTable
#define GpiCreateLogColorTable _GpiCreateLogColorTable

inline LONG APIENTRY _GpiCreateLogFont(HPS a, STR8 *b, LONG c, PFATTRS d)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiCreateLogFont(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiCreateLogFont
#define GpiCreateLogFont _GpiCreateLogFont

inline HPAL APIENTRY _GpiCreatePalette(HAB a, ULONG b, ULONG c, ULONG d, PULONG e)
{
 HPAL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiCreatePalette(a, b, c, d, e);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiCreatePalette
#define GpiCreatePalette _GpiCreatePalette

inline HRGN APIENTRY _GpiCreateRegion(HPS a, LONG b, PRECTL c)
{
 HRGN yyrc;
 USHORT sel = GetFS();

    yyrc = GpiCreateRegion(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiCreateRegion
#define GpiCreateRegion _GpiCreateRegion

inline BOOL APIENTRY _GpiDeleteElement(HPS a)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiDeleteElement(a);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiDeleteElement
#define GpiDeleteElement _GpiDeleteElement

inline BOOL APIENTRY _GpiDeleteElementRange(HPS a, LONG b, LONG c)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiDeleteElementRange(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiDeleteElementRange
#define GpiDeleteElementRange _GpiDeleteElementRange

inline BOOL APIENTRY _GpiDeleteElementsBetweenLabels(HPS a, LONG b, LONG c)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiDeleteElementsBetweenLabels(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiDeleteElementsBetweenLabels
#define GpiDeleteElementsBetweenLabels _GpiDeleteElementsBetweenLabels

inline BOOL APIENTRY _GpiDeleteMetaFile(HMF a)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiDeleteMetaFile(a);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiDeleteMetaFile
#define GpiDeleteMetaFile _GpiDeleteMetaFile

inline BOOL APIENTRY _GpiDeletePalette(HPAL a)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiDeletePalette(a);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiDeletePalette
#define GpiDeletePalette _GpiDeletePalette

inline BOOL APIENTRY _GpiDeleteSetId(HPS a, LONG b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiDeleteSetId(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiDeleteSetId
#define GpiDeleteSetId _GpiDeleteSetId

inline BOOL APIENTRY _GpiDestroyRegion(HPS a, HRGN b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiDestroyRegion(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiDestroyRegion
#define GpiDestroyRegion _GpiDestroyRegion

inline LONG APIENTRY _GpiElement(HPS a, LONG b, PCSZ c, LONG d, PBYTE e)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiElement(a, b, c, d, e);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiElement
#define GpiElement _GpiElement

inline LONG APIENTRY _GpiEndArea(HPS a)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiEndArea(a);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiEndArea
#define GpiEndArea _GpiEndArea

inline BOOL APIENTRY _GpiEndElement(HPS a)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiEndElement(a);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiEndElement
#define GpiEndElement _GpiEndElement

inline BOOL APIENTRY _GpiEndPath(HPS a)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiEndPath(a);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiEndPath
#define GpiEndPath _GpiEndPath

inline LONG APIENTRY _GpiEqualRegion(HPS a, HRGN b, HRGN c)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiEqualRegion(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiEqualRegion
#define GpiEqualRegion _GpiEqualRegion

inline LONG APIENTRY _GpiExcludeClipRectangle(HPS a, PRECTL b)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiExcludeClipRectangle(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiExcludeClipRectangle
#define GpiExcludeClipRectangle _GpiExcludeClipRectangle

inline LONG APIENTRY _GpiFillPath(HPS a, LONG b, LONG c)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiFillPath(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiFillPath
#define GpiFillPath _GpiFillPath

inline LONG APIENTRY _GpiFrameRegion(HPS a, HRGN b, PSIZEL c)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiFrameRegion(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiFrameRegion
#define GpiFrameRegion _GpiFrameRegion

inline LONG APIENTRY _GpiFullArc(HPS a, LONG b, FIXED c)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiFullArc(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiFullArc
#define GpiFullArc _GpiFullArc

inline LONG APIENTRY _GpiImage(HPS a, LONG b, PSIZEL c, LONG d, PBYTE e)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiImage(a, b, c, d, e);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiImage
#define GpiImage _GpiImage

inline LONG APIENTRY _GpiIntersectClipRectangle(HPS a, PRECTL b)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiIntersectClipRectangle(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiIntersectClipRectangle
#define GpiIntersectClipRectangle _GpiIntersectClipRectangle

inline BOOL APIENTRY _GpiLabel(HPS a, LONG b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiLabel(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiLabel
#define GpiLabel _GpiLabel

inline LONG APIENTRY _GpiLine(HPS a, PPOINTL b)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiLine(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiLine
#define GpiLine _GpiLine

inline BOOL APIENTRY _GpiLoadFonts(HAB a, PCSZ b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiLoadFonts(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiLoadFonts
#define GpiLoadFonts _GpiLoadFonts

inline HMF APIENTRY _GpiLoadMetaFile(HAB a, PCSZ b)
{
 HMF yyrc;
 USHORT sel = GetFS();

    yyrc = GpiLoadMetaFile(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiLoadMetaFile
#define GpiLoadMetaFile _GpiLoadMetaFile

inline BOOL APIENTRY _GpiLoadPublicFonts(HAB a, PCSZ b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiLoadPublicFonts(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiLoadPublicFonts
#define GpiLoadPublicFonts _GpiLoadPublicFonts

inline LONG APIENTRY _GpiMarker(HPS a, PPOINTL b)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiMarker(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiMarker
#define GpiMarker _GpiMarker

inline BOOL APIENTRY _GpiModifyPath(HPS a, LONG b, LONG c)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiModifyPath(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiModifyPath
#define GpiModifyPath _GpiModifyPath

inline BOOL APIENTRY _GpiMove(HPS a, PPOINTL b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiMove(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiMove
#define GpiMove _GpiMove

inline LONG APIENTRY _GpiOffsetClipRegion(HPS a, PPOINTL b)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiOffsetClipRegion(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiOffsetClipRegion
#define GpiOffsetClipRegion _GpiOffsetClipRegion

inline BOOL APIENTRY _GpiOffsetElementPointer(HPS a, LONG b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiOffsetElementPointer(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiOffsetElementPointer
#define GpiOffsetElementPointer _GpiOffsetElementPointer

inline BOOL APIENTRY _GpiOffsetRegion(HPS a, HRGN b, PPOINTL c)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiOffsetRegion(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiOffsetRegion
#define GpiOffsetRegion _GpiOffsetRegion

inline LONG APIENTRY _GpiOutlinePath(HPS a, LONG b, LONG c)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiOutlinePath(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiOutlinePath
#define GpiOutlinePath _GpiOutlinePath

inline LONG APIENTRY _GpiPaintRegion(HPS a, HRGN b)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiPaintRegion(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiPaintRegion
#define GpiPaintRegion _GpiPaintRegion

inline LONG APIENTRY _GpiPartialArc(HPS a, PPOINTL b, FIXED c, FIXED d, FIXED e)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiPartialArc(a, b, c, d, e);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiPartialArc
#define GpiPartialArc _GpiPartialArc

inline HRGN APIENTRY _GpiPathToRegion(HPS a, LONG b, LONG c)
{
 HRGN yyrc;
 USHORT sel = GetFS();

    yyrc = GpiPathToRegion(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiPathToRegion
#define GpiPathToRegion _GpiPathToRegion

inline LONG APIENTRY _GpiPlayMetaFile(HPS a, HMF b, LONG c, PLONG d, PLONG e, LONG f, PSZ g)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiPlayMetaFile(a, b, c, d, e, f, g);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiPlayMetaFile
#define GpiPlayMetaFile _GpiPlayMetaFile

inline LONG APIENTRY _GpiPointArc(HPS a, PPOINTL b)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiPointArc(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiPointArc
#define GpiPointArc _GpiPointArc

inline LONG APIENTRY _GpiPolyFillet(HPS a, LONG b, PPOINTL c)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiPolyFillet(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiPolyFillet
#define GpiPolyFillet _GpiPolyFillet

inline LONG APIENTRY _GpiPolyFilletSharp(HPS a, LONG b, PPOINTL c, PFIXED d)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiPolyFilletSharp(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiPolyFilletSharp
#define GpiPolyFilletSharp _GpiPolyFilletSharp

inline LONG APIENTRY _GpiPolygons(HPS a, ULONG b, PPOLYGON c, ULONG d, ULONG e)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiPolygons(a, b, c, d, e);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiPolygons
#define GpiPolygons _GpiPolygons

inline LONG APIENTRY _GpiPolyLine(HPS a, LONG b, PPOINTL c)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiPolyLine(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiPolyLine
#define GpiPolyLine _GpiPolyLine

inline LONG APIENTRY _GpiPolyLineDisjoint(HPS a, LONG b, PPOINTL c)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiPolyLineDisjoint(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiPolyLineDisjoint
#define GpiPolyLineDisjoint _GpiPolyLineDisjoint

inline LONG APIENTRY _GpiPolyMarker(HPS a, LONG b, PPOINTL c)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiPolyMarker(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiPolyMarker
#define GpiPolyMarker _GpiPolyMarker

inline LONG APIENTRY _GpiPolySpline(HPS a, LONG b, PPOINTL c)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiPolySpline(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiPolySpline
#define GpiPolySpline _GpiPolySpline

inline BOOL APIENTRY _GpiPop(HPS a, LONG b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiPop(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiPop
#define GpiPop _GpiPop

inline LONG APIENTRY _GpiPtInRegion(HPS a, HRGN b, PPOINTL c)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiPtInRegion(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiPtInRegion
#define GpiPtInRegion _GpiPtInRegion

inline LONG APIENTRY _GpiPtVisible(HPS a, PPOINTL b)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiPtVisible(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiPtVisible
#define GpiPtVisible _GpiPtVisible

inline BOOL APIENTRY _GpiQueryArcParams(HPS a, PARCPARAMS b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiQueryArcParams(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiQueryArcParams
#define GpiQueryArcParams _GpiQueryArcParams

inline LONG APIENTRY _GpiQueryAttrMode(HPS a)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiQueryAttrMode(a);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiQueryAttrMode
#define GpiQueryAttrMode _GpiQueryAttrMode

inline LONG APIENTRY _GpiQueryAttrs(HPS a, LONG b, ULONG c, PBUNDLE d)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiQueryAttrs(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiQueryAttrs
#define GpiQueryAttrs _GpiQueryAttrs

inline LONG APIENTRY _GpiQueryBackColor(HPS a)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiQueryBackColor(a);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiQueryBackColor
#define GpiQueryBackColor _GpiQueryBackColor

inline LONG APIENTRY _GpiQueryBackMix(HPS a)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiQueryBackMix(a);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiQueryBackMix
#define GpiQueryBackMix _GpiQueryBackMix

inline BOOL APIENTRY _GpiQueryCharAngle(HPS a, PGRADIENTL b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiQueryCharAngle(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiQueryCharAngle
#define GpiQueryCharAngle _GpiQueryCharAngle

inline BOOL APIENTRY _GpiQueryCharBox(HPS a, PSIZEF b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiQueryCharBox(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiQueryCharBox
#define GpiQueryCharBox _GpiQueryCharBox

inline BOOL APIENTRY _GpiQueryCharBreakExtra(HPS a, PFIXED b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiQueryCharBreakExtra(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiQueryCharBreakExtra
#define GpiQueryCharBreakExtra _GpiQueryCharBreakExtra

inline LONG APIENTRY _GpiQueryCharDirection(HPS a)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiQueryCharDirection(a);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiQueryCharDirection
#define GpiQueryCharDirection _GpiQueryCharDirection

inline BOOL APIENTRY _GpiQueryCharExtra(HPS a, PFIXED b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiQueryCharExtra(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiQueryCharExtra
#define GpiQueryCharExtra _GpiQueryCharExtra

inline LONG APIENTRY _GpiQueryCharMode(HPS a)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiQueryCharMode(a);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiQueryCharMode
#define GpiQueryCharMode _GpiQueryCharMode

inline LONG APIENTRY _GpiQueryCharSet(HPS a)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiQueryCharSet(a);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiQueryCharSet
#define GpiQueryCharSet _GpiQueryCharSet

inline BOOL APIENTRY _GpiQueryCharShear(HPS a, PPOINTL b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiQueryCharShear(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiQueryCharShear
#define GpiQueryCharShear _GpiQueryCharShear

inline BOOL APIENTRY _GpiQueryCharStringPos(HPS a, ULONG b, LONG c, PCH d, PLONG e, PPOINTL f)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiQueryCharStringPos(a, b, c, d, e, f);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiQueryCharStringPos
#define GpiQueryCharStringPos _GpiQueryCharStringPos

inline BOOL APIENTRY _GpiQueryCharStringPosAt(HPS a, PPOINTL b, ULONG c, LONG d, PCH e, PLONG f, PPOINTL g)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiQueryCharStringPosAt(a, b, c, d, e, f, g);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiQueryCharStringPosAt
#define GpiQueryCharStringPosAt _GpiQueryCharStringPosAt

inline LONG APIENTRY _GpiQueryClipBox(HPS a, PRECTL b)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiQueryClipBox(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiQueryClipBox
#define GpiQueryClipBox _GpiQueryClipBox

inline HRGN APIENTRY _GpiQueryClipRegion(HPS a)
{
 HRGN yyrc;
 USHORT sel = GetFS();

    yyrc = GpiQueryClipRegion(a);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiQueryClipRegion
#define GpiQueryClipRegion _GpiQueryClipRegion

inline LONG APIENTRY _GpiQueryColor(HPS a)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiQueryColor(a);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiQueryColor
#define GpiQueryColor _GpiQueryColor

inline BOOL APIENTRY _GpiQueryColorData(HPS a, LONG b, PLONG c)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiQueryColorData(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiQueryColorData
#define GpiQueryColorData _GpiQueryColorData

inline LONG APIENTRY _GpiQueryColorIndex(HPS a, ULONG b, LONG c)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiQueryColorIndex(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiQueryColorIndex
#define GpiQueryColorIndex _GpiQueryColorIndex

inline ULONG APIENTRY _GpiQueryCp(HPS a)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiQueryCp(a);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiQueryCp
#define GpiQueryCp _GpiQueryCp

inline BOOL APIENTRY _GpiQueryCurrentPosition(HPS a, PPOINTL b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiQueryCurrentPosition(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiQueryCurrentPosition
#define GpiQueryCurrentPosition _GpiQueryCurrentPosition

inline BOOL APIENTRY _GpiQueryDefArcParams(HPS a, PARCPARAMS b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiQueryDefArcParams(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiQueryDefArcParams
#define GpiQueryDefArcParams _GpiQueryDefArcParams

inline BOOL APIENTRY _GpiQueryDefAttrs(HPS a, LONG b, ULONG c, PBUNDLE d)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiQueryDefAttrs(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiQueryDefAttrs
#define GpiQueryDefAttrs _GpiQueryDefAttrs

inline BOOL APIENTRY _GpiQueryDefCharBox(HPS a, PSIZEL b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiQueryDefCharBox(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiQueryDefCharBox
#define GpiQueryDefCharBox _GpiQueryDefCharBox

inline BOOL APIENTRY _GpiQueryDefTag(HPS a, PLONG b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiQueryDefTag(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiQueryDefTag
#define GpiQueryDefTag _GpiQueryDefTag

inline BOOL APIENTRY _GpiQueryDefViewingLimits(HPS a, PRECTL b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiQueryDefViewingLimits(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiQueryDefViewingLimits
#define GpiQueryDefViewingLimits _GpiQueryDefViewingLimits

inline BOOL APIENTRY _GpiQueryDefaultViewMatrix(HPS a, LONG b, PMATRIXLF c)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiQueryDefaultViewMatrix(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiQueryDefaultViewMatrix
#define GpiQueryDefaultViewMatrix _GpiQueryDefaultViewMatrix

inline LONG APIENTRY _GpiQueryEditMode(HPS a)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiQueryEditMode(a);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiQueryEditMode
#define GpiQueryEditMode _GpiQueryEditMode

inline LONG APIENTRY _GpiQueryElement(HPS a, LONG b, LONG c, PBYTE d)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiQueryElement(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiQueryElement
#define GpiQueryElement _GpiQueryElement

inline LONG APIENTRY _GpiQueryElementPointer(HPS a)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiQueryElementPointer(a);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiQueryElementPointer
#define GpiQueryElementPointer _GpiQueryElementPointer

inline LONG APIENTRY _GpiQueryElementType(HPS a, PLONG b, LONG c, PSZ d)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiQueryElementType(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiQueryElementType
#define GpiQueryElementType _GpiQueryElementType

inline ULONG APIENTRY _GpiQueryFaceString(HPS a, PCSZ b, PFACENAMEDESC c, LONG d, PSZ e)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiQueryFaceString(a, b, c, d, e);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiQueryFaceString
#define GpiQueryFaceString _GpiQueryFaceString

inline ULONG APIENTRY _GpiQueryFontAction(HAB a, ULONG b)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiQueryFontAction(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiQueryFontAction
#define GpiQueryFontAction _GpiQueryFontAction

inline LONG APIENTRY _GpiQueryFontFileDescriptions(HAB a, PCSZ b, PLONG c, PFFDESCS d)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiQueryFontFileDescriptions(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiQueryFontFileDescriptions
#define GpiQueryFontFileDescriptions _GpiQueryFontFileDescriptions

inline BOOL APIENTRY _GpiQueryFontMetrics(HPS a, LONG b, PFONTMETRICS c)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiQueryFontMetrics(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiQueryFontMetrics
#define GpiQueryFontMetrics _GpiQueryFontMetrics

inline LONG APIENTRY _GpiQueryFonts(HPS a, ULONG b, PCSZ c, PLONG d, LONG e, PFONTMETRICS f)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiQueryFonts(a, b, c, d, e, f);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiQueryFonts
#define GpiQueryFonts _GpiQueryFonts

inline LONG APIENTRY _GpiQueryFullFontFileDescs(HAB a, PCSZ b, PLONG c, PVOID d, PLONG e)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiQueryFullFontFileDescs(a, b, c, d, e);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiQueryFullFontFileDescs
#define GpiQueryFullFontFileDescs _GpiQueryFullFontFileDescs

inline BOOL APIENTRY _GpiQueryGraphicsField(HPS a, PRECTL b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiQueryGraphicsField(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiQueryGraphicsField
#define GpiQueryGraphicsField _GpiQueryGraphicsField

inline LONG APIENTRY _GpiQueryKerningPairs(HPS a, LONG b, PKERNINGPAIRS c)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiQueryKerningPairs(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiQueryKerningPairs
#define GpiQueryKerningPairs _GpiQueryKerningPairs

inline LONG APIENTRY _GpiQueryLineEnd(HPS a)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiQueryLineEnd(a);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiQueryLineEnd
#define GpiQueryLineEnd _GpiQueryLineEnd

inline LONG APIENTRY _GpiQueryLineJoin(HPS a)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiQueryLineJoin(a);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiQueryLineJoin
#define GpiQueryLineJoin _GpiQueryLineJoin

inline LONG APIENTRY _GpiQueryLineType(HPS a)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiQueryLineType(a);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiQueryLineType
#define GpiQueryLineType _GpiQueryLineType

inline FIXED APIENTRY _GpiQueryLineWidth(HPS a)
{
 FIXED yyrc;
 USHORT sel = GetFS();

    yyrc = GpiQueryLineWidth(a);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiQueryLineWidth
#define GpiQueryLineWidth _GpiQueryLineWidth

inline LONG APIENTRY _GpiQueryLineWidthGeom(HPS a)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiQueryLineWidthGeom(a);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiQueryLineWidthGeom
#define GpiQueryLineWidthGeom _GpiQueryLineWidthGeom

inline LONG APIENTRY _GpiQueryLogColorTable(HPS a, ULONG b, LONG c, LONG d, PLONG e)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiQueryLogColorTable(a, b, c, d, e);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiQueryLogColorTable
#define GpiQueryLogColorTable _GpiQueryLogColorTable

inline BOOL APIENTRY _GpiQueryLogicalFont(HPS a, LONG b, PSTR8 c, PFATTRS d, LONG e)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiQueryLogicalFont(a, b, c, d, e);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiQueryLogicalFont
#define GpiQueryLogicalFont _GpiQueryLogicalFont

inline LONG APIENTRY _GpiQueryMarker(HPS a)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiQueryMarker(a);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiQueryMarker
#define GpiQueryMarker _GpiQueryMarker

inline BOOL APIENTRY _GpiQueryMarkerBox(HPS a, PSIZEF b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiQueryMarkerBox(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiQueryMarkerBox
#define GpiQueryMarkerBox _GpiQueryMarkerBox

inline LONG APIENTRY _GpiQueryMarkerSet(HPS a)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiQueryMarkerSet(a);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiQueryMarkerSet
#define GpiQueryMarkerSet _GpiQueryMarkerSet

inline BOOL APIENTRY _GpiQueryMetaFileBits(HMF a, LONG b, LONG c, PBYTE d)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiQueryMetaFileBits(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiQueryMetaFileBits
#define GpiQueryMetaFileBits _GpiQueryMetaFileBits

inline LONG APIENTRY _GpiQueryMetaFileLength(HMF a)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiQueryMetaFileLength(a);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiQueryMetaFileLength
#define GpiQueryMetaFileLength _GpiQueryMetaFileLength

inline LONG APIENTRY _GpiQueryMix(HPS a)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiQueryMix(a);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiQueryMix
#define GpiQueryMix _GpiQueryMix

inline BOOL APIENTRY _GpiQueryModelTransformMatrix(HPS a, LONG b, PMATRIXLF c)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiQueryModelTransformMatrix(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiQueryModelTransformMatrix
#define GpiQueryModelTransformMatrix _GpiQueryModelTransformMatrix

inline LONG APIENTRY _GpiQueryNearestColor(HPS a, ULONG b, LONG c)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiQueryNearestColor(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiQueryNearestColor
#define GpiQueryNearestColor _GpiQueryNearestColor

inline LONG APIENTRY _GpiQueryNumberSetIds(HPS a)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiQueryNumberSetIds(a);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiQueryNumberSetIds
#define GpiQueryNumberSetIds _GpiQueryNumberSetIds

inline BOOL APIENTRY _GpiQueryPageViewport(HPS a, PRECTL b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiQueryPageViewport(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiQueryPageViewport
#define GpiQueryPageViewport _GpiQueryPageViewport

inline HPAL APIENTRY _GpiQueryPalette(HPS a)
{
 HPAL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiQueryPalette(a);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiQueryPalette
#define GpiQueryPalette _GpiQueryPalette

inline LONG APIENTRY _GpiQueryPaletteInfo(HPAL a, HPS b, ULONG c, ULONG d, ULONG e, PULONG f)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiQueryPaletteInfo(a, b, c, d, e, f);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiQueryPaletteInfo
#define GpiQueryPaletteInfo _GpiQueryPaletteInfo

inline LONG APIENTRY _GpiQueryPattern(HPS a)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiQueryPattern(a);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiQueryPattern
#define GpiQueryPattern _GpiQueryPattern

inline BOOL APIENTRY _GpiQueryPatternRefPoint(HPS a, PPOINTL b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiQueryPatternRefPoint(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiQueryPatternRefPoint
#define GpiQueryPatternRefPoint _GpiQueryPatternRefPoint

inline LONG APIENTRY _GpiQueryPatternSet(HPS a)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiQueryPatternSet(a);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiQueryPatternSet
#define GpiQueryPatternSet _GpiQueryPatternSet

inline LONG APIENTRY _GpiQueryRealColors(HPS a, ULONG b, LONG c, LONG d, PLONG e)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiQueryRealColors(a, b, c, d, e);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiQueryRealColors
#define GpiQueryRealColors _GpiQueryRealColors

inline LONG APIENTRY _GpiQueryRegionBox(HPS a, HRGN b, PRECTL c)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiQueryRegionBox(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiQueryRegionBox
#define GpiQueryRegionBox _GpiQueryRegionBox

inline BOOL APIENTRY _GpiQueryRegionRects(HPS a, HRGN b, PRECTL c, PRGNRECT d, PRECTL e)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiQueryRegionRects(a, b, c, d, e);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiQueryRegionRects
#define GpiQueryRegionRects _GpiQueryRegionRects

inline LONG APIENTRY _GpiQueryRGBColor(HPS a, ULONG b, LONG c)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiQueryRGBColor(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiQueryRGBColor
#define GpiQueryRGBColor _GpiQueryRGBColor

inline BOOL APIENTRY _GpiQuerySegmentTransformMatrix(HPS a, LONG b, LONG c, PMATRIXLF d)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiQuerySegmentTransformMatrix(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiQuerySegmentTransformMatrix
#define GpiQuerySegmentTransformMatrix _GpiQuerySegmentTransformMatrix

inline BOOL APIENTRY _GpiQuerySetIds(HPS a, LONG b, PLONG c, PSTR8 d, PLONG e)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiQuerySetIds(a, b, c, d, e);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiQuerySetIds
#define GpiQuerySetIds _GpiQuerySetIds

inline BOOL APIENTRY _GpiQueryTextAlignment(HPS a, PLONG b, PLONG c)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiQueryTextAlignment(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiQueryTextAlignment
#define GpiQueryTextAlignment _GpiQueryTextAlignment

inline BOOL APIENTRY _GpiQueryTextBox(HPS a, LONG b, PCH c, LONG d, PPOINTL e)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiQueryTextBox(a, b, c, d, e);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiQueryTextBox
#define GpiQueryTextBox _GpiQueryTextBox

inline BOOL APIENTRY _GpiQueryViewingLimits(HPS a, PRECTL b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiQueryViewingLimits(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiQueryViewingLimits
#define GpiQueryViewingLimits _GpiQueryViewingLimits

inline BOOL APIENTRY _GpiQueryViewingTransformMatrix(HPS a, LONG b, PMATRIXLF c)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiQueryViewingTransformMatrix(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiQueryViewingTransformMatrix
#define GpiQueryViewingTransformMatrix _GpiQueryViewingTransformMatrix

inline BOOL APIENTRY _GpiQueryWidthTable(HPS a, LONG b, LONG c, PLONG d)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiQueryWidthTable(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiQueryWidthTable
#define GpiQueryWidthTable _GpiQueryWidthTable

inline LONG APIENTRY _GpiRectInRegion(HPS a, HRGN b, PRECTL c)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiRectInRegion(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiRectInRegion
#define GpiRectInRegion _GpiRectInRegion

inline LONG APIENTRY _GpiRectVisible(HPS a, PRECTL b)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiRectVisible(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiRectVisible
#define GpiRectVisible _GpiRectVisible

inline BOOL APIENTRY _GpiRotate(HPS a, PMATRIXLF b, LONG c, FIXED d, PPOINTL e)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiRotate(a, b, c, d, e);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiRotate
#define GpiRotate _GpiRotate

inline BOOL APIENTRY _GpiSaveMetaFile(HMF a, PCSZ b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiSaveMetaFile(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiSaveMetaFile
#define GpiSaveMetaFile _GpiSaveMetaFile

inline BOOL APIENTRY _GpiScale(HPS a, PMATRIXLF b, LONG c, PFIXED d, PPOINTL e)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiScale(a, b, c, d, e);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiScale
#define GpiScale _GpiScale

inline HPAL APIENTRY _GpiSelectPalette(HPS a, HPAL b)
{
 HPAL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiSelectPalette(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiSelectPalette
#define GpiSelectPalette _GpiSelectPalette

inline BOOL APIENTRY _GpiSetArcParams(HPS a, PARCPARAMS b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiSetArcParams(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiSetArcParams
#define GpiSetArcParams _GpiSetArcParams

inline BOOL APIENTRY _GpiSetAttrMode(HPS a, LONG b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiSetAttrMode(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiSetAttrMode
#define GpiSetAttrMode _GpiSetAttrMode

inline BOOL APIENTRY _GpiSetAttrs(HPS a, LONG b, ULONG c, ULONG d, PVOID e)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiSetAttrs(a, b, c, d, e);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiSetAttrs
#define GpiSetAttrs _GpiSetAttrs

inline BOOL APIENTRY _GpiSetBackColor(HPS a, LONG b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiSetBackColor(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiSetBackColor
#define GpiSetBackColor _GpiSetBackColor

inline BOOL APIENTRY _GpiSetBackMix(HPS a, LONG b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiSetBackMix(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiSetBackMix
#define GpiSetBackMix _GpiSetBackMix

inline BOOL APIENTRY _GpiSetCharAngle(HPS a, PGRADIENTL b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiSetCharAngle(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiSetCharAngle
#define GpiSetCharAngle _GpiSetCharAngle

inline BOOL APIENTRY _GpiSetCharBox(HPS a, PSIZEF b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiSetCharBox(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiSetCharBox
#define GpiSetCharBox _GpiSetCharBox

inline BOOL APIENTRY _GpiSetCharBreakExtra(HPS a, FIXED b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiSetCharBreakExtra(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiSetCharBreakExtra
#define GpiSetCharBreakExtra _GpiSetCharBreakExtra

inline BOOL APIENTRY _GpiSetCharDirection(HPS a, LONG b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiSetCharDirection(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiSetCharDirection
#define GpiSetCharDirection _GpiSetCharDirection

inline BOOL APIENTRY _GpiSetCharExtra(HPS a, FIXED b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiSetCharExtra(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiSetCharExtra
#define GpiSetCharExtra _GpiSetCharExtra

inline BOOL APIENTRY _GpiSetCharMode(HPS a, LONG b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiSetCharMode(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiSetCharMode
#define GpiSetCharMode _GpiSetCharMode

inline BOOL APIENTRY _GpiSetCharSet(HPS a, LONG b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiSetCharSet(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiSetCharSet
#define GpiSetCharSet _GpiSetCharSet

inline BOOL APIENTRY _GpiSetCharShear(HPS a, PPOINTL b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiSetCharShear(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiSetCharShear
#define GpiSetCharShear _GpiSetCharShear

inline BOOL APIENTRY _GpiSetClipPath(HPS a, LONG b, LONG c)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiSetClipPath(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiSetClipPath
#define GpiSetClipPath _GpiSetClipPath

inline LONG APIENTRY _GpiSetClipRegion(HPS a, HRGN b, PHRGN c)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiSetClipRegion(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiSetClipRegion
#define GpiSetClipRegion _GpiSetClipRegion

inline BOOL APIENTRY _GpiSetColor(HPS a, LONG b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiSetColor(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiSetColor
#define GpiSetColor _GpiSetColor

inline BOOL APIENTRY _GpiSetCp(HPS a, ULONG b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiSetCp(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiSetCp
#define GpiSetCp _GpiSetCp

inline BOOL APIENTRY _GpiSetCurrentPosition(HPS a, PPOINTL b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiSetCurrentPosition(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiSetCurrentPosition
#define GpiSetCurrentPosition _GpiSetCurrentPosition

inline BOOL APIENTRY _GpiSetDefArcParams(HPS a, PARCPARAMS b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiSetDefArcParams(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiSetDefArcParams
#define GpiSetDefArcParams _GpiSetDefArcParams

inline BOOL APIENTRY _GpiSetDefAttrs(HPS a, LONG b, ULONG c, PVOID d)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiSetDefAttrs(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiSetDefAttrs
#define GpiSetDefAttrs _GpiSetDefAttrs

inline BOOL APIENTRY _GpiSetDefaultViewMatrix(HPS a, LONG b, PMATRIXLF c, LONG d)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiSetDefaultViewMatrix(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiSetDefaultViewMatrix
#define GpiSetDefaultViewMatrix _GpiSetDefaultViewMatrix

inline BOOL APIENTRY _GpiSetDefTag(HPS a, LONG b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiSetDefTag(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiSetDefTag
#define GpiSetDefTag _GpiSetDefTag

inline BOOL APIENTRY _GpiSetDefViewingLimits(HPS a, PRECTL b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiSetDefViewingLimits(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiSetDefViewingLimits
#define GpiSetDefViewingLimits _GpiSetDefViewingLimits

inline BOOL APIENTRY _GpiSetEditMode(HPS a, LONG b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiSetEditMode(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiSetEditMode
#define GpiSetEditMode _GpiSetEditMode

inline BOOL APIENTRY _GpiSetElementPointer(HPS a, LONG b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiSetElementPointer(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiSetElementPointer
#define GpiSetElementPointer _GpiSetElementPointer

inline BOOL APIENTRY _GpiSetElementPointerAtLabel(HPS a, LONG b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiSetElementPointerAtLabel(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiSetElementPointerAtLabel
#define GpiSetElementPointerAtLabel _GpiSetElementPointerAtLabel

inline BOOL APIENTRY _GpiSetGraphicsField(HPS a, PRECTL b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiSetGraphicsField(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiSetGraphicsField
#define GpiSetGraphicsField _GpiSetGraphicsField

inline BOOL APIENTRY _GpiSetLineEnd(HPS a, LONG b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiSetLineEnd(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiSetLineEnd
#define GpiSetLineEnd _GpiSetLineEnd

inline BOOL APIENTRY _GpiSetLineJoin(HPS a, LONG b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiSetLineJoin(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiSetLineJoin
#define GpiSetLineJoin _GpiSetLineJoin

inline BOOL APIENTRY _GpiSetLineType(HPS a, LONG b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiSetLineType(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiSetLineType
#define GpiSetLineType _GpiSetLineType

inline BOOL APIENTRY _GpiSetLineWidth(HPS a, FIXED b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiSetLineWidth(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiSetLineWidth
#define GpiSetLineWidth _GpiSetLineWidth

inline BOOL APIENTRY _GpiSetLineWidthGeom(HPS a, LONG b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiSetLineWidthGeom(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiSetLineWidthGeom
#define GpiSetLineWidthGeom _GpiSetLineWidthGeom

inline BOOL APIENTRY _GpiSetMarker(HPS a, LONG b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiSetMarker(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiSetMarker
#define GpiSetMarker _GpiSetMarker

inline BOOL APIENTRY _GpiSetMarkerBox(HPS a, PSIZEF b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiSetMarkerBox(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiSetMarkerBox
#define GpiSetMarkerBox _GpiSetMarkerBox

inline BOOL APIENTRY _GpiSetMarkerSet(HPS a, LONG b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiSetMarkerSet(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiSetMarkerSet
#define GpiSetMarkerSet _GpiSetMarkerSet

inline BOOL APIENTRY _GpiSetMetaFileBits(HMF a, LONG b, LONG c, PBYTE d)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiSetMetaFileBits(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiSetMetaFileBits
#define GpiSetMetaFileBits _GpiSetMetaFileBits

inline BOOL APIENTRY _GpiSetMix(HPS a, LONG b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiSetMix(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiSetMix
#define GpiSetMix _GpiSetMix

inline BOOL APIENTRY _GpiSetModelTransformMatrix(HPS a, LONG b, PMATRIXLF c, LONG d)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiSetModelTransformMatrix(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiSetModelTransformMatrix
#define GpiSetModelTransformMatrix _GpiSetModelTransformMatrix

inline BOOL APIENTRY _GpiSetPageViewport(HPS a, PRECTL b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiSetPageViewport(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiSetPageViewport
#define GpiSetPageViewport _GpiSetPageViewport

inline BOOL APIENTRY _GpiSetPaletteEntries(HPAL a, ULONG b, ULONG c, ULONG d, ULONG *e)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiSetPaletteEntries(a, b, c, d, e);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiSetPaletteEntries
#define GpiSetPaletteEntries _GpiSetPaletteEntries

inline BOOL APIENTRY _GpiSetPattern(HPS a, LONG b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiSetPattern(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiSetPattern
#define GpiSetPattern _GpiSetPattern

inline BOOL APIENTRY _GpiSetPatternRefPoint(HPS a, PPOINTL b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiSetPatternRefPoint(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiSetPatternRefPoint
#define GpiSetPatternRefPoint _GpiSetPatternRefPoint

inline BOOL APIENTRY _GpiSetPatternSet(HPS a, LONG b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiSetPatternSet(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiSetPatternSet
#define GpiSetPatternSet _GpiSetPatternSet

inline BOOL APIENTRY _GpiSetRegion(HPS a, HRGN b, LONG c, PRECTL d)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiSetRegion(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiSetRegion
#define GpiSetRegion _GpiSetRegion

inline BOOL APIENTRY _GpiSetSegmentTransformMatrix(HPS a, LONG b, LONG c, MATRIXLF *d, LONG e)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiSetSegmentTransformMatrix(a, b, c, d, e);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiSetSegmentTransformMatrix
#define GpiSetSegmentTransformMatrix _GpiSetSegmentTransformMatrix

inline BOOL APIENTRY _GpiSetTextAlignment(HPS a, LONG b, LONG c)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiSetTextAlignment(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiSetTextAlignment
#define GpiSetTextAlignment _GpiSetTextAlignment

inline BOOL APIENTRY _GpiSetViewingLimits(HPS a, PRECTL b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiSetViewingLimits(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiSetViewingLimits
#define GpiSetViewingLimits _GpiSetViewingLimits

inline BOOL APIENTRY _GpiSetViewingTransformMatrix(HPS a, LONG b, MATRIXLF *c, LONG d)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiSetViewingTransformMatrix(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiSetViewingTransformMatrix
#define GpiSetViewingTransformMatrix _GpiSetViewingTransformMatrix

inline LONG APIENTRY _GpiStrokePath(HPS a, LONG b, ULONG c)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiStrokePath(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiStrokePath
#define GpiStrokePath _GpiStrokePath

inline BOOL APIENTRY _GpiTranslate(HPS a, PMATRIXLF b, LONG c, PPOINTL d)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiTranslate(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiTranslate
#define GpiTranslate _GpiTranslate

inline BOOL APIENTRY _GpiUnloadFonts(HAB a, PCSZ b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiUnloadFonts(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiUnloadFonts
#define GpiUnloadFonts _GpiUnloadFonts

inline BOOL APIENTRY _GpiUnloadPublicFonts(HAB a, PCSZ b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiUnloadPublicFonts(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiUnloadPublicFonts
#define GpiUnloadPublicFonts _GpiUnloadPublicFonts

#ifdef INCL_GPIBITMAPS
inline LONG APIENTRY _GpiBitBlt(HPS a, HPS b, LONG c, PPOINTL d, LONG e, ULONG f)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiBitBlt(a, b, c, d, e, f);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiBitBlt
#define GpiBitBlt _GpiBitBlt

inline BOOL APIENTRY _GpiDeleteBitmap(HBITMAP a)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiDeleteBitmap(a);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiDeleteBitmap
#define GpiDeleteBitmap _GpiDeleteBitmap

inline HBITMAP APIENTRY _GpiLoadBitmap(HPS a, HMODULE b, ULONG c, LONG d, LONG e)
{
 HBITMAP yyrc;
 USHORT sel = GetFS();

    yyrc = GpiLoadBitmap(a, b, c, d, e);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiLoadBitmap
#define GpiLoadBitmap _GpiLoadBitmap

inline HBITMAP APIENTRY _GpiSetBitmap(HPS a, HBITMAP b)
{
 HBITMAP yyrc;
 USHORT sel = GetFS();

    yyrc = GpiSetBitmap(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiSetBitmap
#define GpiSetBitmap _GpiSetBitmap

inline LONG APIENTRY _GpiWCBitBlt(HPS a, HBITMAP b, LONG c, PPOINTL d, LONG e, ULONG f)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiWCBitBlt(a, b, c, d, e, f);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiWCBitBlt
#define GpiWCBitBlt _GpiWCBitBlt

inline HBITMAP APIENTRY _GpiCreateBitmap(HPS a, BITMAPINFOHEADER2 *b, ULONG c, PBYTE d, BITMAPINFO2 *e)
{
 HBITMAP yyrc;
 USHORT sel = GetFS();

    yyrc = GpiCreateBitmap(a, b, c, d, e);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiCreateBitmap
#define GpiCreateBitmap _GpiCreateBitmap

inline LONG APIENTRY _GpiDrawBits(HPS a, PVOID b, BITMAPINFO2 *c, LONG d, PPOINTL e, LONG f, ULONG g)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiDrawBits(a, b, c, d, e, f, g);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiDrawBits
#define GpiDrawBits _GpiDrawBits

inline LONG APIENTRY _GpiFloodFill(HPS a, LONG b, LONG c)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiFloodFill(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiFloodFill
#define GpiFloodFill _GpiFloodFill

inline LONG APIENTRY _GpiQueryBitmapBits(HPS a, LONG b, LONG c, PBYTE d, PBITMAPINFO2 e)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiQueryBitmapBits(a, b, c, d, e);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiQueryBitmapBits
#define GpiQueryBitmapBits _GpiQueryBitmapBits

inline BOOL APIENTRY _GpiQueryBitmapDimension(HBITMAP a, PSIZEL b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiQueryBitmapDimension(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiQueryBitmapDimension
#define GpiQueryBitmapDimension _GpiQueryBitmapDimension

inline HBITMAP APIENTRY _GpiQueryBitmapHandle(HPS a, LONG b)
{
 HBITMAP yyrc;
 USHORT sel = GetFS();

    yyrc = GpiQueryBitmapHandle(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiQueryBitmapHandle
#define GpiQueryBitmapHandle _GpiQueryBitmapHandle

inline BOOL APIENTRY _GpiQueryBitmapInfoHeader(HBITMAP a, PBITMAPINFOHEADER2 b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiQueryBitmapInfoHeader(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiQueryBitmapInfoHeader
#define GpiQueryBitmapInfoHeader _GpiQueryBitmapInfoHeader

inline BOOL APIENTRY _GpiQueryBitmapParameters(HBITMAP a, PBITMAPINFOHEADER b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiQueryBitmapParameters(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiQueryBitmapParameters
#define GpiQueryBitmapParameters _GpiQueryBitmapParameters

inline BOOL APIENTRY _GpiQueryDeviceBitmapFormats(HPS a, LONG b, PLONG c)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiQueryDeviceBitmapFormats(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiQueryDeviceBitmapFormats
#define GpiQueryDeviceBitmapFormats _GpiQueryDeviceBitmapFormats

inline LONG APIENTRY _GpiSetBitmapBits(HPS a, LONG b, LONG c, PBYTE d, BITMAPINFO2 *e)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiSetBitmapBits(a, b, c, d, e);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiSetBitmapBits
#define GpiSetBitmapBits _GpiSetBitmapBits

inline LONG APIENTRY _GpiQueryPel(HPS a, PPOINTL b)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiQueryPel(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiQueryPel
#define GpiQueryPel _GpiQueryPel

inline BOOL APIENTRY _GpiSetBitmapDimension(HBITMAP a, SIZEL *b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiSetBitmapDimension(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiSetBitmapDimension
#define GpiSetBitmapDimension _GpiSetBitmapDimension

inline BOOL APIENTRY _GpiSetBitmapId(HPS a, HBITMAP b, LONG c)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiSetBitmapId(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiSetBitmapId
#define GpiSetBitmapId _GpiSetBitmapId

inline LONG APIENTRY _GpiSetPel(HPS a, PPOINTL b)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiSetPel(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiSetPel
#define GpiSetPel _GpiSetPel

#endif
#ifdef INCL_GPICONTROL
inline BOOL APIENTRY _GpiAssociate(HPS a, HDC b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiAssociate(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiAssociate
#define GpiAssociate _GpiAssociate

inline HPS APIENTRY _GpiCreatePS(HAB a, HDC b, PSIZEL c, ULONG d)
{
 HPS yyrc;
 USHORT sel = GetFS();

    yyrc = GpiCreatePS(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiCreatePS
#define GpiCreatePS _GpiCreatePS

inline BOOL APIENTRY _GpiDestroyPS(HPS a)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiDestroyPS(a);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiDestroyPS
#define GpiDestroyPS _GpiDestroyPS

inline BOOL APIENTRY _GpiErase(HPS a)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiErase(a);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiErase
#define GpiErase _GpiErase

inline HDC APIENTRY _GpiQueryDevice(HPS a)
{
 HDC yyrc;
 USHORT sel = GetFS();

    yyrc = GpiQueryDevice(a);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiQueryDevice
#define GpiQueryDevice _GpiQueryDevice

inline BOOL APIENTRY _GpiRestorePS(HPS a, LONG b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiRestorePS(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiRestorePS
#define GpiRestorePS _GpiRestorePS

inline LONG APIENTRY _GpiSavePS(HPS a)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiSavePS(a);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiSavePS
#define GpiSavePS _GpiSavePS

inline LONG APIENTRY _GpiErrorSegmentData(HPS a, PLONG b, PLONG c)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiErrorSegmentData(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiErrorSegmentData
#define GpiErrorSegmentData _GpiErrorSegmentData

inline LONG APIENTRY _GpiQueryDrawControl(HPS a, LONG b)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiQueryDrawControl(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiQueryDrawControl
#define GpiQueryDrawControl _GpiQueryDrawControl

inline LONG APIENTRY _GpiQueryDrawingMode(HPS a)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiQueryDrawingMode(a);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiQueryDrawingMode
#define GpiQueryDrawingMode _GpiQueryDrawingMode

inline ULONG APIENTRY _GpiQueryPS(HPS a, PSIZEL b)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiQueryPS(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiQueryPS
#define GpiQueryPS _GpiQueryPS

inline BOOL APIENTRY _GpiResetPS(HPS a, ULONG b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiResetPS(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiResetPS
#define GpiResetPS _GpiResetPS

inline LONG APIENTRY _GpiQueryStopDraw(HPS a)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiQueryStopDraw(a);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiQueryStopDraw
#define GpiQueryStopDraw _GpiQueryStopDraw

inline BOOL APIENTRY _GpiSetDrawControl(HPS a, LONG b, LONG c)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiSetDrawControl(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiSetDrawControl
#define GpiSetDrawControl _GpiSetDrawControl

inline BOOL APIENTRY _GpiSetDrawingMode(HPS a, LONG b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiSetDrawingMode(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiSetDrawingMode
#define GpiSetDrawingMode _GpiSetDrawingMode

inline BOOL APIENTRY _GpiSetPS(HPS a, SIZEL *b, ULONG c)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiSetPS(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiSetPS
#define GpiSetPS _GpiSetPS

inline BOOL APIENTRY _GpiSetStopDraw(HPS a, LONG b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiSetStopDraw(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiSetStopDraw
#define GpiSetStopDraw _GpiSetStopDraw

#endif
#ifdef INCL_GPICORRELATION
inline LONG APIENTRY _GpiCorrelateChain(HPS a, LONG b, PPOINTL c, LONG d, LONG e, PLONG f)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiCorrelateChain(a, b, c, d, e, f);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiCorrelateChain
#define GpiCorrelateChain _GpiCorrelateChain

inline LONG APIENTRY _GpiCorrelateFrom(HPS a, LONG b, LONG c, LONG d, PPOINTL e, LONG f, LONG g, PLONG h)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiCorrelateFrom(a, b, c, d, e, f, g, h);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiCorrelateFrom
#define GpiCorrelateFrom _GpiCorrelateFrom

inline LONG APIENTRY _GpiCorrelateSegment(HPS a, LONG b, LONG c, PPOINTL d, LONG e, LONG f, PLONG g)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiCorrelateSegment(a, b, c, d, e, f, g);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiCorrelateSegment
#define GpiCorrelateSegment _GpiCorrelateSegment

inline BOOL APIENTRY _GpiQueryBoundaryData(HPS a, PRECTL b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiQueryBoundaryData(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiQueryBoundaryData
#define GpiQueryBoundaryData _GpiQueryBoundaryData

inline BOOL APIENTRY _GpiQueryPickAperturePosition(HPS a, PPOINTL b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiQueryPickAperturePosition(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiQueryPickAperturePosition
#define GpiQueryPickAperturePosition _GpiQueryPickAperturePosition

inline BOOL APIENTRY _GpiQueryPickApertureSize(HPS a, PSIZEL b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiQueryPickApertureSize(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiQueryPickApertureSize
#define GpiQueryPickApertureSize _GpiQueryPickApertureSize

inline BOOL APIENTRY _GpiQueryTag(HPS a, PLONG b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiQueryTag(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiQueryTag
#define GpiQueryTag _GpiQueryTag

inline BOOL APIENTRY _GpiResetBoundaryData(HPS a)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiResetBoundaryData(a);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiResetBoundaryData
#define GpiResetBoundaryData _GpiResetBoundaryData

inline BOOL APIENTRY _GpiSetPickAperturePosition(HPS a, PPOINTL b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiSetPickAperturePosition(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiSetPickAperturePosition
#define GpiSetPickAperturePosition _GpiSetPickAperturePosition

inline BOOL APIENTRY _GpiSetPickApertureSize(HPS a, LONG b, SIZEL *c)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiSetPickApertureSize(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiSetPickApertureSize
#define GpiSetPickApertureSize _GpiSetPickApertureSize

inline BOOL APIENTRY _GpiSetTag(HPS a, LONG b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiSetTag(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiSetTag
#define GpiSetTag _GpiSetTag

#endif
#ifdef INCL_GPIINK
inline BOOL APIENTRY _GpiBeginInkPath(HPS a, LONG b, ULONG c)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiBeginInkPath(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiBeginInkPath
#define GpiBeginInkPath _GpiBeginInkPath

inline BOOL APIENTRY _GpiEndInkPath(HPS a, ULONG b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiEndInkPath(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiEndInkPath
#define GpiEndInkPath _GpiEndInkPath

inline LONG APIENTRY _GpiStrokeInkPath(HPS a, LONG b, LONG c, PPOINTL d, ULONG e)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiStrokeInkPath(a, b, c, d, e);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiStrokeInkPath
#define GpiStrokeInkPath _GpiStrokeInkPath

#endif
#ifdef INCL_GPISEGMENTS
inline BOOL APIENTRY _GpiCloseSegment(HPS a)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiCloseSegment(a);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiCloseSegment
#define GpiCloseSegment _GpiCloseSegment

inline BOOL APIENTRY _GpiDeleteSegment(HPS a, LONG b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiDeleteSegment(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiDeleteSegment
#define GpiDeleteSegment _GpiDeleteSegment

inline BOOL APIENTRY _GpiDeleteSegments(HPS a, LONG b, LONG c)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiDeleteSegments(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiDeleteSegments
#define GpiDeleteSegments _GpiDeleteSegments

inline BOOL APIENTRY _GpiDrawChain(HPS a)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiDrawChain(a);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiDrawChain
#define GpiDrawChain _GpiDrawChain

inline BOOL APIENTRY _GpiDrawDynamics(HPS a)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiDrawDynamics(a);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiDrawDynamics
#define GpiDrawDynamics _GpiDrawDynamics

inline BOOL APIENTRY _GpiDrawFrom(HPS a, LONG b, LONG c)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiDrawFrom(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiDrawFrom
#define GpiDrawFrom _GpiDrawFrom

inline BOOL APIENTRY _GpiDrawSegment(HPS a, LONG b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiDrawSegment(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiDrawSegment
#define GpiDrawSegment _GpiDrawSegment

inline LONG APIENTRY _GpiGetData(HPS a, LONG b, PLONG c, LONG d, LONG e, PBYTE f)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiGetData(a, b, c, d, e, f);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiGetData
#define GpiGetData _GpiGetData

inline BOOL APIENTRY _GpiOpenSegment(HPS a, LONG b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiOpenSegment(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiOpenSegment
#define GpiOpenSegment _GpiOpenSegment

inline LONG APIENTRY _GpiPutData(HPS a, LONG b, PLONG c, PBYTE d)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiPutData(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiPutData
#define GpiPutData _GpiPutData

inline LONG APIENTRY _GpiQueryInitialSegmentAttrs(HPS a, LONG b)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiQueryInitialSegmentAttrs(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiQueryInitialSegmentAttrs
#define GpiQueryInitialSegmentAttrs _GpiQueryInitialSegmentAttrs

inline LONG APIENTRY _GpiQuerySegmentAttrs(HPS a, LONG b, LONG c)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiQuerySegmentAttrs(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiQuerySegmentAttrs
#define GpiQuerySegmentAttrs _GpiQuerySegmentAttrs

inline LONG APIENTRY _GpiQuerySegmentNames(HPS a, LONG b, LONG c, LONG d, PLONG e)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiQuerySegmentNames(a, b, c, d, e);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiQuerySegmentNames
#define GpiQuerySegmentNames _GpiQuerySegmentNames

inline LONG APIENTRY _GpiQuerySegmentPriority(HPS a, LONG b, LONG c)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = GpiQuerySegmentPriority(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiQuerySegmentPriority
#define GpiQuerySegmentPriority _GpiQuerySegmentPriority

inline BOOL APIENTRY _GpiRemoveDynamics(HPS a, LONG b, LONG c)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiRemoveDynamics(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiRemoveDynamics
#define GpiRemoveDynamics _GpiRemoveDynamics

inline BOOL APIENTRY _GpiSetInitialSegmentAttrs(HPS a, LONG b, LONG c)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiSetInitialSegmentAttrs(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiSetInitialSegmentAttrs
#define GpiSetInitialSegmentAttrs _GpiSetInitialSegmentAttrs

inline BOOL APIENTRY _GpiSetSegmentAttrs(HPS a, LONG b, LONG c, LONG d)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiSetSegmentAttrs(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiSetSegmentAttrs
#define GpiSetSegmentAttrs _GpiSetSegmentAttrs

inline BOOL APIENTRY _GpiSetSegmentPriority(HPS a, LONG b, LONG c, LONG d)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = GpiSetSegmentPriority(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  GpiSetSegmentPriority
#define GpiSetSegmentPriority _GpiSetSegmentPriority

#endif
#ifdef INCL_DEV
inline LONG APIENTRY _DevEscape(HDC a, LONG b, LONG c, PBYTE d, PLONG e, PBYTE f)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = DevEscape(a, b, c, d, e, f);
    SetFS(sel);

    return yyrc;
} 

#undef  DevEscape
#define DevEscape _DevEscape

inline LONG APIENTRY _DevPostEscape(PCSZ a, PCSZ b, PCSZ c, PCSZ d, ULONG e, ULONG f, PBYTE g, ULONG h, PBYTE i)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = DevPostEscape(a, b, c, d, e, f, g, h, i);
    SetFS(sel);

    return yyrc;
} 

#undef  DevPostEscape
#define DevPostEscape _DevPostEscape

inline LONG APIENTRY _DevPostDeviceModes(HAB a, PDRIVDATA b, PCSZ c, PCSZ d, PCSZ e, ULONG f)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = DevPostDeviceModes(a, b, c, d, e, f);
    SetFS(sel);

    return yyrc;
} 

#undef  DevPostDeviceModes
#define DevPostDeviceModes _DevPostDeviceModes

inline BOOL APIENTRY _DevQueryDeviceNames(HAB a, PCSZ b, PLONG c, PSTR32 d, PSTR64 e, PLONG f, PSTR16 g)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = DevQueryDeviceNames(a, b, c, d, e, f, g);
    SetFS(sel);

    return yyrc;
} 

#undef  DevQueryDeviceNames
#define DevQueryDeviceNames _DevQueryDeviceNames

inline LONG APIENTRY _DevQueryHardcopyCaps(HDC a, LONG b, LONG c, PHCINFO d)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = DevQueryHardcopyCaps(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  DevQueryHardcopyCaps
#define DevQueryHardcopyCaps _DevQueryHardcopyCaps

#endif
inline HMF APIENTRY _DevCloseDC(HDC a)
{
 HMF yyrc;
 USHORT sel = GetFS();

    yyrc = DevCloseDC(a);
    SetFS(sel);

    return yyrc;
} 

#undef  DevCloseDC
#define DevCloseDC _DevCloseDC

inline HDC APIENTRY _DevOpenDC(HAB a, LONG b, PCSZ c, LONG d, PDEVOPENDATA e, HDC f)
{
 HDC yyrc;
 USHORT sel = GetFS();

    yyrc = DevOpenDC(a, b, c, d, e, f);
    SetFS(sel);

    return yyrc;
} 

#undef  DevOpenDC
#define DevOpenDC _DevOpenDC

inline BOOL APIENTRY _DevQueryCaps(HDC a, LONG b, LONG c, PLONG d)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = DevQueryCaps(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  DevQueryCaps
#define DevQueryCaps _DevQueryCaps

#endif
#ifdef INCL_WINPROGRAMLIST
inline HPROGRAM APIENTRY _PrfAddProgram(HINI a, PPROGDETAILS b, HPROGRAM c)
{
 HPROGRAM yyrc;
 USHORT sel = GetFS();

    yyrc = PrfAddProgram(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  PrfAddProgram
#define PrfAddProgram _PrfAddProgram

inline BOOL APIENTRY _PrfChangeProgram(HINI a, HPROGRAM b, PPROGDETAILS c)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = PrfChangeProgram(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  PrfChangeProgram
#define PrfChangeProgram _PrfChangeProgram

inline HPROGRAM APIENTRY _PrfCreateGroup(HINI a, PCSZ b, UCHAR c)
{
 HPROGRAM yyrc;
 USHORT sel = GetFS();

    yyrc = PrfCreateGroup(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  PrfCreateGroup
#define PrfCreateGroup _PrfCreateGroup

inline BOOL APIENTRY _PrfDestroyGroup(HINI a, HPROGRAM b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = PrfDestroyGroup(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  PrfDestroyGroup
#define PrfDestroyGroup _PrfDestroyGroup

inline PROGCATEGORY APIENTRY _PrfQueryProgramCategory(HINI a, PCSZ b)
{
 PROGCATEGORY yyrc;
 USHORT sel = GetFS();

    yyrc = PrfQueryProgramCategory(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  PrfQueryProgramCategory
#define PrfQueryProgramCategory _PrfQueryProgramCategory

inline ULONG APIENTRY _PrfQueryProgramHandle(HINI a, PCSZ b, PHPROGARRAY c, ULONG d, PULONG e)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = PrfQueryProgramHandle(a, b, c, d, e);
    SetFS(sel);

    return yyrc;
} 

#undef  PrfQueryProgramHandle
#define PrfQueryProgramHandle _PrfQueryProgramHandle

inline ULONG APIENTRY _PrfQueryProgramTitles(HINI a, HPROGRAM b, PPROGTITLE c, ULONG d, PULONG e)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = PrfQueryProgramTitles(a, b, c, d, e);
    SetFS(sel);

    return yyrc;
} 

#undef  PrfQueryProgramTitles
#define PrfQueryProgramTitles _PrfQueryProgramTitles

inline ULONG APIENTRY _PrfQueryDefinition(HINI a, HPROGRAM b, PPROGDETAILS c, ULONG d)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = PrfQueryDefinition(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  PrfQueryDefinition
#define PrfQueryDefinition _PrfQueryDefinition

inline BOOL APIENTRY _PrfRemoveProgram(HINI a, HPROGRAM b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = PrfRemoveProgram(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  PrfRemoveProgram
#define PrfRemoveProgram _PrfRemoveProgram

inline HAPP APIENTRY _WinStartApp(HWND a, PPROGDETAILS b, PCSZ c, PVOID d, ULONG e)
{
 HAPP yyrc;
 USHORT sel = GetFS();

    yyrc = WinStartApp(a, b, c, d, e);
    SetFS(sel);

    return yyrc;
} 

#undef  WinStartApp
#define WinStartApp _WinStartApp

inline BOOL APIENTRY _WinTerminateApp(HAPP a)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinTerminateApp(a);
    SetFS(sel);

    return yyrc;
} 

#undef  WinTerminateApp
#define WinTerminateApp _WinTerminateApp

#endif
#ifdef INCL_WINSWITCHLIST
inline HSWITCH APIENTRY _WinAddSwitchEntry(PSWCNTRL a)
{
 HSWITCH yyrc;
 USHORT sel = GetFS();

    yyrc = WinAddSwitchEntry(a);
    SetFS(sel);

    return yyrc;
} 

#undef  WinAddSwitchEntry
#define WinAddSwitchEntry _WinAddSwitchEntry

inline ULONG APIENTRY _WinRemoveSwitchEntry(HSWITCH a)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = WinRemoveSwitchEntry(a);
    SetFS(sel);

    return yyrc;
} 

#undef  WinRemoveSwitchEntry
#define WinRemoveSwitchEntry _WinRemoveSwitchEntry

inline ULONG APIENTRY _WinChangeSwitchEntry(HSWITCH a, PSWCNTRL b)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = WinChangeSwitchEntry(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  WinChangeSwitchEntry
#define WinChangeSwitchEntry _WinChangeSwitchEntry

inline HSWITCH APIENTRY _WinCreateSwitchEntry(HAB a, PSWCNTRL b)
{
 HSWITCH yyrc;
 USHORT sel = GetFS();

    yyrc = WinCreateSwitchEntry(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  WinCreateSwitchEntry
#define WinCreateSwitchEntry _WinCreateSwitchEntry

inline ULONG APIENTRY _WinQuerySessionTitle(HAB a, ULONG b, PSZ c, ULONG d)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = WinQuerySessionTitle(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  WinQuerySessionTitle
#define WinQuerySessionTitle _WinQuerySessionTitle

inline ULONG APIENTRY _WinQuerySwitchEntry(HSWITCH a, PSWCNTRL b)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = WinQuerySwitchEntry(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  WinQuerySwitchEntry
#define WinQuerySwitchEntry _WinQuerySwitchEntry

inline HSWITCH APIENTRY _WinQuerySwitchHandle(HWND a, PID b)
{
 HSWITCH yyrc;
 USHORT sel = GetFS();

    yyrc = WinQuerySwitchHandle(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  WinQuerySwitchHandle
#define WinQuerySwitchHandle _WinQuerySwitchHandle

inline ULONG APIENTRY _WinQuerySwitchList(HAB a, PSWBLOCK b, ULONG c)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = WinQuerySwitchList(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  WinQuerySwitchList
#define WinQuerySwitchList _WinQuerySwitchList

inline ULONG APIENTRY _WinQueryTaskSizePos(HAB a, ULONG b, PSWP c)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = WinQueryTaskSizePos(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  WinQueryTaskSizePos
#define WinQueryTaskSizePos _WinQueryTaskSizePos

inline ULONG APIENTRY _WinQueryTaskTitle(ULONG a, PSZ b, ULONG c)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = WinQueryTaskTitle(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  WinQueryTaskTitle
#define WinQueryTaskTitle _WinQueryTaskTitle

inline ULONG APIENTRY _WinSwitchToProgram(HSWITCH a)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = WinSwitchToProgram(a);
    SetFS(sel);

    return yyrc;
} 

#undef  WinSwitchToProgram
#define WinSwitchToProgram _WinSwitchToProgram

#endif
#ifdef INCL_WINSHELLDATA
inline BOOL APIENTRY _PrfCloseProfile(HINI a)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = PrfCloseProfile(a);
    SetFS(sel);

    return yyrc;
} 

#undef  PrfCloseProfile
#define PrfCloseProfile _PrfCloseProfile

inline HINI APIENTRY _PrfOpenProfile(HAB a, PCSZ b)
{
 HINI yyrc;
 USHORT sel = GetFS();

    yyrc = PrfOpenProfile(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  PrfOpenProfile
#define PrfOpenProfile _PrfOpenProfile

inline BOOL APIENTRY _PrfQueryProfile(HAB a, PPRFPROFILE b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = PrfQueryProfile(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  PrfQueryProfile
#define PrfQueryProfile _PrfQueryProfile

inline BOOL APIENTRY _PrfQueryProfileData(HINI a, PCSZ b, PCSZ c, PVOID d, PULONG e)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = PrfQueryProfileData(a, b, c, d, e);
    SetFS(sel);

    return yyrc;
} 

#undef  PrfQueryProfileData
#define PrfQueryProfileData _PrfQueryProfileData

inline LONG APIENTRY _PrfQueryProfileInt(HINI a, PCSZ b, PCSZ c, LONG d)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = PrfQueryProfileInt(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  PrfQueryProfileInt
#define PrfQueryProfileInt _PrfQueryProfileInt

inline BOOL APIENTRY _PrfQueryProfileSize(HINI a, PCSZ b, PCSZ c, PULONG d)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = PrfQueryProfileSize(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  PrfQueryProfileSize
#define PrfQueryProfileSize _PrfQueryProfileSize

inline ULONG APIENTRY _PrfQueryProfileString(HINI a, PCSZ b, PCSZ c, PCSZ d, PVOID e, ULONG f)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = PrfQueryProfileString(a, b, c, d, e, f);
    SetFS(sel);

    return yyrc;
} 

#undef  PrfQueryProfileString
#define PrfQueryProfileString _PrfQueryProfileString

inline BOOL APIENTRY _PrfReset(HAB a, PPRFPROFILE b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = PrfReset(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  PrfReset
#define PrfReset _PrfReset

inline BOOL APIENTRY _PrfWriteProfileData(HINI a, PCSZ b, PCSZ c, PVOID d, ULONG e)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = PrfWriteProfileData(a, b, c, d, e);
    SetFS(sel);

    return yyrc;
} 

#undef  PrfWriteProfileData
#define PrfWriteProfileData _PrfWriteProfileData

inline BOOL APIENTRY _PrfWriteProfileString(HINI a, PCSZ b, PCSZ c, PCSZ d)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = PrfWriteProfileString(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  PrfWriteProfileString
#define PrfWriteProfileString _PrfWriteProfileString

#endif
#ifdef INCL_WINSTDFILE
inline MRESULT APIENTRY _WinDefFileDlgProc(HWND a, ULONG b, MPARAM c, MPARAM d)
{
 MRESULT yyrc;
 USHORT sel = GetFS();

    yyrc = WinDefFileDlgProc(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  WinDefFileDlgProc
#define WinDefFileDlgProc _WinDefFileDlgProc

inline HWND APIENTRY _WinFileDlg(HWND a, HWND b, PFILEDLG c)
{
 HWND yyrc;
 USHORT sel = GetFS();

    yyrc = WinFileDlg(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  WinFileDlg
#define WinFileDlg _WinFileDlg

inline BOOL APIENTRY _WinFreeFileDlgList(PAPSZ a)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinFreeFileDlgList(a);
    SetFS(sel);

    return yyrc;
} 

#undef  WinFreeFileDlgList
#define WinFreeFileDlgList _WinFreeFileDlgList

#endif
#ifdef INCL_WINSTDFONT
inline HWND APIENTRY _WinFontDlg(HWND a, HWND b, PFONTDLG c)
{
 HWND yyrc;
 USHORT sel = GetFS();

    yyrc = WinFontDlg(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  WinFontDlg
#define WinFontDlg _WinFontDlg

inline MRESULT APIENTRY _WinDefFontDlgProc(HWND a, ULONG b, MPARAM c, MPARAM d)
{
 MRESULT yyrc;
 USHORT sel = GetFS();

    yyrc = WinDefFontDlgProc(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  WinDefFontDlgProc
#define WinDefFontDlgProc _WinDefFontDlgProc

#endif
#ifdef INCL_WINSTDDRAG
inline BOOL APIENTRY _DrgAcceptDroppedFiles(HWND a, PCSZ b, PCSZ c, ULONG d, ULONG e)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = DrgAcceptDroppedFiles(a, b, c, d, e);
    SetFS(sel);

    return yyrc;
} 

#undef  DrgAcceptDroppedFiles
#define DrgAcceptDroppedFiles _DrgAcceptDroppedFiles

inline BOOL APIENTRY _DrgAccessDraginfo(PDRAGINFO a)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = DrgAccessDraginfo(a);
    SetFS(sel);

    return yyrc;
} 

#undef  DrgAccessDraginfo
#define DrgAccessDraginfo _DrgAccessDraginfo

inline HSTR APIENTRY _DrgAddStrHandle(PCSZ a)
{
 HSTR yyrc;
 USHORT sel = GetFS();

    yyrc = DrgAddStrHandle(a);
    SetFS(sel);

    return yyrc;
} 

#undef  DrgAddStrHandle
#define DrgAddStrHandle _DrgAddStrHandle

inline PDRAGINFO APIENTRY _DrgAllocDraginfo(ULONG a)
{
 PDRAGINFO yyrc;
 USHORT sel = GetFS();

    yyrc = DrgAllocDraginfo(a);
    SetFS(sel);

    return yyrc;
} 

#undef  DrgAllocDraginfo
#define DrgAllocDraginfo _DrgAllocDraginfo

inline PDRAGTRANSFER APIENTRY _DrgAllocDragtransfer(ULONG a)
{
 PDRAGTRANSFER yyrc;
 USHORT sel = GetFS();

    yyrc = DrgAllocDragtransfer(a);
    SetFS(sel);

    return yyrc;
} 

#undef  DrgAllocDragtransfer
#define DrgAllocDragtransfer _DrgAllocDragtransfer

inline BOOL APIENTRY _DrgCancelLazyDrag()
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = DrgCancelLazyDrag();
    SetFS(sel);

    return yyrc;
} 

#undef  DrgCancelLazyDrag
#define DrgCancelLazyDrag _DrgCancelLazyDrag

inline BOOL APIENTRY _DrgDeleteDraginfoStrHandles(PDRAGINFO a)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = DrgDeleteDraginfoStrHandles(a);
    SetFS(sel);

    return yyrc;
} 

#undef  DrgDeleteDraginfoStrHandles
#define DrgDeleteDraginfoStrHandles _DrgDeleteDraginfoStrHandles

inline BOOL APIENTRY _DrgDeleteStrHandle(HSTR a)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = DrgDeleteStrHandle(a);
    SetFS(sel);

    return yyrc;
} 

#undef  DrgDeleteStrHandle
#define DrgDeleteStrHandle _DrgDeleteStrHandle

inline HWND APIENTRY _DrgDrag(HWND a, PDRAGINFO b, PDRAGIMAGE c, ULONG d, LONG e, PVOID f)
{
 HWND yyrc;
 USHORT sel = GetFS();

    yyrc = DrgDrag(a, b, c, d, e, f);
    SetFS(sel);

    return yyrc;
} 

#undef  DrgDrag
#define DrgDrag _DrgDrag

inline BOOL APIENTRY _DrgDragFiles(HWND a, PCSZ *b, PCSZ *c, PCSZ *d, ULONG e, HPOINTER f, ULONG g, BOOL h, ULONG i)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = DrgDragFiles(a, b, c, d, e, f, g, h, i);
    SetFS(sel);

    return yyrc;
} 

#undef  DrgDragFiles
#define DrgDragFiles _DrgDragFiles

inline BOOL APIENTRY _DrgFreeDraginfo(PDRAGINFO a)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = DrgFreeDraginfo(a);
    SetFS(sel);

    return yyrc;
} 

#undef  DrgFreeDraginfo
#define DrgFreeDraginfo _DrgFreeDraginfo

inline BOOL APIENTRY _DrgFreeDragtransfer(PDRAGTRANSFER a)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = DrgFreeDragtransfer(a);
    SetFS(sel);

    return yyrc;
} 

#undef  DrgFreeDragtransfer
#define DrgFreeDragtransfer _DrgFreeDragtransfer

inline HPS APIENTRY _DrgGetPS(HWND a)
{
 HPS yyrc;
 USHORT sel = GetFS();

    yyrc = DrgGetPS(a);
    SetFS(sel);

    return yyrc;
} 

#undef  DrgGetPS
#define DrgGetPS _DrgGetPS

inline BOOL APIENTRY _DrgLazyDrag(HWND a, PDRAGINFO b, PDRAGIMAGE c, ULONG d, PVOID e)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = DrgLazyDrag(a, b, c, d, e);
    SetFS(sel);

    return yyrc;
} 

#undef  DrgLazyDrag
#define DrgLazyDrag _DrgLazyDrag

inline BOOL APIENTRY _DrgLazyDrop(HWND a, ULONG b, PPOINTL c)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = DrgLazyDrop(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  DrgLazyDrop
#define DrgLazyDrop _DrgLazyDrop

inline BOOL APIENTRY _DrgPostTransferMsg(HWND a, ULONG b, PDRAGTRANSFER c, ULONG d, ULONG e, BOOL f)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = DrgPostTransferMsg(a, b, c, d, e, f);
    SetFS(sel);

    return yyrc;
} 

#undef  DrgPostTransferMsg
#define DrgPostTransferMsg _DrgPostTransferMsg

inline BOOL APIENTRY _DrgPushDraginfo(PDRAGINFO a, HWND b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = DrgPushDraginfo(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  DrgPushDraginfo
#define DrgPushDraginfo _DrgPushDraginfo

inline PDRAGINFO APIENTRY _DrgQueryDraginfoPtr(PDRAGINFO a)
{
 PDRAGINFO yyrc;
 USHORT sel = GetFS();

    yyrc = DrgQueryDraginfoPtr(a);
    SetFS(sel);

    return yyrc;
} 

#undef  DrgQueryDraginfoPtr
#define DrgQueryDraginfoPtr _DrgQueryDraginfoPtr

inline PDRAGINFO APIENTRY _DrgQueryDraginfoPtrFromHwnd(HWND a)
{
 PDRAGINFO yyrc;
 USHORT sel = GetFS();

    yyrc = DrgQueryDraginfoPtrFromHwnd(a);
    SetFS(sel);

    return yyrc;
} 

#undef  DrgQueryDraginfoPtrFromHwnd
#define DrgQueryDraginfoPtrFromHwnd _DrgQueryDraginfoPtrFromHwnd

inline PDRAGINFO APIENTRY _DrgQueryDraginfoPtrFromDragitem(PDRAGITEM a)
{
 PDRAGINFO yyrc;
 USHORT sel = GetFS();

    yyrc = DrgQueryDraginfoPtrFromDragitem(a);
    SetFS(sel);

    return yyrc;
} 

#undef  DrgQueryDraginfoPtrFromDragitem
#define DrgQueryDraginfoPtrFromDragitem _DrgQueryDraginfoPtrFromDragitem

inline BOOL APIENTRY _DrgQueryDragitem(PDRAGINFO a, ULONG b, PDRAGITEM c, ULONG d)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = DrgQueryDragitem(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  DrgQueryDragitem
#define DrgQueryDragitem _DrgQueryDragitem

inline ULONG APIENTRY _DrgQueryDragitemCount(PDRAGINFO a)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DrgQueryDragitemCount(a);
    SetFS(sel);

    return yyrc;
} 

#undef  DrgQueryDragitemCount
#define DrgQueryDragitemCount _DrgQueryDragitemCount

inline PDRAGITEM APIENTRY _DrgQueryDragitemPtr(PDRAGINFO a, ULONG b)
{
 PDRAGITEM yyrc;
 USHORT sel = GetFS();

    yyrc = DrgQueryDragitemPtr(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  DrgQueryDragitemPtr
#define DrgQueryDragitemPtr _DrgQueryDragitemPtr

inline ULONG APIENTRY _DrgQueryDragStatus()
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DrgQueryDragStatus();
    SetFS(sel);

    return yyrc;
} 

#undef  DrgQueryDragStatus
#define DrgQueryDragStatus _DrgQueryDragStatus

inline BOOL APIENTRY _DrgQueryNativeRMF(PDRAGITEM a, ULONG b, PCHAR c)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = DrgQueryNativeRMF(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  DrgQueryNativeRMF
#define DrgQueryNativeRMF _DrgQueryNativeRMF

inline ULONG APIENTRY _DrgQueryNativeRMFLen(PDRAGITEM a)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DrgQueryNativeRMFLen(a);
    SetFS(sel);

    return yyrc;
} 

#undef  DrgQueryNativeRMFLen
#define DrgQueryNativeRMFLen _DrgQueryNativeRMFLen

inline ULONG APIENTRY _DrgQueryStrName(HSTR a, ULONG b, PSZ c)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DrgQueryStrName(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  DrgQueryStrName
#define DrgQueryStrName _DrgQueryStrName

inline ULONG APIENTRY _DrgQueryStrNameLen(HSTR a)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DrgQueryStrNameLen(a);
    SetFS(sel);

    return yyrc;
} 

#undef  DrgQueryStrNameLen
#define DrgQueryStrNameLen _DrgQueryStrNameLen

inline BOOL APIENTRY _DrgQueryTrueType(PDRAGITEM a, ULONG b, PSZ c)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = DrgQueryTrueType(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  DrgQueryTrueType
#define DrgQueryTrueType _DrgQueryTrueType

inline ULONG APIENTRY _DrgQueryTrueTypeLen(PDRAGITEM a)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = DrgQueryTrueTypeLen(a);
    SetFS(sel);

    return yyrc;
} 

#undef  DrgQueryTrueTypeLen
#define DrgQueryTrueTypeLen _DrgQueryTrueTypeLen

inline PDRAGINFO APIENTRY _DrgReallocDraginfo(PDRAGINFO a, ULONG b)
{
 PDRAGINFO yyrc;
 USHORT sel = GetFS();

    yyrc = DrgReallocDraginfo(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  DrgReallocDraginfo
#define DrgReallocDraginfo _DrgReallocDraginfo

inline BOOL APIENTRY _DrgReleasePS(HPS a)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = DrgReleasePS(a);
    SetFS(sel);

    return yyrc;
} 

#undef  DrgReleasePS
#define DrgReleasePS _DrgReleasePS

inline MRESULT APIENTRY _DrgSendTransferMsg(HWND a, ULONG b, MPARAM c, MPARAM d)
{
 MRESULT yyrc;
 USHORT sel = GetFS();

    yyrc = DrgSendTransferMsg(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  DrgSendTransferMsg
#define DrgSendTransferMsg _DrgSendTransferMsg

inline BOOL APIENTRY _DrgSetDragImage(PDRAGINFO a, PDRAGIMAGE b, ULONG c, PVOID d)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = DrgSetDragImage(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  DrgSetDragImage
#define DrgSetDragImage _DrgSetDragImage

inline BOOL APIENTRY _DrgSetDragitem(PDRAGINFO a, PDRAGITEM b, ULONG c, ULONG d)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = DrgSetDragitem(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  DrgSetDragitem
#define DrgSetDragitem _DrgSetDragitem

inline BOOL APIENTRY _DrgSetDragPointer(PDRAGINFO a, HPOINTER b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = DrgSetDragPointer(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  DrgSetDragPointer
#define DrgSetDragPointer _DrgSetDragPointer

inline BOOL APIENTRY _DrgVerifyNativeRMF(PDRAGITEM a, PCSZ b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = DrgVerifyNativeRMF(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  DrgVerifyNativeRMF
#define DrgVerifyNativeRMF _DrgVerifyNativeRMF

inline BOOL APIENTRY _DrgVerifyRMF(PDRAGITEM a, PCSZ b, PCSZ c)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = DrgVerifyRMF(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  DrgVerifyRMF
#define DrgVerifyRMF _DrgVerifyRMF

inline BOOL APIENTRY _DrgVerifyTrueType(PDRAGITEM a, PCSZ b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = DrgVerifyTrueType(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  DrgVerifyTrueType
#define DrgVerifyTrueType _DrgVerifyTrueType

inline BOOL APIENTRY _DrgVerifyType(PDRAGITEM a, PCSZ b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = DrgVerifyType(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  DrgVerifyType
#define DrgVerifyType _DrgVerifyType

inline BOOL APIENTRY _DrgVerifyTypeSet(PDRAGITEM a, PCSZ b, ULONG c, PSZ d)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = DrgVerifyTypeSet(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  DrgVerifyTypeSet
#define DrgVerifyTypeSet _DrgVerifyTypeSet

#endif
#ifdef INCL_WPCLASS
inline HOBJECT APIENTRY _WinCopyObject(HOBJECT a, HOBJECT b, ULONG c)
{
 HOBJECT yyrc;
 USHORT sel = GetFS();

    yyrc = WinCopyObject(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  WinCopyObject
#define WinCopyObject _WinCopyObject

inline HOBJECT APIENTRY _WinCreateObject(PCSZ a, PCSZ b, PCSZ c, PCSZ d, ULONG e)
{
 HOBJECT yyrc;
 USHORT sel = GetFS();

    yyrc = WinCreateObject(a, b, c, d, e);
    SetFS(sel);

    return yyrc;
} 

#undef  WinCreateObject
#define WinCreateObject _WinCreateObject

inline HOBJECT APIENTRY _WinCreateShadow(HOBJECT a, HOBJECT b, ULONG c)
{
 HOBJECT yyrc;
 USHORT sel = GetFS();

    yyrc = WinCreateShadow(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  WinCreateShadow
#define WinCreateShadow _WinCreateShadow

inline BOOL APIENTRY _WinDeregisterObjectClass(PCSZ a)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinDeregisterObjectClass(a);
    SetFS(sel);

    return yyrc;
} 

#undef  WinDeregisterObjectClass
#define WinDeregisterObjectClass _WinDeregisterObjectClass

inline BOOL APIENTRY _WinDestroyObject(HOBJECT a)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinDestroyObject(a);
    SetFS(sel);

    return yyrc;
} 

#undef  WinDestroyObject
#define WinDestroyObject _WinDestroyObject

inline BOOL APIENTRY _WinEnumObjectClasses(POBJCLASS a, PULONG b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinEnumObjectClasses(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  WinEnumObjectClasses
#define WinEnumObjectClasses _WinEnumObjectClasses

inline BOOL APIENTRY _WinIsSOMDDReady()
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinIsSOMDDReady();
    SetFS(sel);

    return yyrc;
} 

#undef  WinIsSOMDDReady
#define WinIsSOMDDReady _WinIsSOMDDReady

inline BOOL APIENTRY _WinIsWPDServerReady()
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinIsWPDServerReady();
    SetFS(sel);

    return yyrc;
} 

#undef  WinIsWPDServerReady
#define WinIsWPDServerReady _WinIsWPDServerReady

inline HOBJECT APIENTRY _WinMoveObject(HOBJECT a, HOBJECT b, ULONG c)
{
 HOBJECT yyrc;
 USHORT sel = GetFS();

    yyrc = WinMoveObject(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  WinMoveObject
#define WinMoveObject _WinMoveObject

inline BOOL APIENTRY _WinOpenObject(HOBJECT a, ULONG b, BOOL c)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinOpenObject(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  WinOpenObject
#define WinOpenObject _WinOpenObject

inline BOOL APIENTRY _WinQueryActiveDesktopPathname(PSZ a, ULONG b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinQueryActiveDesktopPathname(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  WinQueryActiveDesktopPathname
#define WinQueryActiveDesktopPathname _WinQueryActiveDesktopPathname

inline HOBJECT APIENTRY _WinQueryObject(PCSZ a)
{
 HOBJECT yyrc;
 USHORT sel = GetFS();

    yyrc = WinQueryObject(a);
    SetFS(sel);

    return yyrc;
} 

#undef  WinQueryObject
#define WinQueryObject _WinQueryObject

inline BOOL APIENTRY _WinQueryObjectPath(HOBJECT a, PSZ b, ULONG c)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinQueryObjectPath(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  WinQueryObjectPath
#define WinQueryObjectPath _WinQueryObjectPath

inline BOOL APIENTRY _WinRegisterObjectClass(PCSZ a, PCSZ b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinRegisterObjectClass(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  WinRegisterObjectClass
#define WinRegisterObjectClass _WinRegisterObjectClass

inline BOOL APIENTRY _WinReplaceObjectClass(PCSZ a, PCSZ b, BOOL c)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinReplaceObjectClass(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  WinReplaceObjectClass
#define WinReplaceObjectClass _WinReplaceObjectClass

inline ULONG APIENTRY _WinRestartSOMDD(BOOL a)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = WinRestartSOMDD(a);
    SetFS(sel);

    return yyrc;
} 

#undef  WinRestartSOMDD
#define WinRestartSOMDD _WinRestartSOMDD

inline ULONG APIENTRY _WinRestartWPDServer(BOOL a)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = WinRestartWPDServer(a);
    SetFS(sel);

    return yyrc;
} 

#undef  WinRestartWPDServer
#define WinRestartWPDServer _WinRestartWPDServer

inline BOOL APIENTRY _WinSaveObject(HOBJECT a, BOOL b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinSaveObject(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  WinSaveObject
#define WinSaveObject _WinSaveObject

inline BOOL APIENTRY _WinSetObjectData(HOBJECT a, PCSZ b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinSetObjectData(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  WinSetObjectData
#define WinSetObjectData _WinSetObjectData

inline BOOL APIENTRY _WinFreeFileIcon(HPOINTER a)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinFreeFileIcon(a);
    SetFS(sel);

    return yyrc;
} 

#undef  WinFreeFileIcon
#define WinFreeFileIcon _WinFreeFileIcon

inline HPOINTER APIENTRY _WinLoadFileIcon(PCSZ a, BOOL b)
{
 HPOINTER yyrc;
 USHORT sel = GetFS();

    yyrc = WinLoadFileIcon(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  WinLoadFileIcon
#define WinLoadFileIcon _WinLoadFileIcon

inline BOOL APIENTRY _WinRestoreWindowPos(PCSZ a, PCSZ b, HWND c)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinRestoreWindowPos(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  WinRestoreWindowPos
#define WinRestoreWindowPos _WinRestoreWindowPos

inline BOOL APIENTRY _WinSetFileIcon(PCSZ a, PICONINFO b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinSetFileIcon(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  WinSetFileIcon
#define WinSetFileIcon _WinSetFileIcon

inline BOOL APIENTRY _WinShutdownSystem(HAB a, HMQ b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinShutdownSystem(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  WinShutdownSystem
#define WinShutdownSystem _WinShutdownSystem

inline BOOL APIENTRY _WinStoreWindowPos(PCSZ a, PCSZ b, HWND c)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinStoreWindowPos(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  WinStoreWindowPos
#define WinStoreWindowPos _WinStoreWindowPos

#endif
#ifdef INCL_SPL
inline BOOL APIENTRY _SplStdClose(HDC a)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = SplStdClose(a);
    SetFS(sel);

    return yyrc;
} 

#undef  SplStdClose
#define SplStdClose _SplStdClose

inline BOOL APIENTRY _SplStdDelete(HSTD a)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = SplStdDelete(a);
    SetFS(sel);

    return yyrc;
} 

#undef  SplStdDelete
#define SplStdDelete _SplStdDelete

inline BOOL APIENTRY _SplStdGetBits(HSTD a, LONG b, LONG c, PCH d)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = SplStdGetBits(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  SplStdGetBits
#define SplStdGetBits _SplStdGetBits

inline BOOL APIENTRY _SplStdOpen(HDC a)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = SplStdOpen(a);
    SetFS(sel);

    return yyrc;
} 

#undef  SplStdOpen
#define SplStdOpen _SplStdOpen

inline LONG APIENTRY _SplStdQueryLength(HSTD a)
{
 LONG yyrc;
 USHORT sel = GetFS();

    yyrc = SplStdQueryLength(a);
    SetFS(sel);

    return yyrc;
} 

#undef  SplStdQueryLength
#define SplStdQueryLength _SplStdQueryLength

inline BOOL APIENTRY _SplStdStart(HDC a)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = SplStdStart(a);
    SetFS(sel);

    return yyrc;
} 

#undef  SplStdStart
#define SplStdStart _SplStdStart

inline HSTD APIENTRY _SplStdStop(HDC a)
{
 HSTD yyrc;
 USHORT sel = GetFS();

    yyrc = SplStdStop(a);
    SetFS(sel);

    return yyrc;
} 

#undef  SplStdStop
#define SplStdStop _SplStdStop

inline SPLERR APIENTRY _SplControlDevice(PSZ a, PSZ b, ULONG c)
{
 SPLERR yyrc;
 USHORT sel = GetFS();

    yyrc = SplControlDevice(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  SplControlDevice
#define SplControlDevice _SplControlDevice

inline SPLERR APIENTRY _SplCopyJob(PCSZ a, PCSZ b, ULONG c, PCSZ d, PCSZ e, PULONG f)
{
 SPLERR yyrc;
 USHORT sel = GetFS();

    yyrc = SplCopyJob(a, b, c, d, e, f);
    SetFS(sel);

    return yyrc;
} 

#undef  SplCopyJob
#define SplCopyJob _SplCopyJob

inline SPLERR APIENTRY _SplCreateDevice(PSZ a, ULONG b, PVOID c, ULONG d)
{
 SPLERR yyrc;
 USHORT sel = GetFS();

    yyrc = SplCreateDevice(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  SplCreateDevice
#define SplCreateDevice _SplCreateDevice

inline SPLERR APIENTRY _SplCreatePort(PCSZ a, PCSZ b, PCSZ c, ULONG d, PVOID e, ULONG f)
{
 SPLERR yyrc;
 USHORT sel = GetFS();

    yyrc = SplCreatePort(a, b, c, d, e, f);
    SetFS(sel);

    return yyrc;
} 

#undef  SplCreatePort
#define SplCreatePort _SplCreatePort

inline SPLERR APIENTRY _SplCreateQueue(PSZ a, ULONG b, PVOID c, ULONG d)
{
 SPLERR yyrc;
 USHORT sel = GetFS();

    yyrc = SplCreateQueue(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  SplCreateQueue
#define SplCreateQueue _SplCreateQueue

inline SPLERR APIENTRY _SplDeleteDevice(PSZ a, PSZ b)
{
 SPLERR yyrc;
 USHORT sel = GetFS();

    yyrc = SplDeleteDevice(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  SplDeleteDevice
#define SplDeleteDevice _SplDeleteDevice

inline SPLERR APIENTRY _SplDeleteJob(PSZ a, PSZ b, ULONG c)
{
 SPLERR yyrc;
 USHORT sel = GetFS();

    yyrc = SplDeleteJob(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  SplDeleteJob
#define SplDeleteJob _SplDeleteJob

inline SPLERR APIENTRY _SplDeletePort(PCSZ a, PCSZ b)
{
 SPLERR yyrc;
 USHORT sel = GetFS();

    yyrc = SplDeletePort(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  SplDeletePort
#define SplDeletePort _SplDeletePort

inline SPLERR APIENTRY _SplDeleteQueue(PSZ a, PSZ b)
{
 SPLERR yyrc;
 USHORT sel = GetFS();

    yyrc = SplDeleteQueue(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  SplDeleteQueue
#define SplDeleteQueue _SplDeleteQueue

inline SPLERR APIENTRY _SplEnumDevice(PSZ a, ULONG b, PVOID c, ULONG d, PULONG e, PULONG f, PULONG g, PVOID h)
{
 SPLERR yyrc;
 USHORT sel = GetFS();

    yyrc = SplEnumDevice(a, b, c, d, e, f, g, h);
    SetFS(sel);

    return yyrc;
} 

#undef  SplEnumDevice
#define SplEnumDevice _SplEnumDevice

inline SPLERR APIENTRY _SplEnumDriver(PSZ a, ULONG b, PVOID c, ULONG d, PULONG e, PULONG f, PULONG g, PVOID h)
{
 SPLERR yyrc;
 USHORT sel = GetFS();

    yyrc = SplEnumDriver(a, b, c, d, e, f, g, h);
    SetFS(sel);

    return yyrc;
} 

#undef  SplEnumDriver
#define SplEnumDriver _SplEnumDriver

inline SPLERR APIENTRY _SplEnumJob(PSZ a, PSZ b, ULONG c, PVOID d, ULONG e, PULONG f, PULONG g, PULONG h, PVOID i)
{
 SPLERR yyrc;
 USHORT sel = GetFS();

    yyrc = SplEnumJob(a, b, c, d, e, f, g, h, i);
    SetFS(sel);

    return yyrc;
} 

#undef  SplEnumJob
#define SplEnumJob _SplEnumJob

inline SPLERR APIENTRY _SplEnumPort(PCSZ a, ULONG b, PVOID c, ULONG d, PULONG e, PULONG f, PULONG g, PVOID h)
{
 SPLERR yyrc;
 USHORT sel = GetFS();

    yyrc = SplEnumPort(a, b, c, d, e, f, g, h);
    SetFS(sel);

    return yyrc;
} 

#undef  SplEnumPort
#define SplEnumPort _SplEnumPort

inline SPLERR APIENTRY _SplEnumPrinter(PSZ a, ULONG b, ULONG c, PVOID d, ULONG e, PULONG f, PULONG g, PULONG h, PVOID i)
{
 SPLERR yyrc;
 USHORT sel = GetFS();

    yyrc = SplEnumPrinter(a, b, c, d, e, f, g, h, i);
    SetFS(sel);

    return yyrc;
} 

#undef  SplEnumPrinter
#define SplEnumPrinter _SplEnumPrinter

inline SPLERR APIENTRY _SplEnumQueue(PSZ a, ULONG b, PVOID c, ULONG d, PULONG e, PULONG f, PULONG g, PVOID h)
{
 SPLERR yyrc;
 USHORT sel = GetFS();

    yyrc = SplEnumQueue(a, b, c, d, e, f, g, h);
    SetFS(sel);

    return yyrc;
} 

#undef  SplEnumQueue
#define SplEnumQueue _SplEnumQueue

inline SPLERR APIENTRY _SplEnumQueueProcessor(PSZ a, ULONG b, PVOID c, ULONG d, PULONG e, PULONG f, PULONG g, PVOID h)
{
 SPLERR yyrc;
 USHORT sel = GetFS();

    yyrc = SplEnumQueueProcessor(a, b, c, d, e, f, g, h);
    SetFS(sel);

    return yyrc;
} 

#undef  SplEnumQueueProcessor
#define SplEnumQueueProcessor _SplEnumQueueProcessor

inline SPLERR APIENTRY _SplHoldJob(PCSZ a, PCSZ b, ULONG c)
{
 SPLERR yyrc;
 USHORT sel = GetFS();

    yyrc = SplHoldJob(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  SplHoldJob
#define SplHoldJob _SplHoldJob

inline SPLERR APIENTRY _SplHoldQueue(PSZ a, PSZ b)
{
 SPLERR yyrc;
 USHORT sel = GetFS();

    yyrc = SplHoldQueue(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  SplHoldQueue
#define SplHoldQueue _SplHoldQueue

inline SPLERR APIENTRY _SplPurgeQueue(PSZ a, PSZ b)
{
 SPLERR yyrc;
 USHORT sel = GetFS();

    yyrc = SplPurgeQueue(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  SplPurgeQueue
#define SplPurgeQueue _SplPurgeQueue

inline SPLERR APIENTRY _SplQueryDevice(PSZ a, PSZ b, ULONG c, PVOID d, ULONG e, PULONG f)
{
 SPLERR yyrc;
 USHORT sel = GetFS();

    yyrc = SplQueryDevice(a, b, c, d, e, f);
    SetFS(sel);

    return yyrc;
} 

#undef  SplQueryDevice
#define SplQueryDevice _SplQueryDevice

inline SPLERR APIENTRY _SplQueryDriver(PCSZ a, PCSZ b, PCSZ c, ULONG d, PVOID e, ULONG f, PULONG g)
{
 SPLERR yyrc;
 USHORT sel = GetFS();

    yyrc = SplQueryDriver(a, b, c, d, e, f, g);
    SetFS(sel);

    return yyrc;
} 

#undef  SplQueryDriver
#define SplQueryDriver _SplQueryDriver

inline SPLERR APIENTRY _SplQueryJob(PSZ a, PSZ b, ULONG c, ULONG d, PVOID e, ULONG f, PULONG g)
{
 SPLERR yyrc;
 USHORT sel = GetFS();

    yyrc = SplQueryJob(a, b, c, d, e, f, g);
    SetFS(sel);

    return yyrc;
} 

#undef  SplQueryJob
#define SplQueryJob _SplQueryJob

inline SPLERR APIENTRY _SplQueryPort(PCSZ a, PCSZ b, ULONG c, PVOID d, ULONG e, PULONG f)
{
 SPLERR yyrc;
 USHORT sel = GetFS();

    yyrc = SplQueryPort(a, b, c, d, e, f);
    SetFS(sel);

    return yyrc;
} 

#undef  SplQueryPort
#define SplQueryPort _SplQueryPort

inline SPLERR APIENTRY _SplQueryQueue(PSZ a, PSZ b, ULONG c, PVOID d, ULONG e, PULONG f)
{
 SPLERR yyrc;
 USHORT sel = GetFS();

    yyrc = SplQueryQueue(a, b, c, d, e, f);
    SetFS(sel);

    return yyrc;
} 

#undef  SplQueryQueue
#define SplQueryQueue _SplQueryQueue

inline SPLERR APIENTRY _SplReleaseJob(PCSZ a, PCSZ b, ULONG c)
{
 SPLERR yyrc;
 USHORT sel = GetFS();

    yyrc = SplReleaseJob(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  SplReleaseJob
#define SplReleaseJob _SplReleaseJob

inline SPLERR APIENTRY _SplReleaseQueue(PSZ a, PSZ b)
{
 SPLERR yyrc;
 USHORT sel = GetFS();

    yyrc = SplReleaseQueue(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  SplReleaseQueue
#define SplReleaseQueue _SplReleaseQueue

inline SPLERR APIENTRY _SplSetDevice(PSZ a, PSZ b, ULONG c, PVOID d, ULONG e, ULONG f)
{
 SPLERR yyrc;
 USHORT sel = GetFS();

    yyrc = SplSetDevice(a, b, c, d, e, f);
    SetFS(sel);

    return yyrc;
} 

#undef  SplSetDevice
#define SplSetDevice _SplSetDevice

inline SPLERR APIENTRY _SplSetDriver(PCSZ a, PCSZ b, PCSZ c, ULONG d, PVOID e, ULONG f, ULONG g)
{
 SPLERR yyrc;
 USHORT sel = GetFS();

    yyrc = SplSetDriver(a, b, c, d, e, f, g);
    SetFS(sel);

    return yyrc;
} 

#undef  SplSetDriver
#define SplSetDriver _SplSetDriver

inline SPLERR APIENTRY _SplSetJob(PSZ a, PSZ b, ULONG c, ULONG d, PVOID e, ULONG f, ULONG g)
{
 SPLERR yyrc;
 USHORT sel = GetFS();

    yyrc = SplSetJob(a, b, c, d, e, f, g);
    SetFS(sel);

    return yyrc;
} 

#undef  SplSetJob
#define SplSetJob _SplSetJob

inline SPLERR APIENTRY _SplSetPort(PCSZ a, PCSZ b, ULONG c, PVOID d, ULONG e, ULONG f)
{
 SPLERR yyrc;
 USHORT sel = GetFS();

    yyrc = SplSetPort(a, b, c, d, e, f);
    SetFS(sel);

    return yyrc;
} 

#undef  SplSetPort
#define SplSetPort _SplSetPort

inline SPLERR APIENTRY _SplSetQueue(PSZ a, PSZ b, ULONG c, PVOID d, ULONG e, ULONG f)
{
 SPLERR yyrc;
 USHORT sel = GetFS();

    yyrc = SplSetQueue(a, b, c, d, e, f);
    SetFS(sel);

    return yyrc;
} 

#undef  SplSetQueue
#define SplSetQueue _SplSetQueue

inline ULONG APIENTRY _SplMessageBox(PSZ a, ULONG b, ULONG c, PSZ d, PSZ e, ULONG f, ULONG g)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = SplMessageBox(a, b, c, d, e, f, g);
    SetFS(sel);

    return yyrc;
} 

#undef  SplMessageBox
#define SplMessageBox _SplMessageBox

inline BOOL APIENTRY _SplQmAbort(HSPL a)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = SplQmAbort(a);
    SetFS(sel);

    return yyrc;
} 

#undef  SplQmAbort
#define SplQmAbort _SplQmAbort

inline BOOL APIENTRY _SplQmAbortDoc(HSPL a)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = SplQmAbortDoc(a);
    SetFS(sel);

    return yyrc;
} 

#undef  SplQmAbortDoc
#define SplQmAbortDoc _SplQmAbortDoc

inline BOOL APIENTRY _SplQmClose(HSPL a)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = SplQmClose(a);
    SetFS(sel);

    return yyrc;
} 

#undef  SplQmClose
#define SplQmClose _SplQmClose

inline BOOL APIENTRY _SplQmEndDoc(HSPL a)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = SplQmEndDoc(a);
    SetFS(sel);

    return yyrc;
} 

#undef  SplQmEndDoc
#define SplQmEndDoc _SplQmEndDoc

inline ULONG APIENTRY _SplQmGetJobID(HSPL a, ULONG b, PVOID c, ULONG d, PULONG e)
{
 ULONG yyrc;
 USHORT sel = GetFS();

    yyrc = SplQmGetJobID(a, b, c, d, e);
    SetFS(sel);

    return yyrc;
} 

#undef  SplQmGetJobID
#define SplQmGetJobID _SplQmGetJobID

inline BOOL APIENTRY _SplQmNewPage(HSPL a, ULONG b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = SplQmNewPage(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  SplQmNewPage
#define SplQmNewPage _SplQmNewPage

inline HSPL APIENTRY _SplQmOpen(PSZ a, LONG b, PQMOPENDATA c)
{
 HSPL yyrc;
 USHORT sel = GetFS();

    yyrc = SplQmOpen(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  SplQmOpen
#define SplQmOpen _SplQmOpen

inline BOOL APIENTRY _SplQmStartDoc(HSPL a, PSZ b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = SplQmStartDoc(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  SplQmStartDoc
#define SplQmStartDoc _SplQmStartDoc

inline BOOL APIENTRY _SplQmWrite(HSPL a, LONG b, PVOID c)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = SplQmWrite(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  SplQmWrite
#define SplQmWrite _SplQmWrite

#endif
#ifdef INCL_WINHELP
inline BOOL APIENTRY _WinAssociateHelpInstance(HWND a, HWND b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinAssociateHelpInstance(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  WinAssociateHelpInstance
#define WinAssociateHelpInstance _WinAssociateHelpInstance

inline HWND APIENTRY _WinCreateHelpInstance(HAB a, PHELPINIT b)
{
 HWND yyrc;
 USHORT sel = GetFS();

    yyrc = WinCreateHelpInstance(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  WinCreateHelpInstance
#define WinCreateHelpInstance _WinCreateHelpInstance

inline BOOL APIENTRY _WinCreateHelpTable(HWND a, PHELPTABLE b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinCreateHelpTable(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  WinCreateHelpTable
#define WinCreateHelpTable _WinCreateHelpTable

inline BOOL APIENTRY _WinDestroyHelpInstance(HWND a)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinDestroyHelpInstance(a);
    SetFS(sel);

    return yyrc;
} 

#undef  WinDestroyHelpInstance
#define WinDestroyHelpInstance _WinDestroyHelpInstance

inline BOOL APIENTRY _WinLoadHelpTable(HWND a, ULONG b, HMODULE c)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = WinLoadHelpTable(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  WinLoadHelpTable
#define WinLoadHelpTable _WinLoadHelpTable

inline HWND APIENTRY _WinQueryHelpInstance(HWND a)
{
 HWND yyrc;
 USHORT sel = GetFS();

    yyrc = WinQueryHelpInstance(a);
    SetFS(sel);

    return yyrc;
} 

#undef  WinQueryHelpInstance
#define WinQueryHelpInstance _WinQueryHelpInstance

#endif
#ifdef INCL_DDF
inline BOOL APIENTRY _DdfBeginList(HDDF a, ULONG b, ULONG c, ULONG d)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = DdfBeginList(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  DdfBeginList
#define DdfBeginList _DdfBeginList

inline BOOL APIENTRY _DdfBitmap(HDDF a, HBITMAP b, ULONG c)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = DdfBitmap(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  DdfBitmap
#define DdfBitmap _DdfBitmap

inline BOOL APIENTRY _DdfEndList(HDDF a)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = DdfEndList(a);
    SetFS(sel);

    return yyrc;
} 

#undef  DdfEndList
#define DdfEndList _DdfEndList

inline BOOL APIENTRY _DdfHyperText(HDDF a, PCSZ b, PCSZ c, ULONG d)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = DdfHyperText(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  DdfHyperText
#define DdfHyperText _DdfHyperText

inline BOOL APIENTRY _DdfInform(HDDF a, PCSZ b, ULONG c)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = DdfInform(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  DdfInform
#define DdfInform _DdfInform

inline HDDF APIENTRY _DdfInitialize(HWND a, ULONG b, ULONG c)
{
 HDDF yyrc;
 USHORT sel = GetFS();

    yyrc = DdfInitialize(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  DdfInitialize
#define DdfInitialize _DdfInitialize

inline BOOL APIENTRY _DdfListItem(HDDF a, PCSZ b, PCSZ c)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = DdfListItem(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  DdfListItem
#define DdfListItem _DdfListItem

inline BOOL APIENTRY _DdfMetafile(HDDF a, HMF b, PRECTL c)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = DdfMetafile(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  DdfMetafile
#define DdfMetafile _DdfMetafile

inline BOOL APIENTRY _DdfPara(HDDF a)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = DdfPara(a);
    SetFS(sel);

    return yyrc;
} 

#undef  DdfPara
#define DdfPara _DdfPara

inline BOOL APIENTRY _DdfSetColor(HDDF a, COLOR b, COLOR c)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = DdfSetColor(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  DdfSetColor
#define DdfSetColor _DdfSetColor

inline BOOL APIENTRY _DdfSetFont(HDDF a, PCSZ b, ULONG c, ULONG d)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = DdfSetFont(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  DdfSetFont
#define DdfSetFont _DdfSetFont

inline BOOL APIENTRY _DdfSetFontStyle(HDDF a, ULONG b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = DdfSetFontStyle(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  DdfSetFontStyle
#define DdfSetFontStyle _DdfSetFontStyle

inline BOOL APIENTRY _DdfSetFormat(HDDF a, ULONG b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = DdfSetFormat(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  DdfSetFormat
#define DdfSetFormat _DdfSetFormat

inline BOOL APIENTRY _DdfSetTextAlign(HDDF a, ULONG b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = DdfSetTextAlign(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  DdfSetTextAlign
#define DdfSetTextAlign _DdfSetTextAlign

inline BOOL APIENTRY _DdfText(HDDF a, PCSZ b)
{
 BOOL yyrc;
 USHORT sel = GetFS();

    yyrc = DdfText(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  DdfText
#define DdfText _DdfText

#endif
#ifdef INCL_AVIO
inline USHORT APIENTRY _VioAssociate(HDC a, HVPS b)
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = VIO16ASSOCIATE(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  VioAssociate
#define VioAssociate _VioAssociate

inline USHORT APIENTRY16 _VioCreateLogFont(PFATTRS a, LONG b, PSTR8 c, HVPS d)
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = VIO16CREATELOGFONT(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  VioCreateLogFont
#define VioCreateLogFont _VioCreateLogFont

inline USHORT APIENTRY16 _VioCreatePS(PHVPS a, SHORT b, SHORT c, SHORT d, SHORT e, HVPS f)
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = VIO16CREATEPS(a, b, c, d, e, f);
    SetFS(sel);

    return yyrc;
} 

#undef  VioCreatePS
#define VioCreatePS _VioCreatePS

inline USHORT APIENTRY16 _VioDeleteSetId(LONG a, HVPS b)
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = VIO16DELETESETID(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  VioDeleteSetId
#define VioDeleteSetId _VioDeleteSetId

inline USHORT APIENTRY16 _VioDestroyPS(HVPS a)
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = VIO16DESTROYPS(a);
    SetFS(sel);

    return yyrc;
} 

#undef  VioDestroyPS
#define VioDestroyPS _VioDestroyPS

inline USHORT APIENTRY16 _VioGetDeviceCellSize(PSHORT a, PSHORT b, HVPS c)
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = VIO16GETDEVICECELLSIZE(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  VioGetDeviceCellSize
#define VioGetDeviceCellSize _VioGetDeviceCellSize

inline USHORT APIENTRY16 _VioGetOrg(PSHORT a, PSHORT b, HVPS c)
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = VIO16GETORG(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  VioGetOrg
#define VioGetOrg _VioGetOrg

inline USHORT APIENTRY16 _VioQueryFonts(PLONG a, PFONTMETRICS b, LONG c, PLONG d, PSZ e, ULONG f, HVPS g)
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = VIO16QUERYFONTS(a, b, c, d, e, f, g);
    SetFS(sel);

    return yyrc;
} 

#undef  VioQueryFonts
#define VioQueryFonts _VioQueryFonts

inline USHORT APIENTRY16 _VioQuerySetIds(PLONG a, PSTR8 b, PLONG c, LONG d, HVPS e)
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = VIO16QUERYSETIDS(a, b, c, d, e);
    SetFS(sel);

    return yyrc;
} 

#undef  VioQuerySetIds
#define VioQuerySetIds _VioQuerySetIds

inline USHORT APIENTRY16 _VioSetDeviceCellSize(SHORT a, SHORT b, HVPS c)
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = VIO16SETDEVICECELLSIZE(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  VioSetDeviceCellSize
#define VioSetDeviceCellSize _VioSetDeviceCellSize

inline USHORT APIENTRY16 _VioSetOrg(SHORT a, SHORT b, HVPS c)
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = VIO16SETORG(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  VioSetOrg
#define VioSetOrg _VioSetOrg

inline USHORT APIENTRY16 _VioShowPS(SHORT a, SHORT b, SHORT c, HVPS d)
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = VIO16SHOWPS(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  VioShowPS
#define VioShowPS _VioShowPS

inline MRESULT APIENTRY16 _WinDefAVioWindowProc(HWND a, USHORT b, ULONG c, ULONG d)
{
 MRESULT yyrc;
 USHORT sel = GetFS();

    yyrc = WinDefAVioWindowProc(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  WinDefAVioWindowProc
#define WinDefAVioWindowProc _WinDefAVioWindowProc

#endif
#ifdef INCL_KBD
inline USHORT APIENTRY _KbdCharIn(PKBDKEYINFO a, USHORT b, HKBD c)
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = KbdCharIn(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  KbdCharIn
#define KbdCharIn _KbdCharIn

inline USHORT APIENTRY16 _KbdClose(HKBD a)
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = KbdClose(a);
    SetFS(sel);

    return yyrc;
} 

#undef  KbdClose
#define KbdClose _KbdClose

inline USHORT APIENTRY16 _KbdDeRegister()
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = KbdDeRegister();
    SetFS(sel);

    return yyrc;
} 

#undef  KbdDeRegister
#define KbdDeRegister _KbdDeRegister

inline USHORT APIENTRY16 _KbdFlushBuffer(HKBD a)
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = KbdFlushBuffer(a);
    SetFS(sel);

    return yyrc;
} 

#undef  KbdFlushBuffer
#define KbdFlushBuffer _KbdFlushBuffer

inline USHORT APIENTRY16 _KbdFreeFocus(HKBD a)
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = KbdFreeFocus(a);
    SetFS(sel);

    return yyrc;
} 

#undef  KbdFreeFocus
#define KbdFreeFocus _KbdFreeFocus

inline USHORT APIENTRY16 _KbdGetCp(ULONG a, PUSHORT b, HKBD c)
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = KbdGetCp(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  KbdGetCp
#define KbdGetCp _KbdGetCp

inline USHORT APIENTRY16 _KbdGetFocus(USHORT a, HKBD b)
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = KbdGetFocus(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  KbdGetFocus
#define KbdGetFocus _KbdGetFocus

inline USHORT APIENTRY16 _KbdGetHWID(PKBDHWID a, HKBD b)
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = KbdGetHWID(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  KbdGetHWID
#define KbdGetHWID _KbdGetHWID

inline USHORT APIENTRY16 _KbdGetStatus(PKBDINFO a, HKBD b)
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = KbdGetStatus(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  KbdGetStatus
#define KbdGetStatus _KbdGetStatus

inline USHORT APIENTRY16 _KbdOpen(PHKBD a)
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = KbdOpen(a);
    SetFS(sel);

    return yyrc;
} 

#undef  KbdOpen
#define KbdOpen _KbdOpen

inline USHORT APIENTRY16 _KbdPeek(PKBDKEYINFO a, HKBD b)
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = KbdPeek(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  KbdPeek
#define KbdPeek _KbdPeek

inline USHORT APIENTRY16 _KbdRegister(PSZ a, PSZ b, ULONG c)
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = KbdRegister(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  KbdRegister
#define KbdRegister _KbdRegister

inline USHORT APIENTRY16 _KbdSetCp(USHORT a, USHORT b, HKBD c)
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = KbdSetCp(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  KbdSetCp
#define KbdSetCp _KbdSetCp

inline USHORT APIENTRY16 _KbdSetCustXt(PUSHORT a, HKBD b)
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = KbdSetCustXt(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  KbdSetCustXt
#define KbdSetCustXt _KbdSetCustXt

inline USHORT APIENTRY16 _KbdSetFgnd()
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = KbdSetFgnd();
    SetFS(sel);

    return yyrc;
} 

#undef  KbdSetFgnd
#define KbdSetFgnd _KbdSetFgnd

inline USHORT APIENTRY16 _KbdSetHWID(PKBDHWID a, HKBD b)
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = KbdSetHWID(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  KbdSetHWID
#define KbdSetHWID _KbdSetHWID

inline USHORT APIENTRY16 _KbdSetStatus(PKBDINFO a, HKBD b)
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = KbdSetStatus(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  KbdSetStatus
#define KbdSetStatus _KbdSetStatus

inline USHORT APIENTRY16 _KbdStringIn(PCH a, PSTRINGINBUF b, USHORT c, HKBD d)
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = KbdStringIn(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  KbdStringIn
#define KbdStringIn _KbdStringIn

inline USHORT APIENTRY16 _KbdSynch(USHORT a)
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = KbdSynch(a);
    SetFS(sel);

    return yyrc;
} 

#undef  KbdSynch
#define KbdSynch _KbdSynch

inline USHORT APIENTRY16 _KbdXlate(PKBDTRANS a, HKBD b)
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = KbdXlate(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  KbdXlate
#define KbdXlate _KbdXlate

#endif
#ifdef INCL_VIO
inline USHORT APIENTRY16 _VioCheckCharType(PUSHORT a, USHORT b, USHORT c, HVIO d)
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = VIO16CHECKCHARTYPE(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  VioCheckCharType
#define VioCheckCharType _VioCheckCharType

inline USHORT APIENTRY16 _VioDeRegister()
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = VIO16DEREGISTER();
    SetFS(sel);

    return yyrc;
} 

#undef  VioDeRegister
#define VioDeRegister _VioDeRegister

inline USHORT APIENTRY16 _VioEndPopUp(HVIO a)
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = VIO16ENDPOPUP(a);
    SetFS(sel);

    return yyrc;
} 

#undef  VioEndPopUp
#define VioEndPopUp _VioEndPopUp

inline USHORT APIENTRY16 _VioGetAnsi(PUSHORT a, HVIO b)
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = VIO16GETANSI(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  VioGetAnsi
#define VioGetAnsi _VioGetAnsi

inline USHORT APIENTRY16 _VioGetBuf(PULONG a, PUSHORT b, HVIO c)
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = VIO16GETBUF(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  VioGetBuf
#define VioGetBuf _VioGetBuf

inline USHORT APIENTRY16 _VioGetConfig(USHORT a, PVIOCONFIGINFO b, HVIO c)
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = VIO16GETCONFIG(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  VioGetConfig
#define VioGetConfig _VioGetConfig

inline USHORT APIENTRY16 _VioGetCp(USHORT a, PUSHORT b, HVIO c)
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = VIO16GETCP(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  VioGetCp
#define VioGetCp _VioGetCp

inline USHORT APIENTRY16 _VioGetCurPos(PUSHORT a, PUSHORT b, HVIO c)
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = VIO16GETCURPOS(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  VioGetCurPos
#define VioGetCurPos _VioGetCurPos

inline USHORT APIENTRY16 _VioGetCurType(PVIOCURSORINFO a, HVIO b)
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = VIO16GETCURTYPE(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  VioGetCurType
#define VioGetCurType _VioGetCurType

inline USHORT APIENTRY16 _VioGetFont(PVIOFONTINFO a, HVIO b)
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = VIO16GETFONT(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  VioGetFont
#define VioGetFont _VioGetFont

inline USHORT APIENTRY16 _VioGetMode(PVIOMODEINFO a, HVIO b)
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = VIO16GETMODE(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  VioGetMode
#define VioGetMode _VioGetMode

inline USHORT APIENTRY16 _VioGetPhysBuf(PVIOPHYSBUF a, USHORT b)
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = VIO16GETPHYSBUF(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  VioGetPhysBuf
#define VioGetPhysBuf _VioGetPhysBuf

inline USHORT APIENTRY16 _VioGetState(PVOID a, HVIO b)
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = VIO16GETSTATE(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  VioGetState
#define VioGetState _VioGetState

inline USHORT APIENTRY16 _VioModeUndo(USHORT a, USHORT b, USHORT c)
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = VIO16MODEUNDO(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  VioModeUndo
#define VioModeUndo _VioModeUndo

inline USHORT APIENTRY16 _VioModeWait(USHORT a, PUSHORT b, USHORT c)
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = VIO16MODEWAIT(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  VioModeWait
#define VioModeWait _VioModeWait

inline USHORT APIENTRY16 _VioPopUp(PUSHORT a, HVIO b)
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = VIO16POPUP(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  VioPopUp
#define VioPopUp _VioPopUp

inline USHORT APIENTRY16 _VioPrtSc(HVIO a)
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = VIO16PRTSC(a);
    SetFS(sel);

    return yyrc;
} 

#undef  VioPrtSc
#define VioPrtSc _VioPrtSc

inline USHORT APIENTRY16 _VioPrtScToggle(HVIO a)
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = VIO16PRTSCTOGGLE(a);
    SetFS(sel);

    return yyrc;
} 

#undef  VioPrtScToggle
#define VioPrtScToggle _VioPrtScToggle

inline USHORT APIENTRY16 _VioReadCellStr(PCH a, PUSHORT b, USHORT c, USHORT d, HVIO e)
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = VIO16READCELLSTR(a, b, c, d, e);
    SetFS(sel);

    return yyrc;
} 

#undef  VioReadCellStr
#define VioReadCellStr _VioReadCellStr

inline USHORT APIENTRY16 _VioReadCharStr(PCH a, PUSHORT b, USHORT c, USHORT d, HVIO e)
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = VIO16READCHARSTR(a, b, c, d, e);
    SetFS(sel);

    return yyrc;
} 

#undef  VioReadCharStr
#define VioReadCharStr _VioReadCharStr

inline USHORT APIENTRY16 _VioRegister(PSZ a, PSZ b, ULONG c, ULONG d)
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = VIO16REGISTER(a, b, c, d);
    SetFS(sel);

    return yyrc;
} 

#undef  VioRegister
#define VioRegister _VioRegister

inline USHORT APIENTRY16 _VioSavRedrawUndo(USHORT a, USHORT b, USHORT c)
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = VIO16SAVREDRAWUNDO(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  VioSavRedrawUndo
#define VioSavRedrawUndo _VioSavRedrawUndo

inline USHORT APIENTRY16 _VioSavRedrawWait(USHORT a, PUSHORT b, USHORT c)
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = VIO16SAVREDRAWWAIT(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  VioSavRedrawWait
#define VioSavRedrawWait _VioSavRedrawWait

inline USHORT APIENTRY16 _VioScrLock(USHORT a, PUCHAR b, HVIO c)
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = VIO16SCRLOCK(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  VioScrLock
#define VioScrLock _VioScrLock

inline USHORT APIENTRY16 _VioScrollDn(USHORT a, USHORT b, USHORT c, USHORT d, USHORT e, PBYTE f, HVIO g)
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = VIO16SCROLLDN(a, b, c, d, e, f, g);
    SetFS(sel);

    return yyrc;
} 

#undef  VioScrollDn
#define VioScrollDn _VioScrollDn

inline USHORT APIENTRY16 _VioScrollLf(USHORT a, USHORT b, USHORT c, USHORT d, USHORT e, PBYTE f, HVIO g)
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = VIO16SCROLLLF(a, b, c, d, e, f, g);
    SetFS(sel);

    return yyrc;
} 

#undef  VioScrollLf
#define VioScrollLf _VioScrollLf

inline USHORT APIENTRY16 _VioScrollRt(USHORT a, USHORT b, USHORT c, USHORT d, USHORT e, PBYTE f, HVIO g)
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = VIO16SCROLLRT(a, b, c, d, e, f, g);
    SetFS(sel);

    return yyrc;
} 

#undef  VioScrollRt
#define VioScrollRt _VioScrollRt

inline USHORT APIENTRY16 _VioScrollUp(USHORT a, USHORT b, USHORT c, USHORT d, USHORT e, PBYTE f, HVIO g)
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = VIO16SCROLLUP(a, b, c, d, e, f, g);
    SetFS(sel);

    return yyrc;
} 

#undef  VioScrollUp
#define VioScrollUp _VioScrollUp

inline USHORT APIENTRY16 _VioScrUnLock(HVIO a)
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = VIO16SCRUNLOCK(a);
    SetFS(sel);

    return yyrc;
} 

#undef  VioScrUnLock
#define VioScrUnLock _VioScrUnLock

inline USHORT APIENTRY16 _VioSetAnsi(USHORT a, HVIO b)
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = VIO16SETANSI(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  VioSetAnsi
#define VioSetAnsi _VioSetAnsi

inline USHORT APIENTRY16 _VioSetCp(USHORT a, USHORT b, HVIO c)
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = VIO16SETCP(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  VioSetCp
#define VioSetCp _VioSetCp

inline USHORT APIENTRY16 _VioSetCurPos(USHORT a, USHORT b, HVIO c)
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = VIO16SETCURPOS(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  VioSetCurPos
#define VioSetCurPos _VioSetCurPos

inline USHORT APIENTRY16 _VioSetCurType(PVIOCURSORINFO a, HVIO b)
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = VIO16SETCURTYPE(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  VioSetCurType
#define VioSetCurType _VioSetCurType

inline USHORT APIENTRY16 _VioSetFont(PVIOFONTINFO a, HVIO b)
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = VIO16SETFONT(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  VioSetFont
#define VioSetFont _VioSetFont

inline USHORT APIENTRY16 _VioSetMode(PVIOMODEINFO a, HVIO b)
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = VIO16SETMODE(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  VioSetMode
#define VioSetMode _VioSetMode

inline USHORT APIENTRY16 _VioSetState(PVOID a, HVIO b)
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = VIO16SETSTATE(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  VioSetState
#define VioSetState _VioSetState

inline USHORT APIENTRY16 _VioShowBuf(USHORT a, USHORT b, HVIO c)
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = VIO16SHOWBUF(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  VioShowBuf
#define VioShowBuf _VioShowBuf

inline USHORT APIENTRY16 _VioWrtCellStr(PCH a, USHORT b, USHORT c, USHORT d, HVIO e)
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = VIO16WRTCELLSTR(a, b, c, d, e);
    SetFS(sel);

    return yyrc;
} 

#undef  VioWrtCellStr
#define VioWrtCellStr _VioWrtCellStr

inline USHORT APIENTRY16 _VioWrtCharStr(PCH a, USHORT b, USHORT c, USHORT d, HVIO e)
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = VIO16WRTCHARSTR(a, b, c, d, e);
    SetFS(sel);

    return yyrc;
} 

#undef  VioWrtCharStr
#define VioWrtCharStr _VioWrtCharStr

inline USHORT APIENTRY16 _VioWrtCharStrAtt(PCH a, USHORT b, USHORT c, USHORT d, PBYTE e, HVIO f)
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = VIO16WRTCHARSTRATT(a, b, c, d, e, f);
    SetFS(sel);

    return yyrc;
} 

#undef  VioWrtCharStrAtt
#define VioWrtCharStrAtt _VioWrtCharStrAtt

inline USHORT APIENTRY16 _VioWrtNAttr(PBYTE a, USHORT b, USHORT c, USHORT d, HVIO e)
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = VIO16WRTNATTR(a, b, c, d, e);
    SetFS(sel);

    return yyrc;
} 

#undef  VioWrtNAttr
#define VioWrtNAttr _VioWrtNAttr

inline USHORT APIENTRY16 _VioWrtNCell(PBYTE a, USHORT b, USHORT c, USHORT d, HVIO e)
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = VIO16WRTNCELL(a, b, c, d, e);
    SetFS(sel);

    return yyrc;
} 

#undef  VioWrtNCell
#define VioWrtNCell _VioWrtNCell

inline USHORT APIENTRY16 _VioWrtNChar(PCH a, USHORT b, USHORT c, USHORT d, HVIO e)
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = VIO16WRTNCHAR(a, b, c, d, e);
    SetFS(sel);

    return yyrc;
} 

#undef  VioWrtNChar
#define VioWrtNChar _VioWrtNChar

inline USHORT APIENTRY16 _VioWrtTTY(PCH a, USHORT b, HVIO c)
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = VIO16WRTTTY(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  VioWrtTTY
#define VioWrtTTY _VioWrtTTY

#endif
#ifdef INCL_MOU
inline USHORT APIENTRY16 _MouClose(HMOU a)
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = MOU16CLOSE(a);
    SetFS(sel);

    return yyrc;
} 

#undef  MouClose
#define MouClose _MouClose

inline USHORT APIENTRY16 _MouDeRegister()
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = MOU16DEREGISTER();
    SetFS(sel);

    return yyrc;
} 

#undef  MouDeRegister
#define MouDeRegister _MouDeRegister

inline USHORT APIENTRY16 _MouDrawPtr(HMOU a)
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = MOU16DRAWPTR(a);
    SetFS(sel);

    return yyrc;
} 

#undef  MouDrawPtr
#define MouDrawPtr _MouDrawPtr

inline USHORT APIENTRY16 _MouFlushQue(HMOU a)
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = MOU16FLUSHQUE(a);
    SetFS(sel);

    return yyrc;
} 

#undef  MouFlushQue
#define MouFlushQue _MouFlushQue

inline USHORT APIENTRY16 _MouGetDevStatus(PUSHORT a, HMOU b)
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = MOU16GETDEVSTATUS(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  MouGetDevStatus
#define MouGetDevStatus _MouGetDevStatus

inline USHORT APIENTRY16 _MouGetEventMask(PUSHORT a, HMOU b)
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = MOU16GETEVENTMASK(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  MouGetEventMask
#define MouGetEventMask _MouGetEventMask

inline USHORT APIENTRY16 _MouGetNumButtons(PUSHORT a, HMOU b)
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = MOU16GETNUMBUTTONS(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  MouGetNumButtons
#define MouGetNumButtons _MouGetNumButtons

inline USHORT APIENTRY16 _MouGetNumMickeys(PUSHORT a, HMOU b)
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = MOU16GETNUMMICKEYS(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  MouGetNumMickeys
#define MouGetNumMickeys _MouGetNumMickeys

inline USHORT APIENTRY16 _MouGetNumQueEl(PMOUQUEINFO a, HMOU b)
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = MOU16GETNUMQUEEL(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  MouGetNumQueEl
#define MouGetNumQueEl _MouGetNumQueEl

inline USHORT APIENTRY16 _MouGetPtrPos(PPTRLOC a, HMOU b)
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = MOU16GETPTRPOS(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  MouGetPtrPos
#define MouGetPtrPos _MouGetPtrPos

inline USHORT APIENTRY16 _MouGetPtrShape(PBYTE a, PPTRSHAPE b, HMOU c)
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = MOU16GETPTRSHAPE(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  MouGetPtrShape
#define MouGetPtrShape _MouGetPtrShape

inline USHORT APIENTRY16 _MouGetScaleFact(PSCALEFACT a, HMOU b)
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = MOU16GETSCALEFACT(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  MouGetScaleFact
#define MouGetScaleFact _MouGetScaleFact

inline USHORT APIENTRY16 _MouGetThreshold(PTHRESHOLD a, HMOU b)
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = MOU16GETTHRESHOLD(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  MouGetThreshold
#define MouGetThreshold _MouGetThreshold

inline USHORT APIENTRY16 _MouInitReal(PSZ a)
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = MOU16INITREAL(a);
    SetFS(sel);

    return yyrc;
} 

#undef  MouInitReal
#define MouInitReal _MouInitReal

inline USHORT APIENTRY16 _MouOpen(PSZ a, PHMOU b)
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = MOU16OPEN(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  MouOpen
#define MouOpen _MouOpen

inline USHORT APIENTRY16 _MouReadEventQue(PMOUEVENTINFO a, PUSHORT b, HMOU c)
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = MOU16READEVENTQUE(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  MouReadEventQue
#define MouReadEventQue _MouReadEventQue

inline USHORT APIENTRY16 _MouRegister(PSZ a, PSZ b, ULONG c)
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = MOU16REGISTER(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  MouRegister
#define MouRegister _MouRegister

inline USHORT APIENTRY16 _MouRemovePtr(PNOPTRRECT a, HMOU b)
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = MOU16REMOVEPTR(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  MouRemovePtr
#define MouRemovePtr _MouRemovePtr

inline USHORT APIENTRY16 _MouSetDevStatus(PUSHORT a, HMOU b)
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = MOU16SETDEVSTATUS(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  MouSetDevStatus
#define MouSetDevStatus _MouSetDevStatus

inline USHORT APIENTRY16 _MouSetEventMask(PUSHORT a, HMOU b)
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = MOU16SETEVENTMASK(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  MouSetEventMask
#define MouSetEventMask _MouSetEventMask

inline USHORT APIENTRY16 _MouSetPtrPos(PPTRLOC a, HMOU b)
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = MOU16SETPTRPOS(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  MouSetPtrPos
#define MouSetPtrPos _MouSetPtrPos

inline USHORT APIENTRY16 _MouSetPtrShape(PBYTE a, PPTRSHAPE b, HMOU c)
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = MOU16SETPTRSHAPE(a, b, c);
    SetFS(sel);

    return yyrc;
} 

#undef  MouSetPtrShape
#define MouSetPtrShape _MouSetPtrShape

inline USHORT APIENTRY16 _MouSetScaleFact(PSCALEFACT a, HMOU b)
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = MOU16SETSCALEFACT(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  MouSetScaleFact
#define MouSetScaleFact _MouSetScaleFact

inline USHORT APIENTRY16 _MouSetThreshold(PTHRESHOLD a, HMOU b)
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = MOU16SETTHRESHOLD(a, b);
    SetFS(sel);

    return yyrc;
} 

#undef  MouSetThreshold
#define MouSetThreshold _MouSetThreshold

inline USHORT APIENTRY16 _MouSynch(USHORT a)
{
 USHORT yyrc;
 USHORT sel = GetFS();

    yyrc = MOU16SYNCH(a);
    SetFS(sel);

    return yyrc;
} 

#undef  MouSynch
#define MouSynch _MouSynch

#endif

#endif