turborex 0.1.1

data/resources/headers/rpc/rpcndr.h

@@ -0,0 +1,39 @@
+#include <rpcdcep.h>
+typedef struct _COMM_FAULT_OFFSETS
+    {
+    short       CommOffset;
+    short       FaultOffset;
+    } COMM_FAULT_OFFSETS;
+
+typedef const unsigned char  * PFORMAT_STRING;
+
+typedef struct _MIDL_METHOD_PROPERTY
+{
+    unsigned long                       Id;
+    ULONG_PTR                           Value;
+} MIDL_METHOD_PROPERTY, *PMIDL_METHOD_PROPERTY;
+
+typedef struct _MIDL_METHOD_PROPERTY_MAP
+{
+    unsigned long                       Count;
+    const MIDL_METHOD_PROPERTY         *Properties;
+} MIDL_METHOD_PROPERTY_MAP, *PMIDL_METHOD_PROPERTY_MAP;
+
+typedef struct _MIDL_INTERFACE_METHOD_PROPERTIES
+{
+    unsigned short MethodCount;
+    const MIDL_METHOD_PROPERTY_MAP* const *MethodProperties;
+} MIDL_INTERFACE_METHOD_PROPERTIES;
+
+typedef struct _MIDL_SYNTAX_INFO
+{
+RPC_SYNTAX_IDENTIFIER               TransferSyntax;
+RPC_DISPATCH_TABLE *                DispatchTable;
+PFORMAT_STRING                      ProcString;
+const unsigned short *              FmtStringOffset;
+PFORMAT_STRING                      TypeString;
+const void           *              aUserMarshalQuadruple;
+const MIDL_INTERFACE_METHOD_PROPERTIES *pMethodProperties;
+ULONG_PTR                           pReserved2;
+} MIDL_SYNTAX_INFO, *PMIDL_SYNTAX_INFO;
+

data/resources/headers/rpc/v4_x64/rpcinternals.h

@@ -0,0 +1,154 @@
+#include "../common.h"
+// From RpcView
+static UINT64 RPC_CORE_RUNTIME_VERSION[] = {
+	0x6000324D70000LL,  //6.3.9431.0000
+	0x6000325804000LL,  //6.3.9600.16384
+	0x6000325804340LL,  //6.3.9600.17216
+	0x6000325804407LL,  //6.3.9600.17415
+	0x60003258045FFLL,  //6.3.9600.17919
+	0x6000325804774LL,  //6.3.9600.18292
+	0x6000325804AE8LL,  //6.3.9600.19176
+	0xA000028004000LL,  //10.0.10240.16384
+	0xA00002800401CLL,  //10.0.10240.16412
+	0xA0000280041C9LL,  //10.0.10240.16841
+	0xA0000295A0000LL,  //10.0.10586.0
+	0xA0000295A0132LL,  //10.0.10586.306
+	0xA0000295A0498LL,  //10.0.10586.1176
+	0xA0000380603E8LL,  //10.0.14342.1000
+	0xA000038190000LL,  //10.0.14361.0
+	0xA000038390000LL,  //10.0.14393.0
+	0xA000038390052LL,  //10.0.14393.82
+	0xA0000383906EALL,  //10.0.14393.1770
+	0xA000038390908LL,  //10.0.14393.2312
+	0xA000038390A69LL,  //10.0.14393.2665
+	0xA000038390C2BLL,  //10.0.14393.3115
+	0xA00003AD70000LL,  //10.0.15063.0
+	0xA00003AD701BFLL,  //10.0.15063.447
+	0xA00003AD702A2LL,  //10.0.15063.674
+	0xA00003F6803E8LL,  //10.0.16232.1000
+	0xA00003FAB000FLL,  //10.0.16299.15
+	0xA00003FAB00C0LL,  //10.0.16299.192
+	0xA00003FAB0135LL,  //10.0.16299.309
+	0xA00003FAB0173LL,  //10.0.16299.371
+	0xA00003FAB01ECLL,  //10.0.16299.492
+	0xA00003FAB02D6LL,  //10.0.16299.726
+	0xA00003FAB034ELL,  //10.0.16299.846
+	0xA0000427903E8LL,  //10.0.17017.1000
+	0xA0000428103E8LL,  //10.0.17025.1000
+	0xA000042B203EALL,  //10.0.17074.1002
+	0xA000042EE0001LL,  //10.0.17134.1
+	0xA000042EE0030LL,  //10.0.17134.48
+	0xA000042EE0070LL,  //10.0.17134.112
+	0xA000042EE00E4LL,  //10.0.17134.228
+	0xA000042EE0197LL,  //10.0.17134.407
+	0xA000042EE01D7LL,  //10.0.17134.471
+	0xA000042EE0288LL,  //10.0.17134.648
+	0xA000045630001LL,  //10.0.17763.1
+	0xA000045630086LL,  //10.0.17763.134
+	0xA0000456300C2LL,  //10.0.17763.194
+	0xA00004563017BLL,  //10.0.17763.379
+	0xA0000456302CFLL,  //10.0.17763.719
+	0xA000047BA0001LL,  //10.0.18362.1
+	0xA000047BA01DCLL   //10.0.18362.476
+};
+
+#define ULONG_PTR_T ULONG_PTR
+#define PTR_T *
+
+#pragma pack(1)
+typedef struct _RPC_SERVER_T{
+  MUTEX_T						Mutex;
+  ULONG							__bIslistening;
+  ULONG							bIsListening;
+  ULONG							MinimumCallThreads;
+  ULONG							Wait;
+  ULONG							OutCalls;
+  ULONG							Unk1;
+  ULONG							InCalls;
+  ULONG							Unk2;
+  SIMPLE_DICT_T					AddressDict;
+  ULONG							lAvailableCalls;
+  ULONG							Unk3;
+  SIMPLE_DICT_T					_ProtSeqQueue;
+  ULONG							Unk4[8];
+  ULONG							OutPackets;
+  ULONG							Unk5;
+  MUTEX_T						Mutex2;
+  ULONG							MaxCalls;
+  ULONG							Unk6;
+  VOID PTR_T					hEvent;
+  ULONG							Unk7[4];
+  SIMPLE_DICT_T					InterfaceDict;
+  ULONG							_bIsListening;
+  ULONG							bIsMaxCalls1234;
+  ULONG							Unk8[6];
+  ULONG							InPackets;
+  ULONG							Unk9;
+  RPC_FORWARD_FUNCTION PTR_T	pRpcForwardFunction;
+  ULONG							Unk10[6];
+  SIMPLE_DICT_T					AuthenInfoDict;
+  LIST_ENTRY_T					RpcIfGroupListEntry;
+  ULONG	PTR_T					__SRWLock;
+  LIST_ENTRY_T					field_1E0;
+}RPC_SERVER_T, PTR_T PRPC_SERVER_T;
+
+typedef struct _RPC_INTERFACE_T
+{
+  PRPC_SERVER_T				pRpcServer;
+  ULONG						Flags;
+  ULONG						Unk1;
+  MUTEX_T					Mutex;
+  ULONG						EpMapperFlags;
+  ULONG						Unk2;
+  RPC_MGR_EPV PTR_T			pMgrEpv;
+  RPC_IF_CALLBACK_FN PTR_T	IfCallbackFn;
+  RPC_SERVER_INTERFACE_T	RpcServerInterface;
+  PMIDL_SYNTAX_INFO			pSyntaxInfo;
+  VOID PTR_T				pTransfertSyntaxes;
+  ULONG						TransfertSyntaxesCount;
+  ULONG						__Field_C4;
+  ULONG						NbTypeManager;
+  ULONG						MaxRpcSize;
+  UUID_VECTOR  PTR_T		pUuidVector;
+  SIMPLE_DICT_T				RpcInterfaceManagerDict;
+  UCHAR						Annotation[MAX_RPC_INTERFACE_ANNOTATION];
+  ULONG						IsCallSizeLimitReached;
+  ULONG						currentNullManagerCalls;
+  ULONG						__Field_150;
+  ULONG						__Field_154;
+  ULONG						__Field_158;
+  ULONG						SecurityCallbackInProgress;
+  ULONG						SecurityCacheEntry;
+  ULONG						field_164;
+  VOID PTR_T				__SecurityCacheEntries[16];
+  SIMPLE_DICT_T				FwEpDict;
+  ULONG						Unk3[6];
+  struct RPCP_INTERFACE_GROUP PTR_T pRpcpInterfaceGroup;
+}RPC_INTERFACE_T, PTR_T PRPC_INTERFACE_T;
+ 
+#define RPC_ADDRESS_TYPE_DG		0x400000
+#define RPC_ADDRESS_TYPE_LRPC	0x800000
+#define RPC_ADDRESS_TYPE_OSF	0x800
+
+typedef struct _RPC_ADDRESS_T{
+	VOID PTR_T				pVtable;
+	ULONG					Magic;
+	ULONG					TypeOfAddress;
+	ULONG					ReferenceCounter;
+	ULONG					Unk1[3];
+	WCHAR PTR_T				Name;
+	WCHAR PTR_T				Protocole;
+	WCHAR PTR_T				Address;
+	ULONG					bNamed;
+	ULONG					EpAddAddressFlag;
+	SIMPLE_DICT_T			__LRPCSassociationSimpleDict;
+	ULONG					__Field_68;
+	ULONG					Unk3;
+	ULONG					NbActiveCalls;
+	ULONG					__Field_74;
+	ULONG					Unk4[6];
+	ULONG					__Field_90;
+	MUTEX_T					Mutex;
+}RPC_ADDRESS_T;
+
+#pragma pack()

data/resources/headers/rpc/wintype.h

@@ -0,0 +1,517 @@
+#define WINAPI_FAMILY_PARTITION(Partitions)     (Partitions)
+
+#define PTR_T *
+#if defined(_WIN64)
+ typedef unsigned __int64 ULONG_PTR;
+#else
+ typedef unsigned long ULONG_PTR;
+#endif
+
+typedef ULONG_PTR ULONG_PTR_T;
+// ==============================
+// from winnt.h
+
+typedef unsigned short WCHAR;    // wc,   16-bit UNICODE character
+
+
+#ifndef VOID
+#define VOID void
+typedef char CHAR;
+typedef short SHORT;
+typedef long LONG;
+#if !defined(MIDL_PASS)
+typedef int INT;
+#endif
+#endif
+
+
+// ==============================
+// from minwindef.h
+
+#define far
+#define near
+#define CONST               const
+
+
+typedef unsigned long ULONG;
+typedef ULONG *PULONG;
+typedef unsigned short USHORT;
+typedef USHORT *PUSHORT;
+typedef unsigned char UCHAR;
+typedef UCHAR *PUCHAR;
+
+#define FAR                 far
+#define NEAR                near
+
+#define CALLBACK    __stdcall
+#define WINAPI      __stdcall
+#define WINAPIV     __cdecl
+#define APIENTRY    WINAPI
+#define APIPRIVATE  __stdcall
+#define PASCAL      __stdcall
+
+typedef unsigned long       DWORD;
+typedef int                 BOOL;
+typedef unsigned char       BYTE;
+typedef unsigned short      WORD;
+typedef float               FLOAT;
+typedef FLOAT               *PFLOAT;
+typedef BOOL near           *PBOOL;
+typedef BOOL far            *LPBOOL;
+typedef BYTE near           *PBYTE;
+typedef BYTE far            *LPBYTE;
+typedef int near            *PINT;
+typedef int far             *LPINT;
+typedef WORD near           *PWORD;
+typedef WORD far            *LPWORD;
+typedef long far            *LPLONG;
+typedef DWORD near          *PDWORD;
+typedef DWORD far           *LPDWORD;
+typedef void far            *LPVOID;
+typedef CONST void far      *LPCVOID;
+
+typedef int                 INT;
+typedef unsigned int        UINT;
+typedef unsigned int        *PUINT;
+
+// ==============================
+// from basetsd.h
+
+
+#ifndef _BASETSD_H_
+#define _BASETSD_H_
+
+#if _MSC_VER >= 1200
+#pragma warning(push)
+#pragma warning(disable:4668) 
+#endif
+
+#if !defined(_MAC) && (defined(_M_MRX000) || defined(_WIN64)) && (_MSC_VER >= 1100) && !(defined(MIDL_PASS) || defined(RC_INVOKED))
+ #define POINTER_64 __ptr64
+ typedef unsigned __int64 POINTER_64_INT;
+ #if defined(_WIN64)
+  #define POINTER_32 __ptr32
+ #else
+  #define POINTER_32
+ #endif
+#else
+ #if defined(_MAC) && defined(_MAC_INT_64)
+  #define POINTER_64 __ptr64
+  typedef unsigned __int64 POINTER_64_INT;
+ #else
+  #if (_MSC_VER >= 1300) && !(defined(MIDL_PASS) || defined(RC_INVOKED))
+   #define POINTER_64 __ptr64
+  #else
+   #define POINTER_64
+  #endif
+  typedef unsigned long POINTER_64_INT;
+ #endif
+ #define POINTER_32
+#endif
+
+#if defined(_WIN64)
+#define FIRMWARE_PTR
+#else
+#define FIRMWARE_PTR POINTER_32
+#endif
+
+#if (_MSC_FULL_VER >= 140041204) && !defined(MIDL_PASS) && !defined(RC_INVOKED)
+#define POINTER_SIGNED __sptr
+#define POINTER_UNSIGNED __uptr
+#else
+#define POINTER_SIGNED
+#define POINTER_UNSIGNED
+#endif
+
+#define SPOINTER_32 POINTER_SIGNED POINTER_32
+#define UPOINTER_32 POINTER_UNSIGNED POINTER_32
+
+#if _MSC_VER > 1000
+#pragma once
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef signed char         INT8, *PINT8;
+typedef signed short        INT16, *PINT16;
+typedef signed int          INT32, *PINT32;
+typedef signed __int64      INT64, *PINT64;
+typedef unsigned char       UINT8, *PUINT8;
+typedef unsigned short      UINT16, *PUINT16;
+typedef unsigned int        UINT32, *PUINT32;
+typedef unsigned __int64    UINT64, *PUINT64;
+
+typedef signed int LONG32, *PLONG32;
+
+
+typedef unsigned int ULONG32, *PULONG32;
+typedef unsigned int DWORD32, *PDWORD32;
+
+#if !defined(_W64)
+#if !defined(__midl) && (defined(_X86_) || defined(_M_IX86) || defined(_ARM_) || defined(_M_ARM)) && _MSC_VER >= 1300
+#define _W64 __w64
+#else
+#define _W64
+#endif
+#endif
+
+#if ( defined(__midl) && (501 < __midl) )
+
+    typedef [public] __int3264 INT_PTR, *PINT_PTR;
+    typedef [public] unsigned __int3264 UINT_PTR, *PUINT_PTR;
+
+    typedef [public] __int3264 LONG_PTR, *PLONG_PTR;
+    typedef [public] unsigned __int3264 ULONG_PTR, *PULONG_PTR;
+
+#else  
+
+#if defined(_WIN64)
+    typedef __int64 INT_PTR, *PINT_PTR;
+    typedef unsigned __int64 UINT_PTR, *PUINT_PTR;
+
+    typedef __int64 LONG_PTR, *PLONG_PTR;
+    typedef unsigned __int64 ULONG_PTR, *PULONG_PTR;
+
+    #define __int3264   __int64
+
+#else
+    typedef _W64 int INT_PTR, *PINT_PTR;
+    typedef _W64 unsigned int UINT_PTR, *PUINT_PTR;
+
+    typedef _W64 long LONG_PTR, *PLONG_PTR;
+    typedef _W64 unsigned long ULONG_PTR, *PULONG_PTR;
+
+    #define __int3264   __int32
+
+#endif
+#endif
+
+
+#ifdef _WIN64
+
+#define ADDRESS_TAG_BIT 0x40000000000UI64
+
+typedef __int64 SHANDLE_PTR;
+typedef unsigned __int64 HANDLE_PTR;
+typedef unsigned int UHALF_PTR, *PUHALF_PTR;
+typedef int HALF_PTR, *PHALF_PTR;
+
+#if !defined(__midl)
+__inline
+unsigned long
+HandleToULong(
+    const void *h
+    )
+{
+    return((unsigned long) (ULONG_PTR) h );
+}
+
+__inline
+long
+HandleToLong(
+    const void *h
+    )
+{
+    return((long) (LONG_PTR) h );
+}
+
+__inline
+void *
+ULongToHandle(
+    const unsigned long h
+    )
+{
+    return((void *) (UINT_PTR) h );
+}
+
+
+__inline
+void *
+LongToHandle(
+    const long h
+    )
+{
+    return((void *) (INT_PTR) h );
+}
+
+
+__inline
+unsigned long
+PtrToUlong(
+    const void  *p
+    )
+{
+    return((unsigned long) (ULONG_PTR) p );
+}
+
+__inline
+unsigned int
+PtrToUint(
+    const void  *p
+    )
+{
+    return((unsigned int) (UINT_PTR) p );
+}
+
+__inline
+unsigned short
+PtrToUshort(
+    const void  *p
+    )
+{
+    return((unsigned short) (unsigned long) (ULONG_PTR) p );
+}
+
+__inline
+long
+PtrToLong(
+    const void  *p
+    )
+{
+    return((long) (LONG_PTR) p );
+}
+
+__inline
+int
+PtrToInt(
+    const void  *p
+    )
+{
+    return((int) (INT_PTR) p );
+}
+
+__inline
+short
+PtrToShort(
+    const void  *p
+    )
+{
+    return((short) (long) (LONG_PTR) p );
+}
+
+__inline
+void *
+IntToPtr(
+    const int i
+    )
+{
+    return( (void *)(INT_PTR)i );
+}
+
+__inline
+void *
+UIntToPtr(
+    const unsigned int ui
+    )
+{
+    return( (void *)(UINT_PTR)ui );
+}
+
+__inline
+void *
+LongToPtr(
+    const long l
+    )
+{
+    return( (void *)(LONG_PTR)l );
+}
+
+__inline
+void *
+ULongToPtr(
+    const unsigned long ul
+    )
+{
+    return( (void *)(ULONG_PTR)ul );
+}
+
+#define PtrToPtr64( p )         ((void * POINTER_64) p)
+#define Ptr64ToPtr( p )         ((void *) p)
+#define HandleToHandle64( h )   (PtrToPtr64( h ))
+#define Handle64ToHandle( h )   (Ptr64ToPtr( h ))
+
+__inline
+void *
+Ptr32ToPtr(
+    const void * POINTER_32 p
+    )
+{
+    return((void *) (ULONG_PTR) (unsigned long) p);
+}
+
+__inline
+void *
+Handle32ToHandle(
+    const void * POINTER_32 h
+    )
+{
+    return((void *) (LONG_PTR) (long) h);
+}
+
+__inline
+void * POINTER_32
+PtrToPtr32(
+    const void *p
+    )
+{
+    return((void * POINTER_32) (unsigned long) (ULONG_PTR) p);
+}
+
+#define HandleToHandle32( h )       (PtrToPtr32( h ))
+
+#endif 
+
+#else  
+
+#define ADDRESS_TAG_BIT 0x80000000UL
+
+typedef unsigned short UHALF_PTR, *PUHALF_PTR;
+typedef short HALF_PTR, *PHALF_PTR;
+typedef _W64 long SHANDLE_PTR;
+typedef _W64 unsigned long HANDLE_PTR;
+
+#define HandleToULong( h ) ((ULONG)(ULONG_PTR)(h) )
+#define HandleToLong( h )  ((LONG)(LONG_PTR) (h) )
+#define ULongToHandle( ul ) ((HANDLE)(ULONG_PTR) (ul) )
+#define LongToHandle( h )   ((HANDLE)(LONG_PTR) (h) )
+#define PtrToUlong( p ) ((ULONG)(ULONG_PTR) (p) )
+#define PtrToLong( p )  ((LONG)(LONG_PTR) (p) )
+#define PtrToUint( p ) ((UINT)(UINT_PTR) (p) )
+#define PtrToInt( p )  ((INT)(INT_PTR) (p) )
+#define PtrToUshort( p ) ((unsigned short)(ULONG_PTR)(p) )
+#define PtrToShort( p )  ((short)(LONG_PTR)(p) )
+#define IntToPtr( i )    ((VOID *)(INT_PTR)((int)i))
+#define UIntToPtr( ui )  ((VOID *)(UINT_PTR)((unsigned int)ui))
+#define LongToPtr( l )   ((VOID *)(LONG_PTR)((long)l))
+#define ULongToPtr( ul ) ((VOID *)(ULONG_PTR)((unsigned long)ul))
+
+#if !defined(__midl)
+__inline
+void * POINTER_64
+PtrToPtr64(
+    const void *p
+    )
+{
+    return((void * POINTER_64) (unsigned __int64) (ULONG_PTR)p );
+}
+
+__inline
+void *
+Ptr64ToPtr(
+    const void * POINTER_64 p
+    )
+{
+    return((void *) (ULONG_PTR) (unsigned __int64) p);
+}
+
+__inline
+void * POINTER_64
+HandleToHandle64(
+    const void *h
+    )
+{
+    return((void * POINTER_64)(__int64)(LONG_PTR)h );
+}
+
+__inline
+void *
+Handle64ToHandle(
+    const void * POINTER_64 h
+    )
+{
+    return((void *) (ULONG_PTR) (unsigned __int64) h );
+}
+#endif
+
+#define Ptr32ToPtr( p )         ((void *) p)
+#define Handle32ToHandle( h )   (Ptr32ToPtr( h ))
+#define PtrToPtr32( p )         ((void * POINTER_32) p)
+#define HandleToHandle32( h )   (PtrToPtr32( h ))
+
+#endif // !_WIN64
+
+#define HandleToUlong(h)  HandleToULong(h)
+#define UlongToHandle(ul) ULongToHandle(ul)
+#define UlongToPtr(ul) ULongToPtr(ul)
+#define UintToPtr(ui)  UIntToPtr(ui)
+
+#define MAXUINT_PTR  (~((UINT_PTR)0))
+#define MAXINT_PTR   ((INT_PTR)(MAXUINT_PTR >> 1))
+#define MININT_PTR   (~MAXINT_PTR)
+
+#define MAXULONG_PTR (~((ULONG_PTR)0))
+#define MAXLONG_PTR  ((LONG_PTR)(MAXULONG_PTR >> 1))
+#define MINLONG_PTR  (~MAXLONG_PTR)
+
+#define MAXUHALF_PTR ((UHALF_PTR)~0)
+#define MAXHALF_PTR  ((HALF_PTR)(MAXUHALF_PTR >> 1))
+#define MINHALF_PTR  (~MAXHALF_PTR)
+
+
+typedef ULONG_PTR SIZE_T, *PSIZE_T;
+typedef LONG_PTR SSIZE_T, *PSSIZE_T;
+
+#if _WIN32_WINNT >= 0x0600 || (defined(__cplusplus) && defined(WINDOWS_ENABLE_CPLUSPLUS))
+
+#define MAXUINT8    ((UINT8)~((UINT8)0))
+#define MAXINT8     ((INT8)(MAXUINT8 >> 1))
+#define MININT8     ((INT8)~MAXINT8)
+
+#define MAXUINT16   ((UINT16)~((UINT16)0))
+#define MAXINT16    ((INT16)(MAXUINT16 >> 1))
+#define MININT16    ((INT16)~MAXINT16)
+
+#define MAXUINT32   ((UINT32)~((UINT32)0))
+#define MAXINT32    ((INT32)(MAXUINT32 >> 1))
+#define MININT32    ((INT32)~MAXINT32)
+
+#define MAXUINT64   ((UINT64)~((UINT64)0))
+#define MAXINT64    ((INT64)(MAXUINT64 >> 1))
+#define MININT64    ((INT64)~MAXINT64)
+
+#define MAXULONG32  ((ULONG32)~((ULONG32)0))
+#define MAXLONG32   ((LONG32)(MAXULONG32 >> 1))
+#define MINLONG32   ((LONG32)~MAXLONG32)
+
+#define MAXULONG64  ((ULONG64)~((ULONG64)0))
+#define MAXLONG64   ((LONG64)(MAXULONG64 >> 1))
+#define MINLONG64   ((LONG64)~MAXLONG64)
+
+#define MAXULONGLONG ((ULONGLONG)~((ULONGLONG)0))
+#define MINLONGLONG ((LONGLONG)~MAXLONGLONG)
+
+#define MAXSIZE_T   ((SIZE_T)~((SIZE_T)0))
+#define MAXSSIZE_T  ((SSIZE_T)(MAXSIZE_T >> 1))
+#define MINSSIZE_T  ((SSIZE_T)~MAXSSIZE_T)
+
+#define MAXUINT     ((UINT)~((UINT)0))
+#define MAXINT      ((INT)(MAXUINT >> 1))
+#define MININT      ((INT)~MAXINT)
+
+#define MAXDWORD32  ((DWORD32)~((DWORD32)0))
+#define MAXDWORD64  ((DWORD64)~((DWORD64)0))
+
+#endif 
+
+typedef ULONG_PTR DWORD_PTR, *PDWORD_PTR;
+
+typedef __int64 LONG64, *PLONG64;
+
+typedef unsigned __int64 ULONG64, *PULONG64;
+typedef unsigned __int64 DWORD64, *PDWORD64;
+
+typedef ULONG_PTR KAFFINITY;
+typedef KAFFINITY *PKAFFINITY;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#if _MSC_VER >= 1200
+#pragma warning(pop)
+#endif
+
+#endif