

typedef WCHAR:2$L

typedef *PWCHAR$L

typedef WORD:2
typedef *PWORD

struct UNICODE_STRING
{
	WORD Length;
	WORD MaximumLength;
	PWCHAR Buffer;
}

typedef *PUNICODE_STRING

typedef PVOID

typedef *PPVOID;

typedef BYTE:1
typedef *PBYTE



typedef ULONG
typedef *PULONG
typedef *PPULONG

typedef LONG
typedef *PLONG

typedef DWORD
typedef *PDWORD

typedef HANDLE
typedef *PHANDLE
typedef *PPHANDLE

typedef CHAR:1$S
typedef UCHAR:1

typedef *PCHAR$S
typedef *PUCHAR;

typedef VOID$V

typedef SID$D
typedef *PSID
typedef *PPSID

typedef CTL_CODE$C


typedef SHORT:2
typedef USHORT:2


struct ANSI_STRING
{
	WORD Length;
	WORD MaximumLength;
	PCHAR Buffer;
}

typedef *PANSI_STRING

typedef ACCESS_MASK
typedef *PACCESS_MASK

typedef BOOLEAN:1$B
typedef *PBOOLEAN

typedef BOOL$B
typedef *PBOOL

typedef HWND
typedef HMENU
typedef HINSTANCE
typedef int


struct OBJECT_ATTRIBUTES
{
	ULONG Length;
	HANDLE RootDirectory;
	PUNICODE_STRING ObjectName;
	ULONG Attributes;
	PVOID SecurityDescriptor;
	PVOID SecurityQualityOfService;
}

typedef *POBJECT_ATTRIBUTES

typedef NTSTATUS:4$N

struct CLIENT_ID
{
	ULONG UniqueProcess;
	ULONG UniqueThread;
}
typedef *PCLIENT_ID

struct INITIAL_TEB
{
	PVOID StackBase;
	PVOID StackLimit;
	PVOID StackCommit;
	PVOID StackCommitMax;
	PVOID StackReserved;
}
typedef *PINITIAL_TEB

struct FLOATING_SAVE_AREA
{
	DWORD ControlWord;
	DWORD StatusWord;
	DWORD TagWord;
	DWORD ErrorOffset;
	DWORD ErrorSelector;
	DWORD DataOffset;
	DWORD DataSelector;
	BYTE RegisterArea[80];
	DWORD Cr0NpxState;
}


struct CONTEXT
{
	DWORD ContextFlags;
	DWORD Dr0;
	DWORD Dr1;
	DWORD Dr2;
	DWORD Dr3;
	DWORD Dr6;
	DWORD Dr7;
	FLOATING_SAVE_AREA FloatSave;
	DWORD SegGs;
	DWORD SegFs;
	DWORD SegEs;
	DWORD SegDs;
	DWORD Edi;
	DWORD Esi;
	DWORD Ebx;
	DWORD Edx;
	DWORD Ecx;
	DWORD Eax;
	DWORD Ebp;
	DWORD Eip;
	DWORD SegCs;
	DWORD EFlags;
	DWORD Esp;
	DWORD SegSs;
}

typedef *PCONTEXT

struct MEMORY_BASIC_INFORMATION
{
	PVOID BaseAddress;
	PVOID AllocationBase;
	DWORD AllocationProtect;
	ULONG RegionSize;
	DWORD State;
	DWORD Protect;
	DWORD Type;
}

typedef *PMEMORY_BASIC_INFORMATION

struct LPC_MESSAGE
{
	USHORT 		DataSize;
	USHORT		MessageSize;
	USHORT		MessageType;
	USHORT		VirtualRangesOffset;
	CLIENT_ID 	Cid;
	ULONG 		MessageId;
	ULONG 		SharedSectionSize;
	UCHAR		Data[DataSize];
}
typedef *PLPC_MESSAGE

struct LPC_OTHER_SIDE_MEMORY
{
	ULONG			Length;
	ULONG			ViewSize;
	PVOID			ViewBase;
}
typedef *PLPC_OTHER_SIDE_MEMORY;

struct LPC_THIS_SIDE_MEMORY
{
	ULONG			Length;
	HANDLE			SectionHandle;
	ULONG			OffsetInSection;
	ULONG			ViewSize;
	PVOID			ViewBase;
	PVOID			OtherSideViewBase;
}
typedef *PLPC_THIS_SIDE_MEMORY;

struct LARGE_INTEGER
{
	ULONG Lo;
	ULONG Hi;
}

typedef *PLARGE_INTEGER

struct SYSTEM_MODULE
{
	ULONG Reserved1;
	ULONG Reserved2;
	PVOID ImageBaseAddress;
	ULONG ImageSize;
	ULONG Flags;
	WORD Id;
	WORD Rank;
	WORD w018;
	WORD NameOffset;
	BYTE Name[100];
}

typedef *PSYSTEM_MODULE

typedef RTL_ATOM:2
typedef *PRTL_ATOM;
typedef KPRIORITY:2
typedef KAFFINITY

typedef *PKPRIORITY
typedef *PKAFFINITY

struct THREAD_BASIC_INFORMATION
{
	NTSTATUS			ExitStatus;
	PVOID				TebBaseAddress;
	CLIENT_ID			ClientId;
	KAFFINITY			AffinityMask;
	KPRIORITY			Priority;
	KPRIORITY			BasePriority;
}

typedef *PTHREAD_BASIC_INFORMATION

struct THREAD_TIMES_INFORMATION
{
	LARGE_INTEGER		CreationTime;
	LARGE_INTEGER		ExitTime;
	LARGE_INTEGER		KernelTime;
	LARGE_INTEGER		UserTime;
}

typedef *PTHREAD_TIMES_INFORMATION;

struct THREAD_DESCRIPTOR_TABLE_INFORMATION
{
	ULONG	Unknown1;
	ULONG	Unknown2;
	ULONG	Unknown3;
}

typedef *PTHREAD_DESCRIPTOR_TABLE_INFORMATION;


enum THREAD_INFORMATION_CLASS
{
	ThreadBasicInformation->PTHREAD_BASIC_INFORMATION;
	ThreadTimes->PTHREAD_TIMES_INFORMATION;
	ThreadPriority->PULONG;
	ThreadBasePriority->PULONG;
	ThreadAffinityMask->PULONG;
	ThreadImpersonationToken->PHANDLE;
	ThreadDescriptorTableEntry->PTHREAD_DESCRIPTOR_TABLE_INFORMATION;
	ThreadEnableAlignmentFaultFixup->PBYTE;
	ThreadEventPair->PHANDLE;
	ThreadQuerySetWin32StartAddress->PPVOID;
	ThreadZeroTlsCell->PULONG;
	ThreadPerformanceCount->PLARGE_INTEGER;
	ThreadAmILastThread->PBOOLEAN;
	ThreadIdealProcessor->PULONG;
	ThreadPriorityBoost->PULONG;
	ThreadSetTlsArrayAddress->PULONG;
}


struct SYSTEM_BASIC_INFORMATION
{
    ULONG Reserved;
    ULONG TimerResolution;
    ULONG PageSize;
    ULONG NumberOfPhysicalPages;
    ULONG LowestPhysicalPageNumber;
    ULONG HighestPhysicalPageNumber;
    ULONG AllocationGranularity;
    ULONG MinimumUserModeAddress;
    ULONG MaximumUserModeAddress;
    KAFFINITY ActiveProcessorsAffinityMask;
    BYTE NumberOfProcessors;
}

typedef *PSYSTEM_BASIC_INFORMATION


struct SYSTEM_PROCESS_INFORMATION
{
	ULONG NextEntryOffset;
	ULONG NumberOfThreads;
	LARGE_INTEGER SpareLi1;
	LARGE_INTEGER SpareLi2;
	LARGE_INTEGER SpareLi3;
	LARGE_INTEGER CreateTime;
	LARGE_INTEGER UserTime;
	LARGE_INTEGER KernelTime;
	UNICODE_STRING ImageName;
	KPRIORITY BasePriority;
	HANDLE UniqueProcessId;
	HANDLE InheritedFromUniqueProcessId;
	ULONG HandleCount;
	ULONG SpareUl2;
	ULONG SpareUl3;
	ULONG PeakVirtualSize;
	ULONG VirtualSize;
	ULONG PageFaultCount;
	ULONG PeakWorkingSetSize;
	ULONG WorkingSetSize;
	ULONG QuotaPeakPagedPoolUsage;
	ULONG QuotaPagedPoolUsage;
	ULONG QuotaPeakNonPagedPoolUsage;
	ULONG QuotaNonPagedPoolUsage;
	ULONG PagefileUsage;
	ULONG PeakPagefileUsage;
	ULONG PrivatePageCount;
}

typedef *PSYSTEM_PROCESS_INFORMATION


struct SYSTEM_THREAD_INFORMATION
{
	LARGE_INTEGER KernelTime;
	LARGE_INTEGER UserTime;
	LARGE_INTEGER CreateTime;
	ULONG WaitTime;
	PVOID StartAddress;
	CLIENT_ID ClientId;
	KPRIORITY Priority;
	ULONG BasePriority;
	ULONG ContextSwitches;
	ULONG ThreadState;
	ULONG WaitReason;
}

typedef *PSYSTEM_THREAD_INFORMATION


enum SYSTEM_INFORMATION_CLASS
{
	SystemBasicInformation->PSYSTEM_BASIC_INFORMATION;
	SystemProcessorInformation->PVOID;
	SystemPerformanceInformation->PVOID;
	SystemTimeOfDayInformation->PVOID;
	SystemPathInformation->PVOID;
	SystemProcessInformation->PSYSTEM_PROCESS_INFORMATION;
	SystemCallCountInformation->PVOID;
	SystemDeviceInformation->PVOID;
	SystemProcessorPerformanceInformation->PVOID;
	SystemFlagsInformation->PVOID;
	SystemCallTimeInformation->PVOID;
	SystemModuleInformation->PVOID;
	SystemLocksInformation->PVOID;
	SystemStackTraceInformation->PVOID;
	SystemPagedPoolInformation->PVOID;
	SystemNonPagedPoolInformation->PVOID;
	SystemHandleInformation->PVOID;
	SystemObjectInformation->PVOID;
	SystemPageFileInformation->PVOID;
	SystemVdmInstemulInformation->PVOID;
	SystemVdmBopInformation->PVOID;
	SystemFileCacheInformation->PVOID;
	SystemPoolTagInformation->PVOID;
	SystemInterruptInformation->PVOID;
	SystemDpcBehaviorInformation->PVOID;
	SystemFullMemoryInformation->PVOID;
	SystemLoadGdiDriverInformation->PVOID;
	SystemUnloadGdiDriverInformation->PVOID;
	SystemTimeAdjustmentInformation->PVOID;
	SystemSummaryMemoryInformation->PVOID;
	SystemNextEventIdInformation->PVOID;
	SystemEventIdsInformation->PVOID;
	SystemCrashDumpInformation->PVOID;
	SystemExceptionInformation->PVOID;
	SystemCrashDumpStateInformation->PVOID;
	SystemKernelDebuggerInformation->PVOID;
	SystemContextSwitchInformation->PVOID;
	SystemRegistryQuotaInformation->PVOID;
	SystemExtendServiceTableInformation->PVOID;
	SystemPrioritySeperation->PVOID;
	SystemPlugPlayBusInformation->PVOID;
	SystemDockInformation->PVOID;
	SystemPowerInformation->PVOID;
	SystemProcessorSpeedInformation->PVOID;
	SystemCurrentTimeZoneInformation->PVOID;
	SystemLookasideInformation->PVOID;
}

struct PROCESS_BASIC_INFORMATION
{
	ULONG		ExitStatus;
	PVOID		PebBaseAddress;
	KAFFINITY	AffinityMask;
	KPRIORITY	BasePriority;
	ULONG		UniqueProcessId;
	ULONG		InheritedFromUniqueProcessId;
}

typedef *PPROCESS_BASIC_INFORMATION

struct KERNEL_USER_TIMES
{
	LARGE_INTEGER	CreateTime;
	LARGE_INTEGER	ExitTime;
	LARGE_INTEGER	KernelTime;
	LARGE_INTEGER	UserTime;
}

typedef *PKERNEL_USER_TIMES

struct PROCESS_ACCESS_TOKEN
{
	HANDLE	Token;
	HANDLE	Thread;
}

typedef *PPROCESS_ACCESS_TOKEN

struct POOLED_USAGE_AND_LIMITS
{
	ULONG	PeakPagedPoolUsage;
	ULONG	PagedPoolUsage;
	ULONG	PagedPoolLimit;
	ULONG	PeakNonPagedPoolUsage;
	ULONG	NonPagedPoolUsage;
	ULONG	NonPagedPoolLimit;
	ULONG	PeakPagefileUsage;
	ULONG	PagefileUsage;
	ULONG	PagefileLimit;
}

typedef *PPOOLED_USAGE_AND_LIMITS

struct PROCESS_WS_WATCH_INFORMATION
{
	PVOID	FaultingPc;
	PVOID	FaultingVa;
}

typedef *PPROCESS_WS_WATCH_INFORMATION

struct QUOTA_LIMITS
{
	ULONG PagedPoolLimit;
	ULONG NonPagedPoolLimit;
	ULONG MinimumWorkingSetSize;
	ULONG MaximumWorkingSetSize;
	ULONG PagefileLimit;
	LARGE_INTEGER TimeLimit;
}

typedef *PQUOTA_LIMITS

struct IO_COUNTERS
{
	LARGE_INTEGER ReadOperationCount;
	LARGE_INTEGER WriteOperationCount;
	LARGE_INTEGER OtherOperationCount;
	LARGE_INTEGER ReadTransferCount;
	LARGE_INTEGER WriteTransferCount;
	LARGE_INTEGER OtherTransferCount;
}

typedef *PIO_COUNTERS

struct VM_COUNTERS
{
	DWORD PeakVirtualSize;
	DWORD VirtualSize;
	DWORD PageFaultCount;
	DWORD PeakWorkingSetSize;
	DWORD WorkingSetSize;
	DWORD QuotaPeakPagedPoolUsage;
	DWORD QuotaPagedPoolUsage;
	DWORD QuotaPeakNonPagedPoolUsage;
	DWORD QuotaNonPagedPoolUsage;
	DWORD PagefileUsage;
	DWORD PeakPagefileUsage;
}

typedef *PVM_COUNTERS


enum PROCESS_INFORMATION_CLASS
{
	ProcessBasicInformation->PPROCESS_BASIC_INFORMATION;
	ProcessQuotaLimits->PQUOTA_LIMITS;
	ProcessIoCounters->PIO_COUNTERS;
	ProcessVmCounters->PVM_COUNTERS;
	ProcessTimes->PKERNEL_USER_TIMES;
	ProcessBasePriority->PKPRIORITY;
	ProcessRaisePriority->PKPRIORITY;
	ProcessDebugPort->PHANDLE;
	ProcessExceptionPort->PHANDLE;
	ProcessAccessToken->PPROCESS_ACCESS_TOKEN;
	ProcessLdtInformation->PLARGE_INTEGER;
	ProcessLdtSize->PULONG;
	ProcessDefaultHardErrorMode->PULONG;
	ProcessIoPortHandlers->PVOID;
	ProcessPooledUsageAndLimits->PPOOLED_USAGE_AND_LIMITS;
	ProcessWorkingSetWatch->PPROCESS_WS_WATCH_INFORMATION;
	ProcessUserModeIOPL->PVOID;
	ProcessEnableAlignmentFaultFixup->PULONG;
	ProcessPriorityClass->PULONG;
	ProcessWx86Information->PULONG;
	ProcessHandleCount->PULONG;
	ProcessAffinityMask->PULONG;
	ProcessPriorityBoost->PQUOTA_LIMITS;
	ProcessUnknown1->PULONG;
	ProcessUnknown2->PULONG;
	ProcessUnknown3->PULONG;
	ProcessUnknown4->PULONG;
}

struct EXCEPTION_RECORD
{
	DWORD   ExceptionCode;
	DWORD 	ExceptionFlags;
	PVOID	ExceptionRecord;
	PVOID 	ExceptionAddress;
	DWORD 	NumberParameters;
	ULONG 	ExceptionInformation[10];
}

typedef *PEXCEPTION_RECORD

struct RTL_HEAP_DEFINITION
{
	ULONG		Length;
	ULONG		Unknown1;
	ULONG		Unknown2;
	ULONG		Unknown3;
	ULONG		Unknown4;
	ULONG		Unknown5;
	ULONG		Unknown6;
	ULONG		Unknown7;
	ULONG		Unknown8;
	ULONG		Unknown9;
	ULONG		Unknown10;
	ULONG		Unknown11;
	ULONG		Unknown12;
}

typedef *PRTL_HEAP_DEFINITION;

typedef SECURITY_INFORMATION;

typedef *PSECURITY_INFORMATION;

typedef SECURITY_DESCRIPTOR_CONTROL:2

struct ACL
{
	BYTE	AclRevision;
	BYTE	Sbz1;
	WORD    AclSize;
	WORD    AceCount;
	WORD    Sbz2;
}

typedef *PACL;


struct SECURITY_DESCRIPTOR
{
	BYTE  Revision;
	BYTE  Sbz1;
	SECURITY_DESCRIPTOR_CONTROL Control;
	PSID Owner;
	PSID Group;
	PACL Sacl;
	PACL Dacl;
}

typedef *PSECURITY_DESCRIPTOR;

struct FILE_BASIC_INFORMATION
{
	LARGE_INTEGER CreationTime;
	LARGE_INTEGER LastAccessTime;
	LARGE_INTEGER LastWriteTime;
	LARGE_INTEGER ChangeTime;
	ULONG FileAttributes;
}
typedef *PFILE_BASIC_INFORMATION;

struct FILE_BOTH_DIR_INFORMATION
{
	ULONG			NextEntryOffset;
	ULONG			FileIndex;
	LARGE_INTEGER	CreationTime;
	LARGE_INTEGER	LastAccessTime;
	LARGE_INTEGER	LastWriteTime;
	LARGE_INTEGER	ChangeTime;
	LARGE_INTEGER	EndOfFile;
	LARGE_INTEGER	AllocationSize;
	ULONG			FileAttributes;
	ULONG			FileNameLength;
	ULONG			EaSize;
	BYTE			ShortNameLength;
	WCHAR			ShortName[12];
	WCHAR			FileName[FileNameLength];
}
typedef *PFILE_BOTH_DIR_INFORMATION;

struct FILE_STANDARD_INFORMATION
{
	LARGE_INTEGER	AllocationSize;
	LARGE_INTEGER	EndOfFile;
	ULONG			NumberOfLinks;
	BOOLEAN			DeletePending;
	BOOLEAN			Directory;
}
typedef *PFILE_STANDARD_INFORMATION;

struct FILE_INTERNAL_INFORMATION
{
	LARGE_INTEGER 	IndexNumber;
}
typedef *PFILE_INTERNAL_INFORMATION;

struct FILE_EA_INFORMATION
{
	ULONG 			EaSize;
}
typedef *PFILE_EA_INFORMATION;

struct FILE_ACCESS_INFORMATION
{
	ACCESS_MASK		AccessFlags;
}
typedef *PFILE_ACCESS_INFORMATION;

struct FILE_POSITION_INFORMATION
{
	LARGE_INTEGER 	CurrentByteOffset;
}
typedef *PFILE_POSITION_INFORMATION;

struct FILE_MODE_INFORMATION
{
	ULONG 			Mode;
}
typedef *PFILE_MODE_INFORMATION;

struct FILE_ALIGNMENT_INFORMATION
{
	ULONG 			AlignmentRequirement;
}
typedef *PFILE_ALIGNMENT_INFORMATION;

struct FILE_NAME_INFORMATION
{
	ULONG 			FileNameLength;
	WCHAR 			FileName[FileNameLength];
}
typedef *PFILE_NAME_INFORMATION;


struct FILE_FULL_EA_INFORMATION
{
	ULONG 			NextEntryOffset;
	BYTE 			Flags;
	UCHAR 			EaNameLength;
	USHORT 			EaValueLength;
	CHAR			EaName[EaNameLength];
	UCHAR			EaValue[EaValueLength];
}
typedef *PFILE_FULL_EA_INFORMATION;

struct FILE_ALL_INFORMATION
{
	FILE_BASIC_INFORMATION		BasicInformation;
	FILE_STANDARD_INFORMATION	StandardInformation;
	FILE_INTERNAL_INFORMATION	InternalInformation;
	FILE_EA_INFORMATION			EaInformation;
	FILE_ACCESS_INFORMATION		AccessInformation;
	FILE_POSITION_INFORMATION	PositionInformation;
	FILE_MODE_INFORMATION		ModeInformation;
	FILE_ALIGNMENT_INFORMATION	AlignmentInformation;
	FILE_NAME_INFORMATION		NameInformation;
}
typedef *PFILE_ALL_INFORMATION;

struct FILE_MAILSLOT_QUERY_INFORMATION
{
	ULONG			MaximumMessageSize;
	ULONG			MailslotQuota;
	ULONG			NextMessageSize;
	ULONG			MessagesAvailable;
	LARGE_INTEGER	ReadTimeout;
}
typedef *PFILE_MAILSLOT_QUERY_INFORMATION;

typedef *PPLARGE_INTEGER;

struct FILE_COMPLETION_INFORMATION
{
	HANDLE	Port;
	ULONG	Key;
}
typedef *PFILE_COMPLETION_INFORMATION;

struct FILE_PIPE_INFORMATION
{
	ULONG ReadMode;
	ULONG CompletionMode;
}
typedef *PFILE_PIPE_INFORMATION;

struct FILE_PIPE_LOCAL_INFORMATION
{
	ULONG NamedPipeType;
	ULONG NamedPipeConfiguration;
	ULONG MaximumInstances;
	ULONG CurrentInstances;
	ULONG InboundQuota;
	ULONG ReadDataAvailable;
	ULONG OutboundQuota;
	ULONG WriteQuotaAvailable;
	ULONG NamedPipeState;
	ULONG NamedPipeEnd;
}
typedef *PFILE_PIPE_LOCAL_INFORMATION;

struct FILE_PIPE_REMOTE_INFORMATION
{
	LARGE_INTEGER   CollectDataTime;
	ULONG           MaximumCollectionCount;
	ULONG			Unknown1;
}
typedef *PFILE_PIPE_REMOTE_INFORMATION;

struct FILE_RENAME_INFORMATION
{
	BOOLEAN			ReplaceIfExists;
	HANDLE			RootDirectory;
	ULONG			FileNameLength;
	WCHAR			FileName[1];
}
typedef *PFILE_RENAME_INFORMATION;

struct FILE_LINK_INFORMATION
{
	BOOLEAN			ReplaceIfExists;
	HANDLE			RootDirectory;
	ULONG			FileNameLength;
	WCHAR			FileName[FileNameLength];
}
typedef *PFILE_LINK_INFORMATION;


struct FILE_NETWORK_OPEN_INFORMATION
{
    LARGE_INTEGER CreationTime;
    LARGE_INTEGER LastAccessTime;
    LARGE_INTEGER LastWriteTime;
    LARGE_INTEGER ChangeTime;
    LARGE_INTEGER AllocationSize;
    LARGE_INTEGER EndOfFile;
    ULONG FileAttributes;
}
typedef *PFILE_NETWORK_OPEN_INFORMATION;

struct FILE_ATTRIBUTE_TAG_INFORMATION
{
    ULONG FileAttributes;
    ULONG ReparseTag;
}
typedef *PFILE_ATTRIBUTE_TAG_INFORMATION;

struct FILE_ALLOCATION_INFORMATION
{
    LARGE_INTEGER AllocationSize;                            
}
typedef *PFILE_ALLOCATION_INFORMATION;

struct FILE_COMPRESSION_INFORMATION
{
    LARGE_INTEGER CompressedFileSize;
    USHORT CompressionFormat;
    UCHAR CompressionUnitShift;
    UCHAR ChunkShift;
    UCHAR ClusterShift;
    UCHAR Reserved[3];
}
typedef *PFILE_COMPRESSION_INFORMATION;

struct FILE_VALID_DATA_LENGTH_INFORMATION
{
    LARGE_INTEGER ValidDataLength;
}
typedef *PFILE_VALID_DATA_LENGTH_INFORMATION;


struct FILE_MOVE_CLUSTER_INFORMATION
{
    ULONG ClusterCount;
    HANDLE RootDirectory;
    ULONG FileNameLength;
    WCHAR FileName[FileNameLength];
}
typedef *PFILE_MOVE_CLUSTER_INFORMATION;

struct FILE_STREAM_INFORMATION 
{
    ULONG NextEntryOffset;
    ULONG StreamNameLength;
    LARGE_INTEGER StreamSize;
    LARGE_INTEGER StreamAllocationSize;
    WCHAR StreamName[1];
}
typedef *PFILE_STREAM_INFORMATION;

struct FILE_TRACKING_INFORMATION 
{
    HANDLE DestinationFile;
    ULONG ObjectInformationLength;
    CHAR ObjectInformation[1];
}
typedef *PFILE_TRACKING_INFORMATION;

struct FILE_MAILSLOT_SET_INFORMATION 
{
    PLARGE_INTEGER ReadTimeout;
}
typedef *PFILE_MAILSLOT_SET_INFORMATION;

struct FILE_REPARSE_POINT_INFORMATION 
{
    LARGE_INTEGER FileReference;
    ULONG Tag;
}
typedef *PFILE_REPARSE_POINT_INFORMATION;




enum FILE_INFORMATION_CLASS
{
	FileZeroInformation->PVOID;													
	FileDirectoryInformation->PVOID;                                
	FileFullDirectoryInformation->PVOID;                            
	FileBothDirectoryInformation->PFILE_BOTH_DIR_INFORMATION;       
	FileBasicInformation->PFILE_BASIC_INFORMATION;                  
	FileStandardInformation->PFILE_STANDARD_INFORMATION;            
	FileInternalInformation->PFILE_INTERNAL_INFORMATION;            
	FileEaInformation->PFILE_EA_INFORMATION;                        
	FileAccessInformation->PFILE_ACCESS_INFORMATION;                
	FileNameInformation->PFILE_NAME_INFORMATION;                    
	FileRenameInformation->PFILE_RENAME_INFORMATION;                
	FileLinkInformation->PFILE_LINK_INFORMATION;                    
	FileNamesInformation->PVOID;                                    
	FileDispositionInformation->PBOOLEAN;                           
	FilePositionInformation->PFILE_POSITION_INFORMATION;            
	FileFullEaInformation->PFILE_FULL_EA_INFORMATION;
	FileModeInformation->PFILE_MODE_INFORMATION;                    
	FileAlignmentInformation->PFILE_ALIGNMENT_INFORMATION;          
	FileAllInformation->PFILE_ALL_INFORMATION;                      
	FileAllocationInformation->PFILE_ALLOCATION_INFORMATION;                               
	FileEndOfFileInformation->PLARGE_INTEGER;                       
	FileAlternateNameInformation->PFILE_NAME_INFORMATION;           
	FileStreamInformation->PFILE_STREAM_INFORMATION;                                   
	FilePipeInformation->PFILE_PIPE_INFORMATION;                    
	FilePipeLocalInformation->PFILE_PIPE_LOCAL_INFORMATION;         
	FilePipeRemoteInformation->PFILE_PIPE_REMOTE_INFORMATION;       
	FileMailslotQueryInformation->PFILE_MAILSLOT_QUERY_INFORMATION;	
	FileMailslotSetInformation->PFILE_MAILSLOT_SET_INFORMATION;                    
	FileCompressionInformation->PFILE_COMPRESSION_INFORMATION;                              
	FileObjectIdInformation->PVOID;                                 
	FileCompletionInformation->PFILE_COMPLETION_INFORMATION;        
	FileMoveClusterInformation->PFILE_MOVE_CLUSTER_INFORMATION;                              
	FileQuotaInformation->PVOID;                                    
	FileReparsePointInformation->PFILE_REPARSE_POINT_INFORMATION;
	FileNetworkOpenInformation->PFILE_NETWORK_OPEN_INFORMATION;     
	FileAttributeTagInformation->PFILE_ATTRIBUTE_TAG_INFORMATION;   
	FileTrackingInformation->PFILE_TRACKING_INFORMATION;  
	FileIdBothDirectoryInformation->PVOID;                          
	FileIdFullDirectoryInformation->PVOID;                          
	FileValidDataLengthInformation->PFILE_VALID_DATA_LENGTH_INFORMATION;                          
	FileShortNameInformation->PFILE_NAME_INFORMATION;
}   


enum TOKEN_TYPE
{
	TokenZero->PVOID;
	TokenPrimary->PVOID;
	TokenImpersonation->PVOID;
}

typedef SECURITY_IMPERSONATION_LEVEL


struct KEY_VALUE_BASIC_INFORMATION
{
	ULONG			TitleIndex;
	ULONG			Type;
	ULONG			NameLength;
	WCHAR			Name[NameLength];
} 

typedef *PKEY_VALUE_BASIC_INFORMATION;


struct KEY_VALUE_FULL_INFORMATION
{
	ULONG			TitleIndex;
	ULONG			Type;
	ULONG			DataOffset;
	ULONG			DataLength;
	ULONG			NameLength;
	WCHAR			Name[NameLength];
	UCHAR			Data[DataLength];

}
typedef *PKEY_VALUE_FULL_INFORMATION;


struct KEY_VALUE_PARTIAL_INFORMATION
{
	ULONG			TitleIndex;
	ULONG			Type;
	ULONG			DataLength;
	UCHAR			Data[DataLength];
	
}
typedef *PKEY_VALUE_PARTIAL_INFORMATION;


struct KEY_VALUE_PARTIAL_INFORMATION_ALIGN64
{
	ULONG			Type;
	ULONG			DataLength;
	UCHAR			Data[DataLength];
	
}
typedef *PKEY_VALUE_PARTIAL_INFORMATION_ALIGN64;


struct KEY_BASIC_INFORMATION
{
	LARGE_INTEGER	LastWriteTime;
	ULONG			TitleIndex;
	ULONG			NameLength;
	WCHAR			Name[NameLength];
}

typedef *PKEY_BASIC_INFORMATION;



struct KEY_NODE_INFORMATION 
{
	LARGE_INTEGER	LastWriteTime;
	ULONG			TitleIndex;
	ULONG			ClassOffset;
	ULONG			ClassLength;
	ULONG			NameLength;
	WCHAR			Name[NameLength];
	WCHAR 			ClassName[ClassLength];

}

typedef *PKEY_NODE_INFORMATION;


struct KEY_FULL_INFORMATION
{
	LARGE_INTEGER	LastWriteTime;
	ULONG			TitleIndex;
	ULONG			ClassOffset;
	ULONG			ClassLength;
	ULONG			SubKeys;
	ULONG			MaxNameLen;
	ULONG			MaxClassLen;
	ULONG			Values;
	ULONG			MaxValueNameLen;
	ULONG			MaxValueDataLen;
	WCHAR			ClassName[ClassLength];
	
}

typedef *PKEY_FULL_INFORMATION;


struct KEY_NAME_INFORMATION
{
	ULONG			NameLength;
	WCHAR			Name[NameLength];
}

typedef *PKEY_NAME_INFORMATION;




enum KEY_INFORMATION_CLASS
{
	KeyBasicInformation->PKEY_BASIC_INFORMATION;
	KeyNodeInformation->PKEY_NODE_INFORMATION;
	KeyFullInformation->PKEY_FULL_INFORMATION;
	KeyNameInformation->PKEY_NAME_INFORMATION;
}

enum KEY_VALUE_INFORMATION_CLASS
{
	KeyValueBasicInformation->PKEY_VALUE_BASIC_INFORMATION;
	KeyValueFullInformation->PKEY_VALUE_FULL_INFORMATION;
	KeyValuePartialInformation->PKEY_VALUE_PARTIAL_INFORMATION;
	KeyValueFullInformationAlign64->PVOID;
	KeyValuePartialInformationAlign64->PKEY_VALUE_PARTIAL_INFORMATION_ALIGN64;
}

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

struct LUID
{
	DWORD LowPart;
	ULONG HighPart;
}
typedef *PLUID;

struct LUID_AND_ATTRIBUTES
{
	LUID Luid;
	DWORD Attributes;
}
typedef *PLUID_AND_ATTRIBUTES;

struct TOKEN_USER
{
	SID_AND_ATTRIBUTES User;
}
typedef *PTOKEN_USER;

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

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

struct TOKEN_OWNER
{
    PSID Owner;
}
typedef *PTOKEN_OWNER;

struct TOKEN_PRIMARY_GROUP
{
    PSID PrimaryGroup;
}
typedef *PTOKEN_PRIMARY_GROUP;

struct TOKEN_DEFAULT_DACL
{
    PULONG DefaultDacl;
}
typedef *PTOKEN_DEFAULT_DACL;


enum TOKEN_INFORMATION_CLASS
{
	TokenZeroInformation->PVOID;
	TokenUser->PSID_AND_ATTRIBUTES;
	TokenGroups->PTOKEN_GROUPS;
	TokenPrivileges->PTOKEN_PRIVILEGES;
	TokenOwner->PSID;
	TokenPrimaryGroup->PSID;
	TokenDefaultDacl->PULONG;
	TokenSource->PVOID;
	TokenType->PVOID;
	TokenImpersonationLevel->PVOID;
	TokenStatistics->PVOID;
	TokenRestrictedSids->PVOID;
	TokenSessionId->PVOID;
}

struct PRIVILEGE_SET
{
	ULONG PrivilegeCount;
	ULONG Control;
    LUID_AND_ATTRIBUTES Privilege[1];
}
typedef *PPRIVILEGE_SET;

struct TOKEN_SOURCE
{
	PCHAR SourceName;
	LUID SourceIdentifier;
}
typedef *PTOKEN_SOURCE;

struct IO_STATUS_BLOCK
{
	PVOID StatusOrPointer;
	ULONG Information;
}
typedef *PIO_STATUS_BLOCK;

typedef PIO_APC_ROUTINE;

enum TIMER_TYPE
{
	NotificationTimer->PVOID;
	SynchronizationTimer->PVOID;
}

struct TIMER_BASIC_INFORMATION
{
	LARGE_INTEGER RemainingTime;
	BOOLEAN TimerState;
}
typedef *PTIMER_BASIC_INFORMATION;

enum TIMER_INFORMATION_CLASS
{
	TimerBasicInformation->PTIMER_BASIC_INFORMATION;
}

enum SECURITY_IMPERSONATION_LEVEL
{
	SecurityAnonymous->PVOID;
	SecurityIdentification->PVOID;
	SecurityImpersonation->PVOID;
	SecurityDelegation->PVOID;
}

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

struct LIST_ENTRY
{
	PVOID Prev;
	PVOID Next;
}

struct LDR_MODULE
{
	LIST_ENTRY     InLoadOrderModuleList;
	LIST_ENTRY     InMemoryOrderModuleList;
	LIST_ENTRY     InInitializationOrderModuleList;
	PVOID          BaseAddress;
	ULONG          EntryPoint;
	ULONG          SizeOfImage;
	UNICODE_STRING FullDllName;
	UNICODE_STRING BaseDllName;
	ULONG          Flags;
	SHORT          LoadCount;
	SHORT          TlsIndex;
	HANDLE         SectionHandle;
	ULONG          CheckSum;
	ULONG          TimeDateStamp;
}
typedef *PLDR_MODULE;

struct CURDIR
{
   UNICODE_STRING DosPath;
   PVOID Handle;
}
typedef *PCURDIR;

struct RTL_DRIVE_LETTER_CURDIR
{
   USHORT Flags;
   USHORT Length;
   ULONG TimeStamp;
   UNICODE_STRING DosPath;
}
typedef *PRTL_DRIVE_LETTER_CURDIR;

struct PEB_FREE_BLOCK
{
   PVOID Next;
   ULONG Size;
}
typedef *PPEB_FREE_BLOCK;

struct RTL_USER_PROCESS_PARAMETERS
{
   ULONG		MaximumLength;
   ULONG		Length;
   ULONG		Flags;
   ULONG		DebugFlags;
   PVOID		ConsoleHandle;
   ULONG		ConsoleFlags;
   HANDLE		InputHandle;
   HANDLE		OutputHandle;
   HANDLE		ErrorHandle;
   CURDIR		CurrentDirectory;
   UNICODE_STRING	DllPath;
   UNICODE_STRING	ImagePathName;
   UNICODE_STRING	CommandLine;
   PVOID		Environment;
   ULONG		StartingX;
   ULONG		StartingY;
   ULONG		CountX;
   ULONG		CountY;
   ULONG		CountCharsX;
   ULONG		CountCharsY;
   ULONG		FillAttribute;
   ULONG		WindowFlags;
   ULONG		ShowWindowFlags;
   UNICODE_STRING	WindowTitle;
   UNICODE_STRING	DesktopInfo;
   UNICODE_STRING	ShellInfo;
   UNICODE_STRING	RuntimeData;
   RTL_DRIVE_LETTER_CURDIR DLCurrentDirectory[0x20];
}
typedef *PRTL_USER_PROCESS_PARAMETERS;

struct PEB_LDR_DATA
{
   ULONG Length;
   ULONG Initialized;
   PVOID SsHandle;
   LIST_ENTRY InLoadOrderModuleList;
   LIST_ENTRY InMemoryOrderModuleList;
   LIST_ENTRY InInitializationOrderModuleList;
}
typedef *PPEB_LDR_DATA;

typedef PPEBLOCKROUTINE;

struct PEB
{
	BYTE InheritedAddressSpace;
	BYTE ReadImageFileExecOptions;
	BYTE BeingDebugged;
	BYTE Spare;
	PVOID Mutant;
	PVOID ImageBaseAddress;
	PPEB_LDR_DATA Ldr;
	PRTL_USER_PROCESS_PARAMETERS ProcessParameters;
	PVOID SubSystemData;
	PVOID ProcessHeap;
	PVOID FastPebLock;
	PPEBLOCKROUTINE FastPebLockRoutine;
	PPEBLOCKROUTINE FastPebUnlockRoutine;
	ULONG EnvironmentUpdateCount;
	PPVOID KernelCallbackTable;
	PVOID EventLogSection;
	PVOID EventLog;
	PPEB_FREE_BLOCK FreeList;
	ULONG TlsExpansionCounter;
	PVOID TlsBitmap;
	ULONG TlsBitmapBits[0x2];
	PVOID ReadOnlySharedMemoryBase;
	PVOID ReadOnlySharedMemoryHeap;
	PPVOID ReadOnlyStaticServerData;
	PVOID AnsiCodePageData;
	PVOID OemCodePageData;
	PVOID UnicodeCaseTableData;
	ULONG NumberOfProcessors;
	ULONG NtGlobalFlag;
	BYTE Spare2[0x4];
	LARGE_INTEGER CriticalSectionTimeout;
	ULONG HeapSegmentReserve;
	ULONG HeapSegmentCommit;
	ULONG HeapDeCommitTotalFreeThreshold;
	ULONG HeapDeCommitFreeBlockThreshold;
	ULONG NumberOfHeaps;
	ULONG MaximumNumberOfHeaps;
	PPVOID ProcessHeaps;
	PVOID GdiSharedHandleTable;
	PVOID ProcessStarterHelper;
	PVOID GdiDCAttributeList;
	PVOID LoaderLock;
	ULONG OSMajorVersion;
	ULONG OSMinorVersion;
	ULONG OSBuildNumber;
	ULONG OSPlatformId;
	ULONG ImageSubSystem;
	ULONG ImageSubSystemMajorVersion;
	ULONG ImageSubSystemMinorVersion;
	ULONG GdiHandleBuffer[0x22];
	ULONG PostProcessInitRoutine;
	ULONG TlsExpansionBitmap;
	BYTE TlsExpansionBitmapBits[0x80];
	ULONG SessionId;
}
typedef *PPEB;


struct GDI_TEB_BATCH
{
   ULONG Offset;
   ULONG HDC;
   ULONG Buffer[0x136];
}
typedef *PGDI_TEB_BATCH;

struct NT_TIB
{
    PPVOID ExceptionList;
    PVOID StackBase;
    PVOID StackLimit;
    PVOID SubSystemTib;
    DWORD Version;
    PVOID ArbitraryUserPointer;
    PPVOID Self;
}
typedef *PNT_TIB;


struct TEB
{
   NT_TIB Tib;
   PVOID EnvironmentPointer;
   CLIENT_ID Cid;
   PVOID ActiveRpcInfo;
   PVOID ThreadLocalStoragePointer;
   PPEB Peb;
   ULONG LastErrorValue;
   ULONG CountOfOwnedCriticalSections;
   PVOID CsrClientThread;
   PVOID Win32ThreadInfo;
   ULONG Win32ClientInfo[0x1F];
   PVOID WOW32Reserved;
   ULONG CurrentLocale;
   ULONG FpSoftwareStatusRegister;
   PVOID SystemReserved1[0x36];
   PVOID Spare1;
   LONG ExceptionCode;
   ULONG SpareBytes1[0x28];
   PVOID SystemReserved2[0xA];
   ULONG Offset;
   ULONG HDC;
   ULONG Buffer[0x136];
   ULONG gdiRgn;
   ULONG gdiPen;
   ULONG gdiBrush;
   CLIENT_ID RealClientId;
   PVOID GdiCachedProcessHandle;
   ULONG GdiClientPID;
   ULONG GdiClientTID;
   PVOID GdiThreadLocaleInfo;
   PVOID UserReserved[5];
   PVOID glDispatchTable[0x118];
   ULONG glReserved1[0x1A];
   PVOID glReserved2;
   PVOID glSectionInfo;
   PVOID glSection;
   PVOID glTable;
   PVOID glCurrentRC;
   PVOID glContext;
   NTSTATUS LastStatusValue;
   UNICODE_STRING StaticUnicodeString;
   WCHAR StaticUnicodeBuffer[0x105];
   PVOID DeallocationStack;
   PVOID TlsSlots[0x40];
   LIST_ENTRY TlsLinks;
   PVOID Vdm;
   PVOID ReservedForNtRpc;
   PVOID DbgSsReserved[0x2];
   ULONG HardErrorDisabled;
   PVOID Instrumentation[0x10];
   PVOID WinSockData;
   ULONG GdiBatchCount;
   ULONG Spare2;
   ULONG Spare3;
   ULONG Spare4;
   PVOID ReservedForOle;
   ULONG WaitingOnLoaderLock;
   PVOID StackCommit;
   PVOID StackCommitMax;
   PVOID StackReserved;
}
typedef *PTEB;

enum HARDERROR_RESPONSE_OPTION
{
	OptionAbortRetryIgnore->PVOID;
	OptionOk->PVOID;
	OptionOkCancel->PVOID;
	OptionRetryCancel->PVOID;
	OptionYesNo->PVOID;
	OptionYesNoCancel->PVOID;
	OptionShutdownSystem->PVOID;
}
typedef *PHARDERROR_RESPONSE_OPTION;

enum HARDERROR_RESPONSE
{
	ResponseReturnToCaller->PVOID;
	ResponseNotHandled->PVOID;
	ResponseAbort->PVOID;
	ResponseCancel->PVOID;
	ResponseIgnore->PVOID;
	ResponseNo->PVOID;
	ResponseOk->PVOID;
	ResponseRetry->PVOID;
	ResponseYes->PVOID;
}
typedef *PHARDERROR_RESPONSE;

struct ATOM_BASIC_INFORMATION
{
	USHORT		UsageCount;
	USHORT		Flags;
	USHORT		NameLength;
	WCHAR		Name[NameLength];
}
typedef *PATOM_BASIC_INFORMATION;

struct ATOM_TABLE_INFORMATION
{
	ULONG		NumberOfAtoms;
	RTL_ATOM	Atoms[NumberOfAtoms];
}
typedef *PATOM_TABLE_INFORMATION;

enum ATOM_INFORMATION_CLASS
{
	AtomBasicInformation->PATOM_BASIC_INFORMATION;
	AtomTableInformation->PATOM_TABLE_INFORMATION;
}

struct IO_COMPLETION_BASIC_INFORMATION
{
	ULONG Depth;
}
typedef *PIO_COMPLETION_BASIC_INFORMATION;

enum IO_COMPLETION_INFORMATION_CLASS
{
	IoCompletionBasicInformation->PIO_COMPLETION_BASIC_INFORMATION;
}

struct KEY_MULTIPLE_VALUE_INFORMATION
{
	PUNICODE_STRING ValueName;
	ULONG DataLength;
	ULONG DataOffset;
	ULONG Type;
}
typedef *PKEY_MULTIPLE_VALUE_INFORMATION;

enum KPROFILE_SOURCE
{
	ProfileTime->PVOID;
	ProfileAlignmentFixup->PVOID;
	ProfileTotalIssues->PVOID;
	ProfilePipelineDry->PVOID;
	ProfileLoadInstructions->PVOID;
	ProfilePipelineFrozen->PVOID;
	ProfileBranchInstructions->PVOID;
	ProfileTotalNonissues->PVOID;
	ProfileDcacheMisses->PVOID;
	ProfileIcacheMisses->PVOID;
	ProfileCacheMisses->PVOID;
	ProfileBranchMispredictions->PVOID;
	ProfileStoreInstructions->PVOID;
	ProfileFpInstructions->PVOID;
	ProfileIntegerInstructions->PVOID;
	Profile2Issue->PVOID;
	Profile3Issue->PVOID;
	Profile4Issue->PVOID;
	ProfileSpecialInstructions->PVOID;
	ProfileTotalCycles->PVOID;
	ProfileIcacheIssues->PVOID;
	ProfileDcacheAccesses->PVOID;
	ProfileMemoryBarrierCycles->PVOID;
	ProfileLoadLinkedIssues->PVOID;
	ProfileMaximum->PVOID;
}

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

enum EVENT_TYPE
{
	NotificationEvent->PVOID;
	SynchronizationEvent->PVOID;
}

struct EVENT_BASIC_INFORMATION
{
	EVENT_TYPE EventType;
	LONG EventState;
}

typedef *PEVENT_BASIC_INFORMATION;


struct FILE_FS_VOLUME_INFORMATION 
{
  LARGE_INTEGER           VolumeCreationTime;
  ULONG                   VolumeSerialNumber;
  ULONG                   VolumeLabelLength;
  BOOLEAN                 SupportsObjects;
  WCHAR                   VolumeLabel[VolumeLabelLength];
}
typedef *PFILE_FS_VOLUME_INFORMATION;


struct FILE_FS_LABEL_INFORMATION
{
  ULONG                   VolumeLabelLength;
  WCHAR                   VolumeLabel[VolumeLabelLength];
}
typedef *PFILE_FS_LABEL_INFORMATION;


struct FILE_FS_SIZE_INFORMATION 
{
  LARGE_INTEGER           TotalAllocationUnits;
  LARGE_INTEGER           AvailableAllocationUnits;
  ULONG                   SectorsPerAllocationUnit;
  ULONG                   BytesPerSector;
}
typedef *PFILE_FS_SIZE_INFORMATION;

struct FILE_FS_DEVICE_INFORMATION 
{
  ULONG             DeviceType;
  ULONG             Characteristics;
}
typedef *PFILE_FS_DEVICE_INFORMATION;

struct FILE_FS_ATTRIBUTE_INFORMATION 
{
    ULONG   FileSystemAttributes;
    ULONG   MaximumComponentNameLength;
    ULONG   FileSystemNameLength;
	WCHAR   FileSystemName[FileSystemNameLength];
}
typedef *PFILE_FS_ATTRIBUTE_INFORMATION;

struct FILE_FS_CONTROL_INFORMATION 
{
  LARGE_INTEGER           FreeSpaceStartFiltering;
  LARGE_INTEGER           FreeSpaceThreshold;
  LARGE_INTEGER           FreeSpaceStopFiltering;
  LARGE_INTEGER           DefaultQuotaThreshold;
  LARGE_INTEGER           DefaultQuotaLimit;
  ULONG                   FileSystemControlFlags;
}
typedef *PFILE_FS_CONTROL_INFORMATION;

struct FILE_FS_FULL_SIZE_INFORMATION
{
    LARGE_INTEGER   TotalAllocationUnits;
    LARGE_INTEGER   CallerAvailableAllocationUnits;
    LARGE_INTEGER   ActualAvailableAllocationUnits;
    ULONG           SectorsPerAllocationUnit;
    ULONG           BytesPerSector;
}
typedef *PFILE_FS_FULL_SIZE_INFORMATION;

struct FILE_FS_OBJECT_ID_INFORMATION
{
    UCHAR ObjectId[16];
    UCHAR ExtendedInfo[48];
}
typedef *PFILE_FS_OBJECT_ID_INFORMATION;


enum FS_INFORMATION_CLASS 
{
	FileFsZeroInformation->PVOID;
    FileFsVolumeInformation->PFILE_FS_VOLUME_INFORMATION;
    FileFsLabelInformation->PFILE_FS_LABEL_INFORMATION;
    FileFsSizeInformation->PFILE_FS_SIZE_INFORMATION;
    FileFsDeviceInformation->PFILE_FS_DEVICE_INFORMATION;
    FileFsAttributeInformation->PFILE_FS_ATTRIBUTE_INFORMATION;
    FileFsControlInformation->PFILE_FS_CONTROL_INFORMATION;
    FileFsFullSizeInformation->PFILE_FS_FULL_SIZE_INFORMATION;
    FileFsObjectIdInformation->PFILE_FS_OBJECT_ID_INFORMATION;
}

enum DEVICE_POWER_STATE 
{
    PowerDeviceUnspecified->PVOID;
    PowerDeviceD0->PVOID;
    PowerDeviceD1->PVOID;
    PowerDeviceD2->PVOID;
    PowerDeviceD3->PVOID;
    PowerDeviceMaximum->PVOID;
}
typedef *PDEVICE_POWER_STATE;

enum SYSTEM_POWER_STATE 
{
    PowerSystemUnspecified->PVOID;
    PowerSystemWorking->PVOID;
    PowerSystemSleeping1->PVOID;
    PowerSystemSleeping2->PVOID;
    PowerSystemSleeping3->PVOID;
    PowerSystemHibernate->PVOID;
    PowerSystemShutdown->PVOID;

}
typedef *PSYSTEM_POWER_STATE;

enum POWER_ACTION
{
    PowerActionNone->PVOID;
    PowerActionReserved->PVOID;
    PowerActionSleep->PVOID;
    PowerActionHibernate->PVOID;
    PowerActionShutdown->PVOID;
    PowerActionShutdownReset->PVOID;
    PowerActionShutdownOff->PVOID;
    PowerActionWarmEject->PVOID;
}
typedef *PPOWER_ACTION;


struct OVERLAPPED
{
	ULONG Internal;
	ULONG InternalHigh;
	ULONG Offset;
	ULONG OffsetHigh;
	HANDLE hEvent;
}
typedef *POVERLAPPED;                                                                                                                                                         


enum DBG_STATE
{
	DbgIdle->PVOID;
	DbgReplyPending->PVOID;
	DbgCreateThreadStateChange->PVOID;
	DbgCreateProcessStateChange->PVOID;
	DbgExitThreadStateChange->PVOID;
	DbgExitProcessStateChange->PVOID;
	DbgExceptionStateChange->PVOID;
	DbgBreakpointStateChange->PVOID;
	DbgSingleStepStateChange->PVOID;
	DbgLoadDllStateChange->PVOID;
	DbgUnloadDllStateChang->PVOID;
}
typedef *PDBG_STATE;

struct DBGUI_WAIT_STATE_CHANGE
{
	DBG_STATE NewState;
	CLIENT_ID AppClientId;
}
typedef *PDBGUI_WAIT_STATE_CHANGE;

