#line 1 "C:\\SOURCE\\NEWSCLI\\MSVC32\\WinDebug\\RC570661"
#line 1 "C:\\SOURCE\\NEWSCLI\\NEWSCLI.RC"
#line 1 "C:\\SOURCE\\NEWSCLI\\NEWSCLI.RC"



#line 5 "C:\\SOURCE\\NEWSCLI\\NEWSCLI.RC"
#line 1 "C:\\SOURCE\\NEWSCLI\\newscli.rh"






























#line 6 "C:\\SOURCE\\NEWSCLI\\NEWSCLI.RC"
#line 1 "..\\..\\common/errno.rc"















#line 1 "..\\..\\common/winsock.h"






























#line 1 "d:\\msvc20\\include/windows.h"















































































#line 81 "d:\\msvc20\\include/windows.h"



#line 85 "d:\\msvc20\\include/windows.h"



#line 89 "d:\\msvc20\\include/windows.h"



#line 93 "d:\\msvc20\\include/windows.h"



#line 97 "d:\\msvc20\\include/windows.h"









#line 1 "d:\\msvc20\\include/windef.h"



























typedef unsigned long ULONG;
typedef ULONG *PULONG;
typedef unsigned short USHORT;
typedef USHORT *PUSHORT;
typedef unsigned char UCHAR;
typedef UCHAR *PUCHAR;
typedef char *PSZ;
#line 36 "d:\\msvc20\\include/windef.h"








#line 45 "d:\\msvc20\\include/windef.h"
#line 46 "d:\\msvc20\\include/windef.h"



#line 50 "d:\\msvc20\\include/windef.h"



#line 54 "d:\\msvc20\\include/windef.h"



#line 58 "d:\\msvc20\\include/windef.h"



#line 62 "d:\\msvc20\\include/windef.h"



#line 66 "d:\\msvc20\\include/windef.h"









#line 76 "d:\\msvc20\\include/windef.h"

#line 78 "d:\\msvc20\\include/windef.h"










#line 89 "d:\\msvc20\\include/windef.h"
#line 90 "d:\\msvc20\\include/windef.h"








#line 99 "d:\\msvc20\\include/windef.h"






#line 106 "d:\\msvc20\\include/windef.h"





#line 112 "d:\\msvc20\\include/windef.h"

typedef unsigned long       DWORD;
typedef int                 BOOL;
typedef unsigned char       BYTE;
typedef unsigned short      WORD;
typedef float               FLOAT;
typedef FLOAT               *PFLOAT;
typedef BOOL            *PBOOL;
typedef BOOL             *LPBOOL;
typedef BYTE            *PBYTE;
typedef BYTE             *LPBYTE;
typedef int             *PINT;
typedef int              *LPINT;
typedef WORD            *PWORD;
typedef WORD             *LPWORD;
typedef long             *LPLONG;
typedef DWORD           *PDWORD;
typedef DWORD            *LPDWORD;
typedef void             *LPVOID;
typedef const void       *LPCVOID;

typedef int                 INT;
typedef unsigned int        UINT;
typedef unsigned int        *PUINT;


#line 1 "d:\\msvc20\\include/winnt.h"
























#line 1 "d:\\msvc20\\include/ctype.h"
























#line 26 "d:\\msvc20\\include/ctype.h"

#line 28 "d:\\msvc20\\include/ctype.h"
#line 29 "d:\\msvc20\\include/ctype.h"







#line 37 "d:\\msvc20\\include/ctype.h"

#line 39 "d:\\msvc20\\include/ctype.h"
#line 40 "d:\\msvc20\\include/ctype.h"














#line 55 "d:\\msvc20\\include/ctype.h"
#line 56 "d:\\msvc20\\include/ctype.h"
#line 57 "d:\\msvc20\\include/ctype.h"






#line 64 "d:\\msvc20\\include/ctype.h"



typedef unsigned short wchar_t;

#line 70 "d:\\msvc20\\include/ctype.h"


typedef wchar_t wint_t;
typedef wchar_t wctype_t;

#line 76 "d:\\msvc20\\include/ctype.h"



#line 80 "d:\\msvc20\\include/ctype.h"
































 extern unsigned short _ctype[];









#line 123 "d:\\msvc20\\include/ctype.h"

 extern unsigned short *_pctype;
 extern wctype_t *_pwctype;

#line 128 "d:\\msvc20\\include/ctype.h"

#line 130 "d:\\msvc20\\include/ctype.h"

#line 132 "d:\\msvc20\\include/ctype.h"







				













 int  _isctype(int, int);

 int  isalpha(int);
 int  isupper(int);
 int  islower(int);
 int  isdigit(int);
 int  isxdigit(int);
 int  isspace(int);
 int  ispunct(int);
 int  isalnum(int);
 int  isprint(int);
 int  isgraph(int);
 int  iscntrl(int);
 int  toupper(int);
 int  tolower(int);
 int  _tolower(int);
 int  _toupper(int);
 int  __isascii(int);
 int  __toascii(int);
 int  __iscsymf(int);
 int  __iscsym(int);

#line 176 "d:\\msvc20\\include/ctype.h"







 int  iswalpha(wint_t);
 int  iswupper(wint_t);
 int  iswlower(wint_t);
 int  iswdigit(wint_t);
 int  iswxdigit(wint_t);
 int  iswspace(wint_t);
 int  iswpunct(wint_t);
 int  iswalnum(wint_t);
 int  iswprint(wint_t);
 int  iswgraph(wint_t);
 int  iswcntrl(wint_t);
 int  iswascii(wint_t);
 int  isleadbyte(int);

 wchar_t  towupper(wchar_t);
 wchar_t  towlower(wchar_t);

 int  iswctype(wint_t, wctype_t);


 int  is_wctype(wint_t, wctype_t);



#line 208 "d:\\msvc20\\include/ctype.h"






























#line 239 "d:\\msvc20\\include/ctype.h"

 extern int __mb_cur_max;
#line 242 "d:\\msvc20\\include/ctype.h"

#line 244 "d:\\msvc20\\include/ctype.h"

#line 246 "d:\\msvc20\\include/ctype.h"










































#line 289 "d:\\msvc20\\include/ctype.h"
























#line 314 "d:\\msvc20\\include/ctype.h"

#line 316 "d:\\msvc20\\include/ctype.h"

#line 318 "d:\\msvc20\\include/ctype.h"






#line 325 "d:\\msvc20\\include/ctype.h"
#line 26 "d:\\msvc20\\include/winnt.h"



#line 30 "d:\\msvc20\\include/winnt.h"

#line 32 "d:\\msvc20\\include/winnt.h"



#line 36 "d:\\msvc20\\include/winnt.h"

#line 38 "d:\\msvc20\\include/winnt.h"

typedef void *PVOID;    



#line 44 "d:\\msvc20\\include/winnt.h"


#line 47 "d:\\msvc20\\include/winnt.h"









#line 57 "d:\\msvc20\\include/winnt.h"








typedef char CHAR;
typedef short SHORT;
typedef long LONG;
#line 69 "d:\\msvc20\\include/winnt.h"





typedef wchar_t WCHAR;    

typedef WCHAR *PWCHAR;
typedef WCHAR *LPWCH, *PWCH;
typedef const WCHAR *LPCWCH, *PCWCH;
typedef WCHAR *NWPSTR;
typedef WCHAR *LPWSTR, *PWSTR;

typedef const WCHAR *LPCWSTR, *PCWSTR;




typedef CHAR *PCHAR;
typedef CHAR *LPCH, *PCH;

typedef const CHAR *LPCCH, *PCCH;
typedef CHAR *NPSTR;
typedef CHAR *LPSTR, *PSTR;
typedef const CHAR *LPCSTR, *PCSTR;





















typedef char TCHAR, *PTCHAR;
typedef unsigned char TBYTE , *PTBYTE ;

#line 119 "d:\\msvc20\\include/winnt.h"

typedef LPSTR LPTCH, PTCH;
typedef LPSTR PTSTR, LPTSTR;
typedef LPCSTR LPCTSTR;


#line 126 "d:\\msvc20\\include/winnt.h"



typedef SHORT *PSHORT;  
typedef LONG *PLONG;    





typedef PVOID HANDLE;

#line 139 "d:\\msvc20\\include/winnt.h"
typedef HANDLE *PHANDLE;

typedef char CCHAR;          
typedef DWORD LCID;         
typedef PDWORD PLCID;       
typedef WORD   LANGID;      
  
  












typedef __int64 LONGLONG;
typedef unsigned __int64 DWORDLONG;



#line 165 "d:\\msvc20\\include/winnt.h"

typedef LONGLONG *PLONGLONG;
typedef DWORDLONG *PDWORDLONG;



#line 172 "d:\\msvc20\\include/winnt.h"
typedef union _LARGE_INTEGER {
    struct {
        DWORD LowPart;
        LONG HighPart;
    };
    struct {
        DWORD LowPart;
        LONG HighPart;
    } u;
#line 182 "d:\\msvc20\\include/winnt.h"
    LONGLONG QuadPart;
} LARGE_INTEGER;

typedef LARGE_INTEGER *PLARGE_INTEGER;




#line 191 "d:\\msvc20\\include/winnt.h"
typedef union _ULARGE_INTEGER {
    struct {
        DWORD LowPart;
        DWORD HighPart;
    };
    struct {
        DWORD LowPart;
        DWORD HighPart;
    } u;
#line 201 "d:\\msvc20\\include/winnt.h"
    DWORDLONG QuadPart;
} ULARGE_INTEGER;

typedef ULARGE_INTEGER *PULARGE_INTEGER;







typedef LARGE_INTEGER LUID, *PLUID;



















































































































































































































#line 425 "d:\\msvc20\\include/winnt.h"


typedef BYTE  BOOLEAN;           
typedef BOOLEAN *PBOOLEAN;       





typedef struct _LIST_ENTRY {
   struct _LIST_ENTRY *Flink;
   struct _LIST_ENTRY *Blink;
} LIST_ENTRY;
typedef LIST_ENTRY *PLIST_ENTRY;






typedef struct _SINGLE_LIST_ENTRY {
    struct _SINGLE_LIST_ENTRY *Next;
} SINGLE_LIST_ENTRY, *PSINGLE_LIST_ENTRY;










































































































































































































































#line 683 "d:\\msvc20\\include/winnt.h"


  




























  



typedef DWORD KSPIN_LOCK;  














































































































































































































































































































































































































































































































































typedef struct _LDT_ENTRY {
    WORD    LimitLow;
    WORD    BaseLow;
    union {
        struct {
            BYTE    BaseMid;
            BYTE    Flags1;     
            BYTE    Flags2;     
            BYTE    BaseHi;
        } Bytes;
        struct {
            DWORD   BaseMid : 8;
            DWORD   Type : 5;
            DWORD   Dpl : 2;
            DWORD   Pres : 1;
            DWORD   LimitHi : 4;
            DWORD   Sys : 1;
            DWORD   Reserved_0 : 1;
            DWORD   Default_Big : 1;
            DWORD   Granularity : 1;
            DWORD   BaseHi : 8;
        } Bits;
    } HighWord;
} LDT_ENTRY, *PLDT_ENTRY;








































































































































































#line 1438 "d:\\msvc20\\include/winnt.h"










#line 1449 "d:\\msvc20\\include/winnt.h"


















































































































































































#line 1628 "d:\\msvc20\\include/winnt.h"












#line 1641 "d:\\msvc20\\include/winnt.h"








typedef struct _EXCEPTION_RECORD {
      
    DWORD    ExceptionCode;
      
    DWORD ExceptionFlags;
    struct _EXCEPTION_RECORD *ExceptionRecord;
    PVOID ExceptionAddress;
    DWORD NumberParameters;
    DWORD ExceptionInformation[15];
    } EXCEPTION_RECORD;

typedef EXCEPTION_RECORD *PEXCEPTION_RECORD;





typedef struct _EXCEPTION_POINTERS {
    PEXCEPTION_RECORD ExceptionRecord;
    PCONTEXT ContextRecord;
} EXCEPTION_POINTERS, *PEXCEPTION_POINTERS;


























































typedef struct _MEMORY_BASIC_INFORMATION {
    PVOID BaseAddress;
    PVOID AllocationBase;
    DWORD AllocationProtect;
    DWORD RegionSize;
    DWORD State;
    DWORD Protect;
    DWORD Type;
} MEMORY_BASIC_INFORMATION, *PMEMORY_BASIC_INFORMATION;





























































































































typedef PVOID PACCESS_TOKEN;            
typedef PVOID PSECURITY_DESCRIPTOR;     
typedef PVOID PSID;     







































typedef DWORD ACCESS_MASK;
typedef ACCESS_MASK *PACCESS_MASK;
























































typedef struct _GENERIC_MAPPING {
    ACCESS_MASK GenericRead;
    ACCESS_MASK GenericWrite;
    ACCESS_MASK GenericExecute;
    ACCESS_MASK GenericAll;
} GENERIC_MAPPING;
typedef GENERIC_MAPPING *PGENERIC_MAPPING;












#line 1 "d:\\msvc20\\include/pshpack4.h"































#line 33 "d:\\msvc20\\include/pshpack4.h"
#line 1982 "d:\\msvc20\\include/winnt.h"

typedef struct _LUID_AND_ATTRIBUTES {
    LUID Luid;
    DWORD Attributes;
    } LUID_AND_ATTRIBUTES, * PLUID_AND_ATTRIBUTES;
typedef LUID_AND_ATTRIBUTES LUID_AND_ATTRIBUTES_ARRAY[1];
typedef LUID_AND_ATTRIBUTES_ARRAY *PLUID_AND_ATTRIBUTES_ARRAY;

#line 1 "d:\\msvc20\\include/poppack.h"



































#line 37 "d:\\msvc20\\include/poppack.h"
#line 1991 "d:\\msvc20\\include/winnt.h"
































typedef struct _SID_IDENTIFIER_AUTHORITY {
    BYTE  Value[6];
} SID_IDENTIFIER_AUTHORITY, *PSID_IDENTIFIER_AUTHORITY;


typedef struct _SID {
   BYTE  Revision;
   BYTE  SubAuthorityCount;
   SID_IDENTIFIER_AUTHORITY IdentifierAuthority;



   DWORD SubAuthority[1];
#line 2037 "d:\\msvc20\\include/winnt.h"
} SID, *PISID;





                                                

typedef enum _SID_NAME_USE {
    SidTypeUser = 1,
    SidTypeGroup,
    SidTypeDomain,
    SidTypeAlias,
    SidTypeWellKnownGroup,
    SidTypeDeletedAccount,
    SidTypeInvalid,
    SidTypeUnknown
} SID_NAME_USE, *PSID_NAME_USE;



typedef struct _SID_AND_ATTRIBUTES {
    PSID Sid;
    DWORD Attributes;
    } SID_AND_ATTRIBUTES, * PSID_AND_ATTRIBUTES;

typedef SID_AND_ATTRIBUTES SID_AND_ATTRIBUTES_ARRAY[1];
typedef SID_AND_ATTRIBUTES_ARRAY *PSID_AND_ATTRIBUTES_ARRAY;
































































































































































































typedef struct _ACL {
    BYTE  AclRevision;
    BYTE  Sbz1;
    WORD   AclSize;
    WORD   AceCount;
    WORD   Sbz2;
} ACL;
typedef ACL *PACL;





















typedef struct _ACE_HEADER {
    BYTE  AceType;
    BYTE  AceFlags;
    WORD   AceSize;
} ACE_HEADER;
typedef ACE_HEADER *PACE_HEADER;












































































typedef struct _ACCESS_ALLOWED_ACE {
    ACE_HEADER Header;
    ACCESS_MASK Mask;
    DWORD SidStart;
} ACCESS_ALLOWED_ACE;

typedef ACCESS_ALLOWED_ACE *PACCESS_ALLOWED_ACE;

typedef struct _ACCESS_DENIED_ACE {
    ACE_HEADER Header;
    ACCESS_MASK Mask;
    DWORD SidStart;
} ACCESS_DENIED_ACE;
typedef ACCESS_DENIED_ACE *PACCESS_DENIED_ACE;

typedef struct _SYSTEM_AUDIT_ACE {
    ACE_HEADER Header;
    ACCESS_MASK Mask;
    DWORD SidStart;
} SYSTEM_AUDIT_ACE;
typedef SYSTEM_AUDIT_ACE *PSYSTEM_AUDIT_ACE;

typedef struct _SYSTEM_ALARM_ACE {
    ACE_HEADER Header;
    ACCESS_MASK Mask;
    DWORD SidStart;
} SYSTEM_ALARM_ACE;
typedef SYSTEM_ALARM_ACE *PSYSTEM_ALARM_ACE;










typedef enum _ACL_INFORMATION_CLASS {
    AclRevisionInformation = 1,
    AclSizeInformation
} ACL_INFORMATION_CLASS;






typedef struct _ACL_REVISION_INFORMATION {
    DWORD AclRevision;
} ACL_REVISION_INFORMATION;
typedef ACL_REVISION_INFORMATION *PACL_REVISION_INFORMATION;





typedef struct _ACL_SIZE_INFORMATION {
    DWORD AceCount;
    DWORD AclBytesInUse;
    DWORD AclBytesFree;
} ACL_SIZE_INFORMATION;
typedef ACL_SIZE_INFORMATION *PACL_SIZE_INFORMATION;































typedef WORD   SECURITY_DESCRIPTOR_CONTROL, *PSECURITY_DESCRIPTOR_CONTROL;


















































































typedef struct _SECURITY_DESCRIPTOR {
   BYTE  Revision;
   BYTE  Sbz1;
   SECURITY_DESCRIPTOR_CONTROL Control;
   PSID Owner;
   PSID Group;
   PACL Sacl;
   PACL Dacl;
   } SECURITY_DESCRIPTOR, *PISECURITY_DESCRIPTOR;










































































typedef struct _PRIVILEGE_SET {
    DWORD PrivilegeCount;
    DWORD Control;
    LUID_AND_ATTRIBUTES Privilege[1];
    } PRIVILEGE_SET, * PPRIVILEGE_SET;


















































typedef enum _SECURITY_IMPERSONATION_LEVEL {
    SecurityAnonymous,
    SecurityIdentification,
    SecurityImpersonation,
    SecurityDelegation
    } SECURITY_IMPERSONATION_LEVEL, * PSECURITY_IMPERSONATION_LEVEL;













typedef BOOLEAN SECURITY_CONTEXT_TRACKING_MODE,
                    * PSECURITY_CONTEXT_TRACKING_MODE;







typedef struct _SECURITY_QUALITY_OF_SERVICE {
    DWORD Length;
    SECURITY_IMPERSONATION_LEVEL ImpersonationLevel;
    SECURITY_CONTEXT_TRACKING_MODE ContextTrackingMode;
    BOOLEAN EffectiveOnly;
    } SECURITY_QUALITY_OF_SERVICE, * PSECURITY_QUALITY_OF_SERVICE;






typedef struct _SE_IMPERSONATION_STATE {
    PACCESS_TOKEN Token;
    BOOLEAN CopyOnOpen;
    BOOLEAN EffectiveOnly;
    SECURITY_IMPERSONATION_LEVEL Level;
} SE_IMPERSONATION_STATE, *PSE_IMPERSONATION_STATE;



















































typedef enum _TOKEN_TYPE {
    TokenPrimary = 1,
    TokenImpersonation
    } TOKEN_TYPE;
typedef TOKEN_TYPE *PTOKEN_TYPE;








typedef enum _TOKEN_INFORMATION_CLASS {
    TokenUser = 1,
    TokenGroups,
    TokenPrivileges,
    TokenOwner,
    TokenPrimaryGroup,
    TokenDefaultDacl,
    TokenSource,
    TokenType,
    TokenImpersonationLevel,
    TokenStatistics
} TOKEN_INFORMATION_CLASS, *PTOKEN_INFORMATION_CLASS;






typedef struct _TOKEN_USER {
    SID_AND_ATTRIBUTES User;
} TOKEN_USER, *PTOKEN_USER;


typedef struct _TOKEN_GROUPS {
    DWORD GroupCount;
    SID_AND_ATTRIBUTES Groups[1];
} TOKEN_GROUPS, *PTOKEN_GROUPS;


typedef struct _TOKEN_PRIVILEGES {
    DWORD PrivilegeCount;
    LUID_AND_ATTRIBUTES Privileges[1];
} TOKEN_PRIVILEGES, *PTOKEN_PRIVILEGES;


typedef struct _TOKEN_OWNER {
    PSID Owner;
} TOKEN_OWNER, *PTOKEN_OWNER;


typedef struct _TOKEN_PRIMARY_GROUP {
    PSID PrimaryGroup;
} TOKEN_PRIMARY_GROUP, *PTOKEN_PRIMARY_GROUP;


typedef struct _TOKEN_DEFAULT_DACL {
    PACL DefaultDacl;
} TOKEN_DEFAULT_DACL, *PTOKEN_DEFAULT_DACL;






typedef struct _TOKEN_SOURCE {
    CHAR SourceName[8];
    LUID SourceIdentifier;
} TOKEN_SOURCE, *PTOKEN_SOURCE;



typedef struct _TOKEN_STATISTICS {
    LUID TokenId;
    LUID AuthenticationId;
    LARGE_INTEGER ExpirationTime;
    TOKEN_TYPE TokenType;
    SECURITY_IMPERSONATION_LEVEL ImpersonationLevel;
    DWORD DynamicCharged;
    DWORD DynamicAvailable;
    DWORD GroupCount;
    DWORD PrivilegeCount;
    LUID ModifiedId;
} TOKEN_STATISTICS, *PTOKEN_STATISTICS;




typedef struct _TOKEN_CONTROL {
    LUID TokenId;
    LUID AuthenticationId;
    LUID ModifiedId;
    TOKEN_SOURCE TokenSource;
    } TOKEN_CONTROL, *PTOKEN_CONTROL;


typedef DWORD SECURITY_INFORMATION, *PSECURITY_INFORMATION;











#line 1 "d:\\msvc20\\include/pshpack1.h"































#line 33 "d:\\msvc20\\include/pshpack1.h"
#line 2891 "d:\\msvc20\\include/winnt.h"






typedef struct _IMAGE_DOS_HEADER {      
    WORD   e_magic;                     
    WORD   e_cblp;                      
    WORD   e_cp;                        
    WORD   e_crlc;                      
    WORD   e_cparhdr;                   
    WORD   e_minalloc;                  
    WORD   e_maxalloc;                  
    WORD   e_ss;                        
    WORD   e_sp;                        
    WORD   e_csum;                      
    WORD   e_ip;                        
    WORD   e_cs;                        
    WORD   e_lfarlc;                    
    WORD   e_ovno;                      
    WORD   e_res[4];                    
    WORD   e_oemid;                     
    WORD   e_oeminfo;                   
    WORD   e_res2[10];                  
    LONG   e_lfanew;                    
  } IMAGE_DOS_HEADER, *PIMAGE_DOS_HEADER;

typedef struct _IMAGE_OS2_HEADER {      
    WORD   ne_magic;                    
    CHAR   ne_ver;                      
    CHAR   ne_rev;                      
    WORD   ne_enttab;                   
    WORD   ne_cbenttab;                 
    LONG   ne_crc;                      
    WORD   ne_flags;                    
    WORD   ne_autodata;                 
    WORD   ne_heap;                     
    WORD   ne_stack;                    
    LONG   ne_csip;                     
    LONG   ne_sssp;                     
    WORD   ne_cseg;                     
    WORD   ne_cmod;                     
    WORD   ne_cbnrestab;                
    WORD   ne_segtab;                   
    WORD   ne_rsrctab;                  
    WORD   ne_restab;                   
    WORD   ne_modtab;                   
    WORD   ne_imptab;                   
    LONG   ne_nrestab;                  
    WORD   ne_cmovent;                  
    WORD   ne_align;                    
    WORD   ne_cres;                     
    BYTE   ne_exetyp;                   
    BYTE   ne_flagsothers;              
    WORD   ne_pretthunks;               
    WORD   ne_psegrefbytes;             
    WORD   ne_swaparea;                 
    WORD   ne_expver;                   
  } IMAGE_OS2_HEADER, *PIMAGE_OS2_HEADER;





typedef struct _IMAGE_FILE_HEADER {
    WORD    Machine;
    WORD    NumberOfSections;
    DWORD   TimeDateStamp;
    DWORD   PointerToSymbolTable;
    DWORD   NumberOfSymbols;
    WORD    SizeOfOptionalHeader;
    WORD    Characteristics;
} IMAGE_FILE_HEADER, *PIMAGE_FILE_HEADER;

























typedef struct _IMAGE_DATA_DIRECTORY {
    DWORD   VirtualAddress;
    DWORD   Size;
} IMAGE_DATA_DIRECTORY, *PIMAGE_DATA_DIRECTORY;







typedef struct _IMAGE_OPTIONAL_HEADER {
    
    
    

    WORD    Magic;
    BYTE    MajorLinkerVersion;
    BYTE    MinorLinkerVersion;
    DWORD   SizeOfCode;
    DWORD   SizeOfInitializedData;
    DWORD   SizeOfUninitializedData;
    DWORD   AddressOfEntryPoint;
    DWORD   BaseOfCode;
    DWORD   BaseOfData;

    
    
    

    DWORD   ImageBase;
    DWORD   SectionAlignment;
    DWORD   FileAlignment;
    WORD    MajorOperatingSystemVersion;
    WORD    MinorOperatingSystemVersion;
    WORD    MajorImageVersion;
    WORD    MinorImageVersion;
    WORD    MajorSubsystemVersion;
    WORD    MinorSubsystemVersion;
    DWORD   Reserved1;
    DWORD   SizeOfImage;
    DWORD   SizeOfHeaders;
    DWORD   CheckSum;
    WORD    Subsystem;
    WORD    DllCharacteristics;
    DWORD   SizeOfStackReserve;
    DWORD   SizeOfStackCommit;
    DWORD   SizeOfHeapReserve;
    DWORD   SizeOfHeapCommit;
    DWORD   LoaderFlags;
    DWORD   NumberOfRvaAndSizes;
    IMAGE_DATA_DIRECTORY DataDirectory[16];
} IMAGE_OPTIONAL_HEADER, *PIMAGE_OPTIONAL_HEADER;

typedef struct _IMAGE_ROM_OPTIONAL_HEADER {
    WORD   Magic;
    BYTE   MajorLinkerVersion;
    BYTE   MinorLinkerVersion;
    DWORD  SizeOfCode;
    DWORD  SizeOfInitializedData;
    DWORD  SizeOfUninitializedData;
    DWORD  AddressOfEntryPoint;
    DWORD  BaseOfCode;
    DWORD  BaseOfData;
    DWORD  BaseOfBss;
    DWORD  GprMask;
    DWORD  CprMask[4];
    DWORD  GpValue;
} IMAGE_ROM_OPTIONAL_HEADER, *PIMAGE_ROM_OPTIONAL_HEADER;








typedef struct _IMAGE_NT_HEADERS {
    DWORD Signature;
    IMAGE_FILE_HEADER FileHeader;
    IMAGE_OPTIONAL_HEADER OptionalHeader;
} IMAGE_NT_HEADERS, *PIMAGE_NT_HEADERS;

typedef struct _IMAGE_ROM_HEADERS {
    IMAGE_FILE_HEADER FileHeader;
    IMAGE_ROM_OPTIONAL_HEADER OptionalHeader;
} IMAGE_ROM_HEADERS, *PIMAGE_ROM_HEADERS;






































typedef struct _IMAGE_SECTION_HEADER {
    BYTE    Name[8];
    union {
            DWORD   PhysicalAddress;
            DWORD   VirtualSize;
    } Misc;
    DWORD   VirtualAddress;
    DWORD   SizeOfRawData;
    DWORD   PointerToRawData;
    DWORD   PointerToRelocations;
    DWORD   PointerToLinenumbers;
    WORD    NumberOfRelocations;
    WORD    NumberOfLinenumbers;
    DWORD   Characteristics;
} IMAGE_SECTION_HEADER, *PIMAGE_SECTION_HEADER;


































typedef struct _IMAGE_SYMBOL {
    union {
        BYTE    ShortName[8];
        struct {
            DWORD   Short;     
            DWORD   Long;      
        } Name;
        PBYTE   LongName[2];
    } N;
    DWORD   Value;
    SHORT   SectionNumber;
    WORD    Type;
    BYTE    StorageClass;
    BYTE    NumberOfAuxSymbols;
} IMAGE_SYMBOL;
typedef IMAGE_SYMBOL  *PIMAGE_SYMBOL;





























































































#line 3274 "d:\\msvc20\\include/winnt.h"




#line 3279 "d:\\msvc20\\include/winnt.h"





#line 3285 "d:\\msvc20\\include/winnt.h"




#line 3290 "d:\\msvc20\\include/winnt.h"



#line 3294 "d:\\msvc20\\include/winnt.h"


#line 3297 "d:\\msvc20\\include/winnt.h"





typedef union _IMAGE_AUX_SYMBOL {
    struct {
        DWORD    TagIndex;                      
        union {
            struct {
                WORD    Linenumber;             
                WORD    Size;                   
            } LnSz;
           DWORD    TotalSize;
        } Misc;
        union {
            struct {                            
                DWORD    PointerToLinenumber;
                DWORD    PointerToNextFunction;
            } Function;
            struct {                            
                WORD     Dimension[4];
            } Array;
        } FcnAry;
        WORD    TvIndex;                        
    } Sym;
    struct {
        BYTE    Name[18];
    } File;
    struct {
        DWORD   Length;                         
        WORD    NumberOfRelocations;            
        WORD    NumberOfLinenumbers;            
        DWORD   CheckSum;                       
        SHORT   Number;                         
        BYTE    Selection;                      
    } Section;
} IMAGE_AUX_SYMBOL;
typedef IMAGE_AUX_SYMBOL  *PIMAGE_AUX_SYMBOL;






















typedef struct _IMAGE_RELOCATION {
    DWORD   VirtualAddress;
    DWORD   SymbolTableIndex;
    WORD    Type;
} IMAGE_RELOCATION;
typedef IMAGE_RELOCATION  *PIMAGE_RELOCATION;


























































































typedef struct _IMAGE_BASE_RELOCATION {
    DWORD   VirtualAddress;
    DWORD   SizeOfBlock;

} IMAGE_BASE_RELOCATION, *PIMAGE_BASE_RELOCATION;


















typedef struct _IMAGE_LINENUMBER {
    union {
        DWORD   SymbolTableIndex;               
        DWORD   VirtualAddress;                 
    } Type;
    WORD    Linenumber;                         
} IMAGE_LINENUMBER;
typedef IMAGE_LINENUMBER  *PIMAGE_LINENUMBER;














typedef struct _IMAGE_ARCHIVE_MEMBER_HEADER {
    BYTE     Name[16];                          
    BYTE     Date[12];                          
    BYTE     UserID[6];                         
    BYTE     GroupID[6];                        
    BYTE     Mode[8];                           
    BYTE     Size[10];                          
    BYTE     EndHeader[2];                      
} IMAGE_ARCHIVE_MEMBER_HEADER, *PIMAGE_ARCHIVE_MEMBER_HEADER;











typedef struct _IMAGE_EXPORT_DIRECTORY {
    DWORD   Characteristics;
    DWORD   TimeDateStamp;
    WORD    MajorVersion;
    WORD    MinorVersion;
    DWORD   Name;
    DWORD   Base;
    DWORD   NumberOfFunctions;
    DWORD   NumberOfNames;
    PDWORD  *AddressOfFunctions;
    PDWORD  *AddressOfNames;
    PWORD   *AddressOfNameOrdinals;
} IMAGE_EXPORT_DIRECTORY, *PIMAGE_EXPORT_DIRECTORY;





typedef struct _IMAGE_IMPORT_BY_NAME {
    WORD    Hint;
    BYTE    Name[1];
} IMAGE_IMPORT_BY_NAME, *PIMAGE_IMPORT_BY_NAME;

typedef struct _IMAGE_THUNK_DATA {
    union {
        PDWORD Function;
        DWORD Ordinal;
        PIMAGE_IMPORT_BY_NAME AddressOfData;
    } u1;
} IMAGE_THUNK_DATA, *PIMAGE_THUNK_DATA;





typedef struct _IMAGE_IMPORT_DESCRIPTOR {
    DWORD   Characteristics;
    DWORD   TimeDateStamp;
    DWORD   ForwarderChain;
    DWORD   Name;
    PIMAGE_THUNK_DATA FirstThunk;
} IMAGE_IMPORT_DESCRIPTOR, *PIMAGE_IMPORT_DESCRIPTOR;





typedef void
( *PIMAGE_TLS_CALLBACK) (
    PVOID DllHandle,
    DWORD Reason,
    PVOID Reserved
    );

typedef struct _IMAGE_TLS_DIRECTORY {
    DWORD   StartAddressOfRawData;
    DWORD   EndAddressOfRawData;
    PDWORD  AddressOfIndex;
    PIMAGE_TLS_CALLBACK *AddressOfCallBacks;
    DWORD   SizeOfZeroFill;
    DWORD   Characteristics;
} IMAGE_TLS_DIRECTORY, *PIMAGE_TLS_DIRECTORY;




















typedef struct _IMAGE_RESOURCE_DIRECTORY {
    DWORD   Characteristics;
    DWORD   TimeDateStamp;
    WORD    MajorVersion;
    WORD    MinorVersion;
    WORD    NumberOfNamedEntries;
    WORD    NumberOfIdEntries;

} IMAGE_RESOURCE_DIRECTORY, *PIMAGE_RESOURCE_DIRECTORY;



















typedef struct _IMAGE_RESOURCE_DIRECTORY_ENTRY {
    DWORD   Name;
    DWORD   OffsetToData;
} IMAGE_RESOURCE_DIRECTORY_ENTRY, *PIMAGE_RESOURCE_DIRECTORY_ENTRY;










typedef struct _IMAGE_RESOURCE_DIRECTORY_STRING {
    WORD    Length;
    CHAR    NameString[ 1 ];
} IMAGE_RESOURCE_DIRECTORY_STRING, *PIMAGE_RESOURCE_DIRECTORY_STRING;


typedef struct _IMAGE_RESOURCE_DIR_STRING_U {
    WORD    Length;
    WCHAR   NameString[ 1 ];
} IMAGE_RESOURCE_DIR_STRING_U, *PIMAGE_RESOURCE_DIR_STRING_U;











typedef struct _IMAGE_RESOURCE_DATA_ENTRY {
    DWORD   OffsetToData;
    DWORD   Size;
    DWORD   CodePage;
    DWORD   Reserved;
} IMAGE_RESOURCE_DATA_ENTRY, *PIMAGE_RESOURCE_DATA_ENTRY;





typedef struct _IMAGE_LOAD_CONFIG_DIRECTORY {
    DWORD   Characteristics;
    DWORD   TimeDateStamp;
    WORD    MajorVersion;
    WORD    MinorVersion;
    DWORD   GlobalFlagsClear;
    DWORD   GlobalFlagsSet;
    DWORD   CriticalSectionDefaultTimeout;
    DWORD   DeCommitFreeBlockThreshold;
    DWORD   DeCommitTotalFreeThreshold;
    PVOID   LockPrefixTable;
    DWORD   MaximumAllocationSize;
    DWORD   VirtualMemoryThreshold;
    DWORD   Reserved[ 5 ];
} IMAGE_LOAD_CONFIG_DIRECTORY, *PIMAGE_LOAD_CONFIG_DIRECTORY;









typedef struct _IMAGE_RUNTIME_FUNCTION_ENTRY {
    DWORD BeginAddress;
    DWORD EndAddress;
    PVOID ExceptionHandler;
    PVOID HandlerData;
    DWORD PrologEndAddress;
} IMAGE_RUNTIME_FUNCTION_ENTRY, *PIMAGE_RUNTIME_FUNCTION_ENTRY;





typedef struct _IMAGE_DEBUG_DIRECTORY {
    DWORD   Characteristics;
    DWORD   TimeDateStamp;
    WORD    MajorVersion;
    WORD    MinorVersion;
    DWORD   Type;
    DWORD   SizeOfData;
    DWORD   AddressOfRawData;
    DWORD   PointerToRawData;
} IMAGE_DEBUG_DIRECTORY, *PIMAGE_DEBUG_DIRECTORY;











typedef struct _IMAGE_COFF_SYMBOLS_HEADER {
    DWORD   NumberOfSymbols;
    DWORD   LvaToFirstSymbol;
    DWORD   NumberOfLinenumbers;
    DWORD   LvaToFirstLinenumber;
    DWORD   RvaToFirstByteOfCode;
    DWORD   RvaToLastByteOfCode;
    DWORD   RvaToFirstByteOfData;
    DWORD   RvaToLastByteOfData;
} IMAGE_COFF_SYMBOLS_HEADER, *PIMAGE_COFF_SYMBOLS_HEADER;





typedef struct _FPO_DATA {
    DWORD       ulOffStart;             
    DWORD       cbProcSize;             
    DWORD       cdwLocals;              
    WORD        cdwParams;              
    WORD        cbProlog : 8;           
    WORD        cbRegs   : 3;           
    WORD        fHasSEH  : 1;           
    WORD        fUseBP   : 1;           
    WORD        reserved : 1;           
    WORD        cbFrame  : 2;           
} FPO_DATA, *PFPO_DATA;





typedef struct _IMAGE_DEBUG_MISC {
    DWORD       DataType;               
    DWORD       Length;                 
                                        
    BOOLEAN     Unicode;                
    BYTE        Reserved[ 3 ];
    BYTE        Data[ 1 ];              
} IMAGE_DEBUG_MISC, *PIMAGE_DEBUG_MISC;








typedef struct _IMAGE_FUNCTION_ENTRY {
    DWORD   StartingAddress;
    DWORD   EndingAddress;
    DWORD   EndOfPrologue;
} IMAGE_FUNCTION_ENTRY, *PIMAGE_FUNCTION_ENTRY;





















typedef struct _IMAGE_SEPARATE_DEBUG_HEADER {
    WORD        Signature;
    WORD        Flags;
    WORD        Machine;
    WORD        Characteristics;
    DWORD       TimeDateStamp;
    DWORD       CheckSum;
    DWORD       ImageBase;
    DWORD       SizeOfImage;
    DWORD       NumberOfSections;
    DWORD       ExportedNamesSize;
    DWORD       DebugDirectorySize;
    DWORD       Reserved[ 3 ];          
} IMAGE_SEPARATE_DEBUG_HEADER, *PIMAGE_SEPARATE_DEBUG_HEADER;



#line 1 "d:\\msvc20\\include/poppack.h"



































#line 37 "d:\\msvc20\\include/poppack.h"
#line 3824 "d:\\msvc20\\include/winnt.h"








#line 1 "d:\\msvc20\\include/string.h"































































#line 65 "d:\\msvc20\\include/string.h"



typedef unsigned int size_t;

#line 71 "d:\\msvc20\\include/string.h"










#line 82 "d:\\msvc20\\include/string.h"














 void *  _memccpy(void *, const void *, int, unsigned int);
 void *  memchr(const void *, int, size_t);
	int  memcmp(const void *, const void *, size_t);
 int  _memicmp(const void *, const void *, unsigned int);
	void *  memcpy(void *, const void *, size_t);




 void *  memmove(void *, const void *, size_t);
#line 107 "d:\\msvc20\\include/string.h"
	void *  memset(void *, int, size_t);
	char *  strcat(char *, const char *);
 char *  strchr(const char *, int);
	int  strcmp(const char *, const char *);
 int  _strcmpi(const char *, const char *);
 int  _stricmp(const char *, const char *);
 int  strcoll(const char *, const char *);
 int  _stricoll(const char *, const char *);
 int  _strncoll(const char *, const char *, size_t);
 int  _strnicoll(const char *, const char *, size_t);
	char *  strcpy(char *, const char *);
 size_t  strcspn(const char *, const char *);
 char *  _strdup(const char *);
 char *  _strerror(const char *);
 char *  strerror(int);
	size_t  strlen(const char *);
 char *  _strlwr(char *);
 char *  strncat(char *, const char *, size_t);
 int  strncmp(const char *, const char *, size_t);
 int  _strnicmp(const char *, const char *, size_t);
 char *  strncpy(char *, const char *, size_t);
 char *  _strnset(char *, int, size_t);
 char *  strpbrk(const char *, const char *);
 char *  strrchr(const char *, int);
 char *  _strrev(char *);
	char *  _strset(char *, int);
 size_t  strspn(const char *, const char *);
 char *  strstr(const char *, const char *);
 char *  strtok(char *, const char *);
 char *  _strupr(char *);
 size_t  strxfrm (char *, const char *, size_t);






















 void *  memccpy(void *, const void *, int, unsigned int);
 int  memicmp(const void *, const void *, unsigned int);
 int  strcmpi(const char *, const char *);
 int  stricmp(const char *, const char *);
 char *  strdup(const char *);
 char *  strlwr(char *);
 int  strnicmp(const char *, const char *, size_t);
 char *  strnset(char *, int, size_t);
 char *  strrev(char *);
	char *  strset(char *, int);
 char *  strupr(char *);

#line 173 "d:\\msvc20\\include/string.h"

#line 175 "d:\\msvc20\\include/string.h"






 wchar_t *  wcscat(wchar_t *, const wchar_t *);
 wchar_t *  wcschr(const wchar_t *, wchar_t);
 int  wcscmp(const wchar_t *, const wchar_t *);
 wchar_t *  wcscpy(wchar_t *, const wchar_t *);
 size_t  wcscspn(const wchar_t *, const wchar_t *);
 size_t  wcslen(const wchar_t *);
 wchar_t *  wcsncat(wchar_t *, const wchar_t *, size_t);
 int  wcsncmp(const wchar_t *, const wchar_t *, size_t);
 wchar_t *  wcsncpy(wchar_t *, const wchar_t *, size_t);
 wchar_t *  wcspbrk(const wchar_t *, const wchar_t *);
 wchar_t *  wcsrchr(const wchar_t *, wchar_t);
 size_t  wcsspn(const wchar_t *, const wchar_t *);
 wchar_t *  wcsstr(const wchar_t *, const wchar_t *);
 wchar_t *  wcstok(wchar_t *, const wchar_t *);

 wchar_t *  _wcsdup(const wchar_t *);
 int  _wcsicmp(const wchar_t *, const wchar_t *);
 int  _wcsnicmp(const wchar_t *, const wchar_t *, size_t);
 wchar_t *  _wcsnset(wchar_t *, wchar_t, size_t);
 wchar_t *  _wcsrev(wchar_t *);
 wchar_t *  _wcsset(wchar_t *, wchar_t);

 wchar_t *  _wcslwr(wchar_t *);
 wchar_t *  _wcsupr(wchar_t *);
 size_t  wcsxfrm(wchar_t *, const wchar_t *, size_t);
 int  wcscoll(const wchar_t *, const wchar_t *);
 int  _wcsicoll(const wchar_t *, const wchar_t *);
 int  _wcsncoll(const wchar_t *, const wchar_t *, size_t);
 int  _wcsnicoll(const wchar_t *, const wchar_t *, size_t);






















 wchar_t *  wcsdup(const wchar_t *);
 int  wcsicmp(const wchar_t *, const wchar_t *);
 int  wcsnicmp(const wchar_t *, const wchar_t *, size_t);
 wchar_t *  wcsnset(wchar_t *, wchar_t, size_t);
 wchar_t *  wcsrev(wchar_t *);
 wchar_t *  wcsset(wchar_t *, wchar_t);
 wchar_t *  wcslwr(wchar_t *);
 wchar_t *  wcsupr(wchar_t *);
 int  wcsicoll(const wchar_t *, const wchar_t *);

#line 243 "d:\\msvc20\\include/string.h"

#line 245 "d:\\msvc20\\include/string.h"


#line 248 "d:\\msvc20\\include/string.h"





#line 254 "d:\\msvc20\\include/string.h"
#line 3833 "d:\\msvc20\\include/winnt.h"









































#line 3875 "d:\\msvc20\\include/winnt.h"



void

RtlMoveMemory (
   PVOID Destination,
   const void *Source,
   DWORD Length
   );


void

RtlFillMemory (
   PVOID Destination,
   DWORD Length,
   BYTE  Fill
   );


void

RtlZeroMemory (
   PVOID Destination,
   DWORD Length
   );
#line 3903 "d:\\msvc20\\include/winnt.h"

typedef struct _MESSAGE_RESOURCE_ENTRY {
    WORD   Length;
    WORD   Flags;
    BYTE  Text[ 1 ];
} MESSAGE_RESOURCE_ENTRY, *PMESSAGE_RESOURCE_ENTRY;



typedef struct _MESSAGE_RESOURCE_BLOCK {
    DWORD LowId;
    DWORD HighId;
    DWORD OffsetToEntries;
} MESSAGE_RESOURCE_BLOCK, *PMESSAGE_RESOURCE_BLOCK;

typedef struct _MESSAGE_RESOURCE_DATA {
    DWORD NumberOfBlocks;
    MESSAGE_RESOURCE_BLOCK Blocks[ 1 ];
} MESSAGE_RESOURCE_DATA, *PMESSAGE_RESOURCE_DATA;


typedef struct _RTL_CRITICAL_SECTION_DEBUG {
    WORD   Type;
    WORD   CreatorBackTraceIndex;
    struct _RTL_CRITICAL_SECTION *CriticalSection;
    LIST_ENTRY ProcessLocksList;
    DWORD EntryCount;
    DWORD ContentionCount;
    DWORD Depth;
    PVOID OwnerBackTrace[ 5 ];
} RTL_CRITICAL_SECTION_DEBUG, *PRTL_CRITICAL_SECTION_DEBUG;




typedef struct _RTL_CRITICAL_SECTION {
    PRTL_CRITICAL_SECTION_DEBUG DebugInfo;

    
    
    
    

    LONG LockCount;
    LONG RecursionCount;
    HANDLE OwningThread;        
    HANDLE LockSemaphore;
    DWORD Reserved;
} RTL_CRITICAL_SECTION, *PRTL_CRITICAL_SECTION;











































typedef struct _EVENTLOGRECORD {
    DWORD  Length;        
    DWORD  Reserved;      
    DWORD  RecordNumber;  
    DWORD  TimeGenerated; 
    DWORD  TimeWritten;   
    DWORD  EventID;
    WORD   EventType;
    WORD   NumStrings;
    WORD   EventCategory;
    WORD   ReservedFlags; 
    DWORD  ClosingRecordNumber; 
    DWORD  StringOffset;  
    DWORD  UserSidLength;
    DWORD  UserSidOffset;
    DWORD  DataLength;
    DWORD  DataOffset;    
    
    
    
    
    
    
    
    
    
    
    
} EVENTLOGRECORD, *PEVENTLOGRECORD;
























































                                                    


                                                    


                                                    


                                                    
                                                    














































                                            




























































typedef enum _CM_SERVICE_NODE_TYPE {
    DriverType               = 0x00000001,
    FileSystemType           = 0x00000002,
    Win32ServiceOwnProcess   = 0x00000010,
    Win32ServiceShareProcess = 0x00000020,
    AdapterType              = 0x00000004,
    RecognizerType           = 0x00000008
} SERVICE_NODE_TYPE;

typedef enum _CM_SERVICE_LOAD_TYPE {
    BootLoad    = 0x00000000,
    SystemLoad  = 0x00000001,
    AutoLoad    = 0x00000002,
    DemandLoad  = 0x00000003,
    DisableLoad = 0x00000004
} SERVICE_LOAD_TYPE;

typedef enum _CM_ERROR_CONTROL_TYPE {
    IgnoreError   = 0x00000000,
    NormalError   = 0x00000001,
    SevereError   = 0x00000002,
    CriticalError = 0x00000003
} SERVICE_ERROR_TYPE;









typedef struct _TAPE_ERASE {
    DWORD Type;
    BOOLEAN Immediate;
} TAPE_ERASE, *PTAPE_ERASE;












typedef struct _TAPE_PREPARE {
    DWORD Operation;
    BOOLEAN Immediate;
} TAPE_PREPARE, *PTAPE_PREPARE;










typedef struct _TAPE_WRITE_MARKS {
    DWORD Type;
    DWORD Count;
    BOOLEAN Immediate;
} TAPE_WRITE_MARKS, *PTAPE_WRITE_MARKS;









typedef struct _TAPE_GET_POSITION {
    DWORD Type;
    DWORD Partition;
    LARGE_INTEGER Offset;
} TAPE_GET_POSITION, *PTAPE_GET_POSITION;
















typedef struct _TAPE_SET_POSITION {
    DWORD Method;
    DWORD Partition;
    LARGE_INTEGER Offset;
    BOOLEAN Immediate;
} TAPE_SET_POSITION, *PTAPE_SET_POSITION;



















































































typedef struct _TAPE_GET_DRIVE_PARAMETERS {
    BOOLEAN ECC;
    BOOLEAN Compression;
    BOOLEAN DataPadding;
    BOOLEAN ReportSetmarks;
    DWORD DefaultBlockSize;
    DWORD MaximumBlockSize;
    DWORD MinimumBlockSize;
    DWORD MaximumPartitionCount;
    DWORD FeaturesLow;
    DWORD FeaturesHigh;
    DWORD EOTWarningZoneSize;
} TAPE_GET_DRIVE_PARAMETERS, *PTAPE_GET_DRIVE_PARAMETERS;





typedef struct _TAPE_SET_DRIVE_PARAMETERS {
    BOOLEAN ECC;
    BOOLEAN Compression;
    BOOLEAN DataPadding;
    BOOLEAN ReportSetmarks;
    DWORD EOTWarningZoneSize;
} TAPE_SET_DRIVE_PARAMETERS, *PTAPE_SET_DRIVE_PARAMETERS;





typedef struct _TAPE_GET_MEDIA_PARAMETERS {
    LARGE_INTEGER Capacity;
    LARGE_INTEGER Remaining;
    DWORD BlockSize;
    DWORD PartitionCount;
    BOOLEAN WriteProtected;
} TAPE_GET_MEDIA_PARAMETERS, *PTAPE_GET_MEDIA_PARAMETERS;





typedef struct _TAPE_SET_MEDIA_PARAMETERS {
    DWORD BlockSize;
} TAPE_SET_MEDIA_PARAMETERS, *PTAPE_SET_MEDIA_PARAMETERS;









typedef struct _TAPE_CREATE_PARTITION {
    DWORD Method;
    DWORD Count;
    DWORD Size;
} TAPE_CREATE_PARTITION, *PTAPE_CREATE_PARTITION;






#line 4450 "d:\\msvc20\\include/winnt.h"

#line 139 "d:\\msvc20\\include/windef.h"
#line 140 "d:\\msvc20\\include/windef.h"


typedef UINT WPARAM;
typedef LONG LPARAM;
typedef LONG LRESULT;






















typedef HANDLE HWND;
typedef HANDLE HHOOK;
#line 170 "d:\\msvc20\\include/windef.h"

typedef WORD                ATOM;

typedef HANDLE          *SPHANDLE;
typedef HANDLE           *LPHANDLE;
typedef HANDLE              HGLOBAL;
typedef HANDLE              HLOCAL;
typedef HANDLE              GLOBALHANDLE;
typedef HANDLE              LOCALHANDLE;
typedef int (  *FARPROC)();
typedef int (  *NEARPROC)();
typedef int ( *PROC)();




typedef HANDLE HGDIOBJ;
#line 188 "d:\\msvc20\\include/windef.h"

typedef HANDLE HACCEL;
typedef HANDLE HBITMAP;
typedef HANDLE HBRUSH;
typedef HANDLE HDC;
typedef HANDLE HGLRC;            
typedef HANDLE HDESK;
typedef HANDLE HENHMETAFILE;
typedef HANDLE HFONT;
typedef HANDLE HICON;
typedef HANDLE HMENU;
typedef HANDLE HMETAFILE;
typedef HANDLE HINSTANCE;
typedef HINSTANCE HMODULE;      
typedef HANDLE HPALETTE;
typedef HANDLE HPEN;
typedef HANDLE HRGN;
typedef HANDLE HRSRC;
typedef HANDLE HSTR;
typedef HANDLE HTASK;
typedef HANDLE HWINSTA;
typedef HANDLE HKL;

typedef int HFILE;
typedef HICON HCURSOR;      

typedef DWORD   COLORREF;
typedef DWORD   *LPCOLORREF;



typedef struct tagRECT
{
    LONG    left;
    LONG    top;
    LONG    right;
    LONG    bottom;
} RECT, *PRECT,  *NPRECT,  *LPRECT;

typedef struct _RECTL       
{
    LONG    left;
    LONG    top;
    LONG    right;
    LONG    bottom;
} RECTL, *PRECTL, *LPRECTL;

typedef struct tagPOINT
{
    LONG  x;
    LONG  y;
} POINT, *PPOINT,  *NPPOINT,  *LPPOINT;

typedef struct _POINTL      
{
    LONG  x;
    LONG  y;
} POINTL, *PPOINTL;

typedef struct tagSIZE
{
    LONG        cx;
    LONG        cy;
} SIZE, *PSIZE, *LPSIZE;

typedef SIZE               SIZEL;
typedef SIZE               *PSIZEL, *LPSIZEL;

typedef struct tagPOINTS
{
    SHORT   x;
    SHORT   y;
} POINTS, *PPOINTS, *LPPOINTS;




































#line 298 "d:\\msvc20\\include/windef.h"
#line 107 "d:\\msvc20\\include/windows.h"
#line 1 "d:\\msvc20\\include/winbase.h"































#line 33 "d:\\msvc20\\include/winbase.h"





#line 39 "d:\\msvc20\\include/winbase.h"












































































































































typedef struct _OVERLAPPED {
    DWORD   Internal;
    DWORD   InternalHigh;
    DWORD   Offset;
    DWORD   OffsetHigh;
    HANDLE  hEvent;
} OVERLAPPED, *LPOVERLAPPED;

typedef struct _SECURITY_ATTRIBUTES {
    DWORD nLength;
    LPVOID lpSecurityDescriptor;
    BOOL bInheritHandle;
} SECURITY_ATTRIBUTES, *PSECURITY_ATTRIBUTES, *LPSECURITY_ATTRIBUTES;

typedef struct _PROCESS_INFORMATION {
    HANDLE hProcess;
    HANDLE hThread;
    DWORD dwProcessId;
    DWORD dwThreadId;
} PROCESS_INFORMATION, *PPROCESS_INFORMATION, *LPPROCESS_INFORMATION;





typedef struct _FILETIME {
    DWORD dwLowDateTime;
    DWORD dwHighDateTime;
} FILETIME, *PFILETIME, *LPFILETIME;





typedef struct _SYSTEMTIME {
    WORD wYear;
    WORD wMonth;
    WORD wDayOfWeek;
    WORD wDay;
    WORD wHour;
    WORD wMinute;
    WORD wSecond;
    WORD wMilliseconds;
} SYSTEMTIME, *PSYSTEMTIME, *LPSYSTEMTIME;

typedef DWORD ( *PTHREAD_START_ROUTINE)(
    LPVOID lpThreadParameter
    );
typedef PTHREAD_START_ROUTINE LPTHREAD_START_ROUTINE;

typedef RTL_CRITICAL_SECTION CRITICAL_SECTION;
typedef PRTL_CRITICAL_SECTION PCRITICAL_SECTION;
typedef PRTL_CRITICAL_SECTION LPCRITICAL_SECTION;

typedef RTL_CRITICAL_SECTION_DEBUG CRITICAL_SECTION_DEBUG;
typedef PRTL_CRITICAL_SECTION_DEBUG PCRITICAL_SECTION_DEBUG;
typedef PRTL_CRITICAL_SECTION_DEBUG LPCRITICAL_SECTION_DEBUG;




typedef LPVOID LPLDT_ENTRY;
#line 242 "d:\\msvc20\\include/winbase.h"









































































































typedef struct _COMMPROP {
    WORD wPacketLength;
    WORD wPacketVersion;
    DWORD dwServiceMask;
    DWORD dwReserved1;
    DWORD dwMaxTxQueue;
    DWORD dwMaxRxQueue;
    DWORD dwMaxBaud;
    DWORD dwProvSubType;
    DWORD dwProvCapabilities;
    DWORD dwSettableParams;
    DWORD dwSettableBaud;
    WORD wSettableData;
    WORD wSettableStopParity;
    DWORD dwCurrentTxQueue;
    DWORD dwCurrentRxQueue;
    DWORD dwProvSpec1;
    DWORD dwProvSpec2;
    WCHAR wcProvChar[1];
} COMMPROP,*LPCOMMPROP;







typedef struct _COMSTAT {
    DWORD fCtsHold : 1;
    DWORD fDsrHold : 1;
    DWORD fRlsdHold : 1;
    DWORD fXoffHold : 1;
    DWORD fXoffSent : 1;
    DWORD fEof : 1;
    DWORD fTxim : 1;
    DWORD fReserved : 25;
    DWORD cbInQue;
    DWORD cbOutQue;
} COMSTAT, *LPCOMSTAT;
















typedef struct _DCB {
    DWORD DCBlength;      
    DWORD BaudRate;       
    DWORD fBinary: 1;     
    DWORD fParity: 1;     
    DWORD fOutxCtsFlow:1; 
    DWORD fOutxDsrFlow:1; 
    DWORD fDtrControl:2;  
    DWORD fDsrSensitivity:1; 
    DWORD fTXContinueOnXoff: 1; 
    DWORD fOutX: 1;       
    DWORD fInX: 1;        
    DWORD fErrorChar: 1;  
    DWORD fNull: 1;       
    DWORD fRtsControl:2;  
    DWORD fAbortOnError:1; 
    DWORD fDummy2:17;     
    WORD wReserved;       
    WORD XonLim;          
    WORD XoffLim;         
    BYTE ByteSize;        
    BYTE Parity;          
    BYTE StopBits;        
    char XonChar;         
    char XoffChar;        
    char ErrorChar;       
    char EofChar;         
    char EvtChar;         
    WORD wReserved1;      
} DCB, *LPDCB;

typedef struct _COMMTIMEOUTS {
    DWORD ReadIntervalTimeout;          
    DWORD ReadTotalTimeoutMultiplier;   
    DWORD ReadTotalTimeoutConstant;     
    DWORD WriteTotalTimeoutMultiplier;  
    DWORD WriteTotalTimeoutConstant;    
} COMMTIMEOUTS,*LPCOMMTIMEOUTS;

typedef struct _COMMCONFIG {
    DWORD dwSize;               
    WORD wVersion;              
    WORD wReserved;             
    DCB dcb;                    
    DWORD dwProviderSubType;    

    DWORD dwProviderOffset;     

    DWORD dwProviderSize;       
    WCHAR wcProviderData[1];    
} COMMCONFIG,*LPCOMMCONFIG;

typedef struct _SYSTEM_INFO {
    DWORD dwOemId;
    DWORD dwPageSize;
    LPVOID lpMinimumApplicationAddress;
    LPVOID lpMaximumApplicationAddress;
    DWORD dwActiveProcessorMask;
    DWORD dwNumberOfProcessors;
    DWORD dwProcessorType;
    DWORD dwAllocationGranularity;
    DWORD dwReserved;
} SYSTEM_INFO, *LPSYSTEM_INFO;
































typedef struct _MEMORYSTATUS {
    DWORD dwLength;
    DWORD dwMemoryLoad;
    DWORD dwTotalPhys;
    DWORD dwAvailPhys;
    DWORD dwTotalPageFile;
    DWORD dwAvailPageFile;
    DWORD dwTotalVirtual;
    DWORD dwAvailVirtual;
} MEMORYSTATUS, *LPMEMORYSTATUS;









































































typedef struct _EXCEPTION_DEBUG_INFO {
    EXCEPTION_RECORD ExceptionRecord;
    DWORD dwFirstChance;
} EXCEPTION_DEBUG_INFO, *LPEXCEPTION_DEBUG_INFO;

typedef struct _CREATE_THREAD_DEBUG_INFO {
    HANDLE hThread;
    LPVOID lpThreadLocalBase;
    LPTHREAD_START_ROUTINE lpStartAddress;
} CREATE_THREAD_DEBUG_INFO, *LPCREATE_THREAD_DEBUG_INFO;

typedef struct _CREATE_PROCESS_DEBUG_INFO {
    HANDLE hFile;
    HANDLE hProcess;
    HANDLE hThread;
    LPVOID lpBaseOfImage;
    DWORD dwDebugInfoFileOffset;
    DWORD nDebugInfoSize;
    LPVOID lpThreadLocalBase;
    LPTHREAD_START_ROUTINE lpStartAddress;
    LPVOID lpImageName;
    WORD fUnicode;
} CREATE_PROCESS_DEBUG_INFO, *LPCREATE_PROCESS_DEBUG_INFO;

typedef struct _EXIT_THREAD_DEBUG_INFO {
    DWORD dwExitCode;
} EXIT_THREAD_DEBUG_INFO, *LPEXIT_THREAD_DEBUG_INFO;

typedef struct _EXIT_PROCESS_DEBUG_INFO {
    DWORD dwExitCode;
} EXIT_PROCESS_DEBUG_INFO, *LPEXIT_PROCESS_DEBUG_INFO;

typedef struct _LOAD_DLL_DEBUG_INFO {
    HANDLE hFile;
    LPVOID lpBaseOfDll;
    DWORD dwDebugInfoFileOffset;
    DWORD nDebugInfoSize;
    LPVOID lpImageName;
    WORD fUnicode;
} LOAD_DLL_DEBUG_INFO, *LPLOAD_DLL_DEBUG_INFO;

typedef struct _UNLOAD_DLL_DEBUG_INFO {
    LPVOID lpBaseOfDll;
} UNLOAD_DLL_DEBUG_INFO, *LPUNLOAD_DLL_DEBUG_INFO;

typedef struct _OUTPUT_DEBUG_STRING_INFO {
    LPSTR lpDebugStringData;
    WORD fUnicode;
    WORD nDebugStringLength;
} OUTPUT_DEBUG_STRING_INFO, *LPOUTPUT_DEBUG_STRING_INFO;

typedef struct _RIP_INFO {
    DWORD dwError;
    DWORD dwType;
} RIP_INFO, *LPRIP_INFO;


typedef struct _DEBUG_EVENT {
    DWORD dwDebugEventCode;
    DWORD dwProcessId;
    DWORD dwThreadId;
    union {
        EXCEPTION_DEBUG_INFO Exception;
        CREATE_THREAD_DEBUG_INFO CreateThread;
        CREATE_PROCESS_DEBUG_INFO CreateProcessInfo;
        EXIT_THREAD_DEBUG_INFO ExitThread;
        EXIT_THREAD_DEBUG_INFO ExitProcess;
        LOAD_DLL_DEBUG_INFO LoadDll;
        UNLOAD_DLL_DEBUG_INFO UnloadDll;
        OUTPUT_DEBUG_STRING_INFO DebugString;
        RIP_INFO RipInfo;
    } u;
} DEBUG_EVENT, *LPDEBUG_EVENT;

typedef PCONTEXT LPCONTEXT;
typedef PEXCEPTION_RECORD LPEXCEPTION_RECORD;
typedef PEXCEPTION_POINTERS LPEXCEPTION_POINTERS;

























































































































































































































typedef struct _OFSTRUCT {
    BYTE cBytes;
    BYTE fFixedDisk;
    WORD nErrCode;
    WORD Reserved1;
    WORD Reserved2;
    CHAR szPathName[128];
} OFSTRUCT, *LPOFSTRUCT, *POFSTRUCT;



































#line 918 "d:\\msvc20\\include/winbase.h"


LONG

InterlockedIncrement(
    LPLONG lpAddend
    );


LONG

InterlockedDecrement(
    LPLONG lpAddend
    );


LONG

InterlockedExchange(
    LPLONG Target,
    LONG Value
    );

#line 942 "d:\\msvc20\\include/winbase.h"


BOOL

FreeResource(
        HGLOBAL hResData
        );


LPVOID

LockResource(
        HGLOBAL hResData
        );






int

WinMain(
    HINSTANCE hInstance,
    HINSTANCE hPrevInstance,
    LPSTR lpCmdLine,
    int nShowCmd
    );


BOOL

FreeLibrary(
    HINSTANCE hLibModule
    );



void

FreeLibraryAndExitThread(
    HMODULE hLibModule,
    DWORD dwExitCode
    );


BOOL

DisableThreadLibraryCalls(
    HMODULE hLibModule
    );


FARPROC

GetProcAddress(
    HINSTANCE hModule,
    LPCSTR lpProcName
    );


DWORD

GetVersion( void );


HGLOBAL

GlobalAlloc(
    UINT uFlags,
    DWORD dwBytes
    );


HGLOBAL

GlobalReAlloc(
    HGLOBAL hMem,
    DWORD dwBytes,
    UINT uFlags
    );


DWORD

GlobalSize(
    HGLOBAL hMem
    );


UINT

GlobalFlags(
    HGLOBAL hMem
    );



LPVOID

GlobalLock(
    HGLOBAL hMem
    );



HGLOBAL

GlobalHandle(
    LPCVOID pMem
    );



BOOL

GlobalUnlock(
    HGLOBAL hMem
    );



HGLOBAL

GlobalFree(
    HGLOBAL hMem
    );


UINT

GlobalCompact(
    DWORD dwMinFree
    );


void

GlobalFix(
    HGLOBAL hMem
    );


void

GlobalUnfix(
    HGLOBAL hMem
    );


LPVOID

GlobalWire(
    HGLOBAL hMem
    );


BOOL

GlobalUnWire(
    HGLOBAL hMem
    );


void

GlobalMemoryStatus(
    LPMEMORYSTATUS lpBuffer
    );


HLOCAL

LocalAlloc(
    UINT uFlags,
    UINT uBytes
    );


HLOCAL

LocalReAlloc(
    HLOCAL hMem,
    UINT uBytes,
    UINT uFlags
    );


LPVOID

LocalLock(
    HLOCAL hMem
    );


HLOCAL

LocalHandle(
    LPCVOID pMem
    );


BOOL

LocalUnlock(
    HLOCAL hMem
    );


UINT

LocalSize(
    HLOCAL hMem
    );


UINT

LocalFlags(
    HLOCAL hMem
    );


HLOCAL

LocalFree(
    HLOCAL hMem
    );


UINT

LocalShrink(
    HLOCAL hMem,
    UINT cbNewSize
    );


UINT

LocalCompact(
    UINT uMinFree
    );


BOOL

FlushInstructionCache(
    HANDLE hProcess,
    LPCVOID lpBaseAddress,
    DWORD dwSize
    );


LPVOID

VirtualAlloc(
    LPVOID lpAddress,
    DWORD dwSize,
    DWORD flAllocationType,
    DWORD flProtect
    );


BOOL

VirtualFree(
    LPVOID lpAddress,
    DWORD dwSize,
    DWORD dwFreeType
    );


BOOL

VirtualProtect(
    LPVOID lpAddress,
    DWORD dwSize,
    DWORD flNewProtect,
    PDWORD lpflOldProtect
    );


DWORD

VirtualQuery(
    LPCVOID lpAddress,
    PMEMORY_BASIC_INFORMATION lpBuffer,
    DWORD dwLength
    );


BOOL

VirtualProtectEx(
    HANDLE hProcess,
    LPVOID lpAddress,
    DWORD dwSize,
    DWORD flNewProtect,
    PDWORD lpflOldProtect
    );


DWORD

VirtualQueryEx(
    HANDLE hProcess,
    LPCVOID lpAddress,
    PMEMORY_BASIC_INFORMATION lpBuffer,
    DWORD dwLength
    );


HANDLE

HeapCreate(
    DWORD flOptions,
    DWORD dwInitialSize,
    DWORD dwMaximumSize
    );


BOOL

HeapDestroy(
    HANDLE hHeap
    );


LPVOID

HeapAlloc(
    HANDLE hHeap,
    DWORD dwFlags,
    DWORD dwBytes
    );


LPVOID

HeapReAlloc(
    HANDLE hHeap,
    DWORD dwFlags,
    LPVOID lpMem,
    DWORD dwBytes
    );


BOOL

HeapFree(
    HANDLE hHeap,
    DWORD dwFlags,
    LPVOID lpMem
    );


DWORD

HeapSize(
    HANDLE hHeap,
    DWORD dwFlags,
    LPCVOID lpMem
    );


BOOL

HeapValidate(
    HANDLE hHeap,
    DWORD dwFlags,
    LPCVOID lpMem
    );


UINT

HeapCompact(
    HANDLE hHeap,
    DWORD dwFlags
    );


HANDLE

GetProcessHeap( void );


DWORD

GetProcessHeaps(
    DWORD NumberOfHeaps,
    PHANDLE ProcessHeaps
    );

typedef struct _PROCESS_HEAP_ENTRY {
    PVOID lpData;
    DWORD cbData;
    BYTE cbOverhead;
    BYTE iRegionIndex;
    WORD wFlags;
    union {
        struct {
            HANDLE hMem;
            DWORD dwReserved[ 3 ];
        } Block;
        struct {
            DWORD dwCommittedSize;
            DWORD dwUnCommittedSize;
            LPVOID lpFirstBlock;
            LPVOID lpLastBlock;
        } Region;
    };
} PROCESS_HEAP_ENTRY, *LPPROCESS_HEAP_ENTRY, *PPROCESS_HEAP_ENTRY;








BOOL

HeapLock(
    HANDLE hHeap
    );


BOOL

HeapUnlock(
    HANDLE hHeap
    );


BOOL

HeapWalk(
    HANDLE hHeap,
    LPPROCESS_HEAP_ENTRY lpEntry
    );











BOOL

GetBinaryTypeA(
    LPCSTR lpApplicationName,
    LPDWORD lpBinaryType
    );

BOOL

GetBinaryTypeW(
    LPCWSTR lpApplicationName,
    LPDWORD lpBinaryType
    );




#line 1413 "d:\\msvc20\\include/winbase.h"


DWORD

GetShortPathNameA(
    LPCSTR lpszLongPath,
    LPSTR  lpszShortPath,
    DWORD    cchBuffer
    );

DWORD

GetShortPathNameW(
    LPCWSTR lpszLongPath,
    LPWSTR  lpszShortPath,
    DWORD    cchBuffer
    );




#line 1435 "d:\\msvc20\\include/winbase.h"


BOOL

GetProcessAffinityMask(
    HANDLE hProcess,
    LPDWORD lpProcessAffinityMask,
    LPDWORD lpSystemAffinityMask
    );


BOOL

GetProcessTimes(
    HANDLE hProcess,
    LPFILETIME lpCreationTime,
    LPFILETIME lpExitTime,
    LPFILETIME lpKernelTime,
    LPFILETIME lpUserTime
    );


BOOL

GetProcessWorkingSetSize(
    HANDLE hProcess,
    LPDWORD lpMinimumWorkingSetSize,
    LPDWORD lpMaximumWorkingSetSize
    );


BOOL

SetProcessWorkingSetSize(
    HANDLE hProcess,
    DWORD dwMinimumWorkingSetSize,
    DWORD dwMaximumWorkingSetSize
    );


HANDLE

OpenProcess(
    DWORD dwDesiredAccess,
    BOOL bInheritHandle,
    DWORD dwProcessId
    );


HANDLE

GetCurrentProcess(
    void
    );


DWORD

GetCurrentProcessId(
    void
    );


void

ExitProcess(
    UINT uExitCode
    );


BOOL

TerminateProcess(
    HANDLE hProcess,
    UINT uExitCode
    );


BOOL

GetExitCodeProcess(
    HANDLE hProcess,
    LPDWORD lpExitCode
    );



void

FatalExit(
    int ExitCode
    );


LPSTR

GetEnvironmentStrings(
    void
    );


LPWSTR

GetEnvironmentStringsW(
    void
    );





#line 1547 "d:\\msvc20\\include/winbase.h"


BOOL

FreeEnvironmentStringsA(
    LPSTR
    );

BOOL

FreeEnvironmentStringsW(
    LPWSTR
    );




#line 1565 "d:\\msvc20\\include/winbase.h"


void

RaiseException(
    DWORD dwExceptionCode,
    DWORD dwExceptionFlags,
    DWORD nNumberOfArguments,
    const DWORD *lpArguments
    );


LONG

UnhandledExceptionFilter(
    struct _EXCEPTION_POINTERS *ExceptionInfo
    );

typedef LONG ( *PTOP_LEVEL_EXCEPTION_FILTER)(
    struct _EXCEPTION_POINTERS *ExceptionInfo
    );
typedef PTOP_LEVEL_EXCEPTION_FILTER LPTOP_LEVEL_EXCEPTION_FILTER;


LPTOP_LEVEL_EXCEPTION_FILTER

SetUnhandledExceptionFilter(
    LPTOP_LEVEL_EXCEPTION_FILTER lpTopLevelExceptionFilter
    );


HANDLE

CreateThread(
    LPSECURITY_ATTRIBUTES lpThreadAttributes,
    DWORD dwStackSize,
    LPTHREAD_START_ROUTINE lpStartAddress,
    LPVOID lpParameter,
    DWORD dwCreationFlags,
    LPDWORD lpThreadId
    );


HANDLE

CreateRemoteThread(
    HANDLE hProcess,
    LPSECURITY_ATTRIBUTES lpThreadAttributes,
    DWORD dwStackSize,
    LPTHREAD_START_ROUTINE lpStartAddress,
    LPVOID lpParameter,
    DWORD dwCreationFlags,
    LPDWORD lpThreadId
    );


HANDLE

GetCurrentThread(
    void
    );


DWORD

GetCurrentThreadId(
    void
    );


DWORD

SetThreadAffinityMask(
    HANDLE hThread,
    DWORD dwThreadAffinityMask
    );


BOOL

SetThreadPriority(
    HANDLE hThread,
    int nPriority
    );


int

GetThreadPriority(
    HANDLE hThread
    );


BOOL

GetThreadTimes(
    HANDLE hThread,
    LPFILETIME lpCreationTime,
    LPFILETIME lpExitTime,
    LPFILETIME lpKernelTime,
    LPFILETIME lpUserTime
    );


void

ExitThread(
    DWORD dwExitCode
    );


BOOL

TerminateThread(
    HANDLE hThread,
    DWORD dwExitCode
    );


BOOL

GetExitCodeThread(
    HANDLE hThread,
    LPDWORD lpExitCode
    );


BOOL

GetThreadSelectorEntry(
    HANDLE hThread,
    DWORD dwSelector,
    LPLDT_ENTRY lpSelectorEntry
    );


DWORD

GetLastError(
    void
    );


void

SetLastError(
    DWORD dwErrCode
    );


BOOL

GetOverlappedResult(
    HANDLE hFile,
    LPOVERLAPPED lpOverlapped,
    LPDWORD lpNumberOfBytesTransferred,
    BOOL bWait
    );


HANDLE

CreateIoCompletionPort(
    HANDLE FileHandle,
    HANDLE ExistingCompletionPort,
    DWORD CompletionKey,
    DWORD NumberOfConcurrentThreads
    );


BOOL

GetQueuedCompletionStatus(
    HANDLE CompletionPort,
    LPDWORD lpNumberOfBytesTransferred,
    LPDWORD lpCompletionKey,
    LPOVERLAPPED *lpOverlapped,
    DWORD dwMilliseconds
    );







UINT

SetErrorMode(
    UINT uMode
    );


BOOL

ReadProcessMemory(
    HANDLE hProcess,
    LPCVOID lpBaseAddress,
    LPVOID lpBuffer,
    DWORD nSize,
    LPDWORD lpNumberOfBytesRead
    );


BOOL

WriteProcessMemory(
    HANDLE hProcess,
    LPVOID lpBaseAddress,
    LPVOID lpBuffer,
    DWORD nSize,
    LPDWORD lpNumberOfBytesWritten
    );


BOOL

GetThreadContext(
    HANDLE hThread,
    LPCONTEXT lpContext
    );


BOOL

SetThreadContext(
    HANDLE hThread,
    const CONTEXT *lpContext
    );


DWORD

SuspendThread(
    HANDLE hThread
    );


DWORD

ResumeThread(
    HANDLE hThread
    );


void

DebugBreak(
    void
    );


BOOL

WaitForDebugEvent(
    LPDEBUG_EVENT lpDebugEvent,
    DWORD dwMilliseconds
    );


BOOL

ContinueDebugEvent(
    DWORD dwProcessId,
    DWORD dwThreadId,
    DWORD dwContinueStatus
    );


BOOL

DebugActiveProcess(
    DWORD dwProcessId
    );


void

InitializeCriticalSection(
    LPCRITICAL_SECTION lpCriticalSection
    );


void

EnterCriticalSection(
    LPCRITICAL_SECTION lpCriticalSection
    );


void

LeaveCriticalSection(
    LPCRITICAL_SECTION lpCriticalSection
    );


void

DeleteCriticalSection(
    LPCRITICAL_SECTION lpCriticalSection
    );


BOOL

SetEvent(
    HANDLE hEvent
    );


BOOL

ResetEvent(
    HANDLE hEvent
    );


BOOL

PulseEvent(
    HANDLE hEvent
    );


BOOL

ReleaseSemaphore(
    HANDLE hSemaphore,
    LONG lReleaseCount,
    LPLONG lpPreviousCount
    );


BOOL

ReleaseMutex(
    HANDLE hMutex
    );


DWORD

WaitForSingleObject(
    HANDLE hHandle,
    DWORD dwMilliseconds
    );


DWORD

WaitForMultipleObjects(
    DWORD nCount,
    const HANDLE *lpHandles,
    BOOL bWaitAll,
    DWORD dwMilliseconds
    );


void

Sleep(
    DWORD dwMilliseconds
    );


HGLOBAL

LoadResource(
    HINSTANCE hModule,
    HRSRC hResInfo
    );


DWORD

SizeofResource(
    HINSTANCE hModule,
    HRSRC hResInfo
    );



ATOM

GlobalDeleteAtom(
    ATOM nAtom
    );


BOOL

InitAtomTable(
    DWORD nSize
    );


ATOM

DeleteAtom(
    ATOM nAtom
    );


UINT

SetHandleCount(
    UINT uNumber
    );


DWORD

GetLogicalDrives(
    void
    );


BOOL

LockFile(
    HANDLE hFile,
    DWORD dwFileOffsetLow,
    DWORD dwFileOffsetHigh,
    DWORD nNumberOfBytesToLockLow,
    DWORD nNumberOfBytesToLockHigh
    );


BOOL

UnlockFile(
    HANDLE hFile,
    DWORD dwFileOffsetLow,
    DWORD dwFileOffsetHigh,
    DWORD nNumberOfBytesToUnlockLow,
    DWORD nNumberOfBytesToUnlockHigh
    );


BOOL

LockFileEx(
    HANDLE hFile,
    DWORD dwFlags,
    DWORD dwReserved,
    DWORD nNumberOfBytesToLockLow,
    DWORD nNumberOfBytesToLockHigh,
    LPOVERLAPPED lpOverlapped
    );





BOOL

UnlockFileEx(
    HANDLE hFile,
    DWORD dwReserved,
    DWORD nNumberOfBytesToUnlockLow,
    DWORD nNumberOfBytesToUnlockHigh,
    LPOVERLAPPED lpOverlapped
    );

typedef struct _BY_HANDLE_FILE_INFORMATION {
    DWORD dwFileAttributes;
    FILETIME ftCreationTime;
    FILETIME ftLastAccessTime;
    FILETIME ftLastWriteTime;
    DWORD dwVolumeSerialNumber;
    DWORD nFileSizeHigh;
    DWORD nFileSizeLow;
    DWORD nNumberOfLinks;
    DWORD nFileIndexHigh;
    DWORD nFileIndexLow;
} BY_HANDLE_FILE_INFORMATION, *PBY_HANDLE_FILE_INFORMATION, *LPBY_HANDLE_FILE_INFORMATION;


BOOL

GetFileInformationByHandle(
    HANDLE hFile,
    LPBY_HANDLE_FILE_INFORMATION lpFileInformation
    );


DWORD

GetFileType(
    HANDLE hFile
    );


DWORD

GetFileSize(
    HANDLE hFile,
    LPDWORD lpFileSizeHigh
    );


HANDLE

GetStdHandle(
    DWORD nStdHandle
    );


BOOL

SetStdHandle(
    DWORD nStdHandle,
    HANDLE hHandle
    );


BOOL

WriteFile(
    HANDLE hFile,
    LPCVOID lpBuffer,
    DWORD nNumberOfBytesToWrite,
    LPDWORD lpNumberOfBytesWritten,
    LPOVERLAPPED lpOverlapped
    );


BOOL

ReadFile(
    HANDLE hFile,
    LPVOID lpBuffer,
    DWORD nNumberOfBytesToRead,
    LPDWORD lpNumberOfBytesRead,
    LPOVERLAPPED lpOverlapped
    );


BOOL

FlushFileBuffers(
    HANDLE hFile
    );


BOOL

DeviceIoControl(
    HANDLE hDevice,
    DWORD dwIoControlCode,
    LPVOID lpInBuffer,
    DWORD nInBufferSize,
    LPVOID lpOutBuffer,
    DWORD nOutBufferSize,
    LPDWORD lpBytesReturned,
    LPOVERLAPPED lpOverlapped
    );


BOOL

SetEndOfFile(
    HANDLE hFile
    );


DWORD

SetFilePointer(
    HANDLE hFile,
    LONG lDistanceToMove,
    PLONG lpDistanceToMoveHigh,
    DWORD dwMoveMethod
    );


BOOL

FindClose(
    HANDLE hFindFile
    );


BOOL

GetFileTime(
    HANDLE hFile,
    LPFILETIME lpCreationTime,
    LPFILETIME lpLastAccessTime,
    LPFILETIME lpLastWriteTime
    );


BOOL

SetFileTime(
    HANDLE hFile,
    const FILETIME *lpCreationTime,
    const FILETIME *lpLastAccessTime,
    const FILETIME *lpLastWriteTime
    );


BOOL

CloseHandle(
    HANDLE hObject
    );


BOOL

DuplicateHandle(
    HANDLE hSourceProcessHandle,
    HANDLE hSourceHandle,
    HANDLE hTargetProcessHandle,
    LPHANDLE lpTargetHandle,
    DWORD dwDesiredAccess,
    BOOL bInheritHandle,
    DWORD dwOptions
    );


BOOL

GetHandleInformation(
    HANDLE hObject,
    LPDWORD lpdwFlags
    );


BOOL

SetHandleInformation(
    HANDLE hObject,
    DWORD dwMask,
    DWORD dwFlags
    );







DWORD

LoadModule(
    LPCSTR lpModuleName,
    LPVOID lpParameterBlock
    );


UINT

WinExec(
    LPCSTR lpCmdLine,
    UINT uCmdShow
    );


BOOL

ClearCommBreak(
    HANDLE hFile
    );


BOOL

ClearCommError(
    HANDLE hFile,
    LPDWORD lpErrors,
    LPCOMSTAT lpStat
    );


BOOL

SetupComm(
    HANDLE hFile,
    DWORD dwInQueue,
    DWORD dwOutQueue
    );


BOOL

EscapeCommFunction(
    HANDLE hFile,
    DWORD dwFunc
    );


BOOL

GetCommConfig(
    HANDLE hCommDev,
    LPCOMMCONFIG lpCC,
    LPDWORD lpdwSize
    );


BOOL

GetCommMask(
    HANDLE hFile,
    LPDWORD lpEvtMask
    );


BOOL

GetCommProperties(
    HANDLE hFile,
    LPCOMMPROP lpCommProp
    );


BOOL

GetCommModemStatus(
    HANDLE hFile,
    LPDWORD lpModemStat
    );


BOOL

GetCommState(
    HANDLE hFile,
    LPDCB lpDCB
    );


BOOL

GetCommTimeouts(
    HANDLE hFile,
    LPCOMMTIMEOUTS lpCommTimeouts
    );


BOOL

PurgeComm(
    HANDLE hFile,
    DWORD dwFlags
    );


BOOL

SetCommBreak(
    HANDLE hFile
    );


BOOL

SetCommConfig(
    HANDLE hCommDev,
    LPCOMMCONFIG lpCC,
    DWORD dwSize
    );


BOOL

SetCommMask(
    HANDLE hFile,
    DWORD dwEvtMask
    );


BOOL

SetCommState(
    HANDLE hFile,
    LPDCB lpDCB
    );


BOOL

SetCommTimeouts(
    HANDLE hFile,
    LPCOMMTIMEOUTS lpCommTimeouts
    );


BOOL

TransmitCommChar(
    HANDLE hFile,
    char cChar
    );


BOOL

WaitCommEvent(
    HANDLE hFile,
    LPDWORD lpEvtMask,
    LPOVERLAPPED lpOverlapped
    );



DWORD

SetTapePosition(
    HANDLE hDevice,
    DWORD dwPositionMethod,
    DWORD dwPartition,
    DWORD dwOffsetLow,
    DWORD dwOffsetHigh,
    BOOL bImmediate
    );


DWORD

GetTapePosition(
    HANDLE hDevice,
    DWORD dwPositionType,
    LPDWORD lpdwPartition,
    LPDWORD lpdwOffsetLow,
    LPDWORD lpdwOffsetHigh
    );


DWORD

PrepareTape(
    HANDLE hDevice,
    DWORD dwOperation,
    BOOL bImmediate
    );


DWORD

EraseTape(
    HANDLE hDevice,
    DWORD dwEraseType,
    BOOL bImmediate
    );


DWORD

CreateTapePartition(
    HANDLE hDevice,
    DWORD dwPartitionMethod,
    DWORD dwCount,
    DWORD dwSize
    );


DWORD

WriteTapemark(
    HANDLE hDevice,
    DWORD dwTapemarkType,
    DWORD dwTapemarkCount,
    BOOL bImmediate
    );


DWORD

GetTapeStatus(
    HANDLE hDevice
    );


DWORD

GetTapeParameters(
    HANDLE hDevice,
    DWORD dwOperation,
    LPDWORD lpdwSize,
    LPVOID lpTapeInformation
    );





DWORD

SetTapeParameters(
    HANDLE hDevice,
    DWORD dwOperation,
    LPVOID lpTapeInformation
    );





BOOL

Beep(
    DWORD dwFreq,
    DWORD dwDuration
    );


void

OpenSound(
    void
    );


void

CloseSound(
    void
    );


void

StartSound(
    void
    );


void

StopSound(
    void
    );


DWORD

WaitSoundState(
    DWORD nState
    );


DWORD

SyncAllVoices(
    void
    );


DWORD

CountVoiceNotes(
    DWORD nVoice
    );


LPDWORD

GetThresholdEvent(
    void
    );


DWORD

GetThresholdStatus(
    void
    );


DWORD

SetSoundNoise(
    DWORD nSource,
    DWORD nDuration
    );


DWORD

SetVoiceAccent(
    DWORD nVoice,
    DWORD nTempo,
    DWORD nVolume,
    DWORD nMode,
    DWORD nPitch
    );


DWORD

SetVoiceEnvelope(
    DWORD nVoice,
    DWORD nShape,
    DWORD nRepeat
    );


DWORD

SetVoiceNote(
    DWORD nVoice,
    DWORD nValue,
    DWORD nLength,
    DWORD nCdots
    );


DWORD

SetVoiceQueueSize(
    DWORD nVoice,
    DWORD nBytes
    );


DWORD

SetVoiceSound(
    DWORD nVoice,
    DWORD Frequency,
    DWORD nDuration
    );


DWORD

SetVoiceThreshold(
    DWORD nVoice,
    DWORD nNotes
    );


int

MulDiv(
    int nNumber,
    int nNumerator,
    int nDenominator
    );


void

GetSystemTime(
    LPSYSTEMTIME lpSystemTime
    );


BOOL

SetSystemTime(
    const SYSTEMTIME *lpSystemTime
    );


void

GetLocalTime(
    LPSYSTEMTIME lpSystemTime
    );


BOOL

SetLocalTime(
    const SYSTEMTIME *lpSystemTime
    );


void

GetSystemInfo(
    LPSYSTEM_INFO lpSystemInfo
    );

typedef struct _TIME_ZONE_INFORMATION {
    LONG Bias;
    WCHAR StandardName[ 32 ];
    SYSTEMTIME StandardDate;
    LONG StandardBias;
    WCHAR DaylightName[ 32 ];
    SYSTEMTIME DaylightDate;
    LONG DaylightBias;
} TIME_ZONE_INFORMATION, *PTIME_ZONE_INFORMATION, *LPTIME_ZONE_INFORMATION;


BOOL

SystemTimeToTzSpecificLocalTime(
    LPTIME_ZONE_INFORMATION lpTimeZoneInformation,
    LPSYSTEMTIME lpUniversalTime,
    LPSYSTEMTIME lpLocalTime
    );


DWORD

GetTimeZoneInformation(
    LPTIME_ZONE_INFORMATION lpTimeZoneInformation
    );


BOOL

SetTimeZoneInformation(
    const TIME_ZONE_INFORMATION *lpTimeZoneInformation
    );






BOOL

SystemTimeToFileTime(
    const SYSTEMTIME *lpSystemTime,
    LPFILETIME lpFileTime
    );


BOOL

FileTimeToLocalFileTime(
    const FILETIME *lpFileTime,
    LPFILETIME lpLocalFileTime
    );


BOOL

LocalFileTimeToFileTime(
    const FILETIME *lpLocalFileTime,
    LPFILETIME lpFileTime
    );


BOOL

FileTimeToSystemTime(
    const FILETIME *lpFileTime,
    LPSYSTEMTIME lpSystemTime
    );


LONG

CompareFileTime(
    const FILETIME *lpFileTime1,
    const FILETIME *lpFileTime2
    );


BOOL

FileTimeToDosDateTime(
    const FILETIME *lpFileTime,
    LPWORD lpFatDate,
    LPWORD lpFatTime
    );


BOOL

DosDateTimeToFileTime(
    WORD wFatDate,
    WORD wFatTime,
    LPFILETIME lpFileTime
    );


DWORD

GetTickCount(
    void
    );


BOOL

SetSystemTimeAdjustment(
    DWORD dwTimeAdjustment,
    BOOL  bTimeAdjustmentDisabled
    );


BOOL

GetSystemTimeAdjustment(
    PDWORD lpTimeAdjustment,
    PDWORD lpTimeIncrement,
    PBOOL  lpTimeAdjustmentDisabled
    );


DWORD

FormatMessageA(
    DWORD dwFlags,
    LPCVOID lpSource,
    DWORD dwMessageId,
    DWORD dwLanguageId,
    LPSTR lpBuffer,
    DWORD nSize,
    va_list *Arguments
    );

DWORD

FormatMessageW(
    DWORD dwFlags,
    LPCVOID lpSource,
    DWORD dwMessageId,
    DWORD dwLanguageId,
    LPWSTR lpBuffer,
    DWORD nSize,
    va_list *Arguments
    );




#line 2793 "d:\\msvc20\\include/winbase.h"











BOOL

CreatePipe(
    PHANDLE hReadPipe,
    PHANDLE hWritePipe,
    LPSECURITY_ATTRIBUTES lpPipeAttributes,
    DWORD nSize
    );


BOOL

ConnectNamedPipe(
    HANDLE hNamedPipe,
    LPOVERLAPPED lpOverlapped
    );


BOOL

DisconnectNamedPipe(
    HANDLE hNamedPipe
    );


BOOL

SetNamedPipeHandleState(
    HANDLE hNamedPipe,
    LPDWORD lpMode,
    LPDWORD lpMaxCollectionCount,
    LPDWORD lpCollectDataTimeout
    );


BOOL

GetNamedPipeInfo(
    HANDLE hNamedPipe,
    LPDWORD lpFlags,
    LPDWORD lpOutBufferSize,
    LPDWORD lpInBufferSize,
    LPDWORD lpMaxInstances
    );


BOOL

PeekNamedPipe(
    HANDLE hNamedPipe,
    LPVOID lpBuffer,
    DWORD nBufferSize,
    LPDWORD lpBytesRead,
    LPDWORD lpTotalBytesAvail,
    LPDWORD lpBytesLeftThisMessage
    );


BOOL

TransactNamedPipe(
    HANDLE hNamedPipe,
    LPVOID lpInBuffer,
    DWORD nInBufferSize,
    LPVOID lpOutBuffer,
    DWORD nOutBufferSize,
    LPDWORD lpBytesRead,
    LPOVERLAPPED lpOverlapped
    );


HANDLE

CreateMailslotA(
    LPCSTR lpName,
    DWORD nMaxMessageSize,
    DWORD lReadTimeout,
    LPSECURITY_ATTRIBUTES lpSecurityAttributes
    );

HANDLE

CreateMailslotW(
    LPCWSTR lpName,
    DWORD nMaxMessageSize,
    DWORD lReadTimeout,
    LPSECURITY_ATTRIBUTES lpSecurityAttributes
    );




#line 2897 "d:\\msvc20\\include/winbase.h"


BOOL

GetMailslotInfo(
    HANDLE hMailslot,
    LPDWORD lpMaxMessageSize,
    LPDWORD lpNextSize,
    LPDWORD lpMessageCount,
    LPDWORD lpReadTimeout
    );


BOOL

SetMailslotInfo(
    HANDLE hMailslot,
    DWORD lReadTimeout
    );


LPVOID

MapViewOfFile(
    HANDLE hFileMappingObject,
    DWORD dwDesiredAccess,
    DWORD dwFileOffsetHigh,
    DWORD dwFileOffsetLow,
    DWORD dwNumberOfBytesToMap
    );


BOOL

FlushViewOfFile(
    LPCVOID lpBaseAddress,
    DWORD dwNumberOfBytesToFlush
    );


BOOL

UnmapViewOfFile(
    LPVOID lpBaseAddress
    );






int

lstrcmpA(
    LPCSTR lpString1,
    LPCSTR lpString2
    );

int

lstrcmpW(
    LPCWSTR lpString1,
    LPCWSTR lpString2
    );




#line 2966 "d:\\msvc20\\include/winbase.h"


int

lstrcmpiA(
    LPCSTR lpString1,
    LPCSTR lpString2
    );

int

lstrcmpiW(
    LPCWSTR lpString1,
    LPCWSTR lpString2
    );




#line 2986 "d:\\msvc20\\include/winbase.h"


LPSTR

lstrcpynA(
    LPSTR lpString1,
    LPCSTR lpString2,
    int iMaxLength
    );

LPWSTR

lstrcpynW(
    LPWSTR lpString1,
    LPCWSTR lpString2,
    int iMaxLength
    );




#line 3008 "d:\\msvc20\\include/winbase.h"


LPSTR

lstrcpyA(
    LPSTR lpString1,
    LPCSTR lpString2
    );

LPWSTR

lstrcpyW(
    LPWSTR lpString1,
    LPCWSTR lpString2
    );




#line 3028 "d:\\msvc20\\include/winbase.h"


LPSTR

lstrcatA(
    LPSTR lpString1,
    LPCSTR lpString2
    );

LPWSTR

lstrcatW(
    LPWSTR lpString1,
    LPCWSTR lpString2
    );




#line 3048 "d:\\msvc20\\include/winbase.h"


int

lstrlenA(
    LPCSTR lpString
    );

int

lstrlenW(
    LPCWSTR lpString
    );




#line 3066 "d:\\msvc20\\include/winbase.h"


HFILE

OpenFile(
    LPCSTR lpFileName,
    LPOFSTRUCT lpReOpenBuff,
    UINT uStyle
    );


HFILE

_lopen(
    LPCSTR lpPathName,
    int iReadWrite
    );


HFILE

_lcreat(
    LPCSTR lpPathName,
    int  iAttribute
    );


UINT

_lread(
    HFILE hFile,
    LPVOID lpBuffer,
    UINT uBytes
    );


UINT

_lwrite(
    HFILE hFile,
    LPCSTR lpBuffer,
    UINT uBytes
    );


long

_hread(
    HFILE hFile,
    LPVOID lpBuffer,
    long lBytes
    );


long

_hwrite(
    HFILE hFile,
    LPCSTR lpBuffer,
    long lBytes
    );


HFILE

_lclose(
    HFILE hFile
    );


LONG

_llseek(
    HFILE hFile,
    LONG lOffset,
    int iOrigin
    );


BOOL

IsTextUnicode(
    const LPVOID lpBuffer,
    int cb,
    LPINT lpi
    );


DWORD

TlsAlloc(
    void
    );




LPVOID

TlsGetValue(
    DWORD dwTlsIndex
    );


BOOL

TlsSetValue(
    DWORD dwTlsIndex,
    LPVOID lpTlsValue
    );


BOOL

TlsFree(
    DWORD dwTlsIndex
    );

typedef
void
( *LPOVERLAPPED_COMPLETION_ROUTINE)(
    DWORD dwErrorCode,
    DWORD dwNumberOfBytesTransfered,
    LPOVERLAPPED lpOverlapped
    );


DWORD

SleepEx(
    DWORD dwMilliseconds,
    BOOL bAlertable
    );


DWORD

WaitForSingleObjectEx(
    HANDLE hHandle,
    DWORD dwMilliseconds,
    BOOL bAlertable
    );


DWORD

WaitForMultipleObjectsEx(
    DWORD nCount,
    const HANDLE *lpHandles,
    BOOL bWaitAll,
    DWORD dwMilliseconds,
    BOOL bAlertable
    );


BOOL

ReadFileEx(
    HANDLE hFile,
    LPVOID lpBuffer,
    DWORD nNumberOfBytesToRead,
    LPOVERLAPPED lpOverlapped,
    LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine
    );


BOOL

WriteFileEx(
    HANDLE hFile,
    LPCVOID lpBuffer,
    DWORD nNumberOfBytesToWrite,
    LPOVERLAPPED lpOverlapped,
    LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine
    );


BOOL

BackupRead(
    HANDLE hFile,
    LPBYTE lpBuffer,
    DWORD nNumberOfBytesToRead,
    LPDWORD lpNumberOfBytesRead,
    BOOL bAbort,
    BOOL bProcessSecurity,
    LPVOID *lpContext
    );


BOOL

BackupSeek(
    HANDLE hFile,
    DWORD  dwLowBytesToSeek,
    DWORD  dwHighBytesToSeek,
    LPDWORD lpdwLowByteSeeked,
    LPDWORD lpdwHighByteSeeked,
    LPVOID *lpContext
    );


BOOL

BackupWrite(
    HANDLE hFile,
    LPBYTE lpBuffer,
    DWORD nNumberOfBytesToWrite,
    LPDWORD lpNumberOfBytesWritten,
    BOOL bAbort,
    BOOL bProcessSecurity,
    LPVOID *lpContext
    );




typedef struct _WIN32_STREAM_ID {
        DWORD          dwStreamId ;
        DWORD          dwStreamAttributes ;
        LARGE_INTEGER  Size ;
        DWORD          dwStreamNameSize ;
        WCHAR          cStreamName[ 1 ] ;
} WIN32_STREAM_ID, *LPWIN32_STREAM_ID ;




































typedef struct _STARTUPINFOA {
    DWORD   cb;
    LPSTR   lpReserved;
    LPSTR   lpDesktop;
    LPSTR   lpTitle;
    DWORD   dwX;
    DWORD   dwY;
    DWORD   dwXSize;
    DWORD   dwYSize;
    DWORD   dwXCountChars;
    DWORD   dwYCountChars;
    DWORD   dwFillAttribute;
    DWORD   dwFlags;
    WORD    wShowWindow;
    WORD    cbReserved2;
    LPBYTE  lpReserved2;
    HANDLE  hStdInput;
    HANDLE  hStdOutput;
    HANDLE  hStdError;
} STARTUPINFOA, *LPSTARTUPINFOA;
typedef struct _STARTUPINFOW {
    DWORD   cb;
    LPWSTR  lpReserved;
    LPWSTR  lpDesktop;
    LPWSTR  lpTitle;
    DWORD   dwX;
    DWORD   dwY;
    DWORD   dwXSize;
    DWORD   dwYSize;
    DWORD   dwXCountChars;
    DWORD   dwYCountChars;
    DWORD   dwFillAttribute;
    DWORD   dwFlags;
    WORD    wShowWindow;
    WORD    cbReserved2;
    LPBYTE  lpReserved2;
    HANDLE  hStdInput;
    HANDLE  hStdOutput;
    HANDLE  hStdError;
} STARTUPINFOW, *LPSTARTUPINFOW;




typedef STARTUPINFOA STARTUPINFO;
typedef LPSTARTUPINFOA LPSTARTUPINFO;
#line 3373 "d:\\msvc20\\include/winbase.h"



typedef struct _WIN32_FIND_DATAA {
    DWORD dwFileAttributes;
    FILETIME ftCreationTime;
    FILETIME ftLastAccessTime;
    FILETIME ftLastWriteTime;
    DWORD nFileSizeHigh;
    DWORD nFileSizeLow;
    DWORD dwReserved0;
    DWORD dwReserved1;
    CHAR   cFileName[ 260 ];
    CHAR   cAlternateFileName[ 14 ];
} WIN32_FIND_DATAA, *PWIN32_FIND_DATAA, *LPWIN32_FIND_DATAA;
typedef struct _WIN32_FIND_DATAW {
    DWORD dwFileAttributes;
    FILETIME ftCreationTime;
    FILETIME ftLastAccessTime;
    FILETIME ftLastWriteTime;
    DWORD nFileSizeHigh;
    DWORD nFileSizeLow;
    DWORD dwReserved0;
    DWORD dwReserved1;
    WCHAR  cFileName[ 260 ];
    WCHAR  cAlternateFileName[ 14 ];
} WIN32_FIND_DATAW, *PWIN32_FIND_DATAW, *LPWIN32_FIND_DATAW;





typedef WIN32_FIND_DATAA WIN32_FIND_DATA;
typedef PWIN32_FIND_DATAA PWIN32_FIND_DATA;
typedef LPWIN32_FIND_DATAA LPWIN32_FIND_DATA;
#line 3409 "d:\\msvc20\\include/winbase.h"


HANDLE

CreateMutexA(
    LPSECURITY_ATTRIBUTES lpMutexAttributes,
    BOOL bInitialOwner,
    LPCSTR lpName
    );

HANDLE

CreateMutexW(
    LPSECURITY_ATTRIBUTES lpMutexAttributes,
    BOOL bInitialOwner,
    LPCWSTR lpName
    );




#line 3431 "d:\\msvc20\\include/winbase.h"


HANDLE

OpenMutexA(
    DWORD dwDesiredAccess,
    BOOL bInheritHandle,
    LPCSTR lpName
    );

HANDLE

OpenMutexW(
    DWORD dwDesiredAccess,
    BOOL bInheritHandle,
    LPCWSTR lpName
    );




#line 3453 "d:\\msvc20\\include/winbase.h"


HANDLE

CreateEventA(
    LPSECURITY_ATTRIBUTES lpEventAttributes,
    BOOL bManualReset,
    BOOL bInitialState,
    LPCSTR lpName
    );

HANDLE

CreateEventW(
    LPSECURITY_ATTRIBUTES lpEventAttributes,
    BOOL bManualReset,
    BOOL bInitialState,
    LPCWSTR lpName
    );




#line 3477 "d:\\msvc20\\include/winbase.h"


HANDLE

OpenEventA(
    DWORD dwDesiredAccess,
    BOOL bInheritHandle,
    LPCSTR lpName
    );

HANDLE

OpenEventW(
    DWORD dwDesiredAccess,
    BOOL bInheritHandle,
    LPCWSTR lpName
    );




#line 3499 "d:\\msvc20\\include/winbase.h"


HANDLE

CreateSemaphoreA(
    LPSECURITY_ATTRIBUTES lpSemaphoreAttributes,
    LONG lInitialCount,
    LONG lMaximumCount,
    LPCSTR lpName
    );

HANDLE

CreateSemaphoreW(
    LPSECURITY_ATTRIBUTES lpSemaphoreAttributes,
    LONG lInitialCount,
    LONG lMaximumCount,
    LPCWSTR lpName
    );




#line 3523 "d:\\msvc20\\include/winbase.h"


HANDLE

OpenSemaphoreA(
    DWORD dwDesiredAccess,
    BOOL bInheritHandle,
    LPCSTR lpName
    );

HANDLE

OpenSemaphoreW(
    DWORD dwDesiredAccess,
    BOOL bInheritHandle,
    LPCWSTR lpName
    );




#line 3545 "d:\\msvc20\\include/winbase.h"


HANDLE

CreateFileMappingA(
    HANDLE hFile,
    LPSECURITY_ATTRIBUTES lpFileMappingAttributes,
    DWORD flProtect,
    DWORD dwMaximumSizeHigh,
    DWORD dwMaximumSizeLow,
    LPCSTR lpName
    );

HANDLE

CreateFileMappingW(
    HANDLE hFile,
    LPSECURITY_ATTRIBUTES lpFileMappingAttributes,
    DWORD flProtect,
    DWORD dwMaximumSizeHigh,
    DWORD dwMaximumSizeLow,
    LPCWSTR lpName
    );




#line 3573 "d:\\msvc20\\include/winbase.h"


HANDLE

OpenFileMappingA(
    DWORD dwDesiredAccess,
    BOOL bInheritHandle,
    LPCSTR lpName
    );

HANDLE

OpenFileMappingW(
    DWORD dwDesiredAccess,
    BOOL bInheritHandle,
    LPCWSTR lpName
    );




#line 3595 "d:\\msvc20\\include/winbase.h"


DWORD

GetLogicalDriveStringsA(
    DWORD nBufferLength,
    LPSTR lpBuffer
    );

DWORD

GetLogicalDriveStringsW(
    DWORD nBufferLength,
    LPWSTR lpBuffer
    );




#line 3615 "d:\\msvc20\\include/winbase.h"


HINSTANCE

LoadLibraryA(
    LPCSTR lpLibFileName
    );

HINSTANCE

LoadLibraryW(
    LPCWSTR lpLibFileName
    );




#line 3633 "d:\\msvc20\\include/winbase.h"


HINSTANCE

LoadLibraryExA(
    LPCSTR lpLibFileName,
    HANDLE hFile,
    DWORD dwFlags
    );

HINSTANCE

LoadLibraryExW(
    LPCWSTR lpLibFileName,
    HANDLE hFile,
    DWORD dwFlags
    );




#line 3655 "d:\\msvc20\\include/winbase.h"







DWORD

GetModuleFileNameA(
    HINSTANCE hModule,
    LPSTR lpFilename,
    DWORD nSize
    );

DWORD

GetModuleFileNameW(
    HINSTANCE hModule,
    LPWSTR lpFilename,
    DWORD nSize
    );




#line 3682 "d:\\msvc20\\include/winbase.h"


HMODULE

GetModuleHandleA(
    LPCSTR lpModuleName
    );

HMODULE

GetModuleHandleW(
    LPCWSTR lpModuleName
    );




#line 3700 "d:\\msvc20\\include/winbase.h"


BOOL

CreateProcessA(
    LPCSTR lpApplicationName,
    LPSTR lpCommandLine,
    LPSECURITY_ATTRIBUTES lpProcessAttributes,
    LPSECURITY_ATTRIBUTES lpThreadAttributes,
    BOOL bInheritHandles,
    DWORD dwCreationFlags,
    LPVOID lpEnvironment,
    LPCSTR lpCurrentDirectory,
    LPSTARTUPINFOA lpStartupInfo,
    LPPROCESS_INFORMATION lpProcessInformation
    );

BOOL

CreateProcessW(
    LPCWSTR lpApplicationName,
    LPWSTR lpCommandLine,
    LPSECURITY_ATTRIBUTES lpProcessAttributes,
    LPSECURITY_ATTRIBUTES lpThreadAttributes,
    BOOL bInheritHandles,
    DWORD dwCreationFlags,
    LPVOID lpEnvironment,
    LPCWSTR lpCurrentDirectory,
    LPSTARTUPINFOW lpStartupInfo,
    LPPROCESS_INFORMATION lpProcessInformation
    );




#line 3736 "d:\\msvc20\\include/winbase.h"


BOOL

SetProcessShutdownParameters(
    DWORD dwLevel,
    DWORD dwFlags
    );


BOOL

GetProcessShutdownParameters(
    LPDWORD lpdwLevel,
    LPDWORD lpdwFlags
    );


void

FatalAppExitA(
    UINT uAction,
    LPCSTR lpMessageText
    );

void

FatalAppExitW(
    UINT uAction,
    LPCWSTR lpMessageText
    );




#line 3772 "d:\\msvc20\\include/winbase.h"


void

GetStartupInfoA(
    LPSTARTUPINFOA lpStartupInfo
    );

void

GetStartupInfoW(
    LPSTARTUPINFOW lpStartupInfo
    );




#line 3790 "d:\\msvc20\\include/winbase.h"


LPSTR

GetCommandLineA(
    void
    );

LPWSTR

GetCommandLineW(
    void
    );




#line 3808 "d:\\msvc20\\include/winbase.h"


DWORD

GetEnvironmentVariableA(
    LPCSTR lpName,
    LPSTR lpBuffer,
    DWORD nSize
    );

DWORD

GetEnvironmentVariableW(
    LPCWSTR lpName,
    LPWSTR lpBuffer,
    DWORD nSize
    );




#line 3830 "d:\\msvc20\\include/winbase.h"


BOOL

SetEnvironmentVariableA(
    LPCSTR lpName,
    LPCSTR lpValue
    );

BOOL

SetEnvironmentVariableW(
    LPCWSTR lpName,
    LPCWSTR lpValue
    );




#line 3850 "d:\\msvc20\\include/winbase.h"


DWORD

ExpandEnvironmentStringsA(
    LPCSTR lpSrc,
    LPSTR lpDst,
    DWORD nSize
    );

DWORD

ExpandEnvironmentStringsW(
    LPCWSTR lpSrc,
    LPWSTR lpDst,
    DWORD nSize
    );




#line 3872 "d:\\msvc20\\include/winbase.h"


void

OutputDebugStringA(
    LPCSTR lpOutputString
    );

void

OutputDebugStringW(
    LPCWSTR lpOutputString
    );




#line 3890 "d:\\msvc20\\include/winbase.h"


HRSRC

FindResourceA(
    HINSTANCE hModule,
    LPCSTR lpName,
    LPCSTR lpType
    );

HRSRC

FindResourceW(
    HINSTANCE hModule,
    LPCWSTR lpName,
    LPCWSTR lpType
    );




#line 3912 "d:\\msvc20\\include/winbase.h"


HRSRC

FindResourceExA(
    HINSTANCE hModule,
    LPCSTR lpType,
    LPCSTR lpName,
    WORD    wLanguage
    );

HRSRC

FindResourceExW(
    HINSTANCE hModule,
    LPCWSTR lpType,
    LPCWSTR lpName,
    WORD    wLanguage
    );




#line 3936 "d:\\msvc20\\include/winbase.h"









typedef FARPROC ENUMRESTYPEPROC;
typedef FARPROC ENUMRESNAMEPROC;
typedef FARPROC ENUMRESLANGPROC;
#line 3949 "d:\\msvc20\\include/winbase.h"


BOOL

EnumResourceTypesA(
    HINSTANCE hModule,
    ENUMRESTYPEPROC lpEnumFunc,
    LONG lParam
    );

BOOL

EnumResourceTypesW(
    HINSTANCE hModule,
    ENUMRESTYPEPROC lpEnumFunc,
    LONG lParam
    );




#line 3971 "d:\\msvc20\\include/winbase.h"



BOOL

EnumResourceNamesA(
    HINSTANCE hModule,
    LPCSTR lpType,
    ENUMRESNAMEPROC lpEnumFunc,
    LONG lParam
    );

BOOL

EnumResourceNamesW(
    HINSTANCE hModule,
    LPCWSTR lpType,
    ENUMRESNAMEPROC lpEnumFunc,
    LONG lParam
    );




#line 3996 "d:\\msvc20\\include/winbase.h"


BOOL

EnumResourceLanguagesA(
    HINSTANCE hModule,
    LPCSTR lpType,
    LPCSTR lpName,
    ENUMRESLANGPROC lpEnumFunc,
    LONG lParam
    );

BOOL

EnumResourceLanguagesW(
    HINSTANCE hModule,
    LPCWSTR lpType,
    LPCWSTR lpName,
    ENUMRESLANGPROC lpEnumFunc,
    LONG lParam
    );




#line 4022 "d:\\msvc20\\include/winbase.h"


HANDLE

BeginUpdateResourceA(
    LPCSTR pFileName,
    BOOL bDeleteExistingResources
    );

HANDLE

BeginUpdateResourceW(
    LPCWSTR pFileName,
    BOOL bDeleteExistingResources
    );




#line 4042 "d:\\msvc20\\include/winbase.h"


BOOL

UpdateResourceA(
    HANDLE      hUpdate,
    LPCSTR     lpType,
    LPCSTR     lpName,
    WORD        wLanguage,
    LPVOID      lpData,
    DWORD       cbData
    );

BOOL

UpdateResourceW(
    HANDLE      hUpdate,
    LPCWSTR     lpType,
    LPCWSTR     lpName,
    WORD        wLanguage,
    LPVOID      lpData,
    DWORD       cbData
    );




#line 4070 "d:\\msvc20\\include/winbase.h"


BOOL

EndUpdateResourceA(
    HANDLE      hUpdate,
    BOOL        fDiscard
    );

BOOL

EndUpdateResourceW(
    HANDLE      hUpdate,
    BOOL        fDiscard
    );




#line 4090 "d:\\msvc20\\include/winbase.h"


ATOM

GlobalAddAtomA(
    LPCSTR lpString
    );

ATOM

GlobalAddAtomW(
    LPCWSTR lpString
    );




#line 4108 "d:\\msvc20\\include/winbase.h"


ATOM

GlobalFindAtomA(
    LPCSTR lpString
    );

ATOM

GlobalFindAtomW(
    LPCWSTR lpString
    );




#line 4126 "d:\\msvc20\\include/winbase.h"


UINT

GlobalGetAtomNameA(
    ATOM nAtom,
    LPSTR lpBuffer,
    int nSize
    );

UINT

GlobalGetAtomNameW(
    ATOM nAtom,
    LPWSTR lpBuffer,
    int nSize
    );




#line 4148 "d:\\msvc20\\include/winbase.h"


ATOM

AddAtomA(
    LPCSTR lpString
    );

ATOM

AddAtomW(
    LPCWSTR lpString
    );




#line 4166 "d:\\msvc20\\include/winbase.h"


ATOM

FindAtomA(
    LPCSTR lpString
    );

ATOM

FindAtomW(
    LPCWSTR lpString
    );




#line 4184 "d:\\msvc20\\include/winbase.h"


UINT

GetAtomNameA(
    ATOM nAtom,
    LPSTR lpBuffer,
    int nSize
    );

UINT

GetAtomNameW(
    ATOM nAtom,
    LPWSTR lpBuffer,
    int nSize
    );




#line 4206 "d:\\msvc20\\include/winbase.h"


UINT

GetProfileIntA(
    LPCSTR lpAppName,
    LPCSTR lpKeyName,
    INT nDefault
    );

UINT

GetProfileIntW(
    LPCWSTR lpAppName,
    LPCWSTR lpKeyName,
    INT nDefault
    );




#line 4228 "d:\\msvc20\\include/winbase.h"


DWORD

GetProfileStringA(
    LPCSTR lpAppName,
    LPCSTR lpKeyName,
    LPCSTR lpDefault,
    LPSTR lpReturnedString,
    DWORD nSize
    );

DWORD

GetProfileStringW(
    LPCWSTR lpAppName,
    LPCWSTR lpKeyName,
    LPCWSTR lpDefault,
    LPWSTR lpReturnedString,
    DWORD nSize
    );




#line 4254 "d:\\msvc20\\include/winbase.h"


BOOL

WriteProfileStringA(
    LPCSTR lpAppName,
    LPCSTR lpKeyName,
    LPCSTR lpString
    );

BOOL

WriteProfileStringW(
    LPCWSTR lpAppName,
    LPCWSTR lpKeyName,
    LPCWSTR lpString
    );




#line 4276 "d:\\msvc20\\include/winbase.h"


DWORD

GetProfileSectionA(
    LPCSTR lpAppName,
    LPSTR lpReturnedString,
    DWORD nSize
    );

DWORD

GetProfileSectionW(
    LPCWSTR lpAppName,
    LPWSTR lpReturnedString,
    DWORD nSize
    );




#line 4298 "d:\\msvc20\\include/winbase.h"


BOOL

WriteProfileSectionA(
    LPCSTR lpAppName,
    LPCSTR lpString
    );

BOOL

WriteProfileSectionW(
    LPCWSTR lpAppName,
    LPCWSTR lpString
    );




#line 4318 "d:\\msvc20\\include/winbase.h"


UINT

GetPrivateProfileIntA(
    LPCSTR lpAppName,
    LPCSTR lpKeyName,
    INT nDefault,
    LPCSTR lpFileName
    );

UINT

GetPrivateProfileIntW(
    LPCWSTR lpAppName,
    LPCWSTR lpKeyName,
    INT nDefault,
    LPCWSTR lpFileName
    );




#line 4342 "d:\\msvc20\\include/winbase.h"


DWORD

GetPrivateProfileStringA(
    LPCSTR lpAppName,
    LPCSTR lpKeyName,
    LPCSTR lpDefault,
    LPSTR lpReturnedString,
    DWORD nSize,
    LPCSTR lpFileName
    );

DWORD

GetPrivateProfileStringW(
    LPCWSTR lpAppName,
    LPCWSTR lpKeyName,
    LPCWSTR lpDefault,
    LPWSTR lpReturnedString,
    DWORD nSize,
    LPCWSTR lpFileName
    );




#line 4370 "d:\\msvc20\\include/winbase.h"


BOOL

WritePrivateProfileStringA(
    LPCSTR lpAppName,
    LPCSTR lpKeyName,
    LPCSTR lpString,
    LPCSTR lpFileName
    );

BOOL

WritePrivateProfileStringW(
    LPCWSTR lpAppName,
    LPCWSTR lpKeyName,
    LPCWSTR lpString,
    LPCWSTR lpFileName
    );




#line 4394 "d:\\msvc20\\include/winbase.h"


DWORD

GetPrivateProfileSectionA(
    LPCSTR lpAppName,
    LPSTR lpReturnedString,
    DWORD nSize,
    LPCSTR lpFileName
    );

DWORD

GetPrivateProfileSectionW(
    LPCWSTR lpAppName,
    LPWSTR lpReturnedString,
    DWORD nSize,
    LPCWSTR lpFileName
    );




#line 4418 "d:\\msvc20\\include/winbase.h"


BOOL

WritePrivateProfileSectionA(
    LPCSTR lpAppName,
    LPCSTR lpString,
    LPCSTR lpFileName
    );

BOOL

WritePrivateProfileSectionW(
    LPCWSTR lpAppName,
    LPCWSTR lpString,
    LPCWSTR lpFileName
    );




#line 4440 "d:\\msvc20\\include/winbase.h"


UINT

GetDriveTypeA(
    LPCSTR lpRootPathName
    );

UINT

GetDriveTypeW(
    LPCWSTR lpRootPathName
    );




#line 4458 "d:\\msvc20\\include/winbase.h"


UINT

GetSystemDirectoryA(
    LPSTR lpBuffer,
    UINT uSize
    );

UINT

GetSystemDirectoryW(
    LPWSTR lpBuffer,
    UINT uSize
    );




#line 4478 "d:\\msvc20\\include/winbase.h"


DWORD

GetTempPathA(
    DWORD nBufferLength,
    LPSTR lpBuffer
    );

DWORD

GetTempPathW(
    DWORD nBufferLength,
    LPWSTR lpBuffer
    );




#line 4498 "d:\\msvc20\\include/winbase.h"


UINT

GetTempFileNameA(
    LPCSTR lpPathName,
    LPCSTR lpPrefixString,
    UINT uUnique,
    LPSTR lpTempFileName
    );

UINT

GetTempFileNameW(
    LPCWSTR lpPathName,
    LPCWSTR lpPrefixString,
    UINT uUnique,
    LPWSTR lpTempFileName
    );




#line 4522 "d:\\msvc20\\include/winbase.h"


UINT

GetWindowsDirectoryA(
    LPSTR lpBuffer,
    UINT uSize
    );

UINT

GetWindowsDirectoryW(
    LPWSTR lpBuffer,
    UINT uSize
    );




#line 4542 "d:\\msvc20\\include/winbase.h"


BOOL

SetCurrentDirectoryA(
    LPCSTR lpPathName
    );

BOOL

SetCurrentDirectoryW(
    LPCWSTR lpPathName
    );




#line 4560 "d:\\msvc20\\include/winbase.h"


DWORD

GetCurrentDirectoryA(
    DWORD nBufferLength,
    LPSTR lpBuffer
    );

DWORD

GetCurrentDirectoryW(
    DWORD nBufferLength,
    LPWSTR lpBuffer
    );




#line 4580 "d:\\msvc20\\include/winbase.h"


BOOL

GetDiskFreeSpaceA(
    LPCSTR lpRootPathName,
    LPDWORD lpSectorsPerCluster,
    LPDWORD lpBytesPerSector,
    LPDWORD lpNumberOfFreeClusters,
    LPDWORD lpTotalNumberOfClusters
    );

BOOL

GetDiskFreeSpaceW(
    LPCWSTR lpRootPathName,
    LPDWORD lpSectorsPerCluster,
    LPDWORD lpBytesPerSector,
    LPDWORD lpNumberOfFreeClusters,
    LPDWORD lpTotalNumberOfClusters
    );




#line 4606 "d:\\msvc20\\include/winbase.h"


BOOL

CreateDirectoryA(
    LPCSTR lpPathName,
    LPSECURITY_ATTRIBUTES lpSecurityAttributes
    );

BOOL

CreateDirectoryW(
    LPCWSTR lpPathName,
    LPSECURITY_ATTRIBUTES lpSecurityAttributes
    );




#line 4626 "d:\\msvc20\\include/winbase.h"


BOOL

CreateDirectoryExA(
    LPCSTR lpTemplateDirectory,
    LPCSTR lpNewDirectory,
    LPSECURITY_ATTRIBUTES lpSecurityAttributes
    );

BOOL

CreateDirectoryExW(
    LPCWSTR lpTemplateDirectory,
    LPCWSTR lpNewDirectory,
    LPSECURITY_ATTRIBUTES lpSecurityAttributes
    );




#line 4648 "d:\\msvc20\\include/winbase.h"


BOOL

RemoveDirectoryA(
    LPCSTR lpPathName
    );

BOOL

RemoveDirectoryW(
    LPCWSTR lpPathName
    );




#line 4666 "d:\\msvc20\\include/winbase.h"


DWORD

GetFullPathNameA(
    LPCSTR lpFileName,
    DWORD nBufferLength,
    LPSTR lpBuffer,
    LPSTR *lpFilePart
    );

DWORD

GetFullPathNameW(
    LPCWSTR lpFileName,
    DWORD nBufferLength,
    LPWSTR lpBuffer,
    LPWSTR *lpFilePart
    );




#line 4690 "d:\\msvc20\\include/winbase.h"







BOOL

DefineDosDeviceA(
    DWORD dwFlags,
    LPCSTR lpDeviceName,
    LPCSTR lpTargetPath
    );

BOOL

DefineDosDeviceW(
    DWORD dwFlags,
    LPCWSTR lpDeviceName,
    LPCWSTR lpTargetPath
    );




#line 4717 "d:\\msvc20\\include/winbase.h"


DWORD

QueryDosDeviceA(
    LPCSTR lpDeviceName,
    LPSTR lpTargetPath,
    DWORD ucchMax
    );

DWORD

QueryDosDeviceW(
    LPCWSTR lpDeviceName,
    LPWSTR lpTargetPath,
    DWORD ucchMax
    );




#line 4739 "d:\\msvc20\\include/winbase.h"




HANDLE

CreateFileA(
    LPCSTR lpFileName,
    DWORD dwDesiredAccess,
    DWORD dwShareMode,
    LPSECURITY_ATTRIBUTES lpSecurityAttributes,
    DWORD dwCreationDisposition,
    DWORD dwFlagsAndAttributes,
    HANDLE hTemplateFile
    );

HANDLE

CreateFileW(
    LPCWSTR lpFileName,
    DWORD dwDesiredAccess,
    DWORD dwShareMode,
    LPSECURITY_ATTRIBUTES lpSecurityAttributes,
    DWORD dwCreationDisposition,
    DWORD dwFlagsAndAttributes,
    HANDLE hTemplateFile
    );




#line 4771 "d:\\msvc20\\include/winbase.h"


BOOL

SetFileAttributesA(
    LPCSTR lpFileName,
    DWORD dwFileAttributes
    );

BOOL

SetFileAttributesW(
    LPCWSTR lpFileName,
    DWORD dwFileAttributes
    );




#line 4791 "d:\\msvc20\\include/winbase.h"


DWORD

GetFileAttributesA(
    LPCSTR lpFileName
    );

DWORD

GetFileAttributesW(
    LPCWSTR lpFileName
    );




#line 4809 "d:\\msvc20\\include/winbase.h"


DWORD

GetCompressedFileSizeA(
    LPCSTR lpFileName,
    LPDWORD lpFileSizeHigh
    );

DWORD

GetCompressedFileSizeW(
    LPCWSTR lpFileName,
    LPDWORD lpFileSizeHigh
    );




#line 4829 "d:\\msvc20\\include/winbase.h"


BOOL

DeleteFileA(
    LPCSTR lpFileName
    );

BOOL

DeleteFileW(
    LPCWSTR lpFileName
    );




#line 4847 "d:\\msvc20\\include/winbase.h"


HANDLE

FindFirstFileA(
    LPCSTR lpFileName,
    LPWIN32_FIND_DATAA lpFindFileData
    );

HANDLE

FindFirstFileW(
    LPCWSTR lpFileName,
    LPWIN32_FIND_DATAW lpFindFileData
    );




#line 4867 "d:\\msvc20\\include/winbase.h"


BOOL

FindNextFileA(
    HANDLE hFindFile,
    LPWIN32_FIND_DATAA lpFindFileData
    );

BOOL

FindNextFileW(
    HANDLE hFindFile,
    LPWIN32_FIND_DATAW lpFindFileData
    );




#line 4887 "d:\\msvc20\\include/winbase.h"


DWORD

SearchPathA(
    LPCSTR lpPath,
    LPCSTR lpFileName,
    LPCSTR lpExtension,
    DWORD nBufferLength,
    LPSTR lpBuffer,
    LPSTR *lpFilePart
    );

DWORD

SearchPathW(
    LPCWSTR lpPath,
    LPCWSTR lpFileName,
    LPCWSTR lpExtension,
    DWORD nBufferLength,
    LPWSTR lpBuffer,
    LPWSTR *lpFilePart
    );




#line 4915 "d:\\msvc20\\include/winbase.h"


BOOL

CopyFileA(
    LPCSTR lpExistingFileName,
    LPCSTR lpNewFileName,
    BOOL bFailIfExists
    );

BOOL

CopyFileW(
    LPCWSTR lpExistingFileName,
    LPCWSTR lpNewFileName,
    BOOL bFailIfExists
    );




#line 4937 "d:\\msvc20\\include/winbase.h"


BOOL

MoveFileA(
    LPCSTR lpExistingFileName,
    LPCSTR lpNewFileName
    );

BOOL

MoveFileW(
    LPCWSTR lpExistingFileName,
    LPCWSTR lpNewFileName
    );




#line 4957 "d:\\msvc20\\include/winbase.h"


BOOL

MoveFileExA(
    LPCSTR lpExistingFileName,
    LPCSTR lpNewFileName,
    DWORD dwFlags
    );

BOOL

MoveFileExW(
    LPCWSTR lpExistingFileName,
    LPCWSTR lpNewFileName,
    DWORD dwFlags
    );




#line 4979 "d:\\msvc20\\include/winbase.h"






HANDLE

CreateNamedPipeA(
    LPCSTR lpName,
    DWORD dwOpenMode,
    DWORD dwPipeMode,
    DWORD nMaxInstances,
    DWORD nOutBufferSize,
    DWORD nInBufferSize,
    DWORD nDefaultTimeOut,
    LPSECURITY_ATTRIBUTES lpSecurityAttributes
    );

HANDLE

CreateNamedPipeW(
    LPCWSTR lpName,
    DWORD dwOpenMode,
    DWORD dwPipeMode,
    DWORD nMaxInstances,
    DWORD nOutBufferSize,
    DWORD nInBufferSize,
    DWORD nDefaultTimeOut,
    LPSECURITY_ATTRIBUTES lpSecurityAttributes
    );




#line 5015 "d:\\msvc20\\include/winbase.h"


BOOL

GetNamedPipeHandleStateA(
    HANDLE hNamedPipe,
    LPDWORD lpState,
    LPDWORD lpCurInstances,
    LPDWORD lpMaxCollectionCount,
    LPDWORD lpCollectDataTimeout,
    LPSTR lpUserName,
    DWORD nMaxUserNameSize
    );

BOOL

GetNamedPipeHandleStateW(
    HANDLE hNamedPipe,
    LPDWORD lpState,
    LPDWORD lpCurInstances,
    LPDWORD lpMaxCollectionCount,
    LPDWORD lpCollectDataTimeout,
    LPWSTR lpUserName,
    DWORD nMaxUserNameSize
    );




#line 5045 "d:\\msvc20\\include/winbase.h"


BOOL

CallNamedPipeA(
    LPCSTR lpNamedPipeName,
    LPVOID lpInBuffer,
    DWORD nInBufferSize,
    LPVOID lpOutBuffer,
    DWORD nOutBufferSize,
    LPDWORD lpBytesRead,
    DWORD nTimeOut
    );

BOOL

CallNamedPipeW(
    LPCWSTR lpNamedPipeName,
    LPVOID lpInBuffer,
    DWORD nInBufferSize,
    LPVOID lpOutBuffer,
    DWORD nOutBufferSize,
    LPDWORD lpBytesRead,
    DWORD nTimeOut
    );




#line 5075 "d:\\msvc20\\include/winbase.h"


BOOL

WaitNamedPipeA(
    LPCSTR lpNamedPipeName,
    DWORD nTimeOut
    );

BOOL

WaitNamedPipeW(
    LPCWSTR lpNamedPipeName,
    DWORD nTimeOut
    );




#line 5095 "d:\\msvc20\\include/winbase.h"


BOOL

SetVolumeLabelA(
    LPCSTR lpRootPathName,
    LPCSTR lpVolumeName
    );

BOOL

SetVolumeLabelW(
    LPCWSTR lpRootPathName,
    LPCWSTR lpVolumeName
    );




#line 5115 "d:\\msvc20\\include/winbase.h"


void

SetFileApisToOEM( void );


void

SetFileApisToANSI( void );


BOOL

AreFileApisANSI( void );


BOOL

GetVolumeInformationA(
    LPCSTR lpRootPathName,
    LPSTR lpVolumeNameBuffer,
    DWORD nVolumeNameSize,
    LPDWORD lpVolumeSerialNumber,
    LPDWORD lpMaximumComponentLength,
    LPDWORD lpFileSystemFlags,
    LPSTR lpFileSystemNameBuffer,
    DWORD nFileSystemNameSize
    );

BOOL

GetVolumeInformationW(
    LPCWSTR lpRootPathName,
    LPWSTR lpVolumeNameBuffer,
    DWORD nVolumeNameSize,
    LPDWORD lpVolumeSerialNumber,
    LPDWORD lpMaximumComponentLength,
    LPDWORD lpFileSystemFlags,
    LPWSTR lpFileSystemNameBuffer,
    DWORD nFileSystemNameSize
    );




#line 5162 "d:\\msvc20\\include/winbase.h"






BOOL

ClearEventLogA (
    HANDLE hEventLog,
    LPCSTR lpBackupFileName
    );

BOOL

ClearEventLogW (
    HANDLE hEventLog,
    LPCWSTR lpBackupFileName
    );




#line 5186 "d:\\msvc20\\include/winbase.h"


BOOL

BackupEventLogA (
    HANDLE hEventLog,
    LPCSTR lpBackupFileName
    );

BOOL

BackupEventLogW (
    HANDLE hEventLog,
    LPCWSTR lpBackupFileName
    );




#line 5206 "d:\\msvc20\\include/winbase.h"


BOOL

CloseEventLog (
    HANDLE hEventLog
    );


BOOL

DeregisterEventSource (
    HANDLE hEventLog
    );


BOOL

NotifyChangeEventLog (
    HANDLE hEventLog,
    HANDLE hEvent
    );


BOOL

GetNumberOfEventLogRecords (
    HANDLE hEventLog,
    PDWORD NumberOfRecords
    );


BOOL

GetOldestEventLogRecord (
    HANDLE hEventLog,
    PDWORD OldestRecord
    );


HANDLE

OpenEventLogA (
    LPCSTR lpUNCServerName,
    LPCSTR lpSourceName
    );

HANDLE

OpenEventLogW (
    LPCWSTR lpUNCServerName,
    LPCWSTR lpSourceName
    );




#line 5264 "d:\\msvc20\\include/winbase.h"


HANDLE

RegisterEventSourceA (
    LPCSTR lpUNCServerName,
    LPCSTR lpSourceName
    );

HANDLE

RegisterEventSourceW (
    LPCWSTR lpUNCServerName,
    LPCWSTR lpSourceName
    );




#line 5284 "d:\\msvc20\\include/winbase.h"


HANDLE

OpenBackupEventLogA (
    LPCSTR lpUNCServerName,
    LPCSTR lpFileName
    );

HANDLE

OpenBackupEventLogW (
    LPCWSTR lpUNCServerName,
    LPCWSTR lpFileName
    );




#line 5304 "d:\\msvc20\\include/winbase.h"


BOOL

ReadEventLogA (
     HANDLE     hEventLog,
     DWORD      dwReadFlags,
     DWORD      dwRecordOffset,
     LPVOID     lpBuffer,
     DWORD      nNumberOfBytesToRead,
     DWORD      *pnBytesRead,
     DWORD      *pnMinNumberOfBytesNeeded
    );

BOOL

ReadEventLogW (
     HANDLE     hEventLog,
     DWORD      dwReadFlags,
     DWORD      dwRecordOffset,
     LPVOID     lpBuffer,
     DWORD      nNumberOfBytesToRead,
     DWORD      *pnBytesRead,
     DWORD      *pnMinNumberOfBytesNeeded
    );




#line 5334 "d:\\msvc20\\include/winbase.h"


BOOL

ReportEventA (
     HANDLE     hEventLog,
     WORD       wType,
     WORD       wCategory,
     DWORD      dwEventID,
     PSID       lpUserSid,
     WORD       wNumStrings,
     DWORD      dwDataSize,
     LPCSTR   *lpStrings,
     LPVOID     lpRawData
    );

BOOL

ReportEventW (
     HANDLE     hEventLog,
     WORD       wType,
     WORD       wCategory,
     DWORD      dwEventID,
     PSID       lpUserSid,
     WORD       wNumStrings,
     DWORD      dwDataSize,
     LPCWSTR   *lpStrings,
     LPVOID     lpRawData
    );




#line 5368 "d:\\msvc20\\include/winbase.h"








BOOL

DuplicateToken(
    HANDLE ExistingTokenHandle,
    SECURITY_IMPERSONATION_LEVEL ImpersonationLevel,
    PHANDLE DuplicateTokenHandle
    );


BOOL

GetKernelObjectSecurity (
    HANDLE Handle,
    SECURITY_INFORMATION RequestedInformation,
    PSECURITY_DESCRIPTOR pSecurityDescriptor,
    DWORD nLength,
    LPDWORD lpnLengthNeeded
    );


BOOL

ImpersonateNamedPipeClient(
    HANDLE hNamedPipe
    );


BOOL

ImpersonateSelf(
    SECURITY_IMPERSONATION_LEVEL ImpersonationLevel
    );



BOOL

RevertToSelf (
    void
    );


BOOL

SetThreadToken (
    PHANDLE Thread,
    HANDLE Token
    );


BOOL

AccessCheck (
    PSECURITY_DESCRIPTOR pSecurityDescriptor,
    HANDLE ClientToken,
    DWORD DesiredAccess,
    PGENERIC_MAPPING GenericMapping,
    PPRIVILEGE_SET PrivilegeSet,
    LPDWORD PrivilegeSetLength,
    LPDWORD GrantedAccess,
    LPBOOL AccessStatus
    );



BOOL

OpenProcessToken (
    HANDLE ProcessHandle,
    DWORD DesiredAccess,
    PHANDLE TokenHandle
    );



BOOL

OpenThreadToken (
    HANDLE ThreadHandle,
    DWORD DesiredAccess,
    BOOL OpenAsSelf,
    PHANDLE TokenHandle
    );



BOOL

GetTokenInformation (
    HANDLE TokenHandle,
    TOKEN_INFORMATION_CLASS TokenInformationClass,
    LPVOID TokenInformation,
    DWORD TokenInformationLength,
    PDWORD ReturnLength
    );



BOOL

SetTokenInformation (
    HANDLE TokenHandle,
    TOKEN_INFORMATION_CLASS TokenInformationClass,
    LPVOID TokenInformation,
    DWORD TokenInformationLength
    );



BOOL

AdjustTokenPrivileges (
    HANDLE TokenHandle,
    BOOL DisableAllPrivileges,
    PTOKEN_PRIVILEGES NewState,
    DWORD BufferLength,
    PTOKEN_PRIVILEGES PreviousState,
    PDWORD ReturnLength
    );



BOOL

AdjustTokenGroups (
    HANDLE TokenHandle,
    BOOL ResetToDefault,
    PTOKEN_GROUPS NewState,
    DWORD BufferLength,
    PTOKEN_GROUPS PreviousState,
    PDWORD ReturnLength
    );



BOOL

PrivilegeCheck (
    HANDLE ClientToken,
    PPRIVILEGE_SET RequiredPrivileges,
    LPBOOL pfResult
    );



BOOL

AccessCheckAndAuditAlarmA (
    LPCSTR SubsystemName,
    LPVOID HandleId,
    LPSTR ObjectTypeName,
    LPSTR ObjectName,
    PSECURITY_DESCRIPTOR SecurityDescriptor,
    DWORD DesiredAccess,
    PGENERIC_MAPPING GenericMapping,
    BOOL ObjectCreation,
    LPDWORD GrantedAccess,
    LPBOOL AccessStatus,
    LPBOOL pfGenerateOnClose
    );

BOOL

AccessCheckAndAuditAlarmW (
    LPCWSTR SubsystemName,
    LPVOID HandleId,
    LPWSTR ObjectTypeName,
    LPWSTR ObjectName,
    PSECURITY_DESCRIPTOR SecurityDescriptor,
    DWORD DesiredAccess,
    PGENERIC_MAPPING GenericMapping,
    BOOL ObjectCreation,
    LPDWORD GrantedAccess,
    LPBOOL AccessStatus,
    LPBOOL pfGenerateOnClose
    );




#line 5557 "d:\\msvc20\\include/winbase.h"



BOOL

ObjectOpenAuditAlarmA (
    LPCSTR SubsystemName,
    LPVOID HandleId,
    LPSTR ObjectTypeName,
    LPSTR ObjectName,
    PSECURITY_DESCRIPTOR pSecurityDescriptor,
    HANDLE ClientToken,
    DWORD DesiredAccess,
    DWORD GrantedAccess,
    PPRIVILEGE_SET Privileges,
    BOOL ObjectCreation,
    BOOL AccessGranted,
    LPBOOL GenerateOnClose
    );

BOOL

ObjectOpenAuditAlarmW (
    LPCWSTR SubsystemName,
    LPVOID HandleId,
    LPWSTR ObjectTypeName,
    LPWSTR ObjectName,
    PSECURITY_DESCRIPTOR pSecurityDescriptor,
    HANDLE ClientToken,
    DWORD DesiredAccess,
    DWORD GrantedAccess,
    PPRIVILEGE_SET Privileges,
    BOOL ObjectCreation,
    BOOL AccessGranted,
    LPBOOL GenerateOnClose
    );




#line 5598 "d:\\msvc20\\include/winbase.h"



BOOL

ObjectPrivilegeAuditAlarmA (
    LPCSTR SubsystemName,
    LPVOID HandleId,
    HANDLE ClientToken,
    DWORD DesiredAccess,
    PPRIVILEGE_SET Privileges,
    BOOL AccessGranted
    );

BOOL

ObjectPrivilegeAuditAlarmW (
    LPCWSTR SubsystemName,
    LPVOID HandleId,
    HANDLE ClientToken,
    DWORD DesiredAccess,
    PPRIVILEGE_SET Privileges,
    BOOL AccessGranted
    );




#line 5627 "d:\\msvc20\\include/winbase.h"



BOOL

ObjectCloseAuditAlarmA (
    LPCSTR SubsystemName,
    LPVOID HandleId,
    BOOL GenerateOnClose
    );

BOOL

ObjectCloseAuditAlarmW (
    LPCWSTR SubsystemName,
    LPVOID HandleId,
    BOOL GenerateOnClose
    );




#line 5650 "d:\\msvc20\\include/winbase.h"



BOOL

PrivilegedServiceAuditAlarmA (
    LPCSTR SubsystemName,
    LPCSTR ServiceName,
    HANDLE ClientToken,
    PPRIVILEGE_SET Privileges,
    BOOL AccessGranted
    );

BOOL

PrivilegedServiceAuditAlarmW (
    LPCWSTR SubsystemName,
    LPCWSTR ServiceName,
    HANDLE ClientToken,
    PPRIVILEGE_SET Privileges,
    BOOL AccessGranted
    );




#line 5677 "d:\\msvc20\\include/winbase.h"



BOOL

IsValidSid (
    PSID pSid
    );



BOOL

EqualSid (
    PSID pSid1,
    PSID pSid2
    );



BOOL

EqualPrefixSid (
    PSID pSid1,
    PSID pSid2
    );



DWORD

GetSidLengthRequired (
    UCHAR nSubAuthorityCount
    );



BOOL

AllocateAndInitializeSid (
    PSID_IDENTIFIER_AUTHORITY pIdentifierAuthority,
    BYTE nSubAuthorityCount,
    DWORD nSubAuthority0,
    DWORD nSubAuthority1,
    DWORD nSubAuthority2,
    DWORD nSubAuthority3,
    DWORD nSubAuthority4,
    DWORD nSubAuthority5,
    DWORD nSubAuthority6,
    DWORD nSubAuthority7,
    PSID *pSid
    );


PVOID

FreeSid(
    PSID pSid
    );


BOOL

InitializeSid (
    PSID Sid,
    PSID_IDENTIFIER_AUTHORITY pIdentifierAuthority,
    BYTE nSubAuthorityCount
    );



PSID_IDENTIFIER_AUTHORITY

GetSidIdentifierAuthority (
    PSID pSid
    );



PDWORD

GetSidSubAuthority (
    PSID pSid,
    DWORD nSubAuthority
    );



PUCHAR

GetSidSubAuthorityCount (
    PSID pSid
    );



DWORD

GetLengthSid (
    PSID pSid
    );



BOOL

CopySid (
    DWORD nDestinationSidLength,
    PSID pDestinationSid,
    PSID pSourceSid
    );



BOOL

AreAllAccessesGranted (
    DWORD GrantedAccess,
    DWORD DesiredAccess
    );



BOOL

AreAnyAccessesGranted (
    DWORD GrantedAccess,
    DWORD DesiredAccess
    );



void

MapGenericMask (
    PDWORD AccessMask,
    PGENERIC_MAPPING GenericMapping
    );



BOOL

IsValidAcl (
    PACL pAcl
    );



BOOL

InitializeAcl (
    PACL pAcl,
    DWORD nAclLength,
    DWORD dwAclRevision
    );



BOOL

GetAclInformation (
    PACL pAcl,
    LPVOID pAclInformation,
    DWORD nAclInformationLength,
    ACL_INFORMATION_CLASS dwAclInformationClass
    );



BOOL

SetAclInformation (
    PACL pAcl,
    LPVOID pAclInformation,
    DWORD nAclInformationLength,
    ACL_INFORMATION_CLASS dwAclInformationClass
    );



BOOL

AddAce (
    PACL pAcl,
    DWORD dwAceRevision,
    DWORD dwStartingAceIndex,
    LPVOID pAceList,
    DWORD nAceListLength
    );



BOOL

DeleteAce (
    PACL pAcl,
    DWORD dwAceIndex
    );



BOOL

GetAce (
    PACL pAcl,
    DWORD dwAceIndex,
    LPVOID *pAce
    );



BOOL

AddAccessAllowedAce (
    PACL pAcl,
    DWORD dwAceRevision,
    DWORD AccessMask,
    PSID pSid
    );



BOOL

AddAccessDeniedAce (
    PACL pAcl,
    DWORD dwAceRevision,
    DWORD AccessMask,
    PSID pSid
    );



BOOL

AddAuditAccessAce(
    PACL pAcl,
    DWORD dwAceRevision,
    DWORD dwAccessMask,
    PSID pSid,
    BOOL bAuditSuccess,
    BOOL bAuditFailure
    );



BOOL

FindFirstFreeAce (
    PACL pAcl,
    LPVOID *pAce
    );



BOOL

InitializeSecurityDescriptor (
    PSECURITY_DESCRIPTOR pSecurityDescriptor,
    DWORD dwRevision
    );



BOOL

IsValidSecurityDescriptor (
    PSECURITY_DESCRIPTOR pSecurityDescriptor
    );



DWORD

GetSecurityDescriptorLength (
    PSECURITY_DESCRIPTOR pSecurityDescriptor
    );



BOOL

GetSecurityDescriptorControl (
    PSECURITY_DESCRIPTOR pSecurityDescriptor,
    PSECURITY_DESCRIPTOR_CONTROL pControl,
    LPDWORD lpdwRevision
    );



BOOL

SetSecurityDescriptorDacl (
    PSECURITY_DESCRIPTOR pSecurityDescriptor,
    BOOL bDaclPresent,
    PACL pDacl,
    BOOL bDaclDefaulted
    );



BOOL

GetSecurityDescriptorDacl (
    PSECURITY_DESCRIPTOR pSecurityDescriptor,
    LPBOOL lpbDaclPresent,
    PACL *pDacl,
    LPBOOL lpbDaclDefaulted
    );



BOOL

SetSecurityDescriptorSacl (
    PSECURITY_DESCRIPTOR pSecurityDescriptor,
    BOOL bSaclPresent,
    PACL pSacl,
    BOOL bSaclDefaulted
    );



BOOL

GetSecurityDescriptorSacl (
    PSECURITY_DESCRIPTOR pSecurityDescriptor,
    LPBOOL lpbSaclPresent,
    PACL *pSacl,
    LPBOOL lpbSaclDefaulted
    );



BOOL

SetSecurityDescriptorOwner (
    PSECURITY_DESCRIPTOR pSecurityDescriptor,
    PSID pOwner,
    BOOL bOwnerDefaulted
    );



BOOL

GetSecurityDescriptorOwner (
    PSECURITY_DESCRIPTOR pSecurityDescriptor,
    PSID *pOwner,
    LPBOOL lpbOwnerDefaulted
    );



BOOL

SetSecurityDescriptorGroup (
    PSECURITY_DESCRIPTOR pSecurityDescriptor,
    PSID pGroup,
    BOOL bGroupDefaulted
    );



BOOL

GetSecurityDescriptorGroup (
    PSECURITY_DESCRIPTOR pSecurityDescriptor,
    PSID *pGroup,
    LPBOOL lpbGroupDefaulted
    );



BOOL

CreatePrivateObjectSecurity (
    PSECURITY_DESCRIPTOR ParentDescriptor,
    PSECURITY_DESCRIPTOR CreatorDescriptor,
    PSECURITY_DESCRIPTOR * NewDescriptor,
    BOOL IsDirectoryObject,
    HANDLE Token,
    PGENERIC_MAPPING GenericMapping
    );



BOOL

SetPrivateObjectSecurity (
    SECURITY_INFORMATION SecurityInformation,
    PSECURITY_DESCRIPTOR ModificationDescriptor,
    PSECURITY_DESCRIPTOR *ObjectsSecurityDescriptor,
    PGENERIC_MAPPING GenericMapping,
    HANDLE Token
    );



BOOL

GetPrivateObjectSecurity (
    PSECURITY_DESCRIPTOR ObjectDescriptor,
    SECURITY_INFORMATION SecurityInformation,
    PSECURITY_DESCRIPTOR ResultantDescriptor,
    DWORD DescriptorLength,
    PDWORD ReturnLength
    );



BOOL

DestroyPrivateObjectSecurity (
    PSECURITY_DESCRIPTOR * ObjectDescriptor
    );



BOOL

MakeSelfRelativeSD (
    PSECURITY_DESCRIPTOR pAbsoluteSecurityDescriptor,
    PSECURITY_DESCRIPTOR pSelfRelativeSecurityDescriptor,
    LPDWORD lpdwBufferLength
    );



BOOL

MakeAbsoluteSD (
    PSECURITY_DESCRIPTOR pSelfRelativeSecurityDescriptor,
    PSECURITY_DESCRIPTOR pAbsoluteSecurityDescriptor,
    LPDWORD lpdwAbsoluteSecurityDescriptorSize,
    PACL pDacl,
    LPDWORD lpdwDaclSize,
    PACL pSacl,
    LPDWORD lpdwSaclSize,
    PSID pOwner,
    LPDWORD lpdwOwnerSize,
    PSID pPrimaryGroup,
    LPDWORD lpdwPrimaryGroupSize
    );



BOOL

SetFileSecurityA (
    LPCSTR lpFileName,
    SECURITY_INFORMATION SecurityInformation,
    PSECURITY_DESCRIPTOR pSecurityDescriptor
    );

BOOL

SetFileSecurityW (
    LPCWSTR lpFileName,
    SECURITY_INFORMATION SecurityInformation,
    PSECURITY_DESCRIPTOR pSecurityDescriptor
    );




#line 6145 "d:\\msvc20\\include/winbase.h"



BOOL

GetFileSecurityA (
    LPCSTR lpFileName,
    SECURITY_INFORMATION RequestedInformation,
    PSECURITY_DESCRIPTOR pSecurityDescriptor,
    DWORD nLength,
    LPDWORD lpnLengthNeeded
    );

BOOL

GetFileSecurityW (
    LPCWSTR lpFileName,
    SECURITY_INFORMATION RequestedInformation,
    PSECURITY_DESCRIPTOR pSecurityDescriptor,
    DWORD nLength,
    LPDWORD lpnLengthNeeded
    );




#line 6172 "d:\\msvc20\\include/winbase.h"



BOOL

SetKernelObjectSecurity (
    HANDLE Handle,
    SECURITY_INFORMATION SecurityInformation,
    PSECURITY_DESCRIPTOR SecurityDescriptor
    );




HANDLE

FindFirstChangeNotificationA(
    LPCSTR lpPathName,
    BOOL bWatchSubtree,
    DWORD dwNotifyFilter
    );

HANDLE

FindFirstChangeNotificationW(
    LPCWSTR lpPathName,
    BOOL bWatchSubtree,
    DWORD dwNotifyFilter
    );




#line 6206 "d:\\msvc20\\include/winbase.h"


BOOL

FindNextChangeNotification(
    HANDLE hChangeHandle
    );


BOOL

FindCloseChangeNotification(
    HANDLE hChangeHandle
    );


BOOL

VirtualLock(
    LPVOID lpAddress,
    DWORD dwSize
    );


BOOL

VirtualUnlock(
    LPVOID lpAddress,
    DWORD dwSize
    );


LPVOID

MapViewOfFileEx(
    HANDLE hFileMappingObject,
    DWORD dwDesiredAccess,
    DWORD dwFileOffsetHigh,
    DWORD dwFileOffsetLow,
    DWORD dwNumberOfBytesToMap,
    LPVOID lpBaseAddress
    );


BOOL

SetPriorityClass(
    HANDLE hProcess,
    DWORD dwPriorityClass
    );


DWORD

GetPriorityClass(
    HANDLE hProcess
    );


BOOL

IsBadReadPtr(
    const void *lp,
    UINT ucb
    );


BOOL

IsBadWritePtr(
    LPVOID lp,
    UINT ucb
    );


BOOL

IsBadHugeReadPtr(
    const void *lp,
    UINT ucb
    );


BOOL

IsBadHugeWritePtr(
    LPVOID lp,
    UINT ucb
    );


BOOL

IsBadCodePtr(
    FARPROC lpfn
    );


BOOL

IsBadStringPtrA(
    LPCSTR lpsz,
    UINT ucchMax
    );

BOOL

IsBadStringPtrW(
    LPCWSTR lpsz,
    UINT ucchMax
    );




#line 6322 "d:\\msvc20\\include/winbase.h"


BOOL

LookupAccountSidA(
    LPCSTR lpSystemName,
    PSID Sid,
    LPSTR Name,
    LPDWORD cbName,
    LPSTR ReferencedDomainName,
    LPDWORD cbReferencedDomainName,
    PSID_NAME_USE peUse
    );

BOOL

LookupAccountSidW(
    LPCWSTR lpSystemName,
    PSID Sid,
    LPWSTR Name,
    LPDWORD cbName,
    LPWSTR ReferencedDomainName,
    LPDWORD cbReferencedDomainName,
    PSID_NAME_USE peUse
    );




#line 6352 "d:\\msvc20\\include/winbase.h"


BOOL

LookupAccountNameA(
    LPCSTR lpSystemName,
    LPCSTR lpAccountName,
    PSID Sid,
    LPDWORD cbSid,
    LPSTR ReferencedDomainName,
    LPDWORD cbReferencedDomainName,
    PSID_NAME_USE peUse
    );

BOOL

LookupAccountNameW(
    LPCWSTR lpSystemName,
    LPCWSTR lpAccountName,
    PSID Sid,
    LPDWORD cbSid,
    LPWSTR ReferencedDomainName,
    LPDWORD cbReferencedDomainName,
    PSID_NAME_USE peUse
    );




#line 6382 "d:\\msvc20\\include/winbase.h"


BOOL

LookupPrivilegeValueA(
    LPCSTR lpSystemName,
    LPCSTR lpName,
    PLUID   lpLuid
    );

BOOL

LookupPrivilegeValueW(
    LPCWSTR lpSystemName,
    LPCWSTR lpName,
    PLUID   lpLuid
    );




#line 6404 "d:\\msvc20\\include/winbase.h"


BOOL

LookupPrivilegeNameA(
    LPCSTR lpSystemName,
    PLUID   lpLuid,
    LPSTR lpName,
    LPDWORD cbName
    );

BOOL

LookupPrivilegeNameW(
    LPCWSTR lpSystemName,
    PLUID   lpLuid,
    LPWSTR lpName,
    LPDWORD cbName
    );




#line 6428 "d:\\msvc20\\include/winbase.h"


BOOL

LookupPrivilegeDisplayNameA(
    LPCSTR lpSystemName,
    LPCSTR lpName,
    LPSTR lpDisplayName,
    LPDWORD cbDisplayName,
    LPDWORD lpLanguageId
    );

BOOL

LookupPrivilegeDisplayNameW(
    LPCWSTR lpSystemName,
    LPCWSTR lpName,
    LPWSTR lpDisplayName,
    LPDWORD cbDisplayName,
    LPDWORD lpLanguageId
    );




#line 6454 "d:\\msvc20\\include/winbase.h"


BOOL

AllocateLocallyUniqueId(
    PLUID Luid
    );


BOOL

BuildCommDCBA(
    LPCSTR lpDef,
    LPDCB lpDCB
    );

BOOL

BuildCommDCBW(
    LPCWSTR lpDef,
    LPDCB lpDCB
    );




#line 6481 "d:\\msvc20\\include/winbase.h"


BOOL

BuildCommDCBAndTimeoutsA(
    LPCSTR lpDef,
    LPDCB lpDCB,
    LPCOMMTIMEOUTS lpCommTimeouts
    );

BOOL

BuildCommDCBAndTimeoutsW(
    LPCWSTR lpDef,
    LPDCB lpDCB,
    LPCOMMTIMEOUTS lpCommTimeouts
    );




#line 6503 "d:\\msvc20\\include/winbase.h"


BOOL

CommConfigDialogA(
    LPCSTR lpszName,
    HWND hWnd,
    LPCOMMCONFIG lpCC
    );

BOOL

CommConfigDialogW(
    LPCWSTR lpszName,
    HWND hWnd,
    LPCOMMCONFIG lpCC
    );




#line 6525 "d:\\msvc20\\include/winbase.h"


BOOL

GetDefaultCommConfigA(
    LPCSTR lpszName,
    LPCOMMCONFIG lpCC,
    LPDWORD lpdwSize
    );

BOOL

GetDefaultCommConfigW(
    LPCWSTR lpszName,
    LPCOMMCONFIG lpCC,
    LPDWORD lpdwSize
    );




#line 6547 "d:\\msvc20\\include/winbase.h"


BOOL

SetDefaultCommConfigA(
    LPCSTR lpszName,
    LPCOMMCONFIG lpCC,
    DWORD dwSize
    );

BOOL

SetDefaultCommConfigW(
    LPCWSTR lpszName,
    LPCOMMCONFIG lpCC,
    DWORD dwSize
    );




#line 6569 "d:\\msvc20\\include/winbase.h"





BOOL

GetComputerNameA (
    LPSTR lpBuffer,
    LPDWORD nSize
    );

BOOL

GetComputerNameW (
    LPWSTR lpBuffer,
    LPDWORD nSize
    );




#line 6592 "d:\\msvc20\\include/winbase.h"


BOOL

SetComputerNameA (
    LPCSTR lpComputerName
    );

BOOL

SetComputerNameW (
    LPCWSTR lpComputerName
    );




#line 6610 "d:\\msvc20\\include/winbase.h"


BOOL

GetUserNameA (
    LPSTR lpBuffer,
    LPDWORD nSize
    );

BOOL

GetUserNameW (
    LPWSTR lpBuffer,
    LPDWORD nSize
    );




#line 6630 "d:\\msvc20\\include/winbase.h"






BOOL

QueryPerformanceCounter(
    LARGE_INTEGER *lpPerformanceCount
    );


BOOL

QueryPerformanceFrequency(
    LARGE_INTEGER *lpFrequency
    );

typedef struct _OSVERSIONINFOA {
    DWORD dwOSVersionInfoSize;
    DWORD dwMajorVersion;
    DWORD dwMinorVersion;
    DWORD dwBuildNumber;
    DWORD dwPlatformId;
    CHAR   szCSDVersion[ 128 ];       
} OSVERSIONINFOA, *POSVERSIONINFOA, *LPOSVERSIONINFOA;
typedef struct _OSVERSIONINFOW {
    DWORD dwOSVersionInfoSize;
    DWORD dwMajorVersion;
    DWORD dwMinorVersion;
    DWORD dwBuildNumber;
    DWORD dwPlatformId;
    WCHAR  szCSDVersion[ 128 ];       
} OSVERSIONINFOW, *POSVERSIONINFOW, *LPOSVERSIONINFOW;





typedef OSVERSIONINFOA OSVERSIONINFO;
typedef POSVERSIONINFOA POSVERSIONINFO;
typedef LPOSVERSIONINFOA LPOSVERSIONINFO;
#line 6674 "d:\\msvc20\\include/winbase.h"










BOOL

GetVersionExA(
    LPOSVERSIONINFOA lpVersionInformation
    );

BOOL

GetVersionExW(
    LPOSVERSIONINFOW lpVersionInformation
    );




#line 6700 "d:\\msvc20\\include/winbase.h"






#line 1 "d:\\msvc20\\include/winerror.h"






























































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































#line 6336 "d:\\msvc20\\include/winerror.h"























































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































#line 8664 "d:\\msvc20\\include/winerror.h"
#line 6707 "d:\\msvc20\\include/winbase.h"












#line 6720 "d:\\msvc20\\include/winbase.h"
#line 108 "d:\\msvc20\\include/windows.h"
#line 1 "d:\\msvc20\\include/wingdi.h"




















#line 22 "d:\\msvc20\\include/wingdi.h"









#line 32 "d:\\msvc20\\include/wingdi.h"
















































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































#line 3249 "d:\\msvc20\\include/wingdi.h"
#line 109 "d:\\msvc20\\include/windows.h"
#line 1 "d:\\msvc20\\include/winuser.h"




















#line 22 "d:\\msvc20\\include/winuser.h"







#line 30 "d:\\msvc20\\include/winuser.h"

#line 1 "d:\\msvc20\\include/stdarg.h"




























typedef char *	va_list;
#line 31 "d:\\msvc20\\include/stdarg.h"

#line 33 "d:\\msvc20\\include/stdarg.h"






























#line 64 "d:\\msvc20\\include/stdarg.h"

































#line 98 "d:\\msvc20\\include/stdarg.h"











#line 110 "d:\\msvc20\\include/stdarg.h"






#line 117 "d:\\msvc20\\include/stdarg.h"
#line 32 "d:\\msvc20\\include/winuser.h"



typedef HANDLE HDWP;
typedef void MENUTEMPLATEA;
typedef void MENUTEMPLATEW;



typedef MENUTEMPLATEA MENUTEMPLATE;
#line 43 "d:\\msvc20\\include/winuser.h"
typedef PVOID LPMENUTEMPLATEA;
typedef PVOID LPMENUTEMPLATEW;



typedef LPMENUTEMPLATEA LPMENUTEMPLATE;
#line 50 "d:\\msvc20\\include/winuser.h"

typedef LRESULT (* WNDPROC)(HWND, UINT, WPARAM, LPARAM);





















typedef FARPROC DLGPROC;
typedef FARPROC TIMERPROC;
typedef FARPROC GRAYSTRINGPROC;
typedef FARPROC WNDENUMPROC;
typedef FARPROC HOOKPROC;
typedef FARPROC SENDASYNCPROC;

typedef FARPROC EDITWORDBREAKPROCA;
typedef FARPROC EDITWORDBREAKPROCW;

typedef FARPROC PROPENUMPROCA;
typedef FARPROC PROPENUMPROCW;

typedef FARPROC PROPENUMPROCEXA;
typedef FARPROC PROPENUMPROCEXW;

#line 90 "d:\\msvc20\\include/winuser.h"






typedef PROPENUMPROCA        PROPENUMPROC;
typedef PROPENUMPROCEXA      PROPENUMPROCEX;
typedef EDITWORDBREAKPROCA   EDITWORDBREAKPROC;
#line 100 "d:\\msvc20\\include/winuser.h"








#line 109 "d:\\msvc20\\include/winuser.h"
























#line 134 "d:\\msvc20\\include/winuser.h"


int

wvsprintfA(
    LPSTR,
    LPCSTR,
    va_list arglist);

int

wvsprintfW(
    LPWSTR,
    LPCWSTR,
    va_list arglist);




#line 154 "d:\\msvc20\\include/winuser.h"

 int  wsprintfA(LPSTR, LPCSTR, ...);
 int  wsprintfW(LPWSTR, LPCWSTR, ...);




#line 162 "d:\\msvc20\\include/winuser.h"





































































#line 232 "d:\\msvc20\\include/winuser.h"





























































































































#line 358 "d:\\msvc20\\include/winuser.h"






































































































































































HKL

LoadKeyboardLayoutA(
    LPCSTR pwszKLID,
    UINT Flags);

HKL

LoadKeyboardLayoutW(
    LPCWSTR pwszKLID,
    UINT Flags);




#line 540 "d:\\msvc20\\include/winuser.h"


BOOL

ActivateKeyboardLayout(
    HKL hkl,
    UINT Flags);


BOOL

UnloadKeyboardLayout(
    HKL hkl);


BOOL

GetKeyboardLayoutNameA(
    LPSTR pwszKLID);

BOOL

GetKeyboardLayoutNameW(
    LPWSTR pwszKLID);




#line 569 "d:\\msvc20\\include/winuser.h"
















HDESK

GetThreadDesktop(
    DWORD);

#line 591 "d:\\msvc20\\include/winuser.h"
















HWINSTA

GetProcessWindowStation(
    void);
#line 612 "d:\\msvc20\\include/winuser.h"




BOOL

SetUserObjectSecurity(
    HANDLE hObj,
    PSECURITY_INFORMATION pSIRequested,
    PSECURITY_DESCRIPTOR pSID);


BOOL

GetUserObjectSecurity(
    HANDLE hObj,
    PSECURITY_INFORMATION pSIRequested,
    PSECURITY_DESCRIPTOR pSID,
    DWORD nLength,
    LPDWORD lpnLengthNeeded);

#line 634 "d:\\msvc20\\include/winuser.h"


typedef struct tagWNDCLASSA {
    UINT        style;
    WNDPROC     lpfnWndProc;
    int         cbClsExtra;
    int         cbWndExtra;
    HINSTANCE   hInstance;
    HICON       hIcon;
    HCURSOR     hCursor;
    HBRUSH      hbrBackground;
    LPCSTR      lpszMenuName;
    LPCSTR      lpszClassName;
} WNDCLASSA, *PWNDCLASSA,  *NPWNDCLASSA,  *LPWNDCLASSA;
typedef struct tagWNDCLASSW {
    UINT        style;
    WNDPROC     lpfnWndProc;
    int         cbClsExtra;
    int         cbWndExtra;
    HINSTANCE   hInstance;
    HICON       hIcon;
    HCURSOR     hCursor;
    HBRUSH      hbrBackground;
    LPCWSTR     lpszMenuName;
    LPCWSTR     lpszClassName;
} WNDCLASSW, *PWNDCLASSW,  *NPWNDCLASSW,  *LPWNDCLASSW;






typedef WNDCLASSA WNDCLASS;
typedef PWNDCLASSA PWNDCLASS;
typedef NPWNDCLASSA NPWNDCLASS;
typedef LPWNDCLASSA LPWNDCLASS;
#line 671 "d:\\msvc20\\include/winuser.h"


























































#line 730 "d:\\msvc20\\include/winuser.h"























































typedef struct tagMINMAXINFO {
    POINT ptReserved;
    POINT ptMaxSize;
    POINT ptMaxPosition;
    POINT ptMinTrackSize;
    POINT ptMaxTrackSize;
} MINMAXINFO, *PMINMAXINFO, *LPMINMAXINFO;






































typedef struct tagCOPYDATASTRUCT {
    DWORD dwData;
    DWORD cbData;
    PVOID lpData;
} COPYDATASTRUCT, *PCOPYDATASTRUCT;

















































































































































































#line 1013 "d:\\msvc20\\include/winuser.h"










UINT

RegisterWindowMessageA(
    LPCSTR lpString);

UINT

RegisterWindowMessageW(
    LPCWSTR lpString);




#line 1037 "d:\\msvc20\\include/winuser.h"






















typedef struct tagWINDOWPOS {
    HWND    hwnd;
    HWND    hwndInsertAfter;
    int     x;
    int     y;
    int     cx;
    int     cy;
    UINT    flags;
} WINDOWPOS, *LPWINDOWPOS, *PWINDOWPOS;




typedef struct tagNCCALCSIZE_PARAMS {
    RECT       rgrc[3];
    PWINDOWPOS lppos;
} NCCALCSIZE_PARAMS, *LPNCCALCSIZE_PARAMS;


























#line 1103 "d:\\msvc20\\include/winuser.h"

#line 1105 "d:\\msvc20\\include/winuser.h"













































































#line 1183 "d:\\msvc20\\include/winuser.h"







































#line 1223 "d:\\msvc20\\include/winuser.h"










typedef struct tagACCEL {
    BYTE   fVirt;               
    WORD   key;
    WORD   cmd;
} ACCEL, *LPACCEL;

typedef struct tagPAINTSTRUCT {
    HDC         hdc;
    BOOL        fErase;
    RECT        rcPaint;
    BOOL        fRestore;
    BOOL        fIncUpdate;
    BYTE        rgbReserved[32];
} PAINTSTRUCT, *PPAINTSTRUCT, *NPPAINTSTRUCT, *LPPAINTSTRUCT;

typedef struct tagCREATESTRUCTA {
    LPVOID      lpCreateParams;
    HINSTANCE   hInstance;
    HMENU       hMenu;
    HWND        hwndParent;
    int         cy;
    int         cx;
    int         y;
    int         x;
    LONG        style;
    LPCSTR      lpszName;
    LPCSTR      lpszClass;
    DWORD       dwExStyle;
} CREATESTRUCTA, *LPCREATESTRUCTA;
typedef struct tagCREATESTRUCTW {
    LPVOID      lpCreateParams;
    HINSTANCE   hInstance;
    HMENU       hMenu;
    HWND        hwndParent;
    int         cy;
    int         cx;
    int         y;
    int         x;
    LONG        style;
    LPCWSTR     lpszName;
    LPCWSTR     lpszClass;
    DWORD       dwExStyle;
} CREATESTRUCTW, *LPCREATESTRUCTW;




typedef CREATESTRUCTA CREATESTRUCT;
typedef LPCREATESTRUCTA LPCREATESTRUCT;
#line 1283 "d:\\msvc20\\include/winuser.h"

typedef struct tagWINDOWPLACEMENT {
    UINT  length;
    UINT  flags;
    UINT  showCmd;
    POINT ptMinPosition;
    POINT ptMaxPosition;
    RECT  rcNormalPosition;
} WINDOWPLACEMENT;
typedef WINDOWPLACEMENT *PWINDOWPLACEMENT, *LPWINDOWPLACEMENT;
































typedef struct tagMEASUREITEMSTRUCT {
    UINT       CtlType;
    UINT       CtlID;
    UINT       itemID;
    UINT       itemWidth;
    UINT       itemHeight;
    DWORD      itemData;
} MEASUREITEMSTRUCT,  *PMEASUREITEMSTRUCT,  *LPMEASUREITEMSTRUCT;






typedef struct tagDRAWITEMSTRUCT {
    UINT        CtlType;
    UINT        CtlID;
    UINT        itemID;
    UINT        itemAction;
    UINT        itemState;
    HWND        hwndItem;
    HDC         hDC;
    RECT        rcItem;
    DWORD       itemData;
} DRAWITEMSTRUCT,  *PDRAWITEMSTRUCT,  *LPDRAWITEMSTRUCT;




typedef struct tagDELETEITEMSTRUCT {
    UINT       CtlType;
    UINT       CtlID;
    UINT       itemID;
    HWND       hwndItem;
    UINT       itemData;
} DELETEITEMSTRUCT,  *PDELETEITEMSTRUCT,  *LPDELETEITEMSTRUCT;




typedef struct tagCOMPAREITEMSTRUCT {
    UINT        CtlType;
    UINT        CtlID;
    HWND        hwndItem;
    UINT        itemID1;
    DWORD       itemData1;
    UINT        itemID2;
    DWORD       itemData2;
    DWORD       dwLocaleId;
} COMPAREITEMSTRUCT,  *PCOMPAREITEMSTRUCT,  *LPCOMPAREITEMSTRUCT;




























































































BOOL

RegisterHotKey(
    HWND hWnd ,
    int id,
    UINT fsModifiers,
    UINT vk);


BOOL

UnregisterHotKey(
    HWND hWnd,
    int id);




























BOOL

ExitWindowsEx(
    UINT uFlags,
    DWORD dwReserved);


BOOL

SwapMouseButton(
    BOOL fSwap);


DWORD

GetMessagePos(
    void);


LONG

GetMessageTime(
    void);


LONG

GetMessageExtraInfo(
    void);



LRESULT

SendMessageA(
    HWND hWnd,
    UINT Msg,
    WPARAM wParam,
    LPARAM lParam);

LRESULT

SendMessageW(
    HWND hWnd,
    UINT Msg,
    WPARAM wParam,
    LPARAM lParam);




#line 1561 "d:\\msvc20\\include/winuser.h"


LRESULT

SendMessageTimeoutA(
    HWND hWnd,
    UINT Msg,
    WPARAM wParam,
    LPARAM lParam,
    UINT fuFlags,
    UINT uTimeout,
    LPDWORD lpdwResult);

LRESULT

SendMessageTimeoutW(
    HWND hWnd,
    UINT Msg,
    WPARAM wParam,
    LPARAM lParam,
    UINT fuFlags,
    UINT uTimeout,
    LPDWORD lpdwResult);




#line 1589 "d:\\msvc20\\include/winuser.h"


BOOL

SendNotifyMessageA(
    HWND hWnd,
    UINT Msg,
    WPARAM wParam,
    LPARAM lParam);

BOOL

SendNotifyMessageW(
    HWND hWnd,
    UINT Msg,
    WPARAM wParam,
    LPARAM lParam);




#line 1611 "d:\\msvc20\\include/winuser.h"


BOOL

SendMessageCallbackA(
    HWND hWnd,
    UINT Msg,
    WPARAM wParam,
    LPARAM lParam,
    SENDASYNCPROC lpResultCallBack,
    DWORD dwData);

BOOL

SendMessageCallbackW(
    HWND hWnd,
    UINT Msg,
    WPARAM wParam,
    LPARAM lParam,
    SENDASYNCPROC lpResultCallBack,
    DWORD dwData);




#line 1637 "d:\\msvc20\\include/winuser.h"



BOOL

PostMessageA(
    HWND hWnd,
    UINT Msg,
    WPARAM wParam,
    LPARAM lParam);

BOOL

PostMessageW(
    HWND hWnd,
    UINT Msg,
    WPARAM wParam,
    LPARAM lParam);




#line 1660 "d:\\msvc20\\include/winuser.h"


BOOL

PostThreadMessageA(
    DWORD idThread,
    UINT Msg,
    WPARAM wParam,
    LPARAM lParam);

BOOL

PostThreadMessageW(
    DWORD idThread,
    UINT Msg,
    WPARAM wParam,
    LPARAM lParam);




#line 1682 "d:\\msvc20\\include/winuser.h"









#line 1692 "d:\\msvc20\\include/winuser.h"







BOOL

AttachThreadInput(
    DWORD idAttach,
    DWORD idAttachTo,
    BOOL fAttach);



BOOL

ReplyMessage(
    LRESULT lResult);


BOOL

WaitMessage(
    void);


DWORD

WaitForInputIdle(
    HANDLE hProcess,
    DWORD dwMilliseconds);


LRESULT

DefWindowProcA(
    HWND hWnd,
    UINT Msg,
    WPARAM wParam,
    LPARAM lParam);

LRESULT

DefWindowProcW(
    HWND hWnd,
    UINT Msg,
    WPARAM wParam,
    LPARAM lParam);




#line 1747 "d:\\msvc20\\include/winuser.h"


void

PostQuitMessage(
    int nExitCode);






























LRESULT

CallWindowProcA(
    FARPROC lpPrevWndFunc,
    HWND hWnd,
    UINT Msg,
    WPARAM wParam,
    LPARAM lParam);

LRESULT

CallWindowProcW(
    FARPROC lpPrevWndFunc,
    HWND hWnd,
    UINT Msg,
    WPARAM wParam,
    LPARAM lParam);




#line 1805 "d:\\msvc20\\include/winuser.h"

#line 1807 "d:\\msvc20\\include/winuser.h"


BOOL

InSendMessage(
    void);


UINT

GetDoubleClickTime(
    void);


BOOL

SetDoubleClickTime(
    UINT);


ATOM

RegisterClassA(
    const WNDCLASSA *lpWndClass);

ATOM

RegisterClassW(
    const WNDCLASSW *lpWndClass);




#line 1841 "d:\\msvc20\\include/winuser.h"


BOOL

UnregisterClassA(
    LPCSTR lpClassName,
    HINSTANCE hInstance);

BOOL

UnregisterClassW(
    LPCWSTR lpClassName,
    HINSTANCE hInstance);




#line 1859 "d:\\msvc20\\include/winuser.h"


BOOL

GetClassInfoA(
    HINSTANCE hInstance ,
    LPCSTR lpClassName,
    LPWNDCLASSA lpWndClass);

BOOL

GetClassInfoW(
    HINSTANCE hInstance ,
    LPCWSTR lpClassName,
    LPWNDCLASSW lpWndClass);




#line 1879 "d:\\msvc20\\include/winuser.h"










HWND

CreateWindowExA(
    DWORD dwExStyle,
    LPCSTR lpClassName,
    LPCSTR lpWindowName,
    DWORD dwStyle,
    int X,
    int Y,
    int nWidth,
    int nHeight,
    HWND hWndParent ,
    HMENU hMenu,
    HINSTANCE hInstance,
    LPVOID lpParam);

HWND

CreateWindowExW(
    DWORD dwExStyle,
    LPCWSTR lpClassName,
    LPCWSTR lpWindowName,
    DWORD dwStyle,
    int X,
    int Y,
    int nWidth,
    int nHeight,
    HWND hWndParent ,
    HMENU hMenu,
    HINSTANCE hInstance,
    LPVOID lpParam);




#line 1925 "d:\\msvc20\\include/winuser.h"













#line 1939 "d:\\msvc20\\include/winuser.h"


BOOL

IsWindow(
    HWND hWnd);


BOOL

IsMenu(
    HMENU hMenu);


BOOL

IsChild(
    HWND hWndParent,
    HWND hWnd);


BOOL

DestroyWindow(
    HWND hWnd);


BOOL

ShowWindow(
    HWND hWnd,
    int nCmdShow);



BOOL

FlashWindow(
    HWND hWnd,
    BOOL bInvert);


BOOL

ShowOwnedPopups(
    HWND hWnd,
    BOOL fShow);


BOOL

OpenIcon(
    HWND hWnd);


BOOL

CloseWindow(
    HWND hWnd);


BOOL

MoveWindow(
    HWND hWnd,
    int X,
    int Y,
    int nWidth,
    int nHeight,
    BOOL bRepaint);



BOOL

SetWindowPos(
    HWND hWnd,
    HWND hWndInsertAfter ,
    int X,
    int Y,
    int cx,
    int cy,
    UINT uFlags);


BOOL

GetWindowPlacement(
    HWND hWnd,
    WINDOWPLACEMENT *lpwndpl);


BOOL

SetWindowPlacement(
    HWND hWnd,
    const WINDOWPLACEMENT *lpwndpl);





HDWP

BeginDeferWindowPos(
    int nNumWindows);


HDWP

DeferWindowPos(
    HDWP hWinPosInfo,
    HWND hWnd,
    HWND hWndInsertAfter ,
    int x,
    int y,
    int cx,
    int cy,
    UINT uFlags);


BOOL

EndDeferWindowPos(
    HDWP hWinPosInfo);

#line 2066 "d:\\msvc20\\include/winuser.h"


BOOL

IsWindowVisible(
    HWND hWnd);


BOOL

IsIconic(
    HWND hWnd);


BOOL

AnyPopup(
    void);


BOOL

BringWindowToTop(
    HWND hWnd);


BOOL

IsZoomed(
    HWND hWnd);



































#line 1 "d:\\msvc20\\include/pshpack2.h"































#line 33 "d:\\msvc20\\include/pshpack2.h"
#line 2132 "d:\\msvc20\\include/winuser.h"




typedef struct {
    DWORD style;
    DWORD dwExtendedStyle;
    WORD cdit;
    short x;
    short y;
    short cx;
    short cy;
} DLGTEMPLATE;
typedef DLGTEMPLATE *LPDLGTEMPLATEA;
typedef DLGTEMPLATE *LPDLGTEMPLATEW;



typedef LPDLGTEMPLATEA LPDLGTEMPLATE;
#line 2152 "d:\\msvc20\\include/winuser.h"
typedef const DLGTEMPLATE *LPCDLGTEMPLATEA;
typedef const DLGTEMPLATE *LPCDLGTEMPLATEW;



typedef LPCDLGTEMPLATEA LPCDLGTEMPLATE;
#line 2159 "d:\\msvc20\\include/winuser.h"




typedef struct {
    DWORD style;
    DWORD dwExtendedStyle;
    short x;
    short y;
    short cx;
    short cy;
    WORD id;
} DLGITEMTEMPLATE;
typedef DLGITEMTEMPLATE *PDLGITEMTEMPLATEA;
typedef DLGITEMTEMPLATE *PDLGITEMTEMPLATEW;



typedef PDLGITEMTEMPLATEA PDLGITEMTEMPLATE;
#line 2179 "d:\\msvc20\\include/winuser.h"
typedef DLGITEMTEMPLATE *LPDLGITEMTEMPLATEA;
typedef DLGITEMTEMPLATE *LPDLGITEMTEMPLATEW;



typedef LPDLGITEMTEMPLATEA LPDLGITEMTEMPLATE;
#line 2186 "d:\\msvc20\\include/winuser.h"


#line 1 "d:\\msvc20\\include/poppack.h"



































#line 37 "d:\\msvc20\\include/poppack.h"
#line 2189 "d:\\msvc20\\include/winuser.h"


HWND

CreateDialogParamA(
    HINSTANCE hInstance,
    LPCSTR lpTemplateName,
    HWND hWndParent ,
    DLGPROC lpDialogFunc,
    LPARAM dwInitParam);

HWND

CreateDialogParamW(
    HINSTANCE hInstance,
    LPCWSTR lpTemplateName,
    HWND hWndParent ,
    DLGPROC lpDialogFunc,
    LPARAM dwInitParam);




#line 2213 "d:\\msvc20\\include/winuser.h"


HWND

CreateDialogIndirectParamA(
    HINSTANCE hInstance,
    LPCDLGTEMPLATEA lpTemplate,
    HWND hWndParent,
    DLGPROC lpDialogFunc,
    LPARAM dwInitParam);

HWND

CreateDialogIndirectParamW(
    HINSTANCE hInstance,
    LPCDLGTEMPLATEW lpTemplate,
    HWND hWndParent,
    DLGPROC lpDialogFunc,
    LPARAM dwInitParam);




#line 2237 "d:\\msvc20\\include/winuser.h"









#line 2247 "d:\\msvc20\\include/winuser.h"









#line 2257 "d:\\msvc20\\include/winuser.h"


int

DialogBoxParamA(
    HINSTANCE hInstance,
    LPCSTR lpTemplateName,
    HWND hWndParent ,
    DLGPROC lpDialogFunc,
    LPARAM dwInitParam);

int

DialogBoxParamW(
    HINSTANCE hInstance,
    LPCWSTR lpTemplateName,
    HWND hWndParent ,
    DLGPROC lpDialogFunc,
    LPARAM dwInitParam);




#line 2281 "d:\\msvc20\\include/winuser.h"


int

DialogBoxIndirectParamA(
    HINSTANCE hInstance,
    LPCDLGTEMPLATEA hDialogTemplate,
    HWND hWndParent ,
    DLGPROC lpDialogFunc,
    LPARAM dwInitParam);

int

DialogBoxIndirectParamW(
    HINSTANCE hInstance,
    LPCDLGTEMPLATEW hDialogTemplate,
    HWND hWndParent ,
    DLGPROC lpDialogFunc,
    LPARAM dwInitParam);




#line 2305 "d:\\msvc20\\include/winuser.h"









#line 2315 "d:\\msvc20\\include/winuser.h"









#line 2325 "d:\\msvc20\\include/winuser.h"


BOOL

EndDialog(
    HWND hDlg,
    int nResult);


HWND

GetDlgItem(
    HWND hDlg,
    int nIDDlgItem);


BOOL

SetDlgItemInt(
    HWND hDlg,
    int nIDDlgItem,
    UINT uValue,
    BOOL bSigned);


UINT

GetDlgItemInt(
    HWND hDlg,
    int nIDDlgItem,
    BOOL *lpTranslated,
    BOOL bSigned);


BOOL

SetDlgItemTextA(
    HWND hDlg,
    int nIDDlgItem,
    LPCSTR lpString);

BOOL

SetDlgItemTextW(
    HWND hDlg,
    int nIDDlgItem,
    LPCWSTR lpString);




#line 2377 "d:\\msvc20\\include/winuser.h"


UINT

GetDlgItemTextA(
    HWND hDlg,
    int nIDDlgItem,
    LPSTR lpString,
    int nMaxCount);

UINT

GetDlgItemTextW(
    HWND hDlg,
    int nIDDlgItem,
    LPWSTR lpString,
    int nMaxCount);




#line 2399 "d:\\msvc20\\include/winuser.h"


BOOL

CheckDlgButton(
    HWND hDlg,
    int nIDButton,
    UINT uCheck);


BOOL

CheckRadioButton(
    HWND hDlg,
    int nIDFirstButton,
    int nIDLastButton,
    int nIDCheckButton);


UINT

IsDlgButtonChecked(
    HWND hDlg,
    int nIDButton);


LONG

SendDlgItemMessageA(
    HWND hDlg,
    int nIDDlgItem,
    UINT Msg,
    WPARAM wParam,
    LPARAM lParam);

LONG

SendDlgItemMessageW(
    HWND hDlg,
    int nIDDlgItem,
    UINT Msg,
    WPARAM wParam,
    LPARAM lParam);




#line 2447 "d:\\msvc20\\include/winuser.h"


HWND

GetNextDlgGroupItem(
    HWND hDlg,
    HWND hCtl,
    BOOL bPrevious);


HWND

GetNextDlgTabItem(
    HWND hDlg,
    HWND hCtl,
    BOOL bPrevious);


int

GetDlgCtrlID(
    HWND hWnd);


long

GetDialogBaseUnits(void);


LRESULT

DefDlgProcA(
    HWND hDlg,
    UINT Msg,
    WPARAM wParam,
    LPARAM lParam);

LRESULT

DefDlgProcW(
    HWND hDlg,
    UINT Msg,
    WPARAM wParam,
    LPARAM lParam);




#line 2496 "d:\\msvc20\\include/winuser.h"






#line 2503 "d:\\msvc20\\include/winuser.h"






























BOOL

OpenClipboard(
    HWND hWndNewOwner);


BOOL

CloseClipboard(
    void);


HWND

GetClipboardOwner(
    void);


HWND

SetClipboardViewer(
    HWND hWndNewViewer);


HWND

GetClipboardViewer(
    void);


BOOL

ChangeClipboardChain(
    HWND hWndRemove,
    HWND hWndNewNext);


HANDLE

SetClipboardData(
    UINT uFormat,
    HANDLE hMem);


HANDLE

    GetClipboardData(
    UINT uFormat);


UINT

RegisterClipboardFormatA(
    LPCSTR lpszFormat);

UINT

RegisterClipboardFormatW(
    LPCWSTR lpszFormat);




#line 2597 "d:\\msvc20\\include/winuser.h"


int

CountClipboardFormats(
    void);


UINT

EnumClipboardFormats(
    UINT format);


int

GetClipboardFormatNameA(
    UINT format,
    LPSTR lpszFormatName,
    int cchMaxCount);

int

GetClipboardFormatNameW(
    UINT format,
    LPWSTR lpszFormatName,
    int cchMaxCount);




#line 2629 "d:\\msvc20\\include/winuser.h"


BOOL

EmptyClipboard(
    void);


BOOL

IsClipboardFormatAvailable(
    UINT format);


int

GetPriorityClipboardFormat(
    UINT *paFormatPriorityList,
    int cFormats);


HWND

GetOpenClipboardWindow(
    void);

#line 2656 "d:\\msvc20\\include/winuser.h"






BOOL

CharToOemA(
    LPCSTR lpszSrc,
    LPSTR lpszDst);

BOOL

CharToOemW(
    LPCWSTR lpszSrc,
    LPSTR lpszDst);




#line 2678 "d:\\msvc20\\include/winuser.h"


BOOL

OemToCharA(
    LPCSTR lpszSrc,
    LPSTR lpszDst);

BOOL

OemToCharW(
    LPCSTR lpszSrc,
    LPWSTR lpszDst);




#line 2696 "d:\\msvc20\\include/winuser.h"


BOOL

CharToOemBuffA(
    LPCSTR lpszSrc,
    LPSTR lpszDst,
    DWORD cchDstLength);

BOOL

CharToOemBuffW(
    LPCWSTR lpszSrc,
    LPSTR lpszDst,
    DWORD cchDstLength);




#line 2716 "d:\\msvc20\\include/winuser.h"


BOOL

OemToCharBuffA(
    LPCSTR lpszSrc,
    LPSTR lpszDst,
    DWORD cchDstLength);

BOOL

OemToCharBuffW(
    LPCSTR lpszSrc,
    LPWSTR lpszDst,
    DWORD cchDstLength);




#line 2736 "d:\\msvc20\\include/winuser.h"


LPSTR

CharUpperA(
    LPSTR lpsz);

LPWSTR

CharUpperW(
    LPWSTR lpsz);




#line 2752 "d:\\msvc20\\include/winuser.h"


DWORD

CharUpperBuffA(
    LPSTR lpsz,
    DWORD cchLength);

DWORD

CharUpperBuffW(
    LPWSTR lpsz,
    DWORD cchLength);




#line 2770 "d:\\msvc20\\include/winuser.h"


LPSTR

CharLowerA(
    LPSTR lpsz);

LPWSTR

CharLowerW(
    LPWSTR lpsz);




#line 2786 "d:\\msvc20\\include/winuser.h"


DWORD

CharLowerBuffA(
    LPSTR lpsz,
    DWORD cchLength);

DWORD

CharLowerBuffW(
    LPWSTR lpsz,
    DWORD cchLength);




#line 2804 "d:\\msvc20\\include/winuser.h"


LPSTR

CharNextA(
    LPCSTR lpsz);

LPWSTR

CharNextW(
    LPCWSTR lpsz);




#line 2820 "d:\\msvc20\\include/winuser.h"


LPSTR

CharPrevA(
    LPCSTR lpszStart,
    LPCSTR lpszCurrent);

LPWSTR

CharPrevW(
    LPCWSTR lpszStart,
    LPCWSTR lpszCurrent);




#line 2838 "d:\\msvc20\\include/winuser.h"





















BOOL

IsCharAlphaA(
    CHAR ch);

BOOL

IsCharAlphaW(
    WCHAR ch);




#line 2873 "d:\\msvc20\\include/winuser.h"


BOOL

IsCharAlphaNumericA(
    CHAR ch);

BOOL

IsCharAlphaNumericW(
    WCHAR ch);




#line 2889 "d:\\msvc20\\include/winuser.h"


BOOL

IsCharUpperA(
    CHAR ch);

BOOL

IsCharUpperW(
    WCHAR ch);




#line 2905 "d:\\msvc20\\include/winuser.h"


BOOL

IsCharLowerA(
    CHAR ch);

BOOL

IsCharLowerW(
    WCHAR ch);




#line 2921 "d:\\msvc20\\include/winuser.h"

#line 2923 "d:\\msvc20\\include/winuser.h"


HWND

SetFocus(
    HWND hWnd);


HWND

GetActiveWindow(
    void);


HWND

GetFocus(
    void);


UINT

GetKBCodePage(
    void);


SHORT

GetKeyState(
    int nVirtKey);


SHORT

GetAsyncKeyState(
    int vKey);


BOOL

GetKeyboardState(
    PBYTE lpKeyState);


BOOL

SetKeyboardState(
    LPBYTE lpKeyState);


int

GetKeyNameTextA(
    LONG lParam,
    LPSTR lpString,
    int nSize
    );

int

GetKeyNameTextW(
    LONG lParam,
    LPWSTR lpString,
    int nSize
    );




#line 2993 "d:\\msvc20\\include/winuser.h"


int

GetKeyboardType(
    int nTypeFlag);


int

ToAscii(
    UINT uVirtKey,
    UINT uScanCode,
    PBYTE lpKeyState,
    LPWORD lpChar,
    UINT uFlags);



int

ToUnicode(
    UINT wVirtKey,
    UINT wScanCode,
    PBYTE lpKeyState,
    LPWSTR pwszBuff,
    int cchBuff,
    UINT wFlags);


DWORD

OemKeyScan(
    WORD wOemChar);


SHORT

VkKeyScanA(
    CHAR ch);

SHORT

VkKeyScanW(
    WCHAR ch);




#line 3043 "d:\\msvc20\\include/winuser.h"





void

keybd_event(
    BYTE bVk,
    BYTE bScan,
    DWORD dwFlags,
    DWORD dwExtraInfo);











void

mouse_event(
    DWORD dwFlags,
    DWORD dx,
    DWORD dy,
    DWORD cButtons,
    DWORD dwExtraInfo);


UINT

MapVirtualKeyA(
    UINT uCode,
    UINT uMapType);

UINT

MapVirtualKeyW(
    UINT uCode,
    UINT uMapType);




#line 3092 "d:\\msvc20\\include/winuser.h"



BOOL

GetInputState(
    void);


DWORD

GetQueueStatus(
    UINT flags);


HWND

GetCapture(
    void);


HWND

SetCapture(
    HWND hWnd);


BOOL

ReleaseCapture(
    void);


DWORD

MsgWaitForMultipleObjects(
    DWORD nCount,
    LPHANDLE pHandles,
    BOOL fWaitAll,
    DWORD dwMilliseconds,
    DWORD dwWakeMask);








































UINT

SetTimer(
    HWND hWnd ,
    UINT nIDEvent,
    UINT uElapse,
    TIMERPROC lpTimerFunc);


BOOL

KillTimer(
    HWND hWnd,
    UINT uIDEvent);


BOOL

IsWindowUnicode(
    HWND hWnd);


BOOL

EnableWindow(
    HWND hWnd,
    BOOL bEnable);


BOOL

IsWindowEnabled(
    HWND hWnd);


HACCEL

LoadAcceleratorsA(
    HINSTANCE hInstance,
    LPCSTR lpTableName);

HACCEL

LoadAcceleratorsW(
    HINSTANCE hInstance,
    LPCWSTR lpTableName);




#line 3224 "d:\\msvc20\\include/winuser.h"


HACCEL

CreateAcceleratorTableA(
    LPACCEL, int);

HACCEL

CreateAcceleratorTableW(
    LPACCEL, int);




#line 3240 "d:\\msvc20\\include/winuser.h"


BOOL

DestroyAcceleratorTable(
    HACCEL hAccel);


int

CopyAcceleratorTableA(
    HACCEL hAccelSrc,
    LPACCEL lpAccelDst,
    int cAccelEntries);

int

CopyAcceleratorTableW(
    HACCEL hAccelSrc,
    LPACCEL lpAccelDst,
    int cAccelEntries);




#line 3266 "d:\\msvc20\\include/winuser.h"


























































































HMENU

LoadMenuA(
    HINSTANCE hInstance,
    LPCSTR lpMenuName);

HMENU

LoadMenuW(
    HINSTANCE hInstance,
    LPCWSTR lpMenuName);




#line 3372 "d:\\msvc20\\include/winuser.h"


HMENU

LoadMenuIndirectA(
    const MENUTEMPLATEA *lpMenuTemplate);

HMENU

LoadMenuIndirectW(
    const MENUTEMPLATEW *lpMenuTemplate);




#line 3388 "d:\\msvc20\\include/winuser.h"


HMENU

GetMenu(
    HWND hWnd);


BOOL

SetMenu(
    HWND hWnd,
    HMENU hMenu);


BOOL

ChangeMenuA(
    HMENU hMenu,
    UINT cmd,
    LPCSTR lpszNewItem,
    UINT cmdInsert,
    UINT flags);

BOOL

ChangeMenuW(
    HMENU hMenu,
    UINT cmd,
    LPCWSTR lpszNewItem,
    UINT cmdInsert,
    UINT flags);




#line 3425 "d:\\msvc20\\include/winuser.h"


BOOL

HiliteMenuItem(
    HWND hWnd,
    HMENU hMenu,
    UINT uIDHiliteItem,
    UINT uHilite);


int

GetMenuStringA(
    HMENU hMenu,
    UINT uIDItem,
    LPSTR lpString,
    int nMaxCount,
    UINT uFlag);

int

GetMenuStringW(
    HMENU hMenu,
    UINT uIDItem,
    LPWSTR lpString,
    int nMaxCount,
    UINT uFlag);




#line 3458 "d:\\msvc20\\include/winuser.h"


UINT

GetMenuState(
    HMENU hMenu,
    UINT uId,
    UINT uFlags);


BOOL

DrawMenuBar(
    HWND hWnd);



HMENU

GetSystemMenu(
    HWND hWnd,
    BOOL bRevert);




HMENU

CreateMenu(
    void);


HMENU

CreatePopupMenu(
    void);


BOOL

DestroyMenu(
    HMENU hMenu);


DWORD

CheckMenuItem(
    HMENU hMenu,
    UINT uIDCheckItem,
    UINT uCheck);


BOOL

EnableMenuItem(
    HMENU hMenu,
    UINT uIDEnableItem,
    UINT uEnable);


HMENU

GetSubMenu(
    HMENU hMenu,
    int nPos);


UINT

GetMenuItemID(
    HMENU hMenu,
    int nPos);


int

GetMenuItemCount(
    HMENU hMenu);


BOOL

InsertMenuA(
    HMENU hMenu,
    UINT uPosition,
    UINT uFlags,
    UINT uIDNewItem,
    LPCSTR lpNewItem
    );

BOOL

InsertMenuW(
    HMENU hMenu,
    UINT uPosition,
    UINT uFlags,
    UINT uIDNewItem,
    LPCWSTR lpNewItem
    );




#line 3562 "d:\\msvc20\\include/winuser.h"


BOOL

AppendMenuA(
    HMENU hMenu,
    UINT uFlags,
    UINT uIDNewItem,
    LPCSTR lpNewItem
    );

BOOL

AppendMenuW(
    HMENU hMenu,
    UINT uFlags,
    UINT uIDNewItem,
    LPCWSTR lpNewItem
    );




#line 3586 "d:\\msvc20\\include/winuser.h"


BOOL

ModifyMenuA(
    HMENU hMnu,
    UINT uPosition,
    UINT uFlags,
    UINT uIDNewItem,
    LPCSTR lpNewItem
    );

BOOL

ModifyMenuW(
    HMENU hMnu,
    UINT uPosition,
    UINT uFlags,
    UINT uIDNewItem,
    LPCWSTR lpNewItem
    );




#line 3612 "d:\\msvc20\\include/winuser.h"


BOOL
 RemoveMenu(
    HMENU hMenu,
    UINT uPosition,
    UINT uFlags);


BOOL

DeleteMenu(
    HMENU hMenu,
    UINT uPosition,
    UINT uFlags);


BOOL

SetMenuItemBitmaps(
    HMENU hMenu,
    UINT uPosition,
    UINT uFlags,
    HBITMAP hBitmapUnchecked,
    HBITMAP hBitmapChecked);


LONG

GetMenuCheckMarkDimensions(
    void);


BOOL

TrackPopupMenu(
    HMENU hMenu,
    UINT uFlags,
    int x,
    int y,
    int nReserved,
    HWND hWnd,
    const RECT *prcRect);










#line 3666 "d:\\msvc20\\include/winuser.h"




BOOL

DrawIcon(
    HDC hDC,
    int X,
    int Y,
    HICON hIcon);




























int

DrawTextA(
    HDC hDC,
    LPCSTR lpString,
    int nCount,
    LPRECT lpRect,
    UINT uFormat);

int

DrawTextW(
    HDC hDC,
    LPCWSTR lpString,
    int nCount,
    LPRECT lpRect,
    UINT uFormat);




#line 3727 "d:\\msvc20\\include/winuser.h"



#line 3731 "d:\\msvc20\\include/winuser.h"


BOOL

GrayStringA(
    HDC hDC,
    HBRUSH hBrush,
    GRAYSTRINGPROC lpOutputFunc,
    LPARAM lpData,
    int nCount,
    int X,
    int Y,
    int nWidth,
    int nHeight);

BOOL

GrayStringW(
    HDC hDC,
    HBRUSH hBrush,
    GRAYSTRINGPROC lpOutputFunc,
    LPARAM lpData,
    int nCount,
    int X,
    int Y,
    int nWidth,
    int nHeight);




#line 3763 "d:\\msvc20\\include/winuser.h"




LONG

TabbedTextOutA(
    HDC hDC,
    int X,
    int Y,
    LPCSTR lpString,
    int nCount,
    int nTabPositions,
    LPINT lpnTabStopPositions,
    int nTabOrigin);

LONG

TabbedTextOutW(
    HDC hDC,
    int X,
    int Y,
    LPCWSTR lpString,
    int nCount,
    int nTabPositions,
    LPINT lpnTabStopPositions,
    int nTabOrigin);




#line 3795 "d:\\msvc20\\include/winuser.h"


DWORD

GetTabbedTextExtentA(
    HDC hDC,
    LPCSTR lpString,
    int nCount,
    int nTabPositions,
    LPINT lpnTabStopPositions);

DWORD

GetTabbedTextExtentW(
    HDC hDC,
    LPCWSTR lpString,
    int nCount,
    int nTabPositions,
    LPINT lpnTabStopPositions);




#line 3819 "d:\\msvc20\\include/winuser.h"


BOOL

UpdateWindow(
    HWND hWnd);


HWND

SetActiveWindow(
    HWND hWnd);


HWND

GetForegroundWindow(
    void);



BOOL

SetForegroundWindow(
    HWND hWnd);


HWND

WindowFromDC(
    HDC hDC);


HDC

GetDC(
    HWND hWnd);


HDC

GetDCEx(
    HWND hWnd ,
    HRGN hrgnClip,
    DWORD flags);

























HDC

GetWindowDC(
    HWND hWnd);


int

ReleaseDC(
    HWND hWnd,
    HDC hDC);


HDC

BeginPaint(
    HWND hWnd,
    LPPAINTSTRUCT lpPaint);


BOOL

EndPaint(
    HWND hWnd,
    const PAINTSTRUCT *lpPaint);


BOOL

GetUpdateRect(
    HWND hWnd,
    LPRECT lpRect,
    BOOL bErase);


int

GetUpdateRgn(
    HWND hWnd,
    HRGN hRgn,
    BOOL bErase);


int

ExcludeUpdateRgn(
    HDC hDC,
    HWND hWnd);


BOOL

InvalidateRect(
    HWND hWnd ,
    const RECT *lpRect,
    BOOL bErase);


BOOL

ValidateRect(
    HWND hWnd ,
    const RECT *lpRect);


BOOL

InvalidateRgn(
    HWND hWnd,
    HRGN hRgn,
    BOOL bErase);


BOOL

ValidateRgn(
    HWND hWnd,
    HRGN hRgn);



BOOL

RedrawWindow(
    HWND hWnd,
    const RECT *lprcUpdate,
    HRGN hrgnUpdate,
    UINT flags);




























BOOL

LockWindowUpdate(
    HWND hWndLock);


BOOL

ScrollWindow(
    HWND hWnd,
    int XAmount,
    int YAmount,
    const RECT *lpRect,
    const RECT *lpClipRect);


BOOL

ScrollDC(
    HDC hDC,
    int dx,
    int dy,
    const RECT *lprcScroll,
    const RECT *lprcClip ,
    HRGN hrgnUpdate,
    LPRECT lprcUpdate);


int

ScrollWindowEx(
    HWND hWnd,
    int dx,
    int dy,
    const RECT *prcScroll,
    const RECT *prcClip ,
    HRGN hrgnUpdate,
    LPRECT prcUpdate,
    UINT flags);

















































































BOOL

SetPropA(
    HWND hWnd,
    LPCSTR lpString,
    HANDLE hData);

BOOL

SetPropW(
    HWND hWnd,
    LPCWSTR lpString,
    HANDLE hData);




#line 4143 "d:\\msvc20\\include/winuser.h"


HANDLE

GetPropA(
    HWND hWnd,
    LPCSTR lpString);

HANDLE

GetPropW(
    HWND hWnd,
    LPCWSTR lpString);




#line 4161 "d:\\msvc20\\include/winuser.h"


HANDLE

RemovePropA(
    HWND hWnd,
    LPCSTR lpString);

HANDLE

RemovePropW(
    HWND hWnd,
    LPCWSTR lpString);




#line 4179 "d:\\msvc20\\include/winuser.h"


int

EnumPropsExA(
    HWND hWnd,
    PROPENUMPROCEXA lpEnumFunc,
    LPARAM lParam);

int

EnumPropsExW(
    HWND hWnd,
    PROPENUMPROCEXW lpEnumFunc,
    LPARAM lParam);




#line 4199 "d:\\msvc20\\include/winuser.h"


int

EnumPropsA(
    HWND hWnd,
    PROPENUMPROCA lpEnumFunc);

int

EnumPropsW(
    HWND hWnd,
    PROPENUMPROCW lpEnumFunc);




#line 4217 "d:\\msvc20\\include/winuser.h"


BOOL

SetWindowTextA(
    HWND hWnd,
    LPCSTR lpString);

BOOL

SetWindowTextW(
    HWND hWnd,
    LPCWSTR lpString);




#line 4235 "d:\\msvc20\\include/winuser.h"


int

GetWindowTextA(
    HWND hWnd,
    LPSTR lpString,
    int nMaxCount);

int

GetWindowTextW(
    HWND hWnd,
    LPWSTR lpString,
    int nMaxCount);




#line 4255 "d:\\msvc20\\include/winuser.h"


int

GetWindowTextLengthA(
    HWND hWnd);

int

GetWindowTextLengthW(
    HWND hWnd);




#line 4271 "d:\\msvc20\\include/winuser.h"


BOOL

GetClientRect(
    HWND hWnd,
    LPRECT lpRect);


BOOL

GetWindowRect(
    HWND hWnd,
    LPRECT lpRect);


BOOL

AdjustWindowRect(
    LPRECT lpRect,
    DWORD dwStyle,
    BOOL bMenu);


BOOL

AdjustWindowRectEx(
    LPRECT lpRect,
    DWORD dwStyle,
    BOOL bMenu,
    DWORD dwExStyle);












































int

MessageBoxA(
    HWND hWnd ,
    LPCSTR lpText,
    LPCSTR lpCaption,
    UINT uType);

int

MessageBoxW(
    HWND hWnd ,
    LPCWSTR lpText,
    LPCWSTR lpCaption,
    UINT uType);




#line 4366 "d:\\msvc20\\include/winuser.h"


int

MessageBoxExA(
    HWND hWnd ,
    LPCSTR lpText,
    LPCSTR lpCaption,
    UINT uType,
    WORD wLanguageId);

int

MessageBoxExW(
    HWND hWnd ,
    LPCWSTR lpText,
    LPCWSTR lpCaption,
    UINT uType,
    WORD wLanguageId);




#line 4390 "d:\\msvc20\\include/winuser.h"





BOOL

MessageBeep(
    UINT uType);

#line 4401 "d:\\msvc20\\include/winuser.h"


int

ShowCursor(
    BOOL bShow);


BOOL

SetCursorPos(
    int X,
    int Y);


HCURSOR

SetCursor(
    HCURSOR hCursor);


BOOL

GetCursorPos(
    LPPOINT lpPoint);


BOOL

ClipCursor(
    const RECT *lpRect);


BOOL

GetClipCursor(
    LPRECT lpRect);


HCURSOR

GetCursor(
    void);


BOOL

CreateCaret(
    HWND hWnd,
    HBITMAP hBitmap ,
    int nWidth,
    int nHeight);


UINT

GetCaretBlinkTime(
    void);


BOOL

SetCaretBlinkTime(
    UINT uMSeconds);


BOOL

DestroyCaret(
    void);


BOOL

HideCaret(
    HWND hWnd);


BOOL

ShowCaret(
    HWND hWnd);


BOOL

SetCaretPos(
    int X,
    int Y);


BOOL

GetCaretPos(
    LPPOINT lpPoint);


BOOL

ClientToScreen(
    HWND hWnd,
    LPPOINT lpPoint);


BOOL

ScreenToClient(
    HWND hWnd,
    LPPOINT lpPoint);


int

MapWindowPoints(
    HWND hWndFrom,
    HWND hWndTo,
    LPPOINT lpPoints,
    UINT cPoints);


HWND

WindowFromPoint(
    POINT Point);


HWND

ChildWindowFromPoint(
    HWND hWndParent,
    POINT Point);










































DWORD

GetSysColor(
    int nIndex);



BOOL

SetSysColors(
    int cElements,
    const INT * lpaElements,
    const COLORREF * lpaRgbValues);

#line 4589 "d:\\msvc20\\include/winuser.h"


BOOL

DrawFocusRect(
    HDC hDC,
    const RECT * lprc);


int

FillRect(
    HDC hDC,
    const RECT *lprc,
    HBRUSH hbr);


int

FrameRect(
    HDC hDC,
    const RECT *lprc,
    HBRUSH hbr);


BOOL

InvertRect(
    HDC hDC,
    const RECT *lprc);


BOOL

SetRect(
    LPRECT lprc,
    int xLeft,
    int yTop,
    int xRight,
    int yBottom);


BOOL

    SetRectEmpty(
    LPRECT lprc);


BOOL

CopyRect(
    LPRECT lprcDst,
    const RECT *lprcSrc);


BOOL

InflateRect(
    LPRECT lprc,
    int dx,
    int dy);


BOOL

IntersectRect(
    LPRECT lprcDst,
    const RECT *lprcSrc1,
    const RECT *lprcSrc2);


BOOL

UnionRect(
    LPRECT lprcDst,
    const RECT *lprcSrc1,
    const RECT *lprcSrc2);


BOOL

SubtractRect(
    LPRECT lprcDst,
    const RECT *lprcSrc1,
    const RECT *lprcSrc2);


BOOL

OffsetRect(
    LPRECT lprc,
    int dx,
    int dy);


BOOL

IsRectEmpty(
    const RECT *lprc);


BOOL

EqualRect(
    const RECT *lprc1,
    const RECT *lprc2);


BOOL

PtInRect(
    const RECT *lprc,
    POINT pt);




WORD

GetWindowWord(
    HWND hWnd,
    int nIndex);


WORD

SetWindowWord(
    HWND hWnd,
    int nIndex,
    WORD wNewWord);


LONG

GetWindowLongA(
    HWND hWnd,
    int nIndex);

LONG

GetWindowLongW(
    HWND hWnd,
    int nIndex);




#line 4737 "d:\\msvc20\\include/winuser.h"


LONG

SetWindowLongA(
    HWND hWnd,
    int nIndex,
    LONG dwNewLong);

LONG

SetWindowLongW(
    HWND hWnd,
    int nIndex,
    LONG dwNewLong);




#line 4757 "d:\\msvc20\\include/winuser.h"


WORD

GetClassWord(
    HWND hWnd,
    int nIndex);


WORD

SetClassWord(
    HWND hWnd,
    int nIndex,
    WORD wNewWord);


DWORD

GetClassLongA(
    HWND hWnd,
    int nIndex);

DWORD

GetClassLongW(
    HWND hWnd,
    int nIndex);




#line 4790 "d:\\msvc20\\include/winuser.h"


DWORD

SetClassLongA(
    HWND hWnd,
    int nIndex,
    LONG dwNewLong);

DWORD

SetClassLongW(
    HWND hWnd,
    int nIndex,
    LONG dwNewLong);




#line 4810 "d:\\msvc20\\include/winuser.h"

#line 4812 "d:\\msvc20\\include/winuser.h"


HWND

GetDesktopWindow(
    void);



HWND

GetParent(
    HWND hWnd);


HWND

SetParent(
    HWND hWndChild,
    HWND hWndNewParent);


BOOL

EnumChildWindows(
    HWND hWndParent,
    WNDENUMPROC lpEnumFunc,
    LPARAM lParam);


HWND

FindWindowA(
    LPCSTR lpClassName ,
    LPCSTR lpWindowName);

HWND

FindWindowW(
    LPCWSTR lpClassName ,
    LPCWSTR lpWindowName);




#line 4858 "d:\\msvc20\\include/winuser.h"



BOOL

EnumWindows(
    WNDENUMPROC lpEnumFunc,
    LPARAM lParam);


BOOL

EnumThreadWindows(
    DWORD dwThreadId,
    WNDENUMPROC lpfn,
    LPARAM lParam);




int

GetClassNameA(
    HWND hWnd,
    LPSTR lpClassName,
    int nMaxCount);

int

GetClassNameW(
    HWND hWnd,
    LPWSTR lpClassName,
    int nMaxCount);




#line 4896 "d:\\msvc20\\include/winuser.h"


HWND

GetTopWindow(
    HWND hWnd);






DWORD

GetWindowThreadProcessId(
    HWND hWnd,
    LPDWORD lpdwProcessId);





HWND

GetLastActivePopup(
    HWND hWnd);













HWND

GetWindow(
    HWND hWnd,
    UINT uCmd);





































































































































































typedef struct {
    WORD versionNumber;
    WORD offset;
} MENUITEMTEMPLATEHEADER, *PMENUITEMTEMPLATEHEADER;

typedef struct {        
    WORD mtOption;
    WORD mtID;
    WCHAR mtString[1];
} MENUITEMTEMPLATE, *PMENUITEMTEMPLATE;


#line 5118 "d:\\msvc20\\include/winuser.h"





























#line 5148 "d:\\msvc20\\include/winuser.h"






HBITMAP

LoadBitmapA(
    HINSTANCE hInstance,
    LPCSTR lpBitmapName);

HBITMAP

LoadBitmapW(
    HINSTANCE hInstance,
    LPCWSTR lpBitmapName);




#line 5170 "d:\\msvc20\\include/winuser.h"


HCURSOR

LoadCursorA(
    HINSTANCE hInstance,
    LPCSTR lpCursorName);

HCURSOR

LoadCursorW(
    HINSTANCE hInstance,
    LPCWSTR lpCursorName);




#line 5188 "d:\\msvc20\\include/winuser.h"



HCURSOR

CreateCursor(
    HINSTANCE hInst,
    int xHotSpot,
    int yHotSpot,
    int nWidth,
    int nHeight,
    const void *pvANDPlane,
    const void *pvXORPlane);


BOOL

DestroyCursor(
    HCURSOR hCursor);





















typedef struct _ICONINFO {
    BOOL    fIcon;
    DWORD   xHotspot;
    DWORD   yHotspot;
    HBITMAP hbmMask;
    HBITMAP hbmColor;
} ICONINFO;
typedef ICONINFO *PICONINFO;


HICON

LoadIconA(
    HINSTANCE hInstance,
    LPCSTR lpIconName);

HICON

LoadIconW(
    HINSTANCE hInstance,
    LPCWSTR lpIconName);




#line 5254 "d:\\msvc20\\include/winuser.h"


HICON

CreateIcon(
    HINSTANCE hInstance,
    int nWidth,
    int nHeight,
    BYTE cPlanes,
    BYTE cBitsPixel,
    const BYTE *lpbANDbits,
    const BYTE *lpbXORbits);


BOOL

DestroyIcon(
    HICON hIcon);


int

LookupIconIdFromDirectory(
    PBYTE presbits,
    BOOL fIcon);



HICON

CreateIconFromResource(
    PBYTE presbits,
    DWORD dwResSize,
    BOOL fIcon,
    DWORD dwVer);



HICON

CreateIconIndirect(
    PICONINFO piconinfo);


HICON

CopyIcon(
    HICON hIcon);


BOOL

GetIconInfo(
    HICON hIcon,
    PICONINFO piconinfo);


























































































#line 5400 "d:\\msvc20\\include/winuser.h"

#line 5402 "d:\\msvc20\\include/winuser.h"


int

LoadStringA(
    HINSTANCE hInstance,
    UINT uID,
    LPSTR lpBuffer,
    int nBufferMax);

int

LoadStringW(
    HINSTANCE hInstance,
    UINT uID,
    LPWSTR lpBuffer,
    int nBufferMax);




#line 5424 "d:\\msvc20\\include/winuser.h"






































#line 5463 "d:\\msvc20\\include/winuser.h"




















































#line 5516 "d:\\msvc20\\include/winuser.h"






































































#line 5587 "d:\\msvc20\\include/winuser.h"








































BOOL

MapDialogRect(
    HWND hDlg,
    LPRECT lpRect);


int

DlgDirListA(
    HWND hDlg,
    LPSTR lpPathSpec,
    int nIDListBox,
    int nIDStaticPath,
    UINT uFileType);

int

DlgDirListW(
    HWND hDlg,
    LPWSTR lpPathSpec,
    int nIDListBox,
    int nIDStaticPath,
    UINT uFileType);




#line 5656 "d:\\msvc20\\include/winuser.h"
















BOOL

DlgDirSelectExA(
    HWND hDlg,
    LPSTR lpString,
    int nCount,
    int nIDListBox);

BOOL

DlgDirSelectExW(
    HWND hDlg,
    LPWSTR lpString,
    int nCount,
    int nIDListBox);




#line 5692 "d:\\msvc20\\include/winuser.h"


int

DlgDirListComboBoxA(
    HWND hDlg,
    LPSTR lpPathSpec,
    int nIDComboBox,
    int nIDStaticPath,
    UINT uFiletype);

int

DlgDirListComboBoxW(
    HWND hDlg,
    LPWSTR lpPathSpec,
    int nIDComboBox,
    int nIDStaticPath,
    UINT uFiletype);




#line 5716 "d:\\msvc20\\include/winuser.h"


BOOL

DlgDirSelectComboBoxExA(
    HWND hDlg,
    LPSTR lpString,
    int nCount,
    int nIDComboBox);

BOOL

DlgDirSelectComboBoxExW(
    HWND hDlg,
    LPWSTR lpString,
    int nCount,
    int nIDComboBox);




#line 5738 "d:\\msvc20\\include/winuser.h"






















































                                  




























































#line 5854 "d:\\msvc20\\include/winuser.h"






















#line 5877 "d:\\msvc20\\include/winuser.h"








































#line 5918 "d:\\msvc20\\include/winuser.h"


































#line 5953 "d:\\msvc20\\include/winuser.h"

















#line 5971 "d:\\msvc20\\include/winuser.h"











#line 5983 "d:\\msvc20\\include/winuser.h"
#line 5984 "d:\\msvc20\\include/winuser.h"
















typedef struct tagMDICREATESTRUCTA {
    LPCSTR   szClass;
    LPCSTR   szTitle;
    HANDLE hOwner;
    int x;
    int y;
    int cx;
    int cy;
    DWORD style;
    LPARAM lParam;        
} MDICREATESTRUCTA, *LPMDICREATESTRUCTA;
typedef struct tagMDICREATESTRUCTW {
    LPCWSTR  szClass;
    LPCWSTR  szTitle;
    HANDLE hOwner;
    int x;
    int y;
    int cx;
    int cy;
    DWORD style;
    LPARAM lParam;        
} MDICREATESTRUCTW, *LPMDICREATESTRUCTW;




typedef MDICREATESTRUCTA MDICREATESTRUCT;
typedef LPMDICREATESTRUCTA LPMDICREATESTRUCT;
#line 6029 "d:\\msvc20\\include/winuser.h"

typedef struct tagCLIENTCREATESTRUCT {
    HANDLE hWindowMenu;
    UINT idFirstChild;
} CLIENTCREATESTRUCT, *LPCLIENTCREATESTRUCT;


LRESULT

DefFrameProcA(
    HWND hWnd,
    HWND hWndMDIClient ,
    UINT uMsg,
    WPARAM wParam,
    LPARAM lParam);

LRESULT

DefFrameProcW(
    HWND hWnd,
    HWND hWndMDIClient ,
    UINT uMsg,
    WPARAM wParam,
    LPARAM lParam);




#line 6058 "d:\\msvc20\\include/winuser.h"


LRESULT

DefMDIChildProcA(
    HWND hWnd,
    UINT uMsg,
    WPARAM wParam,
    LPARAM lParam);

LRESULT

DefMDIChildProcW(
    HWND hWnd,
    UINT uMsg,
    WPARAM wParam,
    LPARAM lParam);




#line 6080 "d:\\msvc20\\include/winuser.h"













UINT

ArrangeIconicWindows(
    HWND hWnd);


HWND

CreateMDIWindowA(
    LPSTR lpClassName,
    LPSTR lpWindowName,
    DWORD dwStyle,
    int X,
    int Y,
    int nWidth,
    int nHeight,
    HWND hWndParent,
    HINSTANCE hInstance,
    LPARAM lParam
    );

HWND

CreateMDIWindowW(
    LPWSTR lpClassName,
    LPWSTR lpWindowName,
    DWORD dwStyle,
    int X,
    int Y,
    int nWidth,
    int nHeight,
    HWND hWndParent,
    HINSTANCE hInstance,
    LPARAM lParam
    );




#line 6133 "d:\\msvc20\\include/winuser.h"

#line 6135 "d:\\msvc20\\include/winuser.h"
#line 6136 "d:\\msvc20\\include/winuser.h"





typedef DWORD HELPPOLY;
typedef struct tagMULTIKEYHELPA {
    DWORD  mkSize;
    CHAR   mkKeylist;
    CHAR   szKeyphrase[1];
} MULTIKEYHELPA, *PMULTIKEYHELPA, *LPMULTIKEYHELPA;
typedef struct tagMULTIKEYHELPW {
    DWORD  mkSize;
    WCHAR  mkKeylist;
    WCHAR  szKeyphrase[1];
} MULTIKEYHELPW, *PMULTIKEYHELPW, *LPMULTIKEYHELPW;





typedef MULTIKEYHELPA MULTIKEYHELP;
typedef PMULTIKEYHELPA PMULTIKEYHELP;
typedef LPMULTIKEYHELPA LPMULTIKEYHELP;
#line 6161 "d:\\msvc20\\include/winuser.h"

typedef struct tagHELPWININFOA {
    int  wStructSize;
    int  x;
    int  y;
    int  dx;
    int  dy;
    int  wMax;
    CHAR   rgchMember[2];
} HELPWININFOA, *PHELPWININFOA, *LPHELPWININFOA;
typedef struct tagHELPWININFOW {
    int  wStructSize;
    int  x;
    int  y;
    int  dx;
    int  dy;
    int  wMax;
    WCHAR  rgchMember[2];
} HELPWININFOW, *PHELPWININFOW, *LPHELPWININFOW;





typedef HELPWININFOA HELPWININFO;
typedef PHELPWININFOA PHELPWININFO;
typedef LPHELPWININFOA LPHELPWININFO;
#line 6189 "d:\\msvc20\\include/winuser.h"






















BOOL

WinHelpA(
    HWND hWndMain,
    LPCSTR lpszHelp,
    UINT uCommand,
    DWORD dwData
    );

BOOL

WinHelpW(
    HWND hWndMain,
    LPCWSTR lpszHelp,
    UINT uCommand,
    DWORD dwData
    );




#line 6233 "d:\\msvc20\\include/winuser.h"

#line 6235 "d:\\msvc20\\include/winuser.h"





















































































BOOL

SystemParametersInfoA(
    UINT uiAction,
    UINT uiParam,
    PVOID pvParam,
    UINT fWinIni);

BOOL

SystemParametersInfoW(
    UINT uiAction,
    UINT uiParam,
    PVOID pvParam,
    UINT fWinIni);




#line 6340 "d:\\msvc20\\include/winuser.h"

#line 6342 "d:\\msvc20\\include/winuser.h"




typedef struct tagFILTERKEYS
{
    DWORD cbSize;
    DWORD dwFlags;
    DWORD iWaitMSec;            
    DWORD iDelayMSec;           
    DWORD iRepeatMSec;          
    DWORD iBounceMSec;          
} FILTERKEYS, *LPFILTERKEYS;












typedef struct tagSTICKYKEYS
{
    DWORD cbSize;
    DWORD dwFlags;
} STICKYKEYS, *LPSTICKYKEYS;














typedef struct tagMOUSEKEYS
{
    DWORD cbSize;
    DWORD dwFlags;
    DWORD iMaxSpeed;
    DWORD iTimeToMaxSpeed;
    DWORD iCtrlSpeed;
    DWORD dwReserved1;
    DWORD dwReserved2;
} MOUSEKEYS, *LPMOUSEKEYS;













typedef struct tagACCESSTIMEOUT
{
    DWORD cbSize;
    DWORD dwFlags;
    DWORD iTimeOutMSec;
} ACCESSTIMEOUT, *LPACCESSTIMEOUT;
















typedef struct tagSOUNDSENTRYA
{
    DWORD cbSize;
    DWORD dwFlags;
    DWORD iFSTextEffect;
    DWORD iFSTextEffectMSec;
    DWORD iFSTextEffectColorBits;
    DWORD iFSGrafEffect;
    DWORD iFSGrafEffectMSec;
    DWORD iFSGrafEffectColor;
    DWORD iWindowsEffect;
    DWORD iWindowsEffectMSec;
    LPSTR   lpszWindowsEffectDLL;
    DWORD iWindowsEffectOrdinal;
} SOUNDSENTRYA, *LPSOUNDSENTRYA;
typedef struct tagSOUNDSENTRYW
{
    DWORD cbSize;
    DWORD dwFlags;
    DWORD iFSTextEffect;
    DWORD iFSTextEffectMSec;
    DWORD iFSTextEffectColorBits;
    DWORD iFSGrafEffect;
    DWORD iFSGrafEffectMSec;
    DWORD iFSGrafEffectColor;
    DWORD iWindowsEffect;
    DWORD iWindowsEffectMSec;
    LPWSTR  lpszWindowsEffectDLL;
    DWORD iWindowsEffectOrdinal;
} SOUNDSENTRYW, *LPSOUNDSENTRYW;




typedef SOUNDSENTRYA SOUNDSENTRY;
typedef LPSOUNDSENTRYA LPSOUNDSENTRY;
#line 6468 "d:\\msvc20\\include/winuser.h"








typedef struct tagTOGGLEKEYS
{
    DWORD cbSize;
    DWORD dwFlags;
} TOGGLEKEYS, *LPTOGGLEKEYS;




















void

SetDebugErrorLevel(
    DWORD dwLevel
    );










void

SetLastErrorEx(
    DWORD dwErrCode,
    DWORD dwType
    );








#line 6531 "d:\\msvc20\\include/winuser.h"
#line 110 "d:\\msvc20\\include/windows.h"
#line 1 "d:\\msvc20\\include/winnls.h"














































































































































































































































































































































































































































































typedef DWORD LCTYPE;




typedef DWORD CALTYPE;




typedef DWORD CALID;






typedef struct _cpinfo {
    UINT    MaxCharSize;                    
    BYTE    DefaultChar[2];   
    BYTE    LeadByte[12];        
} CPINFO, *LPCPINFO;






typedef struct _numberfmtA {
    UINT    NumDigits;                 
    UINT    LeadingZero;               
    UINT    Grouping;                  
    LPSTR   lpDecimalSep;              
    LPSTR   lpThousandSep;             
    UINT    NegativeOrder;             
} NUMBERFMTA, *LPNUMBERFMTA;
typedef struct _numberfmtW {
    UINT    NumDigits;                 
    UINT    LeadingZero;               
    UINT    Grouping;                  
    LPWSTR  lpDecimalSep;              
    LPWSTR  lpThousandSep;             
    UINT    NegativeOrder;             
} NUMBERFMTW, *LPNUMBERFMTW;




typedef NUMBERFMTA NUMBERFMT;
typedef LPNUMBERFMTA LPNUMBERFMT;
#line 514 "d:\\msvc20\\include/winnls.h"






typedef struct _currencyfmtA {
    UINT    NumDigits;                 
    UINT    LeadingZero;               
    UINT    Grouping;                  
    LPSTR   lpDecimalSep;              
    LPSTR   lpThousandSep;             
    UINT    NegativeOrder;             
    UINT    PositiveOrder;             
    LPSTR   lpCurrencySymbol;          
} CURRENCYFMTA, *LPCURRENCYFMTA;
typedef struct _currencyfmtW {
    UINT    NumDigits;                 
    UINT    LeadingZero;               
    UINT    Grouping;                  
    LPWSTR  lpDecimalSep;              
    LPWSTR  lpThousandSep;             
    UINT    NegativeOrder;             
    UINT    PositiveOrder;             
    LPWSTR  lpCurrencySymbol;          
} CURRENCYFMTW, *LPCURRENCYFMTW;




typedef CURRENCYFMTA CURRENCYFMT;
typedef LPCURRENCYFMTA LPCURRENCYFMT;
#line 547 "d:\\msvc20\\include/winnls.h"























typedef FARPROC LOCALE_ENUMPROCA;
typedef FARPROC CODEPAGE_ENUMPROCA;
typedef FARPROC DATEFMT_ENUMPROCA;
typedef FARPROC TIMEFMT_ENUMPROCA;
typedef FARPROC CALINFO_ENUMPROCA;

typedef FARPROC LOCALE_ENUMPROCW;
typedef FARPROC CODEPAGE_ENUMPROCW;
typedef FARPROC DATEFMT_ENUMPROCW;
typedef FARPROC TIMEFMT_ENUMPROCW;
typedef FARPROC CALINFO_ENUMPROCW;

#line 583 "d:\\msvc20\\include/winnls.h"

















#line 601 "d:\\msvc20\\include/winnls.h"






















BOOL

IsValidCodePage(
    UINT  CodePage);


UINT

GetACP(void);


UINT

GetOEMCP(void);


BOOL

GetCPInfo(
    UINT      CodePage,
    LPCPINFO  lpCPInfo);


BOOL

IsDBCSLeadByte(
    BYTE  TestChar);


BOOL

IsDBCSLeadByteEx(
    UINT  CodePage,
    BYTE  TestChar);


int

MultiByteToWideChar(
    UINT     CodePage,
    DWORD    dwFlags,
    LPCSTR   lpMultiByteStr,
    int      cchMultiByte,
    LPWSTR   lpWideCharStr,
    int      cchWideChar);


int

WideCharToMultiByte(
    UINT     CodePage,
    DWORD    dwFlags,
    LPCWSTR  lpWideCharStr,
    int      cchWideChar,
    LPSTR    lpMultiByteStr,
    int      cchMultiByte,
    LPCSTR   lpDefaultChar,
    LPBOOL   lpUsedDefaultChar);







int

CompareStringA(
    LCID     Locale,
    DWORD    dwCmpFlags,
    LPCSTR lpString1,
    int      cchCount1,
    LPCSTR lpString2,
    int      cchCount2);

int

CompareStringW(
    LCID     Locale,
    DWORD    dwCmpFlags,
    LPCWSTR lpString1,
    int      cchCount1,
    LPCWSTR lpString2,
    int      cchCount2);




#line 712 "d:\\msvc20\\include/winnls.h"


int

LCMapStringA(
    LCID     Locale,
    DWORD    dwMapFlags,
    LPCSTR lpSrcStr,
    int      cchSrc,
    LPSTR  lpDestStr,
    int      cchDest);

int

LCMapStringW(
    LCID     Locale,
    DWORD    dwMapFlags,
    LPCWSTR lpSrcStr,
    int      cchSrc,
    LPWSTR  lpDestStr,
    int      cchDest);




#line 738 "d:\\msvc20\\include/winnls.h"


int

GetLocaleInfoA(
    LCID     Locale,
    LCTYPE   LCType,
    LPSTR  lpLCData,
    int      cchData);

int

GetLocaleInfoW(
    LCID     Locale,
    LCTYPE   LCType,
    LPWSTR  lpLCData,
    int      cchData);




#line 760 "d:\\msvc20\\include/winnls.h"


BOOL

SetLocaleInfoA(
    LCID     Locale,
    LCTYPE   LCType,
    LPCSTR lpLCData);

BOOL

SetLocaleInfoW(
    LCID     Locale,
    LCTYPE   LCType,
    LPCWSTR lpLCData);




#line 780 "d:\\msvc20\\include/winnls.h"


int

GetTimeFormatA(
    LCID     Locale,
    DWORD    dwFlags,
    const SYSTEMTIME *lpTime,
    LPCSTR lpFormat,
    LPSTR  lpTimeStr,
    int      cchTime);

int

GetTimeFormatW(
    LCID     Locale,
    DWORD    dwFlags,
    const SYSTEMTIME *lpTime,
    LPCWSTR lpFormat,
    LPWSTR  lpTimeStr,
    int      cchTime);




#line 806 "d:\\msvc20\\include/winnls.h"


int

GetDateFormatA(
    LCID     Locale,
    DWORD    dwFlags,
    const SYSTEMTIME *lpDate,
    LPCSTR lpFormat,
    LPSTR  lpDateStr,
    int      cchDate);

int

GetDateFormatW(
    LCID     Locale,
    DWORD    dwFlags,
    const SYSTEMTIME *lpDate,
    LPCWSTR lpFormat,
    LPWSTR  lpDateStr,
    int      cchDate);




#line 832 "d:\\msvc20\\include/winnls.h"


int

GetNumberFormatA(
    LCID     Locale,
    DWORD    dwFlags,
    LPCSTR lpValue,
    const NUMBERFMTA *lpFormat,
    LPSTR  lpNumberStr,
    int      cchNumber);

int

GetNumberFormatW(
    LCID     Locale,
    DWORD    dwFlags,
    LPCWSTR lpValue,
    const NUMBERFMTW *lpFormat,
    LPWSTR  lpNumberStr,
    int      cchNumber);




#line 858 "d:\\msvc20\\include/winnls.h"


int

GetCurrencyFormatA(
    LCID     Locale,
    DWORD    dwFlags,
    LPCSTR lpValue,
    const CURRENCYFMTA *lpFormat,
    LPSTR  lpCurrencyStr,
    int      cchCurrency);

int

GetCurrencyFormatW(
    LCID     Locale,
    DWORD    dwFlags,
    LPCWSTR lpValue,
    const CURRENCYFMTW *lpFormat,
    LPWSTR  lpCurrencyStr,
    int      cchCurrency);




#line 884 "d:\\msvc20\\include/winnls.h"


BOOL

EnumCalendarInfoA(
    CALINFO_ENUMPROCA lpCalInfoEnumProc,
    LCID              Locale,
    CALID             Calendar,
    CALTYPE           CalType);

BOOL

EnumCalendarInfoW(
    CALINFO_ENUMPROCW lpCalInfoEnumProc,
    LCID              Locale,
    CALID             Calendar,
    CALTYPE           CalType);




#line 906 "d:\\msvc20\\include/winnls.h"


BOOL

EnumTimeFormatsA(
    TIMEFMT_ENUMPROCA lpTimeFmtEnumProc,
    LCID              Locale,
    DWORD             dwFlags);

BOOL

EnumTimeFormatsW(
    TIMEFMT_ENUMPROCW lpTimeFmtEnumProc,
    LCID              Locale,
    DWORD             dwFlags);




#line 926 "d:\\msvc20\\include/winnls.h"


BOOL

EnumDateFormatsA(
    DATEFMT_ENUMPROCA lpDateFmtEnumProc,
    LCID              Locale,
    DWORD             dwFlags);

BOOL

EnumDateFormatsW(
    DATEFMT_ENUMPROCW lpDateFmtEnumProc,
    LCID              Locale,
    DWORD             dwFlags);




#line 946 "d:\\msvc20\\include/winnls.h"


BOOL

IsValidLocale(
    LCID   Locale,
    DWORD  dwFlags);


LCID

ConvertDefaultLocale(
    LCID   Locale);


LCID

GetThreadLocale(void);


BOOL

SetThreadLocale(
    LCID  Locale
    );


LANGID

GetSystemDefaultLangID(void);


LANGID

GetUserDefaultLangID(void);


LCID

GetSystemDefaultLCID(void);


LCID

GetUserDefaultLCID(void);







BOOL

GetStringTypeExA(
    LCID     Locale,
    DWORD    dwInfoType,
    LPCSTR lpSrcStr,
    int      cchSrc,
    LPWORD   lpCharType);

BOOL

GetStringTypeExW(
    LCID     Locale,
    DWORD    dwInfoType,
    LPCWSTR lpSrcStr,
    int      cchSrc,
    LPWORD   lpCharType);




#line 1020 "d:\\msvc20\\include/winnls.h"













BOOL

GetStringTypeA(
    LCID     Locale,
    DWORD    dwInfoType,
    LPCSTR   lpSrcStr,
    int      cchSrc,
    LPWORD   lpCharType);


BOOL

GetStringTypeW(
    DWORD    dwInfoType,
    LPCWSTR  lpSrcStr,
    int      cchSrc,
    LPWORD   lpCharType);



int

FoldStringA(
    DWORD    dwMapFlags,
    LPCSTR lpSrcStr,
    int      cchSrc,
    LPSTR  lpDestStr,
    int      cchDest);

int

FoldStringW(
    DWORD    dwMapFlags,
    LPCWSTR lpSrcStr,
    int      cchSrc,
    LPWSTR  lpDestStr,
    int      cchDest);




#line 1075 "d:\\msvc20\\include/winnls.h"


BOOL

EnumSystemLocalesA(
    LOCALE_ENUMPROCA lpLocaleEnumProc,
    DWORD            dwFlags);

BOOL

EnumSystemLocalesW(
    LOCALE_ENUMPROCW lpLocaleEnumProc,
    DWORD            dwFlags);




#line 1093 "d:\\msvc20\\include/winnls.h"


BOOL

EnumSystemCodePagesA(
    CODEPAGE_ENUMPROCA lpCodePageEnumProc,
    DWORD              dwFlags);

BOOL

EnumSystemCodePagesW(
    CODEPAGE_ENUMPROCW lpCodePageEnumProc,
    DWORD              dwFlags);




#line 1111 "d:\\msvc20\\include/winnls.h"



#line 1115 "d:\\msvc20\\include/winnls.h"





#line 1121 "d:\\msvc20\\include/winnls.h"
#line 111 "d:\\msvc20\\include/windows.h"
#line 1 "d:\\msvc20\\include/wincon.h"




























typedef struct _COORD {
    SHORT X;
    SHORT Y;
} COORD, *PCOORD;

typedef struct _SMALL_RECT {
    SHORT Left;
    SHORT Top;
    SHORT Right;
    SHORT Bottom;
} SMALL_RECT, *PSMALL_RECT;

typedef struct _KEY_EVENT_RECORD {
    BOOL bKeyDown;
    WORD wRepeatCount;
    WORD wVirtualKeyCode;
    WORD wVirtualScanCode;
    union {
        WCHAR UnicodeChar;
        CHAR   AsciiChar;
    } uChar;
    DWORD dwControlKeyState;
} KEY_EVENT_RECORD, *PKEY_EVENT_RECORD;















typedef struct _MOUSE_EVENT_RECORD {
    COORD dwMousePosition;
    DWORD dwButtonState;
    DWORD dwControlKeyState;
    DWORD dwEventFlags;
} MOUSE_EVENT_RECORD, *PMOUSE_EVENT_RECORD;


















typedef struct _WINDOW_BUFFER_SIZE_RECORD {
    COORD dwSize;
} WINDOW_BUFFER_SIZE_RECORD, *PWINDOW_BUFFER_SIZE_RECORD;

typedef struct _MENU_EVENT_RECORD {
    UINT dwCommandId;
} MENU_EVENT_RECORD, *PMENU_EVENT_RECORD;

typedef struct _FOCUS_EVENT_RECORD {
    BOOL bSetFocus;
} FOCUS_EVENT_RECORD, *PFOCUS_EVENT_RECORD;

typedef struct _INPUT_RECORD {
    WORD EventType;
    union {
        KEY_EVENT_RECORD KeyEvent;
        MOUSE_EVENT_RECORD MouseEvent;
        WINDOW_BUFFER_SIZE_RECORD WindowBufferSizeEvent;
        MENU_EVENT_RECORD MenuEvent;
        FOCUS_EVENT_RECORD FocusEvent;
    } Event;
} INPUT_RECORD, *PINPUT_RECORD;











typedef struct _CHAR_INFO {
    union {
        WCHAR UnicodeChar;
        CHAR   AsciiChar;
    } Char;
    WORD Attributes;
} CHAR_INFO, *PCHAR_INFO;















typedef struct _CONSOLE_SCREEN_BUFFER_INFO {
    COORD dwSize;
    COORD dwCursorPosition;
    WORD  wAttributes;
    SMALL_RECT srWindow;
    COORD dwMaximumWindowSize;
} CONSOLE_SCREEN_BUFFER_INFO, *PCONSOLE_SCREEN_BUFFER_INFO;

typedef struct _CONSOLE_CURSOR_INFO {
    DWORD  dwSize;
    BOOL   bVisible;
} CONSOLE_CURSOR_INFO, *PCONSOLE_CURSOR_INFO;





typedef
BOOL
( *PHANDLER_ROUTINE)(
    DWORD CtrlType
    );































BOOL

PeekConsoleInputA(
    HANDLE hConsoleInput,
    PINPUT_RECORD lpBuffer,
    DWORD nLength,
    LPDWORD lpNumberOfEventsRead
    );

BOOL

PeekConsoleInputW(
    HANDLE hConsoleInput,
    PINPUT_RECORD lpBuffer,
    DWORD nLength,
    LPDWORD lpNumberOfEventsRead
    );




#line 221 "d:\\msvc20\\include/wincon.h"


BOOL

ReadConsoleInputA(
    HANDLE hConsoleInput,
    PINPUT_RECORD lpBuffer,
    DWORD nLength,
    LPDWORD lpNumberOfEventsRead
    );

BOOL

ReadConsoleInputW(
    HANDLE hConsoleInput,
    PINPUT_RECORD lpBuffer,
    DWORD nLength,
    LPDWORD lpNumberOfEventsRead
    );




#line 245 "d:\\msvc20\\include/wincon.h"


BOOL

WriteConsoleInputA(
    HANDLE hConsoleInput,
    const INPUT_RECORD *lpBuffer,
    DWORD nLength,
    LPDWORD lpNumberOfEventsWritten
    );

BOOL

WriteConsoleInputW(
    HANDLE hConsoleInput,
    const INPUT_RECORD *lpBuffer,
    DWORD nLength,
    LPDWORD lpNumberOfEventsWritten
    );




#line 269 "d:\\msvc20\\include/wincon.h"


BOOL

ReadConsoleOutputA(
    HANDLE hConsoleOutput,
    PCHAR_INFO lpBuffer,
    COORD dwBufferSize,
    COORD dwBufferCoord,
    PSMALL_RECT lpReadRegion
    );

BOOL

ReadConsoleOutputW(
    HANDLE hConsoleOutput,
    PCHAR_INFO lpBuffer,
    COORD dwBufferSize,
    COORD dwBufferCoord,
    PSMALL_RECT lpReadRegion
    );




#line 295 "d:\\msvc20\\include/wincon.h"


BOOL

WriteConsoleOutputA(
    HANDLE hConsoleOutput,
    const CHAR_INFO *lpBuffer,
    COORD dwBufferSize,
    COORD dwBufferCoord,
    PSMALL_RECT lpWriteRegion
    );

BOOL

WriteConsoleOutputW(
    HANDLE hConsoleOutput,
    const CHAR_INFO *lpBuffer,
    COORD dwBufferSize,
    COORD dwBufferCoord,
    PSMALL_RECT lpWriteRegion
    );




#line 321 "d:\\msvc20\\include/wincon.h"


BOOL

ReadConsoleOutputCharacterA(
    HANDLE hConsoleOutput,
    LPSTR lpCharacter,
    DWORD nLength,
    COORD dwReadCoord,
    LPDWORD lpNumberOfCharsRead
    );

BOOL

ReadConsoleOutputCharacterW(
    HANDLE hConsoleOutput,
    LPWSTR lpCharacter,
    DWORD nLength,
    COORD dwReadCoord,
    LPDWORD lpNumberOfCharsRead
    );




#line 347 "d:\\msvc20\\include/wincon.h"


BOOL

ReadConsoleOutputAttribute(
    HANDLE hConsoleOutput,
    LPWORD lpAttribute,
    DWORD nLength,
    COORD dwReadCoord,
    LPDWORD lpNumberOfAttrsRead
    );


BOOL

WriteConsoleOutputCharacterA(
    HANDLE hConsoleOutput,
    LPCSTR lpCharacter,
    DWORD nLength,
    COORD dwWriteCoord,
    LPDWORD lpNumberOfCharsWritten
    );

BOOL

WriteConsoleOutputCharacterW(
    HANDLE hConsoleOutput,
    LPCWSTR lpCharacter,
    DWORD nLength,
    COORD dwWriteCoord,
    LPDWORD lpNumberOfCharsWritten
    );




#line 384 "d:\\msvc20\\include/wincon.h"


BOOL

WriteConsoleOutputAttribute(
    HANDLE hConsoleOutput,
    const WORD *lpAttribute,
    DWORD nLength,
    COORD dwWriteCoord,
    LPDWORD lpNumberOfAttrsWritten
    );


BOOL

FillConsoleOutputCharacterA(
    HANDLE hConsoleOutput,
    CHAR  cCharacter,
    DWORD  nLength,
    COORD  dwWriteCoord,
    LPDWORD lpNumberOfCharsWritten
    );

BOOL

FillConsoleOutputCharacterW(
    HANDLE hConsoleOutput,
    WCHAR  cCharacter,
    DWORD  nLength,
    COORD  dwWriteCoord,
    LPDWORD lpNumberOfCharsWritten
    );




#line 421 "d:\\msvc20\\include/wincon.h"


BOOL

FillConsoleOutputAttribute(
    HANDLE hConsoleOutput,
    WORD   wAttribute,
    DWORD  nLength,
    COORD  dwWriteCoord,
    LPDWORD lpNumberOfAttrsWritten
    );


BOOL

GetConsoleMode(
    HANDLE hConsoleHandle,
    LPDWORD lpMode
    );


BOOL

GetNumberOfConsoleInputEvents(
    HANDLE hConsoleInput,
    LPDWORD lpNumberOfEvents
    );


BOOL

GetConsoleScreenBufferInfo(
    HANDLE hConsoleOutput,
    PCONSOLE_SCREEN_BUFFER_INFO lpConsoleScreenBufferInfo
    );


COORD

GetLargestConsoleWindowSize(
    HANDLE hConsoleOutput
    );


BOOL

GetConsoleCursorInfo(
    HANDLE hConsoleOutput,
    PCONSOLE_CURSOR_INFO lpConsoleCursorInfo
    );


BOOL

GetNumberOfConsoleMouseButtons(
    LPDWORD lpNumberOfMouseButtons
    );


BOOL

SetConsoleMode(
    HANDLE hConsoleHandle,
    DWORD dwMode
    );


BOOL

SetConsoleActiveScreenBuffer(
    HANDLE hConsoleOutput
    );


BOOL

FlushConsoleInputBuffer(
    HANDLE hConsoleInput
    );


BOOL

SetConsoleScreenBufferSize(
    HANDLE hConsoleOutput,
    COORD dwSize
    );


BOOL

SetConsoleCursorPosition(
    HANDLE hConsoleOutput,
    COORD dwCursorPosition
    );


BOOL

SetConsoleCursorInfo(
    HANDLE hConsoleOutput,
    const CONSOLE_CURSOR_INFO *lpConsoleCursorInfo
    );


BOOL

ScrollConsoleScreenBufferA(
    HANDLE hConsoleOutput,
    const SMALL_RECT *lpScrollRectangle,
    const SMALL_RECT *lpClipRectangle,
    COORD dwDestinationOrigin,
    const CHAR_INFO *lpFill
    );

BOOL

ScrollConsoleScreenBufferW(
    HANDLE hConsoleOutput,
    const SMALL_RECT *lpScrollRectangle,
    const SMALL_RECT *lpClipRectangle,
    COORD dwDestinationOrigin,
    const CHAR_INFO *lpFill
    );




#line 550 "d:\\msvc20\\include/wincon.h"


BOOL

SetConsoleWindowInfo(
    HANDLE hConsoleOutput,
    BOOL bAbsolute,
    const SMALL_RECT *lpConsoleWindow
    );


BOOL

SetConsoleTextAttribute(
    HANDLE hConsoleOutput,
    WORD wAttributes
    );


BOOL

SetConsoleCtrlHandler(
    PHANDLER_ROUTINE HandlerRoutine,
    BOOL Add
    );


BOOL

GenerateConsoleCtrlEvent(
    DWORD dwCtrlEvent,
    DWORD dwProcessGroupId
    );


BOOL

AllocConsole( void );


BOOL

FreeConsole( void );



DWORD

GetConsoleTitleA(
    LPSTR lpConsoleTitle,
    DWORD nSize
    );

DWORD

GetConsoleTitleW(
    LPWSTR lpConsoleTitle,
    DWORD nSize
    );




#line 614 "d:\\msvc20\\include/wincon.h"


BOOL

SetConsoleTitleA(
    LPCSTR lpConsoleTitle
    );

BOOL

SetConsoleTitleW(
    LPCWSTR lpConsoleTitle
    );




#line 632 "d:\\msvc20\\include/wincon.h"


BOOL

ReadConsoleA(
    HANDLE hConsoleInput,
    LPVOID lpBuffer,
    DWORD nNumberOfCharsToRead,
    LPDWORD lpNumberOfCharsRead,
    LPVOID lpReserved
    );

BOOL

ReadConsoleW(
    HANDLE hConsoleInput,
    LPVOID lpBuffer,
    DWORD nNumberOfCharsToRead,
    LPDWORD lpNumberOfCharsRead,
    LPVOID lpReserved
    );




#line 658 "d:\\msvc20\\include/wincon.h"


BOOL

WriteConsoleA(
    HANDLE hConsoleOutput,
    const void *lpBuffer,
    DWORD nNumberOfCharsToWrite,
    LPDWORD lpNumberOfCharsWritten,
    LPVOID lpReserved
    );

BOOL

WriteConsoleW(
    HANDLE hConsoleOutput,
    const void *lpBuffer,
    DWORD nNumberOfCharsToWrite,
    LPDWORD lpNumberOfCharsWritten,
    LPVOID lpReserved
    );




#line 684 "d:\\msvc20\\include/wincon.h"




HANDLE

CreateConsoleScreenBuffer(
    DWORD dwDesiredAccess,
    DWORD dwShareMode,
    const SECURITY_ATTRIBUTES *lpSecurityAttributes,
    DWORD dwFlags,
    LPVOID lpScreenBufferData
    );


UINT

GetConsoleCP( void );


BOOL

SetConsoleCP(
    UINT wCodePageID
    );


UINT

GetConsoleOutputCP( void );


BOOL

SetConsoleOutputCP(
    UINT wCodePageID
    );





#line 727 "d:\\msvc20\\include/wincon.h"
#line 112 "d:\\msvc20\\include/windows.h"
#line 1 "d:\\msvc20\\include/winver.h"





































































































































































































































































































#line 295 "d:\\msvc20\\include/winver.h"
#line 113 "d:\\msvc20\\include/windows.h"
#line 1 "d:\\msvc20\\include/winreg.h"






























typedef ACCESS_MASK REGSAM;





typedef HANDLE HKEY;
typedef HKEY *PHKEY;


























LONG

RegCloseKey (
    HKEY hKey
    );


LONG

RegConnectRegistryA (
    LPSTR lpMachineName,
    HKEY hKey,
    PHKEY phkResult
    );

LONG

RegConnectRegistryW (
    LPWSTR lpMachineName,
    HKEY hKey,
    PHKEY phkResult
    );




#line 92 "d:\\msvc20\\include/winreg.h"


LONG

RegCreateKeyA (
    HKEY hKey,
    LPCSTR lpSubKey,
    PHKEY phkResult
    );

LONG

RegCreateKeyW (
    HKEY hKey,
    LPCWSTR lpSubKey,
    PHKEY phkResult
    );




#line 114 "d:\\msvc20\\include/winreg.h"


LONG

RegCreateKeyExA (
    HKEY hKey,
    LPCSTR lpSubKey,
    DWORD Reserved,
    LPSTR lpClass,
    DWORD dwOptions,
    REGSAM samDesired,
    LPSECURITY_ATTRIBUTES lpSecurityAttributes,
    PHKEY phkResult,
    LPDWORD lpdwDisposition
    );

LONG

RegCreateKeyExW (
    HKEY hKey,
    LPCWSTR lpSubKey,
    DWORD Reserved,
    LPWSTR lpClass,
    DWORD dwOptions,
    REGSAM samDesired,
    LPSECURITY_ATTRIBUTES lpSecurityAttributes,
    PHKEY phkResult,
    LPDWORD lpdwDisposition
    );




#line 148 "d:\\msvc20\\include/winreg.h"


LONG

RegDeleteKeyA (
    HKEY hKey,
    LPCSTR lpSubKey
    );

LONG

RegDeleteKeyW (
    HKEY hKey,
    LPCWSTR lpSubKey
    );




#line 168 "d:\\msvc20\\include/winreg.h"


LONG

RegDeleteValueA (
    HKEY hKey,
    LPSTR lpValueName
    );

LONG

RegDeleteValueW (
    HKEY hKey,
    LPWSTR lpValueName
    );




#line 188 "d:\\msvc20\\include/winreg.h"


LONG

RegEnumKeyA (
    HKEY hKey,
    DWORD dwIndex,
    LPSTR lpName,
    DWORD cbName
    );

LONG

RegEnumKeyW (
    HKEY hKey,
    DWORD dwIndex,
    LPWSTR lpName,
    DWORD cbName
    );




#line 212 "d:\\msvc20\\include/winreg.h"


LONG

RegEnumKeyExA (
    HKEY hKey,
    DWORD dwIndex,
    LPSTR lpName,
    LPDWORD lpcbName,
    LPDWORD lpReserved,
    LPSTR lpClass,
    LPDWORD lpcbClass,
    PFILETIME lpftLastWriteTime
    );

LONG

RegEnumKeyExW (
    HKEY hKey,
    DWORD dwIndex,
    LPWSTR lpName,
    LPDWORD lpcbName,
    LPDWORD lpReserved,
    LPWSTR lpClass,
    LPDWORD lpcbClass,
    PFILETIME lpftLastWriteTime
    );




#line 244 "d:\\msvc20\\include/winreg.h"


LONG

RegEnumValueA (
    HKEY hKey,
    DWORD dwIndex,
    LPSTR lpValueName,
    LPDWORD lpcbValueName,
    LPDWORD lpReserved,
    LPDWORD lpType,
    LPBYTE lpData,
    LPDWORD lpcbData
    );

LONG

RegEnumValueW (
    HKEY hKey,
    DWORD dwIndex,
    LPWSTR lpValueName,
    LPDWORD lpcbValueName,
    LPDWORD lpReserved,
    LPDWORD lpType,
    LPBYTE lpData,
    LPDWORD lpcbData
    );




#line 276 "d:\\msvc20\\include/winreg.h"


LONG

RegFlushKey (
    HKEY hKey
    );


LONG

RegGetKeySecurity (
    HKEY hKey,
    SECURITY_INFORMATION SecurityInformation,
    PSECURITY_DESCRIPTOR pSecurityDescriptor,
    LPDWORD lpcbSecurityDescriptor
    );


LONG

RegLoadKeyA (
    HKEY    hKey,
    LPCSTR  lpSubKey,
    LPCSTR  lpFile
    );

LONG

RegLoadKeyW (
    HKEY    hKey,
    LPCWSTR  lpSubKey,
    LPCWSTR  lpFile
    );




#line 315 "d:\\msvc20\\include/winreg.h"


LONG

RegNotifyChangeKeyValue (
    HKEY hKey,
    BOOL bWatchSubtree,
    DWORD dwNotifyFilter,
    HANDLE hEvent,
    BOOL fAsynchronus
    );


LONG

RegOpenKeyA (
    HKEY hKey,
    LPCSTR lpSubKey,
    PHKEY phkResult
    );

LONG

RegOpenKeyW (
    HKEY hKey,
    LPCWSTR lpSubKey,
    PHKEY phkResult
    );




#line 348 "d:\\msvc20\\include/winreg.h"


LONG

RegOpenKeyExA (
    HKEY hKey,
    LPCSTR lpSubKey,
    DWORD ulOptions,
    REGSAM samDesired,
    PHKEY phkResult
    );

LONG

RegOpenKeyExW (
    HKEY hKey,
    LPCWSTR lpSubKey,
    DWORD ulOptions,
    REGSAM samDesired,
    PHKEY phkResult
    );




#line 374 "d:\\msvc20\\include/winreg.h"


LONG

RegQueryInfoKeyA (
    HKEY hKey,
    LPSTR lpClass,
    LPDWORD lpcbClass,
    LPDWORD lpReserved,
    LPDWORD lpcSubKeys,
    LPDWORD lpcbMaxSubKeyLen,
    LPDWORD lpcbMaxClassLen,
    LPDWORD lpcValues,
    LPDWORD lpcbMaxValueNameLen,
    LPDWORD lpcbMaxValueLen,
    LPDWORD lpcbSecurityDescriptor,
    PFILETIME lpftLastWriteTime
    );

LONG

RegQueryInfoKeyW (
    HKEY hKey,
    LPWSTR lpClass,
    LPDWORD lpcbClass,
    LPDWORD lpReserved,
    LPDWORD lpcSubKeys,
    LPDWORD lpcbMaxSubKeyLen,
    LPDWORD lpcbMaxClassLen,
    LPDWORD lpcValues,
    LPDWORD lpcbMaxValueNameLen,
    LPDWORD lpcbMaxValueLen,
    LPDWORD lpcbSecurityDescriptor,
    PFILETIME lpftLastWriteTime
    );




#line 414 "d:\\msvc20\\include/winreg.h"


LONG

RegQueryValueA (
    HKEY hKey,
    LPCSTR lpSubKey,
    LPSTR lpValue,
    PLONG   lpcbValue
    );

LONG

RegQueryValueW (
    HKEY hKey,
    LPCWSTR lpSubKey,
    LPWSTR lpValue,
    PLONG   lpcbValue
    );




#line 438 "d:\\msvc20\\include/winreg.h"


LONG

RegQueryValueExA (
    HKEY hKey,
    LPSTR lpValueName,
    LPDWORD lpReserved,
    LPDWORD lpType,
    LPBYTE lpData,
    LPDWORD lpcbData
    );

LONG

RegQueryValueExW (
    HKEY hKey,
    LPWSTR lpValueName,
    LPDWORD lpReserved,
    LPDWORD lpType,
    LPBYTE lpData,
    LPDWORD lpcbData
    );




#line 466 "d:\\msvc20\\include/winreg.h"


LONG

RegReplaceKeyA (
    HKEY     hKey,
    LPCSTR  lpSubKey,
    LPCSTR  lpNewFile,
    LPCSTR  lpOldFile
    );

LONG

RegReplaceKeyW (
    HKEY     hKey,
    LPCWSTR  lpSubKey,
    LPCWSTR  lpNewFile,
    LPCWSTR  lpOldFile
    );




#line 490 "d:\\msvc20\\include/winreg.h"


LONG

RegRestoreKeyA (
    HKEY hKey,
    LPCSTR lpFile,
    DWORD   dwFlags
    );

LONG

RegRestoreKeyW (
    HKEY hKey,
    LPCWSTR lpFile,
    DWORD   dwFlags
    );




#line 512 "d:\\msvc20\\include/winreg.h"


LONG

RegSaveKeyA (
    HKEY hKey,
    LPCSTR lpFile,
    LPSECURITY_ATTRIBUTES lpSecurityAttributes
    );

LONG

RegSaveKeyW (
    HKEY hKey,
    LPCWSTR lpFile,
    LPSECURITY_ATTRIBUTES lpSecurityAttributes
    );




#line 534 "d:\\msvc20\\include/winreg.h"


LONG

RegSetKeySecurity (
    HKEY hKey,
    SECURITY_INFORMATION SecurityInformation,
    PSECURITY_DESCRIPTOR pSecurityDescriptor
    );


LONG

RegSetValueA (
    HKEY hKey,
    LPCSTR lpSubKey,
    DWORD dwType,
    LPCSTR lpData,
    DWORD cbData
    );

LONG

RegSetValueW (
    HKEY hKey,
    LPCWSTR lpSubKey,
    DWORD dwType,
    LPCWSTR lpData,
    DWORD cbData
    );




#line 569 "d:\\msvc20\\include/winreg.h"



LONG

RegSetValueExA (
    HKEY hKey,
    LPCSTR lpValueName,
    DWORD Reserved,
    DWORD dwType,
    const BYTE* lpData,
    DWORD cbData
    );

LONG

RegSetValueExW (
    HKEY hKey,
    LPCWSTR lpValueName,
    DWORD Reserved,
    DWORD dwType,
    const BYTE* lpData,
    DWORD cbData
    );




#line 598 "d:\\msvc20\\include/winreg.h"


LONG

RegUnLoadKeyA (
    HKEY    hKey,
    LPCSTR lpSubKey
    );

LONG

RegUnLoadKeyW (
    HKEY    hKey,
    LPCWSTR lpSubKey
    );




#line 618 "d:\\msvc20\\include/winreg.h"






BOOL

InitiateSystemShutdownA(
    LPSTR lpMachineName,
    LPSTR lpMessage,
    DWORD dwTimeout,
    BOOL bForceAppsClosed,
    BOOL bRebootAfterShutdown
    );

BOOL

InitiateSystemShutdownW(
    LPWSTR lpMachineName,
    LPWSTR lpMessage,
    DWORD dwTimeout,
    BOOL bForceAppsClosed,
    BOOL bRebootAfterShutdown
    );




#line 648 "d:\\msvc20\\include/winreg.h"



BOOL

AbortSystemShutdownA(
    LPSTR lpMachineName
    );

BOOL

AbortSystemShutdownW(
    LPWSTR lpMachineName
    );




#line 667 "d:\\msvc20\\include/winreg.h"





#line 673 "d:\\msvc20\\include/winreg.h"
#line 114 "d:\\msvc20\\include/windows.h"
#line 1 "d:\\msvc20\\include/winnetwk.h"

































































































typedef struct  _UNIVERSAL_NAME_INFOA {
    LPSTR    lpUniversalName;
}UNIVERSAL_NAME_INFOA, *LPUNIVERSAL_NAME_INFOA;
typedef struct  _UNIVERSAL_NAME_INFOW {
    LPWSTR   lpUniversalName;
}UNIVERSAL_NAME_INFOW, *LPUNIVERSAL_NAME_INFOW;




typedef UNIVERSAL_NAME_INFOA UNIVERSAL_NAME_INFO;
typedef LPUNIVERSAL_NAME_INFOA LPUNIVERSAL_NAME_INFO;
#line 111 "d:\\msvc20\\include/winnetwk.h"

typedef struct  _REMOTE_NAME_INFOA {
    LPSTR    lpUniversalName;
    LPSTR    lpConnectionName;
    LPSTR    lpRemainingPath;
}REMOTE_NAME_INFOA, *LPREMOTE_NAME_INFOA;
typedef struct  _REMOTE_NAME_INFOW {
    LPWSTR   lpUniversalName;
    LPWSTR   lpConnectionName;
    LPWSTR   lpRemainingPath;
}REMOTE_NAME_INFOW, *LPREMOTE_NAME_INFOW;




typedef REMOTE_NAME_INFOA REMOTE_NAME_INFO;
typedef LPREMOTE_NAME_INFOA LPREMOTE_NAME_INFO;
#line 129 "d:\\msvc20\\include/winnetwk.h"

typedef struct  _NETRESOURCEA {
    DWORD    dwScope;
    DWORD    dwType;
    DWORD    dwDisplayType;
    DWORD    dwUsage;
    LPSTR    lpLocalName;
    LPSTR    lpRemoteName;
    LPSTR    lpComment ;
    LPSTR    lpProvider;
}NETRESOURCEA, *LPNETRESOURCEA;
typedef struct  _NETRESOURCEW {
    DWORD    dwScope;
    DWORD    dwType;
    DWORD    dwDisplayType;
    DWORD    dwUsage;
    LPWSTR   lpLocalName;
    LPWSTR   lpRemoteName;
    LPWSTR   lpComment ;
    LPWSTR   lpProvider;
}NETRESOURCEW, *LPNETRESOURCEW;




typedef NETRESOURCEA NETRESOURCE;
typedef LPNETRESOURCEA LPNETRESOURCE;
#line 157 "d:\\msvc20\\include/winnetwk.h"



















DWORD 
WNetAddConnectionA (
     LPCSTR   lpRemoteName,
     LPCSTR   lpPassword,
     LPCSTR   lpLocalName
    );
DWORD 
WNetAddConnectionW (
     LPCWSTR   lpRemoteName,
     LPCWSTR   lpPassword,
     LPCWSTR   lpLocalName
    );




#line 193 "d:\\msvc20\\include/winnetwk.h"


DWORD 
WNetAddConnection2A (
     LPNETRESOURCEA lpNetResource,
     LPCSTR       lpPassword,
     LPCSTR       lpUserName,
     DWORD          dwFlags
    );
DWORD 
WNetAddConnection2W (
     LPNETRESOURCEW lpNetResource,
     LPCWSTR       lpPassword,
     LPCWSTR       lpUserName,
     DWORD          dwFlags
    );




#line 214 "d:\\msvc20\\include/winnetwk.h"

DWORD 
WNetAddConnection3A (
     HWND           hwndOwner,
     LPNETRESOURCEA lpNetResource,
     LPCSTR       lpPassword,
     LPCSTR       lpUserName,
     DWORD          dwFlags
    );
DWORD 
WNetAddConnection3W (
     HWND           hwndOwner,
     LPNETRESOURCEW lpNetResource,
     LPCWSTR       lpPassword,
     LPCWSTR       lpUserName,
     DWORD          dwFlags
    );




#line 236 "d:\\msvc20\\include/winnetwk.h"

DWORD 
WNetCancelConnectionA (
     LPCSTR lpName,
     BOOL     fForce
    );
DWORD 
WNetCancelConnectionW (
     LPCWSTR lpName,
     BOOL     fForce
    );




#line 252 "d:\\msvc20\\include/winnetwk.h"

DWORD 
WNetCancelConnection2A (
     LPCSTR lpName,
     DWORD    dwFlags,
     BOOL     fForce
    );
DWORD 
WNetCancelConnection2W (
     LPCWSTR lpName,
     DWORD    dwFlags,
     BOOL     fForce
    );




#line 270 "d:\\msvc20\\include/winnetwk.h"


DWORD 
WNetGetConnectionA (
     LPCSTR lpLocalName,
     LPSTR  lpRemoteName,
     LPDWORD  lpnLength
    );
DWORD 
WNetGetConnectionW (
     LPCWSTR lpLocalName,
     LPWSTR  lpRemoteName,
     LPDWORD  lpnLength
    );




#line 289 "d:\\msvc20\\include/winnetwk.h"

DWORD 
WNetGetUniversalNameA (
     LPCSTR lpLocalPath,
     DWORD    dwInfoLevel,
     LPVOID   lpBuffer,
     LPDWORD  lpBufferSize
     );
DWORD 
WNetGetUniversalNameW (
     LPCWSTR lpLocalPath,
     DWORD    dwInfoLevel,
     LPVOID   lpBuffer,
     LPDWORD  lpBufferSize
     );




#line 309 "d:\\msvc20\\include/winnetwk.h"


DWORD 
WNetOpenEnumA (
     DWORD          dwScope,
     DWORD          dwType,
     DWORD          dwUsage,
     LPNETRESOURCEA lpNetResource,
     LPHANDLE       lphEnum
    );
DWORD 
WNetOpenEnumW (
     DWORD          dwScope,
     DWORD          dwType,
     DWORD          dwUsage,
     LPNETRESOURCEW lpNetResource,
     LPHANDLE       lphEnum
    );




#line 332 "d:\\msvc20\\include/winnetwk.h"

DWORD 
WNetEnumResourceA (
     HANDLE  hEnum,
     LPDWORD lpcCount,
     LPVOID  lpBuffer,
     LPDWORD lpBufferSize
    );
DWORD 
WNetEnumResourceW (
     HANDLE  hEnum,
     LPDWORD lpcCount,
     LPVOID  lpBuffer,
     LPDWORD lpBufferSize
    );




#line 352 "d:\\msvc20\\include/winnetwk.h"

DWORD 
WNetCloseEnum (
    HANDLE   hEnum
    );





DWORD 
WNetGetUserA (
     LPCSTR  lpName,
     LPSTR   lpUserName,
     LPDWORD   lpnLength
    );
DWORD 
WNetGetUserW (
     LPCWSTR  lpName,
     LPWSTR   lpUserName,
     LPDWORD   lpnLength
    );




#line 379 "d:\\msvc20\\include/winnetwk.h"





DWORD  WNetConnectionDialog(
    HWND  hwnd,
    DWORD dwType
    );

DWORD  WNetDisconnectDialog(
    HWND  hwnd,
    DWORD dwType
    );







DWORD 
WNetGetLastErrorA (
     LPDWORD    lpError,
     LPSTR    lpErrorBuf,
     DWORD      nErrorBufSize,
     LPSTR    lpNameBuf,
     DWORD      nNameBufSize
    );
DWORD 
WNetGetLastErrorW (
     LPDWORD    lpError,
     LPWSTR    lpErrorBuf,
     DWORD      nErrorBufSize,
     LPWSTR    lpNameBuf,
     DWORD      nNameBufSize
    );




#line 421 "d:\\msvc20\\include/winnetwk.h"


























































#line 480 "d:\\msvc20\\include/winnetwk.h"


#line 115 "d:\\msvc20\\include/windows.h"


#line 1 "d:\\msvc20\\include/cderr.h"















































#line 49 "d:\\msvc20\\include/cderr.h"
#line 118 "d:\\msvc20\\include/windows.h"
#line 1 "d:\\msvc20\\include/dde.h"


































typedef struct {
        unsigned short bAppReturnCode:8,
                 reserved:6,
                 fBusy:1,
		 fAck:1;
} DDEACK;









typedef struct {
        unsigned short reserved:14,
                 fDeferUpd:1,
		 fAckReq:1;
	short     cfFormat;
} DDEADVISE;











typedef struct {
	unsigned short unused:12,
                 fResponse:1,
                 fRelease:1,
                 reserved:1,
                 fAckReq:1;
	short	 cfFormat;
	BYTE	 Value[1];
} DDEDATA;











typedef struct {
	unsigned short unused:13,  
                             
		 fRelease:1,
		 fReserved:2;
	short    cfFormat;
	BYTE	 Value[1];  
                            

} DDEPOKE;











typedef struct {
        unsigned short unused:13,
                 fRelease:1,
                 fDeferUpd:1,
		 fAckReq:1;
	short	 cfFormat;
} DDELN;

typedef struct {
	unsigned short unused:12,
                 fAck:1,
                 fRelease:1,
                 fReserved:1,
                 fAckReq:1;
	short	 cfFormat;
	BYTE	 rgb[1];
} DDEUP;






BOOL

DdeSetQualityOfService(
    HWND hwndClient,
    const SECURITY_QUALITY_OF_SERVICE *pqosNew,
    PSECURITY_QUALITY_OF_SERVICE pqosPrev);

BOOL

ImpersonateDdeClientWindow(
    HWND hWndClient,
    HWND hWndServer);




LONG  PackDDElParam(UINT msg, UINT uiLo, UINT uiHi);
BOOL  UnpackDDElParam(UINT msg, LONG lParam, PUINT puiLo, PUINT puiHi);
BOOL  FreeDDElParam(UINT msg, LONG lParam);
LONG  ReuseDDElParam(LONG lParam, UINT msgIn, UINT msgOut, UINT uiLo, UINT uiHi);





#line 157 "d:\\msvc20\\include/dde.h"
#line 119 "d:\\msvc20\\include/windows.h"
#line 1 "d:\\msvc20\\include/ddeml.h"




















typedef DWORD           HCONVLIST;
typedef DWORD           HCONV;
typedef DWORD           HSZ;
typedef DWORD           HDDEDATA;




typedef struct tagHSZPAIR {
    HSZ hszSvc;
    HSZ hszTopic;
} HSZPAIR;
typedef HSZPAIR  *PHSZPAIR;




typedef struct tagCONVCONTEXT {
    UINT        cb;             
    UINT        wFlags;         
    UINT        wCountryID;     
    int         iCodePage;      
    DWORD       dwLangID;       
    DWORD       dwSecurity;     
    SECURITY_QUALITY_OF_SERVICE qos;  
} CONVCONTEXT;
typedef CONVCONTEXT  *PCONVCONTEXT;




typedef struct tagCONVINFO {
    DWORD   cb;            
    DWORD   hUser;         
    HCONV   hConvPartner;  
    HSZ     hszSvcPartner; 
    HSZ     hszServiceReq; 
    HSZ     hszTopic;      
    HSZ     hszItem;       
    UINT    wFmt;          
    UINT    wType;         
    UINT    wStatus;       
    UINT    wConvst;       
    UINT    wLastError;    
    HCONVLIST hConvList;   
    CONVCONTEXT ConvCtxt;  
    HWND    hwnd;          
    HWND    hwndPartner;   
} CONVINFO;
typedef CONVINFO  *PCONVINFO;

























































































































#line 193 "d:\\msvc20\\include/ddeml.h"




typedef HDDEDATA  FNCALLBACK(UINT wType, UINT wFmt, HCONV hConv,
        HSZ hsz1, HSZ hsz2, HDDEDATA hData, DWORD dwData1, DWORD dwData2);
typedef HDDEDATA ( *PFNCALLBACK)(UINT wType, UINT wFmt, HCONV hConv,
        HSZ hsz1, HSZ hsz2, HDDEDATA hData, DWORD dwData1, DWORD dwData2);





UINT  DdeInitializeA(LPDWORD pidInst, PFNCALLBACK pfnCallback,
        DWORD afCmd, DWORD ulRes);
UINT  DdeInitializeW(LPDWORD pidInst, PFNCALLBACK pfnCallback,
        DWORD afCmd, DWORD ulRes);




#line 215 "d:\\msvc20\\include/ddeml.h"


































BOOL  DdeUninitialize(DWORD idInst);





HCONVLIST  DdeConnectList(DWORD idInst, HSZ hszService, HSZ hszTopic,
        HCONVLIST hConvList, PCONVCONTEXT pCC);
HCONV  DdeQueryNextServer(HCONVLIST hConvList, HCONV hConvPrev);
BOOL  DdeDisconnectList(HCONVLIST hConvList);





HCONV  DdeConnect(DWORD idInst, HSZ hszService, HSZ hszTopic,
        PCONVCONTEXT pCC);
BOOL  DdeDisconnect(HCONV hConv);
HCONV  DdeReconnect(HCONV hConv);
UINT  DdeQueryConvInfo(HCONV hConv, DWORD idTransaction, PCONVINFO pConvInfo);
BOOL  DdeSetUserHandle(HCONV hConv, DWORD id, DWORD hUser);
BOOL  DdeAbandonTransaction(DWORD idInst, HCONV hConv, DWORD idTransaction);






BOOL  DdePostAdvise(DWORD idInst, HSZ hszTopic, HSZ hszItem);
BOOL  DdeEnableCallback(DWORD idInst, HCONV hConv, UINT wCmd);
BOOL  DdeImpersonateClient(HCONV hConv);







HDDEDATA  DdeNameService(DWORD idInst, HSZ hsz1, HSZ hsz2, UINT afCmd);










HDDEDATA  DdeClientTransaction(LPBYTE pData, DWORD cbData,
        HCONV hConv, HSZ hszItem, UINT wFmt, UINT wType,
        DWORD dwTimeout, LPDWORD pdwResult);





HDDEDATA  DdeCreateDataHandle(DWORD idInst, LPBYTE pSrc, DWORD cb,
        DWORD cbOff, HSZ hszItem, UINT wFmt, UINT afCmd);
HDDEDATA  DdeAddData(HDDEDATA hData, LPBYTE pSrc, DWORD cb, DWORD cbOff);
DWORD  DdeGetData(HDDEDATA hData, LPBYTE pDst, DWORD cbMax, DWORD cbOff);
LPBYTE  DdeAccessData(HDDEDATA hData, LPDWORD pcbDataSize);
BOOL  DdeUnaccessData(HDDEDATA hData);
BOOL  DdeFreeDataHandle(HDDEDATA hData);




UINT  DdeGetLastError(DWORD idInst);


























HSZ   DdeCreateStringHandleA(DWORD idInst, LPSTR psz, int iCodePage);
HSZ   DdeCreateStringHandleW(DWORD idInst, LPWSTR psz, int iCodePage);




#line 351 "d:\\msvc20\\include/ddeml.h"
DWORD  DdeQueryStringA(DWORD idInst, HSZ hsz, LPSTR psz, DWORD cchMax, int iCodePage);
DWORD  DdeQueryStringW(DWORD idInst, HSZ hsz, LPWSTR psz, DWORD cchMax, int iCodePage);




#line 358 "d:\\msvc20\\include/ddeml.h"
BOOL  DdeFreeStringHandle(DWORD idInst, HSZ hsz);
BOOL  DdeKeepStringHandle(DWORD idInst, HSZ hsz);
int  DdeCmpStringHandles(HSZ hsz1, HSZ hsz2);







typedef struct tagDDEML_MSG_HOOK_DATA {    
    UINT uiLo;      
    UINT uiHi;
    DWORD cbData;   
    DWORD Data[8];  
} DDEML_MSG_HOOK_DATA, *PDDEML_MSG_HOOK_DATA;


typedef struct tagMONMSGSTRUCT {
    UINT    cb;
    HWND    hwndTo;
    DWORD   dwTime;
    HANDLE  hTask;
    UINT    wMsg;
    WPARAM  wParam;
    LPARAM  lParam;
    DDEML_MSG_HOOK_DATA dmhd;       
} MONMSGSTRUCT, *PMONMSGSTRUCT;

typedef struct tagMONCBSTRUCT {
    UINT   cb;
    DWORD  dwTime;
    HANDLE hTask;
    DWORD  dwRet;
    UINT   wType;
    UINT   wFmt;
    HCONV  hConv;
    HSZ    hsz1;
    HSZ    hsz2;
    HDDEDATA hData;
    DWORD  dwData1;
    DWORD  dwData2;
    CONVCONTEXT cc;                 
    DWORD  cbData;                  
    DWORD  Data[8];                 
} MONCBSTRUCT, *PMONCBSTRUCT;

typedef struct tagMONHSZSTRUCTA {
    UINT   cb;
    BOOL   fsAction;    
    DWORD  dwTime;
    HSZ    hsz;
    HANDLE hTask;
    CHAR    str[1];
} MONHSZSTRUCTA, *PMONHSZSTRUCTA;
typedef struct tagMONHSZSTRUCTW {
    UINT   cb;
    BOOL   fsAction;    
    DWORD  dwTime;
    HSZ    hsz;
    HANDLE hTask;
    WCHAR   str[1];
} MONHSZSTRUCTW, *PMONHSZSTRUCTW;




typedef MONHSZSTRUCTA MONHSZSTRUCT;
typedef PMONHSZSTRUCTA PMONHSZSTRUCT;
#line 428 "d:\\msvc20\\include/ddeml.h"






typedef struct tagMONERRSTRUCT {
    UINT    cb;
    UINT    wLastError;
    DWORD   dwTime;
    HANDLE  hTask;
} MONERRSTRUCT, *PMONERRSTRUCT;

typedef struct tagMONLINKSTRUCT {
    UINT    cb;
    DWORD   dwTime;
    HANDLE  hTask;
    BOOL    fEstablished;
    BOOL    fNoData;
    HSZ     hszSvc;
    HSZ     hszTopic;
    HSZ     hszItem;
    UINT    wFmt;
    BOOL    fServer;
    HCONV   hConvServer;
    HCONV   hConvClient;
} MONLINKSTRUCT, *PMONLINKSTRUCT;

typedef struct tagMONCONVSTRUCT {
    UINT    cb;
    BOOL    fConnect;
    DWORD   dwTime;
    HANDLE  hTask;
    HSZ     hszSvc;
    HSZ     hszTopic;
    HCONV   hConvClient;        
    HCONV   hConvServer;        
} MONCONVSTRUCT, PMONCONVSTRUCT;


















#line 485 "d:\\msvc20\\include/ddeml.h"





#line 491 "d:\\msvc20\\include/ddeml.h"


#line 120 "d:\\msvc20\\include/windows.h"
#line 1 "d:\\msvc20\\include/dlgs.h"












    

















    
















    
















    
















    
































    
















    
















    
















    
























typedef struct tagCRGB
    {
    BYTE    bRed;
    BYTE    bGreen;
    BYTE    bBlue;
    BYTE    bExtra;
    }
CRGB;           


#line 202 "d:\\msvc20\\include/dlgs.h"
#line 121 "d:\\msvc20\\include/windows.h"
#line 1 "d:\\msvc20\\include/lzexpand.h"





























INT

LZStart(
	void
	);

void

LZDone(
	void
	);

LONG

CopyLZFile(
	INT,
	INT
	);

LONG

LZCopy(
	INT,
	INT
	);

INT

LZInit(
	INT
	);

INT

GetExpandedNameA(
	LPSTR,
	LPSTR
	);
INT

GetExpandedNameW(
	LPWSTR,
	LPWSTR
	);




#line 79 "d:\\msvc20\\include/lzexpand.h"

INT

LZOpenFileA(
	LPSTR,
	LPOFSTRUCT,
	WORD
	);
INT

LZOpenFileW(
	LPWSTR,
	LPOFSTRUCT,
	WORD
	);




#line 99 "d:\\msvc20\\include/lzexpand.h"

LONG

LZSeek(
	INT,
	LONG,
	INT
	);

INT

LZRead(
	INT,
	LPSTR,
	INT
	);

void

LZClose(
	INT
	);






#line 128 "d:\\msvc20\\include/lzexpand.h"
#line 122 "d:\\msvc20\\include/windows.h"
#line 1 "d:\\msvc20\\include/mmsystem.h"































#line 1 "d:\\msvc20\\include/pshpack1.h"































#line 33 "d:\\msvc20\\include/pshpack1.h"
#line 33 "d:\\msvc20\\include/mmsystem.h"




























#line 62 "d:\\msvc20\\include/mmsystem.h"


















#line 81 "d:\\msvc20\\include/mmsystem.h"



typedef UINT    MMVERSION;      

typedef UINT    MMRESULT;       
                                



typedef UINT       *LPUINT;





typedef struct mmtime_tag
{
    UINT            wType;      
    union
    {
        DWORD ms;               
        DWORD sample;           
        DWORD cb;               
        DWORD ticks;            

        
        struct
        {
            BYTE hour;          
            BYTE min;           
            BYTE sec;           
            BYTE frame;         
            BYTE fps;           
            BYTE dummy;         
            BYTE pad[2];
            } smpte;
        
        struct
        {
            DWORD songptrpos;   
        } midi;
    } u;
} MMTIME;
typedef MMTIME       *PMMTIME;
typedef MMTIME      *NPMMTIME;
typedef MMTIME      *LPMMTIME;


































































                                    



























                                                   
                                                   











typedef HANDLE HDRVR;





















typedef struct tagDRVCONFIGINFO {
    DWORD     dwDCISize;
    LPCWSTR   lpszDCISectionName;
    LPCWSTR   lpszDCIAliasName;
} DRVCONFIGINFO;
typedef DRVCONFIGINFO        *PDRVCONFIGINFO;
typedef DRVCONFIGINFO       *NPDRVCONFIGINFO;
typedef DRVCONFIGINFO       *LPDRVCONFIGINFO;













LRESULT  CloseDriver(HDRVR hDriver, LONG lParam1, LONG lParam2);
HDRVR    OpenDriver( LPCWSTR szDriverName, LPCWSTR szSectionName, LONG lParam2);
LRESULT  SendDriverMessage( HDRVR hDriver, UINT uMsg, LONG lParam1, LONG lParam2);
HMODULE  DrvGetModuleHandle( HDRVR hDriver );
HMODULE  GetDriverModuleHandle( HDRVR hDriver );
LRESULT    DefDriverProc(DWORD dwDriverIdentifier, HDRVR driverID, UINT message, LPARAM lParam1, LPARAM lParam2);




#line 289 "d:\\msvc20\\include/mmsystem.h"
#line 290 "d:\\msvc20\\include/mmsystem.h"




















typedef void ( DRVCALLBACK)(HDRVR hdrvr, UINT uMsg, DWORD dwUser,
                                                    DWORD dw1, DWORD dw2);

typedef DRVCALLBACK     *LPDRVCALLBACK;
typedef DRVCALLBACK     *PDRVCALLBACK;

#line 317 "d:\\msvc20\\include/mmsystem.h"









UINT  mmsystemGetVersion(void);




#line 332 "d:\\msvc20\\include/mmsystem.h"











BOOL  sndPlaySoundA( LPCSTR lpszSoundName, UINT fuSound );
BOOL  sndPlaySoundW( LPCWSTR lpszSoundName, UINT fuSound );




#line 350 "d:\\msvc20\\include/mmsystem.h"
BOOL  PlaySoundA( LPCSTR lpszName, HMODULE hModule, DWORD dwFlags );
BOOL  PlaySoundW( LPCWSTR lpszName, HMODULE hModule, DWORD dwFlags );




#line 357 "d:\\msvc20\\include/mmsystem.h"































                                    













#line 403 "d:\\msvc20\\include/mmsystem.h"

















typedef HANDLE          HWAVE;
typedef HWAVE           HWAVEIN;
typedef HWAVE           HWAVEOUT;

typedef HWAVEIN     *LPHWAVEIN;
typedef HWAVEOUT     *LPHWAVEOUT;

typedef DRVCALLBACK     WAVECALLBACK;
typedef WAVECALLBACK     *LPWAVECALLBACK;

















typedef struct wavehdr_tag {
    LPBYTE      lpData;               
    DWORD       dwBufferLength;       
    DWORD       dwBytesRecorded;      
    DWORD       dwUser;               
    DWORD       dwFlags;              
    DWORD       dwLoops;              
    struct wavehdr_tag     *lpNext;   
    DWORD                 reserved;   
} WAVEHDR;
typedef WAVEHDR       *PWAVEHDR;
typedef WAVEHDR      *NPWAVEHDR;
typedef WAVEHDR      *LPWAVEHDR;









typedef struct tagWAVEOUTCAPSA {
    WORD    wMid;                   
    WORD    wPid;                   
    MMVERSION vDriverVersion;       
    CHAR    szPname[32];   
    DWORD   dwFormats;              
    WORD    wChannels;              
    WORD    wReserved1;             
    DWORD   dwSupport;              
} WAVEOUTCAPSA;

typedef struct tagWAVEOUTCAPSW {
    WORD    wMid;                   
    WORD    wPid;                   
    MMVERSION vDriverVersion;       
    WCHAR   szPname[32];   
    DWORD   dwFormats;              
    WORD    wChannels;              
    WORD    wReserved1;             
    DWORD   dwSupport;              
} WAVEOUTCAPSW;



typedef WAVEOUTCAPSA WAVEOUTCAPS;
#line 494 "d:\\msvc20\\include/mmsystem.h"
typedef WAVEOUTCAPSA      *PWAVEOUTCAPSA;
typedef WAVEOUTCAPSW      *PWAVEOUTCAPSW;



typedef PWAVEOUTCAPSA PWAVEOUTCAPS;
#line 501 "d:\\msvc20\\include/mmsystem.h"
typedef WAVEOUTCAPSA      *NPWAVEOUTCAPSA;
typedef WAVEOUTCAPSW      *NPWAVEOUTCAPSW;



typedef NPWAVEOUTCAPSA NPWAVEOUTCAPS;
#line 508 "d:\\msvc20\\include/mmsystem.h"
typedef WAVEOUTCAPSA      *LPWAVEOUTCAPSA;
typedef WAVEOUTCAPSW      *LPWAVEOUTCAPSW;



typedef LPWAVEOUTCAPSA LPWAVEOUTCAPS;
#line 515 "d:\\msvc20\\include/mmsystem.h"









typedef struct tagWAVEINCAPSA {
    WORD    wMid;                    
    WORD    wPid;                    
    MMVERSION vDriverVersion;        
    CHAR    szPname[32];    
    DWORD   dwFormats;               
    WORD    wChannels;               
    WORD    wReserved1;              
} WAVEINCAPSA;

typedef struct tagWAVEINCAPSW {
    WORD    wMid;                    
    WORD    wPid;                    
    MMVERSION vDriverVersion;        
    WCHAR   szPname[32];    
    DWORD   dwFormats;               
    WORD    wChannels;               
    WORD    wReserved1;              
} WAVEINCAPSW;



typedef WAVEINCAPSA WAVEINCAPS;
#line 548 "d:\\msvc20\\include/mmsystem.h"
typedef WAVEINCAPSA     *PWAVEINCAPSA;
typedef WAVEINCAPSW     *PWAVEINCAPSW;



typedef PWAVEINCAPSA PWAVEINCAPS;
#line 555 "d:\\msvc20\\include/mmsystem.h"
typedef WAVEINCAPSA     *LPWAVEINCAPSA;
typedef WAVEINCAPSW     *LPWAVEINCAPSW;



typedef LPWAVEINCAPSA LPWAVEINCAPS;
#line 562 "d:\\msvc20\\include/mmsystem.h"


















typedef struct {
    WORD    wFormatTag;        
    WORD    nChannels;         
    DWORD   nSamplesPerSec;    
    DWORD   nAvgBytesPerSec;   
    WORD    nBlockAlign;       
} WAVEFORMAT;
typedef WAVEFORMAT       *PWAVEFORMAT;
typedef WAVEFORMAT      *NPWAVEFORMAT;
typedef WAVEFORMAT      *LPWAVEFORMAT;
typedef const WAVEFORMAT  *LPCWAVEFORMAT;
























































































































#line 712 "d:\\msvc20\\include/mmsystem.h"





















typedef HANDLE  HMIDI;
typedef HMIDI   HMIDIIN;
typedef HMIDI   HMIDIOUT;

typedef HMIDIIN     *LPHMIDIIN;
typedef HMIDIOUT     *LPHMIDIOUT;
typedef DRVCALLBACK MIDICALLBACK;
typedef MIDICALLBACK     *LPMIDICALLBACK;

typedef WORD PATCHARRAY[128];
typedef WORD     *LPPATCHARRAY;
typedef WORD KEYARRAY[128];
typedef WORD     *LPKEYARRAY;























typedef struct tagMIDIOUTCAPSA {
    WORD    wMid;                  
    WORD    wPid;                  
    MMVERSION vDriverVersion;      
    CHAR    szPname[32];  
    WORD    wTechnology;           
    WORD    wVoices;               
    WORD    wNotes;                
    WORD    wChannelMask;          
    DWORD   dwSupport;             
} MIDIOUTCAPSA;

typedef struct tagMIDIOUTCAPSW {
    WORD    wMid;                  
    WORD    wPid;                  
    MMVERSION vDriverVersion;      
    WCHAR   szPname[32];  
    WORD    wTechnology;           
    WORD    wVoices;               
    WORD    wNotes;                
    WORD    wChannelMask;          
    DWORD   dwSupport;             
} MIDIOUTCAPSW;



typedef MIDIOUTCAPSA MIDIOUTCAPS;
#line 797 "d:\\msvc20\\include/mmsystem.h"
typedef MIDIOUTCAPSA    *PMIDIOUTCAPSA;
typedef MIDIOUTCAPSW    *PMIDIOUTCAPSW;



typedef PMIDIOUTCAPSA PMIDIOUTCAPS;
#line 804 "d:\\msvc20\\include/mmsystem.h"
typedef MIDIOUTCAPSA      *NPMIDIOUTCAPSA;
typedef MIDIOUTCAPSW      *NPMIDIOUTCAPSW;



typedef NPMIDIOUTCAPSA NPMIDIOUTCAPS;
#line 811 "d:\\msvc20\\include/mmsystem.h"
typedef MIDIOUTCAPSA      *LPMIDIOUTCAPSA;
typedef MIDIOUTCAPSW      *LPMIDIOUTCAPSW;



typedef LPMIDIOUTCAPSA LPMIDIOUTCAPS;
#line 818 "d:\\msvc20\\include/mmsystem.h"














typedef struct tagMIDIINCAPSA {
    WORD        wMid;                   
    WORD        wPid;                   
    MMVERSION   vDriverVersion;         
    CHAR        szPname[32];   
} MIDIINCAPSA;

typedef struct tagMIDIINCAPSW {
    WORD        wMid;                   
    WORD        wPid;                   
    MMVERSION   vDriverVersion;         
    WCHAR       szPname[32];   
} MIDIINCAPSW;



typedef MIDIINCAPSA MIDIINCAPS;
#line 850 "d:\\msvc20\\include/mmsystem.h"
typedef MIDIINCAPSA     *PMIDIINCAPSA;
typedef MIDIINCAPSW     *PMIDIINCAPSW;



typedef PMIDIINCAPSA PMIDIINCAPS;
#line 857 "d:\\msvc20\\include/mmsystem.h"
typedef MIDIINCAPSA      *NPMIDIINCAPSA;
typedef MIDIINCAPSW      *NPMIDIINCAPSW;



typedef NPMIDIINCAPSA NPMIDIINCAPS;
#line 864 "d:\\msvc20\\include/mmsystem.h"
typedef MIDIINCAPSA     *LPMIDIINCAPSA;
typedef MIDIINCAPSW     *LPMIDIINCAPSW;



typedef LPMIDIINCAPSA LPMIDIINCAPS;
#line 871 "d:\\msvc20\\include/mmsystem.h"


typedef struct midihdr_tag {
    LPBYTE      lpData;               
    DWORD       dwBufferLength;       
    DWORD       dwBytesRecorded;      
    DWORD       dwUser;               
    DWORD       dwFlags;              
    struct midihdr_tag     *lpNext;   
    DWORD       reserved;             
} MIDIHDR;
typedef MIDIHDR       *PMIDIHDR;
typedef MIDIHDR      *NPMIDIHDR;
typedef MIDIHDR      *LPMIDIHDR;








UINT  midiOutGetNumDevs(void);

MMRESULT  midiOutGetDevCapsA(UINT uDeviceID, LPMIDIOUTCAPSA lpCaps, UINT cbCaps);
MMRESULT  midiOutGetDevCapsW(UINT uDeviceID, LPMIDIOUTCAPSW lpCaps, UINT cbCaps);




#line 902 "d:\\msvc20\\include/mmsystem.h"

MMRESULT  midiOutGetVolume(UINT uId, LPDWORD lpdwVolume);
MMRESULT  midiOutSetVolume(UINT uId, DWORD dwVolume);

MMRESULT  midiOutGetErrorTextA(MMRESULT mmrError, LPSTR lpText, UINT cchText);
MMRESULT  midiOutGetErrorTextW(MMRESULT mmrError, LPWSTR lpText, UINT cchText);




#line 913 "d:\\msvc20\\include/mmsystem.h"

MMRESULT  midiOutOpen(LPHMIDIOUT lphmo, UINT uDeviceID,
    DWORD dwCallback, DWORD dwInstance, DWORD fdwOpen);
MMRESULT  midiOutClose(HMIDIOUT hmo);
MMRESULT  midiOutPrepareHeader(HMIDIOUT hmo, LPMIDIHDR lpmh, UINT cbmh);
MMRESULT  midiOutUnprepareHeader(HMIDIOUT hmo, LPMIDIHDR lpmh, UINT cbmh);

MMRESULT  midiOutShortMsg(HMIDIOUT hmo, DWORD dwMsg);
MMRESULT  midiOutLongMsg(HMIDIOUT hmo, LPMIDIHDR lpmh, UINT cbmh);
MMRESULT  midiOutReset(HMIDIOUT hmo);
MMRESULT  midiOutCachePatches(HMIDIOUT hmo, UINT uBank, LPWORD lpwpa, UINT fuCache);
MMRESULT  midiOutCacheDrumPatches(HMIDIOUT hmo,
             UINT uPatch, LPWORD lpwkya, UINT fuCache);
MMRESULT  midiOutGetID(HMIDIOUT hmo, LPUINT lpuDeviceID);

MMRESULT  midiOutMessage(HMIDIOUT hmo, UINT uMsg, DWORD dw1, DWORD dw2);

UINT  midiInGetNumDevs(void);
MMRESULT  midiInGetDevCapsA(UINT uDeviceID, LPMIDIINCAPSA lpCaps, UINT cbCaps);
MMRESULT  midiInGetDevCapsW(UINT uDeviceID, LPMIDIINCAPSW lpCaps, UINT cbCaps);




#line 938 "d:\\msvc20\\include/mmsystem.h"

MMRESULT  midiInGetErrorTextA(MMRESULT err, LPSTR lpText, UINT cchText);
MMRESULT  midiInGetErrorTextW(MMRESULT err, LPWSTR lpText, UINT cchText);




#line 946 "d:\\msvc20\\include/mmsystem.h"

MMRESULT  midiInOpen(LPHMIDIIN lphmi, UINT uDeviceID,
        DWORD dwCallback, DWORD dwInstance, DWORD fdwOpen);
MMRESULT  midiInClose(HMIDIIN hmi);
MMRESULT  midiInPrepareHeader(HMIDIIN hmi, LPMIDIHDR lpmh, UINT cbmh);
MMRESULT  midiInUnprepareHeader(HMIDIIN hmi, LPMIDIHDR lpmh, UINT cbmh);
MMRESULT  midiInAddBuffer(HMIDIIN hmi, LPMIDIHDR lpmh, UINT cbmh);
MMRESULT  midiInStart(HMIDIIN hmi);
MMRESULT  midiInStop(HMIDIIN hmi);
MMRESULT  midiInReset(HMIDIIN hmi);
MMRESULT  midiInGetID(HMIDIIN hmi, LPUINT lpuDeviceID);

MMRESULT  midiInMessage(HMIDIIN hmi, UINT uMsg, DWORD dw1, DWORD dw2);

#line 961 "d:\\msvc20\\include/mmsystem.h"














typedef struct tagAUXCAPSA {
    WORD        wMid;                   
    WORD        wPid;                   
    MMVERSION   vDriverVersion;         
    CHAR        szPname[32];   
    WORD        wTechnology;            
    WORD        wReserved1;             
    DWORD       dwSupport;              
} AUXCAPSA;

typedef struct tagAUXCAPSW {
    WORD        wMid;                   
    WORD        wPid;                   
    MMVERSION   vDriverVersion;         
    WCHAR       szPname[32];   
    WORD        wTechnology;            
    WORD        wReserved1;             
    DWORD       dwSupport;              
} AUXCAPSW;



typedef AUXCAPSA AUXCAPS;
#line 999 "d:\\msvc20\\include/mmsystem.h"
typedef AUXCAPSA      *PAUXCAPSA;
typedef AUXCAPSW      *PAUXCAPSW;



typedef PAUXCAPSA PAUXCAPS;
#line 1006 "d:\\msvc20\\include/mmsystem.h"
typedef AUXCAPSA      *NPAUXCAPSA;
typedef AUXCAPSW      *NPAUXCAPSW;



typedef NPAUXCAPSA NPAUXCAPS;
#line 1013 "d:\\msvc20\\include/mmsystem.h"
typedef AUXCAPSA      *LPAUXCAPSA;
typedef AUXCAPSW      *LPAUXCAPSW;



typedef LPAUXCAPSA LPAUXCAPS;
#line 1020 "d:\\msvc20\\include/mmsystem.h"










UINT  auxGetNumDevs(void);
MMRESULT  auxGetDevCapsA(UINT uDeviceID, LPAUXCAPSA lpCaps, UINT cbCaps);
MMRESULT  auxGetDevCapsW(UINT uDeviceID, LPAUXCAPSW lpCaps, UINT cbCaps);




#line 1038 "d:\\msvc20\\include/mmsystem.h"
MMRESULT  auxSetVolume(UINT uDeviceID, DWORD dwVolume);
MMRESULT  auxGetVolume(UINT uDeviceID, LPDWORD lpdwVolume);

MMRESULT  auxOutMessage(UINT uDeviceID, UINT uMsg, DWORD dw1, DWORD dw2);

#line 1044 "d:\\msvc20\\include/mmsystem.h"










typedef HANDLE HMIXEROBJ;
typedef HMIXEROBJ      *LPHMIXEROBJ;

typedef HANDLE HMIXER;
typedef HMIXER         *LPHMIXER;



























UINT  mixerGetNumDevs(void);

typedef struct tMIXERCAPSA
{
    WORD            wMid;                   
    WORD            wPid;                   
    MMVERSION       vDriverVersion;         
    CHAR            szPname[32];   
    DWORD           fdwSupport;             
    DWORD           cDestinations;          
} MIXERCAPSA;
typedef struct tMIXERCAPSW
{
    WORD            wMid;                   
    WORD            wPid;                   
    MMVERSION       vDriverVersion;         
    WCHAR           szPname[32];   
    DWORD           fdwSupport;             
    DWORD           cDestinations;          
} MIXERCAPSW;



typedef MIXERCAPSA MIXERCAPS;
#line 1111 "d:\\msvc20\\include/mmsystem.h"
typedef MIXERCAPSA *PMIXERCAPSA;
typedef MIXERCAPSW *PMIXERCAPSW;



typedef PMIXERCAPSA PMIXERCAPS;
#line 1118 "d:\\msvc20\\include/mmsystem.h"
typedef MIXERCAPSA     *LPMIXERCAPSA;
typedef MIXERCAPSW     *LPMIXERCAPSW;



typedef LPMIXERCAPSA LPMIXERCAPS;
#line 1125 "d:\\msvc20\\include/mmsystem.h"



MMRESULT  mixerGetDevCapsA(UINT uMxId, LPMIXERCAPSA pmxcaps, UINT cbmxcaps);
MMRESULT  mixerGetDevCapsW(UINT uMxId, LPMIXERCAPSW pmxcaps, UINT cbmxcaps);




#line 1135 "d:\\msvc20\\include/mmsystem.h"
MMRESULT  mixerGetID(HMIXEROBJ hmxobj, UINT     *puMxId, DWORD fdwId);


MMRESULT  mixerOpen(LPHMIXER phmx, UINT uMxId, DWORD dwCallback, DWORD dwInstance, DWORD fdwOpen);


MMRESULT  mixerClose(HMIXER hmx);

DWORD  mixerMessage(HMIXER hmx, UINT uMsg, DWORD dwParam1, DWORD dwParam2);

typedef struct tMIXERLINEA
{
    DWORD       cbStruct;               
    DWORD       dwDestination;          
    DWORD       dwSource;               
    DWORD       dwLineID;               
    DWORD       fdwLine;                
    DWORD       dwUser;                 
    DWORD       dwComponentType;        
    DWORD       cChannels;              
    DWORD       cConnections;           
    DWORD       cControls;              
    CHAR        szShortName[16];
    CHAR        szName[64];
    struct
    {
        DWORD   dwType;                 
        DWORD   dwDeviceID;             
        WORD    wMid;                   
        WORD    wPid;                   
        MMVERSION  vDriverVersion;      
        CHAR    szPname[32];   
    } Target;
} MIXERLINEA;
typedef struct tMIXERLINEW
{
    DWORD       cbStruct;               
    DWORD       dwDestination;          
    DWORD       dwSource;               
    DWORD       dwLineID;               
    DWORD       fdwLine;                
    DWORD       dwUser;                 
    DWORD       dwComponentType;        
    DWORD       cChannels;              
    DWORD       cConnections;           
    DWORD       cControls;              
    WCHAR       szShortName[16];
    WCHAR       szName[64];
    struct
    {
        DWORD   dwType;                 
        DWORD   dwDeviceID;             
        WORD    wMid;                   
        WORD    wPid;                   
        MMVERSION  vDriverVersion;      
        WCHAR   szPname[32];   
    } Target;
} MIXERLINEW;



typedef MIXERLINEA MIXERLINE;
#line 1198 "d:\\msvc20\\include/mmsystem.h"
typedef MIXERLINEA *PMIXERLINEA;
typedef MIXERLINEW *PMIXERLINEW;



typedef PMIXERLINEA PMIXERLINE;
#line 1205 "d:\\msvc20\\include/mmsystem.h"
typedef MIXERLINEA     *LPMIXERLINEA;
typedef MIXERLINEW     *LPMIXERLINEW;



typedef LPMIXERLINEA LPMIXERLINE;
#line 1212 "d:\\msvc20\\include/mmsystem.h"



















































MMRESULT  mixerGetLineInfoA (HMIXEROBJ hmxobj, LPMIXERLINEA pmxl, DWORD fdwInfo);
MMRESULT  mixerGetLineInfoW (HMIXEROBJ hmxobj, LPMIXERLINEW pmxl, DWORD fdwInfo);




#line 1270 "d:\\msvc20\\include/mmsystem.h"











typedef struct tMIXERCONTROLA
{
    DWORD           cbStruct;           
    DWORD           dwControlID;        
    DWORD           dwControlType;      
    DWORD           fdwControl;         
    DWORD           cMultipleItems;     
    CHAR            szShortName[16];
    CHAR            szName[64];
    union
    {
        struct
        {
            LONG    lMinimum;           
            LONG    lMaximum;           
        };
        struct
        {
            DWORD   dwMinimum;          
            DWORD   dwMaximum;          
        };
        DWORD       dwReserved[6];
    } Bounds;
    union
    {
        DWORD       cSteps;             
        DWORD       cbCustomData;       
        DWORD       dwReserved[6];      
    } Metrics;
} MIXERCONTROLA;
typedef struct tMIXERCONTROLW
{
    DWORD           cbStruct;           
    DWORD           dwControlID;        
    DWORD           dwControlType;      
    DWORD           fdwControl;         
    DWORD           cMultipleItems;     
    WCHAR           szShortName[16];
    WCHAR           szName[64];
    union
    {
        struct
        {
            LONG    lMinimum;           
            LONG    lMaximum;           
        };
        struct
        {
            DWORD   dwMinimum;          
            DWORD   dwMaximum;          
        };
        DWORD       dwReserved[6];
    } Bounds;
    union
    {
        DWORD       cSteps;             
        DWORD       cbCustomData;       
        DWORD       dwReserved[6];      
    } Metrics;
} MIXERCONTROLW;



typedef MIXERCONTROLA MIXERCONTROL;
#line 1346 "d:\\msvc20\\include/mmsystem.h"
typedef MIXERCONTROLA *PMIXERCONTROLA;
typedef MIXERCONTROLW *PMIXERCONTROLW;



typedef PMIXERCONTROLA PMIXERCONTROL;
#line 1353 "d:\\msvc20\\include/mmsystem.h"
typedef MIXERCONTROLA     *LPMIXERCONTROLA;
typedef MIXERCONTROLW     *LPMIXERCONTROLW;



typedef LPMIXERCONTROLA LPMIXERCONTROL;
#line 1360 "d:\\msvc20\\include/mmsystem.h"











































































typedef struct tMIXERLINECONTROLSA
{
    DWORD           cbStruct;       
    DWORD           dwLineID;       
    union
    {
        DWORD       dwControlID;    
        DWORD       dwControlType;  
    };
    DWORD           cControls;      
    DWORD           cbmxctrl;       
    LPMIXERCONTROLA pamxctrl;       
} MIXERLINECONTROLSA;





typedef struct tMIXERLINECONTROLSW
{
    DWORD           cbStruct;       
    DWORD           dwLineID;       
    union
    {
        DWORD       dwControlID;    
        DWORD       dwControlType;  
    };
    DWORD           cControls;      
    DWORD           cbmxctrl;       
    LPMIXERCONTROLW pamxctrl;       
} MIXERLINECONTROLSW;



typedef MIXERLINECONTROLSA MIXERLINECONTROLS;
#line 1471 "d:\\msvc20\\include/mmsystem.h"
typedef MIXERLINECONTROLSA *PMIXERLINECONTROLSA;
typedef MIXERLINECONTROLSW *PMIXERLINECONTROLSW;



typedef PMIXERLINECONTROLSA PMIXERLINECONTROLS;
#line 1478 "d:\\msvc20\\include/mmsystem.h"
typedef MIXERLINECONTROLSA     *LPMIXERLINECONTROLSA;
typedef MIXERLINECONTROLSW     *LPMIXERLINECONTROLSW;



typedef LPMIXERLINECONTROLSA LPMIXERLINECONTROLS;
#line 1485 "d:\\msvc20\\include/mmsystem.h"


MMRESULT  mixerGetLineControlsA(HMIXEROBJ hmxobj, LPMIXERLINECONTROLSA pmxlc, DWORD fdwControls);
MMRESULT  mixerGetLineControlsW(HMIXEROBJ hmxobj, LPMIXERLINECONTROLSW pmxlc, DWORD fdwControls);




#line 1494 "d:\\msvc20\\include/mmsystem.h"










typedef struct tMIXERCONTROLDETAILS
{
    DWORD           cbStruct;       
    DWORD           dwControlID;    

    DWORD           cChannels;      

    union
    {
        HWND        hwndOwner;      
        DWORD       cMultipleItems; 
    };

    DWORD           cbDetails;      
    LPVOID          paDetails;      

} MIXERCONTROLDETAILS, *PMIXERCONTROLDETAILS,     *LPMIXERCONTROLDETAILS;






typedef struct tMIXERCONTROLDETAILS_LISTTEXTA
{
    DWORD           dwParam1;
    DWORD           dwParam2;
    CHAR            szName[64];
}       MIXERCONTROLDETAILS_LISTTEXTA;




typedef struct tMIXERCONTROLDETAILS_LISTTEXTW
{
    DWORD           dwParam1;
    DWORD           dwParam2;
    WCHAR           szName[64];
}       MIXERCONTROLDETAILS_LISTTEXTW;



typedef MIXERCONTROLDETAILS_LISTTEXTA MIXERCONTROLDETAILS_LISTTEXT;
#line 1548 "d:\\msvc20\\include/mmsystem.h"
typedef MIXERCONTROLDETAILS_LISTTEXTA *PMIXERCONTROLDETAILS_LISTTEXTA;
typedef MIXERCONTROLDETAILS_LISTTEXTW *PMIXERCONTROLDETAILS_LISTTEXTW;



typedef PMIXERCONTROLDETAILS_LISTTEXTA PMIXERCONTROLDETAILS_LISTTEXT;
#line 1555 "d:\\msvc20\\include/mmsystem.h"
typedef MIXERCONTROLDETAILS_LISTTEXTA     *LPMIXERCONTROLDETAILS_LISTTEXTA;
typedef MIXERCONTROLDETAILS_LISTTEXTW     *LPMIXERCONTROLDETAILS_LISTTEXTW;



typedef LPMIXERCONTROLDETAILS_LISTTEXTA LPMIXERCONTROLDETAILS_LISTTEXT;
#line 1562 "d:\\msvc20\\include/mmsystem.h"






typedef struct tMIXERCONTROLDETAILS_BOOLEAN
{
    LONG            fValue;
}       MIXERCONTROLDETAILS_BOOLEAN,
      *PMIXERCONTROLDETAILS_BOOLEAN,
     *LPMIXERCONTROLDETAILS_BOOLEAN;

typedef struct tMIXERCONTROLDETAILS_SIGNED
{
    LONG            lValue;
}       MIXERCONTROLDETAILS_SIGNED,
      *PMIXERCONTROLDETAILS_SIGNED,
     *LPMIXERCONTROLDETAILS_SIGNED;


typedef struct tMIXERCONTROLDETAILS_UNSIGNED
{
    DWORD           dwValue;
}       MIXERCONTROLDETAILS_UNSIGNED,
      *PMIXERCONTROLDETAILS_UNSIGNED,
     *LPMIXERCONTROLDETAILS_UNSIGNED;


MMRESULT  mixerGetControlDetailsA(HMIXEROBJ hmxobj, LPMIXERCONTROLDETAILS pmxcd, DWORD fdwDetails);
MMRESULT  mixerGetControlDetailsW(HMIXEROBJ hmxobj, LPMIXERCONTROLDETAILS pmxcd, DWORD fdwDetails);




#line 1598 "d:\\msvc20\\include/mmsystem.h"







MMRESULT  mixerSetControlDetails(HMIXEROBJ hmxobj, LPMIXERCONTROLDETAILS pmxcd, DWORD fdwDetails);






#line 1613 "d:\\msvc20\\include/mmsystem.h"
















typedef void ( TIMECALLBACK)(UINT uTimerID, UINT uMsg, DWORD dwUser, DWORD dw1, DWORD dw2);
typedef TIMECALLBACK     *LPTIMECALLBACK;











typedef struct timecaps_tag {
    UINT    wPeriodMin;     
    UINT    wPeriodMax;     
} TIMECAPS;
typedef TIMECAPS       *PTIMECAPS;
typedef TIMECAPS      *NPTIMECAPS;
typedef TIMECAPS      *LPTIMECAPS;


MMRESULT  timeGetSystemTime(LPMMTIME lpmmt, UINT cbmmt);
DWORD  timeGetTime(void);
UINT  timeSetEvent(UINT uDelay, UINT uResolution,
    LPTIMECALLBACK lpFunction, DWORD dwUser, UINT uFlags);
MMRESULT  timeKillEvent(UINT uTimerID);
MMRESULT  timeGetDevCaps(LPTIMECAPS lptc, UINT cbtc);
MMRESULT  timeBeginPeriod(UINT uPeriod);
MMRESULT  timeEndPeriod(UINT uPeriod);

#line 1661 "d:\\msvc20\\include/mmsystem.h"






























typedef struct tagJOYCAPSA {
    WORD    wMid;                  
    WORD    wPid;                  
    CHAR    szPname[32];  
    UINT    wXmin;                 
    UINT    wXmax;                 
    UINT    wYmin;                 
    UINT    wYmax;                 
    UINT    wZmin;                 
    UINT    wZmax;                 
    UINT    wNumButtons;           
    UINT    wPeriodMin;            
    UINT    wPeriodMax;            
} JOYCAPSA;

typedef struct tagJOYCAPSW {
    WORD    wMid;                  
    WORD    wPid;                  
    WCHAR   szPname[32];  
    UINT    wXmin;                 
    UINT    wXmax;                 
    UINT    wYmin;                 
    UINT    wYmax;                 
    UINT    wZmin;                 
    UINT    wZmax;                 
    UINT    wNumButtons;           
    UINT    wPeriodMin;            
    UINT    wPeriodMax;            
} JOYCAPSW;



typedef JOYCAPSA JOYCAPS;
#line 1725 "d:\\msvc20\\include/mmsystem.h"
typedef JOYCAPSA      *PJOYCAPSA;
typedef JOYCAPSW      *PJOYCAPSW;



typedef PJOYCAPSA PJOYCAPS;
#line 1732 "d:\\msvc20\\include/mmsystem.h"
typedef JOYCAPSA      *NPJOYCAPSA;
typedef JOYCAPSW      *NPJOYCAPSW;



typedef NPJOYCAPSA NPJOYCAPS;
#line 1739 "d:\\msvc20\\include/mmsystem.h"
typedef JOYCAPSA      *LPJOYCAPSA;
typedef JOYCAPSW      *LPJOYCAPSW;



typedef LPJOYCAPSA LPJOYCAPS;
#line 1746 "d:\\msvc20\\include/mmsystem.h"


typedef struct joyinfo_tag {
    UINT wXpos;                 
    UINT wYpos;                 
    UINT wZpos;                 
    UINT wButtons;              
} JOYINFO;
typedef JOYINFO       *PJOYINFO;
typedef JOYINFO      *NPJOYINFO;
typedef JOYINFO      *LPJOYINFO;


UINT      joyGetNumDevs(void);
MMRESULT  joyGetDevCapsA(UINT uJoyId, LPJOYCAPSA lpjc, UINT cbjc);
MMRESULT  joyGetDevCapsW(UINT uJoyId, LPJOYCAPSW lpjc, UINT cbjc);




#line 1767 "d:\\msvc20\\include/mmsystem.h"
MMRESULT  joyGetPos(UINT uJoyID, LPJOYINFO lpji);
MMRESULT  joyGetThreshold(UINT uJoyID, LPUINT lpuThreshold);
MMRESULT  joyReleaseCapture(UINT uJoyID);
MMRESULT  joySetCapture(HWND hwnd, UINT uJoyID, UINT uPeriod,
    BOOL fChanged);
MMRESULT  joySetThreshold(UINT uJoyID, UINT uThreshold);


#line 1776 "d:\\msvc20\\include/mmsystem.h"































typedef DWORD           FOURCC;         
typedef LPSTR           HPSTR;          
typedef LPCSTR          HPCSTR;         
typedef HANDLE          HMMIO;          
typedef LRESULT ( MMIOPROC)(LPSTR lpmmioinfo, UINT uMsg,
            LPARAM lParam1, LPARAM lParam2);
typedef MMIOPROC     *LPMMIOPROC;


typedef struct _MMIOINFO        
{
        
        DWORD           dwFlags;        
        FOURCC          fccIOProc;      
        LPMMIOPROC      pIOProc;        
        UINT            wErrorRet;      
        HTASK           htask;          

        
        LONG            cchBuffer;      
        HPSTR           pchBuffer;      
        HPSTR           pchNext;        
        HPSTR           pchEndRead;     
        HPSTR           pchEndWrite;    
        LONG            lBufOffset;     

        
        LONG            lDiskOffset;    
        DWORD           adwInfo[3];     

        
        DWORD           dwReserved1;    
        DWORD           dwReserved2;    
        HMMIO           hmmio;          

} MMIOINFO;
typedef MMIOINFO       *PMMIOINFO;
typedef MMIOINFO      *NPMMIOINFO;
typedef MMIOINFO      *LPMMIOINFO;
typedef const MMIOINFO *LPCMMIOINFO;


typedef struct MMCKINFO_tag      
{
        FOURCC          ckid;           
        DWORD           cksize;         
        FOURCC          fccType;        
        DWORD           dwDataOffset;   
        DWORD           dwFlags;        
} MMCKINFO;
typedef MMCKINFO       *PMMCKINFO;
typedef MMCKINFO      *NPMMCKINFO;
typedef MMCKINFO      *LPMMCKINFO;
typedef const MMCKINFO *LPCMMCKINFO;






                                        



































































#line 1936 "d:\\msvc20\\include/mmsystem.h"













FOURCC  mmioStringToFOURCCA(LPCSTR sz, UINT uFlags);

FOURCC  mmioStringToFOURCCW(LPCWSTR sz, UINT uFlags);




#line 1957 "d:\\msvc20\\include/mmsystem.h"

LPMMIOPROC  mmioInstallIOProcA( FOURCC fccIOProc, LPMMIOPROC pIOProc,
                                        DWORD dwFlags);
LPMMIOPROC  mmioInstallIOProcW( FOURCC fccIOProc, LPMMIOPROC pIOProc,
                                        DWORD dwFlags);




#line 1967 "d:\\msvc20\\include/mmsystem.h"

HMMIO  mmioOpenA( LPSTR szFileName, LPMMIOINFO lpmmioinfo, DWORD fdwOpen);
HMMIO  mmioOpenW( LPWSTR szFileName, LPMMIOINFO lpmmioinfo, DWORD fdwOpen);




#line 1975 "d:\\msvc20\\include/mmsystem.h"

MMRESULT  mmioRenameA ( LPCSTR szFileName, LPCSTR szNewFileName,
                               LPCMMIOINFO lpmmioinfo, DWORD fdwRename);
MMRESULT  mmioRenameW ( LPCWSTR szFileName, LPCWSTR szNewFileName,
                               LPCMMIOINFO lpmmioinfo, DWORD fdwRename);




#line 1985 "d:\\msvc20\\include/mmsystem.h"

MMRESULT  mmioClose(HMMIO hmmio, UINT fuClose);
LRESULT  mmioRead(HMMIO hmmio, HPSTR pch, LONG cch);
LRESULT  mmioWrite(HMMIO hmmio, HPCSTR pch, LONG cch);
LRESULT  mmioSeek(HMMIO hmmio, LONG lOffset, int iOrigin);
MMRESULT  mmioGetInfo(HMMIO hmmio, LPMMIOINFO lpmmioinfo, UINT fuInfo);
MMRESULT  mmioSetInfo(HMMIO hmmio, LPCMMIOINFO lpmmioinfo, UINT fuInfo);
MMRESULT  mmioSetBuffer( HMMIO hmmio, LPSTR pchBuffer, LONG cchBuffer,
    UINT fuBuffer);
MMRESULT  mmioFlush(HMMIO hmmio, UINT fuFlush);
MMRESULT  mmioAdvance(HMMIO hmmio, LPMMIOINFO lpmmioinfo, UINT fuAdvance);

LRESULT  mmioSendMessage( HMMIO hmmio, UINT uMsg,
    LPARAM lParam1, LPARAM lParam2);

MMRESULT  mmioDescend(HMMIO hmmio, LPMMCKINFO lpmmcki,
    LPCMMCKINFO lpmmckiParent, UINT fuDescend);
MMRESULT  mmioAscend(HMMIO hmmio, LPMMCKINFO lpmmcki, UINT fuAscend);
MMRESULT  mmioCreateChunk(HMMIO hmmio, LPMMCKINFO lpmmcki, UINT fuCreate);

#line 2006 "d:\\msvc20\\include/mmsystem.h"











typedef DWORD   MCIERROR;       
#line 2019 "d:\\msvc20\\include/mmsystem.h"



typedef UINT    MCIDEVICEID;    


#line 2026 "d:\\msvc20\\include/mmsystem.h"


typedef UINT ( *YIELDPROC)(MCIDEVICEID mciId, DWORD dwYieldData);





MCIERROR  mciSendCommandA(
    MCIDEVICEID mciId,
    UINT uMessage,
    DWORD dwParam1,
    DWORD dwParam2 );
MCIERROR  mciSendCommandW(
    MCIDEVICEID mciId,
    UINT uMessage,
    DWORD dwParam1,
    DWORD dwParam2 );




#line 2049 "d:\\msvc20\\include/mmsystem.h"

MCIERROR  mciSendStringA(
    LPCSTR lpstrCommand,
    LPSTR lpstrReturnString,
    UINT uReturnLength,
    HWND hwndCallback );
MCIERROR  mciSendStringW(
    LPCWSTR lpstrCommand,
    LPWSTR lpstrReturnString,
    UINT uReturnLength,
    HWND hwndCallback );




#line 2065 "d:\\msvc20\\include/mmsystem.h"

MCIDEVICEID  mciGetDeviceIDA( LPCSTR lpstrName );
MCIDEVICEID  mciGetDeviceIDW( LPCWSTR lpstrName );




#line 2073 "d:\\msvc20\\include/mmsystem.h"

MCIDEVICEID  mciGetDeviceIDFromElementIDA(
    DWORD dwElementID,
    LPCSTR lpstrType );
MCIDEVICEID  mciGetDeviceIDFromElementIDW(
    DWORD dwElementID,
    LPCWSTR lpstrType );




#line 2085 "d:\\msvc20\\include/mmsystem.h"

BOOL  mciGetErrorStringA(
    MCIERROR mcierr,
    LPSTR lpstrBuffer,
    UINT cchText );
BOOL  mciGetErrorStringW(
    MCIERROR mcierr,
    LPWSTR lpstrBuffer,
    UINT cchText );




#line 2099 "d:\\msvc20\\include/mmsystem.h"

BOOL  mciSetYieldProc(MCIDEVICEID mciId, YIELDPROC fpYieldProc,
    DWORD dwYieldData);

HANDLE  mciGetCreatorTask(MCIDEVICEID mciId);
YIELDPROC  mciGetYieldProc(MCIDEVICEID mciId, LPDWORD pdwYieldData);






















































































































































































































































































































































typedef struct tagMCI_GENERIC_PARMS {
    DWORD   dwCallback;
} MCI_GENERIC_PARMS;
typedef MCI_GENERIC_PARMS     *PMCI_GENERIC_PARMS;
typedef MCI_GENERIC_PARMS     *LPMCI_GENERIC_PARMS;


typedef struct tagMCI_OPEN_PARMSA {
    DWORD   dwCallback;
    MCIDEVICEID wDeviceID;
    LPCSTR     lpstrDeviceType;
    LPCSTR     lpstrElementName;
    LPCSTR     lpstrAlias;
} MCI_OPEN_PARMSA;

typedef struct tagMCI_OPEN_PARMSW {
    DWORD   dwCallback;
    MCIDEVICEID wDeviceID;
    LPCWSTR    lpstrDeviceType;
    LPCWSTR    lpstrElementName;
    LPCWSTR    lpstrAlias;
} MCI_OPEN_PARMSW;



typedef MCI_OPEN_PARMSA MCI_OPEN_PARMS;
#line 2474 "d:\\msvc20\\include/mmsystem.h"
typedef MCI_OPEN_PARMSA     *PMCI_OPEN_PARMSA;
typedef MCI_OPEN_PARMSW     *PMCI_OPEN_PARMSW;



typedef PMCI_OPEN_PARMSA PMCI_OPEN_PARMS;
#line 2481 "d:\\msvc20\\include/mmsystem.h"
typedef MCI_OPEN_PARMSA     *LPMCI_OPEN_PARMSA;
typedef MCI_OPEN_PARMSW     *LPMCI_OPEN_PARMSW;



typedef LPMCI_OPEN_PARMSA LPMCI_OPEN_PARMS;
#line 2488 "d:\\msvc20\\include/mmsystem.h"


typedef struct tagMCI_PLAY_PARMS {
    DWORD   dwCallback;
    DWORD   dwFrom;
    DWORD   dwTo;
} MCI_PLAY_PARMS;
typedef MCI_PLAY_PARMS     *PMCI_PLAY_PARMS;
typedef MCI_PLAY_PARMS     *LPMCI_PLAY_PARMS;


typedef struct tagMCI_SEEK_PARMS {
    DWORD   dwCallback;
    DWORD   dwTo;
} MCI_SEEK_PARMS;
typedef MCI_SEEK_PARMS     *PMCI_SEEK_PARMS;
typedef MCI_SEEK_PARMS     *LPMCI_SEEK_PARMS;


typedef struct tagMCI_STATUS_PARMS {
    DWORD   dwCallback;
    DWORD   dwReturn;
    DWORD   dwItem;
    DWORD   dwTrack;
} MCI_STATUS_PARMS;
typedef MCI_STATUS_PARMS     * PMCI_STATUS_PARMS;
typedef MCI_STATUS_PARMS     * LPMCI_STATUS_PARMS;


typedef struct tagMCI_INFO_PARMSA {
    DWORD   dwCallback;
    LPSTR   lpstrReturn;
    DWORD   dwRetSize;
} MCI_INFO_PARMSA;

typedef struct tagMCI_INFO_PARMSW {
    DWORD   dwCallback;
    LPWSTR  lpstrReturn;
    DWORD   dwRetSize;
} MCI_INFO_PARMSW;



typedef MCI_INFO_PARMSA MCI_INFO_PARMS;
#line 2533 "d:\\msvc20\\include/mmsystem.h"
typedef MCI_INFO_PARMSA     * PMCI_INFO_PARMSA;
typedef MCI_INFO_PARMSW     * PMCI_INFO_PARMSW;



typedef PMCI_INFO_PARMSA PMCI_INFO_PARMS;
#line 2540 "d:\\msvc20\\include/mmsystem.h"
typedef MCI_INFO_PARMSA     * LPMCI_INFO_PARMSA;
typedef MCI_INFO_PARMSW     * LPMCI_INFO_PARMSW;



typedef LPMCI_INFO_PARMSA LPMCI_INFO_PARMS;
#line 2547 "d:\\msvc20\\include/mmsystem.h"


typedef struct tagMCI_GETDEVCAPS_PARMS {
    DWORD   dwCallback;
    DWORD   dwReturn;
    DWORD   dwItem;
} MCI_GETDEVCAPS_PARMS;
typedef MCI_GETDEVCAPS_PARMS     * PMCI_GETDEVCAPS_PARMS;
typedef MCI_GETDEVCAPS_PARMS     * LPMCI_GETDEVCAPS_PARMS;


typedef struct tagMCI_SYSINFO_PARMSA {
    DWORD   dwCallback;
    LPSTR   lpstrReturn;
    DWORD   dwRetSize;
    DWORD   dwNumber;
    UINT    wDeviceType;
} MCI_SYSINFO_PARMSA;

typedef struct tagMCI_SYSINFO_PARMSW {
    DWORD   dwCallback;
    LPWSTR  lpstrReturn;
    DWORD   dwRetSize;
    DWORD   dwNumber;
    UINT    wDeviceType;
} MCI_SYSINFO_PARMSW;



typedef MCI_SYSINFO_PARMSA MCI_SYSINFO_PARMS;
#line 2578 "d:\\msvc20\\include/mmsystem.h"
typedef MCI_SYSINFO_PARMSA     *PMCI_SYSINFO_PARMSA;
typedef MCI_SYSINFO_PARMSW     *PMCI_SYSINFO_PARMSW;



typedef PMCI_SYSINFO_PARMSA PMCI_SYSINFO_PARMS;
#line 2585 "d:\\msvc20\\include/mmsystem.h"
typedef MCI_SYSINFO_PARMSA     *LPMCI_SYSINFO_PARMSA;
typedef MCI_SYSINFO_PARMSW     *LPMCI_SYSINFO_PARMSW;



typedef LPMCI_SYSINFO_PARMSA LPMCI_SYSINFO_PARMS;
#line 2592 "d:\\msvc20\\include/mmsystem.h"


typedef struct tagMCI_SET_PARMS {
    DWORD   dwCallback;
    DWORD   dwTimeFormat;
    DWORD   dwAudio;
} MCI_SET_PARMS;
typedef MCI_SET_PARMS     *PMCI_SET_PARMS;
typedef MCI_SET_PARMS     *LPMCI_SET_PARMS;


typedef struct tagMCI_BREAK_PARMS {
    DWORD   dwCallback;
    int     nVirtKey;
    HWND    hwndBreak;
} MCI_BREAK_PARMS;
typedef MCI_BREAK_PARMS     * PMCI_BREAK_PARMS;
typedef MCI_BREAK_PARMS     * LPMCI_BREAK_PARMS;


typedef struct tagMCI_SOUND_PARMSA {
    DWORD   dwCallback;
    LPCSTR   lpstrSoundName;
} MCI_SOUND_PARMSA;

typedef struct tagMCI_SOUND_PARMSW {
    DWORD   dwCallback;
    LPCWSTR  lpstrSoundName;
} MCI_SOUND_PARMSW;



typedef MCI_SOUND_PARMSA MCI_SOUND_PARMS;
#line 2626 "d:\\msvc20\\include/mmsystem.h"
typedef MCI_SOUND_PARMSA     *PMCI_SOUND_PARMSA;
typedef MCI_SOUND_PARMSW     *PMCI_SOUND_PARMSW;



typedef PMCI_SOUND_PARMSA PMCI_SOUND_PARMS;
#line 2633 "d:\\msvc20\\include/mmsystem.h"
typedef MCI_SOUND_PARMSA     *LPMCI_SOUND_PARMSA;
typedef MCI_SOUND_PARMSW     *LPMCI_SOUND_PARMSW;



typedef LPMCI_SOUND_PARMSA LPMCI_SOUND_PARMS;
#line 2640 "d:\\msvc20\\include/mmsystem.h"


typedef struct tagMCI_SAVE_PARMSA {
    DWORD    dwCallback;
    LPCSTR    lpfilename;
} MCI_SAVE_PARMSA;

typedef struct tagMCI_SAVE_PARMSW {
    DWORD    dwCallback;
    LPCWSTR   lpfilename;
} MCI_SAVE_PARMSW;



typedef MCI_SAVE_PARMSA MCI_SAVE_PARMS;
#line 2656 "d:\\msvc20\\include/mmsystem.h"
typedef MCI_SAVE_PARMSA     *PMCI_SAVE_PARMSA;
typedef MCI_SAVE_PARMSW     *PMCI_SAVE_PARMSW;



typedef PMCI_SAVE_PARMSA PMCI_SAVE_PARMS;
#line 2663 "d:\\msvc20\\include/mmsystem.h"
typedef MCI_SAVE_PARMSA     *LPMCI_SAVE_PARMSA;
typedef MCI_SAVE_PARMSW     *LPMCI_SAVE_PARMSW;



typedef LPMCI_SAVE_PARMSA LPMCI_SAVE_PARMS;
#line 2670 "d:\\msvc20\\include/mmsystem.h"


typedef struct tagMCI_LOAD_PARMSA {
    DWORD   dwCallback;
    LPCSTR   lpfilename;
} MCI_LOAD_PARMSA;

typedef struct tagMCI_LOAD_PARMSW {
    DWORD   dwCallback;
    LPCWSTR  lpfilename;
} MCI_LOAD_PARMSW;



typedef MCI_LOAD_PARMSA MCI_LOAD_PARMS;
#line 2686 "d:\\msvc20\\include/mmsystem.h"
typedef MCI_LOAD_PARMSA     *PMCI_LOAD_PARMSA;
typedef MCI_LOAD_PARMSW     *PMCI_LOAD_PARMSW;



typedef PMCI_LOAD_PARMSA PMCI_LOAD_PARMS;
#line 2693 "d:\\msvc20\\include/mmsystem.h"
typedef MCI_LOAD_PARMSA     *LPMCI_LOAD_PARMSA;
typedef MCI_LOAD_PARMSW     *LPMCI_LOAD_PARMSW;



typedef LPMCI_LOAD_PARMSA LPMCI_LOAD_PARMS;
#line 2700 "d:\\msvc20\\include/mmsystem.h"


typedef struct tagMCI_RECORD_PARMS {
    DWORD   dwCallback;
    DWORD   dwFrom;
    DWORD   dwTo;
} MCI_RECORD_PARMS;

typedef MCI_RECORD_PARMS     *PMCI_RECORD_PARMS;
typedef MCI_RECORD_PARMS     *LPMCI_RECORD_PARMS;


























































typedef struct tagMCI_VD_PLAY_PARMS {
    DWORD   dwCallback;
    DWORD   dwFrom;
    DWORD   dwTo;
    DWORD   dwSpeed;
} MCI_VD_PLAY_PARMS;
typedef MCI_VD_PLAY_PARMS     *PMCI_VD_PLAY_PARMS;
typedef MCI_VD_PLAY_PARMS     *LPMCI_VD_PLAY_PARMS;


typedef struct tagMCI_VD_STEP_PARMS {
    DWORD   dwCallback;
    DWORD   dwFrames;
} MCI_VD_STEP_PARMS;
typedef MCI_VD_STEP_PARMS     *PMCI_VD_STEP_PARMS;
typedef MCI_VD_STEP_PARMS     *LPMCI_VD_STEP_PARMS;


typedef struct tagMCI_VD_ESCAPE_PARMSA {
    DWORD   dwCallback;
    LPCSTR    lpstrCommand;
} MCI_VD_ESCAPE_PARMSA;

typedef struct tagMCI_VD_ESCAPE_PARMSW {
    DWORD   dwCallback;
    LPCWSTR   lpstrCommand;
} MCI_VD_ESCAPE_PARMSW;



typedef MCI_VD_ESCAPE_PARMSA MCI_VD_ESCAPE_PARMS;
#line 2800 "d:\\msvc20\\include/mmsystem.h"
typedef MCI_VD_ESCAPE_PARMSA     *PMCI_VD_ESCAPE_PARMSA;
typedef MCI_VD_ESCAPE_PARMSW     *PMCI_VD_ESCAPE_PARMSW;



typedef PMCI_VD_ESCAPE_PARMSA PMCI_VD_ESCAPE_PARMS;
#line 2807 "d:\\msvc20\\include/mmsystem.h"
typedef MCI_VD_ESCAPE_PARMSA     *LPMCI_VD_ESCAPE_PARMSA;
typedef MCI_VD_ESCAPE_PARMSW     *LPMCI_VD_ESCAPE_PARMSW;



typedef LPMCI_VD_ESCAPE_PARMSA LPMCI_VD_ESCAPE_PARMS;
#line 2814 "d:\\msvc20\\include/mmsystem.h"











































typedef struct tagMCI_WAVE_OPEN_PARMSA {
    DWORD   dwCallback;
    MCIDEVICEID wDeviceID;
    LPCSTR    lpstrDeviceType;
    LPCSTR    lpstrElementName;
    LPCSTR    lpstrAlias;
    DWORD   dwBufferSeconds;
} MCI_WAVE_OPEN_PARMSA;

typedef struct tagMCI_WAVE_OPEN_PARMSW {
    DWORD   dwCallback;
    MCIDEVICEID wDeviceID;
    LPCWSTR   lpstrDeviceType;
    LPCWSTR   lpstrElementName;
    LPCWSTR   lpstrAlias;
    DWORD   dwBufferSeconds;
} MCI_WAVE_OPEN_PARMSW;



typedef MCI_WAVE_OPEN_PARMSA MCI_WAVE_OPEN_PARMS;
#line 2879 "d:\\msvc20\\include/mmsystem.h"
typedef MCI_WAVE_OPEN_PARMSA     *PMCI_WAVE_OPEN_PARMSA;
typedef MCI_WAVE_OPEN_PARMSW     *PMCI_WAVE_OPEN_PARMSW;



typedef PMCI_WAVE_OPEN_PARMSA PMCI_WAVE_OPEN_PARMS;
#line 2886 "d:\\msvc20\\include/mmsystem.h"
typedef MCI_WAVE_OPEN_PARMSA     *LPMCI_WAVE_OPEN_PARMSA;
typedef MCI_WAVE_OPEN_PARMSW     *LPMCI_WAVE_OPEN_PARMSW;



typedef LPMCI_WAVE_OPEN_PARMSA LPMCI_WAVE_OPEN_PARMS;
#line 2893 "d:\\msvc20\\include/mmsystem.h"


typedef struct tagMCI_WAVE_DELETE_PARMS {
    DWORD   dwCallback;
    DWORD   dwFrom;
    DWORD   dwTo;
} MCI_WAVE_DELETE_PARMS;
typedef MCI_WAVE_DELETE_PARMS     *PMCI_WAVE_DELETE_PARMS;
typedef MCI_WAVE_DELETE_PARMS     *LPMCI_WAVE_DELETE_PARMS;


typedef struct tagMCI_WAVE_SET_PARMS {
    DWORD   dwCallback;
    DWORD   dwTimeFormat;
    DWORD   dwAudio;
    UINT    wInput;
    UINT    wOutput;
    WORD    wFormatTag;                
    WORD    wReserved2;
    WORD    nChannels;                 
    WORD    wReserved3;
    DWORD   nSamplesPerSec;
    DWORD   nAvgBytesPerSec;
    WORD    nBlockAlign;               
    WORD    wReserved4;
    WORD    wBitsPerSample;            
    WORD    wReserved5;
} MCI_WAVE_SET_PARMS;
typedef MCI_WAVE_SET_PARMS     * PMCI_WAVE_SET_PARMS;
typedef MCI_WAVE_SET_PARMS     * LPMCI_WAVE_SET_PARMS;























































typedef struct tagMCI_SEQ_SET_PARMS {
    DWORD   dwCallback;
    DWORD   dwTimeFormat;
    DWORD   dwAudio;
    DWORD   dwTempo;
    DWORD   dwPort;
    DWORD   dwSlave;
    DWORD   dwMaster;
    DWORD   dwOffset;
} MCI_SEQ_SET_PARMS;
typedef MCI_SEQ_SET_PARMS     * PMCI_SEQ_SET_PARMS;
typedef MCI_SEQ_SET_PARMS     * LPMCI_SEQ_SET_PARMS;






































































typedef struct tagMCI_ANIM_OPEN_PARMSA {
    DWORD   dwCallback;
    MCIDEVICEID wDeviceID;
    LPCSTR    lpstrDeviceType;
    LPCSTR    lpstrElementName;
    LPCSTR    lpstrAlias;
    DWORD   dwStyle;
    HWND    hWndParent;
} MCI_ANIM_OPEN_PARMSA;

typedef struct tagMCI_ANIM_OPEN_PARMSW {
    DWORD   dwCallback;
    MCIDEVICEID wDeviceID;
    LPCWSTR   lpstrDeviceType;
    LPCWSTR   lpstrElementName;
    LPCWSTR   lpstrAlias;
    DWORD   dwStyle;
    HWND    hWndParent;
} MCI_ANIM_OPEN_PARMSW;



typedef MCI_ANIM_OPEN_PARMSA MCI_ANIM_OPEN_PARMS;
#line 3084 "d:\\msvc20\\include/mmsystem.h"
typedef MCI_ANIM_OPEN_PARMSA     *PMCI_ANIM_OPEN_PARMSA;
typedef MCI_ANIM_OPEN_PARMSW     *PMCI_ANIM_OPEN_PARMSW;



typedef PMCI_ANIM_OPEN_PARMSA PMCI_ANIM_OPEN_PARMS;
#line 3091 "d:\\msvc20\\include/mmsystem.h"
typedef MCI_ANIM_OPEN_PARMSA     *LPMCI_ANIM_OPEN_PARMSA;
typedef MCI_ANIM_OPEN_PARMSW     *LPMCI_ANIM_OPEN_PARMSW;



typedef LPMCI_ANIM_OPEN_PARMSA LPMCI_ANIM_OPEN_PARMS;
#line 3098 "d:\\msvc20\\include/mmsystem.h"


typedef struct tagMCI_ANIM_PLAY_PARMS {
    DWORD   dwCallback;
    DWORD   dwFrom;
    DWORD   dwTo;
    DWORD   dwSpeed;
} MCI_ANIM_PLAY_PARMS;
typedef MCI_ANIM_PLAY_PARMS     *PMCI_ANIM_PLAY_PARMS;
typedef MCI_ANIM_PLAY_PARMS     *LPMCI_ANIM_PLAY_PARMS;


typedef struct tagMCI_ANIM_STEP_PARMS {
    DWORD   dwCallback;
    DWORD   dwFrames;
} MCI_ANIM_STEP_PARMS;
typedef MCI_ANIM_STEP_PARMS     *PMCI_ANIM_STEP_PARMS;
typedef MCI_ANIM_STEP_PARMS     *LPMCI_ANIM_STEP_PARMS;


typedef struct tagMCI_ANIM_WINDOW_PARMSA {
    DWORD   dwCallback;
    HWND    hWnd;
    UINT    nCmdShow;
    LPCSTR   lpstrText;
} MCI_ANIM_WINDOW_PARMSA;

typedef struct tagMCI_ANIM_WINDOW_PARMSW {
    DWORD   dwCallback;
    HWND    hWnd;
    UINT    nCmdShow;
    LPCWSTR  lpstrText;
} MCI_ANIM_WINDOW_PARMSW;



typedef MCI_ANIM_WINDOW_PARMSA MCI_ANIM_WINDOW_PARMS;
#line 3136 "d:\\msvc20\\include/mmsystem.h"
typedef MCI_ANIM_WINDOW_PARMSA     * PMCI_ANIM_WINDOW_PARMSA;
typedef MCI_ANIM_WINDOW_PARMSW     * PMCI_ANIM_WINDOW_PARMSW;



typedef PMCI_ANIM_WINDOW_PARMSA PMCI_ANIM_WINDOW_PARMS;
#line 3143 "d:\\msvc20\\include/mmsystem.h"
typedef MCI_ANIM_WINDOW_PARMSA     * LPMCI_ANIM_WINDOW_PARMSA;
typedef MCI_ANIM_WINDOW_PARMSW     * LPMCI_ANIM_WINDOW_PARMSW;



typedef LPMCI_ANIM_WINDOW_PARMSA LPMCI_ANIM_WINDOW_PARMS;
#line 3150 "d:\\msvc20\\include/mmsystem.h"


typedef struct tagMCI_ANIM_RECT_PARMS {
    DWORD   dwCallback;




    RECT    rc;
#line 3160 "d:\\msvc20\\include/mmsystem.h"
} MCI_ANIM_RECT_PARMS;
typedef MCI_ANIM_RECT_PARMS     * PMCI_ANIM_RECT_PARMS;
typedef MCI_ANIM_RECT_PARMS     * LPMCI_ANIM_RECT_PARMS;


typedef struct tagMCI_ANIM_UPDATE_PARMS {
    DWORD   dwCallback;
    RECT    rc;
    HDC     hDC;
} MCI_ANIM_UPDATE_PARMS;
typedef MCI_ANIM_UPDATE_PARMS     * PMCI_ANIM_UPDATE_PARMS;
typedef MCI_ANIM_UPDATE_PARMS     * LPMCI_ANIM_UPDATE_PARMS;
















































typedef struct tagMCI_OVLY_OPEN_PARMSA {
    DWORD   dwCallback;
    MCIDEVICEID wDeviceID;
    LPCSTR    lpstrDeviceType;
    LPCSTR    lpstrElementName;
    LPCSTR    lpstrAlias;
    DWORD   dwStyle;
    HWND    hWndParent;
 } MCI_OVLY_OPEN_PARMSA;

typedef struct tagMCI_OVLY_OPEN_PARMSW {
    DWORD   dwCallback;
    MCIDEVICEID wDeviceID;
    LPCWSTR   lpstrDeviceType;
    LPCWSTR   lpstrElementName;
    LPCWSTR   lpstrAlias;
    DWORD   dwStyle;
    HWND    hWndParent;
 } MCI_OVLY_OPEN_PARMSW;



typedef MCI_OVLY_OPEN_PARMSA MCI_OVLY_OPEN_PARMS;
#line 3244 "d:\\msvc20\\include/mmsystem.h"
typedef MCI_OVLY_OPEN_PARMSA     *PMCI_OVLY_OPEN_PARMSA;
typedef MCI_OVLY_OPEN_PARMSW     *PMCI_OVLY_OPEN_PARMSW;



typedef PMCI_OVLY_OPEN_PARMSA PMCI_OVLY_OPEN_PARMS;
#line 3251 "d:\\msvc20\\include/mmsystem.h"
typedef MCI_OVLY_OPEN_PARMSA     *LPMCI_OVLY_OPEN_PARMSA;
typedef MCI_OVLY_OPEN_PARMSW     *LPMCI_OVLY_OPEN_PARMSW;



typedef LPMCI_OVLY_OPEN_PARMSA LPMCI_OVLY_OPEN_PARMS;
#line 3258 "d:\\msvc20\\include/mmsystem.h"


typedef struct tagMCI_OVLY_WINDOW_PARMSA {
    DWORD   dwCallback;
    HWND    hWnd;
    UINT    nCmdShow;
    LPCSTR    lpstrText;
} MCI_OVLY_WINDOW_PARMSA;

typedef struct tagMCI_OVLY_WINDOW_PARMSW {
    DWORD   dwCallback;
    HWND    hWnd;
    UINT    nCmdShow;
    LPCWSTR   lpstrText;
} MCI_OVLY_WINDOW_PARMSW;



typedef MCI_OVLY_WINDOW_PARMSA MCI_OVLY_WINDOW_PARMS;
#line 3278 "d:\\msvc20\\include/mmsystem.h"
typedef MCI_OVLY_WINDOW_PARMSA     * PMCI_OVLY_WINDOW_PARMSA;
typedef MCI_OVLY_WINDOW_PARMSW     * PMCI_OVLY_WINDOW_PARMSW;



typedef PMCI_OVLY_WINDOW_PARMSA PMCI_OVLY_WINDOW_PARMS;
#line 3285 "d:\\msvc20\\include/mmsystem.h"
typedef MCI_OVLY_WINDOW_PARMSA     * LPMCI_OVLY_WINDOW_PARMSA;
typedef MCI_OVLY_WINDOW_PARMSW     * LPMCI_OVLY_WINDOW_PARMSW;



typedef LPMCI_OVLY_WINDOW_PARMSA LPMCI_OVLY_WINDOW_PARMS;
#line 3292 "d:\\msvc20\\include/mmsystem.h"


typedef struct tagMCI_OVLY_RECT_PARMS {
    DWORD   dwCallback;




    RECT    rc;
#line 3302 "d:\\msvc20\\include/mmsystem.h"
} MCI_OVLY_RECT_PARMS;
typedef MCI_OVLY_RECT_PARMS     * PMCI_OVLY_RECT_PARMS;
typedef MCI_OVLY_RECT_PARMS     * LPMCI_OVLY_RECT_PARMS;


typedef struct tagMCI_OVLY_SAVE_PARMSA {
    DWORD   dwCallback;
    LPCSTR    lpfilename;
    RECT    rc;
} MCI_OVLY_SAVE_PARMSA;

typedef struct tagMCI_OVLY_SAVE_PARMSW {
    DWORD   dwCallback;
    LPCWSTR   lpfilename;
    RECT    rc;
} MCI_OVLY_SAVE_PARMSW;



typedef MCI_OVLY_SAVE_PARMSA MCI_OVLY_SAVE_PARMS;
#line 3323 "d:\\msvc20\\include/mmsystem.h"
typedef MCI_OVLY_SAVE_PARMSA     * PMCI_OVLY_SAVE_PARMSA;
typedef MCI_OVLY_SAVE_PARMSW     * PMCI_OVLY_SAVE_PARMSW;



typedef PMCI_OVLY_SAVE_PARMSA PMCI_OVLY_SAVE_PARMS;
#line 3330 "d:\\msvc20\\include/mmsystem.h"
typedef MCI_OVLY_SAVE_PARMSA     * LPMCI_OVLY_SAVE_PARMSA;
typedef MCI_OVLY_SAVE_PARMSW     * LPMCI_OVLY_SAVE_PARMSW;



typedef LPMCI_OVLY_SAVE_PARMSA LPMCI_OVLY_SAVE_PARMS;
#line 3337 "d:\\msvc20\\include/mmsystem.h"


typedef struct tagMCI_OVLY_LOAD_PARMSA {
    DWORD   dwCallback;
    LPCSTR    lpfilename;
    RECT    rc;
} MCI_OVLY_LOAD_PARMSA;

typedef struct tagMCI_OVLY_LOAD_PARMSW {
    DWORD   dwCallback;
    LPCWSTR   lpfilename;
    RECT    rc;
} MCI_OVLY_LOAD_PARMSW;



typedef MCI_OVLY_LOAD_PARMSA MCI_OVLY_LOAD_PARMS;
#line 3355 "d:\\msvc20\\include/mmsystem.h"
typedef MCI_OVLY_LOAD_PARMSA     * PMCI_OVLY_LOAD_PARMSA;
typedef MCI_OVLY_LOAD_PARMSW     * PMCI_OVLY_LOAD_PARMSW;



typedef PMCI_OVLY_LOAD_PARMSA PMCI_OVLY_LOAD_PARMS;
#line 3362 "d:\\msvc20\\include/mmsystem.h"
typedef MCI_OVLY_LOAD_PARMSA     * LPMCI_OVLY_LOAD_PARMSA;
typedef MCI_OVLY_LOAD_PARMSW     * LPMCI_OVLY_LOAD_PARMSW;



typedef LPMCI_OVLY_LOAD_PARMSA LPMCI_OVLY_LOAD_PARMS;
#line 3369 "d:\\msvc20\\include/mmsystem.h"

#line 3371 "d:\\msvc20\\include/mmsystem.h"














#line 3386 "d:\\msvc20\\include/mmsystem.h"































#line 1 "d:\\msvc20\\include/poppack.h"



































#line 37 "d:\\msvc20\\include/poppack.h"
#line 3418 "d:\\msvc20\\include/mmsystem.h"

#line 3420 "d:\\msvc20\\include/mmsystem.h"
#line 123 "d:\\msvc20\\include/windows.h"
#line 1 "d:\\msvc20\\include/nb30.h"









































typedef struct _NCB {
    UCHAR   ncb_command;            
    UCHAR   ncb_retcode;            
    UCHAR   ncb_lsn;                
    UCHAR   ncb_num;                
    PUCHAR  ncb_buffer;             
    WORD    ncb_length;             
    UCHAR   ncb_callname[16]; 
    UCHAR   ncb_name[16];     
    UCHAR   ncb_rto;                
    UCHAR   ncb_sto;                
    void ( *ncb_post)( struct _NCB * ); 
    UCHAR   ncb_lana_num;           
    UCHAR   ncb_cmd_cplt;           
    UCHAR   ncb_reserve[10];        
    HANDLE  ncb_event;              
                                    
                                    
                                    
} NCB, *PNCB;






typedef struct _ADAPTER_STATUS {
    UCHAR   adapter_address[6];
    UCHAR   rev_major;
    UCHAR   reserved0;
    UCHAR   adapter_type;
    UCHAR   rev_minor;
    WORD    duration;
    WORD    frmr_recv;
    WORD    frmr_xmit;

    WORD    iframe_recv_err;

    WORD    xmit_aborts;
    DWORD   xmit_success;
    DWORD   recv_success;

    WORD    iframe_xmit_err;

    WORD    recv_buff_unavail;
    WORD    t1_timeouts;
    WORD    ti_timeouts;
    DWORD   reserved1;
    WORD    free_ncbs;
    WORD    max_cfg_ncbs;
    WORD    max_ncbs;
    WORD    xmit_buf_unavail;
    WORD    max_dgram_size;
    WORD    pending_sess;
    WORD    max_cfg_sess;
    WORD    max_sess;
    WORD    max_sess_pkt_size;
    WORD    name_count;
} ADAPTER_STATUS, *PADAPTER_STATUS;

typedef struct _NAME_BUFFER {
    UCHAR   name[16];
    UCHAR   name_num;
    UCHAR   name_flags;
} NAME_BUFFER, *PNAME_BUFFER;





















typedef struct _SESSION_HEADER {
    UCHAR   sess_name;
    UCHAR   num_sess;
    UCHAR   rcv_dg_outstanding;
    UCHAR   rcv_any_outstanding;
} SESSION_HEADER, *PSESSION_HEADER;

typedef struct _SESSION_BUFFER {
    UCHAR   lsn;
    UCHAR   state;
    UCHAR   local_name[16];
    UCHAR   remote_name[16];
    UCHAR   rcvs_outstanding;
    UCHAR   sends_outstanding;
} SESSION_BUFFER, *PSESSION_BUFFER;

















typedef struct _LANA_ENUM {
    UCHAR   length;         
    UCHAR   lana[254+1];
} LANA_ENUM, *PLANA_ENUM;






typedef struct _FIND_NAME_HEADER {
    WORD    node_count;
    UCHAR   reserved;
    UCHAR   unique_group;
} FIND_NAME_HEADER, *PFIND_NAME_HEADER;

typedef struct _FIND_NAME_BUFFER {
    UCHAR   length;
    UCHAR   access_control;
    UCHAR   frame_control;
    UCHAR   destination_addr[6];
    UCHAR   source_addr[6];
    UCHAR   routing_info[18];
} FIND_NAME_BUFFER, *PFIND_NAME_BUFFER;






typedef struct _ACTION_HEADER {
    ULONG   transport_id;
    USHORT  action_code;
    USHORT  reserved;
} ACTION_HEADER, *PACTION_HEADER;




















































                                















































UCHAR

Netbios(
    PNCB pncb
    );














#line 315 "d:\\msvc20\\include/nb30.h"
#line 124 "d:\\msvc20\\include/windows.h"
#line 1 "d:\\msvc20\\include/rpc.h"















#line 1 "d:\\msvc20\\include/windows.h"


























































































































































#line 17 "d:\\msvc20\\include/rpc.h"
#line 18 "d:\\msvc20\\include/rpc.h"















#line 34 "d:\\msvc20\\include/rpc.h"

typedef void * I_RPC_HANDLE;
typedef long RPC_STATUS;








#line 46 "d:\\msvc20\\include/rpc.h"





#line 52 "d:\\msvc20\\include/rpc.h"





#line 58 "d:\\msvc20\\include/rpc.h"

#line 1 "d:\\msvc20\\include/rpcdce.h"



































typedef I_RPC_HANDLE RPC_BINDING_HANDLE;
typedef RPC_BINDING_HANDLE handle_t;




typedef struct _GUID
{
    unsigned long Data1;
    unsigned short Data2;
    unsigned short Data3;
    unsigned char Data4[8];
} GUID;
#line 50 "d:\\msvc20\\include/rpcdce.h"



typedef GUID UUID;


#line 57 "d:\\msvc20\\include/rpcdce.h"
#line 58 "d:\\msvc20\\include/rpcdce.h"

typedef struct _RPC_BINDING_VECTOR
{
    unsigned long Count;
    RPC_BINDING_HANDLE BindingH[1];
} RPC_BINDING_VECTOR;


#line 67 "d:\\msvc20\\include/rpcdce.h"

typedef struct _UUID_VECTOR
{
  unsigned long Count;
  UUID *Uuid[1];
} UUID_VECTOR;


#line 76 "d:\\msvc20\\include/rpcdce.h"

typedef void  * RPC_IF_HANDLE;



typedef struct _RPC_IF_ID
{
    UUID Uuid;
    unsigned short VersMajor;
    unsigned short VersMinor;
} RPC_IF_ID;
#line 88 "d:\\msvc20\\include/rpcdce.h"













typedef struct _RPC_PROTSEQ_VECTORA
{
    unsigned int Count;
    unsigned char  * Protseq[1];
} RPC_PROTSEQ_VECTORA;

typedef struct _RPC_PROTSEQ_VECTORW
{
    unsigned int Count;
    unsigned short  * Protseq[1];
} RPC_PROTSEQ_VECTORW;





#line 118 "d:\\msvc20\\include/rpcdce.h"









#line 128 "d:\\msvc20\\include/rpcdce.h"

typedef void 
RPC_OBJECT_INQ_FN (
     UUID  * ObjectUuid,
     UUID  * TypeUuid,
     RPC_STATUS  * Status
    );



typedef struct
{
    unsigned int Count;
    unsigned long Stats[1];
} RPC_STATS_VECTOR;






typedef struct
{
  unsigned long Count;
  RPC_IF_ID  * IfId[1];
} RPC_IF_ID_VECTOR;


RPC_STATUS 
RpcBindingCopy (
     RPC_BINDING_HANDLE SourceBinding,
     RPC_BINDING_HANDLE  * DestinationBinding
    );


RPC_STATUS 
RpcBindingFree (
      RPC_BINDING_HANDLE  * Binding
    );





RPC_STATUS 
RpcBindingFromStringBindingA (
     unsigned char  * StringBinding,
     RPC_BINDING_HANDLE  * Binding
    );

RPC_STATUS 
RpcBindingFromStringBindingW (
     unsigned short  * StringBinding,
     RPC_BINDING_HANDLE  * Binding
    );





#line 189 "d:\\msvc20\\include/rpcdce.h"









#line 199 "d:\\msvc20\\include/rpcdce.h"





RPC_STATUS 
RpcBindingInqObject (
     RPC_BINDING_HANDLE Binding,
     UUID  * ObjectUuid
    );


RPC_STATUS 
RpcBindingReset (
     RPC_BINDING_HANDLE Binding
    );





RPC_STATUS 
RpcBindingSetObject (
     RPC_BINDING_HANDLE Binding,
     UUID  * ObjectUuid
    );


RPC_STATUS 
RpcMgmtInqDefaultProtectLevel(
      unsigned long AuthnSvc,
     unsigned long  *AuthnLevel
    );





RPC_STATUS 
RpcBindingToStringBindingA (
     RPC_BINDING_HANDLE Binding,
     unsigned char  *  * StringBinding
    );

RPC_STATUS 
RpcBindingToStringBindingW (
     RPC_BINDING_HANDLE Binding,
     unsigned short  *  * StringBinding
    );





#line 254 "d:\\msvc20\\include/rpcdce.h"









#line 264 "d:\\msvc20\\include/rpcdce.h"


RPC_STATUS 
RpcBindingVectorFree (
      RPC_BINDING_VECTOR  *  * BindingVector
    );





RPC_STATUS 
RpcStringBindingComposeA (
     unsigned char  * ObjUuid ,
     unsigned char  * Protseq ,
     unsigned char  * NetworkAddr ,
     unsigned char  * Endpoint ,
     unsigned char  * Options ,
     unsigned char  *  * StringBinding 
    );

RPC_STATUS 
RpcStringBindingComposeW (
     unsigned short  * ObjUuid ,
     unsigned short  * Protseq ,
     unsigned short  * NetworkAddr ,
     unsigned short  * Endpoint ,
     unsigned short  * Options ,
     unsigned short  *  * StringBinding 
    );





#line 300 "d:\\msvc20\\include/rpcdce.h"













#line 314 "d:\\msvc20\\include/rpcdce.h"





RPC_STATUS 
RpcStringBindingParseA (
     unsigned char  * StringBinding,
     unsigned char  *  * ObjUuid ,
     unsigned char  *  * Protseq ,
     unsigned char  *  * NetworkAddr ,
     unsigned char  *  * Endpoint ,
     unsigned char  *  * NetworkOptions 
    );

RPC_STATUS 
RpcStringBindingParseW (
     unsigned short  * StringBinding,
     unsigned short  *  * ObjUuid ,
     unsigned short  *  * Protseq ,
     unsigned short  *  * NetworkAddr ,
     unsigned short  *  * Endpoint ,
     unsigned short  *  * NetworkOptions 
    );





#line 344 "d:\\msvc20\\include/rpcdce.h"













#line 358 "d:\\msvc20\\include/rpcdce.h"





RPC_STATUS 
RpcStringFreeA (
      unsigned char  *  * String
    );

RPC_STATUS 
RpcStringFreeW (
      unsigned short  *  * String
    );





#line 378 "d:\\msvc20\\include/rpcdce.h"








#line 387 "d:\\msvc20\\include/rpcdce.h"


RPC_STATUS 
RpcIfInqId (
     RPC_IF_HANDLE RpcIfHandle,
     RPC_IF_ID  * RpcIfId
    );





RPC_STATUS 
RpcNetworkIsProtseqValidA (
     unsigned char  * Protseq
    );

RPC_STATUS 
RpcNetworkIsProtseqValidW (
     unsigned short  * Protseq
    );





#line 414 "d:\\msvc20\\include/rpcdce.h"








#line 423 "d:\\msvc20\\include/rpcdce.h"


RPC_STATUS 
RpcMgmtInqComTimeout (
     RPC_BINDING_HANDLE Binding,
     unsigned int  * Timeout
    );


RPC_STATUS 
RpcMgmtSetComTimeout (
     RPC_BINDING_HANDLE Binding,
     unsigned int Timeout
    );


RPC_STATUS 
RpcMgmtSetCancelTimeout(
    long Timeout
    );






RPC_STATUS 
RpcNetworkInqProtseqsA (
     RPC_PROTSEQ_VECTORA  *  * ProtseqVector
    );

RPC_STATUS 
RpcNetworkInqProtseqsW (
     RPC_PROTSEQ_VECTORW  *  * ProtseqVector
    );





#line 464 "d:\\msvc20\\include/rpcdce.h"








#line 473 "d:\\msvc20\\include/rpcdce.h"


RPC_STATUS 
RpcObjectInqType (
     UUID  * ObjUuid,
     UUID  * TypeUuid 
    );


RPC_STATUS 
RpcObjectSetInqFn (
     RPC_OBJECT_INQ_FN  * InquiryFn
    );


RPC_STATUS 
RpcObjectSetType (
     UUID  * ObjUuid,
     UUID  * TypeUuid 
    );





RPC_STATUS 
RpcProtseqVectorFreeA (
      RPC_PROTSEQ_VECTORA  *  * ProtseqVector
    );

RPC_STATUS 
RpcProtseqVectorFreeW (
      RPC_PROTSEQ_VECTORW  *  * ProtseqVector
    );





#line 513 "d:\\msvc20\\include/rpcdce.h"








#line 522 "d:\\msvc20\\include/rpcdce.h"


RPC_STATUS 
RpcServerInqBindings (
     RPC_BINDING_VECTOR  *  * BindingVector
    );


RPC_STATUS 
RpcServerInqIf (
     RPC_IF_HANDLE IfSpec,
     UUID  * MgrTypeUuid, 
     void  *  * MgrEpv
    );


RPC_STATUS 
RpcServerListen (
     unsigned int MinimumCallThreads,
     unsigned int MaxCalls,
     unsigned int DontWait
    );


RPC_STATUS 
RpcServerRegisterIf (
     RPC_IF_HANDLE IfSpec,
     UUID  * MgrTypeUuid ,
     void  * MgrEpv 
    );


RPC_STATUS 
RpcServerUnregisterIf (
     RPC_IF_HANDLE IfSpec,
     UUID  * MgrTypeUuid, 
     unsigned int WaitForCallsToComplete
    );


RPC_STATUS 
RpcServerUseAllProtseqs (
     unsigned int MaxCalls,
     void  * SecurityDescriptor 
    );


RPC_STATUS 
RpcServerUseAllProtseqsIf (
     unsigned int MaxCalls,
     RPC_IF_HANDLE IfSpec,
     void  * SecurityDescriptor 
    );





RPC_STATUS 
RpcServerUseProtseqA (
     unsigned char  * Protseq,
     unsigned int MaxCalls,
     void  * SecurityDescriptor 
    );

RPC_STATUS 
RpcServerUseProtseqW (
     unsigned short  * Protseq,
     unsigned int MaxCalls,
     void  * SecurityDescriptor 
    );





#line 599 "d:\\msvc20\\include/rpcdce.h"










#line 610 "d:\\msvc20\\include/rpcdce.h"





RPC_STATUS 
RpcServerUseProtseqEpA (
     unsigned char  * Protseq,
     unsigned int MaxCalls,
     unsigned char  * Endpoint,
     void  * SecurityDescriptor 
    );

RPC_STATUS 
RpcServerUseProtseqEpW (
     unsigned short  * Protseq,
     unsigned int MaxCalls,
     unsigned short  * Endpoint,
     void  * SecurityDescriptor 
    );





#line 636 "d:\\msvc20\\include/rpcdce.h"











#line 648 "d:\\msvc20\\include/rpcdce.h"





RPC_STATUS 
RpcServerUseProtseqIfA (
     unsigned char  * Protseq,
     unsigned int MaxCalls,
     RPC_IF_HANDLE IfSpec,
     void  * SecurityDescriptor 
    );

RPC_STATUS 
RpcServerUseProtseqIfW (
     unsigned short  * Protseq,
     unsigned int MaxCalls,
     RPC_IF_HANDLE IfSpec,
     void  * SecurityDescriptor 
    );





#line 674 "d:\\msvc20\\include/rpcdce.h"











#line 686 "d:\\msvc20\\include/rpcdce.h"


RPC_STATUS 
RpcMgmtStatsVectorFree (
     RPC_STATS_VECTOR ** StatsVector
    );


RPC_STATUS 
RpcMgmtInqStats (
     RPC_BINDING_HANDLE Binding,
     RPC_STATS_VECTOR ** Statistics
    );


RPC_STATUS 
RpcMgmtIsServerListening (
     RPC_BINDING_HANDLE Binding
    );


RPC_STATUS 
RpcMgmtStopServerListening (
     RPC_BINDING_HANDLE Binding
    );


RPC_STATUS 
RpcMgmtWaitServerListen (
    void
    );


RPC_STATUS 
RpcMgmtSetServerStackSize (
     unsigned long ThreadStackSize
    );


RPC_STATUS 
RpcMgmtEnableIdleCleanup (
    void
    );

RPC_STATUS 
RpcMgmtInqIfIds (
     RPC_BINDING_HANDLE Binding,
     RPC_IF_ID_VECTOR  *  * IfIdVector
    );

RPC_STATUS 
RpcIfIdVectorFree (
      RPC_IF_ID_VECTOR  *  * IfIdVector
    );



RPC_STATUS 
RpcMgmtInqServerPrincNameA (
     RPC_BINDING_HANDLE Binding,
     unsigned long AuthnSvc,
     unsigned char  *  * ServerPrincName
    );

RPC_STATUS 
RpcMgmtInqServerPrincNameW (
     RPC_BINDING_HANDLE Binding,
     unsigned long AuthnSvc,
     unsigned short  *  * ServerPrincName
    );





#line 762 "d:\\msvc20\\include/rpcdce.h"










#line 773 "d:\\msvc20\\include/rpcdce.h"


RPC_STATUS 
RpcEpResolveBinding (
     RPC_BINDING_HANDLE Binding,
     RPC_IF_HANDLE IfSpec
    );





RPC_STATUS 
RpcNsBindingInqEntryNameA (
     RPC_BINDING_HANDLE Binding,
     unsigned long EntryNameSyntax,
     unsigned char  *  * EntryName
    );

RPC_STATUS 
RpcNsBindingInqEntryNameW (
     RPC_BINDING_HANDLE Binding,
     unsigned long EntryNameSyntax,
     unsigned short  *  * EntryName
    );





#line 804 "d:\\msvc20\\include/rpcdce.h"










#line 815 "d:\\msvc20\\include/rpcdce.h"

typedef void  * RPC_AUTH_IDENTITY_HANDLE;
typedef void  * RPC_AUTHZ_HANDLE;
































#line 851 "d:\\msvc20\\include/rpcdce.h"





typedef struct _SEC_WINNT_AUTH_IDENTITY_W {
  unsigned short  *User;
  unsigned long UserLength;
  unsigned short  *Domain;
  unsigned long DomainLength;
  unsigned short  *Password;
  unsigned long PasswordLength;
  unsigned long Flags;
} SEC_WINNT_AUTH_IDENTITY_W, *PSEC_WINNT_AUTH_IDENTITY_W;

typedef struct _SEC_WINNT_AUTH_IDENTITY_A {
  unsigned char  *User;
  unsigned long UserLength;
  unsigned char  *Domain;
  unsigned long DomainLength;
  unsigned char  *Password;
  unsigned long PasswordLength;
  unsigned long Flags;
} SEC_WINNT_AUTH_IDENTITY_A, *PSEC_WINNT_AUTH_IDENTITY_A;









#line 885 "d:\\msvc20\\include/rpcdce.h"
#line 886 "d:\\msvc20\\include/rpcdce.h"







RPC_STATUS 
RpcBindingInqAuthClientA (
     RPC_BINDING_HANDLE ClientBinding, 
     RPC_AUTHZ_HANDLE  * Privs,
     unsigned char  *  * ServerPrincName, 
     unsigned long  * AuthnLevel, 
     unsigned long  * AuthnSvc, 
     unsigned long  * AuthzSvc 
    );

RPC_STATUS 
RpcBindingInqAuthClientW (
     RPC_BINDING_HANDLE ClientBinding, 
     RPC_AUTHZ_HANDLE  * Privs,
     unsigned short  *  * ServerPrincName, 
     unsigned long  * AuthnLevel, 
     unsigned long  * AuthnSvc, 
     unsigned long  * AuthzSvc 
    );

RPC_STATUS 
RpcBindingInqAuthInfoA (
     RPC_BINDING_HANDLE Binding,
     unsigned char  *  * ServerPrincName, 
     unsigned long  * AuthnLevel, 
     unsigned long  * AuthnSvc, 
     RPC_AUTH_IDENTITY_HANDLE  * AuthIdentity, 
     unsigned long  * AuthzSvc 
    );

RPC_STATUS 
RpcBindingInqAuthInfoW (
     RPC_BINDING_HANDLE Binding,
     unsigned short  *  * ServerPrincName, 
     unsigned long  * AuthnLevel, 
     unsigned long  * AuthnSvc, 
     RPC_AUTH_IDENTITY_HANDLE  * AuthIdentity, 
     unsigned long  * AuthzSvc 
    );

RPC_STATUS 
RpcBindingSetAuthInfoA (
     RPC_BINDING_HANDLE Binding,
     unsigned char  * ServerPrincName,
     unsigned long AuthnLevel,
     unsigned long AuthnSvc,
     RPC_AUTH_IDENTITY_HANDLE AuthIdentity, 
     unsigned long AuthzSvc
    );

RPC_STATUS 
RpcBindingSetAuthInfoW (
     RPC_BINDING_HANDLE Binding,
     unsigned short  * ServerPrincName,
     unsigned long AuthnLevel,
     unsigned long AuthnSvc,
     RPC_AUTH_IDENTITY_HANDLE AuthIdentity, 
     unsigned long AuthzSvc
    );

typedef void
( * RPC_AUTH_KEY_RETRIEVAL_FN) (
     void  * Arg,
     unsigned short  * ServerPrincName,
     unsigned long KeyVer,
     void  *  * Key,
     RPC_STATUS  * Status
    );

RPC_STATUS 
RpcServerRegisterAuthInfoA (
     unsigned char  * ServerPrincName,
     unsigned long AuthnSvc,
     RPC_AUTH_KEY_RETRIEVAL_FN GetKeyFn ,
     void  * Arg 
    );

RPC_STATUS 
RpcServerRegisterAuthInfoW (
     unsigned short  * ServerPrincName,
     unsigned long AuthnSvc,
     RPC_AUTH_KEY_RETRIEVAL_FN GetKeyFn ,
     void  * Arg 
    );











#line 989 "d:\\msvc20\\include/rpcdce.h"


















































#line 1040 "d:\\msvc20\\include/rpcdce.h"

typedef struct {
    unsigned char  * UserName;
    unsigned char  * ComputerName;
    unsigned short Privilege;
    unsigned long AuthFlags;
} RPC_CLIENT_INFORMATION1,  * PRPC_CLIENT_INFORMATION1;

RPC_STATUS 
RpcBindingServerFromClient (
     RPC_BINDING_HANDLE ClientBinding,
     RPC_BINDING_HANDLE  * ServerBinding
    );

void 
RpcRaiseException (
     RPC_STATUS exception
    );

RPC_STATUS 
RpcTestCancel(
    );

RPC_STATUS 
RpcCancelThread(
     void * Thread
    );


RPC_STATUS 
UuidCreate (
     UUID  * Uuid
    );




RPC_STATUS 
UuidToStringA (
     UUID  * Uuid,
     unsigned char  *  * StringUuid
    );


RPC_STATUS 
UuidFromStringA (
     unsigned char  * StringUuid,
     UUID  * Uuid
    );


RPC_STATUS 
UuidToStringW (
     UUID  * Uuid,
     unsigned short  *  * StringUuid
    );


RPC_STATUS 
UuidFromStringW (
     unsigned short  * StringUuid,
     UUID  * Uuid
    );







#line 1111 "d:\\msvc20\\include/rpcdce.h"

















#line 1129 "d:\\msvc20\\include/rpcdce.h"

signed int 
UuidCompare (
     UUID  * Uuid1,
     UUID  * Uuid2,
     RPC_STATUS  * Status
    );

RPC_STATUS 
UuidCreateNil (
     UUID  * NilUuid
    );

int 
UuidEqual (
     UUID  * Uuid1,
     UUID  * Uuid2,
     RPC_STATUS  * Status
    );

unsigned short 
UuidHash (
     UUID  * Uuid,
     RPC_STATUS  * Status
    );

int 
UuidIsNil (
     UUID  * Uuid,
     RPC_STATUS  * Status
    );



RPC_STATUS 
RpcEpRegisterNoReplaceA (
     RPC_IF_HANDLE IfSpec,
     RPC_BINDING_VECTOR * BindingVector,
     UUID_VECTOR * UuidVector ,
     unsigned char * Annotation
    );

RPC_STATUS 
RpcEpRegisterNoReplaceW (
     RPC_IF_HANDLE IfSpec,
     RPC_BINDING_VECTOR * BindingVector,
     UUID_VECTOR * UuidVector ,
     unsigned short  * Annotation
    );

RPC_STATUS 
RpcEpRegisterA (
     RPC_IF_HANDLE IfSpec,
     RPC_BINDING_VECTOR * BindingVector,
     UUID_VECTOR * UuidVector ,
     unsigned char * Annotation
    );

RPC_STATUS 
RpcEpRegisterW (
     RPC_IF_HANDLE IfSpec,
     RPC_BINDING_VECTOR * BindingVector,
     UUID_VECTOR * UuidVector ,
     unsigned short * Annotation
    );







#line 1202 "d:\\msvc20\\include/rpcdce.h"



















#line 1222 "d:\\msvc20\\include/rpcdce.h"


RPC_STATUS 
RpcEpUnregister(
     RPC_IF_HANDLE IfSpec,
     RPC_BINDING_VECTOR * BindingVector,
     UUID_VECTOR * UuidVector
    );



RPC_STATUS 
DceErrorInqTextA (
     RPC_STATUS RpcStatus,
     unsigned char  * ErrorText
    );

RPC_STATUS 
DceErrorInqTextW (
     RPC_STATUS RpcStatus,
     unsigned short  * ErrorText
    );





#line 1250 "d:\\msvc20\\include/rpcdce.h"









#line 1260 "d:\\msvc20\\include/rpcdce.h"



typedef I_RPC_HANDLE * RPC_EP_INQ_HANDLE;












RPC_STATUS 
RpcMgmtEpEltInqBegin (
     RPC_BINDING_HANDLE EpBinding ,
     unsigned long InquiryType,
     RPC_IF_ID  * IfId ,
     unsigned long VersOption ,
     UUID  * ObjectUuid ,
     RPC_EP_INQ_HANDLE  * InquiryContext
    );

RPC_STATUS 
RpcMgmtEpEltInqDone (
      RPC_EP_INQ_HANDLE  * InquiryContext
    );



RPC_STATUS 
RpcMgmtEpEltInqNextA (
     RPC_EP_INQ_HANDLE InquiryContext,
     RPC_IF_ID  * IfId,
     RPC_BINDING_HANDLE  * Binding ,
     UUID  * ObjectUuid ,
     unsigned char  *  * Annotation 
    );

RPC_STATUS 
RpcMgmtEpEltInqNextW (
     RPC_EP_INQ_HANDLE InquiryContext,
     RPC_IF_ID  * IfId,
     RPC_BINDING_HANDLE  * Binding ,
     UUID  * ObjectUuid ,
     unsigned short  *  * Annotation 
    );





#line 1316 "d:\\msvc20\\include/rpcdce.h"











#line 1328 "d:\\msvc20\\include/rpcdce.h"

RPC_STATUS 
RpcMgmtEpUnregister (
     RPC_BINDING_HANDLE EpBinding ,
     RPC_IF_ID  * IfId,
     RPC_BINDING_HANDLE Binding,
     UUID  * ObjectUuid 
    );

typedef int
( * RPC_MGMT_AUTHORIZATION_FN) (
     RPC_BINDING_HANDLE ClientBinding,
     unsigned long RequestedMgmtOperation,
     RPC_STATUS  * Status
    );







RPC_STATUS 
RpcMgmtSetAuthorizationFn (
     RPC_MGMT_AUTHORIZATION_FN AuthorizationFn
    );

#line 1 "d:\\msvc20\\include/rpcdcep.h"































#line 33 "d:\\msvc20\\include/rpcdcep.h"





typedef struct _RPC_VERSION {
    unsigned short MajorVersion;
    unsigned short MinorVersion;
} RPC_VERSION;

typedef struct _RPC_SYNTAX_IDENTIFIER {
    GUID SyntaxGUID;
    RPC_VERSION SyntaxVersion;
} RPC_SYNTAX_IDENTIFIER,  * PRPC_SYNTAX_IDENTIFIER;

typedef struct _RPC_MESSAGE
{
    RPC_BINDING_HANDLE Handle;
    unsigned long DataRepresentation;
    void  * Buffer;
    unsigned int BufferLength;
    unsigned int ProcNum;
    PRPC_SYNTAX_IDENTIFIER TransferSyntax;
    void  * RpcInterfaceInformation;
    void  * ReservedForRuntime;
    void  * ManagerEpv;
    void  * ImportContext;
    unsigned long RpcFlags;
} RPC_MESSAGE,  * PRPC_MESSAGE;


typedef RPC_STATUS RPC_FORWARD_FUNCTION(
                        UUID              * InterfaceId,
                        RPC_VERSION       * InterfaceVersion,
                        UUID              * ObjectId,
                        unsigned char          * Rpcpro,
                        void  *  * ppDestEndpoint);














#line 85 "d:\\msvc20\\include/rpcdcep.h"



#line 89 "d:\\msvc20\\include/rpcdcep.h"

typedef
void
(  * RPC_DISPATCH_FUNCTION) (
      PRPC_MESSAGE Message
    );

typedef struct {
    unsigned int DispatchTableCount;
    RPC_DISPATCH_FUNCTION  * DispatchTable;
    int Reserved;
} RPC_DISPATCH_TABLE,  * PRPC_DISPATCH_TABLE;

typedef struct _RPC_PROTSEQ_ENDPOINT
{
    unsigned char  * RpcProtocolSequence;
    unsigned char  * Endpoint;
} RPC_PROTSEQ_ENDPOINT,  * PRPC_PROTSEQ_ENDPOINT;






typedef struct _RPC_SERVER_INTERFACE
{
    unsigned int Length;
    RPC_SYNTAX_IDENTIFIER InterfaceId;
    RPC_SYNTAX_IDENTIFIER TransferSyntax;
    PRPC_DISPATCH_TABLE DispatchTable;
    unsigned int RpcProtseqEndpointCount;
    PRPC_PROTSEQ_ENDPOINT RpcProtseqEndpoint;
    void  *DefaultManagerEpv;
    void const  *InterpreterInfo;
} RPC_SERVER_INTERFACE,  * PRPC_SERVER_INTERFACE;

typedef struct _RPC_CLIENT_INTERFACE
{
    unsigned int Length;
    RPC_SYNTAX_IDENTIFIER InterfaceId;
    RPC_SYNTAX_IDENTIFIER TransferSyntax;
    PRPC_DISPATCH_TABLE DispatchTable;
    unsigned int RpcProtseqEndpointCount;
    PRPC_PROTSEQ_ENDPOINT RpcProtseqEndpoint;
    unsigned long Reserved;
    void const  * InterpreterInfo;
} RPC_CLIENT_INTERFACE,  * PRPC_CLIENT_INTERFACE;

RPC_STATUS 
I_RpcGetBuffer (
      RPC_MESSAGE  * Message
    );

RPC_STATUS 
I_RpcSendReceive (
      RPC_MESSAGE  * Message
    );

RPC_STATUS 
I_RpcFreeBuffer (
      RPC_MESSAGE  * Message
    );

typedef void * I_RPC_MUTEX;

void 
I_RpcRequestMutex (
      I_RPC_MUTEX * Mutex
    );

void 
I_RpcClearMutex (
     I_RPC_MUTEX Mutex
    );

void 
I_RpcDeleteMutex (
     I_RPC_MUTEX Mutex
    );

void  * 
I_RpcAllocate (
     unsigned int Size
    );

void 
I_RpcFree (
     void  * Object
    );

void 
I_RpcPauseExecution (
     unsigned long Milliseconds
    );

typedef
void
(  * PRPC_RUNDOWN) (
    void  * AssociationContext
    );

RPC_STATUS 
I_RpcMonitorAssociation (
     RPC_BINDING_HANDLE Handle,
     PRPC_RUNDOWN RundownRoutine,
     void * Context
    );

RPC_STATUS 
I_RpcStopMonitorAssociation (
     RPC_BINDING_HANDLE Handle
    );

RPC_BINDING_HANDLE 
I_RpcGetCurrentCallHandle(
    void
    );

RPC_STATUS 
I_RpcGetAssociationContext (
     void  *  * AssociationContext
    );

RPC_STATUS 
I_RpcSetAssociationContext (
     void  * AssociationContext
    );



RPC_STATUS 
I_RpcNsBindingSetEntryName (
     RPC_BINDING_HANDLE Binding,
     unsigned long EntryNameSyntax,
     unsigned short  * EntryName
    );










#line 236 "d:\\msvc20\\include/rpcdcep.h"



RPC_STATUS 
I_RpcBindingInqDynamicEndpoint (
     RPC_BINDING_HANDLE Binding,
     unsigned short  *  * DynamicEndpoint
    );









#line 254 "d:\\msvc20\\include/rpcdcep.h"





RPC_STATUS 
I_RpcBindingInqTransportType (
     RPC_BINDING_HANDLE Binding,
     unsigned int  * Type
    );

typedef struct _RPC_TRANSFER_SYNTAX
{
    UUID Uuid;
    unsigned short VersMajor;
    unsigned short VersMinor;
} RPC_TRANSFER_SYNTAX;

RPC_STATUS 
I_RpcIfInqTransferSyntaxes (
     RPC_IF_HANDLE RpcIfHandle,
     RPC_TRANSFER_SYNTAX  * TransferSyntaxes,
     unsigned int TransferSyntaxSize,
     unsigned int  * TransferSyntaxCount
    );

RPC_STATUS 
I_UuidCreate (
     UUID  * Uuid
    );

RPC_STATUS 
I_RpcBindingCopy (
     RPC_BINDING_HANDLE SourceBinding,
     RPC_BINDING_HANDLE  * DestinationBinding
    );

RPC_STATUS 
I_RpcBindingIsClientLocal (
     RPC_BINDING_HANDLE BindingHandle ,
     unsigned int  * ClientLocalFlag
    );

void 
I_RpcSsDontSerializeContext (
    void
    );


RPC_STATUS 
I_RpcServerRegisterForwardFunction (
     RPC_FORWARD_FUNCTION  * pForwardFunction
                       );









#line 317 "d:\\msvc20\\include/rpcdcep.h"

#line 319 "d:\\msvc20\\include/rpcdcep.h"
#line 1356 "d:\\msvc20\\include/rpcdce.h"





#line 1362 "d:\\msvc20\\include/rpcdce.h"
#line 60 "d:\\msvc20\\include/rpc.h"
#line 1 "d:\\msvc20\\include/rpcnsi.h"


















typedef void  * RPC_NS_HANDLE;














RPC_STATUS 
RpcNsBindingExportA(
     unsigned long EntryNameSyntax ,
     unsigned char  * EntryName,
     RPC_IF_HANDLE IfSpec ,
     RPC_BINDING_VECTOR  * BindingVec ,
     UUID_VECTOR  * ObjectUuidVec 
    );


RPC_STATUS 
RpcNsBindingUnexportA(
     unsigned long EntryNameSyntax ,
     unsigned char  * EntryName,
     RPC_IF_HANDLE IfSpec ,
     UUID_VECTOR  * ObjectUuidVec 
    );



RPC_STATUS 
RpcNsBindingExportW(
     unsigned long EntryNameSyntax ,
     unsigned short  * EntryName,
     RPC_IF_HANDLE IfSpec ,
     RPC_BINDING_VECTOR  * BindingVec ,
     UUID_VECTOR  * ObjectUuidVec 
    );

RPC_STATUS 
RpcNsBindingUnexportW(
     unsigned long EntryNameSyntax ,
     unsigned short  * EntryName,
     RPC_IF_HANDLE IfSpec ,
     UUID_VECTOR  * ObjectUuidVec 
    );

#line 72 "d:\\msvc20\\include/rpcnsi.h"



RPC_STATUS 
RpcNsBindingLookupBeginA(
     unsigned long EntryNameSyntax ,
     unsigned char  * EntryName ,
     RPC_IF_HANDLE IfSpec ,
     UUID  * ObjUuid ,
     unsigned long BindingMaxCount ,
     RPC_NS_HANDLE  * LookupContext
    );



RPC_STATUS 
RpcNsBindingLookupBeginW(
     unsigned long EntryNameSyntax ,
     unsigned short  * EntryName ,
     RPC_IF_HANDLE IfSpec ,
     UUID  * ObjUuid ,
     unsigned long BindingMaxCount ,
     RPC_NS_HANDLE  * LookupContext
    );
#line 97 "d:\\msvc20\\include/rpcnsi.h"

RPC_STATUS 
RpcNsBindingLookupNext(
      RPC_NS_HANDLE LookupContext,
     RPC_BINDING_VECTOR  *  * BindingVec
    );

RPC_STATUS 
RpcNsBindingLookupDone(
      RPC_NS_HANDLE  * LookupContext
    );



RPC_STATUS 
RpcNsGroupDeleteA(
     unsigned long GroupNameSyntax ,
     unsigned char  * GroupName
    );

RPC_STATUS 
RpcNsGroupMbrAddA(
     unsigned long GroupNameSyntax ,
     unsigned char  * GroupName,
     unsigned long MemberNameSyntax ,
     unsigned char  * MemberName
    );

RPC_STATUS 
RpcNsGroupMbrRemoveA(
     unsigned long GroupNameSyntax ,
     unsigned char  * GroupName,
     unsigned long MemberNameSyntax ,
     unsigned char  * MemberName
    );

RPC_STATUS 
RpcNsGroupMbrInqBeginA(
     unsigned long GroupNameSyntax ,
     unsigned char  * GroupName,
     unsigned long MemberNameSyntax ,
     RPC_NS_HANDLE  * InquiryContext
    );

RPC_STATUS 
RpcNsGroupMbrInqNextA(
      RPC_NS_HANDLE InquiryContext,
     unsigned char  *  * MemberName
    );



RPC_STATUS 
RpcNsGroupDeleteW(
     unsigned long GroupNameSyntax ,
     unsigned short  * GroupName
    );

RPC_STATUS 
RpcNsGroupMbrAddW(
     unsigned long GroupNameSyntax ,
     unsigned short  * GroupName,
     unsigned long MemberNameSyntax ,
     unsigned short  * MemberName
    );

RPC_STATUS 
RpcNsGroupMbrRemoveW(
     unsigned long GroupNameSyntax ,
     unsigned short  * GroupName,
     unsigned long MemberNameSyntax ,
     unsigned short  * MemberName
    );

RPC_STATUS 
RpcNsGroupMbrInqBeginW(
     unsigned long GroupNameSyntax ,
     unsigned short  * GroupName,
     unsigned long MemberNameSyntax ,
     RPC_NS_HANDLE  * InquiryContext
    );

RPC_STATUS 
RpcNsGroupMbrInqNextW(
      RPC_NS_HANDLE InquiryContext,
     unsigned short  *  * MemberName
    );

#line 186 "d:\\msvc20\\include/rpcnsi.h"

RPC_STATUS 
RpcNsGroupMbrInqDone(
      RPC_NS_HANDLE  * InquiryContext
    );



RPC_STATUS 
RpcNsProfileDeleteA(
     unsigned long ProfileNameSyntax ,
     unsigned char  * ProfileName
    );

RPC_STATUS 
RpcNsProfileEltAddA(
     unsigned long ProfileNameSyntax ,
     unsigned char  * ProfileName,
     RPC_IF_ID  * IfId ,
     unsigned long MemberNameSyntax ,
     unsigned char  * MemberName,
     unsigned long Priority,
     unsigned char  * Annotation 
    );

RPC_STATUS 
RpcNsProfileEltRemoveA(
     unsigned long ProfileNameSyntax ,
     unsigned char  * ProfileName,
     RPC_IF_ID  * IfId ,
     unsigned long MemberNameSyntax ,
     unsigned char  * MemberName
    );

RPC_STATUS 
RpcNsProfileEltInqBeginA(
     unsigned long ProfileNameSyntax ,
     unsigned char  * ProfileName,
     unsigned long InquiryType,
     RPC_IF_ID  * IfId ,
     unsigned long VersOption,
     unsigned long MemberNameSyntax ,
     unsigned char  * MemberName ,
     RPC_NS_HANDLE  * InquiryContext
    );

RPC_STATUS 
RpcNsProfileEltInqNextA(
     RPC_NS_HANDLE InquiryContext,
     RPC_IF_ID  * IfId,
     unsigned char  *  * MemberName,
     unsigned long  * Priority,
     unsigned char  *  * Annotation
    );



RPC_STATUS 
RpcNsProfileDeleteW(
     unsigned long ProfileNameSyntax ,
     unsigned short  * ProfileName
    );

RPC_STATUS 
RpcNsProfileEltAddW(
     unsigned long ProfileNameSyntax ,
     unsigned short  * ProfileName,
     RPC_IF_ID  * IfId ,
     unsigned long MemberNameSyntax ,
     unsigned short  * MemberName,
     unsigned long Priority,
     unsigned short  * Annotation 
    );

RPC_STATUS 
RpcNsProfileEltRemoveW(
     unsigned long ProfileNameSyntax ,
     unsigned short  * ProfileName,
     RPC_IF_ID  * IfId ,
     unsigned long MemberNameSyntax ,
     unsigned short  * MemberName
    );

RPC_STATUS 
RpcNsProfileEltInqBeginW(
     unsigned long ProfileNameSyntax ,
     unsigned short  * ProfileName,
     unsigned long InquiryType,
     RPC_IF_ID  * IfId ,
     unsigned long VersOption,
     unsigned long MemberNameSyntax ,
     unsigned short  * MemberName ,
     RPC_NS_HANDLE  * InquiryContext
    );

RPC_STATUS 
RpcNsProfileEltInqNextW(
     RPC_NS_HANDLE InquiryContext,
     RPC_IF_ID  * IfId,
     unsigned short  *  * MemberName,
     unsigned long  * Priority,
     unsigned short  *  * Annotation
    );

#line 291 "d:\\msvc20\\include/rpcnsi.h"

RPC_STATUS 
RpcNsProfileEltInqDone(
      RPC_NS_HANDLE  * InquiryContext
    );



RPC_STATUS 
RpcNsEntryObjectInqBeginA(
     unsigned long EntryNameSyntax ,
     unsigned char  * EntryName,
     RPC_NS_HANDLE  * InquiryContext
    );



RPC_STATUS 
RpcNsEntryObjectInqBeginW(
     unsigned long EntryNameSyntax ,
     unsigned short  * EntryName,
     RPC_NS_HANDLE  * InquiryContext
    );

#line 316 "d:\\msvc20\\include/rpcnsi.h"

RPC_STATUS 
RpcNsEntryObjectInqNext(
      RPC_NS_HANDLE InquiryContext,
     UUID  * ObjUuid
    );

RPC_STATUS 
RpcNsEntryObjectInqDone(
      RPC_NS_HANDLE  * InquiryContext
    );



RPC_STATUS 
RpcNsEntryExpandNameA(
     unsigned long EntryNameSyntax ,
     unsigned char  * EntryName,
     unsigned char  *  * ExpandedName
    );

RPC_STATUS 
RpcNsMgmtBindingUnexportA(
     unsigned long EntryNameSyntax ,
     unsigned char  * EntryName,
     RPC_IF_ID  * IfId ,
     unsigned long VersOption,
     UUID_VECTOR  * ObjectUuidVec 
    );

RPC_STATUS 
RpcNsMgmtEntryCreateA(
     unsigned long EntryNameSyntax ,
     unsigned char  * EntryName
    );

RPC_STATUS 
RpcNsMgmtEntryDeleteA(
     unsigned long EntryNameSyntax ,
     unsigned char  * EntryName
    );

RPC_STATUS 
RpcNsMgmtEntryInqIfIdsA(
     unsigned long EntryNameSyntax ,
     unsigned char  * EntryName,
     RPC_IF_ID_VECTOR  *  * IfIdVec
    );

RPC_STATUS 
RpcNsMgmtHandleSetExpAge(
     RPC_NS_HANDLE NsHandle,
     unsigned long ExpirationAge
    );

RPC_STATUS 
RpcNsMgmtInqExpAge(
     unsigned long  * ExpirationAge
    );

RPC_STATUS 
RpcNsMgmtSetExpAge(
     unsigned long ExpirationAge
    );



RPC_STATUS 
RpcNsEntryExpandNameW(
     unsigned long EntryNameSyntax ,
     unsigned short  * EntryName,
     unsigned short  *  * ExpandedName
    );

RPC_STATUS 
RpcNsMgmtBindingUnexportW(
     unsigned long EntryNameSyntax ,
     unsigned short  * EntryName,
     RPC_IF_ID  * IfId ,
     unsigned long VersOption,
     UUID_VECTOR  * ObjectUuidVec 
    );

RPC_STATUS 
RpcNsMgmtEntryCreateW(
     unsigned long EntryNameSyntax ,
     unsigned short  * EntryName
    );

RPC_STATUS 
RpcNsMgmtEntryDeleteW(
     unsigned long EntryNameSyntax ,
     unsigned short  * EntryName
    );

RPC_STATUS 
RpcNsMgmtEntryInqIfIdsW(
     unsigned long EntryNameSyntax ,
     unsigned short  * EntryName,
     RPC_IF_ID_VECTOR  *  * IfIdVec
    );

#line 419 "d:\\msvc20\\include/rpcnsi.h"



RPC_STATUS 
RpcNsBindingImportBeginA(
     unsigned long EntryNameSyntax ,
     unsigned char  * EntryName ,
     RPC_IF_HANDLE IfSpec ,
     UUID  * ObjUuid ,
     RPC_NS_HANDLE  * ImportContext
    );



RPC_STATUS 
RpcNsBindingImportBeginW(
     unsigned long EntryNameSyntax ,
     unsigned short  * EntryName ,
     RPC_IF_HANDLE IfSpec ,
     UUID  * ObjUuid ,
     RPC_NS_HANDLE  * ImportContext
    );

#line 443 "d:\\msvc20\\include/rpcnsi.h"

RPC_STATUS 
RpcNsBindingImportNext(
     RPC_NS_HANDLE ImportContext,
     RPC_BINDING_HANDLE   * Binding
    );

RPC_STATUS 
RpcNsBindingImportDone(
      RPC_NS_HANDLE  * ImportContext
    );

RPC_STATUS 
RpcNsBindingSelect(
      RPC_BINDING_VECTOR  * BindingVec,
     RPC_BINDING_HANDLE   * Binding
    );















































#line 508 "d:\\msvc20\\include/rpcnsi.h"

#line 510 "d:\\msvc20\\include/rpcnsi.h"
#line 61 "d:\\msvc20\\include/rpc.h"
#line 1 "d:\\msvc20\\include/rpcnterr.h"
































#line 34 "d:\\msvc20\\include/rpcnterr.h"
#line 62 "d:\\msvc20\\include/rpc.h"


#line 1 "d:\\msvc20\\include/excpt.h"































































#line 65 "d:\\msvc20\\include/excpt.h"





typedef enum _EXCEPTION_DISPOSITION {
    ExceptionContinueExecution,
    ExceptionContinueSearch,
    ExceptionNestedException,
    ExceptionCollidedUnwind
} EXCEPTION_DISPOSITION;







































#line 116 "d:\\msvc20\\include/excpt.h"










































#line 159 "d:\\msvc20\\include/excpt.h"
#line 65 "d:\\msvc20\\include/rpc.h"
#line 1 "d:\\msvc20\\include/winerror.h"























































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































#line 66 "d:\\msvc20\\include/rpc.h"




































RPC_STATUS 
RpcImpersonateClient (
     RPC_BINDING_HANDLE BindingHandle 
    );

RPC_STATUS 
RpcRevertToSelf (
    );

long 
I_RpcMapWin32Status (
     RPC_STATUS Status
    );





#line 121 "d:\\msvc20\\include/rpc.h"

#line 125 "d:\\msvc20\\include/windows.h"
#line 1 "d:\\msvc20\\include/shellapi.h"




















typedef HANDLE HDROP;

UINT  DragQueryFileW(HDROP,UINT,LPWSTR,UINT);
UINT  DragQueryFileA(HDROP,UINT,LPSTR,UINT);





#line 31 "d:\\msvc20\\include/shellapi.h"

BOOL  DragQueryPoint(HDROP,LPPOINT);
void  DragFinish(HDROP);

void  DragAcceptFiles(HWND,BOOL);

HICON   ExtractIconW(HINSTANCE hInst, LPCWSTR lpszExeFileName, UINT nIconIndex);
HICON   ExtractIconA(HINSTANCE hInst, LPCSTR lpszExeFileName, UINT nIconIndex);





#line 45 "d:\\msvc20\\include/shellapi.h"









HINSTANCE  ShellExecuteA(HWND hwnd, LPCSTR lpOperation, LPCSTR lpFile, LPSTR lpParameters, LPCSTR lpDirectory, INT nShowCmd);
HINSTANCE  ShellExecuteW(HWND hwnd, LPCWSTR lpOperation, LPCWSTR lpFile, LPWSTR lpParameters, LPCWSTR lpDirectory, INT nShowCmd);

HINSTANCE  FindExecutableA(LPCSTR lpFile, LPCSTR lpDirectory, LPSTR lpResult);
HINSTANCE  FindExecutableW(LPCWSTR lpFile, LPCWSTR lpDirectory, LPWSTR lpResult);
TCHAR **  CommandLineToArgvW(TCHAR* lpCmdLine, int*pNumArgs);

INT    ShellAboutA(HWND hWnd, LPCSTR szApp, LPCSTR szOtherStuff, HICON hIcon);
INT    ShellAboutW(HWND hWnd, LPCWSTR szApp, LPCWSTR szOtherStuff, HICON hIcon);









#line 73 "d:\\msvc20\\include/shellapi.h"

HICON  DuplicateIcon(HINSTANCE hInst, HICON hIcon);                                
HICON  ExtractAssociatedIconA(HINSTANCE hInst, LPSTR lpIconPath, LPWORD lpiIcon);   
HICON  ExtractAssociatedIconW(HINSTANCE hInst, LPWSTR lpIconPath, LPWORD lpiIcon);   





#line 83 "d:\\msvc20\\include/shellapi.h"





#line 89 "d:\\msvc20\\include/shellapi.h"
#line 126 "d:\\msvc20\\include/windows.h"
#line 1 "d:\\msvc20\\include/winperf.h"



















































typedef struct _PERF_DATA_BLOCK {
    WCHAR           Signature[4];       
    DWORD           LittleEndian;       
    DWORD           Version;            
                                        
    DWORD           Revision;           
                                        
    DWORD           TotalByteLength;    
    DWORD           HeaderLength;       
    DWORD           NumObjectTypes;     
                                        
    LONG            DefaultObject;      
                                        
                                        
                                        
                                        
    SYSTEMTIME      SystemTime;         
                                        
    LARGE_INTEGER   PerfTime;           
                                        
    LARGE_INTEGER   PerfFreq;           
                                        
    LARGE_INTEGER   PerfTime100nSec;    
                                        
    DWORD           SystemNameLength;   
    DWORD           SystemNameOffset;   
                                        
                                        
} PERF_DATA_BLOCK, *PPERF_DATA_BLOCK;









typedef struct _PERF_OBJECT_TYPE {
    DWORD           TotalByteLength;    
                                        
                                        
                                        
                                        
                                        
                                        
                                        
    DWORD           DefinitionLength;   
                                        
                                        
                                        
                                        
                                        
                                        
                                        
    DWORD           HeaderLength;       
                                        
                                        
                                        
    DWORD           ObjectNameTitleIndex;
                                        
    LPWSTR          ObjectNameTitle;    
                                        
                                        
    DWORD           ObjectHelpTitleIndex;
                                        
    LPWSTR          ObjectHelpTitle;    
                                        
                                        
    DWORD           DetailLevel;        
                                        
                                        
                                        
    DWORD           NumCounters;        
                                        
                                        
    LONG            DefaultCounter;     
                                        
                                        
                                        
    LONG            NumInstances;       
                                        
                                        
                                        
                                        
                                        
                                        
                                        
                                        
                                        
                                        
                                        
    DWORD           CodePage;           
                                        
                                        
    LARGE_INTEGER   PerfTime;           
                                        
    LARGE_INTEGER   PerfFreq;           
                                        
} PERF_OBJECT_TYPE, *PPERF_OBJECT_TYPE;


























                                            





























































                     
                                                       



















































































































     






  








    












            








            






                                    























                                        



















typedef struct _PERF_COUNTER_DEFINITION {
    DWORD           ByteLength;         
    DWORD           CounterNameTitleIndex;
                                        
                                        
    LPWSTR          CounterNameTitle;   
                                        
                                        
    DWORD           CounterHelpTitleIndex;
                                        
                                        
    LPWSTR          CounterHelpTitle;   
                                        
                                        
    LONG            DefaultScale;       
                                        
                                        
    DWORD           DetailLevel;        
                                        
    DWORD           CounterType;        
    DWORD           CounterSize;        
    DWORD           CounterOffset;      
                                        
                                        
} PERF_COUNTER_DEFINITION, *PPERF_COUNTER_DEFINITION;














typedef struct _PERF_INSTANCE_DEFINITION {
    DWORD           ByteLength;         
                                        
    DWORD           ParentObjectTitleIndex;
                                        
                                        
                                        
                                        
                                        
    DWORD           ParentObjectInstance;
                                        
                                        
                                        
    LONG            UniqueID;           
                                        
                                        
    DWORD           NameOffset;         
                                        
                                        
    DWORD           NameLength;         

} PERF_INSTANCE_DEFINITION, *PPERF_INSTANCE_DEFINITION;













typedef struct _PERF_COUNTER_BLOCK {
    DWORD           ByteLength;         
                                        
} PERF_COUNTER_BLOCK, *PPERF_COUNTER_BLOCK;









typedef DWORD ( PM_OPEN_PROC) (LPWSTR);
typedef DWORD ( PM_COLLECT_PROC) (LPWSTR, LPVOID *, LPDWORD, LPDWORD);
typedef DWORD ( PM_CLOSE_PROC) (void);

#line 538 "d:\\msvc20\\include/winperf.h"


#line 127 "d:\\msvc20\\include/windows.h"
#line 1 "..\\..\\common/winsock.h"

















































































































































































































































































































































































































































































































































































































































































































































































































































































#line 128 "d:\\msvc20\\include/windows.h"










#line 139 "d:\\msvc20\\include/windows.h"






#line 1 "d:\\msvc20\\include/winsvc.h"










































#line 44 "d:\\msvc20\\include/winsvc.h"








































#line 85 "d:\\msvc20\\include/winsvc.h"



























































































typedef HANDLE      SC_HANDLE;
typedef SC_HANDLE   *LPSC_HANDLE;

typedef DWORD       SERVICE_STATUS_HANDLE;





typedef struct _SERVICE_STATUS {
    DWORD   dwServiceType;
    DWORD   dwCurrentState;
    DWORD   dwControlsAccepted;
    DWORD   dwWin32ExitCode;
    DWORD   dwServiceSpecificExitCode;
    DWORD   dwCheckPoint;
    DWORD   dwWaitHint;
} SERVICE_STATUS, *LPSERVICE_STATUS;







typedef struct _ENUM_SERVICE_STATUSA {
    LPSTR          lpServiceName;
    LPSTR          lpDisplayName;
    SERVICE_STATUS ServiceStatus;
} ENUM_SERVICE_STATUSA, *LPENUM_SERVICE_STATUSA;
typedef struct _ENUM_SERVICE_STATUSW {
    LPWSTR         lpServiceName;
    LPWSTR         lpDisplayName;
    SERVICE_STATUS ServiceStatus;
} ENUM_SERVICE_STATUSW, *LPENUM_SERVICE_STATUSW;




typedef ENUM_SERVICE_STATUSA ENUM_SERVICE_STATUS;
typedef LPENUM_SERVICE_STATUSA LPENUM_SERVICE_STATUS;
#line 218 "d:\\msvc20\\include/winsvc.h"






typedef LPVOID  SC_LOCK;

typedef struct _QUERY_SERVICE_LOCK_STATUSA {
    DWORD   fIsLocked;
    LPSTR   lpLockOwner;
    DWORD   dwLockDuration;
} QUERY_SERVICE_LOCK_STATUSA, *LPQUERY_SERVICE_LOCK_STATUSA;
typedef struct _QUERY_SERVICE_LOCK_STATUSW {
    DWORD   fIsLocked;
    LPWSTR  lpLockOwner;
    DWORD   dwLockDuration;
} QUERY_SERVICE_LOCK_STATUSW, *LPQUERY_SERVICE_LOCK_STATUSW;




typedef QUERY_SERVICE_LOCK_STATUSA QUERY_SERVICE_LOCK_STATUS;
typedef LPQUERY_SERVICE_LOCK_STATUSA LPQUERY_SERVICE_LOCK_STATUS;
#line 243 "d:\\msvc20\\include/winsvc.h"







typedef struct _QUERY_SERVICE_CONFIGA {
    DWORD   dwServiceType;
    DWORD   dwStartType;
    DWORD   dwErrorControl;
    LPSTR   lpBinaryPathName;
    LPSTR   lpLoadOrderGroup;
    DWORD   dwTagId;
    LPSTR   lpDependencies;
    LPSTR   lpServiceStartName;
    LPSTR   lpDisplayName;
} QUERY_SERVICE_CONFIGA, *LPQUERY_SERVICE_CONFIGA;
typedef struct _QUERY_SERVICE_CONFIGW {
    DWORD   dwServiceType;
    DWORD   dwStartType;
    DWORD   dwErrorControl;
    LPWSTR  lpBinaryPathName;
    LPWSTR  lpLoadOrderGroup;
    DWORD   dwTagId;
    LPWSTR  lpDependencies;
    LPWSTR  lpServiceStartName;
    LPWSTR  lpDisplayName;
} QUERY_SERVICE_CONFIGW, *LPQUERY_SERVICE_CONFIGW;




typedef QUERY_SERVICE_CONFIGA QUERY_SERVICE_CONFIG;
typedef LPQUERY_SERVICE_CONFIGA LPQUERY_SERVICE_CONFIG;
#line 279 "d:\\msvc20\\include/winsvc.h"







typedef void ( *LPSERVICE_MAIN_FUNCTIONW)(
    DWORD   dwNumServicesArgs,
    LPWSTR  *lpServiceArgVectors
    );

typedef void ( *LPSERVICE_MAIN_FUNCTIONA)(
    DWORD   dwNumServicesArgs,
    LPSTR   *lpServiceArgVectors
    );





#line 301 "d:\\msvc20\\include/winsvc.h"






typedef struct _SERVICE_TABLE_ENTRYA {
    LPSTR                       lpServiceName;
    LPSERVICE_MAIN_FUNCTIONA    lpServiceProc;
}SERVICE_TABLE_ENTRYA, *LPSERVICE_TABLE_ENTRYA;
typedef struct _SERVICE_TABLE_ENTRYW {
    LPWSTR                      lpServiceName;
    LPSERVICE_MAIN_FUNCTIONW    lpServiceProc;
}SERVICE_TABLE_ENTRYW, *LPSERVICE_TABLE_ENTRYW;




typedef SERVICE_TABLE_ENTRYA SERVICE_TABLE_ENTRY;
typedef LPSERVICE_TABLE_ENTRYA LPSERVICE_TABLE_ENTRY;
#line 322 "d:\\msvc20\\include/winsvc.h"





typedef void ( *LPHANDLER_FUNCTION)(
    DWORD    dwControl
    );








BOOL

ChangeServiceConfigA(
    SC_HANDLE    hService,
    DWORD        dwServiceType,
    DWORD        dwStartType,
    DWORD        dwErrorControl,
    LPCSTR     lpBinaryPathName,
    LPCSTR     lpLoadOrderGroup,
    LPDWORD      lpdwTagId,
    LPCSTR     lpDependencies,
    LPCSTR     lpServiceStartName,
    LPCSTR     lpPassword,
    LPCSTR     lpDisplayName
    );

BOOL

ChangeServiceConfigW(
    SC_HANDLE    hService,
    DWORD        dwServiceType,
    DWORD        dwStartType,
    DWORD        dwErrorControl,
    LPCWSTR     lpBinaryPathName,
    LPCWSTR     lpLoadOrderGroup,
    LPDWORD      lpdwTagId,
    LPCWSTR     lpDependencies,
    LPCWSTR     lpServiceStartName,
    LPCWSTR     lpPassword,
    LPCWSTR     lpDisplayName
    );




#line 374 "d:\\msvc20\\include/winsvc.h"


BOOL

CloseServiceHandle(
    SC_HANDLE   hSCObject
    );


BOOL

ControlService(
    SC_HANDLE           hService,
    DWORD               dwControl,
    LPSERVICE_STATUS    lpServiceStatus
    );


SC_HANDLE

CreateServiceA(
    SC_HANDLE    hSCManager,
    LPCSTR     lpServiceName,
    LPCSTR     lpDisplayName,
    DWORD        dwDesiredAccess,
    DWORD        dwServiceType,
    DWORD        dwStartType,
    DWORD        dwErrorControl,
    LPCSTR     lpBinaryPathName,
    LPCSTR     lpLoadOrderGroup,
    LPDWORD      lpdwTagId,
    LPCSTR     lpDependencies,
    LPCSTR     lpServiceStartName,
    LPCSTR     lpPassword
    );

SC_HANDLE

CreateServiceW(
    SC_HANDLE    hSCManager,
    LPCWSTR     lpServiceName,
    LPCWSTR     lpDisplayName,
    DWORD        dwDesiredAccess,
    DWORD        dwServiceType,
    DWORD        dwStartType,
    DWORD        dwErrorControl,
    LPCWSTR     lpBinaryPathName,
    LPCWSTR     lpLoadOrderGroup,
    LPDWORD      lpdwTagId,
    LPCWSTR     lpDependencies,
    LPCWSTR     lpServiceStartName,
    LPCWSTR     lpPassword
    );




#line 432 "d:\\msvc20\\include/winsvc.h"


BOOL

DeleteService(
    SC_HANDLE   hService
    );


BOOL

EnumDependentServicesA(
    SC_HANDLE               hService,
    DWORD                   dwServiceState,
    LPENUM_SERVICE_STATUSA  lpServices,
    DWORD                   cbBufSize,
    LPDWORD                 pcbBytesNeeded,
    LPDWORD                 lpServicesReturned
    );

BOOL

EnumDependentServicesW(
    SC_HANDLE               hService,
    DWORD                   dwServiceState,
    LPENUM_SERVICE_STATUSW  lpServices,
    DWORD                   cbBufSize,
    LPDWORD                 pcbBytesNeeded,
    LPDWORD                 lpServicesReturned
    );




#line 467 "d:\\msvc20\\include/winsvc.h"


BOOL

EnumServicesStatusA(
    SC_HANDLE               hSCManager,
    DWORD                   dwServiceType,
    DWORD                   dwServiceState,
    LPENUM_SERVICE_STATUSA  lpServices,
    DWORD                   cbBufSize,
    LPDWORD                 pcbBytesNeeded,
    LPDWORD                 lpServicesReturned,
    LPDWORD                 lpResumeHandle
    );

BOOL

EnumServicesStatusW(
    SC_HANDLE               hSCManager,
    DWORD                   dwServiceType,
    DWORD                   dwServiceState,
    LPENUM_SERVICE_STATUSW  lpServices,
    DWORD                   cbBufSize,
    LPDWORD                 pcbBytesNeeded,
    LPDWORD                 lpServicesReturned,
    LPDWORD                 lpResumeHandle
    );




#line 499 "d:\\msvc20\\include/winsvc.h"


BOOL

GetServiceKeyNameA(
    SC_HANDLE               hSCManager,
    LPCSTR                lpDisplayName,
    LPSTR                 lpServiceName,
    LPDWORD                 lpcchBuffer
    );

BOOL

GetServiceKeyNameW(
    SC_HANDLE               hSCManager,
    LPCWSTR                lpDisplayName,
    LPWSTR                 lpServiceName,
    LPDWORD                 lpcchBuffer
    );




#line 523 "d:\\msvc20\\include/winsvc.h"


BOOL

GetServiceDisplayNameA(
    SC_HANDLE               hSCManager,
    LPCSTR                lpServiceName,
    LPSTR                 lpDisplayName,
    LPDWORD                 lpcchBuffer
    );

BOOL

GetServiceDisplayNameW(
    SC_HANDLE               hSCManager,
    LPCWSTR                lpServiceName,
    LPWSTR                 lpDisplayName,
    LPDWORD                 lpcchBuffer
    );




#line 547 "d:\\msvc20\\include/winsvc.h"


SC_LOCK

LockServiceDatabase(
    SC_HANDLE   hSCManager
    );


BOOL

NotifyBootConfigStatus(
    BOOL     BootAcceptable
    );


SC_HANDLE

OpenSCManagerA(
    LPCSTR lpMachineName,
    LPCSTR lpDatabaseName,
    DWORD   dwDesiredAccess
    );

SC_HANDLE

OpenSCManagerW(
    LPCWSTR lpMachineName,
    LPCWSTR lpDatabaseName,
    DWORD   dwDesiredAccess
    );




#line 583 "d:\\msvc20\\include/winsvc.h"


SC_HANDLE

OpenServiceA(
    SC_HANDLE   hSCManager,
    LPCSTR    lpServiceName,
    DWORD       dwDesiredAccess
    );

SC_HANDLE

OpenServiceW(
    SC_HANDLE   hSCManager,
    LPCWSTR    lpServiceName,
    DWORD       dwDesiredAccess
    );




#line 605 "d:\\msvc20\\include/winsvc.h"


BOOL

QueryServiceConfigA(
    SC_HANDLE               hService,
    LPQUERY_SERVICE_CONFIGA lpServiceConfig,
    DWORD                   cbBufSize,
    LPDWORD                 pcbBytesNeeded
    );

BOOL

QueryServiceConfigW(
    SC_HANDLE               hService,
    LPQUERY_SERVICE_CONFIGW lpServiceConfig,
    DWORD                   cbBufSize,
    LPDWORD                 pcbBytesNeeded
    );




#line 629 "d:\\msvc20\\include/winsvc.h"


BOOL

QueryServiceLockStatusA(
    SC_HANDLE                       hSCManager,
    LPQUERY_SERVICE_LOCK_STATUSA    lpLockStatus,
    DWORD                           cbBufSize,
    LPDWORD                         pcbBytesNeeded
    );

BOOL

QueryServiceLockStatusW(
    SC_HANDLE                       hSCManager,
    LPQUERY_SERVICE_LOCK_STATUSW    lpLockStatus,
    DWORD                           cbBufSize,
    LPDWORD                         pcbBytesNeeded
    );




#line 653 "d:\\msvc20\\include/winsvc.h"


BOOL

QueryServiceObjectSecurity(
    SC_HANDLE               hService,
    SECURITY_INFORMATION    dwSecurityInformation,
    PSECURITY_DESCRIPTOR    lpSecurityDescriptor,
    DWORD                   cbBufSize,
    LPDWORD                 pcbBytesNeeded
    );


BOOL

QueryServiceStatus(
    SC_HANDLE           hService,
    LPSERVICE_STATUS    lpServiceStatus
    );


SERVICE_STATUS_HANDLE

RegisterServiceCtrlHandlerA(
    LPCSTR             lpServiceName,
    LPHANDLER_FUNCTION   lpHandlerProc
    );

SERVICE_STATUS_HANDLE

RegisterServiceCtrlHandlerW(
    LPCWSTR             lpServiceName,
    LPHANDLER_FUNCTION   lpHandlerProc
    );




#line 692 "d:\\msvc20\\include/winsvc.h"


BOOL

SetServiceObjectSecurity(
    SC_HANDLE               hService,
    SECURITY_INFORMATION    dwSecurityInformation,
    PSECURITY_DESCRIPTOR    lpSecurityDescriptor
    );


BOOL

SetServiceStatus(
    SERVICE_STATUS_HANDLE   hServiceStatus,
    LPSERVICE_STATUS        lpServiceStatus
    );


BOOL

StartServiceCtrlDispatcherA(
    LPSERVICE_TABLE_ENTRYA    lpServiceStartTable
    );

BOOL

StartServiceCtrlDispatcherW(
    LPSERVICE_TABLE_ENTRYW    lpServiceStartTable
    );




#line 727 "d:\\msvc20\\include/winsvc.h"



BOOL

StartServiceA(
    SC_HANDLE            hService,
    DWORD                dwNumServiceArgs,
    LPCSTR             *lpServiceArgVectors
    );

BOOL

StartServiceW(
    SC_HANDLE            hService,
    DWORD                dwNumServiceArgs,
    LPCWSTR             *lpServiceArgVectors
    );




#line 750 "d:\\msvc20\\include/winsvc.h"


BOOL

UnlockServiceDatabase(
    SC_LOCK     ScLock
    );






#line 764 "d:\\msvc20\\include/winsvc.h"
#line 146 "d:\\msvc20\\include/windows.h"
#line 147 "d:\\msvc20\\include/windows.h"







#line 155 "d:\\msvc20\\include/windows.h"
#line 32 "..\\..\\common/winsock.h"
#line 33 "..\\..\\common/winsock.h"




typedef unsigned char   u_char;
typedef unsigned short  u_short;
typedef unsigned int    u_int;
typedef unsigned long   u_long;





typedef u_int           SOCKET;











#line 59 "..\\..\\common/winsock.h"

typedef struct fd_set {
        u_short fd_count;               
        SOCKET  fd_array[64];   
} fd_set;





extern int   __WSAFDIsSet(SOCKET, fd_set  *);
































struct timeval {
        long    tv_sec;         
        long    tv_usec;        
};



























                                        
























struct  hostent {
        char     * h_name;           
        char     *  * h_aliases;  
        short   h_addrtype;             
        short   h_length;               
        char     *  * h_addr_list; 

};





struct  netent {
        char     * n_name;           
        char     *  * n_aliases;  
        short   n_addrtype;             
        u_long  n_net;                  
};

struct  servent {
        char     * s_name;           
        char     *  * s_aliases;  
        short   s_port;                 
        char     * s_proto;          
};

struct  protoent {
        char     * p_name;           
        char     *  * p_aliases;  
        short   p_proto;                
};




























































                                        

















struct in_addr {
        union {
                struct { u_char s_b1,s_b2,s_b3,s_b4; } S_un_b;
                struct { u_short s_w1,s_w2; } S_un_w;
                u_long S_addr;
        } S_un;

                                

                                

                                

                                

                                

                                
};































struct sockaddr_in {
        short   sin_family;
        u_short sin_port;
        struct  in_addr sin_addr;
        char    sin_zero[8];
};




typedef struct WSAData {
        WORD                    wVersion;
        WORD                    wHighVersion;
        char                    szDescription[256+1];
        char                    szSystemStatus[128+1];
        unsigned short          iMaxSockets;
        unsigned short          iMaxUdpDg;
        char  *              lpVendorInfo;
} WSADATA;

typedef WSADATA  *LPWSADATA;

























































































struct sockaddr {
        u_short sa_family;              
        char    sa_data[14];            
};





struct sockproto {
        u_short sp_family;              
        u_short sp_protocol;            
};





























struct  linger {
        u_short l_onoff;                
        u_short l_linger;               
};















































































































































































SOCKET   accept (SOCKET s, struct sockaddr  *addr,
                          int  *addrlen);

int   bind (SOCKET s, const struct sockaddr  *addr, int namelen);

int   closesocket (SOCKET s);

int   connect (SOCKET s, const struct sockaddr  *name, int namelen);

int   ioctlsocket (SOCKET s, long cmd, u_long  *argp);

int   getpeername (SOCKET s, struct sockaddr  *name,
                            int  * namelen);

int   getsockname (SOCKET s, struct sockaddr  *name,
                            int  * namelen);

int   getsockopt (SOCKET s, int level, int optname,
                           char  * optval, int  *optlen);

u_long   htonl (u_long hostlong);

u_short   htons (u_short hostshort);

unsigned long   inet_addr (const char  * cp);

char  *   inet_ntoa (struct in_addr in);

int   listen (SOCKET s, int backlog);

u_long   ntohl (u_long netlong);

u_short   ntohs (u_short netshort);

int   recv (SOCKET s, char  * buf, int len, int flags);

int   recvfrom (SOCKET s, char  * buf, int len, int flags,
                         struct sockaddr  *from, int  * fromlen);

int   select (int nfds, fd_set  *readfds, fd_set  *writefds,
                       fd_set  *exceptfds, const struct timeval  *timeout);

int   send (SOCKET s, const char  * buf, int len, int flags);

int   sendto (SOCKET s, const char  * buf, int len, int flags,
                       const struct sockaddr  *to, int tolen);

int   setsockopt (SOCKET s, int level, int optname,
                           const char  * optval, int optlen);

int   shutdown (SOCKET s, int how);

SOCKET   socket (int af, int type, int protocol);



struct hostent  *   gethostbyaddr(const char  * addr,
                                              int len, int type);

struct hostent  *   gethostbyname(const char  * name);

int   gethostname (char  * name, int namelen);

struct servent  *   getservbyport(int port, const char  * proto);

struct servent  *   getservbyname(const char  * name,
                                              const char  * proto);

struct protoent  *   getprotobynumber(int proto);

struct protoent  *   getprotobyname(const char  * name);



int   WSAStartup(WORD wVersionRequired, LPWSADATA lpWSAData);

int   WSACleanup(void);

void   WSASetLastError(int iError);

int   WSAGetLastError(void);

BOOL   WSAIsBlocking(void);

int   WSAUnhookBlockingHook(void);

FARPROC   WSASetBlockingHook(FARPROC lpBlockFunc);

int   WSACancelBlockingCall(void);

HANDLE   WSAAsyncGetServByName(HWND hWnd, u_int wMsg,
                                        const char  * name, 
                                        const char  * proto,
                                        char  * buf, int buflen);

HANDLE   WSAAsyncGetServByPort(HWND hWnd, u_int wMsg, int port,
                                        const char  * proto, char  * buf,
                                        int buflen);

HANDLE   WSAAsyncGetProtoByName(HWND hWnd, u_int wMsg,
                                         const char  * name, char  * buf,
                                         int buflen);

HANDLE   WSAAsyncGetProtoByNumber(HWND hWnd, u_int wMsg,
                                           int number, char  * buf,
                                           int buflen);

HANDLE   WSAAsyncGetHostByName(HWND hWnd, u_int wMsg,
                                        const char  * name, char  * buf,
                                        int buflen);

HANDLE   WSAAsyncGetHostByAddr(HWND hWnd, u_int wMsg,
                                        const char  * addr, int len, int type,
                                        char  * buf, int buflen);

int   WSACancelAsyncRequest(HANDLE hAsyncTaskHandle);

int   WSAAsyncSelect(SOCKET s, HWND hWnd, u_int wMsg,
                               long lEvent);






typedef struct sockaddr SOCKADDR;
typedef struct sockaddr *PSOCKADDR;
typedef struct sockaddr  *LPSOCKADDR;

typedef struct sockaddr_in SOCKADDR_IN;
typedef struct sockaddr_in *PSOCKADDR_IN;
typedef struct sockaddr_in  *LPSOCKADDR_IN;

typedef struct linger LINGER;
typedef struct linger *PLINGER;
typedef struct linger  *LPLINGER;

typedef struct in_addr IN_ADDR;
typedef struct in_addr *PIN_ADDR;
typedef struct in_addr  *LPIN_ADDR;

typedef struct fd_set FD_SET;
typedef struct fd_set *PFD_SET;
typedef struct fd_set  *LPFD_SET;

typedef struct hostent HOSTENT;
typedef struct hostent *PHOSTENT;
typedef struct hostent  *LPHOSTENT;

typedef struct servent SERVENT;
typedef struct servent *PSERVENT;
typedef struct servent  *LPSERVENT;

typedef struct protoent PROTOENT;
typedef struct protoent *PPROTOENT;
typedef struct protoent  *LPPROTOENT;

typedef struct timeval TIMEVAL;
typedef struct timeval *PTIMEVAL;
typedef struct timeval  *LPTIMEVAL;







































#line 849 "..\\..\\common/winsock.h"

#line 17 "..\\..\\common/errno.rc"

STRINGTABLE
BEGIN
  10000,         "[0] No Error"
  (10000+4),           "[10004] Interrupted system call"
  (10000+9),           "[10009] Bad file number"
  (10000+13),          "[10013] Permission denied"
  (10000+14),          "[10014] Bad address"
  (10000+22),          "[10022] Invalid argument"
  (10000+24),          "[10024] Too many open files"
  (10000+35),     "[10035] Operation would block"
  (10000+36),     "[10036] Operation now in progress"
  (10000+37),        "[10037] Operation already in progress"
  (10000+38),        "[10038] Socket operation on non-socket"
  (10000+39),    "[10039] Destination address required"
  (10000+40),        "[10040] Message too long"
  (10000+41),      "[10041] Protocol wrong type for socket"
  (10000+42),     "[10042] Bad protocol option"
  (10000+43), "[10043] Protocol not supported"
  (10000+44), "[10044] Socket type not supported"
  (10000+45),      "[10045] Operation not supported on socket"
  (10000+46),    "[10046] Protocol family not supported"
  (10000+47),    "[10047] Address family not supported by protocol family"
  (10000+48),      "[10048] Address already in use"
  (10000+49),   "[10049] Can't assign requested address"
  (10000+50),        "[10050] Network is down"
  (10000+51),     "[10051] Network is unreachable"
  (10000+52),       "[10052] Net dropped connection or reset"
  (10000+53),    "[10053] Software caused connection abort"
  (10000+54),      "[10054] Connection reset by peer"
  (10000+55),         "[10055] No buffer space available"
  (10000+56),         "[10056] Socket is already connected"
  (10000+57),        "[10057] Socket is not connected"
  (10000+58),       "[10058] Can't send after socket shutdown"
  (10000+59),    "[10059] Too many references, can't splice"
  (10000+60),       "[10060] Connection timed out"
  (10000+61),    "[10061] Connection refused"
  (10000+62),           "[10062] Too many levels of symbolic links"
  (10000+63),    "[10063] File name too long"
  (10000+64),       "[10064] Host is down"
  (10000+65),    "[10065] No Route to Host"
  (10000+66),       "[10066] Directory not empty"
  (10000+67),        "[10067] Too many processes"
  (10000+68),          "[10068] Too many users"
  (10000+69),          "[10069] Disc Quota Exceeded"
  (10000+70),          "[10070] Stale NFS file handle"
  (10000+71),         "[10071] Too many levels of remote in path"
  (10000+91),     "[10091] Network SubSystem is unavailable"
  (10000+92), "[10092] WINSOCK DLL Version out of range"
  (10000+93),  "[10093] Successful WSASTARTUP not yet performed"
  (10000+1001),  "[11001] Host not found"
  (10000+1002),       "[11002] Non-Authoritative Host not found"
  (10000+1003),     "[11003] Non-Recoverable errors: FORMERR, REFUSED, NOTIMP"
  (10000+1004),         "[11004] Valid name, no data record of requested type"
END
#line 7 "C:\\SOURCE\\NEWSCLI\\NEWSCLI.RC"
FRAMEMENU MENU 
{
POPUP "&File"
{
MENUITEM "&Open Group", 12
MENUITEM "&Close", 13
MENUITEM SEPARATOR
MENUITEM "E&xit", 11
}
#line 17 "C:\\SOURCE\\NEWSCLI\\NEWSCLI.RC"
POPUP "&News"
{
MENUITEM "&Configure...", 30
}
#line 22 "C:\\SOURCE\\NEWSCLI\\NEWSCLI.RC"
POPUP "&Window"
{
MENUITEM "&Cascade\tShift+F5", 40
MENUITEM "&Tile\tShift+F4", 41
MENUITEM "Arrange &Icons", 42
MENUITEM "Close &All", 43
}
#line 30 "C:\\SOURCE\\NEWSCLI\\NEWSCLI.RC"
POPUP "&Help"
{
MENUITEM "&About...", 50
}
#line 35 "C:\\SOURCE\\NEWSCLI\\NEWSCLI.RC"
}
NEWSCLI ACCELERATORS 
{
"^Z", 20, ASCII
"^X", 21, ASCII
"^C", 22, ASCII
"^V", 23, ASCII
0x74, 40, VIRTKEY, SHIFT
0x73, 41, VIRTKEY, SHIFT
}
#line 48 "C:\\SOURCE\\NEWSCLI\\NEWSCLI.RC"
GROUPMENU MENU 
{
POPUP "&File"
{
MENUITEM "&Open Group", 12
MENUITEM "&Close", 13
MENUITEM SEPARATOR
MENUITEM "E&xit", 11
}
#line 58 "C:\\SOURCE\\NEWSCLI\\NEWSCLI.RC"
POPUP "&News"
{
MENUITEM "&View Article", 101
MENUITEM SEPARATOR
MENUITEM "&Configure...", 30
}
#line 65 "C:\\SOURCE\\NEWSCLI\\NEWSCLI.RC"
POPUP "&Window"
{
MENUITEM "&Cascade\tShift+F5", 40
MENUITEM "&Tile\tShift+F4", 41
MENUITEM "Arrange &Icons", 42
MENUITEM "Close &All", 43
}
#line 73 "C:\\SOURCE\\NEWSCLI\\NEWSCLI.RC"
POPUP "&Help"
{
MENUITEM "&About...", 50
}
#line 78 "C:\\SOURCE\\NEWSCLI\\NEWSCLI.RC"
}
#line 80 "C:\\SOURCE\\NEWSCLI\\NEWSCLI.RC"
ARTICLEMENU MENU 
{
POPUP "&File"
{
MENUITEM "&Open Group", 12
MENUITEM "&Close", 13
MENUITEM SEPARATOR
MENUITEM "E&xit", 11
}
#line 90 "C:\\SOURCE\\NEWSCLI\\NEWSCLI.RC"
POPUP "&Edit"
{
MENUITEM "&Copy\tCtrl+C", 22
}
#line 95 "C:\\SOURCE\\NEWSCLI\\NEWSCLI.RC"
POPUP "&News"
{
MENUITEM "&Configure...", 30
}
#line 100 "C:\\SOURCE\\NEWSCLI\\NEWSCLI.RC"
POPUP "&Window"
{
MENUITEM "&Cascade\tShift+F5", 40
MENUITEM "&Tile\tShift+F4", 41
MENUITEM "Arrange &Icons", 42
MENUITEM "Close &All", 43
}
#line 108 "C:\\SOURCE\\NEWSCLI\\NEWSCLI.RC"
POPUP "&Help"
{
MENUITEM "&About...", 50
}
#line 113 "C:\\SOURCE\\NEWSCLI\\NEWSCLI.RC"
}
#line 116 "C:\\SOURCE\\NEWSCLI\\NEWSCLI.RC"
CONFIGURE DIALOG 6, 15, 207, 49
STYLE 0x80L | 0x80000000L | 0x10000000L | 0x00C00000L | 0x00080000L
CAPTION "Configure"
FONT 8, "MS Sans Serif"
{
DEFPUSHBUTTON "OK", 1, 148, 6, 50, 14
PUSHBUTTON "Cancel", 2, 148, 24, 50, 14
LTEXT "NNTP Server", -1, 12, 10, 48, 8
LTEXT "NNTP Port", -1, 12, 31, 48, 8
EDITTEXT 101, 59, 8, 72, 12
EDITTEXT 102, 59, 29, 28, 12
PUSHBUTTON "Default", 103, 92, 28, 40, 14
}
#line 131 "C:\\SOURCE\\NEWSCLI\\NEWSCLI.RC"
GROUP DIALOG 6, 15, 207, 46
STYLE 0x80L | 0x80000000L | 0x10000000L | 0x00C00000L | 0x00080000L
CAPTION "Open Group"
FONT 8, "MS Sans Serif"
{
DEFPUSHBUTTON "OK", 1, 148, 6, 50, 14
PUSHBUTTON "Cancel", 2, 148, 24, 50, 14
LTEXT "Group:", -1, 8, 8, 24, 8
EDITTEXT 101, 8, 20, 128, 12
}
#line 143 "C:\\SOURCE\\NEWSCLI\\NEWSCLI.RC"
APPICON ICON "newscli.ico"
#line 146 "C:\\SOURCE\\NEWSCLI\\NEWSCLI.RC"
GROUPICON ICON "newsgrp.ico"
#line 149 "C:\\SOURCE\\NEWSCLI\\NEWSCLI.RC"
ARTICLEICON ICON "newsart.ico"
