Adding upstream version 7.0.14-dfsg.upstream/7.0.14-dfsg

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1543 insertions, 0 deletions

diff --git a/src/VBox/Devices/Graphics/shaderlib/wine/include/dbghelp.h b/src/VBox/Devices/Graphics/shaderlib/wine/include/dbghelp.h
new file mode 100644
index 00000000..bd5acf39
--- /dev/null
+++ b/src/VBox/Devices/Graphics/shaderlib/wine/include/dbghelp.h
@@ -0,0 +1,1543 @@
+/*
+ * Declarations for DBGHELP
+ *
+ * Copyright (C) 2003 Eric Pouech
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+/*
+ * Oracle LGPL Disclaimer: For the avoidance of doubt, except that if any license choice
+ * other than GPL or LGPL is available it will apply instead, Oracle elects to use only
+ * the Lesser General Public License version 2.1 (LGPLv2) at this time for any software where
+ * a choice of LGPL license versions is made available with the language indicating
+ * that LGPLv2 or any later version may be used, or where a choice of which version
+ * of the LGPL is applied is otherwise unspecified.
+ */
+
+#ifndef __WINE_DBGHELP_H
+#define __WINE_DBGHELP_H
+
+/* A set of documentation macros (see also imagehlp.h) */
+#ifndef __deref_out
+# define __deref_out
+#endif
+#ifndef __deref_out_opt
+# define __deref_out_opt
+#endif
+#ifndef __deref_opt_out
+# define __deref_opt_out
+#endif
+#ifndef __in
+# define __in
+#endif
+#ifndef __in_opt
+# define __in_opt
+#endif
+#ifndef __in_bcount
+# define __in_bcount(x)
+#endif
+#ifndef __in_bcount_opt
+# define __in_bcount_opt(x)
+#endif
+#ifndef __in_ecount
+# define __in_ecount(x)
+#endif
+#ifndef __inout
+# define __inout
+#endif
+#ifndef __inout_opt
+# define __inout_opt
+#endif
+#ifndef __inout_bcount
+# define __inout_bcount(x)
+#endif
+#ifndef __inout_ecount
+# define __inout_ecount(x)
+#endif
+#ifndef __out
+# define __out
+#endif
+#ifndef __out_opt
+# define __out_opt
+#endif
+#ifndef __out_bcount
+# define __out_bcount(x)
+#endif
+#ifndef __out_bcount_opt
+# define __out_bcount_opt(x)
+#endif
+#ifndef __out_ecount
+# define __out_ecount(x)
+#endif
+#ifndef __out_ecount_opt
+# define __out_ecount_opt(x)
+#endif
+#ifndef __out_xcount
+# define __out_xcount(x)
+#endif
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* defined(__cplusplus) */
+
+#ifdef _WIN64
+#ifndef _IMAGEHLP64
+#define _IMAGEHLP64
+#endif
+#endif
+
+#define IMAGEAPI WINAPI
+#define DBHLPAPI IMAGEAPI
+
+typedef struct _LOADED_IMAGE
+{
+    PSTR                        ModuleName;
+    HANDLE                      hFile;
+    PUCHAR                      MappedAddress;
+    PIMAGE_NT_HEADERS           FileHeader;
+    PIMAGE_SECTION_HEADER       LastRvaSection;
+    ULONG                       NumberOfSections;
+    PIMAGE_SECTION_HEADER       Sections;
+    ULONG                       Characteristics;
+    BOOLEAN                     fSystemImage;
+    BOOLEAN                     fDOSImage;
+    BOOLEAN                     fReadOnly;
+    UCHAR                       Version;
+    LIST_ENTRY                  Links;
+    ULONG                       SizeOfImage;
+} LOADED_IMAGE, *PLOADED_IMAGE;
+
+/*************************
+ *    IMAGEHLP equiv     *
+ *************************/
+
+typedef enum
+{
+    AddrMode1616,
+    AddrMode1632,
+    AddrModeReal,
+    AddrModeFlat
+} ADDRESS_MODE;
+
+#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
+#define ADDRESS ADDRESS64
+#define LPADDRESS LPADDRESS64
+#else
+typedef struct _tagADDRESS
+{
+    DWORD                       Offset;
+    WORD                        Segment;
+    ADDRESS_MODE                Mode;
+} ADDRESS, *LPADDRESS;
+#endif
+
+typedef struct _tagADDRESS64
+{
+    DWORD64                     Offset;
+    WORD                        Segment;
+    ADDRESS_MODE                Mode;
+} ADDRESS64, *LPADDRESS64;
+
+#define SYMF_OMAP_GENERATED   0x00000001
+#define SYMF_OMAP_MODIFIED    0x00000002
+#define SYMF_USER_GENERATED   0x00000004
+#define SYMF_REGISTER         0x00000008
+#define SYMF_REGREL           0x00000010
+#define SYMF_FRAMEREL         0x00000020
+#define SYMF_PARAMETER        0x00000040
+#define SYMF_LOCAL            0x00000080
+#define SYMF_CONSTANT         0x00000100
+#define SYMF_EXPORT           0x00000200
+#define SYMF_FORWARDER        0x00000400
+#define SYMF_FUNCTION         0x00000800
+#define SYMF_VIRTUAL          0x00001000
+#define SYMF_THUNK            0x00002000
+#define SYMF_TLSREL           0x00004000
+
+typedef enum 
+{
+    SymNone = 0,
+    SymCoff,
+    SymCv,
+    SymPdb,
+    SymExport,
+    SymDeferred,
+    SymSym,
+    SymDia,
+    SymVirtual,
+    NumSymTypes
+} SYM_TYPE;
+
+#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
+#define IMAGEHLP_SYMBOL IMAGEHLP_SYMBOL64
+#define IMAGEHLP_SYMBOLW IMAGEHLP_SYMBOLW64
+#define PIMAGEHLP_SYMBOL PIMAGEHLP_SYMBOL64
+#define PIMAGEHLP_SYMBOLW PIMAGEHLP_SYMBOLW64
+#else
+typedef struct _IMAGEHLP_SYMBOL
+{
+    DWORD                       SizeOfStruct;
+    DWORD                       Address;
+    DWORD                       Size;
+    DWORD                       Flags;
+    DWORD                       MaxNameLength;
+    CHAR                        Name[1];
+} IMAGEHLP_SYMBOL, *PIMAGEHLP_SYMBOL;
+
+typedef struct _IMAGEHLP_SYMBOLW
+{
+    DWORD                       SizeOfStruct;
+    DWORD                       Address;
+    DWORD                       Size;
+    DWORD                       Flags;
+    DWORD                       MaxNameLength;
+    WCHAR                       Name[1];
+} IMAGEHLP_SYMBOLW, *PIMAGEHLP_SYMBOLW;
+#endif
+
+typedef struct _IMAGEHLP_SYMBOL64
+{
+    DWORD                       SizeOfStruct;
+    DWORD64                     Address;
+    DWORD                       Size;
+    DWORD                       Flags;
+    DWORD                       MaxNameLength;
+    CHAR                        Name[1];
+} IMAGEHLP_SYMBOL64, *PIMAGEHLP_SYMBOL64;
+
+typedef struct _IMAGEHLP_SYMBOLW64
+{
+    DWORD                       SizeOfStruct;
+    DWORD64                     Address;
+    DWORD                       Size;
+    DWORD                       Flags;
+    DWORD                       MaxNameLength;
+    WCHAR                       Name[1];
+} IMAGEHLP_SYMBOLW64, *PIMAGEHLP_SYMBOLW64;
+
+#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
+#define IMAGEHLP_MODULE IMAGEHLP_MODULE64
+#define PIMAGEHLP_MODULE PIMAGEHLP_MODULE64
+#define IMAGEHLP_MODULEW IMAGEHLP_MODULEW64
+#define PIMAGEHLP_MODULEW PIMAGEHLP_MODULEW64
+#else
+typedef struct _IMAGEHLP_MODULE
+{
+    DWORD                       SizeOfStruct;
+    DWORD                       BaseOfImage;
+    DWORD                       ImageSize;
+    DWORD                       TimeDateStamp;
+    DWORD                       CheckSum;
+    DWORD                       NumSyms;
+    SYM_TYPE                    SymType;
+    CHAR                        ModuleName[32];
+    CHAR                        ImageName[256];
+    CHAR                        LoadedImageName[256];
+} IMAGEHLP_MODULE, *PIMAGEHLP_MODULE;
+
+typedef struct _IMAGEHLP_MODULEW
+{
+    DWORD                       SizeOfStruct;
+    DWORD                       BaseOfImage;
+    DWORD                       ImageSize;
+    DWORD                       TimeDateStamp;
+    DWORD                       CheckSum;
+    DWORD                       NumSyms;
+    SYM_TYPE                    SymType;
+    WCHAR                       ModuleName[32];
+    WCHAR                       ImageName[256];
+    WCHAR                       LoadedImageName[256];
+} IMAGEHLP_MODULEW, *PIMAGEHLP_MODULEW;
+#endif
+
+typedef struct _IMAGEHLP_MODULE64
+{
+    DWORD                       SizeOfStruct;
+    DWORD64                     BaseOfImage;
+    DWORD                       ImageSize;
+    DWORD                       TimeDateStamp;
+    DWORD                       CheckSum;
+    DWORD                       NumSyms;
+    SYM_TYPE                    SymType;
+    CHAR                        ModuleName[32];
+    CHAR                        ImageName[256];
+    CHAR                        LoadedImageName[256];
+    CHAR                        LoadedPdbName[256];
+    DWORD                       CVSig;
+    CHAR                        CVData[MAX_PATH*3];
+    DWORD                       PdbSig;
+    GUID                        PdbSig70;
+    DWORD                       PdbAge;
+    BOOL                        PdbUnmatched;
+    BOOL                        DbgUnmatched;
+    BOOL                        LineNumbers;
+    BOOL                        GlobalSymbols;
+    BOOL                        TypeInfo;
+    BOOL                        SourceIndexed;
+    BOOL                        Publics;
+} IMAGEHLP_MODULE64, *PIMAGEHLP_MODULE64;
+
+typedef struct _IMAGEHLP_MODULEW64
+{
+    DWORD                       SizeOfStruct;
+    DWORD64                     BaseOfImage;
+    DWORD                       ImageSize;
+    DWORD                       TimeDateStamp;
+    DWORD                       CheckSum;
+    DWORD                       NumSyms;
+    SYM_TYPE                    SymType;
+    WCHAR                       ModuleName[32];
+    WCHAR                       ImageName[256];
+    WCHAR                       LoadedImageName[256];
+    WCHAR                       LoadedPdbName[256];
+    DWORD                       CVSig;
+    WCHAR                       CVData[MAX_PATH*3];
+    DWORD                       PdbSig;
+    GUID                        PdbSig70;
+    DWORD                       PdbAge;
+    BOOL                        PdbUnmatched;
+    BOOL                        DbgUnmatched;
+    BOOL                        LineNumbers;
+    BOOL                        GlobalSymbols;
+    BOOL                        TypeInfo;
+    BOOL                        SourceIndexed;
+    BOOL                        Publics;
+} IMAGEHLP_MODULEW64, *PIMAGEHLP_MODULEW64;
+
+#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
+#define IMAGEHLP_LINE IMAGEHLP_LINE64
+#define PIMAGEHLP_LINE PIMAGEHLP_LINE64
+#define IMAGEHLP_LINEW IMAGEHLP_LINEW64
+#define PIMAGEHLP_LINEW PIMAGEHLP_LINEW64
+#else
+typedef struct _IMAGEHLP_LINE
+{
+    DWORD                       SizeOfStruct;
+    PVOID                       Key;
+    DWORD                       LineNumber;
+    PCHAR                       FileName;
+    DWORD                       Address;
+} IMAGEHLP_LINE, *PIMAGEHLP_LINE;
+
+typedef struct _IMAGEHLP_LINEW
+{
+    DWORD                       SizeOfStruct;
+    PVOID                       Key;
+    DWORD                       LineNumber;
+    PWSTR                       FileName;
+    DWORD                       Address;
+} IMAGEHLP_LINEW, *PIMAGEHLP_LINEW;
+#endif
+
+typedef struct _IMAGEHLP_LINE64
+{
+    DWORD                       SizeOfStruct;
+    PVOID                       Key;
+    DWORD                       LineNumber;
+    PCHAR                       FileName;
+    DWORD64                     Address;
+} IMAGEHLP_LINE64, *PIMAGEHLP_LINE64;
+
+typedef struct _IMAGEHLP_LINEW64
+{
+    DWORD                       SizeOfStruct;
+    PVOID                       Key;
+    DWORD                       LineNumber;
+    PWSTR                       FileName;
+    DWORD64                     Address;
+} IMAGEHLP_LINEW64, *PIMAGEHLP_LINEW64;
+
+typedef struct _SOURCEFILE
+{
+    DWORD64                     ModBase;
+    PCHAR                       FileName;
+} SOURCEFILE, *PSOURCEFILE;
+
+typedef struct _SOURCEFILEW
+{
+    DWORD64                     ModBase;
+    PWSTR                       FileName;
+} SOURCEFILEW, *PSOURCEFILEW;
+
+#define CBA_DEFERRED_SYMBOL_LOAD_START          0x00000001
+#define CBA_DEFERRED_SYMBOL_LOAD_COMPLETE       0x00000002
+#define CBA_DEFERRED_SYMBOL_LOAD_FAILURE        0x00000003
+#define CBA_SYMBOLS_UNLOADED                    0x00000004
+#define CBA_DUPLICATE_SYMBOL                    0x00000005
+#define CBA_READ_MEMORY                         0x00000006
+#define CBA_DEFERRED_SYMBOL_LOAD_CANCEL         0x00000007
+#define CBA_SET_OPTIONS                         0x00000008
+#define CBA_EVENT                               0x00000010
+#define CBA_DEFERRED_SYMBOL_LOAD_PARTIAL        0x00000020
+#define CBA_DEBUG_INFO                          0x10000000
+
+typedef struct _IMAGEHLP_CBA_READ_MEMORY
+{
+    DWORD64   addr;
+    PVOID     buf;
+    DWORD     bytes;
+    DWORD    *bytesread;
+} IMAGEHLP_CBA_READ_MEMORY, *PIMAGEHLP_CBA_READ_MEMORY;
+
+enum
+{
+    sevInfo = 0,
+    sevProblem,
+    sevAttn,
+    sevFatal,
+    sevMax
+};
+
+#define EVENT_SRCSPEW_START 100
+#define EVENT_SRCSPEW       100
+#define EVENT_SRCSPEW_END   199
+
+typedef struct _IMAGEHLP_CBA_EVENT
+{
+    DWORD       severity;
+    DWORD       code;
+    PCHAR       desc;
+    PVOID       object;
+} IMAGEHLP_CBA_EVENT, *PIMAGEHLP_CBA_EVENT;
+
+typedef struct _IMAGEHLP_CBA_EVENTW
+{
+    DWORD       severity;
+    DWORD       code;
+    PCWSTR      desc;
+    PVOID       object;
+} IMAGEHLP_CBA_EVENTW, *PIMAGEHLP_CBA_EVENTW;
+
+#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
+#define IMAGEHLP_DEFERRED_SYMBOL_LOAD IMAGEHLP_DEFERRED_SYMBOL_LOAD64
+#define PIMAGEHLP_DEFERRED_SYMBOL_LOAD PIMAGEHLP_DEFERRED_SYMBOL_LOAD64
+#else
+typedef struct _IMAGEHLP_DEFERRED_SYMBOL_LOAD
+{
+    DWORD                       SizeOfStruct;
+    DWORD                       BaseOfImage;
+    DWORD                       CheckSum;
+    DWORD                       TimeDateStamp;
+    CHAR                        FileName[MAX_PATH];
+    BOOLEAN                     Reparse;
+    HANDLE                      hFile;
+} IMAGEHLP_DEFERRED_SYMBOL_LOAD, *PIMAGEHLP_DEFERRED_SYMBOL_LOAD;
+#endif
+
+typedef struct _IMAGEHLP_DEFERRED_SYMBOL_LOAD64
+{
+    DWORD                       SizeOfStruct;
+    DWORD64                     BaseOfImage;
+    DWORD                       CheckSum;
+    DWORD                       TimeDateStamp;
+    CHAR                        FileName[MAX_PATH];
+    BOOLEAN                     Reparse;
+    HANDLE                      hFile;
+    DWORD                       Flags;
+} IMAGEHLP_DEFERRED_SYMBOL_LOAD64, *PIMAGEHLP_DEFERRED_SYMBOL_LOAD64;
+
+typedef struct _IMAGEHLP_DEFERRED_SYMBOL_LOADW64
+{
+    DWORD                       SizeOfStruct;
+    DWORD64                     BaseOfImage;
+    DWORD                       CheckSum;
+    DWORD                       TimeDateStamp;
+    WCHAR                       FileName[MAX_PATH + 1];
+    BOOLEAN                     Reparse;
+    HANDLE                      hFile;
+    DWORD                       Flags;
+} IMAGEHLP_DEFERRED_SYMBOL_LOADW64, *PIMAGEHLP_DEFERRED_SYMBOL_LOADW64;
+
+#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
+#define IMAGEHLP_DUPLICATE_SYMBOL IMAGEHLP_DUPLICATE_SYMBOL64
+#define PIMAGEHLP_DUPLICATE_SYMBOL PIMAGEHLP_DUPLICATE_SYMBOL64
+#else
+typedef struct _IMAGEHLP_DUPLICATE_SYMBOL
+{
+    DWORD                       SizeOfStruct;
+    DWORD                       NumberOfDups;
+    PIMAGEHLP_SYMBOL            Symbol;
+    DWORD                       SelectedSymbol;
+} IMAGEHLP_DUPLICATE_SYMBOL, *PIMAGEHLP_DUPLICATE_SYMBOL;
+#endif
+
+typedef struct _IMAGEHLP_DUPLICATE_SYMBOL64
+{
+    DWORD                       SizeOfStruct;
+    DWORD                       NumberOfDups;
+    PIMAGEHLP_SYMBOL64          Symbol;
+    DWORD                       SelectedSymbol;
+} IMAGEHLP_DUPLICATE_SYMBOL64, *PIMAGEHLP_DUPLICATE_SYMBOL64;
+
+#define SYMOPT_CASE_INSENSITIVE         0x00000001
+#define SYMOPT_UNDNAME                  0x00000002
+#define SYMOPT_DEFERRED_LOADS           0x00000004
+#define SYMOPT_NO_CPP                   0x00000008
+#define SYMOPT_LOAD_LINES               0x00000010
+#define SYMOPT_OMAP_FIND_NEAREST        0x00000020
+#define SYMOPT_LOAD_ANYTHING            0x00000040
+#define SYMOPT_IGNORE_CVREC             0x00000080
+#define SYMOPT_NO_UNQUALIFIED_LOADS     0x00000100
+#define SYMOPT_FAIL_CRITICAL_ERRORS     0x00000200
+#define SYMOPT_EXACT_SYMBOLS            0x00000400
+#define SYMOPT_WILD_UNDERSCORE          0x00000800
+#define SYMOPT_USE_DEFAULTS             0x00001000
+/* latest SDK defines:
+#define SYMOPT_ALLOW_ABSOLUTE_SYMBOLS   0x00000800
+#define SYMOPT_IGNORE_NT_SYMPATH        0x00001000
+*/
+#define SYMOPT_INCLUDE_32BIT_MODULES    0x00002000
+#define SYMOPT_PUBLICS_ONLY             0x00004000
+#define SYMOPT_NO_PUBLICS               0x00008000
+#define SYMOPT_AUTO_PUBLICS             0x00010000
+#define SYMOPT_NO_IMAGE_SEARCH          0x00020000
+#define SYMOPT_SECURE                   0x00040000
+#define SYMOPT_NO_PROMPTS               0x00080000
+#define SYMOPT_OVERWRITE                0x00100000
+#define SYMOPT_IGNORE_IMAGEDIR          0x00200000
+
+#define SYMOPT_DEBUG                    0x80000000
+
+typedef struct _IMAGEHLP_STACK_FRAME
+{
+    ULONG64     InstructionOffset;
+    ULONG64     ReturnOffset;
+    ULONG64     FrameOffset;
+    ULONG64     StackOffset;
+    ULONG64     BackingStoreOffset;
+    ULONG64     FuncTableEntry;
+    ULONG64     Params[4];
+    ULONG64     Reserved[5];
+    BOOL        Virtual;
+    ULONG       Reserved2;
+} IMAGEHLP_STACK_FRAME, *PIMAGEHLP_STACK_FRAME;
+
+typedef VOID IMAGEHLP_CONTEXT, *PIMAGEHLP_CONTEXT;
+
+#define DBHHEADER_DEBUGDIRS     0x1
+typedef struct _DBGHELP_MODLOAD_DATA
+{
+    DWORD               ssize;
+    DWORD               ssig;
+    PVOID               data;
+    DWORD               size;
+    DWORD               flags;
+} MODLOAD_DATA, *PMODLOAD_DATA;
+
+/*************************
+ *       MiniDUMP        *
+ *************************/
+
+#include <pshpack4.h>
+/* DebugHelp */
+
+#define MINIDUMP_SIGNATURE 0x504D444D /* 'MDMP' */
+#define MINIDUMP_VERSION   (42899)
+
+typedef DWORD   RVA;
+typedef ULONG64 RVA64;
+
+typedef enum _MINIDUMP_TYPE 
+{
+    MiniDumpNormal                              = 0x0000,
+    MiniDumpWithDataSegs                        = 0x0001,
+    MiniDumpWithFullMemory                      = 0x0002,
+    MiniDumpWithHandleData                      = 0x0004,
+    MiniDumpFilterMemory                        = 0x0008,
+    MiniDumpScanMemory                          = 0x0010,
+    MiniDumpWithUnloadedModules                 = 0x0020,
+    MiniDumpWithIndirectlyReferencedMemory      = 0x0040,
+    MiniDumpFilterModulePaths                   = 0x0080,
+    MiniDumpWithProcessThreadData               = 0x0100,
+    MiniDumpWithPrivateReadWriteMemory          = 0x0200,
+    MiniDumpWithoutOptionalData                 = 0x0400,
+    MiniDumpWithFullMemoryInfo                  = 0x0800,
+    MiniDumpWithThreadInfo                      = 0x1000,
+    MiniDumpWithCodeSegs                        = 0x2000
+} MINIDUMP_TYPE;
+
+typedef enum _MINIDUMP_CALLBACK_TYPE
+{
+    ModuleCallback,
+    ThreadCallback,
+    ThreadExCallback,
+    IncludeThreadCallback,
+    IncludeModuleCallback,
+    MemoryCallback,
+} MINIDUMP_CALLBACK_TYPE;
+
+typedef struct _MINIDUMP_THREAD_CALLBACK
+{
+    ULONG                       ThreadId;
+    HANDLE                      ThreadHandle;
+    CONTEXT                     Context;
+    ULONG                       SizeOfContext;
+    ULONG64                     StackBase;
+    ULONG64                     StackEnd;
+} MINIDUMP_THREAD_CALLBACK, *PMINIDUMP_THREAD_CALLBACK;
+
+typedef struct _MINIDUMP_THREAD_EX_CALLBACK 
+{
+    ULONG                       ThreadId;
+    HANDLE                      ThreadHandle;
+    CONTEXT                     Context;
+    ULONG                       SizeOfContext;
+    ULONG64                     StackBase;
+    ULONG64                     StackEnd;
+    ULONG64                     BackingStoreBase;
+    ULONG64                     BackingStoreEnd;
+} MINIDUMP_THREAD_EX_CALLBACK, *PMINIDUMP_THREAD_EX_CALLBACK;
+
+typedef struct _MINIDUMP_INCLUDE_THREAD_CALLBACK
+{
+    ULONG ThreadId;
+} MINIDUMP_INCLUDE_THREAD_CALLBACK, *PMINIDUMP_INCLUDE_THREAD_CALLBACK;
+
+typedef enum _THREAD_WRITE_FLAGS 
+{
+    ThreadWriteThread            = 0x0001,
+    ThreadWriteStack             = 0x0002,
+    ThreadWriteContext           = 0x0004,
+    ThreadWriteBackingStore      = 0x0008,
+    ThreadWriteInstructionWindow = 0x0010,
+    ThreadWriteThreadData        = 0x0020,
+    ThreadWriteThreadInfo        = 0x0040
+} THREAD_WRITE_FLAGS;
+
+typedef struct _MINIDUMP_MODULE_CALLBACK 
+{
+    PWCHAR                      FullPath;
+    ULONG64                     BaseOfImage;
+    ULONG                       SizeOfImage;
+    ULONG                       CheckSum;
+    ULONG                       TimeDateStamp;
+    VS_FIXEDFILEINFO            VersionInfo;
+    PVOID                       CvRecord;
+    ULONG                       SizeOfCvRecord;
+    PVOID                       MiscRecord;
+    ULONG                       SizeOfMiscRecord;
+} MINIDUMP_MODULE_CALLBACK, *PMINIDUMP_MODULE_CALLBACK;
+
+typedef struct _MINIDUMP_INCLUDE_MODULE_CALLBACK 
+{
+    ULONG64 BaseOfImage;
+} MINIDUMP_INCLUDE_MODULE_CALLBACK, *PMINIDUMP_INCLUDE_MODULE_CALLBACK;
+
+typedef enum _MODULE_WRITE_FLAGS 
+{
+    ModuleWriteModule        = 0x0001,
+    ModuleWriteDataSeg       = 0x0002,
+    ModuleWriteMiscRecord    = 0x0004,
+    ModuleWriteCvRecord      = 0x0008,
+    ModuleReferencedByMemory = 0x0010,
+    ModuleWriteTlsData       = 0x0020,
+    ModuleWriteCodeSegs      = 0x0040,
+} MODULE_WRITE_FLAGS;
+
+typedef struct _MINIDUMP_CALLBACK_INPUT 
+{
+    ULONG                       ProcessId;
+    HANDLE                      ProcessHandle;
+    ULONG                       CallbackType;
+    union 
+    {
+        MINIDUMP_THREAD_CALLBACK        Thread;
+        MINIDUMP_THREAD_EX_CALLBACK     ThreadEx;
+        MINIDUMP_MODULE_CALLBACK        Module;
+        MINIDUMP_INCLUDE_THREAD_CALLBACK IncludeThread;
+        MINIDUMP_INCLUDE_MODULE_CALLBACK IncludeModule;
+    } DUMMYUNIONNAME;
+} MINIDUMP_CALLBACK_INPUT, *PMINIDUMP_CALLBACK_INPUT;
+
+typedef struct _MINIDUMP_CALLBACK_OUTPUT
+{
+    union 
+    {
+        ULONG                           ModuleWriteFlags;
+        ULONG                           ThreadWriteFlags;
+        struct
+        {
+            ULONG64                     MemoryBase;
+            ULONG                       MemorySize;
+        } DUMMYSTRUCTNAME;
+    } DUMMYUNIONNAME;
+} MINIDUMP_CALLBACK_OUTPUT, *PMINIDUMP_CALLBACK_OUTPUT;
+
+typedef BOOL (WINAPI* MINIDUMP_CALLBACK_ROUTINE)(PVOID, const PMINIDUMP_CALLBACK_INPUT, PMINIDUMP_CALLBACK_OUTPUT);
+
+typedef struct _MINIDUMP_CALLBACK_INFORMATION 
+{
+    MINIDUMP_CALLBACK_ROUTINE   CallbackRoutine;
+    void*                       CallbackParam;
+} MINIDUMP_CALLBACK_INFORMATION, *PMINIDUMP_CALLBACK_INFORMATION;
+
+typedef struct _MINIDUMP_LOCATION_DESCRIPTOR 
+{
+    ULONG                       DataSize;
+    RVA                         Rva;
+} MINIDUMP_LOCATION_DESCRIPTOR;
+
+typedef struct _MINIDUMP_LOCATION_DESCRIPTOR64 
+{
+    ULONG64                     DataSize;
+    RVA64                       Rva;
+} MINIDUMP_LOCATION_DESCRIPTOR64;
+
+typedef struct _MINIDUMP_DIRECTORY 
+{
+    ULONG                       StreamType;
+    MINIDUMP_LOCATION_DESCRIPTOR Location;
+} MINIDUMP_DIRECTORY, *PMINIDUMP_DIRECTORY;
+
+typedef struct _MINIDUMP_EXCEPTION
+{
+    ULONG                       ExceptionCode;
+    ULONG                       ExceptionFlags;
+    ULONG64                     ExceptionRecord;
+    ULONG64                     ExceptionAddress;
+    ULONG                       NumberParameters;
+    ULONG                        __unusedAlignment;
+    ULONG64                     ExceptionInformation[EXCEPTION_MAXIMUM_PARAMETERS];
+} MINIDUMP_EXCEPTION, *PMINIDUMP_EXCEPTION;
+
+typedef struct _MINIDUMP_EXCEPTION_INFORMATION
+{
+    DWORD                       ThreadId;
+    PEXCEPTION_POINTERS         ExceptionPointers;
+    BOOL                        ClientPointers;
+} MINIDUMP_EXCEPTION_INFORMATION, *PMINIDUMP_EXCEPTION_INFORMATION;
+
+typedef struct MINIDUMP_EXCEPTION_STREAM 
+{
+    ULONG                       ThreadId;
+    ULONG                       __alignment;
+    MINIDUMP_EXCEPTION          ExceptionRecord;
+    MINIDUMP_LOCATION_DESCRIPTOR ThreadContext;
+} MINIDUMP_EXCEPTION_STREAM, *PMINIDUMP_EXCEPTION_STREAM;
+
+typedef struct _MINIDUMP_HEADER 
+{
+    DWORD                       Signature;
+    DWORD                       Version;
+    DWORD                       NumberOfStreams;
+    RVA                         StreamDirectoryRva;
+    DWORD                       CheckSum;
+    union 
+    {
+        DWORD                           Reserved;
+        DWORD                           TimeDateStamp;
+    } DUMMYUNIONNAME;
+    ULONG64                     Flags;
+} MINIDUMP_HEADER, *PMINIDUMP_HEADER;
+
+typedef struct _MINIDUMP_MEMORY_DESCRIPTOR 
+{
+    ULONG64                     StartOfMemoryRange;
+    MINIDUMP_LOCATION_DESCRIPTOR Memory;
+} MINIDUMP_MEMORY_DESCRIPTOR, *PMINIDUMP_MEMORY_DESCRIPTOR;
+
+typedef struct _MINIDUMP_MEMORY_LIST
+{
+    ULONG                       NumberOfMemoryRanges;
+    MINIDUMP_MEMORY_DESCRIPTOR  MemoryRanges[1]; /* FIXME: 0-sized array not supported */
+} MINIDUMP_MEMORY_LIST, *PMINIDUMP_MEMORY_LIST;
+
+#define MINIDUMP_MISC1_PROCESS_ID       0x00000001
+#define MINIDUMP_MISC1_PROCESS_TIMES    0x00000002
+
+typedef struct _MINIDUMP_MISC_INFO
+{
+    ULONG                       SizeOfInfo;
+    ULONG                       Flags1;
+    ULONG                       ProcessId;
+    ULONG                       ProcessCreateTime;
+    ULONG                       ProcessUserTime;
+    ULONG                       ProcessKernelTime;
+} MINIDUMP_MISC_INFO, *PMINIDUMP_MISC_INFO;
+
+typedef struct _MINIDUMP_MODULE
+{
+    ULONG64                     BaseOfImage;
+    ULONG                       SizeOfImage;
+    ULONG                       CheckSum;
+    ULONG                       TimeDateStamp;
+    RVA                         ModuleNameRva;
+    VS_FIXEDFILEINFO            VersionInfo;
+    MINIDUMP_LOCATION_DESCRIPTOR CvRecord;
+    MINIDUMP_LOCATION_DESCRIPTOR MiscRecord;
+    ULONG64                     Reserved0;
+    ULONG64                     Reserved1;
+} MINIDUMP_MODULE, *PMINIDUMP_MODULE;
+
+typedef struct _MINIDUMP_MODULE_LIST 
+{
+    ULONG                       NumberOfModules;
+    MINIDUMP_MODULE             Modules[1]; /* FIXME: 0-sized array not supported */
+} MINIDUMP_MODULE_LIST, *PMINIDUMP_MODULE_LIST;
+
+typedef struct _MINIDUMP_STRING
+{
+    ULONG                       Length;
+    WCHAR                       Buffer[1]; /* FIXME: O-sized array not supported */
+} MINIDUMP_STRING, *PMINIDUMP_STRING;
+
+typedef struct _MINIDUMP_SYSTEM_INFO
+{
+    USHORT                      ProcessorArchitecture;
+    USHORT                      ProcessorLevel;
+    USHORT                      ProcessorRevision;
+    union
+    {
+        USHORT                          Reserved0;
+        struct
+        {
+            UCHAR                       NumberOfProcessors;
+            UCHAR                       ProductType;
+        } DUMMYSTRUCTNAME;
+    } DUMMYUNIONNAME;
+
+    ULONG                       MajorVersion;
+    ULONG                       MinorVersion;
+    ULONG                       BuildNumber;
+    ULONG                       PlatformId;
+
+    RVA                         CSDVersionRva;
+    union
+    {
+        ULONG                           Reserved1;
+        struct
+        {
+            USHORT                      SuiteMask;
+            USHORT                      Reserved2;
+        } DUMMYSTRUCTNAME;
+    } DUMMYUNIONNAME1;
+    union _CPU_INFORMATION 
+    {
+        struct 
+        {
+            ULONG                       VendorId[3];
+            ULONG                       VersionInformation;
+            ULONG                       FeatureInformation;
+            ULONG                       AMDExtendedCpuFeatures;
+        } X86CpuInfo;
+        struct 
+        {
+            ULONG64                     ProcessorFeatures[2];
+        } OtherCpuInfo;
+    } Cpu;
+
+} MINIDUMP_SYSTEM_INFO, *PMINIDUMP_SYSTEM_INFO;
+
+typedef struct _MINIDUMP_THREAD
+{
+    ULONG                       ThreadId;
+    ULONG                       SuspendCount;
+    ULONG                       PriorityClass;
+    ULONG                       Priority;
+    ULONG64                     Teb;
+    MINIDUMP_MEMORY_DESCRIPTOR  Stack;
+    MINIDUMP_LOCATION_DESCRIPTOR ThreadContext;
+} MINIDUMP_THREAD, *PMINIDUMP_THREAD;
+
+typedef struct _MINIDUMP_THREAD_LIST
+{
+    ULONG                       NumberOfThreads;
+    MINIDUMP_THREAD             Threads[1]; /* FIXME: no support of 0 sized array */
+} MINIDUMP_THREAD_LIST, *PMINIDUMP_THREAD_LIST;
+
+typedef struct _MINIDUMP_USER_STREAM
+{
+    ULONG                       Type;
+    ULONG                       BufferSize;
+    void*                       Buffer;
+} MINIDUMP_USER_STREAM, *PMINIDUMP_USER_STREAM;
+
+typedef struct _MINIDUMP_USER_STREAM_INFORMATION
+{
+    ULONG                       UserStreamCount;
+    PMINIDUMP_USER_STREAM       UserStreamArray;
+} MINIDUMP_USER_STREAM_INFORMATION, *PMINIDUMP_USER_STREAM_INFORMATION;
+
+typedef enum _MINIDUMP_STREAM_TYPE
+{
+    UnusedStream                = 0,
+    ReservedStream0             = 1,
+    ReservedStream1             = 2,
+    ThreadListStream            = 3,
+    ModuleListStream            = 4,
+    MemoryListStream            = 5,
+    ExceptionStream             = 6,
+    SystemInfoStream            = 7,
+    ThreadExListStream          = 8,
+    Memory64ListStream          = 9,
+    CommentStreamA              = 10,
+    CommentStreamW              = 11,
+    HandleDataStream            = 12,
+    FunctionTableStream         = 13,
+    UnloadedModuleListStream    = 14,
+    MiscInfoStream              = 15,
+    MemoryInfoListStream        = 16,
+    ThreadInfoListStream        = 17,
+
+    LastReservedStream          = 0xffff
+} MINIDUMP_STREAM_TYPE;
+
+BOOL WINAPI MiniDumpWriteDump(HANDLE, DWORD, HANDLE, MINIDUMP_TYPE,
+                              const PMINIDUMP_EXCEPTION_INFORMATION,
+                              const PMINIDUMP_USER_STREAM_INFORMATION,
+                              const PMINIDUMP_CALLBACK_INFORMATION);
+BOOL WINAPI MiniDumpReadDumpStream(PVOID, ULONG, PMINIDUMP_DIRECTORY*, PVOID*,
+                                   ULONG*);
+
+#include <poppack.h>
+
+/*************************
+ *    MODULE handling    *
+ *************************/
+
+/* flags for SymLoadModuleEx */
+#define SLMFLAG_VIRTUAL         0x1
+#define SLMFLAG_NO_SYMBOLS      0x4
+
+typedef BOOL (CALLBACK *PENUMLOADED_MODULES_CALLBACK64)(PCSTR, DWORD64, ULONG, PVOID);
+BOOL   WINAPI EnumerateLoadedModules64(HANDLE, PENUMLOADED_MODULES_CALLBACK64, PVOID);
+typedef BOOL (CALLBACK *PENUMLOADED_MODULES_CALLBACKW64)(PCWSTR, DWORD64, ULONG, PVOID);
+BOOL   WINAPI EnumerateLoadedModulesW64(HANDLE, PENUMLOADED_MODULES_CALLBACKW64, PVOID);
+typedef BOOL (CALLBACK *PSYM_ENUMMODULES_CALLBACK64)(PCSTR, DWORD64, PVOID);
+BOOL    WINAPI SymEnumerateModules64(HANDLE, PSYM_ENUMMODULES_CALLBACK64, PVOID);
+typedef BOOL (CALLBACK *PSYM_ENUMMODULES_CALLBACKW64)(PCWSTR, DWORD64, PVOID);
+BOOL    WINAPI SymEnumerateModulesW64(HANDLE, PSYM_ENUMMODULES_CALLBACKW64, PVOID);
+BOOL    WINAPI SymGetModuleInfo64(HANDLE, DWORD64, PIMAGEHLP_MODULE64);
+BOOL    WINAPI SymGetModuleInfoW64(HANDLE, DWORD64, PIMAGEHLP_MODULEW64);
+DWORD64 WINAPI SymGetModuleBase64(HANDLE, DWORD64);
+DWORD64 WINAPI SymLoadModule64(HANDLE, HANDLE, PCSTR, PCSTR, DWORD64, DWORD);
+DWORD64 WINAPI SymLoadModuleEx(HANDLE, HANDLE, PCSTR, PCSTR, DWORD64, DWORD,
+                               PMODLOAD_DATA, DWORD);
+DWORD64 WINAPI SymLoadModuleExW(HANDLE, HANDLE, PCWSTR, PCWSTR, DWORD64, DWORD,
+                                PMODLOAD_DATA, DWORD);
+BOOL    WINAPI SymUnloadModule64(HANDLE, DWORD64);
+
+/*************************
+ *    Symbol Handling    *
+ *************************/
+
+#define IMAGEHLP_SYMBOL_INFO_VALUEPRESENT          1
+#define IMAGEHLP_SYMBOL_INFO_REGISTER              SYMF_REGISTER        /*  0x08 */
+#define IMAGEHLP_SYMBOL_INFO_REGRELATIVE           SYMF_REGREL          /*  0x10 */
+#define IMAGEHLP_SYMBOL_INFO_FRAMERELATIVE         SYMF_FRAMEREL        /*  0x20 */
+#define IMAGEHLP_SYMBOL_INFO_PARAMETER             SYMF_PARAMETER       /*  0x40 */
+#define IMAGEHLP_SYMBOL_INFO_LOCAL                 SYMF_LOCAL           /*  0x80 */
+#define IMAGEHLP_SYMBOL_INFO_CONSTANT              SYMF_CONSTANT        /* 0x100 */
+#define IMAGEHLP_SYMBOL_FUNCTION                   SYMF_FUNCTION        /* 0x800 */
+
+#define SYMFLAG_VALUEPRESENT     0x00000001
+#define SYMFLAG_REGISTER         0x00000008
+#define SYMFLAG_REGREL           0x00000010
+#define SYMFLAG_FRAMEREL         0x00000020
+#define SYMFLAG_PARAMETER        0x00000040
+#define SYMFLAG_LOCAL            0x00000080
+#define SYMFLAG_CONSTANT         0x00000100
+#define SYMFLAG_EXPORT           0x00000200
+#define SYMFLAG_FORWARDER        0x00000400
+#define SYMFLAG_FUNCTION         0x00000800
+#define SYMFLAG_VIRTUAL          0x00001000
+#define SYMFLAG_THUNK            0x00002000
+#define SYMFLAG_TLSREL           0x00004000
+#define SYMFLAG_SLOT             0x00008000
+
+#define MAX_SYM_NAME    2000
+
+typedef struct _SYMBOL_INFO
+{
+    ULONG       SizeOfStruct;
+    ULONG       TypeIndex;
+    ULONG64     Reserved[2];
+    ULONG       info;   /* sdk states info, while MSDN says it's Index... */
+    ULONG       Size;
+    ULONG64     ModBase;
+    ULONG       Flags;
+    ULONG64     Value;
+    ULONG64     Address;
+    ULONG       Register;
+    ULONG       Scope;
+    ULONG       Tag;
+    ULONG       NameLen;
+    ULONG       MaxNameLen;
+    CHAR        Name[1];
+} SYMBOL_INFO, *PSYMBOL_INFO;
+
+typedef struct _SYMBOL_INFOW
+{
+    ULONG       SizeOfStruct;
+    ULONG       TypeIndex;
+    ULONG64     Reserved[2];
+    ULONG       Index;
+    ULONG       Size;
+    ULONG64     ModBase;
+    ULONG       Flags;
+    ULONG64     Value;
+    ULONG64     Address;
+    ULONG       Register;
+    ULONG       Scope;
+    ULONG       Tag;
+    ULONG       NameLen;
+    ULONG       MaxNameLen;
+    WCHAR       Name[1];
+} SYMBOL_INFOW, *PSYMBOL_INFOW;
+
+typedef struct _SYMBOL_INFO_PACKAGE
+{
+    SYMBOL_INFO si;
+    CHAR        name[MAX_SYM_NAME+1];
+} SYMBOL_INFO_PACKAGE, *PSYMBOL_INFO_PACKAGE;
+
+typedef struct _SYMBOL_INFO_PACKAGEW
+{
+    SYMBOL_INFOW si;
+    WCHAR        name[MAX_SYM_NAME+1];
+} SYMBOL_INFO_PACKAGEW, *PSYMBOL_INFO_PACKAGEW;
+
+typedef enum _IMAGEHLP_SYMBOL_TYPE_INFO 
+{
+    TI_GET_SYMTAG,
+    TI_GET_SYMNAME,
+    TI_GET_LENGTH,
+    TI_GET_TYPE,
+    TI_GET_TYPEID,
+    TI_GET_BASETYPE,
+    TI_GET_ARRAYINDEXTYPEID,
+    TI_FINDCHILDREN,
+    TI_GET_DATAKIND,
+    TI_GET_ADDRESSOFFSET,
+    TI_GET_OFFSET,
+    TI_GET_VALUE,
+    TI_GET_COUNT,
+    TI_GET_CHILDRENCOUNT,
+    TI_GET_BITPOSITION,
+    TI_GET_VIRTUALBASECLASS,
+    TI_GET_VIRTUALTABLESHAPEID,
+    TI_GET_VIRTUALBASEPOINTEROFFSET,
+    TI_GET_CLASSPARENTID,
+    TI_GET_NESTED,
+    TI_GET_SYMINDEX,
+    TI_GET_LEXICALPARENT,
+    TI_GET_ADDRESS,
+    TI_GET_THISADJUST,
+    TI_GET_UDTKIND,
+    TI_IS_EQUIV_TO,
+    TI_GET_CALLING_CONVENTION,
+} IMAGEHLP_SYMBOL_TYPE_INFO;
+
+#define IMAGEHLP_GET_TYPE_INFO_UNCACHED            0x00000001
+#define IMAGEHLP_GET_TYPE_INFO_CHILDREN            0x00000002
+typedef struct _IMAGEHLP_GET_TYPE_INFO_PARAMS
+{
+    ULONG       SizeOfStruct;
+    ULONG       Flags;
+    ULONG       NumIds;
+    PULONG      TypeIds;
+    ULONG64     TagFilter;
+    ULONG       NumReqs;
+    IMAGEHLP_SYMBOL_TYPE_INFO* ReqKinds;
+    PULONG_PTR  ReqOffsets;
+    PULONG      ReqSizes;
+    ULONG_PTR   ReqStride;
+    ULONG_PTR   BufferSize;
+    PVOID       Buffer;
+    ULONG       EntriesMatched;
+    ULONG       EntriesFilled;
+    ULONG64     TagsFound;
+    ULONG64     AllReqsValid;
+    ULONG       NumReqsValid;
+    PULONG64    ReqsValid;
+} IMAGEHLP_GET_TYPE_INFO_PARAMS, *PIMAGEHLP_GET_TYPE_INFO_PARAMS;
+
+typedef struct _TI_FINDCHILDREN_PARAMS 
+{
+    ULONG Count;
+    ULONG Start;
+    ULONG ChildId[1];
+} TI_FINDCHILDREN_PARAMS;
+
+#define UNDNAME_COMPLETE                 (0x0000)
+#define UNDNAME_NO_LEADING_UNDERSCORES   (0x0001)
+#define UNDNAME_NO_MS_KEYWORDS           (0x0002)
+#define UNDNAME_NO_FUNCTION_RETURNS      (0x0004)
+#define UNDNAME_NO_ALLOCATION_MODEL      (0x0008)
+#define UNDNAME_NO_ALLOCATION_LANGUAGE   (0x0010)
+#define UNDNAME_NO_MS_THISTYPE           (0x0020)
+#define UNDNAME_NO_CV_THISTYPE           (0x0040)
+#define UNDNAME_NO_THISTYPE              (0x0060)
+#define UNDNAME_NO_ACCESS_SPECIFIERS     (0x0080)
+#define UNDNAME_NO_THROW_SIGNATURES      (0x0100)
+#define UNDNAME_NO_MEMBER_TYPE           (0x0200)
+#define UNDNAME_NO_RETURN_UDT_MODEL      (0x0400)
+#define UNDNAME_32_BIT_DECODE            (0x0800)
+#define UNDNAME_NAME_ONLY                (0x1000)
+#define UNDNAME_NO_ARGUMENTS             (0x2000)
+#define UNDNAME_NO_SPECIAL_SYMS          (0x4000)
+
+#define SYMSEARCH_MASKOBJS              0x01
+#define SYMSEARCH_RECURSE               0x02
+#define SYMSEARCH_GLOBALSONLY           0x04
+
+BOOL WINAPI SymGetTypeInfo(HANDLE, DWORD64, ULONG, IMAGEHLP_SYMBOL_TYPE_INFO, PVOID);
+BOOL WINAPI SymGetTypeInfoEx(HANDLE, DWORD64, PIMAGEHLP_GET_TYPE_INFO_PARAMS);
+typedef BOOL (CALLBACK *PSYM_ENUMERATESYMBOLS_CALLBACK)(PSYMBOL_INFO, ULONG, PVOID);
+typedef BOOL (CALLBACK *PSYM_ENUMERATESYMBOLS_CALLBACKW)(PSYMBOL_INFOW, ULONG, PVOID);
+BOOL WINAPI SymEnumTypes(HANDLE, ULONG64, PSYM_ENUMERATESYMBOLS_CALLBACK, PVOID);
+BOOL WINAPI SymEnumTypesW(HANDLE, ULONG64, PSYM_ENUMERATESYMBOLS_CALLBACKW, PVOID);
+BOOL WINAPI SymFromAddr(HANDLE, DWORD64, DWORD64*, SYMBOL_INFO*);
+BOOL WINAPI SymFromAddrW(HANDLE, DWORD64, DWORD64*, SYMBOL_INFOW*);
+BOOL WINAPI SymFromToken(HANDLE, DWORD64, DWORD, PSYMBOL_INFO);
+BOOL WINAPI SymFromTokenW(HANDLE, DWORD64, DWORD, PSYMBOL_INFOW);
+BOOL WINAPI SymFromName(HANDLE, PCSTR, PSYMBOL_INFO);
+BOOL WINAPI SymFromNameW(HANDLE, PCWSTR, PSYMBOL_INFOW);
+BOOL WINAPI SymGetSymFromAddr64(HANDLE, DWORD64, PDWORD64, PIMAGEHLP_SYMBOL64);
+BOOL WINAPI SymGetSymFromName64(HANDLE, PCSTR, PIMAGEHLP_SYMBOL64);
+BOOL WINAPI SymGetTypeFromName(HANDLE, ULONG64, PCSTR, PSYMBOL_INFO);
+BOOL WINAPI SymGetTypeFromNameW(HANDLE, ULONG64, PCWSTR, PSYMBOL_INFOW);
+BOOL WINAPI SymGetSymNext64(HANDLE, PIMAGEHLP_SYMBOL64);
+BOOL WINAPI SymGetSymNextW64(HANDLE, PIMAGEHLP_SYMBOLW64);
+BOOL WINAPI SymGetSymPrev64(HANDLE, PIMAGEHLP_SYMBOL64);
+BOOL WINAPI SymGetSymPrevW64(HANDLE, PIMAGEHLP_SYMBOLW64);
+BOOL WINAPI SymEnumSym(HANDLE,ULONG64,PSYM_ENUMERATESYMBOLS_CALLBACK,PVOID);
+BOOL WINAPI SymEnumSymbols(HANDLE, ULONG64, PCSTR, PSYM_ENUMERATESYMBOLS_CALLBACK,
+                           PVOID);
+BOOL WINAPI SymEnumSymbolsW(HANDLE, ULONG64, PCWSTR, PSYM_ENUMERATESYMBOLS_CALLBACKW,
+                            PVOID);
+typedef BOOL (CALLBACK *PSYM_ENUMSYMBOLS_CALLBACK64)(PCSTR, DWORD64, ULONG, PVOID);
+typedef BOOL (CALLBACK *PSYM_ENUMSYMBOLS_CALLBACK64W)(PCWSTR, DWORD64, ULONG, PVOID);
+BOOL WINAPI SymEnumerateSymbols64(HANDLE, ULONG64, PSYM_ENUMSYMBOLS_CALLBACK64, PVOID);
+BOOL WINAPI SymEnumerateSymbolsW64(HANDLE, ULONG64, PSYM_ENUMSYMBOLS_CALLBACK64W, PVOID);
+BOOL WINAPI SymEnumSymbolsForAddr(HANDLE, DWORD64, PSYM_ENUMERATESYMBOLS_CALLBACK, PVOID);
+BOOL WINAPI SymEnumSymbolsForAddrW(HANDLE, DWORD64, PSYM_ENUMERATESYMBOLS_CALLBACKW, PVOID);
+typedef BOOL (CALLBACK *PSYMBOL_REGISTERED_CALLBACK64)(HANDLE, ULONG, ULONG64, ULONG64);
+BOOL WINAPI SymRegisterCallback64(HANDLE, PSYMBOL_REGISTERED_CALLBACK64, ULONG64);
+BOOL WINAPI SymRegisterCallbackW64(HANDLE, PSYMBOL_REGISTERED_CALLBACK64, ULONG64);
+BOOL WINAPI SymUnDName64(PIMAGEHLP_SYMBOL64, PSTR, DWORD);
+BOOL WINAPI SymMatchString(PCSTR, PCSTR, BOOL);
+BOOL WINAPI SymMatchStringA(PCSTR, PCSTR, BOOL);
+BOOL WINAPI SymMatchStringW(PCWSTR, PCWSTR, BOOL);
+BOOL WINAPI SymSearch(HANDLE, ULONG64, DWORD, DWORD, PCSTR, DWORD64, PSYM_ENUMERATESYMBOLS_CALLBACK, PVOID, DWORD);
+BOOL WINAPI SymSearchW(HANDLE, ULONG64, DWORD, DWORD, PCWSTR, DWORD64, PSYM_ENUMERATESYMBOLS_CALLBACKW, PVOID, DWORD);
+DWORD WINAPI UnDecorateSymbolName(PCSTR, PSTR, DWORD, DWORD);
+DWORD WINAPI UnDecorateSymbolNameW(PCWSTR, PWSTR, DWORD, DWORD);
+BOOL WINAPI SymGetScope(HANDLE, ULONG64, DWORD, PSYMBOL_INFO);
+BOOL WINAPI SymGetScopeW(HANDLE, ULONG64, DWORD, PSYMBOL_INFOW);
+BOOL WINAPI SymFromIndex(HANDLE, ULONG64, DWORD, PSYMBOL_INFO);
+BOOL WINAPI SymFromIndexW(HANDLE, ULONG64, DWORD, PSYMBOL_INFOW);
+BOOL WINAPI SymAddSymbol(HANDLE, ULONG64, PCSTR, DWORD64, DWORD, DWORD);
+BOOL WINAPI SymAddSymbolW(HANDLE, ULONG64, PCWSTR, DWORD64, DWORD, DWORD);
+BOOL WINAPI SymDeleteSymbol(HANDLE, ULONG64, PCSTR, DWORD64, DWORD);
+BOOL WINAPI SymDeleteSymbolW(HANDLE, ULONG64, PCWSTR, DWORD64, DWORD);
+
+/*************************
+ *      Source Files     *
+ *************************/
+typedef BOOL (CALLBACK *PSYM_ENUMSOURCEFILES_CALLBACK)(PSOURCEFILE, PVOID);
+typedef BOOL (CALLBACK *PSYM_ENUMSOURCEFILES_CALLBACKW)(PSOURCEFILEW, PVOID);
+
+BOOL WINAPI SymEnumSourceFiles(HANDLE, ULONG64, PCSTR, PSYM_ENUMSOURCEFILES_CALLBACK,
+                               PVOID);
+BOOL WINAPI SymEnumSourceFilesW(HANDLE, ULONG64, PCWSTR, PSYM_ENUMSOURCEFILES_CALLBACKW, PVOID);
+BOOL WINAPI SymGetLineFromAddr64(HANDLE, DWORD64, PDWORD, PIMAGEHLP_LINE64);
+BOOL WINAPI SymGetLineFromAddrW64(HANDLE, DWORD64, PDWORD, PIMAGEHLP_LINEW64);
+BOOL WINAPI SymGetLinePrev64(HANDLE, PIMAGEHLP_LINE64);
+BOOL WINAPI SymGetLinePrevW64(HANDLE, PIMAGEHLP_LINEW64);
+BOOL WINAPI SymGetLineNext64(HANDLE, PIMAGEHLP_LINE64);
+BOOL WINAPI SymGetLineNextW64(HANDLE, PIMAGEHLP_LINEW64);
+BOOL WINAPI SymGetLineFromName64(HANDLE, PCSTR, PCSTR, DWORD, PLONG, PIMAGEHLP_LINE64);
+BOOL WINAPI SymGetLineFromNameW64(HANDLE, PCWSTR, PCWSTR, DWORD, PLONG, PIMAGEHLP_LINEW64);
+ULONG WINAPI SymGetFileLineOffsets64(HANDLE, PCSTR, PCSTR, PDWORD64, ULONG);
+BOOL WINAPI SymGetSourceFile(HANDLE, ULONG64, PCSTR, PCSTR, PSTR, DWORD);
+BOOL WINAPI SymGetSourceFileW(HANDLE, ULONG64, PCWSTR, PCWSTR, PWSTR, DWORD);
+BOOL WINAPI SymGetSourceFileToken(HANDLE, ULONG64, PCSTR, PVOID*, DWORD*);
+BOOL WINAPI SymGetSourceFileTokenW(HANDLE, ULONG64, PCWSTR, PVOID*, DWORD*);
+BOOL WINAPI SymGetSourceFileFromToken(HANDLE, PVOID, PCSTR, PSTR, DWORD);
+BOOL WINAPI SymGetSourceFileFromTokenW(HANDLE, PVOID, PCWSTR, PWSTR, DWORD);
+BOOL WINAPI SymGetSourceVarFromToken(HANDLE, PVOID, PCSTR, PCSTR, PSTR, DWORD);
+BOOL WINAPI SymGetSourceVarFromTokenW(HANDLE, PVOID, PCWSTR, PCWSTR, PWSTR, DWORD);
+
+typedef struct _SRCCODEINFO
+{
+    DWORD       SizeOfStruct;
+    PVOID       Key;
+    DWORD64     ModBase;
+    CHAR        Obj[MAX_PATH+1];
+    CHAR        FileName[MAX_PATH+1];
+    DWORD       LineNumber;
+    DWORD64     Address;
+} SRCCODEINFO, *PSRCCODEINFO;
+
+typedef struct _SRCCODEINFOW
+{
+    DWORD       SizeOfStruct;
+    PVOID       Key;
+    DWORD64     ModBase;
+    WCHAR       Obj[MAX_PATH+1];
+    WCHAR       FileName[MAX_PATH+1];
+    DWORD       LineNumber;
+    DWORD64     Address;
+} SRCCODEINFOW, *PSRCCODEINFOW;
+
+typedef BOOL (CALLBACK* PSYM_ENUMLINES_CALLBACK)(PSRCCODEINFO, PVOID);
+typedef BOOL (CALLBACK* PSYM_ENUMLINES_CALLBACKW)(PSRCCODEINFOW, PVOID);
+BOOL WINAPI SymEnumLines(HANDLE, ULONG64, PCSTR, PCSTR, PSYM_ENUMLINES_CALLBACK, PVOID);
+BOOL WINAPI SymEnumLinesW(HANDLE, ULONG64, PCWSTR, PCWSTR, PSYM_ENUMLINES_CALLBACKW, PVOID);
+BOOL WINAPI SymEnumSourceLines(HANDLE, ULONG64, PCSTR, PCSTR, DWORD, DWORD, PSYM_ENUMLINES_CALLBACK, PVOID);
+BOOL WINAPI SymEnumSourceLinesW(HANDLE, ULONG64, PCWSTR, PCWSTR, DWORD, DWORD, PSYM_ENUMLINES_CALLBACKW, PVOID);
+
+/*************************
+ * File & image handling *
+ *************************/
+BOOL WINAPI SymInitialize(HANDLE, PCSTR, BOOL);
+BOOL WINAPI SymInitializeW(HANDLE, PCWSTR, BOOL);
+BOOL WINAPI SymCleanup(HANDLE);
+
+HANDLE WINAPI FindDebugInfoFile(PCSTR, PCSTR, PSTR);
+typedef BOOL (CALLBACK *PFIND_DEBUG_FILE_CALLBACK)(HANDLE, PCSTR, PVOID);
+typedef BOOL (CALLBACK *PFIND_DEBUG_FILE_CALLBACKW)(HANDLE, PCWSTR, PVOID);
+HANDLE WINAPI FindDebugInfoFileEx(PCSTR, PCSTR, PSTR, PFIND_DEBUG_FILE_CALLBACK, PVOID);
+HANDLE WINAPI FindDebugInfoFileExW(PCWSTR, PCWSTR, PWSTR, PFIND_DEBUG_FILE_CALLBACKW, PVOID);
+HANDLE WINAPI SymFindDebugInfoFile(HANDLE, PCSTR, PSTR, PFIND_DEBUG_FILE_CALLBACK, PVOID);
+HANDLE WINAPI SymFindDebugInfoFileW(HANDLE, PCWSTR, PWSTR, PFIND_DEBUG_FILE_CALLBACKW, PVOID);
+typedef BOOL (CALLBACK *PFINDFILEINPATHCALLBACK)(PCSTR, PVOID);
+typedef BOOL (CALLBACK *PFINDFILEINPATHCALLBACKW)(PCWSTR, PVOID);
+BOOL WINAPI FindFileInPath(HANDLE, PCSTR, PCSTR, PVOID, DWORD, DWORD, DWORD,
+                           PSTR, PFINDFILEINPATHCALLBACK, PVOID);
+BOOL WINAPI SymFindFileInPath(HANDLE, PCSTR, PCSTR, PVOID, DWORD, DWORD, DWORD,
+                              PSTR, PFINDFILEINPATHCALLBACK, PVOID);
+BOOL WINAPI SymFindFileInPathW(HANDLE, PCWSTR, PCWSTR, PVOID, DWORD, DWORD, DWORD,
+                              PWSTR, PFINDFILEINPATHCALLBACKW, PVOID);
+HANDLE WINAPI FindExecutableImage(PCSTR, PCSTR, PSTR);
+typedef BOOL (CALLBACK *PFIND_EXE_FILE_CALLBACK)(HANDLE, PCSTR, PVOID);
+typedef BOOL (CALLBACK *PFIND_EXE_FILE_CALLBACKW)(HANDLE, PCWSTR, PVOID);
+HANDLE WINAPI FindExecutableImageEx(PCSTR, PCSTR, PSTR, PFIND_EXE_FILE_CALLBACK, PVOID);
+HANDLE WINAPI FindExecutableImageExW(PCWSTR, PCWSTR, PWSTR, PFIND_EXE_FILE_CALLBACKW, PVOID);
+HANDLE WINAPI SymFindExecutableImage(HANDLE, PCSTR, PSTR, PFIND_EXE_FILE_CALLBACK, PVOID);
+HANDLE WINAPI SymFindExecutableImageW(HANDLE, PCWSTR, PWSTR, PFIND_EXE_FILE_CALLBACKW, PVOID);
+PIMAGE_NT_HEADERS WINAPI ImageNtHeader(PVOID);
+PVOID WINAPI ImageDirectoryEntryToDataEx(PVOID, BOOLEAN, USHORT, PULONG,
+                                         PIMAGE_SECTION_HEADER *);
+PVOID WINAPI ImageDirectoryEntryToData(PVOID, BOOLEAN, USHORT, PULONG);
+PIMAGE_SECTION_HEADER WINAPI ImageRvaToSection(PIMAGE_NT_HEADERS, PVOID, ULONG);
+PVOID WINAPI ImageRvaToVa(PIMAGE_NT_HEADERS, PVOID, ULONG, PIMAGE_SECTION_HEADER*);
+BOOL WINAPI SymGetSearchPath(HANDLE, PSTR, DWORD);
+BOOL WINAPI SymGetSearchPathW(HANDLE, PWSTR, DWORD);
+BOOL WINAPI SymSetSearchPath(HANDLE, PCSTR);
+BOOL WINAPI SymSetSearchPathW(HANDLE, PCWSTR);
+DWORD WINAPI GetTimestampForLoadedLibrary(HMODULE);
+BOOL WINAPI MakeSureDirectoryPathExists(PCSTR);
+BOOL WINAPI SearchTreeForFile(PCSTR, PCSTR, PSTR);
+BOOL WINAPI SearchTreeForFileW(PCWSTR, PCWSTR, PWSTR);
+typedef BOOL (CALLBACK *PENUMDIRTREE_CALLBACK)(PCSTR, PVOID);
+typedef BOOL (CALLBACK *PENUMDIRTREE_CALLBACKW)(PCWSTR, PVOID);
+BOOL WINAPI EnumDirTree(HANDLE, PCSTR, PCSTR, PSTR, PENUMDIRTREE_CALLBACK, PVOID);
+BOOL WINAPI EnumDirTreeW(HANDLE, PCWSTR, PCWSTR, PWSTR, PENUMDIRTREE_CALLBACKW, PVOID);
+BOOL WINAPI SymMatchFileName(PCSTR, PCSTR, PSTR*, PSTR*);
+BOOL WINAPI SymMatchFileNameW(PCWSTR, PCWSTR, PWSTR*, PWSTR*);
+PCHAR WINAPI SymSetHomeDirectory(HANDLE, PCSTR);
+PWSTR WINAPI SymSetHomeDirectoryW(HANDLE, PCWSTR);
+PCHAR WINAPI SymGetHomeDirectory(DWORD, PSTR, size_t);
+PWSTR WINAPI SymGetHomeDirectoryW(DWORD, PWSTR, size_t);
+#define hdBase  0
+#define hdSym   1
+#define hdSrc   2
+#define hdMax   3
+
+/*************************
+ *   Context management  *
+ *************************/
+BOOL WINAPI SymSetContext(HANDLE, PIMAGEHLP_STACK_FRAME, PIMAGEHLP_CONTEXT);
+
+
+/*************************
+ *    Stack management   *
+ *************************/
+
+#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
+#define KDHELP KDHELP64
+#define PKDHELP PKDHELP64
+#else
+typedef struct _KDHELP
+{
+    DWORD       Thread;
+    DWORD       ThCallbackStack;
+    DWORD       NextCallback;
+    DWORD       FramePointer;
+    DWORD       KiCallUserMode;
+    DWORD       KeUserCallbackDispatcher;
+    DWORD       SystemRangeStart;
+} KDHELP, *PKDHELP;
+#endif
+
+typedef struct _KDHELP64
+{
+    DWORD64     Thread;
+    DWORD       ThCallbackStack;
+    DWORD       ThCallbackBStore;
+    DWORD       NextCallback;
+    DWORD       FramePointer;
+    DWORD64     KiCallUserMode;
+    DWORD64     KeUserCallbackDispatcher;
+    DWORD64     SystemRangeStart;
+    DWORD64     Reserved[8];
+} KDHELP64, *PKDHELP64;
+
+#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
+#define STACKFRAME STACKFRAME64
+#define LPSTACKFRAME LPSTACKFRAME64
+#else
+typedef struct _STACKFRAME
+{
+    ADDRESS     AddrPC;
+    ADDRESS     AddrReturn;
+    ADDRESS     AddrFrame;
+    ADDRESS     AddrStack;
+    PVOID       FuncTableEntry;
+    DWORD       Params[4];
+    BOOL        Far;
+    BOOL        Virtual;
+    DWORD       Reserved[3];
+    KDHELP      KdHelp;
+    ADDRESS     AddrBStore;
+} STACKFRAME, *LPSTACKFRAME;
+#endif
+
+typedef struct _STACKFRAME64
+{
+    ADDRESS64   AddrPC;
+    ADDRESS64   AddrReturn;
+    ADDRESS64   AddrFrame;
+    ADDRESS64   AddrStack;
+    ADDRESS64   AddrBStore;
+    PVOID       FuncTableEntry;
+    DWORD64     Params[4];
+    BOOL        Far;
+    BOOL        Virtual;
+    DWORD64     Reserved[3];
+    KDHELP64    KdHelp;
+} STACKFRAME64, *LPSTACKFRAME64;
+
+typedef BOOL (CALLBACK *PREAD_PROCESS_MEMORY_ROUTINE64)
+    (HANDLE, DWORD64, PVOID, DWORD, PDWORD);
+typedef PVOID (CALLBACK *PFUNCTION_TABLE_ACCESS_ROUTINE64)(HANDLE, DWORD64);
+typedef DWORD64 (CALLBACK *PGET_MODULE_BASE_ROUTINE64)(HANDLE, DWORD64);
+typedef DWORD64 (CALLBACK *PTRANSLATE_ADDRESS_ROUTINE64)(HANDLE, HANDLE, LPADDRESS64);
+BOOL WINAPI StackWalk64(DWORD, HANDLE, HANDLE, LPSTACKFRAME64, PVOID,
+                        PREAD_PROCESS_MEMORY_ROUTINE64,
+                        PFUNCTION_TABLE_ACCESS_ROUTINE64,
+                        PGET_MODULE_BASE_ROUTINE64,
+                        PTRANSLATE_ADDRESS_ROUTINE64);
+
+PVOID WINAPI SymFunctionTableAccess64(HANDLE, DWORD64);
+
+typedef PVOID (CALLBACK *PSYMBOL_FUNCENTRY_CALLBACK64)(HANDLE, ULONG64, ULONG64);
+
+BOOL WINAPI SymRegisterFunctionEntryCallback64(HANDLE, PSYMBOL_FUNCENTRY_CALLBACK64, ULONG64);
+
+/*************************
+ * Version, global stuff *
+ *************************/
+
+#define API_VERSION_NUMBER 9
+
+typedef struct API_VERSION
+{
+    USHORT  MajorVersion;
+    USHORT  MinorVersion;
+    USHORT  Revision;
+    USHORT  Reserved;
+} API_VERSION, *LPAPI_VERSION;
+
+LPAPI_VERSION WINAPI ImagehlpApiVersion(void);
+LPAPI_VERSION WINAPI ImagehlpApiVersionEx(LPAPI_VERSION);
+
+typedef struct _IMAGE_DEBUG_INFORMATION
+{
+    LIST_ENTRY                  List;
+    DWORD                       ReservedSize;
+    PVOID                       ReservedMappedBase;
+    USHORT                      ReservedMachine;
+    USHORT                      ReservedCharacteristics;
+    DWORD                       ReservedCheckSum;
+    DWORD                       ImageBase;
+    DWORD                       SizeOfImage;
+    DWORD                       ReservedNumberOfSections;
+    PIMAGE_SECTION_HEADER       ReservedSections;
+    DWORD                       ReservedExportedNamesSize;
+    PSTR                        ReservedExportedNames;
+    DWORD                       ReservedNumberOfFunctionTableEntries;
+    PIMAGE_FUNCTION_ENTRY       ReservedFunctionTableEntries;
+    DWORD                       ReservedLowestFunctionStartingAddress;
+    DWORD                       ReservedHighestFunctionEndingAddress;
+    DWORD                       ReservedNumberOfFpoTableEntries;
+    PFPO_DATA                   ReservedFpoTableEntries;
+    DWORD                       SizeOfCoffSymbols;
+    PIMAGE_COFF_SYMBOLS_HEADER  CoffSymbols;
+    DWORD                       ReservedSizeOfCodeViewSymbols;
+    PVOID                       ReservedCodeViewSymbols;
+    PSTR                        ImageFilePath;
+    PSTR                        ImageFileName;
+    PSTR                        ReservedDebugFilePath;
+    DWORD                       ReservedTimeDateStamp;
+    BOOL                        ReservedRomImage;
+    PIMAGE_DEBUG_DIRECTORY      ReservedDebugDirectory;
+    DWORD                       ReservedNumberOfDebugDirectories;
+    DWORD                       ReservedOriginalFunctionTableBaseAddress;
+    DWORD                       Reserved[ 2 ];
+} IMAGE_DEBUG_INFORMATION, *PIMAGE_DEBUG_INFORMATION;
+
+
+PIMAGE_DEBUG_INFORMATION WINAPI MapDebugInformation(HANDLE, PCSTR, PCSTR, ULONG);
+
+BOOL WINAPI UnmapDebugInformation(PIMAGE_DEBUG_INFORMATION);
+
+DWORD   WINAPI  SymGetOptions(void);
+DWORD   WINAPI  SymSetOptions(DWORD);
+
+BOOL WINAPI SymSetParentWindow(HWND);
+
+/*************************
+ * Version, global stuff *
+ *************************/
+
+typedef BOOL     (WINAPI* PSYMBOLSERVERPROC)(PCSTR, PCSTR, PVOID, DWORD, DWORD, PSTR);
+typedef BOOL     (WINAPI* PSYMBOLSERVERPROCA)(PCSTR, PCSTR, PVOID, DWORD, DWORD, PSTR);
+typedef BOOL     (WINAPI* PSYMBOLSERVERPROCW)(PCWSTR, PCWSTR, PVOID, DWORD, DWORD, PWSTR);
+typedef BOOL     (WINAPI* PSYMBOLSERVEROPENPROC)(void);
+typedef BOOL     (WINAPI* PSYMBOLSERVERCLOSEPROC)(void);
+typedef BOOL     (WINAPI* PSYMBOLSERVERSETOPTIONSPROC)(UINT_PTR, ULONG64);
+typedef BOOL     (CALLBACK* PSYMBOLSERVERCALLBACKPROC)(UINT_PTR, ULONG64, ULONG64);
+typedef UINT_PTR (WINAPI* PSYMBOLSERVERGETOPTIONSPROC)(void);
+typedef BOOL     (WINAPI* PSYMBOLSERVERPINGPROC)(PCSTR);
+typedef BOOL     (WINAPI* PSYMBOLSERVERPINGPROCA)(PCSTR);
+typedef BOOL     (WINAPI* PSYMBOLSERVERPINGPROCW)(PCWSTR);
+
+#define SSRVOPT_CALLBACK            0x0001
+#define SSRVOPT_DWORD               0x0002
+#define SSRVOPT_DWORDPTR            0x0004
+#define SSRVOPT_GUIDPTR             0x0008
+#define SSRVOPT_OLDGUIDPTR          0x0010
+#define SSRVOPT_UNATTENDED          0x0020
+#define SSRVOPT_NOCOPY              0x0040
+#define SSRVOPT_PARENTWIN           0x0080
+#define SSRVOPT_PARAMTYPE           0x0100
+#define SSRVOPT_SECURE              0x0200
+#define SSRVOPT_TRACE               0x0400
+#define SSRVOPT_SETCONTEXT          0x0800
+#define SSRVOPT_PROXY               0x1000
+#define SSRVOPT_DOWNSTREAM_STORE    0x2000
+#define SSRVOPT_RESET               ((ULONG_PTR)-1)
+
+#define SSRVACTION_TRACE        1
+#define SSRVACTION_QUERYCANCEL  2
+#define SSRVACTION_EVENT        3
+
+/* 32-bit functions */
+
+#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
+
+#define PENUMLOADED_MODULES_CALLBACK PENUMLOADED_MODULES_CALLBACK64
+#define PFUNCTION_TABLE_ACCESS_ROUTINE PFUNCTION_TABLE_ACCESS_ROUTINE64
+#define PGET_MODULE_BASE_ROUTINE PGET_MODULE_BASE_ROUTINE64
+#define PREAD_PROCESS_MEMORY_ROUTINE PREAD_PROCESS_MEMORY_ROUTINE64
+#define PSYMBOL_FUNCENTRY_CALLBACK PSYMBOL_FUNCENTRY_CALLBACK64
+#define PSYMBOL_REGISTERED_CALLBACK PSYMBOL_REGISTERED_CALLBACK64
+#define PSYM_ENUMMODULES_CALLBACK PSYM_ENUMMODULES_CALLBACK64
+#define PSYM_ENUMSYMBOLS_CALLBACK PSYM_ENUMSYMBOLS_CALLBACK64
+#define PSYM_ENUMSYMBOLS_CALLBACKW PSYM_ENUMSYMBOLS_CALLBACKW64
+#define PTRANSLATE_ADDRESS_ROUTINE PTRANSLATE_ADDRESS_ROUTINE64
+
+#define EnumerateLoadedModules EnumerateLoadedModules64
+#define StackWalk StackWalk64
+#define SymEnumerateModules SymEnumerateModules64
+#define SymEnumerateSymbols SymEnumerateSymbols64
+#define SymEnumerateSymbolsW SymEnumerateSymbolsW64
+#define SymFunctionTableAccess SymFunctionTableAccess64
+#define SymGetLineFromAddr SymGetLineFromAddr64
+#define SymGetLineFromAddrW SymGetLineFromAddrW64
+#define SymGetLineFromName SymGetLineFromName64
+#define SymGetLineNext SymGetLineNext64
+#define SymGetLineNextW SymGetLineNextW64
+#define SymGetLinePrev SymGetLinePrev64
+#define SymGetLinePrevW SymGetLinePrevW64
+#define SymGetModuleBase SymGetModuleBase64
+#define SymGetModuleInfo SymGetModuleInfo64
+#define SymGetModuleInfoW SymGetModuleInfoW64
+#define SymGetSymFromAddr SymGetSymFromAddr64
+#define SymGetSymFromName SymGetSymFromName64
+#define SymGetSymNext SymGetSymNext64
+#define SymGetSymNextW SymGetSymNextW64
+#define SymGetSymPrev SymGetSymPrev64
+#define SymGetSymPrevW SymGetSymPrevW64
+#define SymLoadModule SymLoadModule64
+#define SymRegisterCallback SymRegisterCallback64
+#define SymRegisterFunctionEntryCallback SymRegisterFunctionEntryCallback64
+#define SymUnDName SymUnDName64
+#define SymUnloadModule SymUnloadModule64
+
+#else
+
+typedef BOOL  (CALLBACK *PENUMLOADED_MODULES_CALLBACK)(PCSTR, ULONG, ULONG, PVOID);
+typedef PVOID (CALLBACK *PFUNCTION_TABLE_ACCESS_ROUTINE)(HANDLE, DWORD);
+typedef DWORD (CALLBACK *PGET_MODULE_BASE_ROUTINE)(HANDLE, DWORD);
+typedef BOOL  (CALLBACK *PREAD_PROCESS_MEMORY_ROUTINE)(HANDLE, DWORD, PVOID, DWORD, PDWORD);
+typedef BOOL  (CALLBACK *PSYM_ENUMMODULES_CALLBACK)(PCSTR, ULONG, PVOID);
+typedef BOOL  (CALLBACK *PSYM_ENUMSYMBOLS_CALLBACK)(PCSTR, ULONG, ULONG, PVOID);
+typedef BOOL  (CALLBACK *PSYM_ENUMSYMBOLS_CALLBACKW)(PCWSTR, ULONG, ULONG, PVOID);
+typedef BOOL  (CALLBACK *PSYMBOL_REGISTERED_CALLBACK)(HANDLE, ULONG, PVOID, PVOID);
+typedef PVOID (CALLBACK *PSYMBOL_FUNCENTRY_CALLBACK)(HANDLE, DWORD, PVOID);
+typedef DWORD (CALLBACK *PTRANSLATE_ADDRESS_ROUTINE)(HANDLE, HANDLE, LPADDRESS);
+
+BOOL    WINAPI EnumerateLoadedModules(HANDLE, PENUMLOADED_MODULES_CALLBACK, PVOID);
+BOOL    WINAPI StackWalk(DWORD, HANDLE, HANDLE, LPSTACKFRAME, PVOID, PREAD_PROCESS_MEMORY_ROUTINE, PFUNCTION_TABLE_ACCESS_ROUTINE, PGET_MODULE_BASE_ROUTINE, PTRANSLATE_ADDRESS_ROUTINE);
+BOOL    WINAPI SymEnumerateModules(HANDLE, PSYM_ENUMMODULES_CALLBACK, PVOID);
+BOOL    WINAPI SymEnumerateSymbols(HANDLE, ULONG, PSYM_ENUMSYMBOLS_CALLBACK, PVOID);
+BOOL    WINAPI SymEnumerateSymbolsW(HANDLE, ULONG, PSYM_ENUMSYMBOLS_CALLBACKW, PVOID);
+PVOID   WINAPI SymFunctionTableAccess(HANDLE, DWORD);
+BOOL    WINAPI SymGetLineFromAddr(HANDLE, DWORD, PDWORD, PIMAGEHLP_LINE);
+BOOL    WINAPI SymGetLineFromAddrW(HANDLE, DWORD, PDWORD, PIMAGEHLP_LINEW);
+BOOL    WINAPI SymGetLineFromName(HANDLE, PCSTR, PCSTR, DWORD, PLONG, PIMAGEHLP_LINE);
+BOOL    WINAPI SymGetLineNext(HANDLE, PIMAGEHLP_LINE);
+BOOL    WINAPI SymGetLineNextW(HANDLE, PIMAGEHLP_LINEW);
+BOOL    WINAPI SymGetLinePrev(HANDLE, PIMAGEHLP_LINE);
+BOOL    WINAPI SymGetLinePrevW(HANDLE, PIMAGEHLP_LINEW);
+DWORD   WINAPI SymGetModuleBase(HANDLE, DWORD);
+BOOL    WINAPI SymGetModuleInfo(HANDLE, DWORD, PIMAGEHLP_MODULE);
+BOOL    WINAPI SymGetModuleInfoW(HANDLE, DWORD, PIMAGEHLP_MODULEW);
+BOOL    WINAPI SymGetSymFromAddr(HANDLE, DWORD, PDWORD, PIMAGEHLP_SYMBOL);
+BOOL    WINAPI SymGetSymFromName(HANDLE, PCSTR, PIMAGEHLP_SYMBOL);
+BOOL    WINAPI SymGetSymNext(HANDLE, PIMAGEHLP_SYMBOL);
+BOOL    WINAPI SymGetSymNextW(HANDLE, PIMAGEHLP_SYMBOLW);
+BOOL    WINAPI SymGetSymPrev(HANDLE, PIMAGEHLP_SYMBOL);
+BOOL    WINAPI SymGetSymPrevW(HANDLE, PIMAGEHLP_SYMBOLW);
+DWORD   WINAPI SymLoadModule(HANDLE, HANDLE, PCSTR, PCSTR, DWORD, DWORD);
+BOOL    WINAPI SymRegisterCallback(HANDLE, PSYMBOL_REGISTERED_CALLBACK, PVOID);
+BOOL    WINAPI SymRegisterFunctionEntryCallback(HANDLE, PSYMBOL_FUNCENTRY_CALLBACK, PVOID);
+BOOL    WINAPI SymRefreshModuleList(HANDLE);
+BOOL    WINAPI SymUnDName(PIMAGEHLP_SYMBOL, PSTR, DWORD);
+BOOL    WINAPI SymUnloadModule(HANDLE, DWORD);
+
+#endif
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif /* defined(__cplusplus) */
+
+#endif  /* __WINE_DBGHELP_H */