diff --git a/include/dbghelp.h b/include/dbghelp.h
new file mode 100644
index 0000000..2046fd2
--- /dev/null
+++ b/include/dbghelp.h
@@ -0,0 +1,31 @@
+/**
+ * This file has no copyright assigned and is placed in the Public Domain.
+ * This file is part of the mingw-w64 runtime package.
+ * No warranty is given; refer to the file DISCLAIMER.PD within this package.
+ */
+/*
+ * Unlike include/intrin.h in this same directory (an empty stub with zero
+ * dependencies), this is the real mingw-w64 header, and it is NOT
+ * include-order-independent: its dependency psdk_inc/_dbg_LOAD_IMAGE.h uses
+ * PSTR/PUCHAR/HANDLE/etc. without defining or including them itself - they
+ * must already come from <windows.h>. Including this header before
+ * <windows.h> fails to preprocess. This matches vc/v_win.c's actual order
+ * (<windows.h>, then <intrin.h>, then <dbghelp.h>), which this bundle's
+ * bootstrap depends on and has been verified to build; any other consumer
+ * must include <windows.h> first too.
+ */
+#ifndef _DBGHELP_
+#define _DBGHELP_
+
+#include <_mingw_unicode.h>
+
+#ifdef _WIN64
+#ifndef _IMAGEHLP64
+#define _IMAGEHLP64
+#endif
+#endif
+
+#include <psdk_inc/_dbg_LOAD_IMAGE.h>
+#include <psdk_inc/_dbg_common.h>
+
+#endif
diff --git a/include/intrin.h b/include/intrin.h
new file mode 100644
index 0000000..fec1c24
--- /dev/null
+++ b/include/intrin.h
@@ -0,0 +1,36 @@
+/*
+ * Minimal compatibility shim for MSVC's <intrin.h>.
+ *
+ * vlang's vc/v_win.c bootstrap snapshot is always generated with `-cc msvc`
+ * (see vlang/v's .github/workflows/gen_vc_ci.yml), which makes its cgen
+ * emit an unconditional `#include <intrin.h>` under `#ifdef _WIN32` (see
+ * vlang/v's vlib/v/gen/c/cleanc.v, the `g.ccompiler == 'msvc'` branch).
+ * This toolchain does not otherwise ship that header, so building
+ * vc/v_win.c directly with the bundled tcc fails before reaching any real
+ * code.
+ *
+ * This is an empty stub, not a ported real intrin.h, because this
+ * toolchain's own include/_mingw.h unconditionally does
+ * `#define __INTRIN_H_` (see its line ~146), which is the real
+ * mingw-w64 intrin.h's own header guard. Since <windows.h> (included
+ * immediately before this header in vc/v_win.c) pulls in _mingw.h first,
+ * a real ported intrin.h's body would already be skipped by its own
+ * guard in that include order - it would silently do nothing, while
+ * still being unable to preprocess standalone, since this bundle does
+ * not ship intrin.h's own dependencies (crtdefs.h,
+ * psdk_inc/intrin-impl.h). An empty stub is the honest version of the
+ * same no-op, without the missing-dependency failure in any other
+ * include order.
+ *
+ * No definitions are needed here regardless: every call site for the
+ * handful of MSVC intrinsics vlang's cgen can emit (_umul128, _udiv128,
+ * _addcarry_u64, _BitScanForward, _BitScanForward64) is wrapped in
+ * `#if defined(_MSC_VER)` at the C level, so under TCC those branches
+ * never compile in the first place - portable fallbacks run instead.
+ * include/winapi/winnt.h (pulled in by <windows.h>) already provides
+ * working `_BitScanForward`, `_BitScanForward64` and `__faststorefence`
+ * for this toolchain (see vlang-header-compat.patch).
+ */
+#ifndef TCC_INTRIN_H_SHIM
+#define TCC_INTRIN_H_SHIM
+#endif
diff --git a/include/poppack.h b/include/poppack.h
new file mode 100644
index 0000000..163af22
--- /dev/null
+++ b/include/poppack.h
@@ -0,0 +1,8 @@
+/**
+ * This file has no copyright assigned and is placed in the Public Domain.
+ * This file is part of the mingw-w64 runtime package.
+ * No warranty is given; refer to the file DISCLAIMER.PD within this package.
+ */
+#if !(defined(lint) || defined(RC_INVOKED))
+#pragma pack(pop)
+#endif
diff --git a/include/psdk_inc/_dbg_LOAD_IMAGE.h b/include/psdk_inc/_dbg_LOAD_IMAGE.h
new file mode 100644
index 0000000..7470f96
--- /dev/null
+++ b/include/psdk_inc/_dbg_LOAD_IMAGE.h
@@ -0,0 +1,52 @@
+/**
+ * This file has no copyright assigned and is placed in the Public Domain.
+ * This file is part of the mingw-w64 runtime package.
+ * No warranty is given; refer to the file DISCLAIMER.PD within this package.
+ */
+#pragma once
+
+#ifndef WINAPI
+#if defined(_ARM_)
+#define WINAPI
+#else
+#define WINAPI __stdcall
+#endif
+#endif
+
+#define IMAGEAPI DECLSPEC_IMPORT WINAPI
+#define DBHLP_DEPRECIATED __declspec(deprecated)
+
+#define DBHLPAPI IMAGEAPI
+
+#define IMAGE_SEPARATION (64*1024)
+
+  typedef struct _LOADED_IMAGE {
+    PSTR ModuleName;
+    HANDLE hFile;
+    PUCHAR MappedAddress;
+#ifdef _IMAGEHLP64
+    PIMAGE_NT_HEADERS64 FileHeader;
+#else
+    PIMAGE_NT_HEADERS32 FileHeader;
+#endif
+    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;
+
+#define MAX_SYM_NAME 2000
+
+  typedef struct _MODLOAD_DATA {
+    DWORD ssize;
+    DWORD ssig;
+    PVOID data;
+    DWORD size;
+    DWORD flags;
+  } MODLOAD_DATA,*PMODLOAD_DATA;
diff --git a/include/psdk_inc/_dbg_common.h b/include/psdk_inc/_dbg_common.h
new file mode 100644
index 0000000..aa94da4
--- /dev/null
+++ b/include/psdk_inc/_dbg_common.h
@@ -0,0 +1,2185 @@
+/**
+ * This file has no copyright assigned and is placed in the Public Domain.
+ * This file is part of the mingw-w64 runtime package.
+ * No warranty is given; refer to the file DISCLAIMER.PD within this package.
+ */
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+  typedef WINBOOL (CALLBACK *PFIND_DEBUG_FILE_CALLBACK)(HANDLE FileHandle,PCSTR FileName,PVOID CallerData);
+  typedef WINBOOL (CALLBACK *PFIND_DEBUG_FILE_CALLBACKW)(HANDLE FileHandle,PCWSTR FileName,PVOID CallerData);
+  typedef WINBOOL (CALLBACK *PFINDFILEINPATHCALLBACK)(PCSTR filename,PVOID context);
+  typedef WINBOOL (CALLBACK *PFINDFILEINPATHCALLBACKW)(PCWSTR filename,PVOID context);
+  typedef WINBOOL (CALLBACK *PFIND_EXE_FILE_CALLBACK)(HANDLE FileHandle,PCSTR FileName,PVOID CallerData);
+  typedef WINBOOL (CALLBACK *PFIND_EXE_FILE_CALLBACKW)(HANDLE FileHandle,PCWSTR FileName,PVOID CallerData);
+
+  typedef WINBOOL (WINAPI *PSYMBOLSERVERPROC)(LPCSTR,LPCSTR,PVOID,DWORD,DWORD,LPSTR);
+  typedef WINBOOL (WINAPI *PSYMBOLSERVEROPENPROC)(VOID);
+  typedef WINBOOL (WINAPI *PSYMBOLSERVERCLOSEPROC)(VOID);
+  typedef WINBOOL (WINAPI *PSYMBOLSERVERSETOPTIONSPROC)(UINT_PTR,ULONG64);
+  typedef WINBOOL (CALLBACK WINAPI *PSYMBOLSERVERCALLBACKPROC)(UINT_PTR action,ULONG64 data,ULONG64 context);
+  typedef UINT_PTR (WINAPI *PSYMBOLSERVERGETOPTIONSPROC)();
+  typedef WINBOOL (WINAPI *PSYMBOLSERVERPINGPROC)(LPCSTR);
+
+  HANDLE IMAGEAPI FindDebugInfoFile(PCSTR FileName,PCSTR SymbolPath,PSTR DebugFilePath);
+  HANDLE IMAGEAPI FindDebugInfoFileEx(PCSTR FileName,PCSTR SymbolPath,PSTR DebugFilePath,PFIND_DEBUG_FILE_CALLBACK Callback,PVOID CallerData);
+  HANDLE IMAGEAPI FindDebugInfoFileExW(PCWSTR FileName,PCWSTR SymbolPath,PWSTR DebugFilePath,PFIND_DEBUG_FILE_CALLBACKW Callback,PVOID CallerData);
+  WINBOOL IMAGEAPI SymFindFileInPath(HANDLE hprocess,PCSTR SearchPath,PCSTR FileName,PVOID id,DWORD two,DWORD three,DWORD flags,LPSTR FoundFile,PFINDFILEINPATHCALLBACK callback,PVOID context);
+  WINBOOL IMAGEAPI SymFindFileInPathW(HANDLE hprocess,PCWSTR SearchPath,PCWSTR FileName,PVOID id,DWORD two,DWORD three,DWORD flags,LPSTR FoundFile,PFINDFILEINPATHCALLBACKW callback,PVOID context);
+  HANDLE IMAGEAPI FindExecutableImage(PCSTR FileName,PCSTR SymbolPath,PSTR ImageFilePath);
+  HANDLE IMAGEAPI FindExecutableImageEx(PCSTR FileName,PCSTR SymbolPath,PSTR ImageFilePath,PFIND_EXE_FILE_CALLBACK Callback,PVOID CallerData);
+  HANDLE IMAGEAPI FindExecutableImageExW(PCWSTR FileName,PCWSTR SymbolPath,PWSTR ImageFilePath,PFIND_EXE_FILE_CALLBACKW Callback,PVOID CallerData);
+  PIMAGE_NT_HEADERS IMAGEAPI ImageNtHeader(PVOID Base);
+  PVOID IMAGEAPI ImageDirectoryEntryToDataEx(PVOID Base,BOOLEAN MappedAsImage,USHORT DirectoryEntry,PULONG Size,PIMAGE_SECTION_HEADER *FoundHeader);
+  PVOID IMAGEAPI ImageDirectoryEntryToData(PVOID Base,BOOLEAN MappedAsImage,USHORT DirectoryEntry,PULONG Size);
+  PIMAGE_SECTION_HEADER IMAGEAPI ImageRvaToSection(PIMAGE_NT_HEADERS NtHeaders,PVOID Base,ULONG Rva);
+  PVOID IMAGEAPI ImageRvaToVa(PIMAGE_NT_HEADERS NtHeaders,PVOID Base,ULONG Rva,PIMAGE_SECTION_HEADER *LastRvaSection);
+
+#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
+
+#ifndef _WIN64
+  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;
+    WINBOOL ReservedRomImage;
+    PIMAGE_DEBUG_DIRECTORY ReservedDebugDirectory;
+    DWORD ReservedNumberOfDebugDirectories;
+    DWORD ReservedOriginalFunctionTableBaseAddress;
+    DWORD Reserved[2];
+  } IMAGE_DEBUG_INFORMATION,*PIMAGE_DEBUG_INFORMATION;
+
+  PIMAGE_DEBUG_INFORMATION IMAGEAPI MapDebugInformation(HANDLE FileHandle,PSTR FileName,PSTR SymbolPath,DWORD ImageBase);
+  WINBOOL IMAGEAPI UnmapDebugInformation(PIMAGE_DEBUG_INFORMATION DebugInfo);
+#endif
+
+  typedef WINBOOL (CALLBACK *PENUMDIRTREE_CALLBACK)(LPCSTR FilePath,PVOID CallerData);
+
+  WINBOOL IMAGEAPI SearchTreeForFile(PSTR RootPath,PSTR InputPathName,PSTR OutputPathBuffer);
+  WINBOOL IMAGEAPI SearchTreeForFileW(PWSTR RootPath,PWSTR InputPathName,PWSTR OutputPathBuffer);
+  WINBOOL IMAGEAPI EnumDirTree(HANDLE hProcess,PSTR RootPath,PSTR InputPathName,PSTR OutputPathBuffer,PENUMDIRTREE_CALLBACK Callback,PVOID CallbackData);
+  WINBOOL IMAGEAPI MakeSureDirectoryPathExists(PCSTR DirPath);
+
+#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 UNDNAME_NO_ARGUMENTS (0x2000)
+#define UNDNAME_NO_SPECIAL_SYMS (0x4000)
+
+  DWORD IMAGEAPI WINAPI UnDecorateSymbolName(PCSTR DecoratedName,PSTR UnDecoratedName,DWORD UndecoratedLength,DWORD Flags);
+  DWORD IMAGEAPI WINAPI UnDecorateSymbolNameW(PCWSTR DecoratedName,PWSTR UnDecoratedName,DWORD UndecoratedLength,DWORD Flags);
+
+#define DBHHEADER_DEBUGDIRS 0x1
+#define DBHHEADER_CVMISC 0x2
+
+  typedef struct _MODLOAD_CVMISC {
+    DWORD  oCV;
+    size_t cCV;
+    DWORD  oMisc;
+    size_t cMisc;
+    DWORD  dtImage;
+    DWORD  cImage;
+  } MODLOAD_CVMISC, *PMODLOAD_CVMISC;
+
+  typedef enum {
+    AddrMode1616,
+    AddrMode1632,
+    AddrModeReal,
+    AddrModeFlat
+  } ADDRESS_MODE;
+
+  typedef struct _tagADDRESS64 {
+    DWORD64 Offset;
+    WORD Segment;
+    ADDRESS_MODE Mode;
+  } ADDRESS64,*LPADDRESS64;
+
+#ifdef _IMAGEHLP64
+#define ADDRESS ADDRESS64
+#define LPADDRESS LPADDRESS64
+#else
+  typedef struct _tagADDRESS {
+    DWORD Offset;
+    WORD Segment;
+    ADDRESS_MODE Mode;
+  } ADDRESS,*LPADDRESS;
+
+  static __inline void Address32To64(LPADDRESS a32,LPADDRESS64 a64) {
+    a64->Offset = (ULONG64)(LONG64)(LONG)a32->Offset;
+    a64->Segment = a32->Segment;
+    a64->Mode = a32->Mode;
+  }
+
+  static __inline void Address64To32(LPADDRESS64 a64,LPADDRESS a32) {
+    a32->Offset = (ULONG)a64->Offset;
+    a32->Segment = a64->Segment;
+    a32->Mode = a64->Mode;
+  }
+#endif
+
+  typedef struct _KDHELP64 {
+    DWORD64 Thread;
+    DWORD ThCallbackStack;
+    DWORD ThCallbackBStore;
+    DWORD NextCallback;
+    DWORD FramePointer;
+    DWORD64 KiCallUserMode;
+    DWORD64 KeUserCallbackDispatcher;
+    DWORD64 SystemRangeStart;
+    DWORD64 KiUserExceptionDispatcher;
+    DWORD64 StackBase;
+    DWORD64 StackLimit;
+    DWORD BuildVersion;
+    DWORD RetpolineStubFunctionTableSize;
+    DWORD64 RetpolineStubFunctionTable;
+    DWORD RetpolineStubOffset;
+    DWORD RetpolineStubSize;
+    DWORD64 Reserved0[2];
+  } KDHELP64,*PKDHELP64;
+
+#ifdef _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;
+    DWORD ThCallbackBStore;
+    DWORD KiUserExceptionDispatcher;
+    DWORD StackBase;
+    DWORD StackLimit;
+    DWORD Reserved[5];
+  } KDHELP,*PKDHELP;
+
+  static __inline void KdHelp32To64(PKDHELP p32,PKDHELP64 p64) {
+    p64->Thread = p32->Thread;
+    p64->ThCallbackStack = p32->ThCallbackStack;
+    p64->NextCallback = p32->NextCallback;
+    p64->FramePointer = p32->FramePointer;
+    p64->KiCallUserMode = p32->KiCallUserMode;
+    p64->KeUserCallbackDispatcher = p32->KeUserCallbackDispatcher;
+    p64->SystemRangeStart = p32->SystemRangeStart;
+    p64->KiUserExceptionDispatcher = p32->KiUserExceptionDispatcher;
+    p64->StackBase = p32->StackBase;
+    p64->StackLimit = p32->StackLimit;
+  }
+#endif
+
+  typedef struct _tagSTACKFRAME64 {
+    ADDRESS64 AddrPC;
+    ADDRESS64 AddrReturn;
+    ADDRESS64 AddrFrame;
+    ADDRESS64 AddrStack;
+    ADDRESS64 AddrBStore;
+    PVOID FuncTableEntry;
+    DWORD64 Params[4];
+    WINBOOL Far;
+    WINBOOL Virtual;
+    DWORD64 Reserved[3];
+    KDHELP64 KdHelp;
+  } STACKFRAME64,*LPSTACKFRAME64;
+
+#define INLINE_FRAME_CONTEXT_INIT   0
+#define INLINE_FRAME_CONTEXT_IGNORE 0xFFFFFFFF
+
+  typedef struct _tagSTACKFRAME_EX {
+    ADDRESS64 AddrPC;
+    ADDRESS64 AddrReturn;
+    ADDRESS64 AddrFrame;
+    ADDRESS64 AddrStack;
+    ADDRESS64 AddrBStore;
+    PVOID FuncTableEntry;
+    DWORD64 Params[4];
+    WINBOOL Far;
+    WINBOOL Virtual;
+    DWORD64 Reserved[3];
+    KDHELP64 KdHelp;
+    DWORD StackFrameSize;
+    DWORD InlineFrameContext;
+  } STACKFRAME_EX,*LPSTACKFRAME_EX;
+
+#ifdef _IMAGEHLP64
+#define STACKFRAME STACKFRAME64
+#define LPSTACKFRAME LPSTACKFRAME64
+#else
+  typedef struct _tagSTACKFRAME {
+    ADDRESS AddrPC;
+    ADDRESS AddrReturn;
+    ADDRESS AddrFrame;
+    ADDRESS AddrStack;
+    PVOID FuncTableEntry;
+    DWORD Params[4];
+    WINBOOL Far;
+    WINBOOL Virtual;
+    DWORD Reserved[3];
+    KDHELP KdHelp;
+    ADDRESS AddrBStore;
+  } STACKFRAME,*LPSTACKFRAME;
+#endif
+
+  typedef WINBOOL (WINAPI *PREAD_PROCESS_MEMORY_ROUTINE64)(HANDLE hProcess,DWORD64 qwBaseAddress,PVOID lpBuffer,DWORD nSize,LPDWORD lpNumberOfBytesRead);
+  typedef PVOID (WINAPI *PFUNCTION_TABLE_ACCESS_ROUTINE64)(HANDLE hProcess,DWORD64 AddrBase);
+  typedef DWORD64 (WINAPI *PGET_MODULE_BASE_ROUTINE64)(HANDLE hProcess,DWORD64 Address);
+  typedef DWORD64 (WINAPI *PTRANSLATE_ADDRESS_ROUTINE64)(HANDLE hProcess,HANDLE hThread,LPADDRESS64 lpaddr);
+
+  WINBOOL IMAGEAPI StackWalk64(DWORD MachineType,HANDLE hProcess,HANDLE hThread,LPSTACKFRAME64 StackFrame,PVOID ContextRecord,PREAD_PROCESS_MEMORY_ROUTINE64 ReadMemoryRoutine,PFUNCTION_TABLE_ACCESS_ROUTINE64 FunctionTableAccessRoutine,PGET_MODULE_BASE_ROUTINE64 
+GetModuleBaseRoutine,PTRANSLATE_ADDRESS_ROUTINE64 TranslateAddress);
+
+#ifdef _IMAGEHLP64
+#define PREAD_PROCESS_MEMORY_ROUTINE PREAD_PROCESS_MEMORY_ROUTINE64
+#define PFUNCTION_TABLE_ACCESS_ROUTINE PFUNCTION_TABLE_ACCESS_ROUTINE64
+#define PGET_MODULE_BASE_ROUTINE PGET_MODULE_BASE_ROUTINE64
+#define PTRANSLATE_ADDRESS_ROUTINE PTRANSLATE_ADDRESS_ROUTINE64
+#define StackWalk StackWalk64
+#else
+  typedef WINBOOL (WINAPI *PREAD_PROCESS_MEMORY_ROUTINE)(HANDLE hProcess,DWORD lpBaseAddress,PVOID lpBuffer,DWORD nSize,PDWORD lpNumberOfBytesRead);
+  typedef PVOID (WINAPI *PFUNCTION_TABLE_ACCESS_ROUTINE)(HANDLE hProcess,DWORD AddrBase);
+  typedef DWORD (WINAPI *PGET_MODULE_BASE_ROUTINE)(HANDLE hProcess,DWORD Address);
+  typedef DWORD (WINAPI *PTRANSLATE_ADDRESS_ROUTINE)(HANDLE hProcess,HANDLE hThread,LPADDRESS lpaddr);
+
+  WINBOOL IMAGEAPI StackWalk(DWORD MachineType,HANDLE hProcess,HANDLE hThread,LPSTACKFRAME StackFrame,PVOID ContextRecord,PREAD_PROCESS_MEMORY_ROUTINE ReadMemoryRoutine,PFUNCTION_TABLE_ACCESS_ROUTINE FunctionTableAccessRoutine,PGET_MODULE_BASE_ROUTINE 
+GetModuleBaseRoutine,PTRANSLATE_ADDRESS_ROUTINE TranslateAddress);
+#endif
+
+#define API_VERSION_NUMBER 11
+
+  typedef struct API_VERSION {
+    USHORT MajorVersion;
+    USHORT MinorVersion;
+    USHORT Revision;
+    USHORT Reserved;
+  } API_VERSION,*LPAPI_VERSION;
+
+  LPAPI_VERSION IMAGEAPI ImagehlpApiVersion(VOID);
+  LPAPI_VERSION IMAGEAPI ImagehlpApiVersionEx(LPAPI_VERSION AppVersion);
+  DWORD IMAGEAPI GetTimestampForLoadedLibrary(HMODULE Module);
+
+  typedef WINBOOL (CALLBACK *PSYM_ENUMMODULES_CALLBACK64)(PCSTR ModuleName,DWORD64 BaseOfDll,PVOID UserContext);
+  typedef WINBOOL (CALLBACK *PSYM_ENUMMODULES_CALLBACKW64)(PCWSTR ModuleName,DWORD64 BaseOfDll,PVOID UserContext);
+  typedef WINBOOL (CALLBACK *PSYM_ENUMSYMBOLS_CALLBACK64)(PCSTR SymbolName,DWORD64 SymbolAddress,ULONG SymbolSize,PVOID UserContext);
+  typedef WINBOOL (CALLBACK *PSYM_ENUMSYMBOLS_CALLBACK64W)(PCWSTR SymbolName,DWORD64 SymbolAddress,ULONG SymbolSize,PVOID UserContext);
+  typedef WINBOOL (CALLBACK *PENUMLOADED_MODULES_CALLBACK64)(PCSTR ModuleName,DWORD64 ModuleBase,ULONG ModuleSize,PVOID UserContext);
+  typedef WINBOOL (CALLBACK *PENUMLOADED_MODULES_CALLBACKW64)(PCWSTR ModuleName,DWORD64 ModuleBase,ULONG ModuleSize,PVOID UserContext);
+  typedef WINBOOL (CALLBACK *PSYMBOL_REGISTERED_CALLBACK64)(HANDLE hProcess,ULONG ActionCode,ULONG64 CallbackData,ULONG64 UserContext);
+  typedef PVOID (CALLBACK *PSYMBOL_FUNCENTRY_CALLBACK)(HANDLE hProcess,DWORD AddrBase,PVOID UserContext);
+  typedef PVOID (CALLBACK *PSYMBOL_FUNCENTRY_CALLBACK64)(HANDLE hProcess,ULONG64 AddrBase,ULONG64 UserContext);
+
+#ifdef _IMAGEHLP64
+#define PSYM_ENUMMODULES_CALLBACK PSYM_ENUMMODULES_CALLBACK64
+#define PSYM_ENUMSYMBOLS_CALLBACK PSYM_ENUMSYMBOLS_CALLBACK64
+#define PSYM_ENUMSYMBOLS_CALLBACKW PSYM_ENUMSYMBOLS_CALLBACK64W
+#define PENUMLOADED_MODULES_CALLBACK PENUMLOADED_MODULES_CALLBACK64
+#define PSYMBOL_REGISTERED_CALLBACK PSYMBOL_REGISTERED_CALLBACK64
+#define PSYMBOL_FUNCENTRY_CALLBACK PSYMBOL_FUNCENTRY_CALLBACK64
+#else
+  typedef WINBOOL (CALLBACK *PSYM_ENUMMODULES_CALLBACK)(PCSTR ModuleName,ULONG BaseOfDll,PVOID UserContext);
+  typedef WINBOOL (CALLBACK *PSYM_ENUMSYMBOLS_CALLBACK)(PCSTR SymbolName,ULONG SymbolAddress,ULONG SymbolSize,PVOID UserContext);
+  typedef WINBOOL (CALLBACK *PSYM_ENUMSYMBOLS_CALLBACKW)(PCWSTR SymbolName,ULONG SymbolAddress,ULONG SymbolSize,PVOID UserContext);
+  typedef WINBOOL (CALLBACK *PENUMLOADED_MODULES_CALLBACK)(PCSTR ModuleName,ULONG ModuleBase,ULONG ModuleSize,PVOID UserContext);
+  typedef WINBOOL (CALLBACK *PSYMBOL_REGISTERED_CALLBACK)(HANDLE hProcess,ULONG ActionCode,PVOID CallbackData,PVOID UserContext);
+#endif
+
+#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 SYMFLAG_ILREL 0x00010000
+#define SYMFLAG_METADATA 0x00020000
+#define SYMFLAG_CLR_TOKEN 0x00040000
+#define SYMFLAG_NULL 0x00080000
+#define SYMFLAG_FUNC_NO_RETURN 0x00100000
+#define SYMFLAG_SYNTHETIC_ZEROBASE 0x00200000
+#define SYMFLAG_PUBLIC_CODE 0x00400000
+#define SYMFLAG_REGREL_ALIASINDIR 0x00800000
+#define SYMFLAG_FIXUP_ARM64X 0x01000000
+#define SYMFLAG_GLOBAL 0x02000000
+#define SYMFLAG_RESET 0x80000000
+
+  typedef enum {
+    SymNone = 0,
+    SymCoff,
+    SymCv,
+    SymPdb,
+    SymExport,
+    SymDeferred,
+    SymSym,
+    SymDia,
+    SymVirtual,
+    NumSymTypes
+  } SYM_TYPE;
+
+  typedef struct _IMAGEHLP_SYMBOL64 {
+    DWORD SizeOfStruct;
+    DWORD64 Address;
+    DWORD Size;
+    DWORD Flags;
+    DWORD MaxNameLength;
+    CHAR Name[1];
+  } IMAGEHLP_SYMBOL64,*PIMAGEHLP_SYMBOL64;
+
+  typedef struct _IMAGEHLP_SYMBOL64_PACKAGE {
+    IMAGEHLP_SYMBOL64 sym;
+    CHAR name[MAX_SYM_NAME + 1];
+  } IMAGEHLP_SYMBOL64_PACKAGE,*PIMAGEHLP_SYMBOL64_PACKAGE;
+
+#ifdef _IMAGEHLP64
+
+#define IMAGEHLP_SYMBOL IMAGEHLP_SYMBOL64
+#define PIMAGEHLP_SYMBOL PIMAGEHLP_SYMBOL64
+#define IMAGEHLP_SYMBOL_PACKAGE IMAGEHLP_SYMBOL64_PACKAGE
+#define PIMAGEHLP_SYMBOL_PACKAGE PIMAGEHLP_SYMBOL64_PACKAGE
+#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_SYMBOL_PACKAGE {
+    IMAGEHLP_SYMBOL sym;
+    CHAR name[MAX_SYM_NAME + 1];
+  } IMAGEHLP_SYMBOL_PACKAGE,*PIMAGEHLP_SYMBOL_PACKAGE;
+#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;
+    WINBOOL PdbUnmatched;
+    WINBOOL DbgUnmatched;
+    WINBOOL LineNumbers;
+    WINBOOL GlobalSymbols;
+    WINBOOL TypeInfo;
+    WINBOOL SourceIndexed;
+    WINBOOL Publics;
+    DWORD MachineType;
+    DWORD Reserved;
+  } IMAGEHLP_MODULE64,*PIMAGEHLP_MODULE64;
+
+  typedef struct _IMAGEHLP_MODULE64_EX {
+    IMAGEHLP_MODULE64 Module;
+    DWORD RegionFlags;
+  } IMAGEHLP_MODULE64_EX,*PIMAGEHLP_MODULE64_EX;
+
+  typedef struct _IMAGEHLP_MODULE64W {
+    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;
+    WINBOOL PdbUnmatched;
+    WINBOOL DbgUnmatched;
+    WINBOOL LineNumbers;
+    WINBOOL GlobalSymbols;
+    WINBOOL TypeInfo;
+    WINBOOL SourceIndexed;
+    WINBOOL Publics;
+    DWORD MachineType;
+    DWORD Reserved;
+  } IMAGEHLP_MODULEW64,*PIMAGEHLP_MODULEW64;
+
+  typedef struct _IMAGEHLP_MODULEW64_EX {
+    IMAGEHLP_MODULEW64 Module;
+    DWORD RegionFlags;
+  } IMAGEHLP_MODULEW64_EX,*PIMAGEHLP_MODULEW64_EX;
+
+#ifdef _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_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;
+
+#ifdef _IMAGEHLP64
+#define IMAGEHLP_LINE IMAGEHLP_LINE64
+#define PIMAGEHLP_LINE PIMAGEHLP_LINE64
+#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 _SOURCEFILE {
+    DWORD64 ModBase;
+    PCHAR FileName;
+  } SOURCEFILE,*PSOURCEFILE;
+
+  typedef struct _SOURCEFILEW {
+    DWORD64 ModBase;
+    PWCHAR 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
+#define CBA_SRCSRV_INFO 0x20000000
+#define CBA_SRCSRV_EVENT 0x40000000
+
+  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
+  };
+
+  typedef struct _IMAGEHLP_CBA_EVENT {
+    DWORD severity;
+    DWORD code;
+    PCHAR desc;
+    PVOID object;
+  } IMAGEHLP_CBA_EVENT,*PIMAGEHLP_CBA_EVENT;
+
+  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;
+
+#define DSLFLAG_MISMATCHED_PDB 0x1
+#define DSLFLAG_MISMATCHED_DBG 0x2
+
+#ifdef _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_DUPLICATE_SYMBOL64 {
+    DWORD SizeOfStruct;
+    DWORD NumberOfDups;
+    PIMAGEHLP_SYMBOL64 Symbol;
+    DWORD SelectedSymbol;
+  } IMAGEHLP_DUPLICATE_SYMBOL64,*PIMAGEHLP_DUPLICATE_SYMBOL64;
+
+#ifdef _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 _SYMSRV_INDEX_INFO {
+  DWORD sizeofstruct;
+  CHAR file[MAX_PATH +1];
+  WINBOOL  stripped;
+  DWORD timestamp;
+  DWORD size;
+  CHAR dbgfile[MAX_PATH +1];
+  CHAR pdbfile[MAX_PATH + 1];
+  GUID  guid;
+  DWORD sig;
+  DWORD age;
+} SYMSRV_INDEX_INFO, *PSYMSRV_INDEX_INFO;
+
+typedef struct _SYMSRV_INDEX_INFOW {
+  DWORD sizeofstruct;
+  WCHAR file[MAX_PATH +1];
+  WINBOOL  stripped;
+  DWORD timestamp;
+  DWORD size;
+  WCHAR dbgfile[MAX_PATH +1];
+  WCHAR pdbfile[MAX_PATH + 1];
+  GUID  guid;
+  DWORD sig;
+  DWORD age;
+} SYMSRV_INDEX_INFOW, *PSYMSRV_INDEX_INFOW;
+
+  WINBOOL IMAGEAPI SymSetParentWindow(HWND hwnd);
+  PCHAR IMAGEAPI SymSetHomeDirectory(HANDLE hProcess,PCSTR dir);
+  PCHAR IMAGEAPI SymSetHomeDirectoryW(HANDLE hProcess,PCWSTR dir);
+  PCHAR IMAGEAPI SymGetHomeDirectory(DWORD type,PSTR dir,size_t size);
+  PWCHAR IMAGEAPI SymGetHomeDirectoryW(DWORD type,PWSTR dir,size_t size);
+
+#define hdBase 0
+#define hdSym 1
+#define hdSrc 2
+#define hdMax 3
+
+#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_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_ALLOW_ZERO_ADDRESS 0x01000000
+#define SYMOPT_DISABLE_SYMSRV_AUTODETECT 0x02000000
+#define SYMOPT_FAVOR_COMPRESSED 0x00800000
+#define SYMOPT_FLAT_DIRECTORY 0x00400000
+#define SYMOPT_IGNORE_IMAGEDIR 0x00200000
+#define SYMOPT_OVERWRITE 0x00100000
+
+#define SYMOPT_DEBUG 0x80000000
+
+  DWORD IMAGEAPI SymSetOptions(DWORD SymOptions);
+  DWORD IMAGEAPI SymGetOptions(VOID);
+  WINBOOL IMAGEAPI SymCleanup(HANDLE hProcess);
+  WINBOOL IMAGEAPI SymMatchString(PCSTR string,PCSTR expression,WINBOOL fCase);
+  WINBOOL IMAGEAPI SymMatchStringW(PCWSTR string,PCWSTR expression,WINBOOL fCase);
+
+  typedef WINBOOL (CALLBACK *PSYM_ENUMSOURCEFILES_CALLBACK)(PSOURCEFILE pSourceFile,PVOID UserContext);
+  typedef WINBOOL (CALLBACK *PSYM_ENUMSOURCEFILES_CALLBACKW)(PSOURCEFILEW pSourceFile,PVOID UserContext);
+#define PSYM_ENUMSOURCFILES_CALLBACK PSYM_ENUMSOURCEFILES_CALLBACK
+
+  WINBOOL IMAGEAPI SymEnumSourceFiles(HANDLE hProcess,ULONG64 ModBase,PCSTR Mask,PSYM_ENUMSOURCEFILES_CALLBACK cbSrcFiles,PVOID UserContext);
+  WINBOOL IMAGEAPI SymEnumSourceFilesW(HANDLE hProcess,ULONG64 ModBase,PCWSTR Mask,PSYM_ENUMSOURCEFILES_CALLBACKW cbSrcFiles,PVOID UserContext);
+  WINBOOL IMAGEAPI SymEnumerateModules64(HANDLE hProcess,PSYM_ENUMMODULES_CALLBACK64 EnumModulesCallback,PVOID UserContext);
+  WINBOOL IMAGEAPI SymEnumerateModulesW64(HANDLE hProcess,PSYM_ENUMMODULES_CALLBACKW64 EnumModulesCallback,PVOID UserContext);
+
+#ifdef _IMAGEHLP64
+#define SymEnumerateModules SymEnumerateModules64
+#else
+  WINBOOL IMAGEAPI SymEnumerateModules(HANDLE hProcess,PSYM_ENUMMODULES_CALLBACK EnumModulesCallback,PVOID UserContext);
+#endif
+
+  WINBOOL IMAGEAPI SymEnumerateSymbols64(HANDLE hProcess,DWORD64 BaseOfDll,PSYM_ENUMSYMBOLS_CALLBACK64 EnumSymbolsCallback,PVOID UserContext);
+  WINBOOL IMAGEAPI SymEnumerateSymbolsW64(HANDLE hProcess,DWORD64 BaseOfDll,PSYM_ENUMSYMBOLS_CALLBACK64W EnumSymbolsCallback,PVOID UserContext);
+
+#ifdef _IMAGEHLP64
+#define SymEnumerateSymbols SymEnumerateSymbols64
+#define SymEnumerateSymbolsW SymEnumerateSymbolsW64
+#else
+  WINBOOL IMAGEAPI SymEnumerateSymbols(HANDLE hProcess,DWORD BaseOfDll,PSYM_ENUMSYMBOLS_CALLBACK EnumSymbolsCallback,PVOID UserContext);
+  WINBOOL IMAGEAPI SymEnumerateSymbolsW(HANDLE hProcess,DWORD BaseOfDll,PSYM_ENUMSYMBOLS_CALLBACKW EnumSymbolsCallback,PVOID UserContext);
+#endif
+
+  WINBOOL IMAGEAPI EnumerateLoadedModules64(HANDLE hProcess,PENUMLOADED_MODULES_CALLBACK64 EnumLoadedModulesCallback,PVOID UserContext);
+  WINBOOL IMAGEAPI EnumerateLoadedModulesW64(HANDLE hProcess,PENUMLOADED_MODULES_CALLBACKW64 EnumLoadedModulesCallback,PVOID UserContext);
+
+#ifdef _IMAGEHLP64
+#define EnumerateLoadedModules EnumerateLoadedModules64
+#else
+  WINBOOL IMAGEAPI EnumerateLoadedModules(HANDLE hProcess,PENUMLOADED_MODULES_CALLBACK EnumLoadedModulesCallback,PVOID UserContext);
+#endif
+
+  PVOID IMAGEAPI SymFunctionTableAccess64(HANDLE hProcess,DWORD64 AddrBase);
+
+#ifdef _IMAGEHLP64
+#define SymFunctionTableAccess SymFunctionTableAccess64
+#else
+  PVOID IMAGEAPI SymFunctionTableAccess(HANDLE hProcess,DWORD AddrBase);
+#endif
+
+  WINBOOL IMAGEAPI SymGetModuleInfo64(HANDLE hProcess,DWORD64 qwAddr,PIMAGEHLP_MODULE64 ModuleInfo);
+  WINBOOL IMAGEAPI SymGetModuleInfoW64(HANDLE hProcess,DWORD64 qwAddr,PIMAGEHLP_MODULEW64 ModuleInfo);
+
+#ifdef _IMAGEHLP64
+#define SymGetModuleInfo SymGetModuleInfo64
+#define SymGetModuleInfoW SymGetModuleInfoW64
+#else
+  WINBOOL IMAGEAPI SymGetModuleInfo(HANDLE hProcess,DWORD dwAddr,PIMAGEHLP_MODULE ModuleInfo);
+  WINBOOL IMAGEAPI SymGetModuleInfoW(HANDLE hProcess,DWORD dwAddr,PIMAGEHLP_MODULEW ModuleInfo);
+#endif
+
+  DWORD64 IMAGEAPI SymGetModuleBase64(HANDLE hProcess,DWORD64 qwAddr);
+
+#ifdef _IMAGEHLP64
+#define SymGetModuleBase SymGetModuleBase64
+#else
+  DWORD IMAGEAPI SymGetModuleBase(HANDLE hProcess,DWORD dwAddr);
+#endif
+
+  WINBOOL IMAGEAPI SymGetSymNext64(HANDLE hProcess,PIMAGEHLP_SYMBOL64 Symbol);
+
+#ifdef _IMAGEHLP64
+#define SymGetSymNext SymGetSymNext64
+#else
+  WINBOOL IMAGEAPI SymGetSymNext(HANDLE hProcess,PIMAGEHLP_SYMBOL Symbol);
+#endif
+
+  WINBOOL IMAGEAPI SymGetSymPrev64(HANDLE hProcess,PIMAGEHLP_SYMBOL64 Symbol);
+
+#ifdef _IMAGEHLP64
+#define SymGetSymPrev SymGetSymPrev64
+#else
+  WINBOOL IMAGEAPI SymGetSymPrev(HANDLE hProcess,PIMAGEHLP_SYMBOL Symbol);
+#endif
+
+  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 WINBOOL (CALLBACK *PSYM_ENUMLINES_CALLBACK)(PSRCCODEINFO LineInfo,PVOID UserContext);
+  typedef WINBOOL (CALLBACK *PSYM_ENUMLINES_CALLBACKW)(PSRCCODEINFOW LineInfo,PVOID UserContext);
+
+  WINBOOL IMAGEAPI SymEnumLines(HANDLE hProcess,ULONG64 Base,PCSTR Obj,PCSTR File,PSYM_ENUMLINES_CALLBACK EnumLinesCallback,PVOID UserContext);
+  WINBOOL IMAGEAPI SymEnumLinesW(HANDLE hProcess,ULONG64 Base,PCWSTR Obj,PCSTR File,PSYM_ENUMLINES_CALLBACKW EnumLinesCallback,PVOID UserContext);
+  WINBOOL IMAGEAPI SymGetLineFromAddr64(HANDLE hProcess,DWORD64 qwAddr,PDWORD pdwDisplacement,PIMAGEHLP_LINE64 Line64);
+  WINBOOL IMAGEAPI SymGetLineFromAddrW64(HANDLE hProcess,DWORD64 qwAddr,PDWORD pdwDisplacement,PIMAGEHLP_LINEW64 Line64);
+
+#ifdef _IMAGEHLP64
+#define SymGetLineFromAddr SymGetLineFromAddr64
+#define SymGetLineFromAddrW SymGetLineFromAddrW64
+#else
+  WINBOOL IMAGEAPI SymGetLineFromAddr(HANDLE hProcess,DWORD dwAddr,PDWORD pdwDisplacement,PIMAGEHLP_LINE Line);
+  WINBOOL IMAGEAPI SymGetLineFromAddrW(HANDLE hProcess,DWORD dwAddr,PDWORD pdwDisplacement,PIMAGEHLP_LINEW Line);
+#endif
+
+  WINBOOL IMAGEAPI SymGetLineFromName64(HANDLE hProcess,PCSTR ModuleName,PCSTR FileName,DWORD dwLineNumber,PLONG plDisplacement,PIMAGEHLP_LINE64 Line);
+  WINBOOL IMAGEAPI SymGetLineFromNameW64(HANDLE hProcess,PCWSTR ModuleName,PCWSTR FileName,DWORD dwLineNumber,PLONG plDisplacement,PIMAGEHLP_LINEW64 Line);
+
+#ifdef _IMAGEHLP64
+#define SymGetLineFromName SymGetLineFromName64
+#else
+  WINBOOL IMAGEAPI SymGetLineFromName(HANDLE hProcess,PCSTR ModuleName,PCSTR FileName,DWORD dwLineNumber,PLONG plDisplacement,PIMAGEHLP_LINE Line);
+#endif
+
+  WINBOOL IMAGEAPI SymGetLineNext64(HANDLE hProcess,PIMAGEHLP_LINE64 Line);
+  WINBOOL IMAGEAPI SymGetLineNextW64(HANDLE hProcess,PIMAGEHLP_LINEW64 Line);
+
+#ifdef _IMAGEHLP64
+#define SymGetLineNext SymGetLineNext64
+#else
+  WINBOOL IMAGEAPI SymGetLineNext(HANDLE hProcess,PIMAGEHLP_LINE Line);
+#endif
+
+  WINBOOL IMAGEAPI SymGetLinePrev64(HANDLE hProcess,PIMAGEHLP_LINE64 Line);
+  WINBOOL IMAGEAPI SymGetLinePrevW64(HANDLE hProcess,PIMAGEHLP_LINEW64 Line);
+
+#ifdef _IMAGEHLP64
+#define SymGetLinePrev SymGetLinePrev64
+#else
+  WINBOOL IMAGEAPI SymGetLinePrev(HANDLE hProcess,PIMAGEHLP_LINE Line);
+#endif
+
+  WINBOOL IMAGEAPI SymMatchFileName(PCSTR FileName,PCSTR Match,PSTR *FileNameStop,PSTR *MatchStop);
+  WINBOOL IMAGEAPI SymMatchFileNameW(PCWSTR FileName,PCWSTR Match,PWSTR *FileNameStop,PWSTR *MatchStop);
+  WINBOOL IMAGEAPI SymInitialize(HANDLE hProcess,PCSTR UserSearchPath,WINBOOL fInvadeProcess);
+  WINBOOL IMAGEAPI SymInitializeW(HANDLE hProcess,PCWSTR UserSearchPath,WINBOOL fInvadeProcess);
+  WINBOOL IMAGEAPI SymGetSearchPath(HANDLE hProcess,PSTR SearchPath,DWORD SearchPathLength);
+  WINBOOL IMAGEAPI SymGetSearchPathW(HANDLE hProcess,PWSTR SearchPath,DWORD SearchPathLength);
+  WINBOOL IMAGEAPI SymSetSearchPath(HANDLE hProcess,PCSTR SearchPath);
+  WINBOOL IMAGEAPI SymSetSearchPathW(HANDLE hProcess,PCWSTR SearchPath);
+  DWORD64 IMAGEAPI SymLoadModule64(HANDLE hProcess,HANDLE hFile,PCSTR ImageName,PCSTR ModuleName,DWORD64 BaseOfDll,DWORD SizeOfDll);
+
+#define SLMFLAG_VIRTUAL 0x1
+
+  DWORD64 IMAGEAPI SymLoadModuleEx(HANDLE hProcess,HANDLE hFile,PCSTR ImageName,PCSTR ModuleName,DWORD64 BaseOfDll,DWORD DllSize,PMODLOAD_DATA Data,DWORD Flags);
+  DWORD64 IMAGEAPI SymLoadModuleExW(HANDLE hProcess,HANDLE hFile,PCWSTR ImageName,PCWSTR ModuleName,DWORD64 BaseOfDll,DWORD DllSize,PMODLOAD_DATA Data,DWORD Flags);
+
+#ifdef _IMAGEHLP64
+#define SymLoadModule SymLoadModule64
+#else
+  DWORD IMAGEAPI SymLoadModule(HANDLE hProcess,HANDLE hFile,PCSTR ImageName,PCSTR ModuleName,DWORD BaseOfDll,DWORD SizeOfDll);
+#endif
+
+  WINBOOL IMAGEAPI SymUnloadModule64(HANDLE hProcess,DWORD64 BaseOfDll);
+
+#ifdef _IMAGEHLP64
+#define SymUnloadModule SymUnloadModule64
+#else
+  WINBOOL IMAGEAPI SymUnloadModule(HANDLE hProcess,DWORD BaseOfDll);
+#endif
+
+  WINBOOL IMAGEAPI SymUnDName64(PIMAGEHLP_SYMBOL64 sym,PSTR UnDecName,DWORD UnDecNameLength);
+
+#ifdef _IMAGEHLP64
+#define SymUnDName SymUnDName64
+#else
+  WINBOOL IMAGEAPI SymUnDName(PIMAGEHLP_SYMBOL sym,PSTR UnDecName,DWORD UnDecNameLength);
+#endif
+
+  WINBOOL IMAGEAPI SymRegisterCallback64(HANDLE hProcess,PSYMBOL_REGISTERED_CALLBACK64 CallbackFunction,ULONG64 UserContext);
+  WINBOOL IMAGEAPI SymRegisterCallbackW64(HANDLE hProcess,PSYMBOL_REGISTERED_CALLBACK64 CallbackFunction,ULONG64 UserContext);
+
+  WINBOOL IMAGEAPI SymRegisterFunctionEntryCallback64(HANDLE hProcess,PSYMBOL_FUNCENTRY_CALLBACK64 CallbackFunction,ULONG64 UserContext);
+
+#ifdef _IMAGEHLP64
+#define SymRegisterCallback SymRegisterCallback64
+#define SymRegisterFunctionEntryCallback SymRegisterFunctionEntryCallback64
+#else
+  WINBOOL IMAGEAPI SymRegisterCallback(HANDLE hProcess,PSYMBOL_REGISTERED_CALLBACK CallbackFunction,PVOID UserContext);
+  WINBOOL IMAGEAPI SymRegisterFunctionEntryCallback(HANDLE hProcess,PSYMBOL_FUNCENTRY_CALLBACK CallbackFunction,PVOID UserContext);
+#endif
+
+  typedef struct _IMAGEHLP_SYMBOL_SRC {
+    DWORD sizeofstruct;
+    DWORD type;
+    char file[MAX_PATH];
+  } IMAGEHLP_SYMBOL_SRC,*PIMAGEHLP_SYMBOL_SRC;
+
+  typedef struct _MODULE_TYPE_INFO {
+    USHORT dataLength;
+    USHORT leaf;
+    BYTE data[1];
+  } MODULE_TYPE_INFO,*PMODULE_TYPE_INFO;
+
+  typedef struct _SYMBOL_INFO {
+    ULONG SizeOfStruct;
+    ULONG TypeIndex;
+    ULONG64 Reserved[2];
+    ULONG info;
+    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 info;
+    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;
+
+#define SYMFLAG_CLR_TOKEN 0x00040000
+#define SYMFLAG_CONSTANT 0x00000100
+#define SYMFLAG_EXPORT 0x00000200
+#define SYMFLAG_FORWARDER 0x00000400
+#define SYMFLAG_FRAMEREL 0x00000020
+#define SYMFLAG_FUNCTION 0x00000800
+#define SYMFLAG_ILREL 0x00010000
+#define SYMFLAG_LOCAL 0x00000080
+#define SYMFLAG_METADATA 0x00020000
+#define SYMFLAG_PARAMETER 0x00000040
+#define SYMFLAG_REGISTER 0x00000008
+#define SYMFLAG_REGREL 0x00000010
+#define SYMFLAG_SLOT 0x00008000
+#define SYMFLAG_THUNK 0x00002000
+#define SYMFLAG_TLSREL 0x00004000
+#define SYMFLAG_VALUEPRESENT 0x00000001
+#define SYMFLAG_VIRTUAL 0x00001000
+
+  typedef struct _SYMBOL_INFO_PACKAGE {
+    SYMBOL_INFO si;
+    CHAR name[MAX_SYM_NAME + 1];
+  } SYMBOL_INFO_PACKAGE,*PSYMBOL_INFO_PACKAGE;
+
+  typedef struct _IMAGEHLP_STACK_FRAME {
+    ULONG64 InstructionOffset;
+    ULONG64 ReturnOffset;
+    ULONG64 FrameOffset;
+    ULONG64 StackOffset;
+    ULONG64 BackingStoreOffset;
+    ULONG64 FuncTableEntry;
+    ULONG64 Params[4];
+    ULONG64 Reserved[5];
+    WINBOOL Virtual;
+    ULONG Reserved2;
+  } IMAGEHLP_STACK_FRAME,*PIMAGEHLP_STACK_FRAME;
+
+  typedef VOID IMAGEHLP_CONTEXT,*PIMAGEHLP_CONTEXT;
+
+  WINBOOL IMAGEAPI SymSetContext(HANDLE hProcess,PIMAGEHLP_STACK_FRAME StackFrame,PIMAGEHLP_CONTEXT Context);
+  WINBOOL IMAGEAPI SymFromAddr(HANDLE hProcess,DWORD64 Address,PDWORD64 Displacement,PSYMBOL_INFO Symbol);
+  WINBOOL IMAGEAPI SymFromAddrW(HANDLE hProcess,DWORD64 Address,PDWORD64 Displacement,PSYMBOL_INFOW Symbol);
+  WINBOOL IMAGEAPI SymFromToken(HANDLE hProcess,DWORD64 Base,DWORD Token,PSYMBOL_INFO Symbol);
+  WINBOOL IMAGEAPI SymFromTokenW(HANDLE hProcess,DWORD64 Base,DWORD Token,PSYMBOL_INFOW Symbol);
+  WINBOOL IMAGEAPI SymFromName(HANDLE hProcess,PCSTR Name,PSYMBOL_INFO Symbol);
+  WINBOOL IMAGEAPI SymFromNameW(HANDLE hProcess,PCWSTR Name,PSYMBOL_INFOW Symbol);
+
+  typedef WINBOOL (CALLBACK *PSYM_ENUMERATESYMBOLS_CALLBACK)(PSYMBOL_INFO pSymInfo,ULONG SymbolSize,PVOID UserContext);
+  typedef WINBOOL (CALLBACK *PSYM_ENUMERATESYMBOLS_CALLBACKW)(PSYMBOL_INFOW pSymInfo,ULONG SymbolSize,PVOID UserContext);
+
+  WINBOOL IMAGEAPI SymEnumSymbols(HANDLE hProcess,ULONG64 BaseOfDll,PCSTR Mask,PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback,PVOID UserContext);
+  WINBOOL IMAGEAPI SymEnumSymbolsW(HANDLE hProcess,ULONG64 BaseOfDll,PCWSTR Mask,PSYM_ENUMERATESYMBOLS_CALLBACKW EnumSymbolsCallback,PVOID UserContext);
+  WINBOOL IMAGEAPI SymEnumSymbolsForAddr(HANDLE hProcess,DWORD64 Address,PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback,PVOID UserContext);
+  WINBOOL IMAGEAPI SymEnumSymbolsForAddrW(HANDLE hProcess,DWORD64 Address,PSYM_ENUMERATESYMBOLS_CALLBACKW EnumSymbolsCallback,PVOID UserContext);
+
+#define SYMENUMFLAG_FULLSRCH 1
+#define SYMENUMFLAG_SPEEDSRCH 2
+
+  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;
+
+  typedef struct _TI_FINDCHILDREN_PARAMS {
+    ULONG Count;
+    ULONG Start;
+    ULONG ChildId[1];
+  } TI_FINDCHILDREN_PARAMS;
+
+  WINBOOL IMAGEAPI SymGetTypeInfo(HANDLE hProcess,DWORD64 ModBase,ULONG TypeId,IMAGEHLP_SYMBOL_TYPE_INFO GetType,PVOID pInfo);
+  WINBOOL IMAGEAPI SymEnumTypes(HANDLE hProcess,ULONG64 BaseOfDll,PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback,PVOID UserContext);
+  WINBOOL IMAGEAPI SymEnumTypesW(HANDLE hProcess,ULONG64 BaseOfDll,PSYM_ENUMERATESYMBOLS_CALLBACKW EnumSymbolsCallback,PVOID UserContext);
+  WINBOOL IMAGEAPI SymGetTypeFromName(HANDLE hProcess,ULONG64 BaseOfDll,PCSTR Name,PSYMBOL_INFO Symbol);
+  WINBOOL IMAGEAPI SymGetTypeFromNameW(HANDLE hProcess,ULONG64 BaseOfDll,PCWSTR Name,PSYMBOL_INFOW Symbol);
+  WINBOOL IMAGEAPI SymAddSymbol(HANDLE hProcess,ULONG64 BaseOfDll,PCSTR Name,DWORD64 Address,DWORD Size,DWORD Flags);
+  WINBOOL IMAGEAPI SymAddSymbolW(HANDLE hProcess,ULONG64 BaseOfDll,PCWSTR Name,DWORD64 Address,DWORD Size,DWORD Flags);
+  WINBOOL IMAGEAPI SymDeleteSymbol(HANDLE hProcess,ULONG64 BaseOfDll,PCSTR Name,DWORD64 Address,DWORD Flags);
+  WINBOOL IMAGEAPI SymDeleteSymbolW(HANDLE hProcess,ULONG64 BaseOfDll,PCWSTR Name,DWORD64 Address,DWORD Flags);
+
+  typedef WINBOOL (WINAPI *PDBGHELP_CREATE_USER_DUMP_CALLBACK)(DWORD DataType,PVOID *Data,LPDWORD DataLength,PVOID UserData);
+
+  WINBOOL WINAPI DbgHelpCreateUserDump(LPCSTR FileName,PDBGHELP_CREATE_USER_DUMP_CALLBACK Callback,PVOID UserData);
+  WINBOOL WINAPI DbgHelpCreateUserDumpW(LPCWSTR FileName,PDBGHELP_CREATE_USER_DUMP_CALLBACK Callback,PVOID UserData);
+  WINBOOL IMAGEAPI SymGetSymFromAddr64(HANDLE hProcess,DWORD64 qwAddr,PDWORD64 pdwDisplacement,PIMAGEHLP_SYMBOL64 Symbol);
+
+#ifdef _IMAGEHLP64
+#define SymGetSymFromAddr SymGetSymFromAddr64
+#else
+  WINBOOL IMAGEAPI SymGetSymFromAddr(HANDLE hProcess,DWORD dwAddr,PDWORD pdwDisplacement,PIMAGEHLP_SYMBOL Symbol);
+#endif
+
+  WINBOOL IMAGEAPI SymGetSymFromName64(HANDLE hProcess,PCSTR Name,PIMAGEHLP_SYMBOL64 Symbol);
+
+#ifdef _IMAGEHLP64
+#define SymGetSymFromName SymGetSymFromName64
+#else
+  WINBOOL IMAGEAPI SymGetSymFromName(HANDLE hProcess,PCSTR Name,PIMAGEHLP_SYMBOL Symbol);
+#endif
+
+  DBHLP_DEPRECIATED WINBOOL IMAGEAPI FindFileInPath(HANDLE hprocess,PCSTR SearchPath,PCSTR FileName,PVOID id,DWORD two,DWORD three,DWORD flags,PSTR FilePath);
+  DBHLP_DEPRECIATED WINBOOL IMAGEAPI FindFileInSearchPath(HANDLE hprocess,PCSTR SearchPath,PCSTR FileName,DWORD one,DWORD two,DWORD three,PSTR FilePath);
+  DBHLP_DEPRECIATED WINBOOL IMAGEAPI SymEnumSym(HANDLE hProcess,ULONG64 BaseOfDll,PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback,PVOID UserContext);
+
+#ifdef __cplusplus
+}
+#endif
+
+#define SYMF_OMAP_GENERATED 0x00000001
+#define SYMF_OMAP_MODIFIED 0x00000002
+#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
+
+#define IMAGEHLP_SYMBOL_INFO_VALUEPRESENT 1
+#define IMAGEHLP_SYMBOL_INFO_REGISTER SYMF_REGISTER
+#define IMAGEHLP_SYMBOL_INFO_REGRELATIVE SYMF_REGREL
+#define IMAGEHLP_SYMBOL_INFO_FRAMERELATIVE SYMF_FRAMEREL
+#define IMAGEHLP_SYMBOL_INFO_PARAMETER SYMF_PARAMETER
+#define IMAGEHLP_SYMBOL_INFO_LOCAL SYMF_LOCAL
+#define IMAGEHLP_SYMBOL_INFO_CONSTANT SYMF_CONSTANT
+#define IMAGEHLP_SYMBOL_FUNCTION SYMF_FUNCTION
+#define IMAGEHLP_SYMBOL_VIRTUAL SYMF_VIRTUAL
+#define IMAGEHLP_SYMBOL_THUNK SYMF_THUNK
+#define IMAGEHLP_SYMBOL_INFO_TLSRELATIVE SYMF_TLSREL
+
+#include <pshpack4.h>
+
+#define MINIDUMP_SIGNATURE ('PMDM')
+#define MINIDUMP_VERSION (42899)
+  typedef DWORD RVA;
+  typedef ULONG64 RVA64;
+
+  typedef struct _MINIDUMP_LOCATION_DESCRIPTOR {
+    ULONG32 DataSize;
+    RVA Rva;
+  } MINIDUMP_LOCATION_DESCRIPTOR;
+
+  typedef struct _MINIDUMP_LOCATION_DESCRIPTOR64 {
+    ULONG64 DataSize;
+    RVA64 Rva;
+  } MINIDUMP_LOCATION_DESCRIPTOR64;
+
+  typedef struct _MINIDUMP_MEMORY_DESCRIPTOR {
+    ULONG64 StartOfMemoryRange;
+    MINIDUMP_LOCATION_DESCRIPTOR Memory;
+  } MINIDUMP_MEMORY_DESCRIPTOR,*PMINIDUMP_MEMORY_DESCRIPTOR;
+
+  typedef struct _MINIDUMP_MEMORY_DESCRIPTOR64 {
+    ULONG64 StartOfMemoryRange;
+    ULONG64 DataSize;
+  } MINIDUMP_MEMORY_DESCRIPTOR64,*PMINIDUMP_MEMORY_DESCRIPTOR64;
+
+  typedef struct _MINIDUMP_HEADER {
+    ULONG32 Signature;
+    ULONG32 Version;
+    ULONG32 NumberOfStreams;
+    RVA StreamDirectoryRva;
+    ULONG32 CheckSum;
+    __C89_NAMELESS union {
+      ULONG32 Reserved;
+      ULONG32 TimeDateStamp;
+    };
+    ULONG64 Flags;
+  } MINIDUMP_HEADER,*PMINIDUMP_HEADER;
+
+  typedef struct _MINIDUMP_DIRECTORY {
+    ULONG32 StreamType;
+    MINIDUMP_LOCATION_DESCRIPTOR Location;
+  } MINIDUMP_DIRECTORY,*PMINIDUMP_DIRECTORY;
+
+  typedef struct _MINIDUMP_STRING {
+    ULONG32 Length;
+    WCHAR Buffer[0];
+  } MINIDUMP_STRING,*PMINIDUMP_STRING;
+
+  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,
+    HandleOperationListStream = 18,
+    TokenStream = 19,
+    JavaScriptDataStream = 20,
+    SystemMemoryInfoStream = 21,
+    ProcessVmCountersStream = 22,
+    IptTraceStream = 23,
+    ThreadNamesStream = 24,
+    ceStreamNull = 0x8000,
+    ceStreamSystemInfo = 0x8001,
+    ceStreamException = 0x8002,
+    ceStreamModuleList = 0x8003,
+    ceStreamProcessList = 0x8004,
+    ceStreamThreadList = 0x8005,
+    ceStreamThreadContextList = 0x8006,
+    ceStreamThreadCallStackList = 0x8007,
+    ceStreamMemoryVirtualList = 0x8008,
+    ceStreamMemoryPhysicalList = 0x8009,
+    ceStreamBucketParameters = 0x800a,
+    ceStreamProcessModuleMap = 0x800b,
+    ceStreamDiagnosisList = 0x800c,
+    LastReservedStream = 0xffff
+  } MINIDUMP_STREAM_TYPE;
+
+  typedef union _CPU_INFORMATION {
+    struct {
+      ULONG32 VendorId[3];
+      ULONG32 VersionInformation;
+      ULONG32 FeatureInformation;
+      ULONG32 AMDExtendedCpuFeatures;
+    } X86CpuInfo;
+    struct {
+      ULONG64 ProcessorFeatures[2];
+    } OtherCpuInfo;
+  } CPU_INFORMATION,*PCPU_INFORMATION;
+
+  typedef struct _MINIDUMP_SYSTEM_INFO {
+    USHORT ProcessorArchitecture;
+    USHORT ProcessorLevel;
+    USHORT ProcessorRevision;
+    __C89_NAMELESS union {
+      USHORT Reserved0;
+      __C89_NAMELESS struct {
+	UCHAR NumberOfProcessors;
+	UCHAR ProductType;
+      };
+    };
+    ULONG32 MajorVersion;
+    ULONG32 MinorVersion;
+    ULONG32 BuildNumber;
+    ULONG32 PlatformId;
+    RVA CSDVersionRva;
+    __C89_NAMELESS union {
+      ULONG32 Reserved1;
+      __C89_NAMELESS struct {
+	USHORT SuiteMask;
+	USHORT Reserved2;
+      };
+    };
+    CPU_INFORMATION Cpu;
+  } MINIDUMP_SYSTEM_INFO,*PMINIDUMP_SYSTEM_INFO;
+
+  C_ASSERT(sizeof(((PPROCESS_INFORMATION)0)->dwThreadId)==4);
+
+  typedef struct _MINIDUMP_THREAD {
+    ULONG32 ThreadId;
+    ULONG32 SuspendCount;
+    ULONG32 PriorityClass;
+    ULONG32 Priority;
+    ULONG64 Teb;
+    MINIDUMP_MEMORY_DESCRIPTOR Stack;
+    MINIDUMP_LOCATION_DESCRIPTOR ThreadContext;
+  } MINIDUMP_THREAD,*PMINIDUMP_THREAD;
+
+  typedef struct _MINIDUMP_THREAD_LIST {
+    ULONG32 NumberOfThreads;
+    MINIDUMP_THREAD Threads[0];
+  } MINIDUMP_THREAD_LIST,*PMINIDUMP_THREAD_LIST;
+
+  typedef struct _MINIDUMP_THREAD_EX {
+    ULONG32 ThreadId;
+    ULONG32 SuspendCount;
+    ULONG32 PriorityClass;
+    ULONG32 Priority;
+    ULONG64 Teb;
+    MINIDUMP_MEMORY_DESCRIPTOR Stack;
+    MINIDUMP_LOCATION_DESCRIPTOR ThreadContext;
+    MINIDUMP_MEMORY_DESCRIPTOR BackingStore;
+  } MINIDUMP_THREAD_EX,*PMINIDUMP_THREAD_EX;
+
+  typedef struct _MINIDUMP_THREAD_EX_LIST {
+    ULONG32 NumberOfThreads;
+    MINIDUMP_THREAD_EX Threads[0];
+  } MINIDUMP_THREAD_EX_LIST,*PMINIDUMP_THREAD_EX_LIST;
+
+  typedef struct _MINIDUMP_EXCEPTION {
+    ULONG32 ExceptionCode;
+    ULONG32 ExceptionFlags;
+    ULONG64 ExceptionRecord;
+    ULONG64 ExceptionAddress;
+    ULONG32 NumberParameters;
+    ULONG32 __unusedAlignment;
+    ULONG64 ExceptionInformation[EXCEPTION_MAXIMUM_PARAMETERS];
+  } MINIDUMP_EXCEPTION,*PMINIDUMP_EXCEPTION;
+
+  typedef struct MINIDUMP_EXCEPTION_STREAM {
+    ULONG32 ThreadId;
+    ULONG32 __alignment;
+    MINIDUMP_EXCEPTION ExceptionRecord;
+    MINIDUMP_LOCATION_DESCRIPTOR ThreadContext;
+  } MINIDUMP_EXCEPTION_STREAM,*PMINIDUMP_EXCEPTION_STREAM;
+
+  typedef struct _MINIDUMP_MODULE {
+    ULONG64 BaseOfImage;
+    ULONG32 SizeOfImage;
+    ULONG32 CheckSum;
+    ULONG32 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 {
+    ULONG32 NumberOfModules;
+    MINIDUMP_MODULE Modules[0];
+  } MINIDUMP_MODULE_LIST,*PMINIDUMP_MODULE_LIST;
+
+  typedef struct _MINIDUMP_MEMORY_LIST {
+    ULONG32 NumberOfMemoryRanges;
+    MINIDUMP_MEMORY_DESCRIPTOR MemoryRanges[0];
+  } MINIDUMP_MEMORY_LIST,*PMINIDUMP_MEMORY_LIST;
+
+  typedef struct _MINIDUMP_MEMORY64_LIST {
+    ULONG64 NumberOfMemoryRanges;
+    RVA64 BaseRva;
+    MINIDUMP_MEMORY_DESCRIPTOR64 MemoryRanges[0];
+  } MINIDUMP_MEMORY64_LIST,*PMINIDUMP_MEMORY64_LIST;
+
+  typedef struct _MINIDUMP_EXCEPTION_INFORMATION {
+    DWORD ThreadId;
+    PEXCEPTION_POINTERS ExceptionPointers;
+    WINBOOL ClientPointers;
+  } MINIDUMP_EXCEPTION_INFORMATION,*PMINIDUMP_EXCEPTION_INFORMATION;
+
+  typedef struct _MINIDUMP_EXCEPTION_INFORMATION64 {
+    DWORD ThreadId;
+    ULONG64 ExceptionRecord;
+    ULONG64 ContextRecord;
+    WINBOOL ClientPointers;
+  } MINIDUMP_EXCEPTION_INFORMATION64,*PMINIDUMP_EXCEPTION_INFORMATION64;
+
+  typedef enum _MINIDUMP_HANDLE_OBJECT_INFORMATION_TYPE {
+    MiniHandleObjectInformationNone,
+    MiniThreadInformation1,
+    MiniMutantInformation1,
+    MiniMutantInformation2,
+    MiniProcessInformation1,
+    MiniProcessInformation2,
+    MiniEventInformation1,
+    MiniSectionInformation1,
+    MiniSemaphoreInformation1,
+    MiniHandleObjectInformationTypeMax
+  } MINIDUMP_HANDLE_OBJECT_INFORMATION_TYPE;
+
+  typedef struct _MINIDUMP_HANDLE_OBJECT_INFORMATION {
+    RVA NextInfoRva;
+    ULONG32 InfoType;
+    ULONG32 SizeOfInfo;
+  } MINIDUMP_HANDLE_OBJECT_INFORMATION;
+
+  typedef struct _MINIDUMP_HANDLE_DESCRIPTOR {
+    ULONG64 Handle;
+    RVA TypeNameRva;
+    RVA ObjectNameRva;
+    ULONG32 Attributes;
+    ULONG32 GrantedAccess;
+    ULONG32 HandleCount;
+    ULONG32 PointerCount;
+  } MINIDUMP_HANDLE_DESCRIPTOR,*PMINIDUMP_HANDLE_DESCRIPTOR;
+
+  typedef struct _MINIDUMP_HANDLE_DATA_STREAM {
+    ULONG32 SizeOfHeader;
+    ULONG32 SizeOfDescriptor;
+    ULONG32 NumberOfDescriptors;
+    ULONG32 Reserved;
+  } MINIDUMP_HANDLE_DATA_STREAM,*PMINIDUMP_HANDLE_DATA_STREAM;
+
+  typedef struct _MINIDUMP_FUNCTION_TABLE_DESCRIPTOR {
+    ULONG64 MinimumAddress;
+    ULONG64 MaximumAddress;
+    ULONG64 BaseAddress;
+    ULONG32 EntryCount;
+    ULONG32 SizeOfAlignPad;
+  } MINIDUMP_FUNCTION_TABLE_DESCRIPTOR,*PMINIDUMP_FUNCTION_TABLE_DESCRIPTOR;
+
+  typedef struct _MINIDUMP_FUNCTION_TABLE_STREAM {
+    ULONG32 SizeOfHeader;
+    ULONG32 SizeOfDescriptor;
+    ULONG32 SizeOfNativeDescriptor;
+    ULONG32 SizeOfFunctionEntry;
+    ULONG32 NumberOfDescriptors;
+    ULONG32 SizeOfAlignPad;
+  } MINIDUMP_FUNCTION_TABLE_STREAM,*PMINIDUMP_FUNCTION_TABLE_STREAM;
+
+  typedef struct _MINIDUMP_UNLOADED_MODULE {
+    ULONG64 BaseOfImage;
+    ULONG32 SizeOfImage;
+    ULONG32 CheckSum;
+    ULONG32 TimeDateStamp;
+    RVA ModuleNameRva;
+  } MINIDUMP_UNLOADED_MODULE,*PMINIDUMP_UNLOADED_MODULE;
+
+  typedef struct _MINIDUMP_UNLOADED_MODULE_LIST {
+    ULONG32 SizeOfHeader;
+    ULONG32 SizeOfEntry;
+    ULONG32 NumberOfEntries;
+  } MINIDUMP_UNLOADED_MODULE_LIST,*PMINIDUMP_UNLOADED_MODULE_LIST;
+
+#define MINIDUMP_MISC1_PROCESS_ID 0x00000001
+#define MINIDUMP_MISC1_PROCESS_TIMES 0x00000002
+#define MINIDUMP_MISC1_PROCESSOR_POWER_INFO 0x00000004
+
+  typedef struct _MINIDUMP_MISC_INFO {
+    ULONG32 SizeOfInfo;
+    ULONG32 Flags1;
+    ULONG32 ProcessId;
+    ULONG32 ProcessCreateTime;
+    ULONG32 ProcessUserTime;
+    ULONG32 ProcessKernelTime;
+  } MINIDUMP_MISC_INFO,*PMINIDUMP_MISC_INFO;
+
+  typedef struct _MINIDUMP_USER_RECORD {
+    ULONG32 Type;
+    MINIDUMP_LOCATION_DESCRIPTOR Memory;
+  } MINIDUMP_USER_RECORD,*PMINIDUMP_USER_RECORD;
+
+  typedef struct _MINIDUMP_USER_STREAM {
+    ULONG32 Type;
+    ULONG BufferSize;
+    PVOID 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_CALLBACK_TYPE {
+    ModuleCallback,
+    ThreadCallback,
+    ThreadExCallback,
+    IncludeThreadCallback,
+    IncludeModuleCallback,
+    MemoryCallback,
+    CancelCallback,
+    WriteKernelMinidumpCallback,
+    KernelMinidumpStatusCallback,
+    RemoveMemoryCallback,
+    IncludeVmRegionCallback,
+    IoStartCallback,
+    IoWriteAllCallback,
+    IoFinishCallback,
+    ReadMemoryFailureCallback,
+    SecondaryFlagsCallback,
+    IsProcessSnapshotCallback,
+    VmStartCallback,
+    VmQueryCallback,
+    VmPreReadCallback,
+    VmPostReadCallback
+  } MINIDUMP_CALLBACK_TYPE;
+
+  typedef struct _MINIDUMP_THREAD_CALLBACK {
+    ULONG ThreadId;
+    HANDLE ThreadHandle;
+#if defined(__aarch64__)
+    ULONG Pad;
+#endif
+    CONTEXT Context;
+    ULONG SizeOfContext;
+    ULONG64 StackBase;
+    ULONG64 StackEnd;
+  } MINIDUMP_THREAD_CALLBACK,*PMINIDUMP_THREAD_CALLBACK;
+
+  typedef struct _MINIDUMP_THREAD_EX_CALLBACK {
+    ULONG ThreadId;
+    HANDLE ThreadHandle;
+#if defined(__aarch64__)
+    ULONG Pad;
+#endif
+    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 enum _MINIDUMP_SECONDARY_FLAGS {
+    MiniSecondaryWithoutPowerInfo   = 0x00000001
+  } MINIDUMP_SECONDARY_FLAGS;
+
+  typedef struct _MINIDUMP_CALLBACK_INPUT {
+    ULONG ProcessId;
+    HANDLE ProcessHandle;
+    ULONG CallbackType;
+    __C89_NAMELESS union {
+      MINIDUMP_THREAD_CALLBACK Thread;
+      MINIDUMP_THREAD_EX_CALLBACK ThreadEx;
+      MINIDUMP_MODULE_CALLBACK Module;
+      MINIDUMP_INCLUDE_THREAD_CALLBACK IncludeThread;
+      MINIDUMP_INCLUDE_MODULE_CALLBACK IncludeModule;
+    };
+  } MINIDUMP_CALLBACK_INPUT,*PMINIDUMP_CALLBACK_INPUT;
+
+typedef struct _MINIDUMP_MEMORY_INFO {
+  ULONG64 BaseAddress;
+  ULONG64 AllocationBase;
+  ULONG32 AllocationProtect;
+  ULONG32 __alignment1;
+  ULONG64 RegionSize;
+  ULONG32 State;
+  ULONG32 Protect;
+  ULONG32 Type;
+  ULONG32 __alignment2;
+} MINIDUMP_MEMORY_INFO, *PMINIDUMP_MEMORY_INFO;
+
+typedef struct _MINIDUMP_MISC_INFO_2 {
+  ULONG32 SizeOfInfo;
+  ULONG32 Flags1;
+  ULONG32 ProcessId;
+  ULONG32 ProcessCreateTime;
+  ULONG32 ProcessUserTime;
+  ULONG32 ProcessKernelTime;
+  ULONG32 ProcessorMaxMhz;
+  ULONG32 ProcessorCurrentMhz;
+  ULONG32 ProcessorMhzLimit;
+  ULONG32 ProcessorMaxIdleState;
+  ULONG32 ProcessorCurrentIdleState;
+} MINIDUMP_MISC_INFO_2, *PMINIDUMP_MISC_INFO_2;
+
+typedef struct _MINIDUMP_MEMORY_INFO_LIST {
+  ULONG   SizeOfHeader;
+  ULONG   SizeOfEntry;
+  ULONG64 NumberOfEntries;
+} MINIDUMP_MEMORY_INFO_LIST, *PMINIDUMP_MEMORY_INFO_LIST;
+
+  typedef struct _MINIDUMP_CALLBACK_OUTPUT {
+    __C89_NAMELESS union {
+      ULONG ModuleWriteFlags;
+      ULONG ThreadWriteFlags;
+      ULONG SecondaryFlags;
+      __C89_NAMELESS struct {
+	ULONG64 MemoryBase;
+	ULONG MemorySize;
+      };
+      __C89_NAMELESS struct {
+	WINBOOL CheckCancel;
+	WINBOOL Cancel;
+      };
+      HANDLE Handle;
+    };
+    __C89_NAMELESS struct {
+      MINIDUMP_MEMORY_INFO VmRegion;
+      WINBOOL Continue;
+    };
+    HRESULT Status;
+  } MINIDUMP_CALLBACK_OUTPUT, *PMINIDUMP_CALLBACK_OUTPUT;
+
+  typedef enum _MINIDUMP_TYPE {
+    MiniDumpNormal                           = 0x00000000,
+    MiniDumpWithDataSegs                     = 0x00000001,
+    MiniDumpWithFullMemory                   = 0x00000002,
+    MiniDumpWithHandleData                   = 0x00000004,
+    MiniDumpFilterMemory                     = 0x00000008,
+    MiniDumpScanMemory                       = 0x00000010,
+    MiniDumpWithUnloadedModules              = 0x00000020,
+    MiniDumpWithIndirectlyReferencedMemory   = 0x00000040,
+    MiniDumpFilterModulePaths                = 0x00000080,
+    MiniDumpWithProcessThreadData            = 0x00000100,
+    MiniDumpWithPrivateReadWriteMemory       = 0x00000200,
+    MiniDumpWithoutOptionalData              = 0x00000400,
+    MiniDumpWithFullMemoryInfo               = 0x00000800,
+    MiniDumpWithThreadInfo                   = 0x00001000,
+    MiniDumpWithCodeSegs                     = 0x00002000,
+    MiniDumpWithoutAuxiliaryState            = 0x00004000,
+    MiniDumpWithFullAuxiliaryState           = 0x00008000,
+    MiniDumpWithPrivateWriteCopyMemory       = 0x00010000,
+    MiniDumpIgnoreInaccessibleMemory         = 0x00020000,
+    MiniDumpWithTokenInformation             = 0x00040000,
+    MiniDumpWithModuleHeaders                = 0x00080000,
+    MiniDumpFilterTriage                     = 0x00100000,
+    MiniDumpWithAvxXStateContext             = 0x00200000,
+    MiniDumpWithIptTrace                     = 0x00400000,
+    MiniDumpScanInaccessiblePartialPages     = 0x00800000,
+    MiniDumpValidTypeFlags                   = 0x00ffffff
+  } MINIDUMP_TYPE;
+
+#define MINIDUMP_THREAD_INFO_ERROR_THREAD    0x00000001
+#define MINIDUMP_THREAD_INFO_WRITING_THREAD  0x00000002
+#define MINIDUMP_THREAD_INFO_EXITED_THREAD   0x00000004
+#define MINIDUMP_THREAD_INFO_INVALID_INFO    0x00000008
+#define MINIDUMP_THREAD_INFO_INVALID_CONTEXT 0x00000010
+#define MINIDUMP_THREAD_INFO_INVALID_TEB     0x00000020
+
+typedef struct _MINIDUMP_THREAD_INFO {
+  ULONG32 ThreadId;
+  ULONG32 DumpFlags;
+  ULONG32 DumpError;
+  ULONG32 ExitStatus;
+  ULONG64 CreateTime;
+  ULONG64 ExitTime;
+  ULONG64 KernelTime;
+  ULONG64 UserTime;
+  ULONG64 StartAddress;
+  ULONG64 Affinity;
+} MINIDUMP_THREAD_INFO, *PMINIDUMP_THREAD_INFO;
+
+typedef struct _MINIDUMP_THREAD_INFO_LIST {
+  ULONG   SizeOfHeader;
+  ULONG   SizeOfEntry;
+  ULONG   NumberOfEntries;
+} MINIDUMP_THREAD_INFO_LIST, *PMINIDUMP_THREAD_INFO_LIST;
+
+typedef struct _MINIDUMP_HANDLE_OPERATION_LIST {
+    ULONG32 SizeOfHeader;
+    ULONG32 SizeOfEntry;
+    ULONG32 NumberOfEntries;
+    ULONG32 Reserved;
+} MINIDUMP_HANDLE_OPERATION_LIST, *PMINIDUMP_HANDLE_OPERATION_LIST;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+  typedef WINBOOL (WINAPI *MINIDUMP_CALLBACK_ROUTINE)(PVOID CallbackParam,CONST PMINIDUMP_CALLBACK_INPUT CallbackInput,PMINIDUMP_CALLBACK_OUTPUT CallbackOutput);
+
+  typedef struct _MINIDUMP_CALLBACK_INFORMATION {
+    MINIDUMP_CALLBACK_ROUTINE CallbackRoutine;
+    PVOID CallbackParam;
+  } MINIDUMP_CALLBACK_INFORMATION,*PMINIDUMP_CALLBACK_INFORMATION;
+
+#define RVA_TO_ADDR(Mapping,Rva) ((PVOID)(((ULONG_PTR) (Mapping)) + (Rva)))
+
+  WINBOOL WINAPI MiniDumpWriteDump(HANDLE hProcess,DWORD ProcessId,HANDLE hFile,MINIDUMP_TYPE DumpType,CONST PMINIDUMP_EXCEPTION_INFORMATION ExceptionParam,CONST PMINIDUMP_USER_STREAM_INFORMATION UserStreamParam,CONST PMINIDUMP_CALLBACK_INFORMATION CallbackParam);
+  WINBOOL WINAPI MiniDumpReadDumpStream(PVOID BaseOfDump,ULONG StreamNumber,PMINIDUMP_DIRECTORY *Dir,PVOID *StreamPointer,ULONG *StreamSize);
+
+WINBOOL WINAPI EnumerateLoadedModulesEx(
+  HANDLE hProcess,
+  PENUMLOADED_MODULES_CALLBACK64 EnumLoadedModulesCallback,
+  PVOID UserContext
+);
+
+WINBOOL WINAPI EnumerateLoadedModulesExW(
+  HANDLE hProcess,
+  PENUMLOADED_MODULES_CALLBACKW64 EnumLoadedModulesCallback,
+  PVOID UserContext
+);
+
+WINBOOL WINAPI SymAddSourceStream(
+  HANDLE hProcess,
+  ULONG64 Base,
+  PCSTR StreamFile,
+  PBYTE Buffer,
+  size_t Size
+);
+
+WINBOOL WINAPI SymAddSourceStreamW(
+  HANDLE hProcess,
+  ULONG64 Base,
+  PCWSTR StreamFile,
+  PBYTE Buffer,
+  size_t Size
+);
+
+WINBOOL WINAPI SymEnumSourceLines(
+  HANDLE hProcess,
+  ULONG64 Base,
+  PCSTR Obj,
+  PCSTR File,
+  DWORD Line,
+  DWORD Flags,
+  PSYM_ENUMLINES_CALLBACK EnumLinesCallback,
+  PVOID UserContext
+);
+
+WINBOOL WINAPI SymEnumSourceLinesW(
+  HANDLE hProcess,
+  ULONG64 Base,
+  PCWSTR Obj,
+  PCWSTR File,
+  DWORD Line,
+  DWORD Flags,
+  PSYM_ENUMLINES_CALLBACKW EnumLinesCallback,
+  PVOID UserContext
+);
+
+WINBOOL WINAPI SymEnumTypesByName(
+  HANDLE hProcess,
+  ULONG64 BaseOfDll,
+  PCSTR mask,
+  PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback,
+  PVOID UserContext
+);
+
+WINBOOL WINAPI SymEnumTypesByNameW(
+  HANDLE hProcess,
+  ULONG64 BaseOfDll,
+  PCSTR mask,
+  PSYM_ENUMERATESYMBOLS_CALLBACKW EnumSymbolsCallback,
+  PVOID UserContext
+);
+
+HANDLE WINAPI SymFindDebugInfoFile(
+  HANDLE hProcess,
+  PCSTR FileName,
+  PSTR DebugFilePath,
+  PFIND_DEBUG_FILE_CALLBACK Callback,
+  PVOID CallerData
+);
+
+HANDLE WINAPI SymFindDebugInfoFileW(
+  HANDLE hProcess,
+  PCWSTR FileName,
+  PWSTR DebugFilePath,
+  PFIND_DEBUG_FILE_CALLBACKW Callback,
+  PVOID CallerData
+);
+
+HANDLE WINAPI SymFindExecutableImage(
+  HANDLE hProcess,
+  PCSTR FileName,
+  PSTR ImageFilePath,
+  PFIND_EXE_FILE_CALLBACK Callback,
+  PVOID CallerData
+);
+
+HANDLE WINAPI SymFindExecutableImageW(
+  HANDLE hProcess,
+  PCWSTR FileName,
+  PWSTR ImageFilePath,
+  PFIND_EXE_FILE_CALLBACKW Callback,
+  PVOID CallerData
+);
+
+WINBOOL WINAPI SymFromIndex(
+  HANDLE hProcess,
+  ULONG64 BaseOfDll,
+  DWORD Index,
+  PSYMBOL_INFO Symbol
+);
+
+WINBOOL WINAPI SymFromIndexW(
+  HANDLE hProcess,
+  ULONG64 BaseOfDll,
+  DWORD Index,
+  PSYMBOL_INFOW Symbol
+);
+
+WINBOOL WINAPI SymGetScope(
+  HANDLE hProcess,
+  ULONG64 BaseOfDll,
+  DWORD Index,
+  PSYMBOL_INFO Symbol
+);
+
+WINBOOL WINAPI SymGetScopeW(
+  HANDLE hProcess,
+  ULONG64 BaseOfDll,
+  DWORD Index,
+  PSYMBOL_INFOW Symbol
+);
+
+WINBOOL WINAPI SymGetSourceFileFromToken(
+  HANDLE hProcess,
+  PVOID Token,
+  PCSTR Params,
+  PSTR FilePath,
+  DWORD Size
+);
+
+WINBOOL WINAPI SymGetSourceFileFromTokenW(
+  HANDLE hProcess,
+  PVOID Token,
+  PCWSTR Params,
+  PWSTR FilePath,
+  DWORD Size
+);
+
+WINBOOL WINAPI SymGetSourceFileToken(
+  HANDLE hProcess,
+  ULONG64 Base,
+  PCSTR FileSpec,
+  PVOID *Token,
+  DWORD *Size
+);
+
+WINBOOL WINAPI SymGetSourceFileTokenW(
+  HANDLE hProcess,
+  ULONG64 Base,
+  PCWSTR FileSpec,
+  PVOID *Token,
+  DWORD *Size
+);
+
+WINBOOL WINAPI SymGetSourceFile(
+  HANDLE hProcess,
+  ULONG64 Base,
+  PCSTR Params,
+  PCSTR FileSpec,
+  PSTR FilePath,
+  DWORD Size
+);
+
+WINBOOL WINAPI SymGetSourceFileW(
+  HANDLE hProcess,
+  ULONG64 Base,
+  PCWSTR Params,
+  PCWSTR FileSpec,
+  PWSTR FilePath,
+  DWORD Size
+);
+
+WINBOOL WINAPI SymGetSourceVarFromToken(
+  HANDLE hProcess,
+  PVOID Token,
+  PCSTR Params,
+  PCSTR VarName,
+  PSTR Value,
+  DWORD Size
+);
+
+WINBOOL WINAPI SymGetSourceVarFromTokenW(
+  HANDLE hProcess,
+  PVOID Token,
+  PCWSTR Params,
+  PCWSTR VarName,
+  PWSTR Value,
+  DWORD Size
+);
+
+WINBOOL WINAPI SymGetSymbolFile(
+  HANDLE hProcess,
+  PCSTR SymPath,
+  PCSTR ImageFile,
+  DWORD Type,
+  PSTR SymbolFile,
+  size_t cSymbolFile,
+  PSTR DbgFile,
+  size_t cDbgFile
+);
+
+WINBOOL WINAPI SymGetSymbolFileW(
+  HANDLE hProcess,
+  PCWSTR SymPath,
+  PCWSTR ImageFile,
+  DWORD Type,
+  PWSTR SymbolFile,
+  size_t cSymbolFile,
+  PWSTR DbgFile,
+  size_t cDbgFile
+);
+
+WINBOOL WINAPI SymNext(
+  HANDLE hProcess,
+  PSYMBOL_INFO Symbol
+);
+
+WINBOOL WINAPI SymNextW(
+  HANDLE hProcess,
+  PSYMBOL_INFOW Symbol
+);
+
+WINBOOL WINAPI SymPrev(
+  HANDLE hProcess,
+  PSYMBOL_INFO Symbol
+);
+
+WINBOOL WINAPI SymPrevW(
+  HANDLE hProcess,
+  PSYMBOL_INFOW Symbol
+);
+
+WINBOOL WINAPI SymRefreshModuleList(
+  HANDLE hProcess
+);
+
+#define SYMSEARCH_MASKOBJS 0x01
+#define SYMSEARCH_RECURSE 0x02
+#define SYMSEARCH_GLOBALSONLY 0x04
+#define SYMSEARCH_ALLITEMS 0x08
+
+WINBOOL WINAPI SymSearch(
+  HANDLE hProcess,
+  ULONG64 BaseOfDll,
+  DWORD Index,
+  DWORD SymTag,
+  PCSTR Mask,
+  DWORD64 Address,
+  PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback,
+  PVOID UserContext,
+  DWORD Options
+);
+
+WINBOOL WINAPI SymSearchW(
+  HANDLE hProcess,
+  ULONG64 BaseOfDll,
+  DWORD Index,
+  DWORD SymTag,
+  PCWSTR Mask,
+  DWORD64 Address,
+  PSYM_ENUMERATESYMBOLS_CALLBACKW EnumSymbolsCallback,
+  PVOID UserContext,
+  DWORD Options
+);
+
+WINBOOL WINAPI SymSrvGetFileIndexString(
+  HANDLE hProcess,
+  PCSTR SrvPath,
+  PCSTR File,
+  PSTR Index,
+  size_t Size,
+  DWORD Flags
+);
+
+WINBOOL WINAPI SymSrvGetFileIndexStringW(
+  HANDLE hProcess,
+  PCWSTR SrvPath,
+  PCWSTR File,
+  PWSTR Index,
+  size_t Size,
+  DWORD Flags
+);
+
+WINBOOL WINAPI SymSrvGetFileIndexInfo(
+  PCSTR File,
+  PSYMSRV_INDEX_INFO Info,
+  DWORD Flags
+);
+
+WINBOOL WINAPI SymSrvGetFileIndexInfoW(
+  PCWSTR File,
+  PSYMSRV_INDEX_INFOW Info,
+  DWORD Flags
+);
+
+WINBOOL WINAPI SymSrvGetFileIndexes(
+  PCTSTR File,
+  GUID *Id,
+  DWORD *Val1,
+  DWORD *Val2,
+  DWORD Flags
+);
+
+WINBOOL WINAPI SymSrvGetFileIndexesW(
+  PCWSTR File,
+  GUID *Id,
+  DWORD *Val1,
+  DWORD *Val2,
+  DWORD Flags
+);
+
+PCSTR WINAPI SymSrvGetSupplement(
+  HANDLE hProcess,
+  PCSTR SymPath,
+  PCSTR Node,
+  PCSTR File
+);
+
+PCWSTR WINAPI SymSrvGetSupplementW(
+  HANDLE hProcess,
+  PCWSTR SymPath,
+  PCWSTR Node,
+  PCWSTR File
+);
+
+WINBOOL WINAPI SymSrvIsStore(
+  HANDLE hProcess,
+  PCSTR path
+);
+
+WINBOOL WINAPI SymSrvIsStoreW(
+  HANDLE hProcess,
+  PCWSTR path
+);
+
+PCSTR WINAPI SymSrvStoreFile(
+  HANDLE hProcess,
+  PCSTR SrvPath,
+  PCSTR File,
+  DWORD Flags
+);
+
+PCWSTR WINAPI SymSrvStoreFileW(
+  HANDLE hProcess,
+  PCWSTR SrvPath,
+  PCWSTR File,
+  DWORD Flags
+);
+
+#define SYMSTOREOPT_COMPRESS 0x01
+#define SYMSTOREOPT_OVERWRITE 0x02
+#define SYMSTOREOPT_RETURNINDEX 0x04
+#define SYMSTOREOPT_POINTER 0x08
+#define SYMSTOREOPT_PASS_IF_EXISTS 0x40
+
+PCSTR WINAPI SymSrvStoreSupplement(
+  HANDLE hProcess,
+  const PCTSTR SymPath,
+  PCSTR Node,
+  PCSTR File,
+  DWORD Flags
+);
+
+PCWSTR WINAPI SymSrvStoreSupplementW(
+  HANDLE hProcess,
+  const PCWSTR SymPath,
+  PCWSTR Node,
+  PCWSTR File,
+  DWORD Flags
+);
+
+PCSTR WINAPI SymSrvDeltaName(
+  HANDLE hProcess,
+  PCSTR SymPath,
+  PCSTR Type,
+  PCSTR File1,
+  PCSTR File2
+);
+
+PCWSTR WINAPI SymSrvDeltaNameW(
+  HANDLE hProcess,
+  PCWSTR SymPath,
+  PCWSTR Type,
+  PCWSTR File1,
+  PCWSTR File2
+);
+
+#ifdef DBGHELP_TRANSLATE_TCHAR
+#define SymInitialize SymInitializeW
+#define SymAddSymbol SymAddSymbolW
+#define SymDeleteSymbol SymDeleteSymbolW
+#define SearchTreeForFile SearchTreeForFileW
+#define UnDecorateSymbolName UnDecorateSymbolNameW
+#define SymGetLineFromName64 SymGetLineFromNameW64
+#define SymGetLineFromAddr64 SymGetLineFromAddrW64
+#define SymGetLineFromInlineContext SymGetLineFromInlineContextW
+#define SymGetLineNext64 SymGetLineNextW64
+#define SymGetLinePrev64 SymGetLinePrevW64
+#define SymFromName SymFromNameW
+#define SymFindExecutableImage SymFindExecutableImageW
+#define FindExecutableImageEx FindExecutableImageExW
+#define SymSearch SymSearchW
+#define SymEnumLines SymEnumLinesW
+#define SymEnumSourceLines SymEnumSourceLinesW
+#define SymGetTypeFromName SymGetTypeFromNameW
+#define SymEnumSymbolsForAddr SymEnumSymbolsForAddrW
+#define SymFromAddr SymFromAddrW
+#define SymFromInlineContext SymFromInlineContextW
+#define SymMatchString SymMatchStringW
+#define SymEnumSourceFiles SymEnumSourceFilesW
+#define SymEnumSymbols SymEnumSymbolsW
+#define SymEnumSymbolsEx SymEnumSymbolsExW
+#define SymLoadModuleEx SymLoadModuleExW
+#define SymSetSearchPath SymSetSearchPathW
+#define SymGetSearchPath SymGetSearchPathW
+#define EnumDirTree EnumDirTreeW
+#define SymFromToken SymFromTokenW
+#define SymFromIndex SymFromIndexW
+#define SymGetScope SymGetScopeW
+#define SymNext SymNextW
+#define SymPrev SymPrevW
+#define SymEnumTypes SymEnumTypesW
+#define SymEnumTypesByName SymEnumTypesByNameW
+#define SymRegisterCallback64 SymRegisterCallbackW64
+#define SymFindDebugInfoFile SymFindDebugInfoFileW
+#define FindDebugInfoFileEx FindDebugInfoFileExW
+#define SymFindFileInPath SymFindFileInPathW
+#define SymEnumerateModules64 SymEnumerateModulesW64
+#define SymSetHomeDirectory SymSetHomeDirectoryW
+#define SymGetHomeDirectory SymGetHomeDirectoryW
+#define SymGetSourceFile SymGetSourceFileW
+#define SymGetSourceFileToken SymGetSourceFileTokenW
+#define SymGetSourceFileFromToken SymGetSourceFileFromTokenW
+#define SymGetSourceVarFromToken SymGetSourceVarFromTokenW
+#define SymGetSourceFileTokenByTokenName SymGetSourceFileTokenByTokenNameW
+#define SymGetFileLineOffsets64 SymGetFileLineOffsetsW64
+#define SymFindFileInPath SymFindFileInPathW
+#define SymMatchFileName SymMatchFileNameW
+#define SymGetSourceFileFromTokenByTokenName SymGetSourceFileFromTokenByTokenNameW
+#define SymGetModuleInfo64 SymGetModuleInfoW64
+#define SymAddSourceStream SymAddSourceStreamW
+#define SymSrvIsStore SymSrvIsStoreW
+#define SymSrvDeltaName SymSrvDeltaNameW
+#define SymSrvGetSupplement SymSrvGetSupplementW
+#define SymSrvStoreSupplement SymSrvStoreSupplementW
+#define SymSrvGetFileIndexes SymSrvGetFileIndexesW
+#define SymSrvGetFileIndexString SymSrvGetFileIndexStringW
+#define SymSrvStoreFile SymSrvStoreFileW
+#define SymGetSymbolFile SymGetSymbolFileW
+#define EnumerateLoadedModules64 EnumerateLoadedModulesW64
+#define EnumerateLoadedModulesEx EnumerateLoadedModulesExW
+#define SymSrvGetFileIndexInfo SymSrvGetFileIndexInfoW
+
+#define IMAGEHLP_LINE64 IMAGEHLP_LINEW64
+#define PIMAGEHLP_LINE64 PIMAGEHLP_LINEW64
+#define SYMBOL_INFO SYMBOL_INFOW
+#define PSYMBOL_INFO PSYMBOL_INFOW
+#define SYMBOL_INFO_PACKAGE SYMBOL_INFO_PACKAGEW
+#define PSYMBOL_INFO_PACKAGE PSYMBOL_INFO_PACKAGEW
+#define FIND_EXE_FILE_CALLBACK FIND_EXE_FILE_CALLBACKW
+#define PFIND_EXE_FILE_CALLBACK PFIND_EXE_FILE_CALLBACKW
+#define SYM_ENUMERATESYMBOLS_CALLBACK SYM_ENUMERATESYMBOLS_CALLBACKW
+#define PSYM_ENUMERATESYMBOLS_CALLBACK PSYM_ENUMERATESYMBOLS_CALLBACKW
+#define SRCCODEINFO SRCCODEINFOW
+#define PSRCCODEINFO PSRCCODEINFOW
+#define SOURCEFILE SOURCEFILEW
+#define PSOURCEFILE PSOURCEFILEW
+#define SYM_ENUMSOURECFILES_CALLBACK SYM_ENUMSOURCEFILES_CALLBACKW
+#define PSYM_ENUMSOURCEFILES_CALLBACK PSYM_ENUMSOURECFILES_CALLBACKW
+#define IMAGEHLP_CBA_EVENT IMAGEHLP_CBA_EVENTW
+#define PIMAGEHLP_CBA_EVENT PIMAGEHLP_CBA_EVENTW
+#define PENUMDIRTREE_CALLBACK PENUMDIRTREE_CALLBACKW
+#define IMAGEHLP_DEFERRED_SYMBOL_LOAD64 IMAGEHLP_DEFERRED_SYMBOL_LOADW64
+#define PIMAGEHLP_DEFERRED_SYMBOL_LOAD64 PIMAGEHLP_DEFERRED_SYMBOL_LOADW64
+#define PFIND_DEBUG_FILE_CALLBACK PFIND_DEBUG_FILE_CALLBACKW
+#define PFINDFILEINPATHCALLBACK PFINDFILEINPATHCALLBACKW
+#define IMAGEHLP_MODULE64 IMAGEHLP_MODULEW64
+#define PIMAGEHLP_MODULE64 PIMAGEHLP_MODULEW64
+#define SYMSRV_INDEX_INFO SYMSRV_INDEX_INFOW
+#define PSYMSRV_INDEX_INFO PSYMSRV_INDEX_INFOW
+
+#define PSYMBOLSERVERPROC PSYMBOLSERVERPROCW
+#define PSYMBOLSERVERPINGPROC PSYMBOLSERVERPINGPROCW
+
+#endif /* DBGHELP_TRANSLATE_TCHAR */
+
+#include <poppack.h>
+
+#ifdef __cplusplus
+}
+#endif
+
diff --git a/include/pshpack4.h b/include/pshpack4.h
new file mode 100644
index 0000000..59fdbbc
--- /dev/null
+++ b/include/pshpack4.h
@@ -0,0 +1,8 @@
+/**
+ * This file has no copyright assigned and is placed in the Public Domain.
+ * This file is part of the mingw-w64 runtime package.
+ * No warranty is given; refer to the file DISCLAIMER.PD within this package.
+ */
+#if !(defined(lint) || defined(RC_INVOKED))
+#pragma pack(push,4)
+#endif