Merge pull request #2647 from dotnet-bot/from-tfs

Merge changes from TFS

25 files changed, 17430 insertions, 8 deletions

diff --git a/src/ToolBox/PdbTypeMatch/.gitmirror b/src/ToolBox/PdbTypeMatch/.gitmirror
new file mode 100644
index 0000000000..f507630f94
--- /dev/null
+++ b/src/ToolBox/PdbTypeMatch/.gitmirror
@@ -0,0 +1 @@
+Only contents of this folder, excluding subfolders, will be mirrored by the Git-TFS Mirror. 
\ No newline at end of file
diff --git a/src/ToolBox/PdbTypeMatch/PdbTypeMatch.cpp b/src/ToolBox/PdbTypeMatch/PdbTypeMatch.cpp
new file mode 100644
index 0000000000..74090f8590
--- /dev/null
+++ b/src/ToolBox/PdbTypeMatch/PdbTypeMatch.cpp
@@ -0,0 +1,2022 @@
+//
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+
+#include "stdafx.h"
+#include "PdbTypeMatch.h"
+#include "PrintSymbol.h"
+
+#include "Callback.h"
+
+#include <fstream>
+#include <iostream>
+#include <sstream>
+#include <sys/stat.h>
+#include <algorithm>
+#include "Shlwapi.h"
+
+#define DEBUG_VERBOSE 0
+
+#pragma warning (disable : 4100)
+
+const wchar_t *g_szFilename1, *g_szFilename2;
+IDiaDataSource *g_pDiaDataSource1, *g_pDiaDataSource2;
+IDiaSession *g_pDiaSession1, *g_pDiaSession2;
+IDiaSymbol *g_pGlobalSymbol1, *g_pGlobalSymbol2;
+DWORD g_dwMachineType = CV_CFL_80386;
+IDiaSymbolSet g_excludedTypes;
+IDiaSymbolSet g_excludedTypePatterns;
+
+////////////////////////////////////////////////////////////
+//
+int __cdecl wmain(int argc, wchar_t *argv[])
+{
+  FILE *pFile;
+
+  if (argc < 3) {
+    PrintHelpOptions();
+    return -1;
+  }
+
+  if (!_wcsicmp(argv[1], L"-type")) {
+    
+    // -type <symbolname> <pdbfilename>: dump this type in detail
+    
+    if (argc < 4) {
+      PrintHelpOptions();
+      return -1;
+    }
+    
+    if ((argc > 1) && (*argv[2] != L'-')) {
+    
+        if (_wfopen_s(&pFile, argv[3], L"r") || !pFile) {
+        // invalid file name or file does not exist
+    
+        PrintHelpOptions();
+        return -1;
+      }
+      fclose(pFile);
+      // CoCreate() and initialize COM objects
+      if (!InitDiaSource(&g_pDiaDataSource1))
+      {
+          return -1;
+      }
+      if (!LoadDataFromPdb(argv[3], g_pDiaDataSource1, &g_pDiaSession1, &g_pGlobalSymbol1)) {
+        return -1;
+      }
+  
+      DumpType(g_pGlobalSymbol1, argv[2]);
+      
+      // release COM objects and CoUninitialize()
+      Cleanup();
+      
+      return 0;
+    }
+  }
+
+  if (argc < 3) {
+    PrintHelpOptions();
+    return -1;
+  }
+  
+  if (_wfopen_s(&pFile, argv[1], L"r") || !pFile) {
+    // invalid file name or file does not exist
+
+    PrintHelpOptions();
+    return -1;
+  }
+
+  fclose(pFile);
+
+  if (_wfopen_s(&pFile, argv[2], L"r") || !pFile) {
+    // invalid file name or file does not exist
+
+    PrintHelpOptions();
+    return -1;
+  }
+
+  fclose(pFile);
+
+  g_szFilename1 = argv[1];
+
+  // CoCreate() and initialize COM objects
+  if (!InitDiaSource(&g_pDiaDataSource1))
+  {
+      return -1;
+  }
+  if (!LoadDataFromPdb(g_szFilename1, g_pDiaDataSource1, &g_pDiaSession1, &g_pGlobalSymbol1)) {
+    return -1;
+  }
+
+  g_szFilename2 = argv[2];
+
+  InitDiaSource(&g_pDiaDataSource2);
+  if (!LoadDataFromPdb(g_szFilename2, g_pDiaDataSource2, &g_pDiaSession2, &g_pGlobalSymbol2)) {
+    return -1;
+  }
+  
+  // Read exclusion list.
+  struct stat fileStatus;  
+  if (stat(UnicodeToAnsi(argv[3]), &fileStatus) != 0)
+  {
+    wprintf(L"Could not open type_exclusion_list file!\n"); 
+    return -1;
+  }
+ 
+  char linec[2048];  
+  FILE *file = fopen(UnicodeToAnsi(argv[3]), "r");
+  while (fgets (linec, sizeof(linec), file) != NULL)
+  {
+      std::string line(linec);
+      line.erase(std::remove_if(line.begin(), line.end(), isspace), line.end());
+      if (line.empty() || line.length() <= 1)
+      {
+          continue;
+      }
+      if (line.front() == '#') continue;
+      int len;
+      int slength = (int)line.length() + 1;
+      len = MultiByteToWideChar(CP_ACP, 0, line.c_str(), slength, 0, 0); 
+      wchar_t* buf = new wchar_t[len];
+      MultiByteToWideChar(CP_ACP, 0, line.c_str(), slength, buf, len);
+      std::wstring wLine(buf);
+      delete[] buf;
+      
+      /// Add *str in the patterns list.
+      if (line.front() == '*') 
+      {
+          g_excludedTypePatterns.insert((std::wstring)(wLine.substr(1, wLine.size()-1)));    
+      }
+      else
+      {
+          g_excludedTypes.insert((std::wstring)(wLine));
+      }         
+  } 
+  fclose(file);
+  
+  IDiaSymbolSet types1;
+  IDiaSymbolSet types2;
+  if (!EnumTypesInPdb(&types1, g_pDiaSession1, g_pGlobalSymbol1))
+  {
+      return -1;
+  }
+
+  if (!EnumTypesInPdb(&types2, g_pDiaSession2, g_pGlobalSymbol2))
+  {
+      return -1;
+  }
+
+  IDiaSymbolSet commonTypes;
+
+  // Intersect types
+  for (IDiaSymbolSet::iterator i = types1.begin(); i != types1.end(); i++)
+  {
+      std::wstring typeName = *i;
+
+      /// Skip excluded types
+      if (g_excludedTypes.find(typeName) != g_excludedTypes.end())
+      {
+          continue;
+      }
+      bool skipType = false;
+      /// Skip if includes one pattern string.
+      for (IDiaSymbolSet::iterator j = g_excludedTypePatterns.begin(); j != g_excludedTypePatterns.end(); j++)
+      {
+           std::wstring patternStr = *j;
+           if (wcsstr(typeName.c_str(), patternStr.c_str()) != NULL)
+           {
+              skipType = true;
+              break;
+           }
+      }
+      
+      if (skipType) continue;
+      
+      if (types2.find(typeName) != types2.end())
+      {
+          commonTypes.insert(typeName);
+      }
+  }
+
+  bool matchedSymbols = true;
+  ULONG failuresNb = 0;
+      
+  
+  // Compare layout for common types
+  for (IDiaSymbolSet::iterator i = commonTypes.begin(); i != commonTypes.end(); i++)
+  {
+      std::wstring typeName = *i;
+
+      IDiaEnumSymbols *pEnumSymbols1;
+      BSTR pwstrTypeName = SysAllocString(typeName.c_str());
+      if (FAILED(g_pGlobalSymbol1->findChildren(SymTagUDT, pwstrTypeName, nsNone, &pEnumSymbols1))) {
+        SysFreeString(pwstrTypeName);
+        return false;
+      }
+
+      IDiaEnumSymbols *pEnumSymbols2;
+      if (FAILED(g_pGlobalSymbol2->findChildren(SymTagUDT, pwstrTypeName, nsNone, &pEnumSymbols2))) {
+        SysFreeString(pwstrTypeName);
+        return false;
+      }
+      
+      IDiaSymbol *pSymbol1;
+      IDiaSymbol *pSymbol2;
+      ULONG celt = 0;      
+
+      
+      while (SUCCEEDED(pEnumSymbols1->Next(1, &pSymbol1, &celt)) && (celt == 1)) {
+        if (SUCCEEDED(pEnumSymbols2->Next(1, &pSymbol2, &celt)) && (celt == 1))
+        {   
+           
+            BSTR bstrSymbol1Name;
+            if (pSymbol1->get_name(&bstrSymbol1Name) != S_OK) 
+            {   
+                bstrSymbol1Name = NULL; 
+                pSymbol2->Release();
+                continue;               
+            }              
+            BSTR bstrSymbol2Name;
+            if (pSymbol2->get_name(&bstrSymbol2Name) != S_OK) 
+            {
+                bstrSymbol2Name = NULL;
+                pSymbol2->Release();
+                continue;                           
+            }            
+            if (_wcsicmp(bstrSymbol1Name, bstrSymbol2Name) != 0)
+            {
+                pSymbol2->Release();
+                continue;                
+            }
+            ULONGLONG sym1Size;
+            ULONGLONG sym2Size;
+            if (pSymbol1->get_length(&sym1Size) != S_OK)
+            {
+               wprintf(L"ERROR - can't retrieve the symbol's length\n");           
+               pSymbol2->Release();
+               continue;
+            } 
+            //wprintf(L"sym1Size = %x\n", sym1Size);
+            if (pSymbol2->get_length(&sym2Size) != S_OK)
+            {
+               wprintf(L"ERROR - can't retrieve the symbol's length\n");           
+               pSymbol2->Release();
+               continue;
+            }            
+            //wprintf(L"sym2Size = %x\n", sym2Size);
+            if (sym1Size == 0 || sym2Size == 2)
+            {
+                pSymbol2->Release();
+                continue;
+            }
+            
+            if (!LayoutMatches(pSymbol1, pSymbol2))
+            {
+                wprintf(L"Type \"%s\" is not matching in %s and %s\n", pwstrTypeName, g_szFilename1, g_szFilename2);                
+                pSymbol2->Release();
+
+                matchedSymbols = false;
+                failuresNb++;
+                // Continue to compare and report all inconsistencies.               
+                continue;
+            }
+            else
+            {
+#if	DEBUG_VERBOSE
+                wprintf(L"Matched type: %s\n", pwstrTypeName);
+#endif
+            }
+            
+            pSymbol2->Release();
+        }
+
+        pSymbol1->Release();
+      }
+      
+      SysFreeString(pwstrTypeName);
+      pEnumSymbols1->Release();
+      pEnumSymbols2->Release();
+  }
+  
+  // release COM objects and CoUninitialize()
+  Cleanup();
+  
+  if (matchedSymbols)
+  {
+      wprintf(L"OK: All %d common types of %s and %s match!\n", commonTypes.size(), g_szFilename1, g_szFilename2);
+      return 0;
+  }
+  else
+  {
+      wprintf(L"FAIL: Failed to match %d common types of %s and %s!\n", failuresNb, g_szFilename1, g_szFilename2);
+      wprintf(L"Matched %d common types!\n", commonTypes.size() - failuresNb);
+      return -1;
+  }
+}
+
+LPSTR UnicodeToAnsi(LPCWSTR s)
+{
+    if (s==NULL) return NULL;
+    int cw=lstrlenW(s);
+    if (cw==0) 
+    {
+        CHAR *psz=new CHAR[1];*psz='\0';return psz;
+    }
+    int cc=WideCharToMultiByte(CP_ACP,0,s,cw,NULL,0,NULL,NULL);
+    if (cc==0) return NULL;
+    CHAR *psz=new CHAR[cc+1];
+    cc=WideCharToMultiByte(CP_ACP,0,s,cw,psz,cc,NULL,NULL);
+    if (cc==0) {delete[] psz;return NULL;}
+    psz[cc]='\0';
+    return psz;
+}
+
+
+bool InitDiaSource(IDiaDataSource  **ppSource)
+{
+    HRESULT hr = CoInitialize(NULL);
+
+    // Obtain access to the provider
+
+    hr = CoCreateInstance(__uuidof(DiaSource),
+                        NULL,
+                        CLSCTX_INPROC_SERVER,
+                        __uuidof(IDiaDataSource),
+                        (void **) ppSource);
+
+	if (FAILED(hr)) {
+		   ACTCTX actCtx;
+       memset((void*)&actCtx, 0, sizeof(ACTCTX));
+       actCtx.cbSize = sizeof(ACTCTX);
+       CHAR   dllPath[MAX_PATH*2];
+       GetModuleFileName(NULL, dllPath, _countof(dllPath));
+       PathRemoveFileSpec(dllPath);
+       strcat(dllPath, "\\msdia100.sxs.manifest");
+       actCtx.lpSource = dllPath;
+    
+       HANDLE hCtx = ::CreateActCtx(&actCtx);
+       if (hCtx == INVALID_HANDLE_VALUE)
+          wprintf(L"CreateActCtx returned: INVALID_HANDLE_VALUE\n");                 
+       else
+       {
+          ULONG_PTR cookie;
+          if (::ActivateActCtx(hCtx, &cookie))
+          {
+             hr = CoCreateInstance(__uuidof(DiaSource),
+                        NULL,
+                        CLSCTX_INPROC_SERVER,
+                        __uuidof(IDiaDataSource),
+                        (void **) ppSource);
+             ::DeactivateActCtx(0, cookie);
+                 if (FAILED(hr)) {
+		          wprintf(L"CoCreateInstance failed - HRESULT = %08X\n", hr);
+		          return false;
+              }
+          }
+       }
+	  }
+    if (FAILED(hr)) {
+		wprintf(L"CoCreateInstance failed - HRESULT = %08X\n", hr);
+
+		return false;
+    }
+
+    return true;
+}
+
+////////////////////////////////////////////////////////////
+// Create an IDiaData source and open a PDB file
+//
+bool LoadDataFromPdb(
+    const wchar_t    *szFilename,
+    IDiaDataSource  *ppSource,
+    IDiaSession     **ppSession,
+    IDiaSymbol      **ppGlobal)
+{
+  wchar_t wszExt[MAX_PATH];
+  wchar_t *wszSearchPath = L"SRV**\\\\symbols\\symbols"; // Alternate path to search for debug data
+  DWORD dwMachType = 0;
+  HRESULT hr;
+
+  _wsplitpath_s(szFilename, NULL, 0, NULL, 0, NULL, 0, wszExt, MAX_PATH);
+
+  if (!_wcsicmp(wszExt, L".pdb")) {
+    // Open and prepare a program database (.pdb) file as a debug data source
+
+    hr = (ppSource)->loadDataFromPdb(szFilename);
+
+    if (FAILED(hr)) {
+      wprintf(L"loadDataFromPdb failed - HRESULT = %08X\n", hr);
+
+      return false;
+    }
+  }
+
+  else {
+    CCallback callback; // Receives callbacks from the DIA symbol locating procedure,
+                        // thus enabling a user interface to report on the progress of
+                        // the location attempt. The client application may optionally
+                        // provide a reference to its own implementation of this
+                        // virtual base class to the IDiaDataSource::loadDataForExe method.
+    callback.AddRef();
+
+    // Open and prepare the debug data associated with the executable
+
+    hr = (ppSource)->loadDataForExe(szFilename, wszSearchPath, &callback);
+
+    if (FAILED(hr)) {
+      wprintf(L"loadDataForExe failed - HRESULT = %08X\n", hr);
+
+      return false;
+    }
+  }
+
+  // Open a session for querying symbols
+
+  hr = (ppSource)->openSession(ppSession);
+
+  if (FAILED(hr)) {
+    wprintf(L"openSession failed - HRESULT = %08X\n", hr);
+
+    return false;
+  }
+
+  // Retrieve a reference to the global scope
+
+  hr = (*ppSession)->get_globalScope(ppGlobal);
+
+  if (hr != S_OK) {
+    wprintf(L"get_globalScope failed\n");
+
+    return false;
+  }
+
+  // Set Machine type for getting correct register names
+
+  if ((*ppGlobal)->get_machineType(&dwMachType) == S_OK) {
+    switch (dwMachType) {
+      case IMAGE_FILE_MACHINE_I386 : g_dwMachineType = CV_CFL_80386; break;
+      case IMAGE_FILE_MACHINE_IA64 : g_dwMachineType = CV_CFL_IA64; break;
+      case IMAGE_FILE_MACHINE_AMD64 : g_dwMachineType = CV_CFL_AMD64; break;
+    }
+  }
+
+  return true;
+}
+
+bool LayoutMatches(IDiaSymbol* pSymbol1, IDiaSymbol* pSymbol2)
+{
+    DWORD dwTag1, dwTag2;
+    DWORD dwLocType1, dwLocType2;
+    LONG lOffset1, lOffset2;
+
+    if (pSymbol1->get_symTag(&dwTag1) != S_OK) 
+    {
+        wprintf(L"ERROR - can't retrieve the symbol's SymTag\n");
+        return false;
+   }
+   if (pSymbol2->get_symTag(&dwTag2) != S_OK) 
+   {
+        wprintf(L"ERROR - can't retrieve the symbol's SymTag\n");
+        return false;
+   }
+
+   if (dwTag1 == SymTagUDT)
+   {
+       if (dwTag2 != SymTagUDT)
+       {
+           
+            wprintf(L"ERROR - symbols don't match\n");
+            wprintf(L"Symbol 1:\n");
+            PrintTypeInDetail(pSymbol1, 0);
+            wprintf(L"Symbol 2:\n");
+            PrintTypeInDetail(pSymbol2, 0);
+            return false;
+       }
+
+       // First check that types size match
+       ULONGLONG sym1Size;
+       ULONGLONG sym2Size;
+       if (pSymbol1->get_length(&sym1Size) != S_OK)
+       {
+           wprintf(L"ERROR - can't retrieve the symbol's length\n");           
+           return false;  
+       } 
+       if (pSymbol2->get_length(&sym2Size) != S_OK)
+       {
+           wprintf(L"ERROR - can't retrieve the symbol's length\n");           
+           return false;  
+       }
+       if (sym1Size == 0 || sym2Size == 0)
+       {
+            return true;
+       } 
+       if (sym1Size != sym2Size)
+       {                
+            wprintf(L"Failed to match type size: (sizeof(sym1)=%x) != (sizeof(sym2)=%x)\n", sym1Size, sym2Size);            
+            return false;
+       }
+       IDiaEnumSymbols *pEnumChildren1, *pEnumChildren2;
+       IDiaSymbol *pChild1, *pChild2;
+       ULONG celt = 0;
+       BSTR bstrName1, bstrName2;
+       if (SUCCEEDED(pSymbol1->findChildren(SymTagNull, NULL, nsNone, &pEnumChildren1))) 
+       {
+            while (SUCCEEDED(pEnumChildren1->Next(1, &pChild1, &celt)) && (celt == 1)) 
+            {
+                if (pChild1->get_symTag(&dwTag1) != S_OK) 
+                {
+                    wprintf(L"ERROR - can't retrieve the symbol's SymTag\n");
+                    pChild1->Release();
+                    return false;
+                }
+                if (dwTag1 != SymTagData) { pChild1->Release(); continue; }
+                if (pChild1->get_locationType(&dwLocType1) != S_OK) 
+                {
+                    wprintf(L"symbol in optmized code");
+                    pChild1->Release();
+                    return false;
+                }
+                if (dwLocType1 != LocIsThisRel) { pChild1->Release(); continue; }
+                if (pChild1->get_offset(&lOffset1) != S_OK) 
+                {
+                    wprintf(L"ERROR - geting field offset\n");
+                    pChild1->Release();
+                    return false;
+                }
+                if (pChild1->get_name(&bstrName1) != S_OK) 
+                {
+                    bstrName1 = NULL;
+                }
+                /// Search in the second symbol the field at lOffset1
+                bool fieldMatched = false;
+                if  (SUCCEEDED(pSymbol2->findChildren(SymTagNull, NULL, nsNone, &pEnumChildren2)))
+                {
+                    while (SUCCEEDED(pEnumChildren2->Next(1, &pChild2, &celt)) && (celt == 1)) 
+                    {
+                        if (pChild2->get_symTag(&dwTag2) != S_OK) 
+                        {
+                            wprintf(L"ERROR - can't retrieve the symbol's SymTag\n");
+                            pChild2->Release();
+                            return false;
+                        }
+                        if (dwTag2 != SymTagData) { pChild2->Release(); continue; }
+                        if (pChild2->get_locationType(&dwLocType2) != S_OK) 
+                        {
+                            wprintf(L"symbol in optmized code");
+                            pChild2->Release();
+                            return false;
+                        }
+                        if (dwLocType2 != LocIsThisRel) { pChild2->Release(); continue; }
+                        if (pChild2->get_offset(&lOffset2) != S_OK) 
+                        {
+                            wprintf(L"ERROR - geting field offset\n");
+                            pChild2->Release();
+                            return false;
+                        }
+                        if (pChild2->get_name(&bstrName2) != S_OK) 
+                        {
+                            bstrName2 = NULL;
+                        }
+                        if (lOffset2 == lOffset1)
+                        {
+                            if (_wcsicmp(bstrName1, bstrName2) == 0
+                            || wcsstr(bstrName1, bstrName2) == bstrName1
+                            || wcsstr(bstrName2, bstrName1) == bstrName2)
+                            {
+                                //wprintf(L"Matched field %s at offset %x\n", bstrName1, lOffset2);
+                                fieldMatched = true;
+                                pChild2->Release();
+                                break;
+                            }
+                        }
+                        pChild2->Release();
+                    }
+                    pEnumChildren2->Release();
+                }
+                if (!fieldMatched)
+                {
+                    BSTR bstrSymbol1Name;
+                    if (pSymbol1->get_name(&bstrSymbol1Name) != S_OK) 
+                    {
+                        bstrSymbol1Name = NULL;
+                    }
+                    wprintf(L"Failed to match %s field %s at offset %x\n", bstrSymbol1Name, bstrName1, lOffset1);
+                    pChild1->Release();
+                    return false;
+                }
+                pChild1->Release();
+            }
+
+            pEnumChildren1->Release();
+       }
+   }
+
+   return true;
+}
+
+////////////////////////////////////////////////////////////
+// Release DIA objects and CoUninitialize
+//
+void Cleanup()
+{
+  if (g_pGlobalSymbol1) {
+    g_pGlobalSymbol1->Release();
+    g_pGlobalSymbol1 = NULL;
+  }
+
+  if (g_pGlobalSymbol2) {
+    g_pGlobalSymbol2->Release();
+    g_pGlobalSymbol2 = NULL;
+  }
+
+  if (g_pDiaSession1) {
+    g_pDiaSession1->Release();
+    g_pDiaSession1 = NULL;
+  }
+
+  if (g_pDiaSession2) {
+    g_pDiaSession2->Release();
+    g_pDiaSession2 = NULL;
+  }
+
+  CoUninitialize();
+}
+
+
+////////////////////////////////////////////////////////////
+// Display the usage
+//
+void PrintHelpOptions()
+{
+  static const wchar_t * const helpString = L"usage: PdbTypeMatch.exe <pdb_filename_1> <pdb_filename_2> <type_exclusion_list_file> : compare all common types by size and fields\n"
+                                            L"       PdbTypeMatch.exe -type <symbolname>  <pdb_filename_1>: dump this type in detail\n";
+                                            
+  wprintf(helpString);
+}
+
+bool EnumTypesInPdb(IDiaSymbolSet* types, IDiaSession *pSession, IDiaSymbol *pGlobal)
+{
+    IDiaEnumSymbols *pEnumSymbols;
+
+    if (FAILED(pGlobal->findChildren(SymTagUDT, NULL, nsNone, &pEnumSymbols))) 
+    {
+        wprintf(L"ERROR - EnumTypesInPdb() returned no symbols\n");
+
+        return false;
+    }
+
+    IDiaSymbol *pSymbol;
+    ULONG celt = 0;
+
+    while (SUCCEEDED(pEnumSymbols->Next(1, &pSymbol, &celt)) && (celt == 1)) 
+    {
+        std::wstring typeName;
+        GetSymbolName(typeName, pSymbol);
+        types->insert(std::wstring(typeName));
+        pSymbol->Release();
+    }
+
+    pEnumSymbols->Release();
+
+    return true;
+}
+
+////////////////////////////////////////////////////////////
+// Dump all the data stored in a PDB
+//
+void DumpAllPdbInfo(IDiaSession *pSession, IDiaSymbol *pGlobal)
+{
+  DumpAllMods(pGlobal);
+  DumpAllPublics(pGlobal);
+  DumpAllSymbols(pGlobal);
+  DumpAllGlobals(pGlobal);
+  DumpAllTypes(pGlobal);
+  DumpAllFiles(pSession, pGlobal);
+  DumpAllLines(pSession, pGlobal);
+  DumpAllSecContribs(pSession);
+  DumpAllDebugStreams(pSession);
+  DumpAllInjectedSources(pSession);
+  DumpAllFPO(pSession);
+  DumpAllOEMs(pGlobal);
+}
+
+////////////////////////////////////////////////////////////
+// Dump all the modules information
+//
+bool DumpAllMods(IDiaSymbol *pGlobal)
+{
+  wprintf(L"\n\n*** MODULES\n\n");
+
+  // Retrieve all the compiland symbols
+
+  IDiaEnumSymbols *pEnumSymbols;
+
+  if (FAILED(pGlobal->findChildren(SymTagCompiland, NULL, nsNone, &pEnumSymbols))) {
+    return false;
+  }
+
+  IDiaSymbol *pCompiland;
+  ULONG celt = 0;
+  ULONG iMod = 1;
+
+  while (SUCCEEDED(pEnumSymbols->Next(1, &pCompiland, &celt)) && (celt == 1)) {
+    BSTR bstrName;
+
+    if (pCompiland->get_name(&bstrName) != S_OK) {
+      wprintf(L"ERROR - Failed to get the compiland's name\n");
+
+      pCompiland->Release();
+      pEnumSymbols->Release();
+
+      return false;
+    }
+
+    wprintf(L"%04X %s\n", iMod++, bstrName);
+
+    // Deallocate the string allocated previously by the call to get_name
+
+    SysFreeString(bstrName);
+
+    pCompiland->Release();
+  }
+
+  pEnumSymbols->Release();
+
+  putwchar(L'\n');
+
+  return true;
+}
+
+////////////////////////////////////////////////////////////
+// Dump all the public symbols - SymTagPublicSymbol
+//
+bool DumpAllPublics(IDiaSymbol *pGlobal)
+{
+  wprintf(L"\n\n*** PUBLICS\n\n");
+
+  // Retrieve all the public symbols
+
+  IDiaEnumSymbols *pEnumSymbols;
+
+  if (FAILED(pGlobal->findChildren(SymTagPublicSymbol, NULL, nsNone, &pEnumSymbols))) {
+    return false;
+  }
+
+  IDiaSymbol *pSymbol;
+  ULONG celt = 0;
+
+  while (SUCCEEDED(pEnumSymbols->Next(1, &pSymbol, &celt)) && (celt == 1)) {
+    PrintPublicSymbol(pSymbol);
+
+    pSymbol->Release();
+  }
+
+  pEnumSymbols->Release();
+
+  putwchar(L'\n');
+
+  return true;
+}
+
+////////////////////////////////////////////////////////////
+// Dump all the symbol information stored in the compilands
+//
+bool DumpAllSymbols(IDiaSymbol *pGlobal)
+{
+  wprintf(L"\n\n*** SYMBOLS\n\n\n");
+
+  // Retrieve the compilands first
+
+  IDiaEnumSymbols *pEnumSymbols;
+
+  if (FAILED(pGlobal->findChildren(SymTagCompiland, NULL, nsNone, &pEnumSymbols))) {
+    return false;
+  }
+
+  IDiaSymbol *pCompiland;
+  ULONG celt = 0;
+
+  while (SUCCEEDED(pEnumSymbols->Next(1, &pCompiland, &celt)) && (celt == 1)) {
+    wprintf(L"\n** Module: ");
+
+    // Retrieve the name of the module
+
+    BSTR bstrName;
+
+    if (pCompiland->get_name(&bstrName) != S_OK) {
+      wprintf(L"(???)\n\n");
+    }
+
+    else {
+      wprintf(L"%s\n\n", bstrName);
+
+      SysFreeString(bstrName);
+    }
+
+    // Find all the symbols defined in this compiland and print their info
+
+    IDiaEnumSymbols *pEnumChildren;
+
+    if (SUCCEEDED(pCompiland->findChildren(SymTagNull, NULL, nsNone, &pEnumChildren))) {
+      IDiaSymbol *pSymbol;
+      ULONG celtChildren = 0;
+
+      while (SUCCEEDED(pEnumChildren->Next(1, &pSymbol, &celtChildren)) && (celtChildren == 1)) {
+        PrintSymbol(pSymbol, 0);
+        pSymbol->Release();
+      }
+
+      pEnumChildren->Release();
+    }
+
+    pCompiland->Release();
+  }
+
+  pEnumSymbols->Release();
+
+  putwchar(L'\n');
+
+  return true;
+}
+
+////////////////////////////////////////////////////////////
+// Dump all the global symbols - SymTagFunction,
+//  SymTagThunk and SymTagData
+//
+bool DumpAllGlobals(IDiaSymbol *pGlobal)
+{
+  IDiaEnumSymbols *pEnumSymbols;
+  IDiaSymbol *pSymbol;
+  enum SymTagEnum dwSymTags[] = { SymTagFunction, SymTagThunk, SymTagData };
+  ULONG celt = 0;
+
+  wprintf(L"\n\n*** GLOBALS\n\n");
+
+  for (size_t i = 0; i < _countof(dwSymTags); i++, pEnumSymbols = NULL) {
+    if (SUCCEEDED(pGlobal->findChildren(dwSymTags[i], NULL, nsNone, &pEnumSymbols))) {
+      while (SUCCEEDED(pEnumSymbols->Next(1, &pSymbol, &celt)) && (celt == 1)) {
+        PrintGlobalSymbol(pSymbol);
+
+        pSymbol->Release();
+      }
+
+      pEnumSymbols->Release();
+    }
+
+    else {
+      wprintf(L"ERROR - DumpAllGlobals() returned no symbols\n");
+
+      return false;
+    }
+  }
+
+  putwchar(L'\n');
+
+  return true;
+}
+
+////////////////////////////////////////////////////////////
+// Dump all the types information
+//  (type symbols can be UDTs, enums or typedefs)
+//
+bool DumpAllTypes(IDiaSymbol *pGlobal)
+{
+  wprintf(L"\n\n*** TYPES\n");
+
+  return DumpAllUDTs(pGlobal) || DumpAllEnums(pGlobal) || DumpAllTypedefs(pGlobal);
+}
+
+////////////////////////////////////////////////////////////
+// Dump all the user defined types (UDT)
+//
+bool DumpAllUDTs(IDiaSymbol *pGlobal)
+{
+  wprintf(L"\n\n** User Defined Types\n\n");
+
+  IDiaEnumSymbols *pEnumSymbols;
+
+  if (FAILED(pGlobal->findChildren(SymTagUDT, NULL, nsNone, &pEnumSymbols))) {
+    wprintf(L"ERROR - DumpAllUDTs() returned no symbols\n");
+
+    return false;
+  }
+
+  IDiaSymbol *pSymbol;
+  ULONG celt = 0;
+
+  while (SUCCEEDED(pEnumSymbols->Next(1, &pSymbol, &celt)) && (celt == 1)) {
+    PrintTypeInDetail(pSymbol, 0);
+
+    pSymbol->Release();
+  }
+
+  pEnumSymbols->Release();
+
+  putwchar(L'\n');
+
+  return true;
+}
+
+////////////////////////////////////////////////////////////
+// Dump all the enum types from the pdb
+//
+bool DumpAllEnums(IDiaSymbol *pGlobal)
+{
+  wprintf(L"\n\n** ENUMS\n\n");
+
+  IDiaEnumSymbols *pEnumSymbols;
+
+  if (FAILED(pGlobal->findChildren(SymTagEnum, NULL, nsNone, &pEnumSymbols))) {
+    wprintf(L"ERROR - DumpAllEnums() returned no symbols\n");
+
+    return false;
+  }
+
+  IDiaSymbol *pSymbol;
+  ULONG celt = 0;
+
+  while (SUCCEEDED(pEnumSymbols->Next(1, &pSymbol, &celt)) && (celt == 1)) {
+    PrintTypeInDetail(pSymbol, 0);
+
+    pSymbol->Release();
+  }
+
+  pEnumSymbols->Release();
+
+  putwchar(L'\n');
+
+  return true;
+}
+
+////////////////////////////////////////////////////////////
+// Dump all the typedef types from the pdb
+//
+bool DumpAllTypedefs(IDiaSymbol *pGlobal)
+{
+  wprintf(L"\n\n** TYPEDEFS\n\n");
+
+  IDiaEnumSymbols *pEnumSymbols;
+
+  if (FAILED(pGlobal->findChildren(SymTagTypedef, NULL, nsNone, &pEnumSymbols))) {
+    wprintf(L"ERROR - DumpAllTypedefs() returned no symbols\n");
+
+    return false;
+  }
+
+  IDiaSymbol *pSymbol;
+  ULONG celt = 0;
+
+  while (SUCCEEDED(pEnumSymbols->Next(1, &pSymbol, &celt)) && (celt == 1)) {
+    PrintTypeInDetail(pSymbol, 0);
+
+    pSymbol->Release();
+  }
+
+  pEnumSymbols->Release();
+
+  putwchar(L'\n');
+
+  return true;
+}
+
+////////////////////////////////////////////////////////////
+// Dump OEM specific types
+//
+bool DumpAllOEMs(IDiaSymbol *pGlobal)
+{
+  wprintf(L"\n\n*** OEM Specific types\n\n");
+
+  IDiaEnumSymbols *pEnumSymbols;
+
+  if (FAILED(pGlobal->findChildren(SymTagCustomType, NULL, nsNone, &pEnumSymbols))) {
+    wprintf(L"ERROR - DumpAllOEMs() returned no symbols\n");
+
+    return false;
+  }
+
+  IDiaSymbol *pSymbol;
+  ULONG celt = 0;
+
+  while (SUCCEEDED(pEnumSymbols->Next(1, &pSymbol, &celt)) && (celt == 1)) {
+    PrintTypeInDetail(pSymbol, 0);
+
+    pSymbol->Release();
+  }
+
+  pEnumSymbols->Release();
+
+  putwchar(L'\n');
+
+  return true;
+}
+
+////////////////////////////////////////////////////////////
+// For each compiland in the PDB dump all the source files
+//
+bool DumpAllFiles(IDiaSession *pSession, IDiaSymbol *pGlobal)
+{
+  wprintf(L"\n\n*** FILES\n\n");
+
+  // In order to find the source files, we have to look at the image's compilands/modules
+
+  IDiaEnumSymbols *pEnumSymbols;
+
+  if (FAILED(pGlobal->findChildren(SymTagCompiland, NULL, nsNone, &pEnumSymbols))) {
+    return false;
+  }
+
+  IDiaSymbol *pCompiland;
+  ULONG celt = 0;
+
+  while (SUCCEEDED(pEnumSymbols->Next(1, &pCompiland, &celt)) && (celt == 1)) {
+    BSTR bstrName;
+
+    if (pCompiland->get_name(&bstrName) == S_OK) {
+      wprintf(L"\nCompiland = %s\n\n", bstrName);
+
+      SysFreeString(bstrName);
+    }
+
+    // Every compiland could contain multiple references to the source files which were used to build it
+    // Retrieve all source files by compiland by passing NULL for the name of the source file
+
+    IDiaEnumSourceFiles *pEnumSourceFiles;
+
+    if (SUCCEEDED(pSession->findFile(pCompiland, NULL, nsNone, &pEnumSourceFiles))) {
+      IDiaSourceFile *pSourceFile;
+
+      while (SUCCEEDED(pEnumSourceFiles->Next(1, &pSourceFile, &celt)) && (celt == 1)) {
+        PrintSourceFile(pSourceFile);
+        putwchar(L'\n');
+
+        pSourceFile->Release();
+      }
+
+      pEnumSourceFiles->Release();
+    }
+
+    putwchar(L'\n');
+
+    pCompiland->Release();
+  }
+
+  pEnumSymbols->Release();
+
+  return true;
+}
+
+////////////////////////////////////////////////////////////
+// Dump all the line numbering information contained in the PDB
+//  Only function symbols have corresponding line numbering information
+bool DumpAllLines(IDiaSession *pSession, IDiaSymbol *pGlobal)
+{
+  wprintf(L"\n\n*** LINES\n\n");
+
+  // First retrieve the compilands/modules
+
+  IDiaEnumSymbols *pEnumSymbols;
+
+  if (FAILED(pGlobal->findChildren(SymTagCompiland, NULL, nsNone, &pEnumSymbols))) {
+    return false;
+  }
+
+  IDiaSymbol *pCompiland;
+  ULONG celt = 0;
+
+  while (SUCCEEDED(pEnumSymbols->Next(1, &pCompiland, &celt)) && (celt == 1)) {
+    IDiaEnumSymbols *pEnumFunction;
+
+    // For every function symbol defined in the compiland, retrieve and print the line numbering info
+
+    if (SUCCEEDED(pCompiland->findChildren(SymTagFunction, NULL, nsNone, &pEnumFunction))) {
+      IDiaSymbol *pFunction;
+      ULONG celt = 0;
+
+      while (SUCCEEDED(pEnumFunction->Next(1, &pFunction, &celt)) && (celt == 1)) {
+        PrintLines(pSession, pFunction);
+
+        pFunction->Release();
+      }
+
+      pEnumFunction->Release();
+    }
+
+    pCompiland->Release();
+  }
+
+  pEnumSymbols->Release();
+
+  putwchar(L'\n');
+
+  return true;
+}
+
+////////////////////////////////////////////////////////////
+// Dump all the line numbering information for a given RVA
+// and a given range
+//
+bool DumpAllLines(IDiaSession *pSession, DWORD dwRVA, DWORD dwRange)
+{
+  // Retrieve and print the lines that corresponds to a specified RVA
+
+  IDiaEnumLineNumbers *pLines;
+
+  if (FAILED(pSession->findLinesByRVA(dwRVA, dwRange, &pLines))) {
+    return false;
+  }
+
+  PrintLines(pLines);
+
+  pLines->Release();
+
+  putwchar(L'\n');
+
+  return true;
+}
+
+////////////////////////////////////////////////////////////
+// Dump all the section contributions from the PDB
+//
+//  Section contributions are stored in a table which will
+//  be retrieved via IDiaSession->getEnumTables through
+//  QueryInterface()using the REFIID of the IDiaEnumSectionContribs
+//
+bool DumpAllSecContribs(IDiaSession *pSession)
+{
+  wprintf(L"\n\n*** SECTION CONTRIBUTION\n\n");
+
+  IDiaEnumSectionContribs *pEnumSecContribs;
+
+  if (FAILED(GetTable(pSession, __uuidof(IDiaEnumSectionContribs), (void **) &pEnumSecContribs))) {
+    return false;
+  }
+
+  wprintf(L"    RVA        Address       Size    Module\n");
+
+  IDiaSectionContrib *pSecContrib;
+  ULONG celt = 0;
+
+  while (SUCCEEDED(pEnumSecContribs->Next(1, &pSecContrib, &celt)) && (celt == 1)) {
+    PrintSecContribs(pSecContrib);
+
+    pSecContrib->Release();
+  }
+
+  pEnumSecContribs->Release();
+
+  putwchar(L'\n');
+
+  return true;
+}
+
+////////////////////////////////////////////////////////////
+// Dump all debug data streams contained in the PDB
+//
+bool DumpAllDebugStreams(IDiaSession *pSession)
+{
+  IDiaEnumDebugStreams *pEnumStreams;
+
+  wprintf(L"\n\n*** DEBUG STREAMS\n\n");
+
+  // Retrieve an enumerated sequence of debug data streams
+
+  if (FAILED(pSession->getEnumDebugStreams(&pEnumStreams))) {
+    return false;
+  }
+
+  IDiaEnumDebugStreamData *pStream;
+  ULONG celt = 0;
+
+  for (; SUCCEEDED(pEnumStreams->Next(1, &pStream, &celt)) && (celt == 1); pStream = NULL) {
+    PrintStreamData(pStream);
+
+    pStream->Release();
+  }
+
+  pEnumStreams->Release();
+
+  putwchar(L'\n');
+
+  return true;
+}
+
+////////////////////////////////////////////////////////////
+// Dump all the injected source from the PDB
+//
+//  Injected sources data is stored in a table which will
+//  be retrieved via IDiaSession->getEnumTables through
+//  QueryInterface()using the REFIID of the IDiaEnumSectionContribs
+//
+bool DumpAllInjectedSources(IDiaSession *pSession)
+{
+  wprintf(L"\n\n*** INJECTED SOURCES TABLE\n\n");
+
+  IDiaEnumInjectedSources *pEnumInjSources;
+
+  if (SUCCEEDED(GetTable(pSession, __uuidof(IDiaEnumInjectedSources), (void **) &pEnumInjSources))) {
+    return false;
+  }
+
+  IDiaInjectedSource *pInjSource;
+  ULONG celt = 0;
+
+  while (SUCCEEDED(pEnumInjSources->Next(1, &pInjSource, &celt)) && (celt == 1)) {
+    PrintGeneric(pInjSource);
+
+    pInjSource->Release();
+  }
+
+  pEnumInjSources->Release();
+
+  putwchar(L'\n');
+
+  return true;
+}
+
+////////////////////////////////////////////////////////////
+// Dump info corresponing to a given injected source filename
+//
+bool DumpInjectedSource(IDiaSession *pSession, const wchar_t *szName)
+{
+  // Retrieve a source that has been placed into the symbol store by attribute providers or
+  //  other components of the compilation process
+
+  IDiaEnumInjectedSources *pEnumInjSources;
+
+  if (FAILED(pSession->findInjectedSource(szName, &pEnumInjSources))) {
+    wprintf(L"ERROR - DumpInjectedSources() could not find %s\n", szName);
+
+    return false;
+  }
+
+  IDiaInjectedSource *pInjSource;
+  ULONG celt = 0;
+
+  while (SUCCEEDED(pEnumInjSources->Next(1, &pInjSource, &celt)) && (celt == 1)) {
+    PrintGeneric(pInjSource);
+
+    pInjSource->Release();
+  }
+
+  pEnumInjSources->Release();
+
+  return true;
+}
+
+////////////////////////////////////////////////////////////
+// Dump all the source file information stored in the PDB
+// We have to go through every compiland in order to retrieve
+//   all the information otherwise checksums for instance
+//   will not be available
+// Compilands can have multiple source files with the same
+//   name but different content which produces diffrent
+//   checksums
+//
+bool DumpAllSourceFiles(IDiaSession *pSession, IDiaSymbol *pGlobal)
+{
+  wprintf(L"\n\n*** SOURCE FILES\n\n");
+
+  // To get the complete source file info we must go through the compiland first
+  // by passing NULL instead all the source file names only will be retrieved
+
+  IDiaEnumSymbols *pEnumSymbols;
+
+  if (FAILED(pGlobal->findChildren(SymTagCompiland, NULL, nsNone, &pEnumSymbols))) {
+    return false;
+  }
+
+  IDiaSymbol *pCompiland;
+  ULONG celt = 0;
+
+  while (SUCCEEDED(pEnumSymbols->Next(1, &pCompiland, &celt)) && (celt == 1)) {
+    BSTR bstrName;
+
+    if (pCompiland->get_name(&bstrName) == S_OK) {
+      wprintf(L"\nCompiland = %s\n\n", bstrName);
+
+      SysFreeString(bstrName);
+    }
+
+    // Every compiland could contain multiple references to the source files which were used to build it
+    // Retrieve all source files by compiland by passing NULL for the name of the source file
+
+    IDiaEnumSourceFiles *pEnumSourceFiles;
+
+    if (SUCCEEDED(pSession->findFile(pCompiland, NULL, nsNone, &pEnumSourceFiles))) {
+      IDiaSourceFile *pSourceFile;
+
+      while (SUCCEEDED(pEnumSourceFiles->Next(1, &pSourceFile, &celt)) && (celt == 1)) {
+        PrintSourceFile(pSourceFile);
+        putwchar(L'\n');
+
+        pSourceFile->Release();
+      }
+
+      pEnumSourceFiles->Release();
+    }
+
+    putwchar(L'\n');
+
+    pCompiland->Release();
+  }
+
+  pEnumSymbols->Release();
+
+  return true;
+}
+
+////////////////////////////////////////////////////////////
+// Dump all the FPO info
+//
+//  FPO data stored in a table which will be retrieved via
+//    IDiaSession->getEnumTables through QueryInterface()
+//    using the REFIID of the IDiaEnumFrameData
+//
+bool DumpAllFPO(IDiaSession *pSession)
+{
+  IDiaEnumFrameData *pEnumFrameData;
+
+  wprintf(L"\n\n*** FPO\n\n");
+
+  if (FAILED(GetTable(pSession, __uuidof(IDiaEnumFrameData), (void **) &pEnumFrameData))) {
+    return false;
+  }
+
+  IDiaFrameData *pFrameData;
+  ULONG celt = 0;
+
+  while (SUCCEEDED(pEnumFrameData->Next(1, &pFrameData, &celt)) && (celt == 1)) {
+    PrintFrameData(pFrameData);
+
+    pFrameData->Release();
+  }
+
+  pEnumFrameData->Release();
+
+  putwchar(L'\n');
+
+  return true;
+}
+
+////////////////////////////////////////////////////////////
+// Dump FPO info for a function at the specified RVA
+//
+bool DumpFPO(IDiaSession *pSession, DWORD dwRVA)
+{
+  IDiaEnumFrameData *pEnumFrameData;
+
+  // Retrieve first the table holding all the FPO info
+
+  if ((dwRVA != 0) && SUCCEEDED(GetTable(pSession, __uuidof(IDiaEnumFrameData), (void **) &pEnumFrameData))) {
+    IDiaFrameData *pFrameData;
+
+    // Retrieve the frame data corresponding to the given RVA
+
+    if (SUCCEEDED(pEnumFrameData->frameByRVA(dwRVA, &pFrameData))) {
+      PrintGeneric(pFrameData);
+
+      pFrameData->Release();
+    }
+
+    else {
+      // Some function might not have FPO data available (see ASM funcs like strcpy)
+
+      wprintf(L"ERROR - DumpFPO() frameByRVA invalid RVA: 0x%08X\n", dwRVA);
+
+      pEnumFrameData->Release();
+
+      return false;
+    }
+
+    pEnumFrameData->Release();
+  }
+
+  else {
+    wprintf(L"ERROR - DumpFPO() GetTable\n");
+
+    return false;
+  }
+
+  putwchar(L'\n');
+
+  return true;
+}
+
+////////////////////////////////////////////////////////////
+// Dump FPO info for a specified function symbol using its
+//  name (a regular expression string is used for the search)
+//
+bool DumpFPO(IDiaSession *pSession, IDiaSymbol *pGlobal, const wchar_t *szSymbolName)
+{
+  IDiaEnumSymbols *pEnumSymbols;
+  IDiaSymbol *pSymbol;
+  ULONG celt = 0;
+  DWORD dwRVA;
+
+  // Find first all the function symbols that their names matches the search criteria
+
+  if (FAILED(pGlobal->findChildren(SymTagFunction, szSymbolName, nsRegularExpression, &pEnumSymbols))) {
+    wprintf(L"ERROR - DumpFPO() findChildren could not find symol %s\n", szSymbolName);
+
+    return false;
+  }
+
+  while (SUCCEEDED(pEnumSymbols->Next(1, &pSymbol, &celt)) && (celt == 1)) {
+    if (pSymbol->get_relativeVirtualAddress(&dwRVA) == S_OK) {
+      PrintPublicSymbol(pSymbol);
+
+      DumpFPO(pSession, dwRVA);
+    }
+
+    pSymbol->Release();
+  }
+
+  pEnumSymbols->Release();
+
+  putwchar(L'\n');
+
+  return true;
+}
+
+////////////////////////////////////////////////////////////
+// Dump a specified compiland and all the symbols defined in it
+//
+bool DumpCompiland(IDiaSymbol *pGlobal, const wchar_t *szCompName)
+{
+  IDiaEnumSymbols *pEnumSymbols;
+
+  if (FAILED(pGlobal->findChildren(SymTagCompiland, szCompName, nsCaseInsensitive, &pEnumSymbols))) {
+    return false;
+  }
+
+  IDiaSymbol *pCompiland;
+  ULONG celt = 0;
+
+  while (SUCCEEDED(pEnumSymbols->Next(1, &pCompiland, &celt)) && (celt == 1)) {
+    wprintf(L"\n** Module: ");
+
+    // Retrieve the name of the module
+
+    BSTR bstrName;
+
+    if (pCompiland->get_name(&bstrName) != S_OK) {
+      wprintf(L"(???)\n\n");
+    }
+
+    else {
+      wprintf(L"%s\n\n", bstrName);
+
+      SysFreeString(bstrName);
+    }
+
+    IDiaEnumSymbols *pEnumChildren;
+
+    if (SUCCEEDED(pCompiland->findChildren(SymTagNull, NULL, nsNone, &pEnumChildren))) {
+      IDiaSymbol *pSymbol;
+      ULONG celt_ = 0;
+
+      while (SUCCEEDED(pEnumChildren->Next(1, &pSymbol, &celt_)) && (celt_ == 1)) {
+        PrintSymbol(pSymbol, 0);
+
+        pSymbol->Release();
+      }
+
+      pEnumChildren->Release();
+    }
+
+    pCompiland->Release();
+  }
+
+  pEnumSymbols->Release();
+
+  return true;
+}
+
+////////////////////////////////////////////////////////////
+// Dump the line numbering information for a specified RVA
+//
+bool DumpLines(IDiaSession *pSession, DWORD dwRVA)
+{
+  IDiaEnumLineNumbers *pLines;
+
+  if (FAILED(pSession->findLinesByRVA(dwRVA, MAX_RVA_LINES_BYTES_RANGE, &pLines))) {
+    return false;
+  }
+
+  PrintLines(pLines);
+
+  pLines->Release();
+
+  return true;
+}
+
+////////////////////////////////////////////////////////////
+// Dump the all line numbering information for a specified
+//  function symbol name (as a regular expression string)
+//
+bool DumpLines(IDiaSession *pSession, IDiaSymbol *pGlobal, const wchar_t *szFuncName)
+{
+  IDiaEnumSymbols *pEnumSymbols;
+
+  if (FAILED(pGlobal->findChildren(SymTagFunction, szFuncName, nsRegularExpression, &pEnumSymbols))) {
+    return false;
+  }
+
+  IDiaSymbol *pFunction;
+  ULONG celt = 0;
+
+  while (SUCCEEDED(pEnumSymbols->Next(1, &pFunction, &celt)) && (celt == 1)) {
+    PrintLines(pSession, pFunction);
+
+    pFunction->Release();
+  }
+
+  pEnumSymbols->Release();
+
+  return true;
+}
+
+////////////////////////////////////////////////////////////
+// Dump the symbol information corresponding to a specified RVA
+//
+bool DumpSymbolWithRVA(IDiaSession *pSession, DWORD dwRVA, const wchar_t *szChildname)
+{
+  IDiaSymbol *pSymbol;
+  LONG lDisplacement;
+
+  if (FAILED(pSession->findSymbolByRVAEx(dwRVA, SymTagNull, &pSymbol, &lDisplacement))) {
+    return false;
+  }
+
+  wprintf(L"Displacement = 0x%X\n", lDisplacement);
+
+  PrintGeneric(pSymbol);
+
+  bool bReturn = DumpSymbolWithChildren(pSymbol, szChildname);
+
+  while (pSymbol != NULL) {
+    IDiaSymbol *pParent;
+
+    if ((pSymbol->get_lexicalParent(&pParent) == S_OK) && pParent) {
+      wprintf(L"\nParent\n");
+
+      PrintSymbol(pParent, 0);
+
+      pSymbol->Release();
+
+      pSymbol = pParent;
+    }
+
+    else {
+      pSymbol->Release();
+      break;
+    }
+  }
+
+  return true;
+}
+
+////////////////////////////////////////////////////////////
+// Dump the symbols information where their names matches a
+//  specified regular expression string
+//
+bool DumpSymbolsWithRegEx(IDiaSymbol *pGlobal, const wchar_t *szRegEx, const wchar_t *szChildname)
+{
+  IDiaEnumSymbols *pEnumSymbols;
+
+  if (FAILED(pGlobal->findChildren(SymTagNull, szRegEx, nsRegularExpression, &pEnumSymbols))) {
+    return false;
+  }
+
+  bool bReturn = true;
+
+  IDiaSymbol *pSymbol;
+  ULONG celt = 0;
+
+  while (SUCCEEDED(pEnumSymbols->Next(1, &pSymbol, &celt)) && (celt == 1)) {
+    PrintGeneric(pSymbol);
+
+    bReturn = DumpSymbolWithChildren(pSymbol, szChildname);
+
+    pSymbol->Release();
+  }
+
+  pEnumSymbols->Release();
+
+  return bReturn;
+}
+
+////////////////////////////////////////////////////////////
+// Dump the information corresponding to a symbol name which
+//  is a children of the specified parent symbol
+//
+bool DumpSymbolWithChildren(IDiaSymbol *pSymbol, const wchar_t *szChildname)
+{
+  if (szChildname != NULL) {
+    IDiaEnumSymbols *pEnumSyms;
+
+    if (FAILED(pSymbol->findChildren(SymTagNull, szChildname, nsRegularExpression, &pEnumSyms))) {
+      return false;
+    }
+
+    IDiaSymbol *pChild;
+    DWORD celt = 1;
+
+    while (SUCCEEDED(pEnumSyms->Next(celt, &pChild, &celt)) && (celt == 1)) {
+      PrintGeneric(pChild);
+      PrintSymbol(pChild, 0);
+
+      pChild->Release();
+    }
+
+    pEnumSyms->Release();
+  }
+
+  else {
+    // If the specified name is NULL then only the parent symbol data is displayed
+
+    DWORD dwSymTag;
+
+    if ((pSymbol->get_symTag(&dwSymTag) == S_OK) && (dwSymTag == SymTagPublicSymbol)) {
+      PrintPublicSymbol(pSymbol);
+    }
+
+    else {
+      PrintSymbol(pSymbol, 0);
+    }
+  }
+
+  return true;
+}
+
+////////////////////////////////////////////////////////////
+// Dump all the type symbols information that matches their
+//  names to a specified regular expression string
+//
+bool DumpType(IDiaSymbol *pGlobal, const wchar_t *szRegEx)
+{
+  IDiaEnumSymbols *pEnumSymbols;
+
+  if (FAILED(pGlobal->findChildren(SymTagUDT, szRegEx, nsRegularExpression, &pEnumSymbols))) {
+    return false;
+  }
+
+  IDiaSymbol *pSymbol;
+  ULONG celt = 0;
+
+  while (SUCCEEDED(pEnumSymbols->Next(1, &pSymbol, &celt)) && (celt == 1)) {
+    PrintTypeInDetail(pSymbol, 0);
+
+    pSymbol->Release();
+  }
+
+  pEnumSymbols->Release();
+
+  return true;
+}
+
+////////////////////////////////////////////////////////////
+// Dump line numbering information for a given file name and
+//  an optional line number
+//
+bool DumpLinesForSourceFile(IDiaSession *pSession, const wchar_t *szFileName, DWORD dwLine)
+{
+  IDiaEnumSourceFiles *pEnumSrcFiles;
+
+  if (FAILED(pSession->findFile(NULL, szFileName, nsFNameExt, &pEnumSrcFiles))) {
+    return false;
+  }
+
+  IDiaSourceFile *pSrcFile;
+  ULONG celt = 0;
+
+  while (SUCCEEDED(pEnumSrcFiles->Next(1, &pSrcFile, &celt)) && (celt == 1)) {
+    IDiaEnumSymbols *pEnumCompilands;
+
+    if (pSrcFile->get_compilands(&pEnumCompilands) == S_OK) {
+      IDiaSymbol *pCompiland;
+
+      celt = 0;
+      while (SUCCEEDED(pEnumCompilands->Next(1, &pCompiland, &celt)) && (celt == 1)) {
+        BSTR bstrName;
+
+        if (pCompiland->get_name(&bstrName) == S_OK) {
+          wprintf(L"Compiland = %s\n", bstrName);
+
+          SysFreeString(bstrName);
+        }
+
+        else {
+          wprintf(L"Compiland = (???)\n");
+        }
+
+        IDiaEnumLineNumbers *pLines;
+
+        if (dwLine != 0) {
+          if (SUCCEEDED(pSession->findLinesByLinenum(pCompiland, pSrcFile, dwLine, 0, &pLines))) {
+            PrintLines(pLines);
+
+            pLines->Release();
+          }
+        }
+
+        else {
+          if (SUCCEEDED(pSession->findLines(pCompiland, pSrcFile, &pLines))) {
+            PrintLines(pLines);
+
+            pLines->Release();
+          }
+        }
+
+        pCompiland->Release();
+      }
+
+      pEnumCompilands->Release();
+    }
+
+    pSrcFile->Release();
+  }
+
+  pEnumSrcFiles->Release();
+
+  return true;
+}
+
+////////////////////////////////////////////////////////////
+// Dump public symbol information for a given number of
+//  symbols around a given RVA address
+//
+bool DumpPublicSymbolsSorted(IDiaSession *pSession, DWORD dwRVA, DWORD dwRange, bool bReverse)
+{
+  IDiaEnumSymbolsByAddr *pEnumSymsByAddr;
+
+  if (FAILED(pSession->getSymbolsByAddr(&pEnumSymsByAddr))) {
+    return false;
+  }
+
+  IDiaSymbol *pSymbol;
+
+  if (SUCCEEDED(pEnumSymsByAddr->symbolByRVA(dwRVA, &pSymbol))) {
+    if (dwRange == 0) {
+      PrintPublicSymbol(pSymbol);
+    }
+
+    ULONG celt;
+    ULONG i;
+
+    if (bReverse) {
+      pSymbol->Release();
+
+      i = 0;
+
+      for (pSymbol = NULL; (i < dwRange) && SUCCEEDED(pEnumSymsByAddr->Next(1, &pSymbol, &celt)) && (celt == 1); i++) {
+        PrintPublicSymbol(pSymbol);
+
+        pSymbol->Release();
+      }
+    }
+
+    else {
+      PrintPublicSymbol(pSymbol);
+
+      pSymbol->Release();
+
+      i = 1;
+
+      for (pSymbol = NULL; (i < dwRange) && SUCCEEDED(pEnumSymsByAddr->Prev(1, &pSymbol, &celt)) && (celt == 1); i++) {
+        PrintPublicSymbol(pSymbol);
+      }
+    }
+  }
+
+  pEnumSymsByAddr->Release();
+
+  return true;
+}
+
+////////////////////////////////////////////////////////////
+// Dump label symbol information at a given RVA
+//
+bool DumpLabel(IDiaSession *pSession, DWORD dwRVA)
+{
+  IDiaSymbol *pSymbol;
+  LONG lDisplacement;
+
+  if (FAILED(pSession->findSymbolByRVAEx(dwRVA, SymTagLabel, &pSymbol, &lDisplacement)) || (pSymbol == NULL)) {
+    return false;
+  }
+
+  wprintf(L"Displacement = 0x%X\n", lDisplacement);
+
+  PrintGeneric(pSymbol);
+
+  pSymbol->Release();
+
+  return true;
+}
+
+////////////////////////////////////////////////////////////
+// Dump annotation symbol information at a given RVA
+//
+bool DumpAnnotations(IDiaSession *pSession, DWORD dwRVA)
+{
+  IDiaSymbol *pSymbol;
+  LONG lDisplacement;
+
+  if (FAILED(pSession->findSymbolByRVAEx(dwRVA, SymTagAnnotation, &pSymbol, &lDisplacement)) || (pSymbol == NULL)) {
+    return false;
+  }
+
+  wprintf(L"Displacement = 0x%X\n", lDisplacement);
+
+  PrintGeneric(pSymbol);
+
+  pSymbol->Release();
+
+  return true;
+}
+
+struct OMAP_DATA
+{
+  DWORD dwRVA;
+  DWORD dwRVATo;
+};
+
+////////////////////////////////////////////////////////////
+//
+bool DumpMapToSrc(IDiaSession *pSession, DWORD dwRVA)
+{
+  IDiaEnumDebugStreams *pEnumStreams;
+  IDiaEnumDebugStreamData *pStream;
+  ULONG celt;
+
+  if (FAILED(pSession->getEnumDebugStreams(&pEnumStreams))) {
+    return false;
+  }
+
+  celt = 0;
+
+  for (; SUCCEEDED(pEnumStreams->Next(1, &pStream, &celt)) && (celt == 1); pStream = NULL) {
+    BSTR bstrName;
+
+    if (pStream->get_name(&bstrName) != S_OK) {
+      bstrName = NULL;
+    }
+
+    if (bstrName && wcscmp(bstrName, L"OMAPTO") == 0) {
+      OMAP_DATA data, datasav;
+      DWORD cbData, celt;
+      DWORD dwRVATo = 0;
+      unsigned int i;
+
+      datasav.dwRVATo = 0;
+      datasav.dwRVA = 0;
+
+      while (SUCCEEDED(pStream->Next(1, sizeof(data), &cbData, (BYTE*) &data, &celt)) && (celt == 1)) {
+        if (dwRVA > data.dwRVA) {
+          datasav = data;
+          continue;
+        }
+
+         else if (dwRVA == data.dwRVA) {
+          dwRVATo = data.dwRVATo;
+        }
+
+        else if (datasav.dwRVATo) {
+          dwRVATo = datasav.dwRVATo + (dwRVA - datasav.dwRVA);
+        }
+        break;
+      }
+
+      wprintf(L"image rva = %08X ==> source rva = %08X\n\nRelated OMAP entries:\n", dwRVA, dwRVATo);
+      wprintf(L"image rva ==> source rva\n");
+      wprintf(L"%08X  ==> %08X\n", datasav.dwRVA, datasav.dwRVATo);
+
+      i = 0;
+
+      do {
+        wprintf(L"%08X  ==> %08X\n", data.dwRVA, data.dwRVATo);
+      }
+      while ((++i) < 5 && SUCCEEDED(pStream->Next(1, sizeof(data), &cbData, (BYTE*) &data, &celt)) && (celt == 1));
+    }
+
+    if (bstrName != NULL) {
+      SysFreeString(bstrName);
+    }
+
+    pStream->Release();
+  }
+
+  pEnumStreams->Release();
+
+  return true;
+}
+
+////////////////////////////////////////////////////////////
+//
+bool DumpMapFromSrc(IDiaSession *pSession, DWORD dwRVA)
+{
+  IDiaEnumDebugStreams *pEnumStreams;
+
+  if (FAILED(pSession->getEnumDebugStreams(&pEnumStreams))) {
+    return false;
+  }
+
+  IDiaEnumDebugStreamData *pStream;
+  ULONG celt = 0;
+
+  for (; SUCCEEDED(pEnumStreams->Next(1, &pStream, &celt)) && (celt == 1); pStream = NULL) {
+    BSTR bstrName;
+
+    if (pStream->get_name(&bstrName) != S_OK) {
+      bstrName = NULL;
+    }
+
+    if (bstrName && wcscmp(bstrName, L"OMAPFROM") == 0) {
+      OMAP_DATA data;
+      OMAP_DATA datasav;
+      DWORD cbData;
+      DWORD celt;
+      DWORD dwRVATo = 0;
+      unsigned int i;
+
+      datasav.dwRVATo = 0;
+      datasav.dwRVA = 0;
+
+      while (SUCCEEDED(pStream->Next(1, sizeof(data), &cbData, (BYTE*) &data, &celt)) && (celt == 1)) {
+        if (dwRVA > data.dwRVA) {
+          datasav = data;
+          continue;
+        }
+
+        else if (dwRVA == data.dwRVA) {
+          dwRVATo = data.dwRVATo;
+        }
+
+        else if (datasav.dwRVATo) {
+          dwRVATo = datasav.dwRVATo + (dwRVA - datasav.dwRVA);
+        }
+        break;
+      }
+
+      wprintf(L"source rva = %08X ==> image rva = %08X\n\nRelated OMAP entries:\n", dwRVA, dwRVATo);
+      wprintf(L"source rva ==> image rva\n");
+      wprintf(L"%08X  ==> %08X\n", datasav.dwRVA, datasav.dwRVATo);
+
+      i = 0;
+
+      do {
+        wprintf(L"%08X  ==> %08X\n", data.dwRVA, data.dwRVATo);
+      }
+      while ((++i) < 5 && SUCCEEDED(pStream->Next(1, sizeof(data), &cbData, (BYTE*) &data, &celt)) && (celt == 1));
+    }
+
+    if (bstrName != NULL) {
+      SysFreeString(bstrName);
+    }
+
+    pStream->Release();
+  }
+
+  pEnumStreams->Release();
+
+  return true;
+}
+
+////////////////////////////////////////////////////////////
+// Retreive the table that matches the given iid
+//
+//  A PDB table could store the section contributions, the frame data,
+//  the injected sources
+//
+HRESULT GetTable(IDiaSession *pSession, REFIID iid, void **ppUnk)
+{
+  IDiaEnumTables *pEnumTables;
+
+  if (FAILED(pSession->getEnumTables(&pEnumTables))) {
+    wprintf(L"ERROR - GetTable() getEnumTables\n");
+
+    return E_FAIL;
+  }
+
+  IDiaTable *pTable;
+  ULONG celt = 0;
+
+  while (SUCCEEDED(pEnumTables->Next(1, &pTable, &celt)) && (celt == 1)) {
+    // There's only one table that matches the given IID
+
+    if (SUCCEEDED(pTable->QueryInterface(iid, (void **) ppUnk))) {
+      pTable->Release();
+      pEnumTables->Release();
+
+      return S_OK;
+    }
+
+    pTable->Release();
+  }
+
+  pEnumTables->Release();
+
+  return E_FAIL;
+}
diff --git a/src/ToolBox/PdbTypeMatch/PdbTypeMatch.h b/src/ToolBox/PdbTypeMatch/PdbTypeMatch.h
new file mode 100644
index 0000000000..b2accf902d
--- /dev/null
+++ b/src/ToolBox/PdbTypeMatch/PdbTypeMatch.h
@@ -0,0 +1,65 @@
+#include "dia2.h"
+#include <set>
+
+extern const wchar_t *g_szFilename;
+extern IDiaDataSource *g_pDiaDataSource;
+extern IDiaSession *g_pDiaSession1, *g_pDiaSession2;
+extern IDiaSymbol *g_pGlobalSymbol1, *g_pGlobalSymbol2;
+extern DWORD g_dwMachineType;
+
+typedef std::set<std::wstring> IDiaSymbolSet;
+
+
+void PrintHelpOptions();
+bool ParseArg(int , wchar_t *[]);
+
+bool InitDiaSource(IDiaDataSource  **ppSource);
+void Cleanup();
+bool LoadDataFromPdb(const wchar_t *, IDiaDataSource *, IDiaSession **, IDiaSymbol **);
+
+
+bool EnumTypesInPdb(IDiaSymbolSet* types, IDiaSession *pSession, IDiaSymbol *pGlobal);
+bool LayoutMatches(IDiaSymbol* pSymbol1, IDiaSymbol* pSymbol2);
+
+LPSTR UnicodeToAnsi(LPCWSTR s);
+void DumpAllPdbInfo(IDiaSession *, IDiaSymbol *);
+bool DumpAllMods(IDiaSymbol *);
+bool DumpAllPublics(IDiaSymbol *);
+bool DumpCompiland(IDiaSymbol *, const wchar_t *);
+bool DumpAllSymbols(IDiaSymbol *);
+bool DumpAllGlobals(IDiaSymbol *);
+bool DumpAllTypes(IDiaSymbol *);
+bool DumpAllUDTs(IDiaSymbol *);
+bool DumpAllEnums(IDiaSymbol *);
+bool DumpAllTypedefs(IDiaSymbol *);
+bool DumpAllOEMs(IDiaSymbol *);
+bool DumpAllFiles(IDiaSession *, IDiaSymbol *);
+bool DumpAllLines(IDiaSession *, IDiaSymbol *);
+bool DumpAllLines(IDiaSession *, DWORD, DWORD);
+bool DumpAllSecContribs(IDiaSession *);
+bool DumpAllDebugStreams(IDiaSession *);
+bool DumpAllInjectedSources(IDiaSession *);
+bool DumpInjectedSource(IDiaSession *, const wchar_t *);
+bool DumpAllSourceFiles(IDiaSession *, IDiaSymbol *);
+bool DumpAllFPO(IDiaSession *);
+bool DumpFPO(IDiaSession *, DWORD);
+bool DumpFPO(IDiaSession *, IDiaSymbol *, const wchar_t *);
+bool DumpSymbolWithRVA(IDiaSession *, DWORD, const wchar_t *);
+bool DumpSymbolsWithRegEx(IDiaSymbol *, const wchar_t *, const wchar_t *);
+bool DumpSymbolWithChildren(IDiaSymbol *, const wchar_t *);
+bool DumpLines(IDiaSession *, DWORD);
+bool DumpLines(IDiaSession *, IDiaSymbol *, const wchar_t *);
+bool DumpType(IDiaSymbol *, const wchar_t *);
+bool DumpLinesForSourceFile(IDiaSession *, const wchar_t *, DWORD);
+bool DumpPublicSymbolsSorted(IDiaSession *, DWORD, DWORD, bool);
+bool DumpLabel(IDiaSession *, DWORD);
+bool DumpAnnotations(IDiaSession *, DWORD);
+bool DumpMapToSrc(IDiaSession *, DWORD);
+bool DumpMapFromSrc(IDiaSession *, DWORD);
+
+HRESULT GetTable(IDiaSession *, REFIID, void **);
+
+///////////////////////////////////////////////////////////////////
+// Functions defined in regs.cpp
+const wchar_t *SzNameC7Reg(USHORT, DWORD);
+const wchar_t *SzNameC7Reg(USHORT);
diff --git a/src/ToolBox/PdbTypeMatch/PdbTypeMatch.nativeproj b/src/ToolBox/PdbTypeMatch/PdbTypeMatch.nativeproj
new file mode 100644
index 0000000000..fb2f71b36c
--- /dev/null
+++ b/src/ToolBox/PdbTypeMatch/PdbTypeMatch.nativeproj
@@ -0,0 +1,59 @@
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="$(_NTDRIVE)$(_NTROOT)\ndp\clr\clr.props" />
+  <PropertyGroup>    
+    <ClCallingConvention>cdecl</ClCallingConvention>
+    <OutputName>pdbtypematch</OutputName>
+    <OutputPath>$(IntermediateOutputPath)</OutputPath>
+    <TargetType>PROGRAM</TargetType>
+    <LinkSubsystem>console</LinkSubsystem>
+    <EntryPoint>wmain</EntryPoint>
+    <UseStl>true</UseStl>     
+    <PCHHeader>stdafx.h</PCHHeader>
+    <EnableCxxPCHHeaders>true</EnableCxxPCHHeaders>
+    <PCHCompile>stdafx.cpp</PCHCompile>    
+    <PCHOutput>pdbtypematch.pch</PCHOutput>  
+    <LinkAdditionalOptions>$(LinkAdditionalOptions) /DYNAMICBASE /NXCOMPAT /ALLOWISOLATION</LinkAdditionalOptions>        
+    <CharacterSet>MultiByte</CharacterSet>    
+    <PreprocessorDefinitions>WIN32;%(PreprocessorDefinitions)</PreprocessorDefinitions>      
+    <OutputPath>$(IntermediateOutputPath)</OutputPath>
+    <UserIncludes>
+        .;
+        .\include;
+        $(UserIncludes);      
+    </UserIncludes>
+    <LinkUseCMT>true</LinkUseCMT>
+    <UseMsvcrt>false</UseMsvcrt>
+    <AlwaysUseReleaseLibCMT>true</AlwaysUseReleaseLibCMT>
+        <!--
+            This would build (cl.exe) with /MT switch instead of default /MTd. However it works either way, so we do not need it now.
+            It might be handy if we ever use some debug-only CRT features by accident.
+            <ClRuntimeLibrary>MultiThreaded</ClRuntimeLibrary>
+        -->    
+                                                     
+  </PropertyGroup>
+  <!--Leaf Project Items-->
+  <ItemGroup>
+    <TargetLib Include="$(SdkLibPath)\ole32.lib" />
+    <TargetLib Include="$(SdkLibPath)\oleaut32.lib" />
+    <TargetLib Include="$(SdkLibPath)\Shlwapi.lib" />   
+    <TargetLib Include="$(CrtLibPath)\comsupp.lib" />    
+  </ItemGroup>
+  <ItemGroup>
+    <Reference Include="DiaLib">
+      <ProjectReference>$(ClrSrcDirectory)toolbox\sos\diasdk\diasdk.nativeproj</ProjectReference>
+      <HintPath>$(ClrIntraLibPath)\DiaLib.dll</HintPath>
+    </Reference>
+  </ItemGroup>
+  <ItemGroup>       
+    <CppCompile Include="PrintSymbol.cpp" />
+    <CppCompile Include="regs.cpp" />
+    <CppCompile Include="PdbTypeMatch.cpp" />         
+  </ItemGroup> 
+
+  <ItemGroup>
+    <RCResourceFile Include="native.rc" />
+  </ItemGroup>
+  
+  <!--Import the targets-->
+  <Import Project="$(_NTDRIVE)$(_NTROOT)\ndp\clr\clr.targets" />
+</Project>
\ No newline at end of file
diff --git a/src/ToolBox/PdbTypeMatch/PrintSymbol.cpp b/src/ToolBox/PdbTypeMatch/PrintSymbol.cpp
new file mode 100644
index 0000000000..defd4549af
--- /dev/null
+++ b/src/ToolBox/PdbTypeMatch/PrintSymbol.cpp
@@ -0,0 +1,2251 @@
+// PrintSymbol.cpp : Defines the printing procedures for the symbols
+//
+// This is a part of the Debug Interface Access SDK 
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// This source code is only intended as a supplement to the
+// Debug Interface Access SDK and related electronic documentation 
+// provided with the library.
+// See these sources for detailed information regarding the
+// Debug Interface Access SDK API.
+//
+
+#include "stdafx.h"
+
+#include <malloc.h>
+
+#include "dia2.h"
+#include "regs.h"
+#include "PrintSymbol.h"
+#include <comdef.h>
+
+
+// Basic types
+const wchar_t * const rgBaseType[] =
+{
+  L"<NoType>",                         // btNoType = 0,
+  L"void",                             // btVoid = 1,
+  L"char",                             // btChar = 2,
+  L"wchar_t",                          // btWChar = 3,
+  L"signed char",
+  L"unsigned char",
+  L"int",                              // btInt = 6,
+  L"unsigned int",                     // btUInt = 7,
+  L"float",                            // btFloat = 8,
+  L"<BCD>",                            // btBCD = 9,
+  L"bool",                             // btBool = 10,
+  L"short",
+  L"unsigned short",
+  L"long",                             // btLong = 13,
+  L"unsigned long",                    // btULong = 14,
+  L"__int8",
+  L"__int16",
+  L"__int32",
+  L"__int64",
+  L"__int128",
+  L"unsigned __int8",
+  L"unsigned __int16",
+  L"unsigned __int32",
+  L"unsigned __int64",
+  L"unsigned __int128",
+  L"<currency>",                       // btCurrency = 25,
+  L"<date>",                           // btDate = 26,
+  L"VARIANT",                          // btVariant = 27,
+  L"<complex>",                        // btComplex = 28,
+  L"<bit>",                            // btBit = 29,
+  L"BSTR",                             // btBSTR = 30,
+  L"HRESULT"                           // btHresult = 31
+};
+
+// Tags returned by Dia
+const wchar_t * const rgTags[] =
+{
+  L"(SymTagNull)",                     // SymTagNull
+  L"Executable (Global)",              // SymTagExe
+  L"Compiland",                        // SymTagCompiland
+  L"CompilandDetails",                 // SymTagCompilandDetails
+  L"CompilandEnv",                     // SymTagCompilandEnv
+  L"Function",                         // SymTagFunction
+  L"Block",                            // SymTagBlock
+  L"Data",                             // SymTagData
+  L"Annotation",                       // SymTagAnnotation
+  L"Label",                            // SymTagLabel
+  L"PublicSymbol",                     // SymTagPublicSymbol
+  L"UserDefinedType",                  // SymTagUDT
+  L"Enum",                             // SymTagEnum
+  L"FunctionType",                     // SymTagFunctionType
+  L"PointerType",                      // SymTagPointerType
+  L"ArrayType",                        // SymTagArrayType
+  L"BaseType",                         // SymTagBaseType
+  L"Typedef",                          // SymTagTypedef
+  L"BaseClass",                        // SymTagBaseClass
+  L"Friend",                           // SymTagFriend
+  L"FunctionArgType",                  // SymTagFunctionArgType
+  L"FuncDebugStart",                   // SymTagFuncDebugStart
+  L"FuncDebugEnd",                     // SymTagFuncDebugEnd
+  L"UsingNamespace",                   // SymTagUsingNamespace
+  L"VTableShape",                      // SymTagVTableShape
+  L"VTable",                           // SymTagVTable
+  L"Custom",                           // SymTagCustom
+  L"Thunk",                            // SymTagThunk
+  L"CustomType",                       // SymTagCustomType
+  L"ManagedType",                      // SymTagManagedType
+  L"Dimension",                        // SymTagDimension
+  L"CallSite",                         // SymTagCallSite
+};
+
+
+// Processors
+const wchar_t * const rgFloatPackageStrings[] =
+{
+  L"hardware processor (80x87 for Intel processors)",    // CV_CFL_NDP
+  L"emulator",                                           // CV_CFL_EMU
+  L"altmath",                                            // CV_CFL_ALT
+  L"???"
+};
+
+const wchar_t * const rgProcessorStrings[] =
+{
+  L"8080",                             //  CV_CFL_8080
+  L"8086",                             //  CV_CFL_8086
+  L"80286",                            //  CV_CFL_80286
+  L"80386",                            //  CV_CFL_80386
+  L"80486",                            //  CV_CFL_80486
+  L"Pentium",                          //  CV_CFL_PENTIUM
+  L"Pentium Pro/Pentium II",           //  CV_CFL_PENTIUMII/CV_CFL_PENTIUMPRO
+  L"Pentium III",                      //  CV_CFL_PENTIUMIII
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"MIPS (Generic)",                   //  CV_CFL_MIPSR4000
+  L"MIPS16",                           //  CV_CFL_MIPS16
+  L"MIPS32",                           //  CV_CFL_MIPS32
+  L"MIPS64",                           //  CV_CFL_MIPS64
+  L"MIPS I",                           //  CV_CFL_MIPSI
+  L"MIPS II",                          //  CV_CFL_MIPSII
+  L"MIPS III",                         //  CV_CFL_MIPSIII
+  L"MIPS IV",                          //  CV_CFL_MIPSIV
+  L"MIPS V",                           //  CV_CFL_MIPSV
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"M68000",                           //  CV_CFL_M68000
+  L"M68010",                           //  CV_CFL_M68010
+  L"M68020",                           //  CV_CFL_M68020
+  L"M68030",                           //  CV_CFL_M68030
+  L"M68040",                           //  CV_CFL_M68040
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"Alpha 21064",                      // CV_CFL_ALPHA, CV_CFL_ALPHA_21064
+  L"Alpha 21164",                      // CV_CFL_ALPHA_21164
+  L"Alpha 21164A",                     // CV_CFL_ALPHA_21164A
+  L"Alpha 21264",                      // CV_CFL_ALPHA_21264
+  L"Alpha 21364",                      // CV_CFL_ALPHA_21364
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"PPC 601",                          // CV_CFL_PPC601
+  L"PPC 603",                          // CV_CFL_PPC603
+  L"PPC 604",                          // CV_CFL_PPC604
+  L"PPC 620",                          // CV_CFL_PPC620
+  L"PPC w/FP",                         // CV_CFL_PPCFP
+  L"PPC (Big Endian)",                 // CV_CFL_PPCBE
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"SH3",                              // CV_CFL_SH3
+  L"SH3E",                             // CV_CFL_SH3E
+  L"SH3DSP",                           // CV_CFL_SH3DSP
+  L"SH4",                              // CV_CFL_SH4
+  L"SHmedia",                          // CV_CFL_SHMEDIA
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"ARM3",                             // CV_CFL_ARM3
+  L"ARM4",                             // CV_CFL_ARM4
+  L"ARM4T",                            // CV_CFL_ARM4T
+  L"ARM5",                             // CV_CFL_ARM5
+  L"ARM5T",                            // CV_CFL_ARM5T
+  L"ARM6",                             // CV_CFL_ARM6
+  L"ARM (XMAC)",                       // CV_CFL_ARM_XMAC
+  L"ARM (WMMX)",                       // CV_CFL_ARM_WMMX
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"Omni",                             // CV_CFL_OMNI
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"Itanium",                          // CV_CFL_IA64, CV_CFL_IA64_1
+  L"Itanium (McKinley)",               // CV_CFL_IA64_2
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"CEE",                              // CV_CFL_CEE
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"AM33",                             // CV_CFL_AM33
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"M32R",                             // CV_CFL_M32R
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"TriCore",                          // CV_CFL_TRICORE
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"x64",                              // CV_CFL_X64
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"EBC",                              // CV_CFL_EBC
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"Thumb",                            // CV_CFL_THUMB
+};
+
+const wchar_t * const rgDataKind[] =
+{
+  L"Unknown",
+  L"Local",
+  L"Static Local",
+  L"Param",
+  L"Object Ptr",
+  L"File Static",
+  L"Global",
+  L"Member",
+  L"Static Member",
+  L"Constant",
+};
+
+const wchar_t * const rgUdtKind[] =
+{
+  L"struct",
+  L"class",
+  L"union",
+  L"enum",
+};
+
+const wchar_t * const rgAccess[] =
+{
+  L"",                     // No access specifier
+  L"private",
+  L"protected",
+  L"public"
+};
+
+const wchar_t * const rgCallingConvention[] =
+{
+  L"CV_CALL_NEAR_C      ",
+  L"CV_CALL_FAR_C       ",
+  L"CV_CALL_NEAR_PASCAL ",
+  L"CV_CALL_FAR_PASCAL  ",
+  L"CV_CALL_NEAR_FAST   ",
+  L"CV_CALL_FAR_FAST    ",
+  L"CV_CALL_SKIPPED     ",
+  L"CV_CALL_NEAR_STD    ",
+  L"CV_CALL_FAR_STD     ",
+  L"CV_CALL_NEAR_SYS    ",
+  L"CV_CALL_FAR_SYS     ",
+  L"CV_CALL_THISCALL    ",
+  L"CV_CALL_MIPSCALL    ",
+  L"CV_CALL_GENERIC     ",
+  L"CV_CALL_ALPHACALL   ",
+  L"CV_CALL_PPCCALL     ",
+  L"CV_CALL_SHCALL      ",
+  L"CV_CALL_ARMCALL     ",
+  L"CV_CALL_AM33CALL    ",
+  L"CV_CALL_TRICALL     ",
+  L"CV_CALL_SH5CALL     ",
+  L"CV_CALL_M32RCALL    ",
+  L"CV_CALL_RESERVED    "
+};
+
+const wchar_t * const rgLanguage[] =
+{
+  L"C",                                // CV_CFL_C
+  L"C++",                              // CV_CFL_CXX
+  L"FORTRAN",                          // CV_CFL_FORTRAN
+  L"MASM",                             // CV_CFL_MASM
+  L"Pascal",                           // CV_CFL_PASCAL
+  L"Basic",                            // CV_CFL_BASIC
+  L"COBOL",                            // CV_CFL_COBOL
+  L"LINK",                             // CV_CFL_LINK
+  L"CVTRES",                           // CV_CFL_CVTRES
+  L"CVTPGD",                           // CV_CFL_CVTPGD
+  L"C#",                               // CV_CFL_CSHARP
+  L"Visual Basic",                     // CV_CFL_VB
+  L"ILASM",                            // CV_CFL_ILASM
+  L"Java",                             // CV_CFL_JAVA
+  L"JScript",                          // CV_CFL_JSCRIPT
+  L"MSIL",                             // CV_CFL_MSIL
+};
+
+const wchar_t * const rgLocationTypeString[] =
+{
+  L"NULL",
+  L"static",
+  L"TLS",
+  L"RegRel",
+  L"ThisRel",
+  L"Enregistered",
+  L"BitField",
+  L"Slot",
+  L"IL Relative",
+  L"In MetaData",
+  L"Constant"
+};
+
+
+////////////////////////////////////////////////////////////
+// Print a public symbol info: name, VA, RVA, SEG:OFF
+//
+void PrintPublicSymbol(IDiaSymbol *pSymbol)
+{
+  DWORD dwSymTag;
+  DWORD dwRVA;
+  DWORD dwSeg;
+  DWORD dwOff;
+  BSTR bstrName;
+  
+  if (pSymbol->get_symTag(&dwSymTag) != S_OK) {
+    return;
+  }
+
+  if (pSymbol->get_relativeVirtualAddress(&dwRVA) != S_OK) {
+    dwRVA = 0xFFFFFFFF;
+  }
+
+  pSymbol->get_addressSection(&dwSeg);
+  pSymbol->get_addressOffset(&dwOff);
+
+  wprintf(L"%s: [%08X][%04X:%08X] ", rgTags[dwSymTag], dwRVA, dwSeg, dwOff);
+  
+  if (dwSymTag == SymTagThunk) {
+    if (pSymbol->get_name(&bstrName) == S_OK) {
+      wprintf(L"%s\n", bstrName);
+
+      SysFreeString(bstrName);
+    }
+
+    else {
+      if (pSymbol->get_targetRelativeVirtualAddress(&dwRVA) != S_OK) {
+        dwRVA = 0xFFFFFFFF;
+      }
+
+      pSymbol->get_targetSection(&dwSeg);
+      pSymbol->get_targetOffset(&dwOff);
+
+      wprintf(L"target -> [%08X][%04X:%08X]\n", dwRVA, dwSeg, dwOff);
+    }
+  }
+
+  else {
+    // must be a function or a data symbol
+
+    BSTR bstrUndname;
+
+    if (pSymbol->get_name(&bstrName) == S_OK) {
+      if (pSymbol->get_undecoratedName(&bstrUndname) == S_OK) {
+        wprintf(L"%s(%s)\n", bstrName, bstrUndname);
+
+        SysFreeString(bstrUndname);
+      }
+
+      else {
+        wprintf(L"%s\n", bstrName);
+      }
+
+      SysFreeString(bstrName);
+    }
+  }
+}
+
+////////////////////////////////////////////////////////////
+// Print a global symbol info: name, VA, RVA, SEG:OFF
+//
+void PrintGlobalSymbol(IDiaSymbol *pSymbol)
+{
+  DWORD dwSymTag;
+  DWORD dwRVA;
+  DWORD dwSeg;
+  DWORD dwOff;
+  
+  if (pSymbol->get_symTag(&dwSymTag) != S_OK) {
+    return;
+  }
+
+  if (pSymbol->get_relativeVirtualAddress(&dwRVA) != S_OK) {
+    dwRVA = 0xFFFFFFFF;
+  }
+
+  pSymbol->get_addressSection(&dwSeg);
+  pSymbol->get_addressOffset(&dwOff);
+
+  wprintf(L"%s: [%08X][%04X:%08X] ", rgTags[dwSymTag], dwRVA, dwSeg, dwOff);
+  
+  if (dwSymTag == SymTagThunk) {
+    BSTR bstrName;
+
+    if (pSymbol->get_name(&bstrName) == S_OK) {
+      wprintf(L"%s\n", bstrName);
+
+      SysFreeString(bstrName);
+    }
+
+    else {
+      if (pSymbol->get_targetRelativeVirtualAddress(&dwRVA) != S_OK) {
+        dwRVA = 0xFFFFFFFF;
+      }
+
+      pSymbol->get_targetSection(&dwSeg);
+      pSymbol->get_targetOffset(&dwOff);
+      wprintf(L"target -> [%08X][%04X:%08X]\n", dwRVA, dwSeg, dwOff);
+    }
+  }
+
+  else {
+    BSTR bstrName;
+    BSTR bstrUndname;
+
+    if (pSymbol->get_name(&bstrName) == S_OK) {
+      if (pSymbol->get_undecoratedName(&bstrUndname) == S_OK) {
+        wprintf(L"%s(%s)\n", bstrName, bstrUndname);
+
+        SysFreeString(bstrUndname);
+      }
+
+      else {
+        wprintf(L"%s\n", bstrName);
+      }
+
+      SysFreeString(bstrName);
+    }
+  }
+}
+
+////////////////////////////////////////////////////////////
+// Print a callsite symbol info: SEG:OFF, RVA, type
+//
+void PrintCallSiteInfo(IDiaSymbol *pSymbol)
+{
+  DWORD dwISect, dwOffset;
+  if (pSymbol->get_addressSection(&dwISect) == S_OK &&
+    pSymbol->get_addressOffset(&dwOffset) == S_OK) {
+    wprintf(L"[0x%04x:0x%08x]  ", dwISect, dwOffset);
+  }
+
+  DWORD rva;
+  if (pSymbol->get_relativeVirtualAddress(&rva) == S_OK) {
+    wprintf(L"0x%08X  ", rva);
+  }
+
+  IDiaSymbol *pFuncType;
+  if (pSymbol->get_type(&pFuncType) == S_OK) {
+    DWORD tag;
+    if (pFuncType->get_symTag(&tag) == S_OK) {
+      switch(tag)
+      {
+        case SymTagFunctionType:
+          PrintFunctionType(pSymbol);
+          break;
+        case SymTagPointerType:
+          PrintFunctionType(pFuncType);
+          break;
+        default:
+          wprintf(L"???\n");
+          break;
+      }
+    }
+    pFuncType->Release();
+  }
+}
+
+////////////////////////////////////////////////////////////
+// Print a symbol info: name, type etc.
+//
+void PrintSymbol(IDiaSymbol *pSymbol, DWORD dwIndent)
+{
+  IDiaSymbol *pType;
+  DWORD dwSymTag;
+  ULONGLONG ulLen;
+  
+  if (pSymbol->get_symTag(&dwSymTag) != S_OK) {
+    wprintf(L"ERROR - PrintSymbol get_symTag() failed\n");
+    return;
+  }
+
+  if (dwSymTag == SymTagFunction) {
+    putwchar(L'\n');
+  }
+
+  PrintSymTag(dwSymTag);
+
+  for (DWORD i = 0; i < dwIndent; i++) {
+    putwchar(L' ');
+  }
+
+  switch (dwSymTag) {
+    case SymTagCompilandDetails:
+      PrintCompilandDetails(pSymbol);
+      break;
+
+    case SymTagCompilandEnv:
+      PrintCompilandEnv(pSymbol);
+      break;
+
+    case SymTagData:
+      PrintData(pSymbol, dwIndent + 2);
+      break;
+
+    case SymTagFunction:
+    case SymTagBlock:
+      PrintLocation(pSymbol);
+
+      if (pSymbol->get_length(&ulLen) == S_OK) {
+        wprintf(L", len = %08X, ", ulLen);
+      }
+
+      if (dwSymTag == SymTagFunction) {
+        DWORD dwCall;
+
+        if (pSymbol->get_callingConvention(&dwCall) == S_OK) {
+          wprintf(L", %s", SafeDRef(rgCallingConvention, dwCall));
+        }
+      }
+
+      PrintUndName(pSymbol);
+      putwchar(L'\n');
+
+      if (dwSymTag == SymTagFunction)
+      {
+        BOOL f;
+
+        for (DWORD i = 0; i < dwIndent; i++) {
+          putwchar(L' ');
+        }
+        wprintf(L"                 Function attribute:");
+
+        if ((pSymbol->get_isCxxReturnUdt(&f) == S_OK) && f) {
+          wprintf(L" return user defined type (C++ style)");
+        }
+        if ((pSymbol->get_constructor(&f) == S_OK) && f) {
+          wprintf(L" instance constructor");
+        }
+        if ((pSymbol->get_isConstructorVirtualBase(&f) == S_OK) && f) {
+          wprintf(L" instance constructor of a class with virtual base");
+        }
+        putwchar (L'\n');
+
+        for (DWORD i = 0; i < dwIndent; i++) {
+          putwchar(L' ');
+        }
+        wprintf(L"                 Function info:");
+
+        if ((pSymbol->get_hasAlloca(&f) == S_OK) && f) {
+          wprintf(L" alloca");
+        }
+
+        if ((pSymbol->get_hasSetJump(&f) == S_OK) && f) {
+          wprintf(L" setjmp");
+        }
+
+        if ((pSymbol->get_hasLongJump(&f) == S_OK) && f) {
+          wprintf(L" longjmp");
+        }
+
+        if ((pSymbol->get_hasInlAsm(&f) == S_OK) && f) {
+          wprintf(L" inlasm");
+        }
+
+        if ((pSymbol->get_hasEH(&f) == S_OK) && f) {
+          wprintf(L" eh");
+        }
+
+        if ((pSymbol->get_inlSpec(&f) == S_OK) && f) {
+          wprintf(L" inl_specified");
+        }
+
+        if ((pSymbol->get_hasSEH(&f) == S_OK) && f) {
+          wprintf(L" seh");
+        }
+
+        if ((pSymbol->get_isNaked(&f) == S_OK) && f) {
+          wprintf(L" naked");
+        }
+
+        if ((pSymbol->get_hasSecurityChecks(&f) == S_OK) && f) {
+          wprintf(L" gschecks");
+        }
+
+        if ((pSymbol->get_isSafeBuffers(&f) == S_OK) && f) {
+          wprintf(L" safebuffers");
+        }
+
+        if ((pSymbol->get_hasEHa(&f) == S_OK) && f) {
+          wprintf(L" asyncheh");
+        }
+
+        if ((pSymbol->get_noStackOrdering(&f) == S_OK) && f) {
+          wprintf(L" gsnostackordering");
+        }
+
+        if ((pSymbol->get_wasInlined(&f) == S_OK) && f) {
+          wprintf(L" wasinlined");
+        }
+
+        if ((pSymbol->get_strictGSCheck(&f) == S_OK) && f) {
+          wprintf(L" strict_gs_check");
+        }
+
+        putwchar(L'\n');
+      }
+
+      IDiaEnumSymbols *pEnumChildren;
+
+      if (SUCCEEDED(pSymbol->findChildren(SymTagNull, NULL, nsNone, &pEnumChildren))) {
+        IDiaSymbol *pChild;
+        ULONG celt = 0;
+
+        while (SUCCEEDED(pEnumChildren->Next(1, &pChild, &celt)) && (celt == 1)) {
+          PrintSymbol(pChild, dwIndent + 2);
+          pChild->Release();
+        }
+
+        pEnumChildren->Release();
+      }
+      return;
+
+    case SymTagAnnotation:
+      PrintLocation(pSymbol);
+      putwchar(L'\n');
+      break;
+
+    case SymTagLabel:
+      PrintLocation(pSymbol);
+      wprintf(L", ");
+      PrintName(pSymbol);
+      break;
+
+    case SymTagEnum:
+    case SymTagTypedef:
+    case SymTagUDT:
+    case SymTagBaseClass:
+      PrintUDT(pSymbol);
+      break;
+
+    case SymTagFuncDebugStart:
+    case SymTagFuncDebugEnd:
+      PrintLocation(pSymbol);
+      break;
+
+    case SymTagFunctionArgType:
+    case SymTagFunctionType:
+    case SymTagPointerType:
+    case SymTagArrayType:
+    case SymTagBaseType:
+      if (pSymbol->get_type(&pType) == S_OK) {
+        PrintType(pType);
+        pType->Release();
+      }
+
+      putwchar(L'\n');
+      break;
+
+    case SymTagThunk:
+      PrintThunk(pSymbol);
+      break;
+
+    case SymTagCallSite:
+      PrintCallSiteInfo(pSymbol);
+      break;
+        
+    default:
+      PrintName(pSymbol);
+
+      IDiaSymbol *pType;
+
+      if (pSymbol->get_type(&pType) == S_OK) {
+        wprintf(L" has type ");
+        PrintType(pType);
+        pType->Release();
+      }
+  }
+
+  if ((dwSymTag == SymTagUDT) || (dwSymTag == SymTagAnnotation)) {
+    IDiaEnumSymbols *pEnumChildren;
+
+    putwchar(L'\n');
+
+    if (SUCCEEDED(pSymbol->findChildren(SymTagNull, NULL, nsNone, &pEnumChildren))) {
+      IDiaSymbol *pChild;
+      ULONG celt = 0;
+
+      while (SUCCEEDED(pEnumChildren->Next(1, &pChild, &celt)) && (celt == 1)) {
+        PrintSymbol(pChild, dwIndent + 2);
+        pChild->Release();
+      }
+
+      pEnumChildren->Release();
+    }
+  }
+  putwchar(L'\n');
+}
+
+////////////////////////////////////////////////////////////
+// Print the string coresponding to the symbol's tag property
+//
+void PrintSymTag(DWORD dwSymTag)
+{
+  wprintf(L"%-15s: ", SafeDRef(rgTags, dwSymTag));
+}
+
+////////////////////////////////////////////////////////////
+// Print the name of the symbol
+//
+void PrintName(IDiaSymbol *pSymbol)
+{
+  BSTR bstrName;
+  BSTR bstrUndName;
+
+  if (pSymbol->get_name(&bstrName) != S_OK) {
+    wprintf(L"(none)");
+    return;
+  }
+
+  if (pSymbol->get_undecoratedName(&bstrUndName) == S_OK) {
+    if (wcscmp(bstrName, bstrUndName) == 0) {
+      wprintf(L"%s", bstrName);
+    }
+
+    else {
+      wprintf(L"%s(%s)", bstrUndName, bstrName);
+    }
+
+    SysFreeString(bstrUndName);
+  }
+
+  else {
+    wprintf(L"%s", bstrName);
+  }
+
+  SysFreeString(bstrName);
+}
+
+void GetSymbolName(std::wstring& symbolName, IDiaSymbol *pSymbol)
+{
+    BSTR bstrName;
+    BSTR bstrUndName;
+
+    if (pSymbol->get_name(&bstrName) != S_OK) {
+    symbolName.clear();
+    return;
+    }
+
+    if (pSymbol->get_undecoratedName(&bstrUndName) == S_OK) {
+    if (wcscmp(bstrName, bstrUndName) == 0) 
+    {
+        symbolName= _bstr_t(bstrName);
+    }
+    else
+    {
+        symbolName= _bstr_t(bstrUndName);
+    }
+
+        SysFreeString(bstrUndName);
+    }
+
+    else 
+    {
+        symbolName= _bstr_t(bstrName);
+    }
+
+    SysFreeString(bstrName);
+}
+
+////////////////////////////////////////////////////////////
+// Print the undecorated name of the symbol
+//  - only SymTagFunction, SymTagData and SymTagPublicSymbol
+//    can have this property set
+//
+void PrintUndName(IDiaSymbol *pSymbol)
+{
+  BSTR bstrName;
+
+  if (pSymbol->get_undecoratedName(&bstrName) != S_OK) {
+    if (pSymbol->get_name(&bstrName) == S_OK) {
+      // Print the name of the symbol instead
+
+      wprintf(L"%s", (bstrName[0] != L'\0') ? bstrName : L"(none)");
+
+      SysFreeString(bstrName);
+    }
+
+    else {
+      wprintf(L"(none)");
+    }
+
+    return;
+  }
+
+  if (bstrName[0] != L'\0') {
+    wprintf(L"%s", bstrName);
+  }
+
+  SysFreeString(bstrName);
+}
+
+////////////////////////////////////////////////////////////
+// Print a SymTagThunk symbol's info
+//
+void PrintThunk(IDiaSymbol *pSymbol)
+{
+  DWORD dwRVA;
+  DWORD dwISect;
+  DWORD dwOffset;
+
+  if ((pSymbol->get_relativeVirtualAddress(&dwRVA) == S_OK) &&
+      (pSymbol->get_addressSection(&dwISect) == S_OK) &&
+      (pSymbol->get_addressOffset(&dwOffset) == S_OK)) {
+    wprintf(L"[%08X][%04X:%08X]", dwRVA, dwISect, dwOffset);
+  }
+
+  if ((pSymbol->get_targetSection(&dwISect) == S_OK) &&
+      (pSymbol->get_targetOffset(&dwOffset) == S_OK) &&
+      (pSymbol->get_targetRelativeVirtualAddress(&dwRVA) == S_OK)) {
+    wprintf(L", target [%08X][%04X:%08X] ", dwRVA, dwISect, dwOffset);
+  }
+
+  else {
+    wprintf(L", target ");
+
+    PrintName(pSymbol);
+  }
+}
+
+////////////////////////////////////////////////////////////
+// Print the compiland/module details: language, platform...
+//
+void PrintCompilandDetails(IDiaSymbol *pSymbol)
+{
+  DWORD dwLanguage;
+
+  if (pSymbol->get_language(&dwLanguage) == S_OK) {
+    wprintf(L"\n\tLanguage: %s\n", SafeDRef(rgLanguage, dwLanguage));
+  }
+
+  DWORD dwPlatform;
+
+  if (pSymbol->get_platform(&dwPlatform) == S_OK) {
+    wprintf(L"\tTarget processor: %s\n", SafeDRef(rgProcessorStrings, dwPlatform));
+  }
+
+  BOOL fEC;
+
+  if (pSymbol->get_editAndContinueEnabled(&fEC) == S_OK) {
+    if (fEC) {
+      wprintf(L"\tCompiled for edit and continue: yes\n");
+    }
+
+    else {
+      wprintf(L"\tCompiled for edit and continue: no\n");
+    }
+  }
+
+  BOOL fDbgInfo;
+
+  if (pSymbol->get_hasDebugInfo(&fDbgInfo) == S_OK) {
+    if (fDbgInfo) {
+      wprintf(L"\tCompiled without debugging info: no\n");
+    }
+
+    else {
+      wprintf(L"\tCompiled without debugging info: yes\n");
+    }
+  }
+
+  BOOL fLTCG;
+
+  if (pSymbol->get_isLTCG(&fLTCG) == S_OK) {
+    if (fLTCG) {
+      wprintf(L"\tCompiled with LTCG: yes\n");
+    }
+
+    else {
+      wprintf(L"\tCompiled with LTCG: no\n");
+    }
+  }
+
+  BOOL fDataAlign;
+
+  if (pSymbol->get_isDataAligned(&fDataAlign) == S_OK) {
+    if (fDataAlign) {
+      wprintf(L"\tCompiled with /bzalign: no\n");
+    }
+
+    else {
+      wprintf(L"\tCompiled with /bzalign: yes\n");
+    }
+  }
+
+  BOOL fManagedPresent;
+
+  if (pSymbol->get_hasManagedCode(&fManagedPresent) == S_OK) {
+    if (fManagedPresent) {
+      wprintf(L"\tManaged code present: yes\n");
+    }
+
+    else {
+      wprintf(L"\tManaged code present: no\n");
+    }
+  }
+
+  BOOL fSecurityChecks;
+
+  if (pSymbol->get_hasSecurityChecks(&fSecurityChecks) == S_OK) {
+    if (fSecurityChecks) {
+      wprintf(L"\tCompiled with /GS: yes\n");
+    }
+
+    else {
+      wprintf(L"\tCompiled with /GS: no\n");
+    }
+  }
+
+  BOOL fHotPatch;
+
+  if (pSymbol->get_isHotpatchable(&fHotPatch) == S_OK) {
+    if (fHotPatch) {
+      wprintf(L"\tCompiled with /hotpatch: yes\n");
+    }
+
+    else {
+      wprintf(L"\tCompiled with /hotpatch: no\n");
+    }
+  }
+
+  BOOL fCVTCIL;
+
+  if (pSymbol->get_isCVTCIL(&fCVTCIL) == S_OK) {
+    if (fCVTCIL) {
+      wprintf(L"\tConverted by CVTCIL: yes\n");
+    }
+
+    else {
+      wprintf(L"\tConverted by CVTCIL: no\n");
+    }
+  }
+
+  BOOL fMSILModule;
+
+  if (pSymbol->get_isMSILNetmodule(&fMSILModule) == S_OK) {
+    if (fMSILModule) {
+      wprintf(L"\tMSIL module: yes\n");
+    }
+
+    else {
+      wprintf(L"\tMSIL module: no\n");
+    }
+  }
+
+  DWORD dwVerMajor;
+  DWORD dwVerMinor;
+  DWORD dwVerBuild;
+  DWORD dwVerQFE;
+
+  if ((pSymbol->get_frontEndMajor(&dwVerMajor) == S_OK) &&
+      (pSymbol->get_frontEndMinor(&dwVerMinor) == S_OK) &&
+      (pSymbol->get_frontEndBuild(&dwVerBuild) == S_OK)) {
+    wprintf(L"\tFrontend Version: Major = %u, Minor = %u, Build = %u",
+            dwVerMajor,
+            dwVerMinor,
+            dwVerBuild);
+
+    if (pSymbol->get_frontEndQFE(&dwVerQFE) == S_OK) {
+      wprintf(L", QFE = %u", dwVerQFE);
+    }
+
+    putwchar(L'\n');
+  }
+
+  if ((pSymbol->get_backEndMajor(&dwVerMajor) == S_OK) &&
+      (pSymbol->get_backEndMinor(&dwVerMinor) == S_OK) &&
+      (pSymbol->get_backEndBuild(&dwVerBuild) == S_OK)) {
+    wprintf(L"\tBackend Version: Major = %u, Minor = %u, Build = %u",
+            dwVerMajor,
+            dwVerMinor,
+            dwVerBuild);
+
+    if (pSymbol->get_backEndQFE(&dwVerQFE) == S_OK) {
+      wprintf(L", QFE = %u", dwVerQFE);
+    }
+
+    putwchar(L'\n');
+  }
+
+  BSTR bstrCompilerName;
+
+  if (pSymbol->get_compilerName(&bstrCompilerName) == S_OK) {
+    if (bstrCompilerName != NULL) {
+      wprintf(L"\tVersion string: %s", bstrCompilerName);
+
+      SysFreeString(bstrCompilerName);
+    }
+  }
+
+  putwchar(L'\n');
+}
+
+////////////////////////////////////////////////////////////
+// Print the compilan/module env
+//
+void PrintCompilandEnv(IDiaSymbol *pSymbol)
+{
+  PrintName(pSymbol);
+  wprintf(L" =");
+
+  VARIANT vt = { VT_EMPTY };
+
+  if (pSymbol->get_value(&vt) == S_OK) {
+    PrintVariant(vt);
+    VariantClear((VARIANTARG *) &vt);
+  }
+}
+
+////////////////////////////////////////////////////////////
+// Print a string corespondig to a location type
+//
+void PrintLocation(IDiaSymbol *pSymbol)
+{
+  DWORD dwLocType;
+  DWORD dwRVA, dwSect, dwOff, dwReg, dwBitPos, dwSlot;
+  LONG lOffset;
+  ULONGLONG ulLen;
+  VARIANT vt = { VT_EMPTY };
+
+  if (pSymbol->get_locationType(&dwLocType) != S_OK) {
+    // It must be a symbol in optimized code
+
+    wprintf(L"symbol in optmized code");
+    return;
+  }
+
+  switch (dwLocType) {
+    case LocIsStatic:
+      if ((pSymbol->get_relativeVirtualAddress(&dwRVA) == S_OK) &&
+          (pSymbol->get_addressSection(&dwSect) == S_OK) &&
+          (pSymbol->get_addressOffset(&dwOff) == S_OK)) {
+        wprintf(L"%s, [%08X][%04X:%08X]", SafeDRef(rgLocationTypeString, dwLocType), dwRVA, dwSect, dwOff);
+      }
+      break;
+
+    case LocIsTLS:
+    case LocInMetaData:
+    case LocIsIlRel:
+      if ((pSymbol->get_relativeVirtualAddress(&dwRVA) == S_OK) &&
+          (pSymbol->get_addressSection(&dwSect) == S_OK) &&
+          (pSymbol->get_addressOffset(&dwOff) == S_OK)) {
+        wprintf(L"%s, [%08X][%04X:%08X]", SafeDRef(rgLocationTypeString, dwLocType), dwRVA, dwSect, dwOff);
+      }
+      break;
+
+    case LocIsRegRel:
+      if ((pSymbol->get_registerId(&dwReg) == S_OK) &&
+          (pSymbol->get_offset(&lOffset) == S_OK)) {
+        wprintf(L"%s Relative, [%08X]", SzNameC7Reg((USHORT) dwReg), lOffset);
+      }
+      break;
+
+    case LocIsThisRel:
+      if (pSymbol->get_offset(&lOffset) == S_OK) {
+        wprintf(L"this+0x%X", lOffset);
+      }
+      break;
+
+    case LocIsBitField:
+      if ((pSymbol->get_offset(&lOffset) == S_OK) &&
+          (pSymbol->get_bitPosition(&dwBitPos) == S_OK) &&
+          (pSymbol->get_length(&ulLen) == S_OK)) {
+        wprintf(L"this(bf)+0x%X:0x%X len(0x%X)", lOffset, dwBitPos, ulLen);
+      }
+      break;
+
+    case LocIsEnregistered:
+      if (pSymbol->get_registerId(&dwReg) == S_OK) {
+        wprintf(L"enregistered %s", SzNameC7Reg((USHORT) dwReg));
+      }
+      break;
+
+    case LocIsSlot:
+      if (pSymbol->get_slot(&dwSlot) == S_OK) {
+        wprintf(L"%s, [%08X]", SafeDRef(rgLocationTypeString, dwLocType), dwSlot);
+      }
+      break;
+
+    case LocIsConstant:
+      wprintf(L"constant");
+
+      if (pSymbol->get_value(&vt) == S_OK) {
+        PrintVariant(vt);
+        VariantClear((VARIANTARG *) &vt);
+      }
+      break;
+
+    case LocIsNull:
+      break;
+
+    default :
+      wprintf(L"Error - invalid location type: 0x%X", dwLocType);
+      break;
+    }
+}
+
+////////////////////////////////////////////////////////////
+// Print the type, value and the name of a const symbol
+//
+void PrintConst(IDiaSymbol *pSymbol)
+{
+  PrintSymbolType(pSymbol);
+
+  VARIANT vt = { VT_EMPTY };
+
+  if (pSymbol->get_value(&vt) == S_OK) {
+    PrintVariant(vt);
+    VariantClear((VARIANTARG *) &vt);
+  }
+
+  PrintName(pSymbol);
+}
+
+////////////////////////////////////////////////////////////
+// Print the name and the type of an user defined type
+//
+void PrintUDT(IDiaSymbol *pSymbol)
+{
+  PrintName(pSymbol);
+  PrintSymbolType(pSymbol);
+}
+
+////////////////////////////////////////////////////////////
+// Print a string representing the type of a symbol
+//
+void PrintSymbolType(IDiaSymbol *pSymbol)
+{
+  IDiaSymbol *pType;
+
+  if (pSymbol->get_type(&pType) == S_OK) {
+    wprintf(L", Type: ");
+    PrintType(pType);
+    pType->Release();
+  }
+}
+
+////////////////////////////////////////////////////////////
+// Print the information details for a type symbol
+//
+void PrintType(IDiaSymbol *pSymbol)
+{
+  IDiaSymbol *pBaseType;
+  IDiaEnumSymbols *pEnumSym;
+  IDiaSymbol *pSym;
+  DWORD dwTag;
+  BSTR bstrName;
+  DWORD dwInfo;
+  BOOL bSet;
+  DWORD dwRank;
+  LONG lCount = 0;
+  ULONG celt = 1;
+
+  if (pSymbol->get_symTag(&dwTag) != S_OK) {
+    wprintf(L"ERROR - can't retrieve the symbol's SymTag\n");
+    return;
+  }
+
+  if (pSymbol->get_name(&bstrName) != S_OK) {
+    bstrName = NULL;
+  }
+
+  if (dwTag != SymTagPointerType) {
+    if ((pSymbol->get_constType(&bSet) == S_OK) && bSet) {
+      wprintf(L"const ");
+    }
+
+    if ((pSymbol->get_volatileType(&bSet) == S_OK) && bSet) {
+       wprintf(L"volatile ");
+    }
+
+    if ((pSymbol->get_unalignedType(&bSet) == S_OK) && bSet) {
+      wprintf(L"__unaligned ");
+    }
+  }
+
+  ULONGLONG ulLen;
+
+  pSymbol->get_length(&ulLen);
+
+  switch (dwTag) {
+    case SymTagUDT:
+      PrintUdtKind(pSymbol);
+      PrintName(pSymbol);
+      break;
+
+    case SymTagEnum:
+      wprintf(L"enum ");
+      PrintName(pSymbol);
+      break;
+
+    case SymTagFunctionType:
+      wprintf(L"function ");
+      break;
+
+    case SymTagPointerType:
+      if (pSymbol->get_type(&pBaseType) != S_OK) {
+        wprintf(L"ERROR - SymTagPointerType get_type");
+        if (bstrName != NULL) {
+          SysFreeString(bstrName);
+        }
+        return;
+      }
+
+      PrintType(pBaseType);
+      pBaseType->Release();
+
+      if ((pSymbol->get_reference(&bSet) == S_OK) && bSet) {
+        wprintf(L" &");
+      }
+
+      else {
+        wprintf(L" *");
+      }
+
+      if ((pSymbol->get_constType(&bSet) == S_OK) && bSet) {
+        wprintf(L" const");
+      }
+
+      if ((pSymbol->get_volatileType(&bSet) == S_OK) && bSet) {
+        wprintf(L" volatile");
+      }
+
+      if ((pSymbol->get_unalignedType(&bSet) == S_OK) && bSet) {
+        wprintf(L" __unaligned");
+      }
+      break;
+
+    case SymTagArrayType:
+      if (pSymbol->get_type(&pBaseType) == S_OK) {
+        PrintType(pBaseType);
+
+        if (pSymbol->get_rank(&dwRank) == S_OK) {
+          if (SUCCEEDED(pSymbol->findChildren(SymTagDimension, NULL, nsNone, &pEnumSym)) && (pEnumSym != NULL)) {
+            while (SUCCEEDED(pEnumSym->Next(1, &pSym, &celt)) && (celt == 1)) {
+              IDiaSymbol *pBound;
+
+              wprintf(L"[");
+
+              if (pSym->get_lowerBound(&pBound) == S_OK) {
+                PrintBound(pBound);
+
+                wprintf(L"..");
+
+                pBound->Release();
+              }
+
+              pBound = NULL;
+
+              if (pSym->get_upperBound(&pBound) == S_OK) {
+                PrintBound(pBound);
+
+                pBound->Release();
+              }
+
+              pSym->Release();
+              pSym = NULL;
+
+              wprintf(L"]");
+            }
+
+            pEnumSym->Release();
+          }
+        }
+
+        else if (SUCCEEDED(pSymbol->findChildren(SymTagCustomType, NULL, nsNone, &pEnumSym)) &&
+                 (pEnumSym != NULL) &&
+                 (pEnumSym->get_Count(&lCount) == S_OK) &&
+                 (lCount > 0)) {
+          while (SUCCEEDED(pEnumSym->Next(1, &pSym, &celt)) && (celt == 1)) {
+            wprintf(L"[");
+            PrintType(pSym);
+            wprintf(L"]");
+
+            pSym->Release();
+          }
+
+          pEnumSym->Release();
+        }
+
+        else {
+          DWORD dwCountElems;
+          ULONGLONG ulLenArray;
+          ULONGLONG ulLenElem;
+
+          if (pSymbol->get_count(&dwCountElems) == S_OK) {
+            wprintf(L"[0x%X]", dwCountElems);
+          }
+
+          else if ((pSymbol->get_length(&ulLenArray) == S_OK) &&
+                   (pBaseType->get_length(&ulLenElem) == S_OK)) {
+            if (ulLenElem == 0) {
+              wprintf(L"[0x%lX]", ulLenArray);
+            }
+
+            else {
+              wprintf(L"[0x%lX]", ulLenArray/ulLenElem);
+            }
+          }
+        }
+
+        pBaseType->Release();
+      }
+
+      else {
+        wprintf(L"ERROR - SymTagArrayType get_type\n");
+        if (bstrName != NULL) {
+          SysFreeString(bstrName);
+        }
+        return;
+      }
+      break;
+
+    case SymTagBaseType:
+      if (pSymbol->get_baseType(&dwInfo) != S_OK) {
+        wprintf(L"SymTagBaseType get_baseType\n");
+        if (bstrName != NULL) {
+          SysFreeString(bstrName);
+        }
+        return;
+      }
+
+      switch (dwInfo) {
+        case btUInt :
+          wprintf(L"unsigned ");
+
+        // Fall through
+
+        case btInt :
+          switch (ulLen) {
+            case 1:
+              if (dwInfo == btInt) {
+                wprintf(L"signed ");
+              }
+
+              wprintf(L"char");
+              break;
+
+            case 2:
+              wprintf(L"short");
+              break;
+
+            case 4:
+              wprintf(L"int");
+              break;
+
+            case 8:
+              wprintf(L"__int64");
+              break;
+          }
+
+          dwInfo = 0xFFFFFFFF;
+          break;
+
+        case btFloat :
+          switch (ulLen) {
+            case 4:
+              wprintf(L"float");
+              break;
+
+            case 8:
+              wprintf(L"double");
+              break;
+          }
+
+          dwInfo = 0xFFFFFFFF;
+          break;
+      }
+
+      if (dwInfo == 0xFFFFFFFF) {
+         break;
+      }
+
+      wprintf(L"%s", rgBaseType[dwInfo]);
+      break;
+
+    case SymTagTypedef:
+      PrintName(pSymbol);
+      break;
+
+    case SymTagCustomType:
+      {
+        DWORD idOEM, idOEMSym;
+        DWORD cbData = 0;
+        DWORD count;
+
+        if (pSymbol->get_oemId(&idOEM) == S_OK) {
+          wprintf(L"OEMId = %X, ", idOEM);
+        }
+
+        if (pSymbol->get_oemSymbolId(&idOEMSym) == S_OK) {
+          wprintf(L"SymbolId = %X, ", idOEMSym);
+        }
+
+        if (pSymbol->get_types(0, &count, NULL) == S_OK) {
+          IDiaSymbol** rgpDiaSymbols = (IDiaSymbol**) _alloca(sizeof(IDiaSymbol *) * count);
+
+          if (pSymbol->get_types(count, &count, rgpDiaSymbols) == S_OK) {
+            for (ULONG i = 0; i < count; i++) {
+              PrintType(rgpDiaSymbols[i]);
+              rgpDiaSymbols[i]->Release();
+            }
+          }
+        }
+
+        // print custom data
+
+        if ((pSymbol->get_dataBytes(cbData, &cbData, NULL) == S_OK) && (cbData != 0)) {
+          wprintf(L", Data: ");
+
+          BYTE *pbData = new BYTE[cbData];
+
+          pSymbol->get_dataBytes(cbData, &cbData, pbData);
+
+          for (ULONG i = 0; i < cbData; i++) {
+            wprintf(L"0x%02X ", pbData[i]);
+          }
+
+          delete [] pbData;
+        }
+      }
+      break;
+
+    case SymTagData: // This really is member data, just print its location
+      PrintLocation(pSymbol);
+      break;
+  }
+
+  if (bstrName != NULL) {
+    SysFreeString(bstrName);
+  }
+}
+
+////////////////////////////////////////////////////////////
+// Print bound information
+//
+void PrintBound(IDiaSymbol *pSymbol)
+{
+  DWORD dwTag = 0;
+  DWORD dwKind;
+
+  if (pSymbol->get_symTag(&dwTag) != S_OK) {
+    wprintf(L"ERROR - PrintBound() get_symTag");
+    return;
+  }
+
+  if (pSymbol->get_locationType(&dwKind) != S_OK) {
+    wprintf(L"ERROR - PrintBound() get_locationType");
+    return;
+  }
+
+  if (dwTag == SymTagData && dwKind == LocIsConstant) {
+    VARIANT v;
+
+    if (pSymbol->get_value(&v) == S_OK) {
+      PrintVariant(v);
+      VariantClear((VARIANTARG *) &v);
+    }
+  }
+
+  else {
+    PrintName(pSymbol);
+  }
+}
+
+////////////////////////////////////////////////////////////
+//
+void PrintData(IDiaSymbol *pSymbol, DWORD dwIndent)
+{
+  PrintLocation(pSymbol);
+
+  DWORD dwDataKind;
+  if (pSymbol->get_dataKind(&dwDataKind) != S_OK) {
+    wprintf(L"ERROR - PrintData() get_dataKind");
+    return;
+  }
+
+  wprintf(L", %s", SafeDRef(rgDataKind, dwDataKind));
+  PrintSymbolType(pSymbol);
+
+  wprintf(L", ");
+  PrintName(pSymbol);
+}
+
+////////////////////////////////////////////////////////////
+// Print a VARIANT
+//
+void PrintVariant(VARIANT var)
+{
+  switch (var.vt) {
+    case VT_UI1:
+    case VT_I1:
+      wprintf(L" 0x%X", var.bVal);
+      break;
+
+    case VT_I2:
+    case VT_UI2:
+    case VT_BOOL:
+      wprintf(L" 0x%X", var.iVal);
+      break;
+
+    case VT_I4:
+    case VT_UI4:
+    case VT_INT:
+    case VT_UINT:
+    case VT_ERROR:
+      wprintf(L" 0x%X", var.lVal);
+      break;
+
+    case VT_R4:
+      wprintf(L" %g", var.fltVal);
+      break;
+
+    case VT_R8:
+      wprintf(L" %g", var.dblVal);
+      break;
+
+    case VT_BSTR:
+      wprintf(L" \"%s\"", var.bstrVal);
+      break;
+
+    default:
+      wprintf(L" ??");
+    }
+}
+
+////////////////////////////////////////////////////////////
+// Print a string corresponding to a UDT kind
+//
+void PrintUdtKind(IDiaSymbol *pSymbol)
+{
+  DWORD dwKind = 0;
+
+  if (pSymbol->get_udtKind(&dwKind) == S_OK) {
+    wprintf(L"%s ", rgUdtKind[dwKind]);
+  }
+}
+
+////////////////////////////////////////////////////////////
+// Print type informations is details
+//
+void PrintTypeInDetail(IDiaSymbol *pSymbol, DWORD dwIndent)
+{
+  IDiaEnumSymbols *pEnumChildren;
+  IDiaSymbol *pType;
+  IDiaSymbol *pChild;
+  DWORD dwSymTag;
+  DWORD dwSymTagType;
+  ULONG celt = 0;
+  BOOL bFlag;
+
+  if (dwIndent > MAX_TYPE_IN_DETAIL) {
+    return;
+  }
+
+  if (pSymbol->get_symTag(&dwSymTag) != S_OK) {
+    wprintf(L"ERROR - PrintTypeInDetail() get_symTag\n");
+    return;
+  }
+
+  PrintSymTag(dwSymTag);
+
+  for (DWORD i = 0;i < dwIndent; i++) {
+    putwchar(L' ');
+  }
+
+  switch (dwSymTag) {
+    case SymTagData:
+      PrintData(pSymbol, dwIndent);
+
+      if (pSymbol->get_type(&pType) == S_OK) {
+        if (pType->get_symTag(&dwSymTagType) == S_OK) {
+          if (dwSymTagType == SymTagUDT) {
+            putwchar(L'\n');
+            PrintTypeInDetail(pType, dwIndent + 2);
+          }
+        }
+        pType->Release();
+      }
+      break;
+
+    case SymTagTypedef:
+    case SymTagVTable:
+      PrintSymbolType(pSymbol);
+      break;
+
+    case SymTagEnum:
+    case SymTagUDT:
+      PrintUDT(pSymbol);
+      putwchar(L'\n');
+
+      if (SUCCEEDED(pSymbol->findChildren(SymTagNull, NULL, nsNone, &pEnumChildren))) {
+        while (SUCCEEDED(pEnumChildren->Next(1, &pChild, &celt)) && (celt == 1)) {
+          PrintTypeInDetail(pChild, dwIndent + 2);
+
+          pChild->Release();
+        }
+
+        pEnumChildren->Release();
+      }
+      return;
+      break;
+
+    case SymTagFunction:
+      PrintFunctionType(pSymbol);
+      return;
+      break;
+
+    case SymTagPointerType:
+      PrintName(pSymbol);
+      wprintf(L" has type ");
+      PrintType(pSymbol);
+      break;
+
+    case SymTagArrayType:
+    case SymTagBaseType:
+    case SymTagFunctionArgType:
+    case SymTagUsingNamespace:
+    case SymTagCustom:
+    case SymTagFriend:
+      PrintName(pSymbol);
+      PrintSymbolType(pSymbol);
+      break;
+
+    case SymTagVTableShape:
+    case SymTagBaseClass:
+      PrintName(pSymbol);
+
+      if ((pSymbol->get_virtualBaseClass(&bFlag) == S_OK) && bFlag) {
+        IDiaSymbol *pVBTableType;
+        LONG ptrOffset;
+        DWORD dispIndex;
+
+        if ((pSymbol->get_virtualBaseDispIndex(&dispIndex) == S_OK) &&
+            (pSymbol->get_virtualBasePointerOffset(&ptrOffset) == S_OK)) {
+          wprintf(L" virtual, offset = 0x%X, pointer offset = %ld, virtual base pointer type = ", dispIndex, ptrOffset);
+
+          if (pSymbol->get_virtualBaseTableType(&pVBTableType) == S_OK) {
+            PrintType(pVBTableType);
+            pVBTableType->Release();
+          }
+
+          else {
+            wprintf(L"(unknown)");
+          }
+        }
+      }
+
+      else {
+        LONG offset;
+
+        if (pSymbol->get_offset(&offset) == S_OK) {
+          wprintf(L", offset = 0x%X", offset);
+        }
+      }
+
+      putwchar(L'\n');
+
+      if (SUCCEEDED(pSymbol->findChildren(SymTagNull, NULL, nsNone, &pEnumChildren))) {
+        while (SUCCEEDED(pEnumChildren->Next(1, &pChild, &celt)) && (celt == 1)) {
+          PrintTypeInDetail(pChild, dwIndent + 2);
+          pChild->Release();
+        }
+
+        pEnumChildren->Release();
+      }
+      break;
+
+    case SymTagFunctionType:
+      if (pSymbol->get_type(&pType) == S_OK) {
+        PrintType(pType);
+      }
+      break;
+
+    case SymTagThunk:
+      // Happens for functions which only have S_PROCREF
+      PrintThunk(pSymbol);
+      break;
+
+    default:
+      wprintf(L"ERROR - PrintTypeInDetail() invalid SymTag\n");
+    }
+
+    putwchar(L'\n');
+}
+
+////////////////////////////////////////////////////////////
+// Print a function type
+//
+void PrintFunctionType(IDiaSymbol *pSymbol)
+{
+  DWORD dwAccess = 0;
+
+  if (pSymbol->get_access(&dwAccess) == S_OK) {
+    wprintf(L"%s ", SafeDRef(rgAccess, dwAccess));
+  }
+
+  BOOL bIsStatic = FALSE;
+
+  if ((pSymbol->get_isStatic(&bIsStatic) == S_OK) && bIsStatic) {
+    wprintf(L"static ");
+  }
+
+  IDiaSymbol *pFuncType;
+
+  if (pSymbol->get_type(&pFuncType) == S_OK) {
+    IDiaSymbol *pReturnType;
+
+    if (pFuncType->get_type(&pReturnType) == S_OK) {
+      PrintType(pReturnType);
+      putwchar(L' ');
+
+      BSTR bstrName;
+
+      if (pSymbol->get_name(&bstrName) == S_OK) {
+        wprintf(L"%s", bstrName);
+
+        SysFreeString(bstrName);
+      }
+
+      IDiaEnumSymbols *pEnumChildren;
+
+      if (SUCCEEDED(pFuncType->findChildren(SymTagNull, NULL, nsNone, &pEnumChildren))) {
+        IDiaSymbol *pChild;
+        ULONG celt = 0;
+        ULONG nParam = 0;
+
+        wprintf(L"(");
+
+        while (SUCCEEDED(pEnumChildren->Next(1, &pChild, &celt)) && (celt == 1)) {
+          IDiaSymbol *pType;
+
+          if (pChild->get_type(&pType) == S_OK) {
+            if (nParam++) {
+              wprintf(L", ");
+            }
+
+            PrintType(pType);
+            pType->Release();
+          }
+
+          pChild->Release();
+        }
+
+        pEnumChildren->Release();
+
+        wprintf(L")\n");
+      }
+
+      pReturnType->Release();
+    }
+
+    pFuncType->Release();
+  }
+}
+
+////////////////////////////////////////////////////////////
+//
+void PrintSourceFile(IDiaSourceFile *pSource)
+{
+  BSTR bstrSourceName;
+
+  if (pSource->get_fileName(&bstrSourceName) == S_OK) {
+    wprintf(L"\t%s", bstrSourceName);
+
+    SysFreeString(bstrSourceName);
+  }
+
+  else {
+    wprintf(L"ERROR - PrintSourceFile() get_fileName");
+    return;
+  }
+
+  BYTE checksum[256];
+  DWORD cbChecksum = sizeof(checksum);
+
+  if (pSource->get_checksum(cbChecksum, &cbChecksum, checksum) == S_OK) {
+    wprintf(L" (");
+
+    DWORD checksumType;
+
+    if (pSource->get_checksumType(&checksumType) == S_OK) {
+      switch (checksumType) {
+        case CHKSUM_TYPE_NONE :
+          wprintf(L"None");
+          break;
+
+        case CHKSUM_TYPE_MD5 :
+          wprintf(L"MD5");
+          break;
+
+        case CHKSUM_TYPE_SHA1 :
+          wprintf(L"SHA1");
+          break;
+
+        default :
+          wprintf(L"0x%X", checksumType);
+          break;
+      }
+
+      if (cbChecksum != 0) {
+        wprintf(L": ");
+      }
+    }
+
+    for (DWORD ib = 0; ib < cbChecksum; ib++) {
+      wprintf(L"%02X", checksum[ib]);
+    }
+
+    wprintf(L")");
+  }
+}
+
+////////////////////////////////////////////////////////////
+//
+void PrintLines(IDiaSession *pSession, IDiaSymbol *pFunction)
+{
+  DWORD dwSymTag;
+
+  if ((pFunction->get_symTag(&dwSymTag) != S_OK) || (dwSymTag != SymTagFunction)) {
+    wprintf(L"ERROR - PrintLines() dwSymTag != SymTagFunction");
+    return;
+  }
+
+  BSTR bstrName;
+
+  if (pFunction->get_name(&bstrName) == S_OK) {
+    wprintf(L"\n** %s\n\n", bstrName);
+
+    SysFreeString(bstrName);
+  }
+
+  ULONGLONG ulLength;
+
+  if (pFunction->get_length(&ulLength) != S_OK) {
+    wprintf(L"ERROR - PrintLines() get_length");
+    return;
+  }
+
+  DWORD dwRVA;
+  IDiaEnumLineNumbers *pLines;
+
+  if (pFunction->get_relativeVirtualAddress(&dwRVA) == S_OK) {
+    if (SUCCEEDED(pSession->findLinesByRVA(dwRVA, static_cast<DWORD>(ulLength), &pLines))) {
+      PrintLines(pLines);
+      pLines->Release();
+    }
+  }
+
+  else {
+    DWORD dwSect;
+    DWORD dwOffset;
+
+    if ((pFunction->get_addressSection(&dwSect) == S_OK) &&
+        (pFunction->get_addressOffset(&dwOffset) == S_OK)) {
+      if (SUCCEEDED(pSession->findLinesByAddr(dwSect, dwOffset, static_cast<DWORD>(ulLength), &pLines))) {
+        PrintLines(pLines);
+        pLines->Release();
+      }
+    }
+  }
+}
+
+////////////////////////////////////////////////////////////
+//
+void PrintLines(IDiaEnumLineNumbers *pLines)
+{
+  IDiaLineNumber *pLine;
+  DWORD celt;
+  DWORD dwRVA;
+  DWORD dwSeg;
+  DWORD dwOffset;
+  DWORD dwLinenum;
+  DWORD dwSrcId;
+  DWORD dwLength;
+
+  DWORD dwSrcIdLast = (DWORD)(-1);
+
+  while (SUCCEEDED(pLines->Next(1, &pLine, &celt)) && (celt == 1)) {
+    if ((pLine->get_relativeVirtualAddress(&dwRVA) == S_OK) &&
+        (pLine->get_addressSection(&dwSeg) == S_OK) &&
+        (pLine->get_addressOffset(&dwOffset) == S_OK) &&
+        (pLine->get_lineNumber(&dwLinenum) == S_OK) &&
+        (pLine->get_sourceFileId(&dwSrcId) == S_OK) &&
+        (pLine->get_length(&dwLength) == S_OK)) {
+      wprintf(L"\tline %u at [%08X][%04X:%08X], len = 0x%X", dwLinenum, dwRVA, dwSeg, dwOffset, dwLength);
+
+      if (dwSrcId != dwSrcIdLast) {
+        IDiaSourceFile *pSource;
+
+        if (pLine->get_sourceFile(&pSource) == S_OK) {
+          PrintSourceFile(pSource);
+
+          dwSrcIdLast = dwSrcId;
+
+          pSource->Release();
+        }
+      }
+
+      pLine->Release();
+
+      putwchar(L'\n');
+    }
+  }
+}
+
+////////////////////////////////////////////////////////////
+// Print the section contribution data: name, Sec::Off, length
+void PrintSecContribs(IDiaSectionContrib *pSegment)
+{
+  DWORD dwRVA;
+  DWORD dwSect;
+  DWORD dwOffset;
+  DWORD dwLen;
+  IDiaSymbol *pCompiland;
+  BSTR bstrName;
+
+  if ((pSegment->get_relativeVirtualAddress(&dwRVA) == S_OK) &&
+      (pSegment->get_addressSection(&dwSect) == S_OK) &&
+      (pSegment->get_addressOffset(&dwOffset) == S_OK) &&
+      (pSegment->get_length(&dwLen) == S_OK) &&
+      (pSegment->get_compiland(&pCompiland) == S_OK) &&
+      (pCompiland->get_name(&bstrName) == S_OK)) {
+    wprintf(L"  %08X  %04X:%08X  %08X  %s\n", dwRVA, dwSect, dwOffset, dwLen, bstrName);
+
+    pCompiland->Release();
+
+    SysFreeString(bstrName);
+  }
+}
+
+////////////////////////////////////////////////////////////
+// Print a debug stream data
+//
+void PrintStreamData(IDiaEnumDebugStreamData *pStream)
+{
+  BSTR bstrName;
+
+  if (pStream->get_name(&bstrName) != S_OK) {
+    wprintf(L"ERROR - PrintStreamData() get_name\n");
+  }
+
+  else {
+    wprintf(L"Stream: %s", bstrName);
+
+    SysFreeString(bstrName);
+  }
+
+  LONG dwElem;
+
+  if (pStream->get_Count(&dwElem) != S_OK) {
+      wprintf(L"ERROR - PrintStreamData() get_Count\n");
+  }
+
+  else {
+    wprintf(L"(%u)\n", dwElem);
+  }
+
+  DWORD cbTotal = 0;
+
+  BYTE data[1024];
+  DWORD cbData;
+  ULONG celt = 0;
+
+  while (SUCCEEDED(pStream->Next(1, sizeof(data), &cbData, (BYTE *) &data, &celt)) && (celt == 1)) {
+    DWORD i;
+
+    for (i = 0; i < cbData; i++) {
+      wprintf(L"%02X ", data[i]);
+
+      if (i && (i % 8 == 7) && (i+1 < cbData)) {
+        wprintf(L"- ");
+      }
+    }
+
+    wprintf(L"| ");
+
+    for (i = 0; i < cbData; i++) {
+      wprintf(L"%c", iswprint(data[i]) ? data[i] : '.');
+    }
+
+    putwchar(L'\n');
+
+    cbTotal += cbData;
+  }
+
+  wprintf(L"Summary :\n\tNo of Elems = %u\n", dwElem);
+  if (dwElem != 0) {
+    wprintf(L"\tSizeof(Elem) = %u\n", cbTotal / dwElem);
+  }
+  putwchar(L'\n');
+}
+
+////////////////////////////////////////////////////////////
+// Print the FPO info for a given symbol;
+//
+void PrintFrameData(IDiaFrameData *pFrameData)
+{
+  DWORD dwSect;
+  DWORD dwOffset;
+  DWORD cbBlock;
+  DWORD cbLocals;                      // Number of bytes reserved for the function locals
+  DWORD cbParams;                      // Number of bytes reserved for the function arguments
+  DWORD cbMaxStack;
+  DWORD cbProlog;
+  DWORD cbSavedRegs;
+  BOOL bSEH;
+  BOOL bEH;
+  BOOL bStart;
+
+  if ((pFrameData->get_addressSection(&dwSect) == S_OK) &&
+      (pFrameData->get_addressOffset(&dwOffset) == S_OK) &&
+      (pFrameData->get_lengthBlock(&cbBlock) == S_OK) &&
+      (pFrameData->get_lengthLocals(&cbLocals) == S_OK) &&
+      (pFrameData->get_lengthParams(&cbParams) == S_OK) &&
+      (pFrameData->get_maxStack(&cbMaxStack) == S_OK) &&
+      (pFrameData->get_lengthProlog(&cbProlog) == S_OK) &&
+      (pFrameData->get_lengthSavedRegisters(&cbSavedRegs) == S_OK) &&
+      (pFrameData->get_systemExceptionHandling(&bSEH) == S_OK) &&
+      (pFrameData->get_cplusplusExceptionHandling(&bEH) == S_OK) &&
+      (pFrameData->get_functionStart(&bStart) == S_OK)) {
+    wprintf(L"%04X:%08X   %8X %8X %8X %8X %8X %8X %c   %c   %c",
+            dwSect, dwOffset, cbBlock, cbLocals, cbParams, cbMaxStack, cbProlog, cbSavedRegs,
+            bSEH ? L'Y' : L'N',
+            bEH ? L'Y' : L'N',
+            bStart ? L'Y' : L'N');
+
+    BSTR bstrProgram;
+
+    if (pFrameData->get_program(&bstrProgram) == S_OK) {
+      wprintf(L" %s", bstrProgram);
+
+      SysFreeString(bstrProgram);
+    }
+
+    putwchar(L'\n');
+  }
+}
+
+////////////////////////////////////////////////////////////
+// Print all the valid properties associated to a symbol
+//
+void PrintPropertyStorage(IDiaPropertyStorage *pPropertyStorage)
+{
+  IEnumSTATPROPSTG *pEnumProps;
+
+  if (SUCCEEDED(pPropertyStorage->Enum(&pEnumProps))) {
+    STATPROPSTG prop;
+    DWORD celt = 1;
+
+    while (SUCCEEDED(pEnumProps->Next(celt, &prop, &celt)) && (celt == 1)) {
+      PROPSPEC pspec = { PRSPEC_PROPID, prop.propid };
+      PROPVARIANT vt = { VT_EMPTY };
+
+      if (SUCCEEDED(pPropertyStorage->ReadMultiple(1, &pspec, &vt))) {
+        switch (vt.vt) {
+          case VT_BOOL:
+            wprintf(L"%32s:\t %s\n", prop.lpwstrName, vt.bVal ? L"true" : L"false");
+            break;
+
+          case VT_I2:
+            wprintf(L"%32s:\t %d\n", prop.lpwstrName, vt.iVal);
+            break;
+
+          case VT_UI2:
+            wprintf(L"%32s:\t %u\n", prop.lpwstrName, vt.uiVal);
+            break;
+
+          case VT_I4:
+            wprintf(L"%32s:\t %d\n", prop.lpwstrName, vt.intVal);
+            break;
+
+          case VT_UI4:
+            wprintf(L"%32s:\t 0x%0X\n", prop.lpwstrName, vt.uintVal);
+            break;
+
+          case VT_UI8:
+            wprintf(L"%32s:\t 0x%X\n", prop.lpwstrName, vt.uhVal.QuadPart);
+            break;
+
+          case VT_BSTR:
+            wprintf(L"%32s:\t %s\n", prop.lpwstrName, vt.bstrVal);
+            break;
+
+          case VT_UNKNOWN:
+            wprintf(L"%32s:\t %p\n", prop.lpwstrName, vt.punkVal);
+            break;
+
+          case VT_SAFEARRAY:
+            break;
+        }
+
+        VariantClear((VARIANTARG *) &vt);
+      }
+
+      SysFreeString( prop.lpwstrName );
+    }
+
+    pEnumProps->Release();
+  }
+}
diff --git a/src/ToolBox/PdbTypeMatch/PrintSymbol.h b/src/ToolBox/PdbTypeMatch/PrintSymbol.h
new file mode 100644
index 0000000000..2aeffc47b9
--- /dev/null
+++ b/src/ToolBox/PdbTypeMatch/PrintSymbol.h
@@ -0,0 +1,62 @@
+#include <string>
+
+inline int myDebugBreak( int ){
+    DebugBreak();
+    return 0;
+}
+#define MAXELEMS(x)     (sizeof(x)/sizeof(x[0]))
+#define SafeDRef(a, i)  ((i < MAXELEMS(a)) ? a[i] : a[myDebugBreak(i)])
+
+#define MAX_TYPE_IN_DETAIL 5
+#define MAX_RVA_LINES_BYTES_RANGE 0x100
+
+extern const wchar_t * const rgBaseType[];
+extern const wchar_t * const rgTags[];
+extern const wchar_t * const rgFloatPackageStrings[];
+extern const wchar_t * const rgProcessorStrings[];
+extern const wchar_t * const rgDataKind[];
+extern const wchar_t * const rgUdtKind[];
+extern const wchar_t * const rgAccess[];
+extern const wchar_t * const rgCallingConvention[];
+extern const wchar_t * const rgLanguage[];
+extern const wchar_t * const rgLocationTypeString[];
+
+void PrintPublicSymbol( IDiaSymbol* );
+void PrintGlobalSymbol( IDiaSymbol* );
+void PrintSymbol( IDiaSymbol* , DWORD );
+void GetSymbolName(std::wstring& symbolName, IDiaSymbol *pSymbol);
+void PrintSymTag( DWORD );
+void PrintName( IDiaSymbol* );
+void PrintUndName( IDiaSymbol* );
+void PrintThunk( IDiaSymbol* );
+void PrintCompilandDetails( IDiaSymbol* );
+void PrintCompilandEnv( IDiaSymbol* );
+void PrintLocation( IDiaSymbol* );
+void PrintConst( IDiaSymbol* );
+void PrintUDT( IDiaSymbol* );
+void PrintSymbolType( IDiaSymbol* );
+void PrintType( IDiaSymbol* );
+void PrintBound( IDiaSymbol* );
+void PrintData( IDiaSymbol* , DWORD );
+void PrintVariant( VARIANT );
+void PrintUdtKind( IDiaSymbol* );
+void PrintTypeInDetail( IDiaSymbol* , DWORD );
+void PrintFunctionType( IDiaSymbol* );
+void PrintSourceFile( IDiaSourceFile* );
+void PrintLines( IDiaSession* , IDiaSymbol* );
+void PrintLines( IDiaEnumLineNumbers* );
+void PrintSource( IDiaSourceFile* );
+void PrintSecContribs( IDiaSectionContrib* );
+void PrintStreamData( IDiaEnumDebugStreamData* );
+void PrintFrameData( IDiaFrameData* );
+
+void PrintPropertyStorage( IDiaPropertyStorage* );
+
+template<class T> void PrintGeneric( T t ){
+  IDiaPropertyStorage* pPropertyStorage;
+  
+  if(t->QueryInterface( __uuidof(IDiaPropertyStorage), (void **)&pPropertyStorage ) == S_OK){
+    PrintPropertyStorage(pPropertyStorage);
+    pPropertyStorage->Release();
+  }
+}
diff --git a/src/ToolBox/PdbTypeMatch/callback.h b/src/ToolBox/PdbTypeMatch/callback.h
new file mode 100644
index 0000000000..c1d6887f30
--- /dev/null
+++ b/src/ToolBox/PdbTypeMatch/callback.h
@@ -0,0 +1,91 @@
+#include "dia2.h"
+
+#pragma warning ( disable : 4100)
+
+class CCallback : public IDiaLoadCallback2{
+    int m_nRefCount;
+public:
+    CCallback() { m_nRefCount = 0; }
+
+    //IUnknown
+    ULONG STDMETHODCALLTYPE AddRef() {
+        m_nRefCount++;
+        return m_nRefCount;
+    }
+    ULONG STDMETHODCALLTYPE Release() {
+        if ( (--m_nRefCount) == 0 )
+            delete this;
+        return m_nRefCount;
+    }
+    HRESULT STDMETHODCALLTYPE QueryInterface( REFIID rid, void **ppUnk ) {
+        if ( ppUnk == NULL ) {
+            return E_INVALIDARG;
+        }
+        if (rid == __uuidof( IDiaLoadCallback2 ) )
+            *ppUnk = (IDiaLoadCallback2 *)this;
+        else if (rid == __uuidof( IDiaLoadCallback ) )
+            *ppUnk = (IDiaLoadCallback *)this;
+        else if (rid == __uuidof( IUnknown ) )
+            *ppUnk = (IUnknown *)this;
+        else
+            *ppUnk = NULL;
+        if ( *ppUnk != NULL ) {
+            AddRef();
+            return S_OK;
+        }
+        return E_NOINTERFACE;
+    }
+
+    HRESULT STDMETHODCALLTYPE NotifyDebugDir(
+                BOOL fExecutable, 
+                DWORD cbData,
+                BYTE data[]) // really a const struct _IMAGE_DEBUG_DIRECTORY *
+    {
+        return S_OK;
+    }
+    HRESULT STDMETHODCALLTYPE NotifyOpenDBG(
+                LPCOLESTR dbgPath, 
+                HRESULT resultCode)
+    {
+        // wprintf(L"opening %s...\n", dbgPath);
+        return S_OK;
+    }
+
+    HRESULT STDMETHODCALLTYPE NotifyOpenPDB(
+                LPCOLESTR pdbPath, 
+                HRESULT resultCode)
+    {
+        // wprintf(L"opening %s...\n", pdbPath);
+        return S_OK;
+    }
+    HRESULT STDMETHODCALLTYPE RestrictRegistryAccess()         
+    {
+        // return hr != S_OK to prevent querying the registry for symbol search paths
+        return S_OK;
+    }
+    HRESULT STDMETHODCALLTYPE RestrictSymbolServerAccess()
+    {
+      // return hr != S_OK to prevent accessing a symbol server
+      return S_OK;
+    }
+    HRESULT STDMETHODCALLTYPE RestrictOriginalPathAccess()     
+    {
+        // return hr != S_OK to prevent querying the registry for symbol search paths
+        return S_OK;
+    }
+    HRESULT STDMETHODCALLTYPE RestrictReferencePathAccess()
+    {
+        // return hr != S_OK to prevent accessing a symbol server
+        return S_OK;
+    }
+    HRESULT STDMETHODCALLTYPE RestrictDBGAccess()
+    {
+        return S_OK;
+    }
+    HRESULT STDMETHODCALLTYPE RestrictSystemRootAccess()
+    {
+        return S_OK;
+    }
+};
+
+#pragma warning ( default : 4100 )
diff --git a/src/ToolBox/PdbTypeMatch/include/.gitmirror b/src/ToolBox/PdbTypeMatch/include/.gitmirror
new file mode 100644
index 0000000000..f507630f94
--- /dev/null
+++ b/src/ToolBox/PdbTypeMatch/include/.gitmirror
@@ -0,0 +1 @@
+Only contents of this folder, excluding subfolders, will be mirrored by the Git-TFS Mirror. 
\ No newline at end of file
diff --git a/src/ToolBox/PdbTypeMatch/include/cvconst.h b/src/ToolBox/PdbTypeMatch/include/cvconst.h
new file mode 100644
index 0000000000..9212cf1582
--- /dev/null
+++ b/src/ToolBox/PdbTypeMatch/include/cvconst.h
@@ -0,0 +1,3182 @@
+// cvconst.h - codeview constant definitions
+//-----------------------------------------------------------------
+//
+// Copyright Microsoft Corporation.  All Rights Reserved.
+//
+//---------------------------------------------------------------
+#ifndef _CVCONST_H_
+#define _CVCONST_H_
+
+
+
+//      Enumeration for function call type
+
+
+typedef enum CV_call_e {
+    CV_CALL_NEAR_C      = 0x00, // near right to left push, caller pops stack
+    CV_CALL_FAR_C       = 0x01, // far right to left push, caller pops stack
+    CV_CALL_NEAR_PASCAL = 0x02, // near left to right push, callee pops stack
+    CV_CALL_FAR_PASCAL  = 0x03, // far left to right push, callee pops stack
+    CV_CALL_NEAR_FAST   = 0x04, // near left to right push with regs, callee pops stack
+    CV_CALL_FAR_FAST    = 0x05, // far left to right push with regs, callee pops stack
+    CV_CALL_SKIPPED     = 0x06, // skipped (unused) call index
+    CV_CALL_NEAR_STD    = 0x07, // near standard call
+    CV_CALL_FAR_STD     = 0x08, // far standard call
+    CV_CALL_NEAR_SYS    = 0x09, // near sys call
+    CV_CALL_FAR_SYS     = 0x0a, // far sys call
+    CV_CALL_THISCALL    = 0x0b, // this call (this passed in register)
+    CV_CALL_MIPSCALL    = 0x0c, // Mips call
+    CV_CALL_GENERIC     = 0x0d, // Generic call sequence
+    CV_CALL_ALPHACALL   = 0x0e, // Alpha call
+    CV_CALL_PPCCALL     = 0x0f, // PPC call
+    CV_CALL_SHCALL      = 0x10, // Hitachi SuperH call
+    CV_CALL_ARMCALL     = 0x11, // ARM call
+    CV_CALL_AM33CALL    = 0x12, // AM33 call
+    CV_CALL_TRICALL     = 0x13, // TriCore Call
+    CV_CALL_SH5CALL     = 0x14, // Hitachi SuperH-5 call
+    CV_CALL_M32RCALL    = 0x15, // M32R Call
+    CV_CALL_CLRCALL     = 0x16, // clr call
+    CV_CALL_RESERVED    = 0x17  // first unused call enumeration
+
+    // Do NOT add any more machine specific conventions.  This is to be used for
+    // calling conventions in the source only (e.g. __cdecl, __stdcall).
+} CV_call_e;
+
+
+//      Values for the access protection of class attributes
+
+
+typedef enum CV_access_e {
+    CV_private   = 1,
+    CV_protected = 2,
+    CV_public    = 3
+} CV_access_e;
+
+typedef enum THUNK_ORDINAL {
+    THUNK_ORDINAL_NOTYPE,       // standard thunk
+    THUNK_ORDINAL_ADJUSTOR,     // "this" adjustor thunk
+    THUNK_ORDINAL_VCALL,        // virtual call thunk
+    THUNK_ORDINAL_PCODE,        // pcode thunk
+    THUNK_ORDINAL_LOAD,         // thunk which loads the address to jump to
+                                //  via unknown means...
+
+ // trampoline thunk ordinals   - only for use in Trampoline thunk symbols
+    THUNK_ORDINAL_TRAMP_INCREMENTAL,
+    THUNK_ORDINAL_TRAMP_BRANCHISLAND,
+
+} THUNK_ORDINAL;
+
+
+enum CV_SourceChksum_t {
+    CHKSUM_TYPE_NONE = 0,        // indicates no checksum is available
+    CHKSUM_TYPE_MD5,
+    CHKSUM_TYPE_SHA1
+};
+
+//
+// DIA enums
+//
+
+enum SymTagEnum
+{
+    SymTagNull,
+    SymTagExe,
+    SymTagCompiland,
+    SymTagCompilandDetails,
+    SymTagCompilandEnv,
+    SymTagFunction,
+    SymTagBlock,
+    SymTagData,
+    SymTagAnnotation,
+    SymTagLabel,
+    SymTagPublicSymbol,
+    SymTagUDT,
+    SymTagEnum,
+    SymTagFunctionType,
+    SymTagPointerType,
+    SymTagArrayType,
+    SymTagBaseType,
+    SymTagTypedef,
+    SymTagBaseClass,
+    SymTagFriend,
+    SymTagFunctionArgType,
+    SymTagFuncDebugStart,
+    SymTagFuncDebugEnd,
+    SymTagUsingNamespace,
+    SymTagVTableShape,
+    SymTagVTable,
+    SymTagCustom,
+    SymTagThunk,
+    SymTagCustomType,
+    SymTagManagedType,
+    SymTagDimension,
+    SymTagCallSite,
+    SymTagMax
+};
+
+enum LocationType
+{
+    LocIsNull,
+    LocIsStatic,
+    LocIsTLS,
+    LocIsRegRel,
+    LocIsThisRel,
+    LocIsEnregistered,
+    LocIsBitField,
+    LocIsSlot,
+    LocIsIlRel,
+    LocInMetaData,
+    LocIsConstant,
+    LocTypeMax
+};
+
+enum DataKind
+{
+    DataIsUnknown,
+    DataIsLocal,
+    DataIsStaticLocal,
+    DataIsParam,
+    DataIsObjectPtr,
+    DataIsFileStatic,
+    DataIsGlobal,
+    DataIsMember,
+    DataIsStaticMember,
+    DataIsConstant
+};
+
+enum UdtKind
+{
+    UdtStruct,
+    UdtClass,
+    UdtUnion
+};
+
+enum BasicType
+{
+    btNoType = 0,
+    btVoid = 1,
+    btChar = 2,
+    btWChar = 3,
+    btInt = 6,
+    btUInt = 7,
+    btFloat = 8,
+    btBCD = 9,
+    btBool = 10,
+    btLong = 13,
+    btULong = 14,
+    btCurrency = 25,
+    btDate = 26,
+    btVariant = 27,
+    btComplex = 28,
+    btBit = 29,
+    btBSTR = 30,
+    btHresult = 31
+};
+
+
+//  enum describing the compile flag source language
+
+
+typedef enum CV_CFL_LANG {
+    CV_CFL_C        = 0x00,
+    CV_CFL_CXX      = 0x01,
+    CV_CFL_FORTRAN  = 0x02,
+    CV_CFL_MASM     = 0x03,
+    CV_CFL_PASCAL   = 0x04,
+    CV_CFL_BASIC    = 0x05,
+    CV_CFL_COBOL    = 0x06,
+    CV_CFL_LINK     = 0x07,
+    CV_CFL_CVTRES   = 0x08,
+    CV_CFL_CVTPGD   = 0x09,
+    CV_CFL_CSHARP   = 0x0A,  // C#
+    CV_CFL_VB       = 0x0B,  // Visual Basic
+    CV_CFL_ILASM    = 0x0C,  // IL (as in CLR) ASM
+    CV_CFL_JAVA     = 0x0D,
+    CV_CFL_JSCRIPT  = 0x0E,
+    CV_CFL_MSIL     = 0x0F,  // Unknown MSIL (LTCG of .NETMODULE)
+} CV_CFL_LANG;
+
+
+//  enum describing target processor
+
+
+typedef enum CV_CPU_TYPE_e {
+    CV_CFL_8080         = 0x00,
+    CV_CFL_8086         = 0x01,
+    CV_CFL_80286        = 0x02,
+    CV_CFL_80386        = 0x03,
+    CV_CFL_80486        = 0x04,
+    CV_CFL_PENTIUM      = 0x05,
+    CV_CFL_PENTIUMII    = 0x06,
+    CV_CFL_PENTIUMPRO   = CV_CFL_PENTIUMII,
+    CV_CFL_PENTIUMIII   = 0x07,
+    CV_CFL_MIPS         = 0x10,
+    CV_CFL_MIPSR4000    = CV_CFL_MIPS,  // don't break current code
+    CV_CFL_MIPS16       = 0x11,
+    CV_CFL_MIPS32       = 0x12,
+    CV_CFL_MIPS64       = 0x13,
+    CV_CFL_MIPSI        = 0x14,
+    CV_CFL_MIPSII       = 0x15,
+    CV_CFL_MIPSIII      = 0x16,
+    CV_CFL_MIPSIV       = 0x17,
+    CV_CFL_MIPSV        = 0x18,
+    CV_CFL_M68000       = 0x20,
+    CV_CFL_M68010       = 0x21,
+    CV_CFL_M68020       = 0x22,
+    CV_CFL_M68030       = 0x23,
+    CV_CFL_M68040       = 0x24,
+    CV_CFL_ALPHA        = 0x30,
+    CV_CFL_ALPHA_21064  = 0x30,
+    CV_CFL_ALPHA_21164  = 0x31,
+    CV_CFL_ALPHA_21164A = 0x32,
+    CV_CFL_ALPHA_21264  = 0x33,
+    CV_CFL_ALPHA_21364  = 0x34,
+    CV_CFL_PPC601       = 0x40,
+    CV_CFL_PPC603       = 0x41,
+    CV_CFL_PPC604       = 0x42,
+    CV_CFL_PPC620       = 0x43,
+    CV_CFL_PPCFP        = 0x44,
+    CV_CFL_PPCBE        = 0x45,
+    CV_CFL_SH3          = 0x50,
+    CV_CFL_SH3E         = 0x51,
+    CV_CFL_SH3DSP       = 0x52,
+    CV_CFL_SH4          = 0x53,
+    CV_CFL_SHMEDIA      = 0x54,
+    CV_CFL_ARM3         = 0x60,
+    CV_CFL_ARM4         = 0x61,
+    CV_CFL_ARM4T        = 0x62,
+    CV_CFL_ARM5         = 0x63,
+    CV_CFL_ARM5T        = 0x64,
+    CV_CFL_ARM6         = 0x65,
+    CV_CFL_ARM_XMAC     = 0x66,
+    CV_CFL_ARM_WMMX     = 0x67,
+    CV_CFL_ARM7         = 0x68,
+    CV_CFL_OMNI         = 0x70,
+    CV_CFL_IA64         = 0x80,
+    CV_CFL_IA64_1       = 0x80,
+    CV_CFL_IA64_2       = 0x81,
+    CV_CFL_CEE          = 0x90,
+    CV_CFL_AM33         = 0xA0,
+    CV_CFL_M32R         = 0xB0,
+    CV_CFL_TRICORE      = 0xC0,
+    CV_CFL_X64          = 0xD0,
+    CV_CFL_AMD64        = CV_CFL_X64,
+    CV_CFL_EBC          = 0xE0,
+    CV_CFL_THUMB        = 0xF0,
+} CV_CPU_TYPE_e;
+
+typedef enum CV_HREG_e {
+    // Register subset shared by all processor types,
+    // must not overlap with any of the ranges below, hence the high values
+
+    CV_ALLREG_ERR   =   30000,
+    CV_ALLREG_TEB   =   30001,
+    CV_ALLREG_TIMER =   30002,
+    CV_ALLREG_EFAD1 =   30003,
+    CV_ALLREG_EFAD2 =   30004,
+    CV_ALLREG_EFAD3 =   30005,
+    CV_ALLREG_VFRAME=   30006,
+    CV_ALLREG_HANDLE=   30007,
+    CV_ALLREG_PARAMS=   30008,
+    CV_ALLREG_LOCALS=   30009,
+    CV_ALLREG_TID   =   30010,
+    CV_ALLREG_ENV   =   30011,
+    CV_ALLREG_CMDLN =   30012,
+
+
+    //  Register set for the Intel 80x86 and ix86 processor series
+    //  (plus PCODE registers)
+
+    CV_REG_NONE     =   0,
+    CV_REG_AL       =   1,
+    CV_REG_CL       =   2,
+    CV_REG_DL       =   3,
+    CV_REG_BL       =   4,
+    CV_REG_AH       =   5,
+    CV_REG_CH       =   6,
+    CV_REG_DH       =   7,
+    CV_REG_BH       =   8,
+    CV_REG_AX       =   9,
+    CV_REG_CX       =  10,
+    CV_REG_DX       =  11,
+    CV_REG_BX       =  12,
+    CV_REG_SP       =  13,
+    CV_REG_BP       =  14,
+    CV_REG_SI       =  15,
+    CV_REG_DI       =  16,
+    CV_REG_EAX      =  17,
+    CV_REG_ECX      =  18,
+    CV_REG_EDX      =  19,
+    CV_REG_EBX      =  20,
+    CV_REG_ESP      =  21,
+    CV_REG_EBP      =  22,
+    CV_REG_ESI      =  23,
+    CV_REG_EDI      =  24,
+    CV_REG_ES       =  25,
+    CV_REG_CS       =  26,
+    CV_REG_SS       =  27,
+    CV_REG_DS       =  28,
+    CV_REG_FS       =  29,
+    CV_REG_GS       =  30,
+    CV_REG_IP       =  31,
+    CV_REG_FLAGS    =  32,
+    CV_REG_EIP      =  33,
+    CV_REG_EFLAGS   =  34,
+    CV_REG_TEMP     =  40,          // PCODE Temp
+    CV_REG_TEMPH    =  41,          // PCODE TempH
+    CV_REG_QUOTE    =  42,          // PCODE Quote
+    CV_REG_PCDR3    =  43,          // PCODE reserved
+    CV_REG_PCDR4    =  44,          // PCODE reserved
+    CV_REG_PCDR5    =  45,          // PCODE reserved
+    CV_REG_PCDR6    =  46,          // PCODE reserved
+    CV_REG_PCDR7    =  47,          // PCODE reserved
+    CV_REG_CR0      =  80,          // CR0 -- control registers
+    CV_REG_CR1      =  81,
+    CV_REG_CR2      =  82,
+    CV_REG_CR3      =  83,
+    CV_REG_CR4      =  84,          // Pentium
+    CV_REG_DR0      =  90,          // Debug register
+    CV_REG_DR1      =  91,
+    CV_REG_DR2      =  92,
+    CV_REG_DR3      =  93,
+    CV_REG_DR4      =  94,
+    CV_REG_DR5      =  95,
+    CV_REG_DR6      =  96,
+    CV_REG_DR7      =  97,
+    CV_REG_GDTR     =  110,
+    CV_REG_GDTL     =  111,
+    CV_REG_IDTR     =  112,
+    CV_REG_IDTL     =  113,
+    CV_REG_LDTR     =  114,
+    CV_REG_TR       =  115,
+
+    CV_REG_PSEUDO1  =  116,
+    CV_REG_PSEUDO2  =  117,
+    CV_REG_PSEUDO3  =  118,
+    CV_REG_PSEUDO4  =  119,
+    CV_REG_PSEUDO5  =  120,
+    CV_REG_PSEUDO6  =  121,
+    CV_REG_PSEUDO7  =  122,
+    CV_REG_PSEUDO8  =  123,
+    CV_REG_PSEUDO9  =  124,
+
+    CV_REG_ST0      =  128,
+    CV_REG_ST1      =  129,
+    CV_REG_ST2      =  130,
+    CV_REG_ST3      =  131,
+    CV_REG_ST4      =  132,
+    CV_REG_ST5      =  133,
+    CV_REG_ST6      =  134,
+    CV_REG_ST7      =  135,
+    CV_REG_CTRL     =  136,
+    CV_REG_STAT     =  137,
+    CV_REG_TAG      =  138,
+    CV_REG_FPIP     =  139,
+    CV_REG_FPCS     =  140,
+    CV_REG_FPDO     =  141,
+    CV_REG_FPDS     =  142,
+    CV_REG_ISEM     =  143,
+    CV_REG_FPEIP    =  144,
+    CV_REG_FPEDO    =  145,
+
+    CV_REG_MM0      =  146,
+    CV_REG_MM1      =  147,
+    CV_REG_MM2      =  148,
+    CV_REG_MM3      =  149,
+    CV_REG_MM4      =  150,
+    CV_REG_MM5      =  151,
+    CV_REG_MM6      =  152,
+    CV_REG_MM7      =  153,
+
+    CV_REG_XMM0     =  154, // KATMAI registers
+    CV_REG_XMM1     =  155,
+    CV_REG_XMM2     =  156,
+    CV_REG_XMM3     =  157,
+    CV_REG_XMM4     =  158,
+    CV_REG_XMM5     =  159,
+    CV_REG_XMM6     =  160,
+    CV_REG_XMM7     =  161,
+
+    CV_REG_XMM00    =  162, // KATMAI sub-registers
+    CV_REG_XMM01    =  163,
+    CV_REG_XMM02    =  164,
+    CV_REG_XMM03    =  165,
+    CV_REG_XMM10    =  166,
+    CV_REG_XMM11    =  167,
+    CV_REG_XMM12    =  168,
+    CV_REG_XMM13    =  169,
+    CV_REG_XMM20    =  170,
+    CV_REG_XMM21    =  171,
+    CV_REG_XMM22    =  172,
+    CV_REG_XMM23    =  173,
+    CV_REG_XMM30    =  174,
+    CV_REG_XMM31    =  175,
+    CV_REG_XMM32    =  176,
+    CV_REG_XMM33    =  177,
+    CV_REG_XMM40    =  178,
+    CV_REG_XMM41    =  179,
+    CV_REG_XMM42    =  180,
+    CV_REG_XMM43    =  181,
+    CV_REG_XMM50    =  182,
+    CV_REG_XMM51    =  183,
+    CV_REG_XMM52    =  184,
+    CV_REG_XMM53    =  185,
+    CV_REG_XMM60    =  186,
+    CV_REG_XMM61    =  187,
+    CV_REG_XMM62    =  188,
+    CV_REG_XMM63    =  189,
+    CV_REG_XMM70    =  190,
+    CV_REG_XMM71    =  191,
+    CV_REG_XMM72    =  192,
+    CV_REG_XMM73    =  193,
+
+    CV_REG_XMM0L    =  194,
+    CV_REG_XMM1L    =  195,
+    CV_REG_XMM2L    =  196,
+    CV_REG_XMM3L    =  197,
+    CV_REG_XMM4L    =  198,
+    CV_REG_XMM5L    =  199,
+    CV_REG_XMM6L    =  200,
+    CV_REG_XMM7L    =  201,
+
+    CV_REG_XMM0H    =  202,
+    CV_REG_XMM1H    =  203,
+    CV_REG_XMM2H    =  204,
+    CV_REG_XMM3H    =  205,
+    CV_REG_XMM4H    =  206,
+    CV_REG_XMM5H    =  207,
+    CV_REG_XMM6H    =  208,
+    CV_REG_XMM7H    =  209,
+
+    CV_REG_MXCSR    =  211, // XMM status register
+
+    CV_REG_EDXEAX   =  212, // EDX:EAX pair
+
+    CV_REG_EMM0L    =  220, // XMM sub-registers (WNI integer)
+    CV_REG_EMM1L    =  221,
+    CV_REG_EMM2L    =  222,
+    CV_REG_EMM3L    =  223,
+    CV_REG_EMM4L    =  224,
+    CV_REG_EMM5L    =  225,
+    CV_REG_EMM6L    =  226,
+    CV_REG_EMM7L    =  227,
+
+    CV_REG_EMM0H    =  228,
+    CV_REG_EMM1H    =  229,
+    CV_REG_EMM2H    =  230,
+    CV_REG_EMM3H    =  231,
+    CV_REG_EMM4H    =  232,
+    CV_REG_EMM5H    =  233,
+    CV_REG_EMM6H    =  234,
+    CV_REG_EMM7H    =  235,
+
+    // do not change the order of these regs, first one must be even too
+    CV_REG_MM00     =  236,
+    CV_REG_MM01     =  237,
+    CV_REG_MM10     =  238,
+    CV_REG_MM11     =  239,
+    CV_REG_MM20     =  240,
+    CV_REG_MM21     =  241,
+    CV_REG_MM30     =  242,
+    CV_REG_MM31     =  243,
+    CV_REG_MM40     =  244,
+    CV_REG_MM41     =  245,
+    CV_REG_MM50     =  246,
+    CV_REG_MM51     =  247,
+    CV_REG_MM60     =  248,
+    CV_REG_MM61     =  249,
+    CV_REG_MM70     =  250,
+    CV_REG_MM71     =  251,
+
+    CV_REG_YMM0     =  252, // AVX registers
+    CV_REG_YMM1     =  253,
+    CV_REG_YMM2     =  254,
+    CV_REG_YMM3     =  255,
+    CV_REG_YMM4     =  256,
+    CV_REG_YMM5     =  257,
+    CV_REG_YMM6     =  258,
+    CV_REG_YMM7     =  259,
+
+    CV_REG_YMM0H    =  260,
+    CV_REG_YMM1H    =  261,
+    CV_REG_YMM2H    =  262,
+    CV_REG_YMM3H    =  263,
+    CV_REG_YMM4H    =  264,
+    CV_REG_YMM5H    =  265,
+    CV_REG_YMM6H    =  266,
+    CV_REG_YMM7H    =  267,
+
+    CV_REG_YMM0I0     =    268,    // AVX integer registers
+    CV_REG_YMM0I1     =    269,
+    CV_REG_YMM0I2     =    270,
+    CV_REG_YMM0I3     =    271,
+    CV_REG_YMM1I0     =    272,
+    CV_REG_YMM1I1     =    273,
+    CV_REG_YMM1I2     =    274,
+    CV_REG_YMM1I3     =    275,
+    CV_REG_YMM2I0     =    276,
+    CV_REG_YMM2I1     =    277,
+    CV_REG_YMM2I2     =    278,
+    CV_REG_YMM2I3     =    279,
+    CV_REG_YMM3I0     =    280,
+    CV_REG_YMM3I1     =    281,
+    CV_REG_YMM3I2     =    282,
+    CV_REG_YMM3I3     =    283,
+    CV_REG_YMM4I0     =    284,
+    CV_REG_YMM4I1     =    285,
+    CV_REG_YMM4I2     =    286,
+    CV_REG_YMM4I3     =    287,
+    CV_REG_YMM5I0     =    288,
+    CV_REG_YMM5I1     =    289,
+    CV_REG_YMM5I2     =    290,
+    CV_REG_YMM5I3     =    291,
+    CV_REG_YMM6I0     =    292,
+    CV_REG_YMM6I1     =    293,
+    CV_REG_YMM6I2     =    294,
+    CV_REG_YMM6I3     =    295,
+    CV_REG_YMM7I0     =    296,
+    CV_REG_YMM7I1     =    297,
+    CV_REG_YMM7I2     =    298,
+    CV_REG_YMM7I3     =    299,
+        
+    CV_REG_YMM0F0    =  300,     // AVX floating-point single precise registers
+    CV_REG_YMM0F1    =  301,
+    CV_REG_YMM0F2    =  302,
+    CV_REG_YMM0F3    =  303,
+    CV_REG_YMM0F4    =  304,
+    CV_REG_YMM0F5    =  305,
+    CV_REG_YMM0F6    =  306,
+    CV_REG_YMM0F7    =  307,
+    CV_REG_YMM1F0    =  308,
+    CV_REG_YMM1F1    =  309,
+    CV_REG_YMM1F2    =  310,
+    CV_REG_YMM1F3    =  311,
+    CV_REG_YMM1F4    =  312,
+    CV_REG_YMM1F5    =  313,
+    CV_REG_YMM1F6    =  314,
+    CV_REG_YMM1F7    =  315,
+    CV_REG_YMM2F0    =  316,
+    CV_REG_YMM2F1    =  317,
+    CV_REG_YMM2F2    =  318,
+    CV_REG_YMM2F3    =  319,
+    CV_REG_YMM2F4    =  320,
+    CV_REG_YMM2F5    =  321,
+    CV_REG_YMM2F6    =  322,
+    CV_REG_YMM2F7    =  323,
+    CV_REG_YMM3F0    =  324,
+    CV_REG_YMM3F1    =  325,
+    CV_REG_YMM3F2    =  326,
+    CV_REG_YMM3F3    =  327,
+    CV_REG_YMM3F4    =  328,
+    CV_REG_YMM3F5    =  329,
+    CV_REG_YMM3F6    =  330,
+    CV_REG_YMM3F7    =  331,
+    CV_REG_YMM4F0    =  332,
+    CV_REG_YMM4F1    =  333,
+    CV_REG_YMM4F2    =  334,
+    CV_REG_YMM4F3    =  335,
+    CV_REG_YMM4F4    =  336,
+    CV_REG_YMM4F5    =  337,
+    CV_REG_YMM4F6    =  338,
+    CV_REG_YMM4F7    =  339,
+    CV_REG_YMM5F0    =  340,
+    CV_REG_YMM5F1    =  341,
+    CV_REG_YMM5F2    =  342,
+    CV_REG_YMM5F3    =  343,
+    CV_REG_YMM5F4    =  344,
+    CV_REG_YMM5F5    =  345,
+    CV_REG_YMM5F6    =  346,
+    CV_REG_YMM5F7    =  347,
+    CV_REG_YMM6F0    =  348,
+    CV_REG_YMM6F1    =  349,
+    CV_REG_YMM6F2    =  350,
+    CV_REG_YMM6F3    =  351,
+    CV_REG_YMM6F4    =  352,
+    CV_REG_YMM6F5    =  353,
+    CV_REG_YMM6F6    =  354,
+    CV_REG_YMM6F7    =  355,
+    CV_REG_YMM7F0    =  356,
+    CV_REG_YMM7F1    =  357,
+    CV_REG_YMM7F2    =  358,
+    CV_REG_YMM7F3    =  359,
+    CV_REG_YMM7F4    =  360,
+    CV_REG_YMM7F5    =  361,
+    CV_REG_YMM7F6    =  362,
+    CV_REG_YMM7F7    =  363,
+    
+    CV_REG_YMM0D0     =    364,    // AVX floating-point double precise registers
+    CV_REG_YMM0D1     =    365,
+    CV_REG_YMM0D2     =    366,
+    CV_REG_YMM0D3     =    367,
+    CV_REG_YMM1D0     =    368,
+    CV_REG_YMM1D1     =    369,
+    CV_REG_YMM1D2     =    370,
+    CV_REG_YMM1D3     =    371,
+    CV_REG_YMM2D0     =    372,
+    CV_REG_YMM2D1     =    373,
+    CV_REG_YMM2D2     =    374,
+    CV_REG_YMM2D3     =    375,
+    CV_REG_YMM3D0     =    376,
+    CV_REG_YMM3D1     =    377,
+    CV_REG_YMM3D2     =    378,
+    CV_REG_YMM3D3     =    379,
+    CV_REG_YMM4D0     =    380,
+    CV_REG_YMM4D1     =    381,
+    CV_REG_YMM4D2     =    382,
+    CV_REG_YMM4D3     =    383,
+    CV_REG_YMM5D0     =    384,
+    CV_REG_YMM5D1     =    385,
+    CV_REG_YMM5D2     =    386,
+    CV_REG_YMM5D3     =    387,
+    CV_REG_YMM6D0     =    388,
+    CV_REG_YMM6D1     =    389,
+    CV_REG_YMM6D2     =    390,
+    CV_REG_YMM6D3     =    391,
+    CV_REG_YMM7D0     =    392,
+    CV_REG_YMM7D1     =    393,
+    CV_REG_YMM7D2     =    394,
+    CV_REG_YMM7D3     =    395,
+
+    // registers for the 68K processors
+
+    CV_R68_D0       =    0,
+    CV_R68_D1       =    1,
+    CV_R68_D2       =    2,
+    CV_R68_D3       =    3,
+    CV_R68_D4       =    4,
+    CV_R68_D5       =    5,
+    CV_R68_D6       =    6,
+    CV_R68_D7       =    7,
+    CV_R68_A0       =    8,
+    CV_R68_A1       =    9,
+    CV_R68_A2       =   10,
+    CV_R68_A3       =   11,
+    CV_R68_A4       =   12,
+    CV_R68_A5       =   13,
+    CV_R68_A6       =   14,
+    CV_R68_A7       =   15,
+    CV_R68_CCR      =   16,
+    CV_R68_SR       =   17,
+    CV_R68_USP      =   18,
+    CV_R68_MSP      =   19,
+    CV_R68_SFC      =   20,
+    CV_R68_DFC      =   21,
+    CV_R68_CACR     =   22,
+    CV_R68_VBR      =   23,
+    CV_R68_CAAR     =   24,
+    CV_R68_ISP      =   25,
+    CV_R68_PC       =   26,
+    //reserved  27
+    CV_R68_FPCR     =   28,
+    CV_R68_FPSR     =   29,
+    CV_R68_FPIAR    =   30,
+    //reserved  31
+    CV_R68_FP0      =   32,
+    CV_R68_FP1      =   33,
+    CV_R68_FP2      =   34,
+    CV_R68_FP3      =   35,
+    CV_R68_FP4      =   36,
+    CV_R68_FP5      =   37,
+    CV_R68_FP6      =   38,
+    CV_R68_FP7      =   39,
+    //reserved  40
+    CV_R68_MMUSR030 =   41,
+    CV_R68_MMUSR    =   42,
+    CV_R68_URP      =   43,
+    CV_R68_DTT0     =   44,
+    CV_R68_DTT1     =   45,
+    CV_R68_ITT0     =   46,
+    CV_R68_ITT1     =   47,
+    //reserved  50
+    CV_R68_PSR      =   51,
+    CV_R68_PCSR     =   52,
+    CV_R68_VAL      =   53,
+    CV_R68_CRP      =   54,
+    CV_R68_SRP      =   55,
+    CV_R68_DRP      =   56,
+    CV_R68_TC       =   57,
+    CV_R68_AC       =   58,
+    CV_R68_SCC      =   59,
+    CV_R68_CAL      =   60,
+    CV_R68_TT0      =   61,
+    CV_R68_TT1      =   62,
+    //reserved  63
+    CV_R68_BAD0     =   64,
+    CV_R68_BAD1     =   65,
+    CV_R68_BAD2     =   66,
+    CV_R68_BAD3     =   67,
+    CV_R68_BAD4     =   68,
+    CV_R68_BAD5     =   69,
+    CV_R68_BAD6     =   70,
+    CV_R68_BAD7     =   71,
+    CV_R68_BAC0     =   72,
+    CV_R68_BAC1     =   73,
+    CV_R68_BAC2     =   74,
+    CV_R68_BAC3     =   75,
+    CV_R68_BAC4     =   76,
+    CV_R68_BAC5     =   77,
+    CV_R68_BAC6     =   78,
+    CV_R68_BAC7     =   79,
+
+     // Register set for the MIPS 4000
+
+    CV_M4_NOREG     =   CV_REG_NONE,
+
+    CV_M4_IntZERO   =   10,      /* CPU REGISTER */
+    CV_M4_IntAT     =   11,
+    CV_M4_IntV0     =   12,
+    CV_M4_IntV1     =   13,
+    CV_M4_IntA0     =   14,
+    CV_M4_IntA1     =   15,
+    CV_M4_IntA2     =   16,
+    CV_M4_IntA3     =   17,
+    CV_M4_IntT0     =   18,
+    CV_M4_IntT1     =   19,
+    CV_M4_IntT2     =   20,
+    CV_M4_IntT3     =   21,
+    CV_M4_IntT4     =   22,
+    CV_M4_IntT5     =   23,
+    CV_M4_IntT6     =   24,
+    CV_M4_IntT7     =   25,
+    CV_M4_IntS0     =   26,
+    CV_M4_IntS1     =   27,
+    CV_M4_IntS2     =   28,
+    CV_M4_IntS3     =   29,
+    CV_M4_IntS4     =   30,
+    CV_M4_IntS5     =   31,
+    CV_M4_IntS6     =   32,
+    CV_M4_IntS7     =   33,
+    CV_M4_IntT8     =   34,
+    CV_M4_IntT9     =   35,
+    CV_M4_IntKT0    =   36,
+    CV_M4_IntKT1    =   37,
+    CV_M4_IntGP     =   38,
+    CV_M4_IntSP     =   39,
+    CV_M4_IntS8     =   40,
+    CV_M4_IntRA     =   41,
+    CV_M4_IntLO     =   42,
+    CV_M4_IntHI     =   43,
+
+    CV_M4_Fir       =   50,
+    CV_M4_Psr       =   51,
+
+    CV_M4_FltF0     =   60,      /* Floating point registers */
+    CV_M4_FltF1     =   61,
+    CV_M4_FltF2     =   62,
+    CV_M4_FltF3     =   63,
+    CV_M4_FltF4     =   64,
+    CV_M4_FltF5     =   65,
+    CV_M4_FltF6     =   66,
+    CV_M4_FltF7     =   67,
+    CV_M4_FltF8     =   68,
+    CV_M4_FltF9     =   69,
+    CV_M4_FltF10    =   70,
+    CV_M4_FltF11    =   71,
+    CV_M4_FltF12    =   72,
+    CV_M4_FltF13    =   73,
+    CV_M4_FltF14    =   74,
+    CV_M4_FltF15    =   75,
+    CV_M4_FltF16    =   76,
+    CV_M4_FltF17    =   77,
+    CV_M4_FltF18    =   78,
+    CV_M4_FltF19    =   79,
+    CV_M4_FltF20    =   80,
+    CV_M4_FltF21    =   81,
+    CV_M4_FltF22    =   82,
+    CV_M4_FltF23    =   83,
+    CV_M4_FltF24    =   84,
+    CV_M4_FltF25    =   85,
+    CV_M4_FltF26    =   86,
+    CV_M4_FltF27    =   87,
+    CV_M4_FltF28    =   88,
+    CV_M4_FltF29    =   89,
+    CV_M4_FltF30    =   90,
+    CV_M4_FltF31    =   91,
+    CV_M4_FltFsr    =   92,
+
+
+    // Register set for the ALPHA AXP
+
+    CV_ALPHA_NOREG  = CV_REG_NONE,
+
+    CV_ALPHA_FltF0  =   10,   // Floating point registers
+    CV_ALPHA_FltF1  =   11,
+    CV_ALPHA_FltF2  =   12,
+    CV_ALPHA_FltF3  =   13,
+    CV_ALPHA_FltF4  =   14,
+    CV_ALPHA_FltF5  =   15,
+    CV_ALPHA_FltF6  =   16,
+    CV_ALPHA_FltF7  =   17,
+    CV_ALPHA_FltF8  =   18,
+    CV_ALPHA_FltF9  =   19,
+    CV_ALPHA_FltF10 =   20,
+    CV_ALPHA_FltF11 =   21,
+    CV_ALPHA_FltF12 =   22,
+    CV_ALPHA_FltF13 =   23,
+    CV_ALPHA_FltF14 =   24,
+    CV_ALPHA_FltF15 =   25,
+    CV_ALPHA_FltF16 =   26,
+    CV_ALPHA_FltF17 =   27,
+    CV_ALPHA_FltF18 =   28,
+    CV_ALPHA_FltF19 =   29,
+    CV_ALPHA_FltF20 =   30,
+    CV_ALPHA_FltF21 =   31,
+    CV_ALPHA_FltF22 =   32,
+    CV_ALPHA_FltF23 =   33,
+    CV_ALPHA_FltF24 =   34,
+    CV_ALPHA_FltF25 =   35,
+    CV_ALPHA_FltF26 =   36,
+    CV_ALPHA_FltF27 =   37,
+    CV_ALPHA_FltF28 =   38,
+    CV_ALPHA_FltF29 =   39,
+    CV_ALPHA_FltF30 =   40,
+    CV_ALPHA_FltF31 =   41,
+
+    CV_ALPHA_IntV0  =   42,   // Integer registers
+    CV_ALPHA_IntT0  =   43,
+    CV_ALPHA_IntT1  =   44,
+    CV_ALPHA_IntT2  =   45,
+    CV_ALPHA_IntT3  =   46,
+    CV_ALPHA_IntT4  =   47,
+    CV_ALPHA_IntT5  =   48,
+    CV_ALPHA_IntT6  =   49,
+    CV_ALPHA_IntT7  =   50,
+    CV_ALPHA_IntS0  =   51,
+    CV_ALPHA_IntS1  =   52,
+    CV_ALPHA_IntS2  =   53,
+    CV_ALPHA_IntS3  =   54,
+    CV_ALPHA_IntS4  =   55,
+    CV_ALPHA_IntS5  =   56,
+    CV_ALPHA_IntFP  =   57,
+    CV_ALPHA_IntA0  =   58,
+    CV_ALPHA_IntA1  =   59,
+    CV_ALPHA_IntA2  =   60,
+    CV_ALPHA_IntA3  =   61,
+    CV_ALPHA_IntA4  =   62,
+    CV_ALPHA_IntA5  =   63,
+    CV_ALPHA_IntT8  =   64,
+    CV_ALPHA_IntT9  =   65,
+    CV_ALPHA_IntT10 =   66,
+    CV_ALPHA_IntT11 =   67,
+    CV_ALPHA_IntRA  =   68,
+    CV_ALPHA_IntT12 =   69,
+    CV_ALPHA_IntAT  =   70,
+    CV_ALPHA_IntGP  =   71,
+    CV_ALPHA_IntSP  =   72,
+    CV_ALPHA_IntZERO =  73,
+
+
+    CV_ALPHA_Fpcr   =   74,   // Control registers
+    CV_ALPHA_Fir    =   75,
+    CV_ALPHA_Psr    =   76,
+    CV_ALPHA_FltFsr =   77,
+    CV_ALPHA_SoftFpcr =   78,
+
+    // Register Set for Motorola/IBM PowerPC
+
+    /*
+    ** PowerPC General Registers ( User Level )
+    */
+    CV_PPC_GPR0     =  1,
+    CV_PPC_GPR1     =  2,
+    CV_PPC_GPR2     =  3,
+    CV_PPC_GPR3     =  4,
+    CV_PPC_GPR4     =  5,
+    CV_PPC_GPR5     =  6,
+    CV_PPC_GPR6     =  7,
+    CV_PPC_GPR7     =  8,
+    CV_PPC_GPR8     =  9,
+    CV_PPC_GPR9     = 10,
+    CV_PPC_GPR10    = 11,
+    CV_PPC_GPR11    = 12,
+    CV_PPC_GPR12    = 13,
+    CV_PPC_GPR13    = 14,
+    CV_PPC_GPR14    = 15,
+    CV_PPC_GPR15    = 16,
+    CV_PPC_GPR16    = 17,
+    CV_PPC_GPR17    = 18,
+    CV_PPC_GPR18    = 19,
+    CV_PPC_GPR19    = 20,
+    CV_PPC_GPR20    = 21,
+    CV_PPC_GPR21    = 22,
+    CV_PPC_GPR22    = 23,
+    CV_PPC_GPR23    = 24,
+    CV_PPC_GPR24    = 25,
+    CV_PPC_GPR25    = 26,
+    CV_PPC_GPR26    = 27,
+    CV_PPC_GPR27    = 28,
+    CV_PPC_GPR28    = 29,
+    CV_PPC_GPR29    = 30,
+    CV_PPC_GPR30    = 31,
+    CV_PPC_GPR31    = 32,
+
+    /*
+    ** PowerPC Condition Register ( User Level )
+    */
+    CV_PPC_CR       = 33,
+    CV_PPC_CR0      = 34,
+    CV_PPC_CR1      = 35,
+    CV_PPC_CR2      = 36,
+    CV_PPC_CR3      = 37,
+    CV_PPC_CR4      = 38,
+    CV_PPC_CR5      = 39,
+    CV_PPC_CR6      = 40,
+    CV_PPC_CR7      = 41,
+
+    /*
+    ** PowerPC Floating Point Registers ( User Level )
+    */
+    CV_PPC_FPR0     = 42,
+    CV_PPC_FPR1     = 43,
+    CV_PPC_FPR2     = 44,
+    CV_PPC_FPR3     = 45,
+    CV_PPC_FPR4     = 46,
+    CV_PPC_FPR5     = 47,
+    CV_PPC_FPR6     = 48,
+    CV_PPC_FPR7     = 49,
+    CV_PPC_FPR8     = 50,
+    CV_PPC_FPR9     = 51,
+    CV_PPC_FPR10    = 52,
+    CV_PPC_FPR11    = 53,
+    CV_PPC_FPR12    = 54,
+    CV_PPC_FPR13    = 55,
+    CV_PPC_FPR14    = 56,
+    CV_PPC_FPR15    = 57,
+    CV_PPC_FPR16    = 58,
+    CV_PPC_FPR17    = 59,
+    CV_PPC_FPR18    = 60,
+    CV_PPC_FPR19    = 61,
+    CV_PPC_FPR20    = 62,
+    CV_PPC_FPR21    = 63,
+    CV_PPC_FPR22    = 64,
+    CV_PPC_FPR23    = 65,
+    CV_PPC_FPR24    = 66,
+    CV_PPC_FPR25    = 67,
+    CV_PPC_FPR26    = 68,
+    CV_PPC_FPR27    = 69,
+    CV_PPC_FPR28    = 70,
+    CV_PPC_FPR29    = 71,
+    CV_PPC_FPR30    = 72,
+    CV_PPC_FPR31    = 73,
+
+    /*
+    ** PowerPC Floating Point Status and Control Register ( User Level )
+    */
+    CV_PPC_FPSCR    = 74,
+
+    /*
+    ** PowerPC Machine State Register ( Supervisor Level )
+    */
+    CV_PPC_MSR      = 75,
+
+    /*
+    ** PowerPC Segment Registers ( Supervisor Level )
+    */
+    CV_PPC_SR0      = 76,
+    CV_PPC_SR1      = 77,
+    CV_PPC_SR2      = 78,
+    CV_PPC_SR3      = 79,
+    CV_PPC_SR4      = 80,
+    CV_PPC_SR5      = 81,
+    CV_PPC_SR6      = 82,
+    CV_PPC_SR7      = 83,
+    CV_PPC_SR8      = 84,
+    CV_PPC_SR9      = 85,
+    CV_PPC_SR10     = 86,
+    CV_PPC_SR11     = 87,
+    CV_PPC_SR12     = 88,
+    CV_PPC_SR13     = 89,
+    CV_PPC_SR14     = 90,
+    CV_PPC_SR15     = 91,
+
+    /*
+    ** For all of the special purpose registers add 100 to the SPR# that the
+    ** Motorola/IBM documentation gives with the exception of any imaginary
+    ** registers.
+    */
+
+    /*
+    ** PowerPC Special Purpose Registers ( User Level )
+    */
+    CV_PPC_PC       = 99,     // PC (imaginary register)
+
+    CV_PPC_MQ       = 100,    // MPC601
+    CV_PPC_XER      = 101,
+    CV_PPC_RTCU     = 104,    // MPC601
+    CV_PPC_RTCL     = 105,    // MPC601
+    CV_PPC_LR       = 108,
+    CV_PPC_CTR      = 109,
+
+    CV_PPC_COMPARE  = 110,    // part of XER (internal to the debugger only)
+    CV_PPC_COUNT    = 111,    // part of XER (internal to the debugger only)
+
+    /*
+    ** PowerPC Special Purpose Registers ( Supervisor Level )
+    */
+    CV_PPC_DSISR    = 118,
+    CV_PPC_DAR      = 119,
+    CV_PPC_DEC      = 122,
+    CV_PPC_SDR1     = 125,
+    CV_PPC_SRR0     = 126,
+    CV_PPC_SRR1     = 127,
+    CV_PPC_SPRG0    = 372,
+    CV_PPC_SPRG1    = 373,
+    CV_PPC_SPRG2    = 374,
+    CV_PPC_SPRG3    = 375,
+    CV_PPC_ASR      = 280,    // 64-bit implementations only
+    CV_PPC_EAR      = 382,
+    CV_PPC_PVR      = 287,
+    CV_PPC_BAT0U    = 628,
+    CV_PPC_BAT0L    = 629,
+    CV_PPC_BAT1U    = 630,
+    CV_PPC_BAT1L    = 631,
+    CV_PPC_BAT2U    = 632,
+    CV_PPC_BAT2L    = 633,
+    CV_PPC_BAT3U    = 634,
+    CV_PPC_BAT3L    = 635,
+    CV_PPC_DBAT0U   = 636,
+    CV_PPC_DBAT0L   = 637,
+    CV_PPC_DBAT1U   = 638,
+    CV_PPC_DBAT1L   = 639,
+    CV_PPC_DBAT2U   = 640,
+    CV_PPC_DBAT2L   = 641,
+    CV_PPC_DBAT3U   = 642,
+    CV_PPC_DBAT3L   = 643,
+
+    /*
+    ** PowerPC Special Purpose Registers Implementation Dependent ( Supervisor Level )
+    */
+
+    /*
+    ** Doesn't appear that IBM/Motorola has finished defining these.
+    */
+
+    CV_PPC_PMR0     = 1044,   // MPC620,
+    CV_PPC_PMR1     = 1045,   // MPC620,
+    CV_PPC_PMR2     = 1046,   // MPC620,
+    CV_PPC_PMR3     = 1047,   // MPC620,
+    CV_PPC_PMR4     = 1048,   // MPC620,
+    CV_PPC_PMR5     = 1049,   // MPC620,
+    CV_PPC_PMR6     = 1050,   // MPC620,
+    CV_PPC_PMR7     = 1051,   // MPC620,
+    CV_PPC_PMR8     = 1052,   // MPC620,
+    CV_PPC_PMR9     = 1053,   // MPC620,
+    CV_PPC_PMR10    = 1054,   // MPC620,
+    CV_PPC_PMR11    = 1055,   // MPC620,
+    CV_PPC_PMR12    = 1056,   // MPC620,
+    CV_PPC_PMR13    = 1057,   // MPC620,
+    CV_PPC_PMR14    = 1058,   // MPC620,
+    CV_PPC_PMR15    = 1059,   // MPC620,
+
+    CV_PPC_DMISS    = 1076,   // MPC603
+    CV_PPC_DCMP     = 1077,   // MPC603
+    CV_PPC_HASH1    = 1078,   // MPC603
+    CV_PPC_HASH2    = 1079,   // MPC603
+    CV_PPC_IMISS    = 1080,   // MPC603
+    CV_PPC_ICMP     = 1081,   // MPC603
+    CV_PPC_RPA      = 1082,   // MPC603
+
+    CV_PPC_HID0     = 1108,   // MPC601, MPC603, MPC620
+    CV_PPC_HID1     = 1109,   // MPC601
+    CV_PPC_HID2     = 1110,   // MPC601, MPC603, MPC620 ( IABR )
+    CV_PPC_HID3     = 1111,   // Not Defined
+    CV_PPC_HID4     = 1112,   // Not Defined
+    CV_PPC_HID5     = 1113,   // MPC601, MPC604, MPC620 ( DABR )
+    CV_PPC_HID6     = 1114,   // Not Defined
+    CV_PPC_HID7     = 1115,   // Not Defined
+    CV_PPC_HID8     = 1116,   // MPC620 ( BUSCSR )
+    CV_PPC_HID9     = 1117,   // MPC620 ( L2CSR )
+    CV_PPC_HID10    = 1118,   // Not Defined
+    CV_PPC_HID11    = 1119,   // Not Defined
+    CV_PPC_HID12    = 1120,   // Not Defined
+    CV_PPC_HID13    = 1121,   // MPC604 ( HCR )
+    CV_PPC_HID14    = 1122,   // Not Defined
+    CV_PPC_HID15    = 1123,   // MPC601, MPC604, MPC620 ( PIR )
+
+    //
+    // JAVA VM registers
+    //
+
+    CV_JAVA_PC      = 1,
+
+    //
+    // Register set for the Hitachi SH3
+    //
+
+    CV_SH3_NOREG    =   CV_REG_NONE,
+
+    CV_SH3_IntR0    =   10,   // CPU REGISTER
+    CV_SH3_IntR1    =   11,
+    CV_SH3_IntR2    =   12,
+    CV_SH3_IntR3    =   13,
+    CV_SH3_IntR4    =   14,
+    CV_SH3_IntR5    =   15,
+    CV_SH3_IntR6    =   16,
+    CV_SH3_IntR7    =   17,
+    CV_SH3_IntR8    =   18,
+    CV_SH3_IntR9    =   19,
+    CV_SH3_IntR10   =   20,
+    CV_SH3_IntR11   =   21,
+    CV_SH3_IntR12   =   22,
+    CV_SH3_IntR13   =   23,
+    CV_SH3_IntFp    =   24,
+    CV_SH3_IntSp    =   25,
+    CV_SH3_Gbr      =   38,
+    CV_SH3_Pr       =   39,
+    CV_SH3_Mach     =   40,
+    CV_SH3_Macl     =   41,
+
+    CV_SH3_Pc       =   50,
+    CV_SH3_Sr       =   51,
+
+    CV_SH3_BarA     =   60,
+    CV_SH3_BasrA    =   61,
+    CV_SH3_BamrA    =   62,
+    CV_SH3_BbrA     =   63,
+    CV_SH3_BarB     =   64,
+    CV_SH3_BasrB    =   65,
+    CV_SH3_BamrB    =   66,
+    CV_SH3_BbrB     =   67,
+    CV_SH3_BdrB     =   68,
+    CV_SH3_BdmrB    =   69,
+    CV_SH3_Brcr     =   70,
+
+    //
+    // Additional registers for Hitachi SH processors
+    //
+
+    CV_SH_Fpscr    =   75,    // floating point status/control register
+    CV_SH_Fpul     =   76,    // floating point communication register
+
+    CV_SH_FpR0     =   80,    // Floating point registers
+    CV_SH_FpR1     =   81,
+    CV_SH_FpR2     =   82,
+    CV_SH_FpR3     =   83,
+    CV_SH_FpR4     =   84,
+    CV_SH_FpR5     =   85,
+    CV_SH_FpR6     =   86,
+    CV_SH_FpR7     =   87,
+    CV_SH_FpR8     =   88,
+    CV_SH_FpR9     =   89,
+    CV_SH_FpR10    =   90,
+    CV_SH_FpR11    =   91,
+    CV_SH_FpR12    =   92,
+    CV_SH_FpR13    =   93,
+    CV_SH_FpR14    =   94,
+    CV_SH_FpR15    =   95,
+
+    CV_SH_XFpR0    =   96,
+    CV_SH_XFpR1    =   97,
+    CV_SH_XFpR2    =   98,
+    CV_SH_XFpR3    =   99,
+    CV_SH_XFpR4    =  100,
+    CV_SH_XFpR5    =  101,
+    CV_SH_XFpR6    =  102,
+    CV_SH_XFpR7    =  103,
+    CV_SH_XFpR8    =  104,
+    CV_SH_XFpR9    =  105,
+    CV_SH_XFpR10   =  106,
+    CV_SH_XFpR11   =  107,
+    CV_SH_XFpR12   =  108,
+    CV_SH_XFpR13   =  109,
+    CV_SH_XFpR14   =  110,
+    CV_SH_XFpR15   =  111,
+
+    //
+    // Register set for the ARM processor.
+    //
+
+    CV_ARM_NOREG    =   CV_REG_NONE,
+
+    CV_ARM_R0       =   10,
+    CV_ARM_R1       =   11,
+    CV_ARM_R2       =   12,
+    CV_ARM_R3       =   13,
+    CV_ARM_R4       =   14,
+    CV_ARM_R5       =   15,
+    CV_ARM_R6       =   16,
+    CV_ARM_R7       =   17,
+    CV_ARM_R8       =   18,
+    CV_ARM_R9       =   19,
+    CV_ARM_R10      =   20,
+    CV_ARM_R11      =   21, // Frame pointer, if allocated
+    CV_ARM_R12      =   22,
+    CV_ARM_SP       =   23, // Stack pointer
+    CV_ARM_LR       =   24, // Link Register
+    CV_ARM_PC       =   25, // Program counter
+    CV_ARM_CPSR     =   26, // Current program status register
+
+    //
+    // Register set for Intel IA64
+    //
+
+    CV_IA64_NOREG   =   CV_REG_NONE,
+
+    // Branch Registers
+
+    CV_IA64_Br0     =   512,
+    CV_IA64_Br1     =   513,
+    CV_IA64_Br2     =   514,
+    CV_IA64_Br3     =   515,
+    CV_IA64_Br4     =   516,
+    CV_IA64_Br5     =   517,
+    CV_IA64_Br6     =   518,
+    CV_IA64_Br7     =   519,
+
+    // Predicate Registers
+
+    CV_IA64_P0    =   704,
+    CV_IA64_P1    =   705,
+    CV_IA64_P2    =   706,
+    CV_IA64_P3    =   707,
+    CV_IA64_P4    =   708,
+    CV_IA64_P5    =   709,
+    CV_IA64_P6    =   710,
+    CV_IA64_P7    =   711,
+    CV_IA64_P8    =   712,
+    CV_IA64_P9    =   713,
+    CV_IA64_P10   =   714,
+    CV_IA64_P11   =   715,
+    CV_IA64_P12   =   716,
+    CV_IA64_P13   =   717,
+    CV_IA64_P14   =   718,
+    CV_IA64_P15   =   719,
+    CV_IA64_P16   =   720,
+    CV_IA64_P17   =   721,
+    CV_IA64_P18   =   722,
+    CV_IA64_P19   =   723,
+    CV_IA64_P20   =   724,
+    CV_IA64_P21   =   725,
+    CV_IA64_P22   =   726,
+    CV_IA64_P23   =   727,
+    CV_IA64_P24   =   728,
+    CV_IA64_P25   =   729,
+    CV_IA64_P26   =   730,
+    CV_IA64_P27   =   731,
+    CV_IA64_P28   =   732,
+    CV_IA64_P29   =   733,
+    CV_IA64_P30   =   734,
+    CV_IA64_P31   =   735,
+    CV_IA64_P32   =   736,
+    CV_IA64_P33   =   737,
+    CV_IA64_P34   =   738,
+    CV_IA64_P35   =   739,
+    CV_IA64_P36   =   740,
+    CV_IA64_P37   =   741,
+    CV_IA64_P38   =   742,
+    CV_IA64_P39   =   743,
+    CV_IA64_P40   =   744,
+    CV_IA64_P41   =   745,
+    CV_IA64_P42   =   746,
+    CV_IA64_P43   =   747,
+    CV_IA64_P44   =   748,
+    CV_IA64_P45   =   749,
+    CV_IA64_P46   =   750,
+    CV_IA64_P47   =   751,
+    CV_IA64_P48   =   752,
+    CV_IA64_P49   =   753,
+    CV_IA64_P50   =   754,
+    CV_IA64_P51   =   755,
+    CV_IA64_P52   =   756,
+    CV_IA64_P53   =   757,
+    CV_IA64_P54   =   758,
+    CV_IA64_P55   =   759,
+    CV_IA64_P56   =   760,
+    CV_IA64_P57   =   761,
+    CV_IA64_P58   =   762,
+    CV_IA64_P59   =   763,
+    CV_IA64_P60   =   764,
+    CV_IA64_P61   =   765,
+    CV_IA64_P62   =   766,
+    CV_IA64_P63   =   767,
+
+    CV_IA64_Preds   =   768,
+
+    // Banked General Registers
+
+    CV_IA64_IntH0   =   832,
+    CV_IA64_IntH1   =   833,
+    CV_IA64_IntH2   =   834,
+    CV_IA64_IntH3   =   835,
+    CV_IA64_IntH4   =   836,
+    CV_IA64_IntH5   =   837,
+    CV_IA64_IntH6   =   838,
+    CV_IA64_IntH7   =   839,
+    CV_IA64_IntH8   =   840,
+    CV_IA64_IntH9   =   841,
+    CV_IA64_IntH10  =   842,
+    CV_IA64_IntH11  =   843,
+    CV_IA64_IntH12  =   844,
+    CV_IA64_IntH13  =   845,
+    CV_IA64_IntH14  =   846,
+    CV_IA64_IntH15  =   847,
+
+    // Special Registers
+
+    CV_IA64_Ip      =   1016,
+    CV_IA64_Umask   =   1017,
+    CV_IA64_Cfm     =   1018,
+    CV_IA64_Psr     =   1019,
+
+    // Banked General Registers
+
+    CV_IA64_Nats    =   1020,
+    CV_IA64_Nats2   =   1021,
+    CV_IA64_Nats3   =   1022,
+
+    // General-Purpose Registers
+
+    // Integer registers
+    CV_IA64_IntR0   =   1024,
+    CV_IA64_IntR1   =   1025,
+    CV_IA64_IntR2   =   1026,
+    CV_IA64_IntR3   =   1027,
+    CV_IA64_IntR4   =   1028,
+    CV_IA64_IntR5   =   1029,
+    CV_IA64_IntR6   =   1030,
+    CV_IA64_IntR7   =   1031,
+    CV_IA64_IntR8   =   1032,
+    CV_IA64_IntR9   =   1033,
+    CV_IA64_IntR10  =   1034,
+    CV_IA64_IntR11  =   1035,
+    CV_IA64_IntR12  =   1036,
+    CV_IA64_IntR13  =   1037,
+    CV_IA64_IntR14  =   1038,
+    CV_IA64_IntR15  =   1039,
+    CV_IA64_IntR16  =   1040,
+    CV_IA64_IntR17  =   1041,
+    CV_IA64_IntR18  =   1042,
+    CV_IA64_IntR19  =   1043,
+    CV_IA64_IntR20  =   1044,
+    CV_IA64_IntR21  =   1045,
+    CV_IA64_IntR22  =   1046,
+    CV_IA64_IntR23  =   1047,
+    CV_IA64_IntR24  =   1048,
+    CV_IA64_IntR25  =   1049,
+    CV_IA64_IntR26  =   1050,
+    CV_IA64_IntR27  =   1051,
+    CV_IA64_IntR28  =   1052,
+    CV_IA64_IntR29  =   1053,
+    CV_IA64_IntR30  =   1054,
+    CV_IA64_IntR31  =   1055,
+
+    // Register Stack
+    CV_IA64_IntR32  =   1056,
+    CV_IA64_IntR33  =   1057,
+    CV_IA64_IntR34  =   1058,
+    CV_IA64_IntR35  =   1059,
+    CV_IA64_IntR36  =   1060,
+    CV_IA64_IntR37  =   1061,
+    CV_IA64_IntR38  =   1062,
+    CV_IA64_IntR39  =   1063,
+    CV_IA64_IntR40  =   1064,
+    CV_IA64_IntR41  =   1065,
+    CV_IA64_IntR42  =   1066,
+    CV_IA64_IntR43  =   1067,
+    CV_IA64_IntR44  =   1068,
+    CV_IA64_IntR45  =   1069,
+    CV_IA64_IntR46  =   1070,
+    CV_IA64_IntR47  =   1071,
+    CV_IA64_IntR48  =   1072,
+    CV_IA64_IntR49  =   1073,
+    CV_IA64_IntR50  =   1074,
+    CV_IA64_IntR51  =   1075,
+    CV_IA64_IntR52  =   1076,
+    CV_IA64_IntR53  =   1077,
+    CV_IA64_IntR54  =   1078,
+    CV_IA64_IntR55  =   1079,
+    CV_IA64_IntR56  =   1080,
+    CV_IA64_IntR57  =   1081,
+    CV_IA64_IntR58  =   1082,
+    CV_IA64_IntR59  =   1083,
+    CV_IA64_IntR60  =   1084,
+    CV_IA64_IntR61  =   1085,
+    CV_IA64_IntR62  =   1086,
+    CV_IA64_IntR63  =   1087,
+    CV_IA64_IntR64  =   1088,
+    CV_IA64_IntR65  =   1089,
+    CV_IA64_IntR66  =   1090,
+    CV_IA64_IntR67  =   1091,
+    CV_IA64_IntR68  =   1092,
+    CV_IA64_IntR69  =   1093,
+    CV_IA64_IntR70  =   1094,
+    CV_IA64_IntR71  =   1095,
+    CV_IA64_IntR72  =   1096,
+    CV_IA64_IntR73  =   1097,
+    CV_IA64_IntR74  =   1098,
+    CV_IA64_IntR75  =   1099,
+    CV_IA64_IntR76  =   1100,
+    CV_IA64_IntR77  =   1101,
+    CV_IA64_IntR78  =   1102,
+    CV_IA64_IntR79  =   1103,
+    CV_IA64_IntR80  =   1104,
+    CV_IA64_IntR81  =   1105,
+    CV_IA64_IntR82  =   1106,
+    CV_IA64_IntR83  =   1107,
+    CV_IA64_IntR84  =   1108,
+    CV_IA64_IntR85  =   1109,
+    CV_IA64_IntR86  =   1110,
+    CV_IA64_IntR87  =   1111,
+    CV_IA64_IntR88  =   1112,
+    CV_IA64_IntR89  =   1113,
+    CV_IA64_IntR90  =   1114,
+    CV_IA64_IntR91  =   1115,
+    CV_IA64_IntR92  =   1116,
+    CV_IA64_IntR93  =   1117,
+    CV_IA64_IntR94  =   1118,
+    CV_IA64_IntR95  =   1119,
+    CV_IA64_IntR96  =   1120,
+    CV_IA64_IntR97  =   1121,
+    CV_IA64_IntR98  =   1122,
+    CV_IA64_IntR99  =   1123,
+    CV_IA64_IntR100 =   1124,
+    CV_IA64_IntR101 =   1125,
+    CV_IA64_IntR102 =   1126,
+    CV_IA64_IntR103 =   1127,
+    CV_IA64_IntR104 =   1128,
+    CV_IA64_IntR105 =   1129,
+    CV_IA64_IntR106 =   1130,
+    CV_IA64_IntR107 =   1131,
+    CV_IA64_IntR108 =   1132,
+    CV_IA64_IntR109 =   1133,
+    CV_IA64_IntR110 =   1134,
+    CV_IA64_IntR111 =   1135,
+    CV_IA64_IntR112 =   1136,
+    CV_IA64_IntR113 =   1137,
+    CV_IA64_IntR114 =   1138,
+    CV_IA64_IntR115 =   1139,
+    CV_IA64_IntR116 =   1140,
+    CV_IA64_IntR117 =   1141,
+    CV_IA64_IntR118 =   1142,
+    CV_IA64_IntR119 =   1143,
+    CV_IA64_IntR120 =   1144,
+    CV_IA64_IntR121 =   1145,
+    CV_IA64_IntR122 =   1146,
+    CV_IA64_IntR123 =   1147,
+    CV_IA64_IntR124 =   1148,
+    CV_IA64_IntR125 =   1149,
+    CV_IA64_IntR126 =   1150,
+    CV_IA64_IntR127 =   1151,
+
+    // Floating-Point Registers
+
+    // Low Floating Point Registers
+    CV_IA64_FltF0   =   2048,
+    CV_IA64_FltF1   =   2049,
+    CV_IA64_FltF2   =   2050,
+    CV_IA64_FltF3   =   2051,
+    CV_IA64_FltF4   =   2052,
+    CV_IA64_FltF5   =   2053,
+    CV_IA64_FltF6   =   2054,
+    CV_IA64_FltF7   =   2055,
+    CV_IA64_FltF8   =   2056,
+    CV_IA64_FltF9   =   2057,
+    CV_IA64_FltF10  =   2058,
+    CV_IA64_FltF11  =   2059,
+    CV_IA64_FltF12  =   2060,
+    CV_IA64_FltF13  =   2061,
+    CV_IA64_FltF14  =   2062,
+    CV_IA64_FltF15  =   2063,
+    CV_IA64_FltF16  =   2064,
+    CV_IA64_FltF17  =   2065,
+    CV_IA64_FltF18  =   2066,
+    CV_IA64_FltF19  =   2067,
+    CV_IA64_FltF20  =   2068,
+    CV_IA64_FltF21  =   2069,
+    CV_IA64_FltF22  =   2070,
+    CV_IA64_FltF23  =   2071,
+    CV_IA64_FltF24  =   2072,
+    CV_IA64_FltF25  =   2073,
+    CV_IA64_FltF26  =   2074,
+    CV_IA64_FltF27  =   2075,
+    CV_IA64_FltF28  =   2076,
+    CV_IA64_FltF29  =   2077,
+    CV_IA64_FltF30  =   2078,
+    CV_IA64_FltF31  =   2079,
+
+    // High Floating Point Registers
+    CV_IA64_FltF32  =   2080,
+    CV_IA64_FltF33  =   2081,
+    CV_IA64_FltF34  =   2082,
+    CV_IA64_FltF35  =   2083,
+    CV_IA64_FltF36  =   2084,
+    CV_IA64_FltF37  =   2085,
+    CV_IA64_FltF38  =   2086,
+    CV_IA64_FltF39  =   2087,
+    CV_IA64_FltF40  =   2088,
+    CV_IA64_FltF41  =   2089,
+    CV_IA64_FltF42  =   2090,
+    CV_IA64_FltF43  =   2091,
+    CV_IA64_FltF44  =   2092,
+    CV_IA64_FltF45  =   2093,
+    CV_IA64_FltF46  =   2094,
+    CV_IA64_FltF47  =   2095,
+    CV_IA64_FltF48  =   2096,
+    CV_IA64_FltF49  =   2097,
+    CV_IA64_FltF50  =   2098,
+    CV_IA64_FltF51  =   2099,
+    CV_IA64_FltF52  =   2100,
+    CV_IA64_FltF53  =   2101,
+    CV_IA64_FltF54  =   2102,
+    CV_IA64_FltF55  =   2103,
+    CV_IA64_FltF56  =   2104,
+    CV_IA64_FltF57  =   2105,
+    CV_IA64_FltF58  =   2106,
+    CV_IA64_FltF59  =   2107,
+    CV_IA64_FltF60  =   2108,
+    CV_IA64_FltF61  =   2109,
+    CV_IA64_FltF62  =   2110,
+    CV_IA64_FltF63  =   2111,
+    CV_IA64_FltF64  =   2112,
+    CV_IA64_FltF65  =   2113,
+    CV_IA64_FltF66  =   2114,
+    CV_IA64_FltF67  =   2115,
+    CV_IA64_FltF68  =   2116,
+    CV_IA64_FltF69  =   2117,
+    CV_IA64_FltF70  =   2118,
+    CV_IA64_FltF71  =   2119,
+    CV_IA64_FltF72  =   2120,
+    CV_IA64_FltF73  =   2121,
+    CV_IA64_FltF74  =   2122,
+    CV_IA64_FltF75  =   2123,
+    CV_IA64_FltF76  =   2124,
+    CV_IA64_FltF77  =   2125,
+    CV_IA64_FltF78  =   2126,
+    CV_IA64_FltF79  =   2127,
+    CV_IA64_FltF80  =   2128,
+    CV_IA64_FltF81  =   2129,
+    CV_IA64_FltF82  =   2130,
+    CV_IA64_FltF83  =   2131,
+    CV_IA64_FltF84  =   2132,
+    CV_IA64_FltF85  =   2133,
+    CV_IA64_FltF86  =   2134,
+    CV_IA64_FltF87  =   2135,
+    CV_IA64_FltF88  =   2136,
+    CV_IA64_FltF89  =   2137,
+    CV_IA64_FltF90  =   2138,
+    CV_IA64_FltF91  =   2139,
+    CV_IA64_FltF92  =   2140,
+    CV_IA64_FltF93  =   2141,
+    CV_IA64_FltF94  =   2142,
+    CV_IA64_FltF95  =   2143,
+    CV_IA64_FltF96  =   2144,
+    CV_IA64_FltF97  =   2145,
+    CV_IA64_FltF98  =   2146,
+    CV_IA64_FltF99  =   2147,
+    CV_IA64_FltF100 =   2148,
+    CV_IA64_FltF101 =   2149,
+    CV_IA64_FltF102 =   2150,
+    CV_IA64_FltF103 =   2151,
+    CV_IA64_FltF104 =   2152,
+    CV_IA64_FltF105 =   2153,
+    CV_IA64_FltF106 =   2154,
+    CV_IA64_FltF107 =   2155,
+    CV_IA64_FltF108 =   2156,
+    CV_IA64_FltF109 =   2157,
+    CV_IA64_FltF110 =   2158,
+    CV_IA64_FltF111 =   2159,
+    CV_IA64_FltF112 =   2160,
+    CV_IA64_FltF113 =   2161,
+    CV_IA64_FltF114 =   2162,
+    CV_IA64_FltF115 =   2163,
+    CV_IA64_FltF116 =   2164,
+    CV_IA64_FltF117 =   2165,
+    CV_IA64_FltF118 =   2166,
+    CV_IA64_FltF119 =   2167,
+    CV_IA64_FltF120 =   2168,
+    CV_IA64_FltF121 =   2169,
+    CV_IA64_FltF122 =   2170,
+    CV_IA64_FltF123 =   2171,
+    CV_IA64_FltF124 =   2172,
+    CV_IA64_FltF125 =   2173,
+    CV_IA64_FltF126 =   2174,
+    CV_IA64_FltF127 =   2175,
+
+    // Application Registers
+
+    CV_IA64_ApKR0   =   3072,
+    CV_IA64_ApKR1   =   3073,
+    CV_IA64_ApKR2   =   3074,
+    CV_IA64_ApKR3   =   3075,
+    CV_IA64_ApKR4   =   3076,
+    CV_IA64_ApKR5   =   3077,
+    CV_IA64_ApKR6   =   3078,
+    CV_IA64_ApKR7   =   3079,
+    CV_IA64_AR8     =   3080,
+    CV_IA64_AR9     =   3081,
+    CV_IA64_AR10    =   3082,
+    CV_IA64_AR11    =   3083,
+    CV_IA64_AR12    =   3084,
+    CV_IA64_AR13    =   3085,
+    CV_IA64_AR14    =   3086,
+    CV_IA64_AR15    =   3087,
+    CV_IA64_RsRSC   =   3088,
+    CV_IA64_RsBSP   =   3089,
+    CV_IA64_RsBSPSTORE  =   3090,
+    CV_IA64_RsRNAT  =   3091,
+    CV_IA64_AR20    =   3092,
+    CV_IA64_StFCR   =   3093,
+    CV_IA64_AR22    =   3094,
+    CV_IA64_AR23    =   3095,
+    CV_IA64_EFLAG   =   3096,
+    CV_IA64_CSD     =   3097,
+    CV_IA64_SSD     =   3098,
+    CV_IA64_CFLG    =   3099,
+    CV_IA64_StFSR   =   3100,
+    CV_IA64_StFIR   =   3101,
+    CV_IA64_StFDR   =   3102,
+    CV_IA64_AR31    =   3103,
+    CV_IA64_ApCCV   =   3104,
+    CV_IA64_AR33    =   3105,
+    CV_IA64_AR34    =   3106,
+    CV_IA64_AR35    =   3107,
+    CV_IA64_ApUNAT  =   3108,
+    CV_IA64_AR37    =   3109,
+    CV_IA64_AR38    =   3110,
+    CV_IA64_AR39    =   3111,
+    CV_IA64_StFPSR  =   3112,
+    CV_IA64_AR41    =   3113,
+    CV_IA64_AR42    =   3114,
+    CV_IA64_AR43    =   3115,
+    CV_IA64_ApITC   =   3116,
+    CV_IA64_AR45    =   3117,
+    CV_IA64_AR46    =   3118,
+    CV_IA64_AR47    =   3119,
+    CV_IA64_AR48    =   3120,
+    CV_IA64_AR49    =   3121,
+    CV_IA64_AR50    =   3122,
+    CV_IA64_AR51    =   3123,
+    CV_IA64_AR52    =   3124,
+    CV_IA64_AR53    =   3125,
+    CV_IA64_AR54    =   3126,
+    CV_IA64_AR55    =   3127,
+    CV_IA64_AR56    =   3128,
+    CV_IA64_AR57    =   3129,
+    CV_IA64_AR58    =   3130,
+    CV_IA64_AR59    =   3131,
+    CV_IA64_AR60    =   3132,
+    CV_IA64_AR61    =   3133,
+    CV_IA64_AR62    =   3134,
+    CV_IA64_AR63    =   3135,
+    CV_IA64_RsPFS   =   3136,
+    CV_IA64_ApLC    =   3137,
+    CV_IA64_ApEC    =   3138,
+    CV_IA64_AR67    =   3139,
+    CV_IA64_AR68    =   3140,
+    CV_IA64_AR69    =   3141,
+    CV_IA64_AR70    =   3142,
+    CV_IA64_AR71    =   3143,
+    CV_IA64_AR72    =   3144,
+    CV_IA64_AR73    =   3145,
+    CV_IA64_AR74    =   3146,
+    CV_IA64_AR75    =   3147,
+    CV_IA64_AR76    =   3148,
+    CV_IA64_AR77    =   3149,
+    CV_IA64_AR78    =   3150,
+    CV_IA64_AR79    =   3151,
+    CV_IA64_AR80    =   3152,
+    CV_IA64_AR81    =   3153,
+    CV_IA64_AR82    =   3154,
+    CV_IA64_AR83    =   3155,
+    CV_IA64_AR84    =   3156,
+    CV_IA64_AR85    =   3157,
+    CV_IA64_AR86    =   3158,
+    CV_IA64_AR87    =   3159,
+    CV_IA64_AR88    =   3160,
+    CV_IA64_AR89    =   3161,
+    CV_IA64_AR90    =   3162,
+    CV_IA64_AR91    =   3163,
+    CV_IA64_AR92    =   3164,
+    CV_IA64_AR93    =   3165,
+    CV_IA64_AR94    =   3166,
+    CV_IA64_AR95    =   3167,
+    CV_IA64_AR96    =   3168,
+    CV_IA64_AR97    =   3169,
+    CV_IA64_AR98    =   3170,
+    CV_IA64_AR99    =   3171,
+    CV_IA64_AR100   =   3172,
+    CV_IA64_AR101   =   3173,
+    CV_IA64_AR102   =   3174,
+    CV_IA64_AR103   =   3175,
+    CV_IA64_AR104   =   3176,
+    CV_IA64_AR105   =   3177,
+    CV_IA64_AR106   =   3178,
+    CV_IA64_AR107   =   3179,
+    CV_IA64_AR108   =   3180,
+    CV_IA64_AR109   =   3181,
+    CV_IA64_AR110   =   3182,
+    CV_IA64_AR111   =   3183,
+    CV_IA64_AR112   =   3184,
+    CV_IA64_AR113   =   3185,
+    CV_IA64_AR114   =   3186,
+    CV_IA64_AR115   =   3187,
+    CV_IA64_AR116   =   3188,
+    CV_IA64_AR117   =   3189,
+    CV_IA64_AR118   =   3190,
+    CV_IA64_AR119   =   3191,
+    CV_IA64_AR120   =   3192,
+    CV_IA64_AR121   =   3193,
+    CV_IA64_AR122   =   3194,
+    CV_IA64_AR123   =   3195,
+    CV_IA64_AR124   =   3196,
+    CV_IA64_AR125   =   3197,
+    CV_IA64_AR126   =   3198,
+    CV_IA64_AR127   =   3199,
+
+    // CPUID Registers
+
+    CV_IA64_CPUID0  =   3328,
+    CV_IA64_CPUID1  =   3329,
+    CV_IA64_CPUID2  =   3330,
+    CV_IA64_CPUID3  =   3331,
+    CV_IA64_CPUID4  =   3332,
+
+    // Control Registers
+
+    CV_IA64_ApDCR   =   4096,
+    CV_IA64_ApITM   =   4097,
+    CV_IA64_ApIVA   =   4098,
+    CV_IA64_CR3     =   4099,
+    CV_IA64_CR4     =   4100,
+    CV_IA64_CR5     =   4101,
+    CV_IA64_CR6     =   4102,
+    CV_IA64_CR7     =   4103,
+    CV_IA64_ApPTA   =   4104,
+    CV_IA64_ApGPTA  =   4105,
+    CV_IA64_CR10    =   4106,
+    CV_IA64_CR11    =   4107,
+    CV_IA64_CR12    =   4108,
+    CV_IA64_CR13    =   4109,
+    CV_IA64_CR14    =   4110,
+    CV_IA64_CR15    =   4111,
+    CV_IA64_StIPSR  =   4112,
+    CV_IA64_StISR   =   4113,
+    CV_IA64_CR18    =   4114,
+    CV_IA64_StIIP   =   4115,
+    CV_IA64_StIFA   =   4116,
+    CV_IA64_StITIR  =   4117,
+    CV_IA64_StIIPA  =   4118,
+    CV_IA64_StIFS   =   4119,
+    CV_IA64_StIIM   =   4120,
+    CV_IA64_StIHA   =   4121,
+    CV_IA64_CR26    =   4122,
+    CV_IA64_CR27    =   4123,
+    CV_IA64_CR28    =   4124,
+    CV_IA64_CR29    =   4125,
+    CV_IA64_CR30    =   4126,
+    CV_IA64_CR31    =   4127,
+    CV_IA64_CR32    =   4128,
+    CV_IA64_CR33    =   4129,
+    CV_IA64_CR34    =   4130,
+    CV_IA64_CR35    =   4131,
+    CV_IA64_CR36    =   4132,
+    CV_IA64_CR37    =   4133,
+    CV_IA64_CR38    =   4134,
+    CV_IA64_CR39    =   4135,
+    CV_IA64_CR40    =   4136,
+    CV_IA64_CR41    =   4137,
+    CV_IA64_CR42    =   4138,
+    CV_IA64_CR43    =   4139,
+    CV_IA64_CR44    =   4140,
+    CV_IA64_CR45    =   4141,
+    CV_IA64_CR46    =   4142,
+    CV_IA64_CR47    =   4143,
+    CV_IA64_CR48    =   4144,
+    CV_IA64_CR49    =   4145,
+    CV_IA64_CR50    =   4146,
+    CV_IA64_CR51    =   4147,
+    CV_IA64_CR52    =   4148,
+    CV_IA64_CR53    =   4149,
+    CV_IA64_CR54    =   4150,
+    CV_IA64_CR55    =   4151,
+    CV_IA64_CR56    =   4152,
+    CV_IA64_CR57    =   4153,
+    CV_IA64_CR58    =   4154,
+    CV_IA64_CR59    =   4155,
+    CV_IA64_CR60    =   4156,
+    CV_IA64_CR61    =   4157,
+    CV_IA64_CR62    =   4158,
+    CV_IA64_CR63    =   4159,
+    CV_IA64_SaLID   =   4160,
+    CV_IA64_SaIVR   =   4161,
+    CV_IA64_SaTPR   =   4162,
+    CV_IA64_SaEOI   =   4163,
+    CV_IA64_SaIRR0  =   4164,
+    CV_IA64_SaIRR1  =   4165,
+    CV_IA64_SaIRR2  =   4166,
+    CV_IA64_SaIRR3  =   4167,
+    CV_IA64_SaITV   =   4168,
+    CV_IA64_SaPMV   =   4169,
+    CV_IA64_SaCMCV  =   4170,
+    CV_IA64_CR75    =   4171,
+    CV_IA64_CR76    =   4172,
+    CV_IA64_CR77    =   4173,
+    CV_IA64_CR78    =   4174,
+    CV_IA64_CR79    =   4175,
+    CV_IA64_SaLRR0  =   4176,
+    CV_IA64_SaLRR1  =   4177,
+    CV_IA64_CR82    =   4178,
+    CV_IA64_CR83    =   4179,
+    CV_IA64_CR84    =   4180,
+    CV_IA64_CR85    =   4181,
+    CV_IA64_CR86    =   4182,
+    CV_IA64_CR87    =   4183,
+    CV_IA64_CR88    =   4184,
+    CV_IA64_CR89    =   4185,
+    CV_IA64_CR90    =   4186,
+    CV_IA64_CR91    =   4187,
+    CV_IA64_CR92    =   4188,
+    CV_IA64_CR93    =   4189,
+    CV_IA64_CR94    =   4190,
+    CV_IA64_CR95    =   4191,
+    CV_IA64_CR96    =   4192,
+    CV_IA64_CR97    =   4193,
+    CV_IA64_CR98    =   4194,
+    CV_IA64_CR99    =   4195,
+    CV_IA64_CR100   =   4196,
+    CV_IA64_CR101   =   4197,
+    CV_IA64_CR102   =   4198,
+    CV_IA64_CR103   =   4199,
+    CV_IA64_CR104   =   4200,
+    CV_IA64_CR105   =   4201,
+    CV_IA64_CR106   =   4202,
+    CV_IA64_CR107   =   4203,
+    CV_IA64_CR108   =   4204,
+    CV_IA64_CR109   =   4205,
+    CV_IA64_CR110   =   4206,
+    CV_IA64_CR111   =   4207,
+    CV_IA64_CR112   =   4208,
+    CV_IA64_CR113   =   4209,
+    CV_IA64_CR114   =   4210,
+    CV_IA64_CR115   =   4211,
+    CV_IA64_CR116   =   4212,
+    CV_IA64_CR117   =   4213,
+    CV_IA64_CR118   =   4214,
+    CV_IA64_CR119   =   4215,
+    CV_IA64_CR120   =   4216,
+    CV_IA64_CR121   =   4217,
+    CV_IA64_CR122   =   4218,
+    CV_IA64_CR123   =   4219,
+    CV_IA64_CR124   =   4220,
+    CV_IA64_CR125   =   4221,
+    CV_IA64_CR126   =   4222,
+    CV_IA64_CR127   =   4223,
+
+    // Protection Key Registers
+
+    CV_IA64_Pkr0    =   5120,
+    CV_IA64_Pkr1    =   5121,
+    CV_IA64_Pkr2    =   5122,
+    CV_IA64_Pkr3    =   5123,
+    CV_IA64_Pkr4    =   5124,
+    CV_IA64_Pkr5    =   5125,
+    CV_IA64_Pkr6    =   5126,
+    CV_IA64_Pkr7    =   5127,
+    CV_IA64_Pkr8    =   5128,
+    CV_IA64_Pkr9    =   5129,
+    CV_IA64_Pkr10   =   5130,
+    CV_IA64_Pkr11   =   5131,
+    CV_IA64_Pkr12   =   5132,
+    CV_IA64_Pkr13   =   5133,
+    CV_IA64_Pkr14   =   5134,
+    CV_IA64_Pkr15   =   5135,
+
+    // Region Registers
+
+    CV_IA64_Rr0     =   6144,
+    CV_IA64_Rr1     =   6145,
+    CV_IA64_Rr2     =   6146,
+    CV_IA64_Rr3     =   6147,
+    CV_IA64_Rr4     =   6148,
+    CV_IA64_Rr5     =   6149,
+    CV_IA64_Rr6     =   6150,
+    CV_IA64_Rr7     =   6151,
+
+    // Performance Monitor Data Registers
+
+    CV_IA64_PFD0    =   7168,
+    CV_IA64_PFD1    =   7169,
+    CV_IA64_PFD2    =   7170,
+    CV_IA64_PFD3    =   7171,
+    CV_IA64_PFD4    =   7172,
+    CV_IA64_PFD5    =   7173,
+    CV_IA64_PFD6    =   7174,
+    CV_IA64_PFD7    =   7175,
+    CV_IA64_PFD8    =   7176,
+    CV_IA64_PFD9    =   7177,
+    CV_IA64_PFD10   =   7178,
+    CV_IA64_PFD11   =   7179,
+    CV_IA64_PFD12   =   7180,
+    CV_IA64_PFD13   =   7181,
+    CV_IA64_PFD14   =   7182,
+    CV_IA64_PFD15   =   7183,
+    CV_IA64_PFD16   =   7184,
+    CV_IA64_PFD17   =   7185,
+
+    // Performance Monitor Config Registers
+
+    CV_IA64_PFC0    =   7424,
+    CV_IA64_PFC1    =   7425,
+    CV_IA64_PFC2    =   7426,
+    CV_IA64_PFC3    =   7427,
+    CV_IA64_PFC4    =   7428,
+    CV_IA64_PFC5    =   7429,
+    CV_IA64_PFC6    =   7430,
+    CV_IA64_PFC7    =   7431,
+    CV_IA64_PFC8    =   7432,
+    CV_IA64_PFC9    =   7433,
+    CV_IA64_PFC10   =   7434,
+    CV_IA64_PFC11   =   7435,
+    CV_IA64_PFC12   =   7436,
+    CV_IA64_PFC13   =   7437,
+    CV_IA64_PFC14   =   7438,
+    CV_IA64_PFC15   =   7439,
+
+    // Instruction Translation Registers
+
+    CV_IA64_TrI0    =   8192,
+    CV_IA64_TrI1    =   8193,
+    CV_IA64_TrI2    =   8194,
+    CV_IA64_TrI3    =   8195,
+    CV_IA64_TrI4    =   8196,
+    CV_IA64_TrI5    =   8197,
+    CV_IA64_TrI6    =   8198,
+    CV_IA64_TrI7    =   8199,
+
+    // Data Translation Registers
+
+    CV_IA64_TrD0    =   8320,
+    CV_IA64_TrD1    =   8321,
+    CV_IA64_TrD2    =   8322,
+    CV_IA64_TrD3    =   8323,
+    CV_IA64_TrD4    =   8324,
+    CV_IA64_TrD5    =   8325,
+    CV_IA64_TrD6    =   8326,
+    CV_IA64_TrD7    =   8327,
+
+    // Instruction Breakpoint Registers
+
+    CV_IA64_DbI0    =   8448,
+    CV_IA64_DbI1    =   8449,
+    CV_IA64_DbI2    =   8450,
+    CV_IA64_DbI3    =   8451,
+    CV_IA64_DbI4    =   8452,
+    CV_IA64_DbI5    =   8453,
+    CV_IA64_DbI6    =   8454,
+    CV_IA64_DbI7    =   8455,
+
+    // Data Breakpoint Registers
+
+    CV_IA64_DbD0    =   8576,
+    CV_IA64_DbD1    =   8577,
+    CV_IA64_DbD2    =   8578,
+    CV_IA64_DbD3    =   8579,
+    CV_IA64_DbD4    =   8580,
+    CV_IA64_DbD5    =   8581,
+    CV_IA64_DbD6    =   8582,
+    CV_IA64_DbD7    =   8583,
+
+    //
+    // Register set for the TriCore processor.
+    //
+
+    CV_TRI_NOREG    =   CV_REG_NONE,
+
+    // General Purpose Data Registers
+
+    CV_TRI_D0   =   10,
+    CV_TRI_D1   =   11,
+    CV_TRI_D2   =   12,
+    CV_TRI_D3   =   13,
+    CV_TRI_D4   =   14,
+    CV_TRI_D5   =   15,
+    CV_TRI_D6   =   16,
+    CV_TRI_D7   =   17,
+    CV_TRI_D8   =   18,
+    CV_TRI_D9   =   19,
+    CV_TRI_D10  =   20,
+    CV_TRI_D11  =   21,
+    CV_TRI_D12  =   22,
+    CV_TRI_D13  =   23,
+    CV_TRI_D14  =   24,
+    CV_TRI_D15  =   25,
+
+    // General Purpose Address Registers
+
+    CV_TRI_A0   =   26,
+    CV_TRI_A1   =   27,
+    CV_TRI_A2   =   28,
+    CV_TRI_A3   =   29,
+    CV_TRI_A4   =   30,
+    CV_TRI_A5   =   31,
+    CV_TRI_A6   =   32,
+    CV_TRI_A7   =   33,
+    CV_TRI_A8   =   34,
+    CV_TRI_A9   =   35,
+    CV_TRI_A10  =   36,
+    CV_TRI_A11  =   37,
+    CV_TRI_A12  =   38,
+    CV_TRI_A13  =   39,
+    CV_TRI_A14  =   40,
+    CV_TRI_A15  =   41,
+
+    // Extended (64-bit) data registers
+
+    CV_TRI_E0   =   42,
+    CV_TRI_E2   =   43,
+    CV_TRI_E4   =   44,
+    CV_TRI_E6   =   45,
+    CV_TRI_E8   =   46,
+    CV_TRI_E10  =   47,
+    CV_TRI_E12  =   48,
+    CV_TRI_E14  =   49,
+
+    // Extended (64-bit) address registers
+
+    CV_TRI_EA0  =   50,
+    CV_TRI_EA2  =   51,
+    CV_TRI_EA4  =   52,
+    CV_TRI_EA6  =   53,
+    CV_TRI_EA8  =   54,
+    CV_TRI_EA10 =   55,
+    CV_TRI_EA12 =   56,
+    CV_TRI_EA14 =   57,
+
+    CV_TRI_PSW  =   58,
+    CV_TRI_PCXI =   59,
+    CV_TRI_PC   =   60,
+    CV_TRI_FCX  =   61,
+    CV_TRI_LCX  =   62,
+    CV_TRI_ISP  =   63,
+    CV_TRI_ICR  =   64,
+    CV_TRI_BIV  =   65,
+    CV_TRI_BTV  =   66,
+    CV_TRI_SYSCON   =   67,
+    CV_TRI_DPRx_0   =   68,
+    CV_TRI_DPRx_1   =   69,
+    CV_TRI_DPRx_2   =   70,
+    CV_TRI_DPRx_3   =   71,
+    CV_TRI_CPRx_0   =   68,
+    CV_TRI_CPRx_1   =   69,
+    CV_TRI_CPRx_2   =   70,
+    CV_TRI_CPRx_3   =   71,
+    CV_TRI_DPMx_0   =   68,
+    CV_TRI_DPMx_1   =   69,
+    CV_TRI_DPMx_2   =   70,
+    CV_TRI_DPMx_3   =   71,
+    CV_TRI_CPMx_0   =   68,
+    CV_TRI_CPMx_1   =   69,
+    CV_TRI_CPMx_2   =   70,
+    CV_TRI_CPMx_3   =   71,
+    CV_TRI_DBGSSR   =   72,
+    CV_TRI_EXEVT    =   73,
+    CV_TRI_SWEVT    =   74,
+    CV_TRI_CREVT    =   75,
+    CV_TRI_TRnEVT   =   76,
+    CV_TRI_MMUCON   =   77,
+    CV_TRI_ASI      =   78,
+    CV_TRI_TVA      =   79,
+    CV_TRI_TPA      =   80,
+    CV_TRI_TPX      =   81,
+    CV_TRI_TFA      =   82,
+
+    //
+    // Register set for the AM33 and related processors.
+    //
+
+    CV_AM33_NOREG   =   CV_REG_NONE,
+
+    // "Extended" (general purpose integer) registers
+    CV_AM33_E0      =   10,
+    CV_AM33_E1      =   11,
+    CV_AM33_E2      =   12,
+    CV_AM33_E3      =   13,
+    CV_AM33_E4      =   14,
+    CV_AM33_E5      =   15,
+    CV_AM33_E6      =   16,
+    CV_AM33_E7      =   17,
+
+    // Address registers
+    CV_AM33_A0      =   20,
+    CV_AM33_A1      =   21,
+    CV_AM33_A2      =   22,
+    CV_AM33_A3      =   23,
+
+    // Integer data registers
+    CV_AM33_D0      =   30,
+    CV_AM33_D1      =   31,
+    CV_AM33_D2      =   32,
+    CV_AM33_D3      =   33,
+
+    // (Single-precision) floating-point registers
+    CV_AM33_FS0     =   40,
+    CV_AM33_FS1     =   41,
+    CV_AM33_FS2     =   42,
+    CV_AM33_FS3     =   43,
+    CV_AM33_FS4     =   44,
+    CV_AM33_FS5     =   45,
+    CV_AM33_FS6     =   46,
+    CV_AM33_FS7     =   47,
+    CV_AM33_FS8     =   48,
+    CV_AM33_FS9     =   49,
+    CV_AM33_FS10    =   50,
+    CV_AM33_FS11    =   51,
+    CV_AM33_FS12    =   52,
+    CV_AM33_FS13    =   53,
+    CV_AM33_FS14    =   54,
+    CV_AM33_FS15    =   55,
+    CV_AM33_FS16    =   56,
+    CV_AM33_FS17    =   57,
+    CV_AM33_FS18    =   58,
+    CV_AM33_FS19    =   59,
+    CV_AM33_FS20    =   60,
+    CV_AM33_FS21    =   61,
+    CV_AM33_FS22    =   62,
+    CV_AM33_FS23    =   63,
+    CV_AM33_FS24    =   64,
+    CV_AM33_FS25    =   65,
+    CV_AM33_FS26    =   66,
+    CV_AM33_FS27    =   67,
+    CV_AM33_FS28    =   68,
+    CV_AM33_FS29    =   69,
+    CV_AM33_FS30    =   70,
+    CV_AM33_FS31    =   71,
+
+    // Special purpose registers
+
+    // Stack pointer
+    CV_AM33_SP      =   80,
+
+    // Program counter
+    CV_AM33_PC      =   81,
+
+    // Multiply-divide/accumulate registers
+    CV_AM33_MDR     =   82,
+    CV_AM33_MDRQ    =   83,
+    CV_AM33_MCRH    =   84,
+    CV_AM33_MCRL    =   85,
+    CV_AM33_MCVF    =   86,
+
+    // CPU status words
+    CV_AM33_EPSW    =   87,
+    CV_AM33_FPCR    =   88,
+
+    // Loop buffer registers
+    CV_AM33_LIR     =   89,
+    CV_AM33_LAR     =   90,
+
+    //
+    // Register set for the Mitsubishi M32R
+    //
+
+    CV_M32R_NOREG    =   CV_REG_NONE,
+
+    CV_M32R_R0    =   10,
+    CV_M32R_R1    =   11,
+    CV_M32R_R2    =   12,
+    CV_M32R_R3    =   13,
+    CV_M32R_R4    =   14,
+    CV_M32R_R5    =   15,
+    CV_M32R_R6    =   16,
+    CV_M32R_R7    =   17,
+    CV_M32R_R8    =   18,
+    CV_M32R_R9    =   19,
+    CV_M32R_R10   =   20,
+    CV_M32R_R11   =   21,
+    CV_M32R_R12   =   22,   // Gloabal Pointer, if used
+    CV_M32R_R13   =   23,   // Frame Pointer, if allocated
+    CV_M32R_R14   =   24,   // Link Register
+    CV_M32R_R15   =   25,   // Stack Pointer
+    CV_M32R_PSW   =   26,   // Preocessor Status Register
+    CV_M32R_CBR   =   27,   // Condition Bit Register
+    CV_M32R_SPI   =   28,   // Interrupt Stack Pointer
+    CV_M32R_SPU   =   29,   // User Stack Pointer
+    CV_M32R_SPO   =   30,   // OS Stack Pointer
+    CV_M32R_BPC   =   31,   // Backup Program Counter
+    CV_M32R_ACHI  =   32,   // Accumulator High
+    CV_M32R_ACLO  =   33,   // Accumulator Low
+    CV_M32R_PC    =   34,   // Program Counter
+
+    //
+    // Register set for the SuperH SHMedia processor including compact
+    // mode
+    //
+
+    // Integer - 64 bit general registers
+    CV_SHMEDIA_NOREG   =   CV_REG_NONE,
+    CV_SHMEDIA_R0      =   10,
+    CV_SHMEDIA_R1      =   11,
+    CV_SHMEDIA_R2      =   12,
+    CV_SHMEDIA_R3      =   13,
+    CV_SHMEDIA_R4      =   14,
+    CV_SHMEDIA_R5      =   15,
+    CV_SHMEDIA_R6      =   16,
+    CV_SHMEDIA_R7      =   17,
+    CV_SHMEDIA_R8      =   18,
+    CV_SHMEDIA_R9      =   19,
+    CV_SHMEDIA_R10     =   20,
+    CV_SHMEDIA_R11     =   21,
+    CV_SHMEDIA_R12     =   22,
+    CV_SHMEDIA_R13     =   23,
+    CV_SHMEDIA_R14     =   24,
+    CV_SHMEDIA_R15     =   25,
+    CV_SHMEDIA_R16     =   26,
+    CV_SHMEDIA_R17     =   27,
+    CV_SHMEDIA_R18     =   28,
+    CV_SHMEDIA_R19     =   29,
+    CV_SHMEDIA_R20     =   30,
+    CV_SHMEDIA_R21     =   31,
+    CV_SHMEDIA_R22     =   32,
+    CV_SHMEDIA_R23     =   33,
+    CV_SHMEDIA_R24     =   34,
+    CV_SHMEDIA_R25     =   35,
+    CV_SHMEDIA_R26     =   36,
+    CV_SHMEDIA_R27     =   37,
+    CV_SHMEDIA_R28     =   38,
+    CV_SHMEDIA_R29     =   39,
+    CV_SHMEDIA_R30     =   40,
+    CV_SHMEDIA_R31     =   41,
+    CV_SHMEDIA_R32     =   42,
+    CV_SHMEDIA_R33     =   43,
+    CV_SHMEDIA_R34     =   44,
+    CV_SHMEDIA_R35     =   45,
+    CV_SHMEDIA_R36     =   46,
+    CV_SHMEDIA_R37     =   47,
+    CV_SHMEDIA_R38     =   48,
+    CV_SHMEDIA_R39     =   49,
+    CV_SHMEDIA_R40     =   50,
+    CV_SHMEDIA_R41     =   51,
+    CV_SHMEDIA_R42     =   52,
+    CV_SHMEDIA_R43     =   53,
+    CV_SHMEDIA_R44     =   54,
+    CV_SHMEDIA_R45     =   55,
+    CV_SHMEDIA_R46     =   56,
+    CV_SHMEDIA_R47     =   57,
+    CV_SHMEDIA_R48     =   58,
+    CV_SHMEDIA_R49     =   59,
+    CV_SHMEDIA_R50     =   60,
+    CV_SHMEDIA_R51     =   61,
+    CV_SHMEDIA_R52     =   62,
+    CV_SHMEDIA_R53     =   63,
+    CV_SHMEDIA_R54     =   64,
+    CV_SHMEDIA_R55     =   65,
+    CV_SHMEDIA_R56     =   66,
+    CV_SHMEDIA_R57     =   67,
+    CV_SHMEDIA_R58     =   68,
+    CV_SHMEDIA_R59     =   69,
+    CV_SHMEDIA_R60     =   70,
+    CV_SHMEDIA_R61     =   71,
+    CV_SHMEDIA_R62     =   72,
+    CV_SHMEDIA_R63     =   73,
+    
+    // Target Registers - 32 bit
+    CV_SHMEDIA_TR0     =   74,
+    CV_SHMEDIA_TR1     =   75,
+    CV_SHMEDIA_TR2     =   76,
+    CV_SHMEDIA_TR3     =   77,
+    CV_SHMEDIA_TR4     =   78,
+    CV_SHMEDIA_TR5     =   79,
+    CV_SHMEDIA_TR6     =   80,
+    CV_SHMEDIA_TR7     =   81,
+    CV_SHMEDIA_TR8     =   82, // future-proof
+    CV_SHMEDIA_TR9     =   83, // future-proof
+    CV_SHMEDIA_TR10    =   84, // future-proof
+    CV_SHMEDIA_TR11    =   85, // future-proof
+    CV_SHMEDIA_TR12    =   86, // future-proof
+    CV_SHMEDIA_TR13    =   87, // future-proof
+    CV_SHMEDIA_TR14    =   88, // future-proof
+    CV_SHMEDIA_TR15    =   89, // future-proof
+
+    // Single - 32 bit fp registers
+    CV_SHMEDIA_FR0     =   128,
+    CV_SHMEDIA_FR1     =   129,
+    CV_SHMEDIA_FR2     =   130,
+    CV_SHMEDIA_FR3     =   131,
+    CV_SHMEDIA_FR4     =   132,
+    CV_SHMEDIA_FR5     =   133,
+    CV_SHMEDIA_FR6     =   134,
+    CV_SHMEDIA_FR7     =   135,
+    CV_SHMEDIA_FR8     =   136,
+    CV_SHMEDIA_FR9     =   137,
+    CV_SHMEDIA_FR10    =   138,
+    CV_SHMEDIA_FR11    =   139,
+    CV_SHMEDIA_FR12    =   140,
+    CV_SHMEDIA_FR13    =   141,
+    CV_SHMEDIA_FR14    =   142,
+    CV_SHMEDIA_FR15    =   143,
+    CV_SHMEDIA_FR16    =   144,
+    CV_SHMEDIA_FR17    =   145,
+    CV_SHMEDIA_FR18    =   146,
+    CV_SHMEDIA_FR19    =   147,
+    CV_SHMEDIA_FR20    =   148,
+    CV_SHMEDIA_FR21    =   149,
+    CV_SHMEDIA_FR22    =   150,
+    CV_SHMEDIA_FR23    =   151,
+    CV_SHMEDIA_FR24    =   152,
+    CV_SHMEDIA_FR25    =   153,
+    CV_SHMEDIA_FR26    =   154,
+    CV_SHMEDIA_FR27    =   155,
+    CV_SHMEDIA_FR28    =   156,
+    CV_SHMEDIA_FR29    =   157,
+    CV_SHMEDIA_FR30    =   158,
+    CV_SHMEDIA_FR31    =   159,
+    CV_SHMEDIA_FR32    =   160,
+    CV_SHMEDIA_FR33    =   161,
+    CV_SHMEDIA_FR34    =   162,
+    CV_SHMEDIA_FR35    =   163,
+    CV_SHMEDIA_FR36    =   164,
+    CV_SHMEDIA_FR37    =   165,
+    CV_SHMEDIA_FR38    =   166,
+    CV_SHMEDIA_FR39    =   167,
+    CV_SHMEDIA_FR40    =   168,
+    CV_SHMEDIA_FR41    =   169,
+    CV_SHMEDIA_FR42    =   170,
+    CV_SHMEDIA_FR43    =   171,
+    CV_SHMEDIA_FR44    =   172,
+    CV_SHMEDIA_FR45    =   173,
+    CV_SHMEDIA_FR46    =   174,
+    CV_SHMEDIA_FR47    =   175,
+    CV_SHMEDIA_FR48    =   176,
+    CV_SHMEDIA_FR49    =   177,
+    CV_SHMEDIA_FR50    =   178,
+    CV_SHMEDIA_FR51    =   179,
+    CV_SHMEDIA_FR52    =   180,
+    CV_SHMEDIA_FR53    =   181,
+    CV_SHMEDIA_FR54    =   182,
+    CV_SHMEDIA_FR55    =   183,
+    CV_SHMEDIA_FR56    =   184,
+    CV_SHMEDIA_FR57    =   185,
+    CV_SHMEDIA_FR58    =   186,
+    CV_SHMEDIA_FR59    =   187,
+    CV_SHMEDIA_FR60    =   188,
+    CV_SHMEDIA_FR61    =   189,
+    CV_SHMEDIA_FR62    =   190,
+    CV_SHMEDIA_FR63    =   191,
+
+    // Double - 64 bit synonyms for 32bit fp register pairs
+    //          subtract 128 to find first base single register
+    CV_SHMEDIA_DR0     =   256,
+    CV_SHMEDIA_DR2     =   258,
+    CV_SHMEDIA_DR4     =   260,
+    CV_SHMEDIA_DR6     =   262,
+    CV_SHMEDIA_DR8     =   264,
+    CV_SHMEDIA_DR10    =   266,
+    CV_SHMEDIA_DR12    =   268,
+    CV_SHMEDIA_DR14    =   270,
+    CV_SHMEDIA_DR16    =   272,
+    CV_SHMEDIA_DR18    =   274,
+    CV_SHMEDIA_DR20    =   276,
+    CV_SHMEDIA_DR22    =   278,
+    CV_SHMEDIA_DR24    =   280,
+    CV_SHMEDIA_DR26    =   282,
+    CV_SHMEDIA_DR28    =   284,
+    CV_SHMEDIA_DR30    =   286,
+    CV_SHMEDIA_DR32    =   288,
+    CV_SHMEDIA_DR34    =   290,
+    CV_SHMEDIA_DR36    =   292,
+    CV_SHMEDIA_DR38    =   294,
+    CV_SHMEDIA_DR40    =   296,
+    CV_SHMEDIA_DR42    =   298,
+    CV_SHMEDIA_DR44    =   300,
+    CV_SHMEDIA_DR46    =   302,
+    CV_SHMEDIA_DR48    =   304,
+    CV_SHMEDIA_DR50    =   306,
+    CV_SHMEDIA_DR52    =   308,
+    CV_SHMEDIA_DR54    =   310,
+    CV_SHMEDIA_DR56    =   312,
+    CV_SHMEDIA_DR58    =   314,
+    CV_SHMEDIA_DR60    =   316,
+    CV_SHMEDIA_DR62    =   318,
+
+    // Vector - 128 bit synonyms for 32bit fp register quads
+    //          subtract 384 to find first base single register
+    CV_SHMEDIA_FV0     =   512,
+    CV_SHMEDIA_FV4     =   516,
+    CV_SHMEDIA_FV8     =   520,
+    CV_SHMEDIA_FV12    =   524,
+    CV_SHMEDIA_FV16    =   528,
+    CV_SHMEDIA_FV20    =   532,
+    CV_SHMEDIA_FV24    =   536,
+    CV_SHMEDIA_FV28    =   540,
+    CV_SHMEDIA_FV32    =   544,
+    CV_SHMEDIA_FV36    =   548,
+    CV_SHMEDIA_FV40    =   552,
+    CV_SHMEDIA_FV44    =   556,
+    CV_SHMEDIA_FV48    =   560,
+    CV_SHMEDIA_FV52    =   564,
+    CV_SHMEDIA_FV56    =   568,
+    CV_SHMEDIA_FV60    =   572,
+
+    // Matrix - 512 bit synonyms for 16 adjacent 32bit fp registers
+    //          subtract 896 to find first base single register
+    CV_SHMEDIA_MTRX0   =   1024,
+    CV_SHMEDIA_MTRX16  =   1040,
+    CV_SHMEDIA_MTRX32  =   1056,
+    CV_SHMEDIA_MTRX48  =   1072,
+
+    // Control - Implementation defined 64bit control registers
+    CV_SHMEDIA_CR0     =   2000,
+    CV_SHMEDIA_CR1     =   2001,
+    CV_SHMEDIA_CR2     =   2002,
+    CV_SHMEDIA_CR3     =   2003,
+    CV_SHMEDIA_CR4     =   2004,
+    CV_SHMEDIA_CR5     =   2005,
+    CV_SHMEDIA_CR6     =   2006,
+    CV_SHMEDIA_CR7     =   2007,
+    CV_SHMEDIA_CR8     =   2008,
+    CV_SHMEDIA_CR9     =   2009,
+    CV_SHMEDIA_CR10    =   2010,
+    CV_SHMEDIA_CR11    =   2011,
+    CV_SHMEDIA_CR12    =   2012,
+    CV_SHMEDIA_CR13    =   2013,
+    CV_SHMEDIA_CR14    =   2014,
+    CV_SHMEDIA_CR15    =   2015,
+    CV_SHMEDIA_CR16    =   2016,
+    CV_SHMEDIA_CR17    =   2017,
+    CV_SHMEDIA_CR18    =   2018,
+    CV_SHMEDIA_CR19    =   2019,
+    CV_SHMEDIA_CR20    =   2020,
+    CV_SHMEDIA_CR21    =   2021,
+    CV_SHMEDIA_CR22    =   2022,
+    CV_SHMEDIA_CR23    =   2023,
+    CV_SHMEDIA_CR24    =   2024,
+    CV_SHMEDIA_CR25    =   2025,
+    CV_SHMEDIA_CR26    =   2026,
+    CV_SHMEDIA_CR27    =   2027,
+    CV_SHMEDIA_CR28    =   2028,
+    CV_SHMEDIA_CR29    =   2029,
+    CV_SHMEDIA_CR30    =   2030,
+    CV_SHMEDIA_CR31    =   2031,
+    CV_SHMEDIA_CR32    =   2032,
+    CV_SHMEDIA_CR33    =   2033,
+    CV_SHMEDIA_CR34    =   2034,
+    CV_SHMEDIA_CR35    =   2035,
+    CV_SHMEDIA_CR36    =   2036,
+    CV_SHMEDIA_CR37    =   2037,
+    CV_SHMEDIA_CR38    =   2038,
+    CV_SHMEDIA_CR39    =   2039,
+    CV_SHMEDIA_CR40    =   2040,
+    CV_SHMEDIA_CR41    =   2041,
+    CV_SHMEDIA_CR42    =   2042,
+    CV_SHMEDIA_CR43    =   2043,
+    CV_SHMEDIA_CR44    =   2044,
+    CV_SHMEDIA_CR45    =   2045,
+    CV_SHMEDIA_CR46    =   2046,
+    CV_SHMEDIA_CR47    =   2047,
+    CV_SHMEDIA_CR48    =   2048,
+    CV_SHMEDIA_CR49    =   2049,
+    CV_SHMEDIA_CR50    =   2050,
+    CV_SHMEDIA_CR51    =   2051,
+    CV_SHMEDIA_CR52    =   2052,
+    CV_SHMEDIA_CR53    =   2053,
+    CV_SHMEDIA_CR54    =   2054,
+    CV_SHMEDIA_CR55    =   2055,
+    CV_SHMEDIA_CR56    =   2056,
+    CV_SHMEDIA_CR57    =   2057,
+    CV_SHMEDIA_CR58    =   2058,
+    CV_SHMEDIA_CR59    =   2059,
+    CV_SHMEDIA_CR60    =   2060,
+    CV_SHMEDIA_CR61    =   2061,
+    CV_SHMEDIA_CR62    =   2062,
+    CV_SHMEDIA_CR63    =   2063,
+
+    CV_SHMEDIA_FPSCR   =   2064,
+
+    // Compact mode synonyms
+    CV_SHMEDIA_GBR     =   CV_SHMEDIA_R16,
+    CV_SHMEDIA_MACL    =   90, // synonym for lower 32bits of media R17
+    CV_SHMEDIA_MACH    =   91, // synonym for upper 32bits of media R17
+    CV_SHMEDIA_PR      =   CV_SHMEDIA_R18,
+    CV_SHMEDIA_T       =   92, // synonym for lowest bit of media R19
+    CV_SHMEDIA_FPUL    =   CV_SHMEDIA_FR32,
+    CV_SHMEDIA_PC      =   93,
+    CV_SHMEDIA_SR      =   CV_SHMEDIA_CR0,
+
+    //
+    // AMD64 registers
+    //
+
+    CV_AMD64_AL       =   1,
+    CV_AMD64_CL       =   2,
+    CV_AMD64_DL       =   3,
+    CV_AMD64_BL       =   4,
+    CV_AMD64_AH       =   5,
+    CV_AMD64_CH       =   6,
+    CV_AMD64_DH       =   7,
+    CV_AMD64_BH       =   8,
+    CV_AMD64_AX       =   9,
+    CV_AMD64_CX       =  10,
+    CV_AMD64_DX       =  11,
+    CV_AMD64_BX       =  12,
+    CV_AMD64_SP       =  13,
+    CV_AMD64_BP       =  14,
+    CV_AMD64_SI       =  15,
+    CV_AMD64_DI       =  16,
+    CV_AMD64_EAX      =  17,
+    CV_AMD64_ECX      =  18,
+    CV_AMD64_EDX      =  19,
+    CV_AMD64_EBX      =  20,
+    CV_AMD64_ESP      =  21,
+    CV_AMD64_EBP      =  22,
+    CV_AMD64_ESI      =  23,
+    CV_AMD64_EDI      =  24,
+    CV_AMD64_ES       =  25,
+    CV_AMD64_CS       =  26,
+    CV_AMD64_SS       =  27,
+    CV_AMD64_DS       =  28,
+    CV_AMD64_FS       =  29,
+    CV_AMD64_GS       =  30,
+    CV_AMD64_FLAGS    =  32,
+    CV_AMD64_RIP      =  33,
+    CV_AMD64_EFLAGS   =  34,
+
+    // Control registers
+    CV_AMD64_CR0      =  80,
+    CV_AMD64_CR1      =  81,
+    CV_AMD64_CR2      =  82,
+    CV_AMD64_CR3      =  83,
+    CV_AMD64_CR4      =  84,
+    CV_AMD64_CR8      =  88,
+
+    // Debug registers
+    CV_AMD64_DR0      =  90,
+    CV_AMD64_DR1      =  91,
+    CV_AMD64_DR2      =  92,
+    CV_AMD64_DR3      =  93,
+    CV_AMD64_DR4      =  94,
+    CV_AMD64_DR5      =  95,
+    CV_AMD64_DR6      =  96,
+    CV_AMD64_DR7      =  97,
+    CV_AMD64_DR8      =  98,
+    CV_AMD64_DR9      =  99,
+    CV_AMD64_DR10     =  100,
+    CV_AMD64_DR11     =  101,
+    CV_AMD64_DR12     =  102,
+    CV_AMD64_DR13     =  103,
+    CV_AMD64_DR14     =  104,
+    CV_AMD64_DR15     =  105,
+
+    CV_AMD64_GDTR     =  110,
+    CV_AMD64_GDTL     =  111,
+    CV_AMD64_IDTR     =  112,
+    CV_AMD64_IDTL     =  113,
+    CV_AMD64_LDTR     =  114,
+    CV_AMD64_TR       =  115,
+
+    CV_AMD64_ST0      =  128,
+    CV_AMD64_ST1      =  129,
+    CV_AMD64_ST2      =  130,
+    CV_AMD64_ST3      =  131,
+    CV_AMD64_ST4      =  132,
+    CV_AMD64_ST5      =  133,
+    CV_AMD64_ST6      =  134,
+    CV_AMD64_ST7      =  135,
+    CV_AMD64_CTRL     =  136,
+    CV_AMD64_STAT     =  137,
+    CV_AMD64_TAG      =  138,
+    CV_AMD64_FPIP     =  139,
+    CV_AMD64_FPCS     =  140,
+    CV_AMD64_FPDO     =  141,
+    CV_AMD64_FPDS     =  142,
+    CV_AMD64_ISEM     =  143,
+    CV_AMD64_FPEIP    =  144,
+    CV_AMD64_FPEDO    =  145,
+
+    CV_AMD64_MM0      =  146,
+    CV_AMD64_MM1      =  147,
+    CV_AMD64_MM2      =  148,
+    CV_AMD64_MM3      =  149,
+    CV_AMD64_MM4      =  150,
+    CV_AMD64_MM5      =  151,
+    CV_AMD64_MM6      =  152,
+    CV_AMD64_MM7      =  153,
+
+    CV_AMD64_XMM0     =  154,   // KATMAI registers
+    CV_AMD64_XMM1     =  155,
+    CV_AMD64_XMM2     =  156,
+    CV_AMD64_XMM3     =  157,
+    CV_AMD64_XMM4     =  158,
+    CV_AMD64_XMM5     =  159,
+    CV_AMD64_XMM6     =  160,
+    CV_AMD64_XMM7     =  161,
+
+    CV_AMD64_XMM0_0   =  162,   // KATMAI sub-registers
+    CV_AMD64_XMM0_1   =  163,
+    CV_AMD64_XMM0_2   =  164,
+    CV_AMD64_XMM0_3   =  165,
+    CV_AMD64_XMM1_0   =  166,
+    CV_AMD64_XMM1_1   =  167,
+    CV_AMD64_XMM1_2   =  168,
+    CV_AMD64_XMM1_3   =  169,
+    CV_AMD64_XMM2_0   =  170,
+    CV_AMD64_XMM2_1   =  171,
+    CV_AMD64_XMM2_2   =  172,
+    CV_AMD64_XMM2_3   =  173,
+    CV_AMD64_XMM3_0   =  174,
+    CV_AMD64_XMM3_1   =  175,
+    CV_AMD64_XMM3_2   =  176,
+    CV_AMD64_XMM3_3   =  177,
+    CV_AMD64_XMM4_0   =  178,
+    CV_AMD64_XMM4_1   =  179,
+    CV_AMD64_XMM4_2   =  180,
+    CV_AMD64_XMM4_3   =  181,
+    CV_AMD64_XMM5_0   =  182,
+    CV_AMD64_XMM5_1   =  183,
+    CV_AMD64_XMM5_2   =  184,
+    CV_AMD64_XMM5_3   =  185,
+    CV_AMD64_XMM6_0   =  186,
+    CV_AMD64_XMM6_1   =  187,
+    CV_AMD64_XMM6_2   =  188,
+    CV_AMD64_XMM6_3   =  189,
+    CV_AMD64_XMM7_0   =  190,
+    CV_AMD64_XMM7_1   =  191,
+    CV_AMD64_XMM7_2   =  192,
+    CV_AMD64_XMM7_3   =  193,
+
+    CV_AMD64_XMM0L    =  194,
+    CV_AMD64_XMM1L    =  195,
+    CV_AMD64_XMM2L    =  196,
+    CV_AMD64_XMM3L    =  197,
+    CV_AMD64_XMM4L    =  198,
+    CV_AMD64_XMM5L    =  199,
+    CV_AMD64_XMM6L    =  200,
+    CV_AMD64_XMM7L    =  201,
+
+    CV_AMD64_XMM0H    =  202,
+    CV_AMD64_XMM1H    =  203,
+    CV_AMD64_XMM2H    =  204,
+    CV_AMD64_XMM3H    =  205,
+    CV_AMD64_XMM4H    =  206,
+    CV_AMD64_XMM5H    =  207,
+    CV_AMD64_XMM6H    =  208,
+    CV_AMD64_XMM7H    =  209,
+
+    CV_AMD64_MXCSR    =  211,   // XMM status register
+
+    CV_AMD64_EMM0L    =  220,   // XMM sub-registers (WNI integer)
+    CV_AMD64_EMM1L    =  221,
+    CV_AMD64_EMM2L    =  222,
+    CV_AMD64_EMM3L    =  223,
+    CV_AMD64_EMM4L    =  224,
+    CV_AMD64_EMM5L    =  225,
+    CV_AMD64_EMM6L    =  226,
+    CV_AMD64_EMM7L    =  227,
+
+    CV_AMD64_EMM0H    =  228,
+    CV_AMD64_EMM1H    =  229,
+    CV_AMD64_EMM2H    =  230,
+    CV_AMD64_EMM3H    =  231,
+    CV_AMD64_EMM4H    =  232,
+    CV_AMD64_EMM5H    =  233,
+    CV_AMD64_EMM6H    =  234,
+    CV_AMD64_EMM7H    =  235,
+
+    // do not change the order of these regs, first one must be even too
+    CV_AMD64_MM00     =  236,
+    CV_AMD64_MM01     =  237,
+    CV_AMD64_MM10     =  238,
+    CV_AMD64_MM11     =  239,
+    CV_AMD64_MM20     =  240,
+    CV_AMD64_MM21     =  241,
+    CV_AMD64_MM30     =  242,
+    CV_AMD64_MM31     =  243,
+    CV_AMD64_MM40     =  244,
+    CV_AMD64_MM41     =  245,
+    CV_AMD64_MM50     =  246,
+    CV_AMD64_MM51     =  247,
+    CV_AMD64_MM60     =  248,
+    CV_AMD64_MM61     =  249,
+    CV_AMD64_MM70     =  250,
+    CV_AMD64_MM71     =  251,
+
+    // Extended KATMAI registers
+    CV_AMD64_XMM8     =  252,   // KATMAI registers
+    CV_AMD64_XMM9     =  253,
+    CV_AMD64_XMM10    =  254,
+    CV_AMD64_XMM11    =  255,
+    CV_AMD64_XMM12    =  256,
+    CV_AMD64_XMM13    =  257,
+    CV_AMD64_XMM14    =  258,
+    CV_AMD64_XMM15    =  259,
+
+    CV_AMD64_XMM8_0   =  260,   // KATMAI sub-registers
+    CV_AMD64_XMM8_1   =  261,
+    CV_AMD64_XMM8_2   =  262,
+    CV_AMD64_XMM8_3   =  263,
+    CV_AMD64_XMM9_0   =  264,
+    CV_AMD64_XMM9_1   =  265,
+    CV_AMD64_XMM9_2   =  266,
+    CV_AMD64_XMM9_3   =  267,
+    CV_AMD64_XMM10_0  =  268,
+    CV_AMD64_XMM10_1  =  269,
+    CV_AMD64_XMM10_2  =  270,
+    CV_AMD64_XMM10_3  =  271,
+    CV_AMD64_XMM11_0  =  272,
+    CV_AMD64_XMM11_1  =  273,
+    CV_AMD64_XMM11_2  =  274,
+    CV_AMD64_XMM11_3  =  275,
+    CV_AMD64_XMM12_0  =  276,
+    CV_AMD64_XMM12_1  =  277,
+    CV_AMD64_XMM12_2  =  278,
+    CV_AMD64_XMM12_3  =  279,
+    CV_AMD64_XMM13_0  =  280,
+    CV_AMD64_XMM13_1  =  281,
+    CV_AMD64_XMM13_2  =  282,
+    CV_AMD64_XMM13_3  =  283,
+    CV_AMD64_XMM14_0  =  284,
+    CV_AMD64_XMM14_1  =  285,
+    CV_AMD64_XMM14_2  =  286,
+    CV_AMD64_XMM14_3  =  287,
+    CV_AMD64_XMM15_0  =  288,
+    CV_AMD64_XMM15_1  =  289,
+    CV_AMD64_XMM15_2  =  290,
+    CV_AMD64_XMM15_3  =  291,
+
+    CV_AMD64_XMM8L    =  292,
+    CV_AMD64_XMM9L    =  293,
+    CV_AMD64_XMM10L   =  294,
+    CV_AMD64_XMM11L   =  295,
+    CV_AMD64_XMM12L   =  296,
+    CV_AMD64_XMM13L   =  297,
+    CV_AMD64_XMM14L   =  298,
+    CV_AMD64_XMM15L   =  299,
+
+    CV_AMD64_XMM8H    =  300,
+    CV_AMD64_XMM9H    =  301,
+    CV_AMD64_XMM10H   =  302,
+    CV_AMD64_XMM11H   =  303,
+    CV_AMD64_XMM12H   =  304,
+    CV_AMD64_XMM13H   =  305,
+    CV_AMD64_XMM14H   =  306,
+    CV_AMD64_XMM15H   =  307,
+
+    CV_AMD64_EMM8L    =  308,   // XMM sub-registers (WNI integer)
+    CV_AMD64_EMM9L    =  309,
+    CV_AMD64_EMM10L   =  310,
+    CV_AMD64_EMM11L   =  311,
+    CV_AMD64_EMM12L   =  312,
+    CV_AMD64_EMM13L   =  313,
+    CV_AMD64_EMM14L   =  314,
+    CV_AMD64_EMM15L   =  315,
+
+    CV_AMD64_EMM8H    =  316,
+    CV_AMD64_EMM9H    =  317,
+    CV_AMD64_EMM10H   =  318,
+    CV_AMD64_EMM11H   =  319,
+    CV_AMD64_EMM12H   =  320,
+    CV_AMD64_EMM13H   =  321,
+    CV_AMD64_EMM14H   =  322,
+    CV_AMD64_EMM15H   =  323,
+
+    // Low byte forms of some standard registers
+    CV_AMD64_SIL      =  324,
+    CV_AMD64_DIL      =  325,
+    CV_AMD64_BPL      =  326,
+    CV_AMD64_SPL      =  327,
+
+    // 64-bit regular registers
+    CV_AMD64_RAX      =  328,
+    CV_AMD64_RBX      =  329,
+    CV_AMD64_RCX      =  330,
+    CV_AMD64_RDX      =  331,
+    CV_AMD64_RSI      =  332,
+    CV_AMD64_RDI      =  333,
+    CV_AMD64_RBP      =  334,
+    CV_AMD64_RSP      =  335,
+
+    // 64-bit integer registers with 8-, 16-, and 32-bit forms (B, W, and D)
+    CV_AMD64_R8       =  336,
+    CV_AMD64_R9       =  337,
+    CV_AMD64_R10      =  338,
+    CV_AMD64_R11      =  339,
+    CV_AMD64_R12      =  340,
+    CV_AMD64_R13      =  341,
+    CV_AMD64_R14      =  342,
+    CV_AMD64_R15      =  343,
+
+    CV_AMD64_R8B      =  344,
+    CV_AMD64_R9B      =  345,
+    CV_AMD64_R10B     =  346,
+    CV_AMD64_R11B     =  347,
+    CV_AMD64_R12B     =  348,
+    CV_AMD64_R13B     =  349,
+    CV_AMD64_R14B     =  350,
+    CV_AMD64_R15B     =  351,
+
+    CV_AMD64_R8W      =  352,
+    CV_AMD64_R9W      =  353,
+    CV_AMD64_R10W     =  354,
+    CV_AMD64_R11W     =  355,
+    CV_AMD64_R12W     =  356,
+    CV_AMD64_R13W     =  357,
+    CV_AMD64_R14W     =  358,
+    CV_AMD64_R15W     =  359,
+
+    CV_AMD64_R8D      =  360,
+    CV_AMD64_R9D      =  361,
+    CV_AMD64_R10D     =  362,
+    CV_AMD64_R11D     =  363,
+    CV_AMD64_R12D     =  364,
+    CV_AMD64_R13D     =  365,
+    CV_AMD64_R14D     =  366,
+    CV_AMD64_R15D     =  367,
+
+    // AVX registers 256 bits
+    CV_AMD64_YMM0     =  368,
+    CV_AMD64_YMM1     =  369,
+    CV_AMD64_YMM2     =  370,
+    CV_AMD64_YMM3     =  371,
+    CV_AMD64_YMM4     =  372,
+    CV_AMD64_YMM5     =  373,
+    CV_AMD64_YMM6     =  374,
+    CV_AMD64_YMM7     =  375,
+    CV_AMD64_YMM8     =  376, 
+    CV_AMD64_YMM9     =  377,
+    CV_AMD64_YMM10    =  378,
+    CV_AMD64_YMM11    =  379,
+    CV_AMD64_YMM12    =  380,
+    CV_AMD64_YMM13    =  381,
+    CV_AMD64_YMM14    =  382,
+    CV_AMD64_YMM15    =  383,
+
+    // AVX registers upper 128 bits
+    CV_AMD64_YMM0H    =  384,
+    CV_AMD64_YMM1H    =  385,
+    CV_AMD64_YMM2H    =  386,
+    CV_AMD64_YMM3H    =  387,
+    CV_AMD64_YMM4H    =  388,
+    CV_AMD64_YMM5H    =  389,
+    CV_AMD64_YMM6H    =  390,
+    CV_AMD64_YMM7H    =  391,
+    CV_AMD64_YMM8H    =  392, 
+    CV_AMD64_YMM9H    =  393,
+    CV_AMD64_YMM10H   =  394,
+    CV_AMD64_YMM11H   =  395,
+    CV_AMD64_YMM12H   =  396,
+    CV_AMD64_YMM13H   =  397,
+    CV_AMD64_YMM14H   =  398,
+    CV_AMD64_YMM15H   =  399,
+
+    //Lower/upper 8 bytes of XMM registers.  Unlike CV_AMD64_XMM<regnum><H/L>, these
+    //values reprsesent the bit patterns of the registers as 64-bit integers, not
+    //the representation of these registers as a double.
+    CV_AMD64_XMM0IL    = 400,
+    CV_AMD64_XMM1IL    = 401,
+    CV_AMD64_XMM2IL    = 402,
+    CV_AMD64_XMM3IL    = 403,
+    CV_AMD64_XMM4IL    = 404,
+    CV_AMD64_XMM5IL    = 405,
+    CV_AMD64_XMM6IL    = 406,
+    CV_AMD64_XMM7IL    = 407,
+    CV_AMD64_XMM8IL    = 408,
+    CV_AMD64_XMM9IL    = 409,
+    CV_AMD64_XMM10IL    = 410,
+    CV_AMD64_XMM11IL    = 411,
+    CV_AMD64_XMM12IL    = 412,
+    CV_AMD64_XMM13IL    = 413,
+    CV_AMD64_XMM14IL    = 414,
+    CV_AMD64_XMM15IL    = 415,
+
+    CV_AMD64_XMM0IH    = 416,
+    CV_AMD64_XMM1IH    = 417,
+    CV_AMD64_XMM2IH    = 418,
+    CV_AMD64_XMM3IH    = 419,
+    CV_AMD64_XMM4IH    = 420,
+    CV_AMD64_XMM5IH    = 421,
+    CV_AMD64_XMM6IH    = 422,
+    CV_AMD64_XMM7IH    = 423,
+    CV_AMD64_XMM8IH    = 424,
+    CV_AMD64_XMM9IH    = 425,
+    CV_AMD64_XMM10IH    = 426,
+    CV_AMD64_XMM11IH    = 427,
+    CV_AMD64_XMM12IH    = 428,
+    CV_AMD64_XMM13IH    = 429,
+    CV_AMD64_XMM14IH    = 430,
+    CV_AMD64_XMM15IH    = 431,
+
+    CV_AMD64_YMM0I0    =  432,        // AVX integer registers
+    CV_AMD64_YMM0I1    =  433,
+    CV_AMD64_YMM0I2    =  434,
+    CV_AMD64_YMM0I3    =  435,
+    CV_AMD64_YMM1I0    =  436,
+    CV_AMD64_YMM1I1    =  437,
+    CV_AMD64_YMM1I2    =  438,
+    CV_AMD64_YMM1I3    =  439,
+    CV_AMD64_YMM2I0    =  440,
+    CV_AMD64_YMM2I1    =  441,
+    CV_AMD64_YMM2I2    =  442,
+    CV_AMD64_YMM2I3    =  443,
+    CV_AMD64_YMM3I0    =  444,
+    CV_AMD64_YMM3I1    =  445,
+    CV_AMD64_YMM3I2    =  446,
+    CV_AMD64_YMM3I3    =  447,
+    CV_AMD64_YMM4I0    =  448,
+    CV_AMD64_YMM4I1    =  449,
+    CV_AMD64_YMM4I2    =  450,
+    CV_AMD64_YMM4I3    =  451,
+    CV_AMD64_YMM5I0    =  452,
+    CV_AMD64_YMM5I1    =  453,
+    CV_AMD64_YMM5I2    =  454,
+    CV_AMD64_YMM5I3    =  455,
+    CV_AMD64_YMM6I0    =  456,
+    CV_AMD64_YMM6I1    =  457,
+    CV_AMD64_YMM6I2    =  458,
+    CV_AMD64_YMM6I3    =  459,
+    CV_AMD64_YMM7I0    =  460,
+    CV_AMD64_YMM7I1    =  461,
+    CV_AMD64_YMM7I2    =  462,
+    CV_AMD64_YMM7I3    =  463,
+    CV_AMD64_YMM8I0    =  464,
+    CV_AMD64_YMM8I1    =  465,
+    CV_AMD64_YMM8I2    =  466,
+    CV_AMD64_YMM8I3    =  467,
+    CV_AMD64_YMM9I0    =  468,
+    CV_AMD64_YMM9I1    =  469,
+    CV_AMD64_YMM9I2    =  470,
+    CV_AMD64_YMM9I3    =  471,
+    CV_AMD64_YMM10I0    =  472,
+    CV_AMD64_YMM10I1    =  473,
+    CV_AMD64_YMM10I2    =  474,
+    CV_AMD64_YMM10I3    =  475,
+    CV_AMD64_YMM11I0    =  476,
+    CV_AMD64_YMM11I1    =  477,
+    CV_AMD64_YMM11I2    =  478,
+    CV_AMD64_YMM11I3    =  479,
+    CV_AMD64_YMM12I0    =  480,
+    CV_AMD64_YMM12I1    =  481,
+    CV_AMD64_YMM12I2    =  482,
+    CV_AMD64_YMM12I3    =  483,
+    CV_AMD64_YMM13I0    =  484,
+    CV_AMD64_YMM13I1    =  485,
+    CV_AMD64_YMM13I2    =  486,
+    CV_AMD64_YMM13I3    =  487,
+    CV_AMD64_YMM14I0    =  488,
+    CV_AMD64_YMM14I1    =  489,
+    CV_AMD64_YMM14I2    =  490,
+    CV_AMD64_YMM14I3    =  491,
+    CV_AMD64_YMM15I0    =  492,
+    CV_AMD64_YMM15I1    =  493,
+    CV_AMD64_YMM15I2    =  494,
+    CV_AMD64_YMM15I3    =  495,
+
+    CV_AMD64_YMM0F0    =  496,        // AVX floating-point single precise registers
+    CV_AMD64_YMM0F1    =  497,
+    CV_AMD64_YMM0F2    =  498,
+    CV_AMD64_YMM0F3    =  499,
+    CV_AMD64_YMM0F4    =  500,
+    CV_AMD64_YMM0F5    =  501,
+    CV_AMD64_YMM0F6    =  502,
+    CV_AMD64_YMM0F7    =  503,
+    CV_AMD64_YMM1F0    =  504,
+    CV_AMD64_YMM1F1    =  505,
+    CV_AMD64_YMM1F2    =  506,
+    CV_AMD64_YMM1F3    =  507,
+    CV_AMD64_YMM1F4    =  508,
+    CV_AMD64_YMM1F5    =  509,
+    CV_AMD64_YMM1F6    =  510,
+    CV_AMD64_YMM1F7    =  511,
+    CV_AMD64_YMM2F0    =  512,
+    CV_AMD64_YMM2F1    =  513,
+    CV_AMD64_YMM2F2    =  514,
+    CV_AMD64_YMM2F3    =  515,
+    CV_AMD64_YMM2F4    =  516,
+    CV_AMD64_YMM2F5    =  517,
+    CV_AMD64_YMM2F6    =  518,
+    CV_AMD64_YMM2F7    =  519,
+    CV_AMD64_YMM3F0    =  520,
+    CV_AMD64_YMM3F1    =  521,
+    CV_AMD64_YMM3F2    =  522,
+    CV_AMD64_YMM3F3    =  523,
+    CV_AMD64_YMM3F4    =  524,
+    CV_AMD64_YMM3F5    =  525,
+    CV_AMD64_YMM3F6    =  526,
+    CV_AMD64_YMM3F7    =  527,
+    CV_AMD64_YMM4F0    =  528,
+    CV_AMD64_YMM4F1    =  529,
+    CV_AMD64_YMM4F2    =  530,
+    CV_AMD64_YMM4F3    =  531,
+    CV_AMD64_YMM4F4    =  532,
+    CV_AMD64_YMM4F5    =  533,
+    CV_AMD64_YMM4F6    =  534,
+    CV_AMD64_YMM4F7    =  535,
+    CV_AMD64_YMM5F0    =  536,
+    CV_AMD64_YMM5F1    =  537,
+    CV_AMD64_YMM5F2    =  538,
+    CV_AMD64_YMM5F3    =  539,
+    CV_AMD64_YMM5F4    =  540,
+    CV_AMD64_YMM5F5    =  541,
+    CV_AMD64_YMM5F6    =  542,
+    CV_AMD64_YMM5F7    =  543,
+    CV_AMD64_YMM6F0    =  544,
+    CV_AMD64_YMM6F1    =  545,
+    CV_AMD64_YMM6F2    =  546,
+    CV_AMD64_YMM6F3    =  547,
+    CV_AMD64_YMM6F4    =  548,
+    CV_AMD64_YMM6F5    =  549,
+    CV_AMD64_YMM6F6    =  550,
+    CV_AMD64_YMM6F7    =  551,
+    CV_AMD64_YMM7F0    =  552,
+    CV_AMD64_YMM7F1    =  553,
+    CV_AMD64_YMM7F2    =  554,
+    CV_AMD64_YMM7F3    =  555,
+    CV_AMD64_YMM7F4    =  556,
+    CV_AMD64_YMM7F5    =  557,
+    CV_AMD64_YMM7F6    =  558,
+    CV_AMD64_YMM7F7    =  559,
+    CV_AMD64_YMM8F0    =  560,
+    CV_AMD64_YMM8F1    =  561,
+    CV_AMD64_YMM8F2    =  562,
+    CV_AMD64_YMM8F3    =  563,
+    CV_AMD64_YMM8F4    =  564,
+    CV_AMD64_YMM8F5    =  565,
+    CV_AMD64_YMM8F6    =  566,
+    CV_AMD64_YMM8F7    =  567,
+    CV_AMD64_YMM9F0    =  568,
+    CV_AMD64_YMM9F1    =  569,
+    CV_AMD64_YMM9F2    =  570,
+    CV_AMD64_YMM9F3    =  571,
+    CV_AMD64_YMM9F4    =  572,
+    CV_AMD64_YMM9F5    =  573,
+    CV_AMD64_YMM9F6    =  574,
+    CV_AMD64_YMM9F7    =  575,
+    CV_AMD64_YMM10F0    =  576,
+    CV_AMD64_YMM10F1    =  577,
+    CV_AMD64_YMM10F2    =  578,
+    CV_AMD64_YMM10F3    =  579,
+    CV_AMD64_YMM10F4    =  580,
+    CV_AMD64_YMM10F5    =  581,
+    CV_AMD64_YMM10F6    =  582,
+    CV_AMD64_YMM10F7    =  583,
+    CV_AMD64_YMM11F0    =  584,
+    CV_AMD64_YMM11F1    =  585,
+    CV_AMD64_YMM11F2    =  586,
+    CV_AMD64_YMM11F3    =  587,
+    CV_AMD64_YMM11F4    =  588,
+    CV_AMD64_YMM11F5    =  589,
+    CV_AMD64_YMM11F6    =  590,
+    CV_AMD64_YMM11F7    =  591,
+    CV_AMD64_YMM12F0    =  592,
+    CV_AMD64_YMM12F1    =  593,
+    CV_AMD64_YMM12F2    =  594,
+    CV_AMD64_YMM12F3    =  595,
+    CV_AMD64_YMM12F4    =  596,
+    CV_AMD64_YMM12F5    =  597,
+    CV_AMD64_YMM12F6    =  598,
+    CV_AMD64_YMM12F7    =  599,
+    CV_AMD64_YMM13F0    =  600,
+    CV_AMD64_YMM13F1    =  601,
+    CV_AMD64_YMM13F2    =  602,
+    CV_AMD64_YMM13F3    =  603,
+    CV_AMD64_YMM13F4    =  604,
+    CV_AMD64_YMM13F5    =  605,
+    CV_AMD64_YMM13F6    =  606,
+    CV_AMD64_YMM13F7    =  607,
+    CV_AMD64_YMM14F0    =  608,
+    CV_AMD64_YMM14F1    =  609,
+    CV_AMD64_YMM14F2    =  610,
+    CV_AMD64_YMM14F3    =  611,
+    CV_AMD64_YMM14F4    =  612,
+    CV_AMD64_YMM14F5    =  613,
+    CV_AMD64_YMM14F6    =  614,
+    CV_AMD64_YMM14F7    =  615,
+    CV_AMD64_YMM15F0    =  616,
+    CV_AMD64_YMM15F1    =  617,
+    CV_AMD64_YMM15F2    =  618,
+    CV_AMD64_YMM15F3    =  619,
+    CV_AMD64_YMM15F4    =  620,
+    CV_AMD64_YMM15F5    =  621,
+    CV_AMD64_YMM15F6    =  622,
+    CV_AMD64_YMM15F7    =  623,
+    
+    CV_AMD64_YMM0D0    =  624,        // AVX floating-point double precise registers
+    CV_AMD64_YMM0D1    =  625,
+    CV_AMD64_YMM0D2    =  626,
+    CV_AMD64_YMM0D3    =  627,
+    CV_AMD64_YMM1D0    =  628,
+    CV_AMD64_YMM1D1    =  629,
+    CV_AMD64_YMM1D2    =  630,
+    CV_AMD64_YMM1D3    =  631,
+    CV_AMD64_YMM2D0    =  632,
+    CV_AMD64_YMM2D1    =  633,
+    CV_AMD64_YMM2D2    =  634,
+    CV_AMD64_YMM2D3    =  635,
+    CV_AMD64_YMM3D0    =  636,
+    CV_AMD64_YMM3D1    =  637,
+    CV_AMD64_YMM3D2    =  638,
+    CV_AMD64_YMM3D3    =  639,
+    CV_AMD64_YMM4D0    =  640,
+    CV_AMD64_YMM4D1    =  641,
+    CV_AMD64_YMM4D2    =  642,
+    CV_AMD64_YMM4D3    =  643,
+    CV_AMD64_YMM5D0    =  644,
+    CV_AMD64_YMM5D1    =  645,
+    CV_AMD64_YMM5D2    =  646,
+    CV_AMD64_YMM5D3    =  647,
+    CV_AMD64_YMM6D0    =  648,
+    CV_AMD64_YMM6D1    =  649,
+    CV_AMD64_YMM6D2    =  650,
+    CV_AMD64_YMM6D3    =  651,
+    CV_AMD64_YMM7D0    =  652,
+    CV_AMD64_YMM7D1    =  653,
+    CV_AMD64_YMM7D2    =  654,
+    CV_AMD64_YMM7D3    =  655,
+    CV_AMD64_YMM8D0    =  656,
+    CV_AMD64_YMM8D1    =  657,
+    CV_AMD64_YMM8D2    =  658,
+    CV_AMD64_YMM8D3    =  659,
+    CV_AMD64_YMM9D0    =  660,
+    CV_AMD64_YMM9D1    =  661,
+    CV_AMD64_YMM9D2    =  662,
+    CV_AMD64_YMM9D3    =  663,
+    CV_AMD64_YMM10D0    =  664,
+    CV_AMD64_YMM10D1    =  665,
+    CV_AMD64_YMM10D2    =  666,
+    CV_AMD64_YMM10D3    =  667,
+    CV_AMD64_YMM11D0    =  668,
+    CV_AMD64_YMM11D1    =  669,
+    CV_AMD64_YMM11D2    =  670,
+    CV_AMD64_YMM11D3    =  671,
+    CV_AMD64_YMM12D0    =  672,
+    CV_AMD64_YMM12D1    =  673,
+    CV_AMD64_YMM12D2    =  674,
+    CV_AMD64_YMM12D3    =  675,
+    CV_AMD64_YMM13D0    =  676,
+    CV_AMD64_YMM13D1    =  677,
+    CV_AMD64_YMM13D2    =  678,
+    CV_AMD64_YMM13D3    =  679,
+    CV_AMD64_YMM14D0    =  680,
+    CV_AMD64_YMM14D1    =  681,
+    CV_AMD64_YMM14D2    =  682,
+    CV_AMD64_YMM14D3    =  683,
+    CV_AMD64_YMM15D0    =  684,
+    CV_AMD64_YMM15D1    =  685,
+    CV_AMD64_YMM15D2    =  686,
+    CV_AMD64_YMM15D3    =  687
+
+
+    // Note:  Next set of platform registers need to go into a new enum...
+    // this one is above 44K now.
+
+} CV_HREG_e;
+
+enum StackFrameTypeEnum
+{
+    FrameTypeFPO,                   // Frame pointer omitted, FPO info available
+    FrameTypeTrap,                  // Kernel Trap frame
+    FrameTypeTSS,                   // Kernel Trap frame
+    FrameTypeStandard,              // Standard EBP stackframe
+    FrameTypeFrameData,             // Frame pointer omitted, FrameData info available
+
+    FrameTypeUnknown = -1,          // Frame which does not have any debug info
+};
+
+enum MemoryTypeEnum
+{
+    MemTypeCode,                    // Read only code memory
+    MemTypeData,                    // Read only data/stack memory
+    MemTypeStack,                   // Read only stack memory
+
+    MemTypeAny = -1,
+};
+
+#endif
diff --git a/src/ToolBox/PdbTypeMatch/include/dia2.h b/src/ToolBox/PdbTypeMatch/include/dia2.h
new file mode 100644
index 0000000000..e463b795a2
--- /dev/null
+++ b/src/ToolBox/PdbTypeMatch/include/dia2.h
@@ -0,0 +1,7852 @@
+
+
+/* this ALWAYS GENERATED file contains the definitions for the interfaces */
+
+
+ /* File created by MIDL compiler version 7.00.0499 */
+/* Compiler settings for dia2.idl:
+    Oicf, W1, Zp8, env=Win32 (32b run)
+    protocol : dce , ms_ext, c_ext, robust
+    error checks: allocation ref bounds_check enum stub_data 
+    VC __declspec() decoration level: 
+         __declspec(uuid()), __declspec(selectany), __declspec(novtable)
+         DECLSPEC_UUID(), MIDL_INTERFACE()
+*/
+//@@MIDL_FILE_HEADING(  )
+
+#pragma warning( disable: 4049 )  /* more than 64k source lines */
+
+
+/* verify that the <rpcndr.h> version is high enough to compile this file*/
+#ifndef __REQUIRED_RPCNDR_H_VERSION__
+#define __REQUIRED_RPCNDR_H_VERSION__ 475
+#endif
+
+/* verify that the <rpcsal.h> version is high enough to compile this file*/
+#ifndef __REQUIRED_RPCSAL_H_VERSION__
+#define __REQUIRED_RPCSAL_H_VERSION__ 100
+#endif
+
+#include "rpc.h"
+#include "rpcndr.h"
+
+#ifndef __RPCNDR_H_VERSION__
+#error this stub requires an updated version of <rpcndr.h>
+#endif // __RPCNDR_H_VERSION__
+
+#ifndef COM_NO_WINDOWS_H
+#include "windows.h"
+#include "ole2.h"
+#endif /*COM_NO_WINDOWS_H*/
+
+#ifndef __dia2_h__
+#define __dia2_h__
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+#pragma once
+#endif
+
+/* Forward Declarations */ 
+
+#ifndef __IDiaLoadCallback_FWD_DEFINED__
+#define __IDiaLoadCallback_FWD_DEFINED__
+typedef interface IDiaLoadCallback IDiaLoadCallback;
+#endif 	/* __IDiaLoadCallback_FWD_DEFINED__ */
+
+
+#ifndef __IDiaLoadCallback2_FWD_DEFINED__
+#define __IDiaLoadCallback2_FWD_DEFINED__
+typedef interface IDiaLoadCallback2 IDiaLoadCallback2;
+#endif 	/* __IDiaLoadCallback2_FWD_DEFINED__ */
+
+
+#ifndef __IDiaReadExeAtOffsetCallback_FWD_DEFINED__
+#define __IDiaReadExeAtOffsetCallback_FWD_DEFINED__
+typedef interface IDiaReadExeAtOffsetCallback IDiaReadExeAtOffsetCallback;
+#endif 	/* __IDiaReadExeAtOffsetCallback_FWD_DEFINED__ */
+
+
+#ifndef __IDiaReadExeAtRVACallback_FWD_DEFINED__
+#define __IDiaReadExeAtRVACallback_FWD_DEFINED__
+typedef interface IDiaReadExeAtRVACallback IDiaReadExeAtRVACallback;
+#endif 	/* __IDiaReadExeAtRVACallback_FWD_DEFINED__ */
+
+
+#ifndef __IDiaDataSource_FWD_DEFINED__
+#define __IDiaDataSource_FWD_DEFINED__
+typedef interface IDiaDataSource IDiaDataSource;
+#endif 	/* __IDiaDataSource_FWD_DEFINED__ */
+
+
+#ifndef __IDiaEnumSymbols_FWD_DEFINED__
+#define __IDiaEnumSymbols_FWD_DEFINED__
+typedef interface IDiaEnumSymbols IDiaEnumSymbols;
+#endif 	/* __IDiaEnumSymbols_FWD_DEFINED__ */
+
+
+#ifndef __IDiaEnumSymbolsByAddr_FWD_DEFINED__
+#define __IDiaEnumSymbolsByAddr_FWD_DEFINED__
+typedef interface IDiaEnumSymbolsByAddr IDiaEnumSymbolsByAddr;
+#endif 	/* __IDiaEnumSymbolsByAddr_FWD_DEFINED__ */
+
+
+#ifndef __IDiaEnumSourceFiles_FWD_DEFINED__
+#define __IDiaEnumSourceFiles_FWD_DEFINED__
+typedef interface IDiaEnumSourceFiles IDiaEnumSourceFiles;
+#endif 	/* __IDiaEnumSourceFiles_FWD_DEFINED__ */
+
+
+#ifndef __IDiaEnumLineNumbers_FWD_DEFINED__
+#define __IDiaEnumLineNumbers_FWD_DEFINED__
+typedef interface IDiaEnumLineNumbers IDiaEnumLineNumbers;
+#endif 	/* __IDiaEnumLineNumbers_FWD_DEFINED__ */
+
+
+#ifndef __IDiaEnumInjectedSources_FWD_DEFINED__
+#define __IDiaEnumInjectedSources_FWD_DEFINED__
+typedef interface IDiaEnumInjectedSources IDiaEnumInjectedSources;
+#endif 	/* __IDiaEnumInjectedSources_FWD_DEFINED__ */
+
+
+#ifndef __IDiaEnumSegments_FWD_DEFINED__
+#define __IDiaEnumSegments_FWD_DEFINED__
+typedef interface IDiaEnumSegments IDiaEnumSegments;
+#endif 	/* __IDiaEnumSegments_FWD_DEFINED__ */
+
+
+#ifndef __IDiaEnumSectionContribs_FWD_DEFINED__
+#define __IDiaEnumSectionContribs_FWD_DEFINED__
+typedef interface IDiaEnumSectionContribs IDiaEnumSectionContribs;
+#endif 	/* __IDiaEnumSectionContribs_FWD_DEFINED__ */
+
+
+#ifndef __IDiaEnumFrameData_FWD_DEFINED__
+#define __IDiaEnumFrameData_FWD_DEFINED__
+typedef interface IDiaEnumFrameData IDiaEnumFrameData;
+#endif 	/* __IDiaEnumFrameData_FWD_DEFINED__ */
+
+
+#ifndef __IDiaEnumDebugStreamData_FWD_DEFINED__
+#define __IDiaEnumDebugStreamData_FWD_DEFINED__
+typedef interface IDiaEnumDebugStreamData IDiaEnumDebugStreamData;
+#endif 	/* __IDiaEnumDebugStreamData_FWD_DEFINED__ */
+
+
+#ifndef __IDiaEnumDebugStreams_FWD_DEFINED__
+#define __IDiaEnumDebugStreams_FWD_DEFINED__
+typedef interface IDiaEnumDebugStreams IDiaEnumDebugStreams;
+#endif 	/* __IDiaEnumDebugStreams_FWD_DEFINED__ */
+
+
+#ifndef __IDiaAddressMap_FWD_DEFINED__
+#define __IDiaAddressMap_FWD_DEFINED__
+typedef interface IDiaAddressMap IDiaAddressMap;
+#endif 	/* __IDiaAddressMap_FWD_DEFINED__ */
+
+
+#ifndef __IDiaSession_FWD_DEFINED__
+#define __IDiaSession_FWD_DEFINED__
+typedef interface IDiaSession IDiaSession;
+#endif 	/* __IDiaSession_FWD_DEFINED__ */
+
+
+#ifndef __IDiaSymbol_FWD_DEFINED__
+#define __IDiaSymbol_FWD_DEFINED__
+typedef interface IDiaSymbol IDiaSymbol;
+#endif 	/* __IDiaSymbol_FWD_DEFINED__ */
+
+
+#ifndef __IDiaSourceFile_FWD_DEFINED__
+#define __IDiaSourceFile_FWD_DEFINED__
+typedef interface IDiaSourceFile IDiaSourceFile;
+#endif 	/* __IDiaSourceFile_FWD_DEFINED__ */
+
+
+#ifndef __IDiaLineNumber_FWD_DEFINED__
+#define __IDiaLineNumber_FWD_DEFINED__
+typedef interface IDiaLineNumber IDiaLineNumber;
+#endif 	/* __IDiaLineNumber_FWD_DEFINED__ */
+
+
+#ifndef __IDiaSectionContrib_FWD_DEFINED__
+#define __IDiaSectionContrib_FWD_DEFINED__
+typedef interface IDiaSectionContrib IDiaSectionContrib;
+#endif 	/* __IDiaSectionContrib_FWD_DEFINED__ */
+
+
+#ifndef __IDiaSegment_FWD_DEFINED__
+#define __IDiaSegment_FWD_DEFINED__
+typedef interface IDiaSegment IDiaSegment;
+#endif 	/* __IDiaSegment_FWD_DEFINED__ */
+
+
+#ifndef __IDiaInjectedSource_FWD_DEFINED__
+#define __IDiaInjectedSource_FWD_DEFINED__
+typedef interface IDiaInjectedSource IDiaInjectedSource;
+#endif 	/* __IDiaInjectedSource_FWD_DEFINED__ */
+
+
+#ifndef __IDiaStackWalkFrame_FWD_DEFINED__
+#define __IDiaStackWalkFrame_FWD_DEFINED__
+typedef interface IDiaStackWalkFrame IDiaStackWalkFrame;
+#endif 	/* __IDiaStackWalkFrame_FWD_DEFINED__ */
+
+
+#ifndef __IDiaFrameData_FWD_DEFINED__
+#define __IDiaFrameData_FWD_DEFINED__
+typedef interface IDiaFrameData IDiaFrameData;
+#endif 	/* __IDiaFrameData_FWD_DEFINED__ */
+
+
+#ifndef __IDiaImageData_FWD_DEFINED__
+#define __IDiaImageData_FWD_DEFINED__
+typedef interface IDiaImageData IDiaImageData;
+#endif 	/* __IDiaImageData_FWD_DEFINED__ */
+
+
+#ifndef __IDiaTable_FWD_DEFINED__
+#define __IDiaTable_FWD_DEFINED__
+typedef interface IDiaTable IDiaTable;
+#endif 	/* __IDiaTable_FWD_DEFINED__ */
+
+
+#ifndef __IDiaEnumTables_FWD_DEFINED__
+#define __IDiaEnumTables_FWD_DEFINED__
+typedef interface IDiaEnumTables IDiaEnumTables;
+#endif 	/* __IDiaEnumTables_FWD_DEFINED__ */
+
+
+#ifndef __DiaSource_FWD_DEFINED__
+#define __DiaSource_FWD_DEFINED__
+
+#ifdef __cplusplus
+typedef class DiaSource DiaSource;
+#else
+typedef struct DiaSource DiaSource;
+#endif /* __cplusplus */
+
+#endif 	/* __DiaSource_FWD_DEFINED__ */
+
+
+#ifndef __DiaSourceAlt_FWD_DEFINED__
+#define __DiaSourceAlt_FWD_DEFINED__
+
+#ifdef __cplusplus
+typedef class DiaSourceAlt DiaSourceAlt;
+#else
+typedef struct DiaSourceAlt DiaSourceAlt;
+#endif /* __cplusplus */
+
+#endif 	/* __DiaSourceAlt_FWD_DEFINED__ */
+
+
+#ifndef __DiaStackWalker_FWD_DEFINED__
+#define __DiaStackWalker_FWD_DEFINED__
+
+#ifdef __cplusplus
+typedef class DiaStackWalker DiaStackWalker;
+#else
+typedef struct DiaStackWalker DiaStackWalker;
+#endif /* __cplusplus */
+
+#endif 	/* __DiaStackWalker_FWD_DEFINED__ */
+
+
+#ifndef __IDiaPropertyStorage_FWD_DEFINED__
+#define __IDiaPropertyStorage_FWD_DEFINED__
+typedef interface IDiaPropertyStorage IDiaPropertyStorage;
+#endif 	/* __IDiaPropertyStorage_FWD_DEFINED__ */
+
+
+#ifndef __IDiaStackFrame_FWD_DEFINED__
+#define __IDiaStackFrame_FWD_DEFINED__
+typedef interface IDiaStackFrame IDiaStackFrame;
+#endif 	/* __IDiaStackFrame_FWD_DEFINED__ */
+
+
+#ifndef __IDiaEnumStackFrames_FWD_DEFINED__
+#define __IDiaEnumStackFrames_FWD_DEFINED__
+typedef interface IDiaEnumStackFrames IDiaEnumStackFrames;
+#endif 	/* __IDiaEnumStackFrames_FWD_DEFINED__ */
+
+
+#ifndef __IDiaStackWalkHelper_FWD_DEFINED__
+#define __IDiaStackWalkHelper_FWD_DEFINED__
+typedef interface IDiaStackWalkHelper IDiaStackWalkHelper;
+#endif 	/* __IDiaStackWalkHelper_FWD_DEFINED__ */
+
+
+#ifndef __IDiaStackWalker_FWD_DEFINED__
+#define __IDiaStackWalker_FWD_DEFINED__
+typedef interface IDiaStackWalker IDiaStackWalker;
+#endif 	/* __IDiaStackWalker_FWD_DEFINED__ */
+
+
+#ifndef __IDiaStackWalkHelper2_FWD_DEFINED__
+#define __IDiaStackWalkHelper2_FWD_DEFINED__
+typedef interface IDiaStackWalkHelper2 IDiaStackWalkHelper2;
+#endif 	/* __IDiaStackWalkHelper2_FWD_DEFINED__ */
+
+
+#ifndef __IDiaStackWalker2_FWD_DEFINED__
+#define __IDiaStackWalker2_FWD_DEFINED__
+typedef interface IDiaStackWalker2 IDiaStackWalker2;
+#endif 	/* __IDiaStackWalker2_FWD_DEFINED__ */
+
+
+/* header files for imported files */
+#include "objidl.h"
+#include "oaidl.h"
+#include "propidl.h"
+#include "cvconst.h"
+
+#ifdef __cplusplus
+extern "C"{
+#endif 
+
+
+/* interface __MIDL_itf_dia2_0000_0000 */
+/* [local] */ 
+
+
+enum NameSearchOptions
+    {	nsNone	= 0,
+	nsfCaseSensitive	= 0x1,
+	nsfCaseInsensitive	= 0x2,
+	nsfFNameExt	= 0x4,
+	nsfRegularExpression	= 0x8,
+	nsfUndecoratedName	= 0x10,
+	nsCaseSensitive	= nsfCaseSensitive,
+	nsCaseInsensitive	= nsfCaseInsensitive,
+	nsFNameExt	= ( nsfCaseInsensitive | nsfFNameExt ) ,
+	nsRegularExpression	= ( nsfRegularExpression | nsfCaseSensitive ) ,
+	nsCaseInRegularExpression	= ( nsfRegularExpression | nsfCaseInsensitive ) 
+    } ;
+
+enum __MIDL___MIDL_itf_dia2_0000_0000_0001
+    {	E_PDB_OK	= ( HRESULT  )(( ( ( ( unsigned long  )1 << 31 )  | ( ( unsigned long  )( LONG  )0x6d << 16 )  )  | ( unsigned long  )1 ) ),
+	E_PDB_USAGE	= ( E_PDB_OK + 1 ) ,
+	E_PDB_OUT_OF_MEMORY	= ( E_PDB_USAGE + 1 ) ,
+	E_PDB_FILE_SYSTEM	= ( E_PDB_OUT_OF_MEMORY + 1 ) ,
+	E_PDB_NOT_FOUND	= ( E_PDB_FILE_SYSTEM + 1 ) ,
+	E_PDB_INVALID_SIG	= ( E_PDB_NOT_FOUND + 1 ) ,
+	E_PDB_INVALID_AGE	= ( E_PDB_INVALID_SIG + 1 ) ,
+	E_PDB_PRECOMP_REQUIRED	= ( E_PDB_INVALID_AGE + 1 ) ,
+	E_PDB_OUT_OF_TI	= ( E_PDB_PRECOMP_REQUIRED + 1 ) ,
+	E_PDB_NOT_IMPLEMENTED	= ( E_PDB_OUT_OF_TI + 1 ) ,
+	E_PDB_V1_PDB	= ( E_PDB_NOT_IMPLEMENTED + 1 ) ,
+	E_PDB_FORMAT	= ( E_PDB_V1_PDB + 1 ) ,
+	E_PDB_LIMIT	= ( E_PDB_FORMAT + 1 ) ,
+	E_PDB_CORRUPT	= ( E_PDB_LIMIT + 1 ) ,
+	E_PDB_TI16	= ( E_PDB_CORRUPT + 1 ) ,
+	E_PDB_ACCESS_DENIED	= ( E_PDB_TI16 + 1 ) ,
+	E_PDB_ILLEGAL_TYPE_EDIT	= ( E_PDB_ACCESS_DENIED + 1 ) ,
+	E_PDB_INVALID_EXECUTABLE	= ( E_PDB_ILLEGAL_TYPE_EDIT + 1 ) ,
+	E_PDB_DBG_NOT_FOUND	= ( E_PDB_INVALID_EXECUTABLE + 1 ) ,
+	E_PDB_NO_DEBUG_INFO	= ( E_PDB_DBG_NOT_FOUND + 1 ) ,
+	E_PDB_INVALID_EXE_TIMESTAMP	= ( E_PDB_NO_DEBUG_INFO + 1 ) ,
+	E_PDB_RESERVED	= ( E_PDB_INVALID_EXE_TIMESTAMP + 1 ) ,
+	E_PDB_DEBUG_INFO_NOT_IN_PDB	= ( E_PDB_RESERVED + 1 ) ,
+	E_PDB_SYMSRV_BAD_CACHE_PATH	= ( E_PDB_DEBUG_INFO_NOT_IN_PDB + 1 ) ,
+	E_PDB_SYMSRV_CACHE_FULL	= ( E_PDB_SYMSRV_BAD_CACHE_PATH + 1 ) ,
+	E_PDB_MAX	= ( E_PDB_SYMSRV_CACHE_FULL + 1 ) 
+    } ;
+typedef void ( __cdecl *PfnPDBDebugDirV )( 
+    BOOL __MIDL____MIDL_itf_dia2_0000_00000000,
+    void *__MIDL____MIDL_itf_dia2_0000_00000001);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+extern RPC_IF_HANDLE __MIDL_itf_dia2_0000_0000_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_dia2_0000_0000_v0_0_s_ifspec;
+
+#ifndef __IDiaLoadCallback_INTERFACE_DEFINED__
+#define __IDiaLoadCallback_INTERFACE_DEFINED__
+
+/* interface IDiaLoadCallback */
+/* [unique][helpstring][local][uuid][object] */ 
+
+
+EXTERN_C const IID IID_IDiaLoadCallback;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("C32ADB82-73F4-421b-95D5-A4706EDF5DBE")
+    IDiaLoadCallback : public IUnknown
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE NotifyDebugDir( 
+            /* [in] */ BOOL fExecutable,
+            /* [in] */ DWORD cbData,
+            /* [size_is][in] */ BYTE *pbData) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE NotifyOpenDBG( 
+            /* [in] */ LPCOLESTR dbgPath,
+            /* [in] */ HRESULT resultCode) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE NotifyOpenPDB( 
+            /* [in] */ LPCOLESTR pdbPath,
+            /* [in] */ HRESULT resultCode) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE RestrictRegistryAccess( void) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE RestrictSymbolServerAccess( void) = 0;
+        
+    };
+    
+#else 	/* C style interface */
+
+    typedef struct IDiaLoadCallbackVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            IDiaLoadCallback * This,
+            /* [in] */ REFIID riid,
+            /* [iid_is][out] */ 
+            __RPC__deref_out  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            IDiaLoadCallback * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            IDiaLoadCallback * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *NotifyDebugDir )( 
+            IDiaLoadCallback * This,
+            /* [in] */ BOOL fExecutable,
+            /* [in] */ DWORD cbData,
+            /* [size_is][in] */ BYTE *pbData);
+        
+        HRESULT ( STDMETHODCALLTYPE *NotifyOpenDBG )( 
+            IDiaLoadCallback * This,
+            /* [in] */ LPCOLESTR dbgPath,
+            /* [in] */ HRESULT resultCode);
+        
+        HRESULT ( STDMETHODCALLTYPE *NotifyOpenPDB )( 
+            IDiaLoadCallback * This,
+            /* [in] */ LPCOLESTR pdbPath,
+            /* [in] */ HRESULT resultCode);
+        
+        HRESULT ( STDMETHODCALLTYPE *RestrictRegistryAccess )( 
+            IDiaLoadCallback * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *RestrictSymbolServerAccess )( 
+            IDiaLoadCallback * This);
+        
+        END_INTERFACE
+    } IDiaLoadCallbackVtbl;
+
+    interface IDiaLoadCallback
+    {
+        CONST_VTBL struct IDiaLoadCallbackVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define IDiaLoadCallback_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define IDiaLoadCallback_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define IDiaLoadCallback_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define IDiaLoadCallback_NotifyDebugDir(This,fExecutable,cbData,pbData)	\
+    ( (This)->lpVtbl -> NotifyDebugDir(This,fExecutable,cbData,pbData) ) 
+
+#define IDiaLoadCallback_NotifyOpenDBG(This,dbgPath,resultCode)	\
+    ( (This)->lpVtbl -> NotifyOpenDBG(This,dbgPath,resultCode) ) 
+
+#define IDiaLoadCallback_NotifyOpenPDB(This,pdbPath,resultCode)	\
+    ( (This)->lpVtbl -> NotifyOpenPDB(This,pdbPath,resultCode) ) 
+
+#define IDiaLoadCallback_RestrictRegistryAccess(This)	\
+    ( (This)->lpVtbl -> RestrictRegistryAccess(This) ) 
+
+#define IDiaLoadCallback_RestrictSymbolServerAccess(This)	\
+    ( (This)->lpVtbl -> RestrictSymbolServerAccess(This) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __IDiaLoadCallback_INTERFACE_DEFINED__ */
+
+
+#ifndef __IDiaLoadCallback2_INTERFACE_DEFINED__
+#define __IDiaLoadCallback2_INTERFACE_DEFINED__
+
+/* interface IDiaLoadCallback2 */
+/* [unique][helpstring][local][uuid][object] */ 
+
+
+EXTERN_C const IID IID_IDiaLoadCallback2;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("4688a074-5a4d-4486-aea8-7b90711d9f7c")
+    IDiaLoadCallback2 : public IDiaLoadCallback
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE RestrictOriginalPathAccess( void) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE RestrictReferencePathAccess( void) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE RestrictDBGAccess( void) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE RestrictSystemRootAccess( void) = 0;
+        
+    };
+    
+#else 	/* C style interface */
+
+    typedef struct IDiaLoadCallback2Vtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            IDiaLoadCallback2 * This,
+            /* [in] */ REFIID riid,
+            /* [iid_is][out] */ 
+            __RPC__deref_out  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            IDiaLoadCallback2 * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            IDiaLoadCallback2 * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *NotifyDebugDir )( 
+            IDiaLoadCallback2 * This,
+            /* [in] */ BOOL fExecutable,
+            /* [in] */ DWORD cbData,
+            /* [size_is][in] */ BYTE *pbData);
+        
+        HRESULT ( STDMETHODCALLTYPE *NotifyOpenDBG )( 
+            IDiaLoadCallback2 * This,
+            /* [in] */ LPCOLESTR dbgPath,
+            /* [in] */ HRESULT resultCode);
+        
+        HRESULT ( STDMETHODCALLTYPE *NotifyOpenPDB )( 
+            IDiaLoadCallback2 * This,
+            /* [in] */ LPCOLESTR pdbPath,
+            /* [in] */ HRESULT resultCode);
+        
+        HRESULT ( STDMETHODCALLTYPE *RestrictRegistryAccess )( 
+            IDiaLoadCallback2 * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *RestrictSymbolServerAccess )( 
+            IDiaLoadCallback2 * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *RestrictOriginalPathAccess )( 
+            IDiaLoadCallback2 * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *RestrictReferencePathAccess )( 
+            IDiaLoadCallback2 * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *RestrictDBGAccess )( 
+            IDiaLoadCallback2 * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *RestrictSystemRootAccess )( 
+            IDiaLoadCallback2 * This);
+        
+        END_INTERFACE
+    } IDiaLoadCallback2Vtbl;
+
+    interface IDiaLoadCallback2
+    {
+        CONST_VTBL struct IDiaLoadCallback2Vtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define IDiaLoadCallback2_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define IDiaLoadCallback2_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define IDiaLoadCallback2_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define IDiaLoadCallback2_NotifyDebugDir(This,fExecutable,cbData,pbData)	\
+    ( (This)->lpVtbl -> NotifyDebugDir(This,fExecutable,cbData,pbData) ) 
+
+#define IDiaLoadCallback2_NotifyOpenDBG(This,dbgPath,resultCode)	\
+    ( (This)->lpVtbl -> NotifyOpenDBG(This,dbgPath,resultCode) ) 
+
+#define IDiaLoadCallback2_NotifyOpenPDB(This,pdbPath,resultCode)	\
+    ( (This)->lpVtbl -> NotifyOpenPDB(This,pdbPath,resultCode) ) 
+
+#define IDiaLoadCallback2_RestrictRegistryAccess(This)	\
+    ( (This)->lpVtbl -> RestrictRegistryAccess(This) ) 
+
+#define IDiaLoadCallback2_RestrictSymbolServerAccess(This)	\
+    ( (This)->lpVtbl -> RestrictSymbolServerAccess(This) ) 
+
+
+#define IDiaLoadCallback2_RestrictOriginalPathAccess(This)	\
+    ( (This)->lpVtbl -> RestrictOriginalPathAccess(This) ) 
+
+#define IDiaLoadCallback2_RestrictReferencePathAccess(This)	\
+    ( (This)->lpVtbl -> RestrictReferencePathAccess(This) ) 
+
+#define IDiaLoadCallback2_RestrictDBGAccess(This)	\
+    ( (This)->lpVtbl -> RestrictDBGAccess(This) ) 
+
+#define IDiaLoadCallback2_RestrictSystemRootAccess(This)	\
+    ( (This)->lpVtbl -> RestrictSystemRootAccess(This) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __IDiaLoadCallback2_INTERFACE_DEFINED__ */
+
+
+#ifndef __IDiaReadExeAtOffsetCallback_INTERFACE_DEFINED__
+#define __IDiaReadExeAtOffsetCallback_INTERFACE_DEFINED__
+
+/* interface IDiaReadExeAtOffsetCallback */
+/* [unique][helpstring][local][uuid][object] */ 
+
+
+EXTERN_C const IID IID_IDiaReadExeAtOffsetCallback;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("587A461C-B80B-4f54-9194-5032589A6319")
+    IDiaReadExeAtOffsetCallback : public IUnknown
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE ReadExecutableAt( 
+            /* [in] */ DWORDLONG fileOffset,
+            /* [in] */ DWORD cbData,
+            /* [out] */ DWORD *pcbData,
+            /* [size_is][out] */ BYTE *pbData) = 0;
+        
+    };
+    
+#else 	/* C style interface */
+
+    typedef struct IDiaReadExeAtOffsetCallbackVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            IDiaReadExeAtOffsetCallback * This,
+            /* [in] */ REFIID riid,
+            /* [iid_is][out] */ 
+            __RPC__deref_out  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            IDiaReadExeAtOffsetCallback * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            IDiaReadExeAtOffsetCallback * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *ReadExecutableAt )( 
+            IDiaReadExeAtOffsetCallback * This,
+            /* [in] */ DWORDLONG fileOffset,
+            /* [in] */ DWORD cbData,
+            /* [out] */ DWORD *pcbData,
+            /* [size_is][out] */ BYTE *pbData);
+        
+        END_INTERFACE
+    } IDiaReadExeAtOffsetCallbackVtbl;
+
+    interface IDiaReadExeAtOffsetCallback
+    {
+        CONST_VTBL struct IDiaReadExeAtOffsetCallbackVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define IDiaReadExeAtOffsetCallback_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define IDiaReadExeAtOffsetCallback_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define IDiaReadExeAtOffsetCallback_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define IDiaReadExeAtOffsetCallback_ReadExecutableAt(This,fileOffset,cbData,pcbData,pbData)	\
+    ( (This)->lpVtbl -> ReadExecutableAt(This,fileOffset,cbData,pcbData,pbData) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __IDiaReadExeAtOffsetCallback_INTERFACE_DEFINED__ */
+
+
+#ifndef __IDiaReadExeAtRVACallback_INTERFACE_DEFINED__
+#define __IDiaReadExeAtRVACallback_INTERFACE_DEFINED__
+
+/* interface IDiaReadExeAtRVACallback */
+/* [unique][helpstring][local][uuid][object] */ 
+
+
+EXTERN_C const IID IID_IDiaReadExeAtRVACallback;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("8E3F80CA-7517-432a-BA07-285134AAEA8E")
+    IDiaReadExeAtRVACallback : public IUnknown
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE ReadExecutableAtRVA( 
+            /* [in] */ DWORD relativeVirtualAddress,
+            /* [in] */ DWORD cbData,
+            /* [out] */ DWORD *pcbData,
+            /* [size_is][out] */ BYTE *pbData) = 0;
+        
+    };
+    
+#else 	/* C style interface */
+
+    typedef struct IDiaReadExeAtRVACallbackVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            IDiaReadExeAtRVACallback * This,
+            /* [in] */ REFIID riid,
+            /* [iid_is][out] */ 
+            __RPC__deref_out  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            IDiaReadExeAtRVACallback * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            IDiaReadExeAtRVACallback * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *ReadExecutableAtRVA )( 
+            IDiaReadExeAtRVACallback * This,
+            /* [in] */ DWORD relativeVirtualAddress,
+            /* [in] */ DWORD cbData,
+            /* [out] */ DWORD *pcbData,
+            /* [size_is][out] */ BYTE *pbData);
+        
+        END_INTERFACE
+    } IDiaReadExeAtRVACallbackVtbl;
+
+    interface IDiaReadExeAtRVACallback
+    {
+        CONST_VTBL struct IDiaReadExeAtRVACallbackVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define IDiaReadExeAtRVACallback_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define IDiaReadExeAtRVACallback_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define IDiaReadExeAtRVACallback_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define IDiaReadExeAtRVACallback_ReadExecutableAtRVA(This,relativeVirtualAddress,cbData,pcbData,pbData)	\
+    ( (This)->lpVtbl -> ReadExecutableAtRVA(This,relativeVirtualAddress,cbData,pcbData,pbData) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __IDiaReadExeAtRVACallback_INTERFACE_DEFINED__ */
+
+
+#ifndef __IDiaDataSource_INTERFACE_DEFINED__
+#define __IDiaDataSource_INTERFACE_DEFINED__
+
+/* interface IDiaDataSource */
+/* [unique][helpstring][local][uuid][object] */ 
+
+
+EXTERN_C const IID IID_IDiaDataSource;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("79F1BB5F-B66E-48e5-B6A9-1545C323CA3D")
+    IDiaDataSource : public IUnknown
+    {
+    public:
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_lastError( 
+            /* [retval][out] */ BSTR *pRetVal) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE loadDataFromPdb( 
+            /* [in] */ LPCOLESTR pdbPath) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE loadAndValidateDataFromPdb( 
+            /* [in] */ LPCOLESTR pdbPath,
+            /* [in] */ GUID *pcsig70,
+            /* [in] */ DWORD sig,
+            /* [in] */ DWORD age) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE loadDataForExe( 
+            /* [in] */ LPCOLESTR executable,
+            /* [in] */ LPCOLESTR searchPath,
+            /* [in] */ IUnknown *pCallback) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE loadDataFromIStream( 
+            /* [in] */ IStream *pIStream) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE openSession( 
+            /* [out] */ IDiaSession **ppSession) = 0;
+        
+    };
+    
+#else 	/* C style interface */
+
+    typedef struct IDiaDataSourceVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            IDiaDataSource * This,
+            /* [in] */ REFIID riid,
+            /* [iid_is][out] */ 
+            __RPC__deref_out  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            IDiaDataSource * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            IDiaDataSource * This);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lastError )( 
+            IDiaDataSource * This,
+            /* [retval][out] */ BSTR *pRetVal);
+        
+        HRESULT ( STDMETHODCALLTYPE *loadDataFromPdb )( 
+            IDiaDataSource * This,
+            /* [in] */ LPCOLESTR pdbPath);
+        
+        HRESULT ( STDMETHODCALLTYPE *loadAndValidateDataFromPdb )( 
+            IDiaDataSource * This,
+            /* [in] */ LPCOLESTR pdbPath,
+            /* [in] */ GUID *pcsig70,
+            /* [in] */ DWORD sig,
+            /* [in] */ DWORD age);
+        
+        HRESULT ( STDMETHODCALLTYPE *loadDataForExe )( 
+            IDiaDataSource * This,
+            /* [in] */ LPCOLESTR executable,
+            /* [in] */ LPCOLESTR searchPath,
+            /* [in] */ IUnknown *pCallback);
+        
+        HRESULT ( STDMETHODCALLTYPE *loadDataFromIStream )( 
+            IDiaDataSource * This,
+            /* [in] */ IStream *pIStream);
+        
+        HRESULT ( STDMETHODCALLTYPE *openSession )( 
+            IDiaDataSource * This,
+            /* [out] */ IDiaSession **ppSession);
+        
+        END_INTERFACE
+    } IDiaDataSourceVtbl;
+
+    interface IDiaDataSource
+    {
+        CONST_VTBL struct IDiaDataSourceVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define IDiaDataSource_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define IDiaDataSource_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define IDiaDataSource_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define IDiaDataSource_get_lastError(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_lastError(This,pRetVal) ) 
+
+#define IDiaDataSource_loadDataFromPdb(This,pdbPath)	\
+    ( (This)->lpVtbl -> loadDataFromPdb(This,pdbPath) ) 
+
+#define IDiaDataSource_loadAndValidateDataFromPdb(This,pdbPath,pcsig70,sig,age)	\
+    ( (This)->lpVtbl -> loadAndValidateDataFromPdb(This,pdbPath,pcsig70,sig,age) ) 
+
+#define IDiaDataSource_loadDataForExe(This,executable,searchPath,pCallback)	\
+    ( (This)->lpVtbl -> loadDataForExe(This,executable,searchPath,pCallback) ) 
+
+#define IDiaDataSource_loadDataFromIStream(This,pIStream)	\
+    ( (This)->lpVtbl -> loadDataFromIStream(This,pIStream) ) 
+
+#define IDiaDataSource_openSession(This,ppSession)	\
+    ( (This)->lpVtbl -> openSession(This,ppSession) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __IDiaDataSource_INTERFACE_DEFINED__ */
+
+
+#ifndef __IDiaEnumSymbols_INTERFACE_DEFINED__
+#define __IDiaEnumSymbols_INTERFACE_DEFINED__
+
+/* interface IDiaEnumSymbols */
+/* [unique][helpstring][local][uuid][object] */ 
+
+
+EXTERN_C const IID IID_IDiaEnumSymbols;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("CAB72C48-443B-48f5-9B0B-42F0820AB29A")
+    IDiaEnumSymbols : public IUnknown
+    {
+    public:
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get__NewEnum( 
+            /* [retval][out] */ IUnknown **pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_Count( 
+            /* [retval][out] */ LONG *pRetVal) = 0;
+        
+        virtual /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE Item( 
+            /* [in] */ DWORD index,
+            /* [retval][out] */ IDiaSymbol **symbol) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Next( 
+            /* [in] */ ULONG celt,
+            /* [out] */ IDiaSymbol **rgelt,
+            /* [out] */ ULONG *pceltFetched) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Skip( 
+            /* [in] */ ULONG celt) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Reset( void) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Clone( 
+            /* [out] */ IDiaEnumSymbols **ppenum) = 0;
+        
+    };
+    
+#else 	/* C style interface */
+
+    typedef struct IDiaEnumSymbolsVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            IDiaEnumSymbols * This,
+            /* [in] */ REFIID riid,
+            /* [iid_is][out] */ 
+            __RPC__deref_out  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            IDiaEnumSymbols * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            IDiaEnumSymbols * This);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get__NewEnum )( 
+            IDiaEnumSymbols * This,
+            /* [retval][out] */ IUnknown **pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Count )( 
+            IDiaEnumSymbols * This,
+            /* [retval][out] */ LONG *pRetVal);
+        
+        /* [helpstring][id] */ HRESULT ( STDMETHODCALLTYPE *Item )( 
+            IDiaEnumSymbols * This,
+            /* [in] */ DWORD index,
+            /* [retval][out] */ IDiaSymbol **symbol);
+        
+        HRESULT ( STDMETHODCALLTYPE *Next )( 
+            IDiaEnumSymbols * This,
+            /* [in] */ ULONG celt,
+            /* [out] */ IDiaSymbol **rgelt,
+            /* [out] */ ULONG *pceltFetched);
+        
+        HRESULT ( STDMETHODCALLTYPE *Skip )( 
+            IDiaEnumSymbols * This,
+            /* [in] */ ULONG celt);
+        
+        HRESULT ( STDMETHODCALLTYPE *Reset )( 
+            IDiaEnumSymbols * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *Clone )( 
+            IDiaEnumSymbols * This,
+            /* [out] */ IDiaEnumSymbols **ppenum);
+        
+        END_INTERFACE
+    } IDiaEnumSymbolsVtbl;
+
+    interface IDiaEnumSymbols
+    {
+        CONST_VTBL struct IDiaEnumSymbolsVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define IDiaEnumSymbols_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define IDiaEnumSymbols_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define IDiaEnumSymbols_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define IDiaEnumSymbols_get__NewEnum(This,pRetVal)	\
+    ( (This)->lpVtbl -> get__NewEnum(This,pRetVal) ) 
+
+#define IDiaEnumSymbols_get_Count(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_Count(This,pRetVal) ) 
+
+#define IDiaEnumSymbols_Item(This,index,symbol)	\
+    ( (This)->lpVtbl -> Item(This,index,symbol) ) 
+
+#define IDiaEnumSymbols_Next(This,celt,rgelt,pceltFetched)	\
+    ( (This)->lpVtbl -> Next(This,celt,rgelt,pceltFetched) ) 
+
+#define IDiaEnumSymbols_Skip(This,celt)	\
+    ( (This)->lpVtbl -> Skip(This,celt) ) 
+
+#define IDiaEnumSymbols_Reset(This)	\
+    ( (This)->lpVtbl -> Reset(This) ) 
+
+#define IDiaEnumSymbols_Clone(This,ppenum)	\
+    ( (This)->lpVtbl -> Clone(This,ppenum) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __IDiaEnumSymbols_INTERFACE_DEFINED__ */
+
+
+#ifndef __IDiaEnumSymbolsByAddr_INTERFACE_DEFINED__
+#define __IDiaEnumSymbolsByAddr_INTERFACE_DEFINED__
+
+/* interface IDiaEnumSymbolsByAddr */
+/* [unique][helpstring][local][uuid][object] */ 
+
+
+EXTERN_C const IID IID_IDiaEnumSymbolsByAddr;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("624B7D9C-24EA-4421-9D06-3B577471C1FA")
+    IDiaEnumSymbolsByAddr : public IUnknown
+    {
+    public:
+        virtual /* [helpstring] */ HRESULT STDMETHODCALLTYPE symbolByAddr( 
+            /* [in] */ DWORD isect,
+            /* [in] */ DWORD offset,
+            /* [retval][out] */ IDiaSymbol **ppSymbol) = 0;
+        
+        virtual /* [helpstring] */ HRESULT STDMETHODCALLTYPE symbolByRVA( 
+            /* [in] */ DWORD relativeVirtualAddress,
+            /* [retval][out] */ IDiaSymbol **ppSymbol) = 0;
+        
+        virtual /* [helpstring] */ HRESULT STDMETHODCALLTYPE symbolByVA( 
+            /* [in] */ ULONGLONG virtualAddress,
+            /* [retval][out] */ IDiaSymbol **ppSymbol) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Next( 
+            /* [in] */ ULONG celt,
+            /* [out] */ IDiaSymbol **rgelt,
+            /* [out] */ ULONG *pceltFetched) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Prev( 
+            /* [in] */ ULONG celt,
+            /* [out] */ IDiaSymbol **rgelt,
+            /* [out] */ ULONG *pceltFetched) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Clone( 
+            /* [out] */ IDiaEnumSymbolsByAddr **ppenum) = 0;
+        
+    };
+    
+#else 	/* C style interface */
+
+    typedef struct IDiaEnumSymbolsByAddrVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            IDiaEnumSymbolsByAddr * This,
+            /* [in] */ REFIID riid,
+            /* [iid_is][out] */ 
+            __RPC__deref_out  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            IDiaEnumSymbolsByAddr * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            IDiaEnumSymbolsByAddr * This);
+        
+        /* [helpstring] */ HRESULT ( STDMETHODCALLTYPE *symbolByAddr )( 
+            IDiaEnumSymbolsByAddr * This,
+            /* [in] */ DWORD isect,
+            /* [in] */ DWORD offset,
+            /* [retval][out] */ IDiaSymbol **ppSymbol);
+        
+        /* [helpstring] */ HRESULT ( STDMETHODCALLTYPE *symbolByRVA )( 
+            IDiaEnumSymbolsByAddr * This,
+            /* [in] */ DWORD relativeVirtualAddress,
+            /* [retval][out] */ IDiaSymbol **ppSymbol);
+        
+        /* [helpstring] */ HRESULT ( STDMETHODCALLTYPE *symbolByVA )( 
+            IDiaEnumSymbolsByAddr * This,
+            /* [in] */ ULONGLONG virtualAddress,
+            /* [retval][out] */ IDiaSymbol **ppSymbol);
+        
+        HRESULT ( STDMETHODCALLTYPE *Next )( 
+            IDiaEnumSymbolsByAddr * This,
+            /* [in] */ ULONG celt,
+            /* [out] */ IDiaSymbol **rgelt,
+            /* [out] */ ULONG *pceltFetched);
+        
+        HRESULT ( STDMETHODCALLTYPE *Prev )( 
+            IDiaEnumSymbolsByAddr * This,
+            /* [in] */ ULONG celt,
+            /* [out] */ IDiaSymbol **rgelt,
+            /* [out] */ ULONG *pceltFetched);
+        
+        HRESULT ( STDMETHODCALLTYPE *Clone )( 
+            IDiaEnumSymbolsByAddr * This,
+            /* [out] */ IDiaEnumSymbolsByAddr **ppenum);
+        
+        END_INTERFACE
+    } IDiaEnumSymbolsByAddrVtbl;
+
+    interface IDiaEnumSymbolsByAddr
+    {
+        CONST_VTBL struct IDiaEnumSymbolsByAddrVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define IDiaEnumSymbolsByAddr_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define IDiaEnumSymbolsByAddr_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define IDiaEnumSymbolsByAddr_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define IDiaEnumSymbolsByAddr_symbolByAddr(This,isect,offset,ppSymbol)	\
+    ( (This)->lpVtbl -> symbolByAddr(This,isect,offset,ppSymbol) ) 
+
+#define IDiaEnumSymbolsByAddr_symbolByRVA(This,relativeVirtualAddress,ppSymbol)	\
+    ( (This)->lpVtbl -> symbolByRVA(This,relativeVirtualAddress,ppSymbol) ) 
+
+#define IDiaEnumSymbolsByAddr_symbolByVA(This,virtualAddress,ppSymbol)	\
+    ( (This)->lpVtbl -> symbolByVA(This,virtualAddress,ppSymbol) ) 
+
+#define IDiaEnumSymbolsByAddr_Next(This,celt,rgelt,pceltFetched)	\
+    ( (This)->lpVtbl -> Next(This,celt,rgelt,pceltFetched) ) 
+
+#define IDiaEnumSymbolsByAddr_Prev(This,celt,rgelt,pceltFetched)	\
+    ( (This)->lpVtbl -> Prev(This,celt,rgelt,pceltFetched) ) 
+
+#define IDiaEnumSymbolsByAddr_Clone(This,ppenum)	\
+    ( (This)->lpVtbl -> Clone(This,ppenum) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __IDiaEnumSymbolsByAddr_INTERFACE_DEFINED__ */
+
+
+#ifndef __IDiaEnumSourceFiles_INTERFACE_DEFINED__
+#define __IDiaEnumSourceFiles_INTERFACE_DEFINED__
+
+/* interface IDiaEnumSourceFiles */
+/* [unique][helpstring][local][uuid][object] */ 
+
+
+EXTERN_C const IID IID_IDiaEnumSourceFiles;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("10F3DBD9-664F-4469-B808-9471C7A50538")
+    IDiaEnumSourceFiles : public IUnknown
+    {
+    public:
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get__NewEnum( 
+            /* [retval][out] */ IUnknown **pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_Count( 
+            /* [retval][out] */ LONG *pRetVal) = 0;
+        
+        virtual /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE Item( 
+            /* [in] */ DWORD index,
+            /* [retval][out] */ IDiaSourceFile **sourceFile) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Next( 
+            /* [in] */ ULONG celt,
+            /* [out] */ IDiaSourceFile **rgelt,
+            /* [out] */ ULONG *pceltFetched) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Skip( 
+            /* [in] */ ULONG celt) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Reset( void) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Clone( 
+            /* [out] */ IDiaEnumSourceFiles **ppenum) = 0;
+        
+    };
+    
+#else 	/* C style interface */
+
+    typedef struct IDiaEnumSourceFilesVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            IDiaEnumSourceFiles * This,
+            /* [in] */ REFIID riid,
+            /* [iid_is][out] */ 
+            __RPC__deref_out  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            IDiaEnumSourceFiles * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            IDiaEnumSourceFiles * This);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get__NewEnum )( 
+            IDiaEnumSourceFiles * This,
+            /* [retval][out] */ IUnknown **pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Count )( 
+            IDiaEnumSourceFiles * This,
+            /* [retval][out] */ LONG *pRetVal);
+        
+        /* [helpstring][id] */ HRESULT ( STDMETHODCALLTYPE *Item )( 
+            IDiaEnumSourceFiles * This,
+            /* [in] */ DWORD index,
+            /* [retval][out] */ IDiaSourceFile **sourceFile);
+        
+        HRESULT ( STDMETHODCALLTYPE *Next )( 
+            IDiaEnumSourceFiles * This,
+            /* [in] */ ULONG celt,
+            /* [out] */ IDiaSourceFile **rgelt,
+            /* [out] */ ULONG *pceltFetched);
+        
+        HRESULT ( STDMETHODCALLTYPE *Skip )( 
+            IDiaEnumSourceFiles * This,
+            /* [in] */ ULONG celt);
+        
+        HRESULT ( STDMETHODCALLTYPE *Reset )( 
+            IDiaEnumSourceFiles * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *Clone )( 
+            IDiaEnumSourceFiles * This,
+            /* [out] */ IDiaEnumSourceFiles **ppenum);
+        
+        END_INTERFACE
+    } IDiaEnumSourceFilesVtbl;
+
+    interface IDiaEnumSourceFiles
+    {
+        CONST_VTBL struct IDiaEnumSourceFilesVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define IDiaEnumSourceFiles_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define IDiaEnumSourceFiles_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define IDiaEnumSourceFiles_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define IDiaEnumSourceFiles_get__NewEnum(This,pRetVal)	\
+    ( (This)->lpVtbl -> get__NewEnum(This,pRetVal) ) 
+
+#define IDiaEnumSourceFiles_get_Count(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_Count(This,pRetVal) ) 
+
+#define IDiaEnumSourceFiles_Item(This,index,sourceFile)	\
+    ( (This)->lpVtbl -> Item(This,index,sourceFile) ) 
+
+#define IDiaEnumSourceFiles_Next(This,celt,rgelt,pceltFetched)	\
+    ( (This)->lpVtbl -> Next(This,celt,rgelt,pceltFetched) ) 
+
+#define IDiaEnumSourceFiles_Skip(This,celt)	\
+    ( (This)->lpVtbl -> Skip(This,celt) ) 
+
+#define IDiaEnumSourceFiles_Reset(This)	\
+    ( (This)->lpVtbl -> Reset(This) ) 
+
+#define IDiaEnumSourceFiles_Clone(This,ppenum)	\
+    ( (This)->lpVtbl -> Clone(This,ppenum) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __IDiaEnumSourceFiles_INTERFACE_DEFINED__ */
+
+
+#ifndef __IDiaEnumLineNumbers_INTERFACE_DEFINED__
+#define __IDiaEnumLineNumbers_INTERFACE_DEFINED__
+
+/* interface IDiaEnumLineNumbers */
+/* [unique][helpstring][local][uuid][object] */ 
+
+
+EXTERN_C const IID IID_IDiaEnumLineNumbers;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("FE30E878-54AC-44f1-81BA-39DE940F6052")
+    IDiaEnumLineNumbers : public IUnknown
+    {
+    public:
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get__NewEnum( 
+            /* [retval][out] */ IUnknown **pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_Count( 
+            /* [retval][out] */ LONG *pRetVal) = 0;
+        
+        virtual /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE Item( 
+            /* [in] */ DWORD index,
+            /* [retval][out] */ IDiaLineNumber **lineNumber) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Next( 
+            /* [in] */ ULONG celt,
+            /* [out] */ IDiaLineNumber **rgelt,
+            /* [out] */ ULONG *pceltFetched) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Skip( 
+            /* [in] */ ULONG celt) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Reset( void) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Clone( 
+            /* [out] */ IDiaEnumLineNumbers **ppenum) = 0;
+        
+    };
+    
+#else 	/* C style interface */
+
+    typedef struct IDiaEnumLineNumbersVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            IDiaEnumLineNumbers * This,
+            /* [in] */ REFIID riid,
+            /* [iid_is][out] */ 
+            __RPC__deref_out  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            IDiaEnumLineNumbers * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            IDiaEnumLineNumbers * This);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get__NewEnum )( 
+            IDiaEnumLineNumbers * This,
+            /* [retval][out] */ IUnknown **pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Count )( 
+            IDiaEnumLineNumbers * This,
+            /* [retval][out] */ LONG *pRetVal);
+        
+        /* [helpstring][id] */ HRESULT ( STDMETHODCALLTYPE *Item )( 
+            IDiaEnumLineNumbers * This,
+            /* [in] */ DWORD index,
+            /* [retval][out] */ IDiaLineNumber **lineNumber);
+        
+        HRESULT ( STDMETHODCALLTYPE *Next )( 
+            IDiaEnumLineNumbers * This,
+            /* [in] */ ULONG celt,
+            /* [out] */ IDiaLineNumber **rgelt,
+            /* [out] */ ULONG *pceltFetched);
+        
+        HRESULT ( STDMETHODCALLTYPE *Skip )( 
+            IDiaEnumLineNumbers * This,
+            /* [in] */ ULONG celt);
+        
+        HRESULT ( STDMETHODCALLTYPE *Reset )( 
+            IDiaEnumLineNumbers * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *Clone )( 
+            IDiaEnumLineNumbers * This,
+            /* [out] */ IDiaEnumLineNumbers **ppenum);
+        
+        END_INTERFACE
+    } IDiaEnumLineNumbersVtbl;
+
+    interface IDiaEnumLineNumbers
+    {
+        CONST_VTBL struct IDiaEnumLineNumbersVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define IDiaEnumLineNumbers_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define IDiaEnumLineNumbers_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define IDiaEnumLineNumbers_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define IDiaEnumLineNumbers_get__NewEnum(This,pRetVal)	\
+    ( (This)->lpVtbl -> get__NewEnum(This,pRetVal) ) 
+
+#define IDiaEnumLineNumbers_get_Count(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_Count(This,pRetVal) ) 
+
+#define IDiaEnumLineNumbers_Item(This,index,lineNumber)	\
+    ( (This)->lpVtbl -> Item(This,index,lineNumber) ) 
+
+#define IDiaEnumLineNumbers_Next(This,celt,rgelt,pceltFetched)	\
+    ( (This)->lpVtbl -> Next(This,celt,rgelt,pceltFetched) ) 
+
+#define IDiaEnumLineNumbers_Skip(This,celt)	\
+    ( (This)->lpVtbl -> Skip(This,celt) ) 
+
+#define IDiaEnumLineNumbers_Reset(This)	\
+    ( (This)->lpVtbl -> Reset(This) ) 
+
+#define IDiaEnumLineNumbers_Clone(This,ppenum)	\
+    ( (This)->lpVtbl -> Clone(This,ppenum) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __IDiaEnumLineNumbers_INTERFACE_DEFINED__ */
+
+
+#ifndef __IDiaEnumInjectedSources_INTERFACE_DEFINED__
+#define __IDiaEnumInjectedSources_INTERFACE_DEFINED__
+
+/* interface IDiaEnumInjectedSources */
+/* [unique][helpstring][local][uuid][object] */ 
+
+
+EXTERN_C const IID IID_IDiaEnumInjectedSources;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("D5612573-6925-4468-8883-98CDEC8C384A")
+    IDiaEnumInjectedSources : public IUnknown
+    {
+    public:
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get__NewEnum( 
+            /* [retval][out] */ IUnknown **pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_Count( 
+            /* [retval][out] */ LONG *pRetVal) = 0;
+        
+        virtual /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE Item( 
+            /* [in] */ DWORD index,
+            /* [retval][out] */ IDiaInjectedSource **injectedSource) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Next( 
+            /* [in] */ ULONG celt,
+            /* [out] */ IDiaInjectedSource **rgelt,
+            /* [out] */ ULONG *pceltFetched) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Skip( 
+            /* [in] */ ULONG celt) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Reset( void) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Clone( 
+            /* [out] */ IDiaEnumInjectedSources **ppenum) = 0;
+        
+    };
+    
+#else 	/* C style interface */
+
+    typedef struct IDiaEnumInjectedSourcesVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            IDiaEnumInjectedSources * This,
+            /* [in] */ REFIID riid,
+            /* [iid_is][out] */ 
+            __RPC__deref_out  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            IDiaEnumInjectedSources * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            IDiaEnumInjectedSources * This);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get__NewEnum )( 
+            IDiaEnumInjectedSources * This,
+            /* [retval][out] */ IUnknown **pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Count )( 
+            IDiaEnumInjectedSources * This,
+            /* [retval][out] */ LONG *pRetVal);
+        
+        /* [helpstring][id] */ HRESULT ( STDMETHODCALLTYPE *Item )( 
+            IDiaEnumInjectedSources * This,
+            /* [in] */ DWORD index,
+            /* [retval][out] */ IDiaInjectedSource **injectedSource);
+        
+        HRESULT ( STDMETHODCALLTYPE *Next )( 
+            IDiaEnumInjectedSources * This,
+            /* [in] */ ULONG celt,
+            /* [out] */ IDiaInjectedSource **rgelt,
+            /* [out] */ ULONG *pceltFetched);
+        
+        HRESULT ( STDMETHODCALLTYPE *Skip )( 
+            IDiaEnumInjectedSources * This,
+            /* [in] */ ULONG celt);
+        
+        HRESULT ( STDMETHODCALLTYPE *Reset )( 
+            IDiaEnumInjectedSources * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *Clone )( 
+            IDiaEnumInjectedSources * This,
+            /* [out] */ IDiaEnumInjectedSources **ppenum);
+        
+        END_INTERFACE
+    } IDiaEnumInjectedSourcesVtbl;
+
+    interface IDiaEnumInjectedSources
+    {
+        CONST_VTBL struct IDiaEnumInjectedSourcesVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define IDiaEnumInjectedSources_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define IDiaEnumInjectedSources_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define IDiaEnumInjectedSources_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define IDiaEnumInjectedSources_get__NewEnum(This,pRetVal)	\
+    ( (This)->lpVtbl -> get__NewEnum(This,pRetVal) ) 
+
+#define IDiaEnumInjectedSources_get_Count(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_Count(This,pRetVal) ) 
+
+#define IDiaEnumInjectedSources_Item(This,index,injectedSource)	\
+    ( (This)->lpVtbl -> Item(This,index,injectedSource) ) 
+
+#define IDiaEnumInjectedSources_Next(This,celt,rgelt,pceltFetched)	\
+    ( (This)->lpVtbl -> Next(This,celt,rgelt,pceltFetched) ) 
+
+#define IDiaEnumInjectedSources_Skip(This,celt)	\
+    ( (This)->lpVtbl -> Skip(This,celt) ) 
+
+#define IDiaEnumInjectedSources_Reset(This)	\
+    ( (This)->lpVtbl -> Reset(This) ) 
+
+#define IDiaEnumInjectedSources_Clone(This,ppenum)	\
+    ( (This)->lpVtbl -> Clone(This,ppenum) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __IDiaEnumInjectedSources_INTERFACE_DEFINED__ */
+
+
+#ifndef __IDiaEnumSegments_INTERFACE_DEFINED__
+#define __IDiaEnumSegments_INTERFACE_DEFINED__
+
+/* interface IDiaEnumSegments */
+/* [unique][helpstring][local][uuid][object] */ 
+
+
+EXTERN_C const IID IID_IDiaEnumSegments;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("E8368CA9-01D1-419d-AC0C-E31235DBDA9F")
+    IDiaEnumSegments : public IUnknown
+    {
+    public:
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get__NewEnum( 
+            /* [retval][out] */ IUnknown **pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_Count( 
+            /* [retval][out] */ LONG *pRetVal) = 0;
+        
+        virtual /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE Item( 
+            /* [in] */ DWORD index,
+            /* [retval][out] */ IDiaSegment **segment) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Next( 
+            /* [in] */ ULONG celt,
+            /* [out] */ IDiaSegment **rgelt,
+            /* [out] */ ULONG *pceltFetched) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Skip( 
+            /* [in] */ ULONG celt) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Reset( void) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Clone( 
+            /* [out] */ IDiaEnumSegments **ppenum) = 0;
+        
+    };
+    
+#else 	/* C style interface */
+
+    typedef struct IDiaEnumSegmentsVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            IDiaEnumSegments * This,
+            /* [in] */ REFIID riid,
+            /* [iid_is][out] */ 
+            __RPC__deref_out  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            IDiaEnumSegments * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            IDiaEnumSegments * This);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get__NewEnum )( 
+            IDiaEnumSegments * This,
+            /* [retval][out] */ IUnknown **pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Count )( 
+            IDiaEnumSegments * This,
+            /* [retval][out] */ LONG *pRetVal);
+        
+        /* [helpstring][id] */ HRESULT ( STDMETHODCALLTYPE *Item )( 
+            IDiaEnumSegments * This,
+            /* [in] */ DWORD index,
+            /* [retval][out] */ IDiaSegment **segment);
+        
+        HRESULT ( STDMETHODCALLTYPE *Next )( 
+            IDiaEnumSegments * This,
+            /* [in] */ ULONG celt,
+            /* [out] */ IDiaSegment **rgelt,
+            /* [out] */ ULONG *pceltFetched);
+        
+        HRESULT ( STDMETHODCALLTYPE *Skip )( 
+            IDiaEnumSegments * This,
+            /* [in] */ ULONG celt);
+        
+        HRESULT ( STDMETHODCALLTYPE *Reset )( 
+            IDiaEnumSegments * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *Clone )( 
+            IDiaEnumSegments * This,
+            /* [out] */ IDiaEnumSegments **ppenum);
+        
+        END_INTERFACE
+    } IDiaEnumSegmentsVtbl;
+
+    interface IDiaEnumSegments
+    {
+        CONST_VTBL struct IDiaEnumSegmentsVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define IDiaEnumSegments_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define IDiaEnumSegments_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define IDiaEnumSegments_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define IDiaEnumSegments_get__NewEnum(This,pRetVal)	\
+    ( (This)->lpVtbl -> get__NewEnum(This,pRetVal) ) 
+
+#define IDiaEnumSegments_get_Count(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_Count(This,pRetVal) ) 
+
+#define IDiaEnumSegments_Item(This,index,segment)	\
+    ( (This)->lpVtbl -> Item(This,index,segment) ) 
+
+#define IDiaEnumSegments_Next(This,celt,rgelt,pceltFetched)	\
+    ( (This)->lpVtbl -> Next(This,celt,rgelt,pceltFetched) ) 
+
+#define IDiaEnumSegments_Skip(This,celt)	\
+    ( (This)->lpVtbl -> Skip(This,celt) ) 
+
+#define IDiaEnumSegments_Reset(This)	\
+    ( (This)->lpVtbl -> Reset(This) ) 
+
+#define IDiaEnumSegments_Clone(This,ppenum)	\
+    ( (This)->lpVtbl -> Clone(This,ppenum) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __IDiaEnumSegments_INTERFACE_DEFINED__ */
+
+
+#ifndef __IDiaEnumSectionContribs_INTERFACE_DEFINED__
+#define __IDiaEnumSectionContribs_INTERFACE_DEFINED__
+
+/* interface IDiaEnumSectionContribs */
+/* [unique][helpstring][local][uuid][object] */ 
+
+
+EXTERN_C const IID IID_IDiaEnumSectionContribs;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("1994DEB2-2C82-4b1d-A57F-AFF424D54A68")
+    IDiaEnumSectionContribs : public IUnknown
+    {
+    public:
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get__NewEnum( 
+            /* [retval][out] */ IUnknown **pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_Count( 
+            /* [retval][out] */ LONG *pRetVal) = 0;
+        
+        virtual /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE Item( 
+            /* [in] */ DWORD index,
+            /* [retval][out] */ IDiaSectionContrib **section) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Next( 
+            /* [in] */ ULONG celt,
+            /* [out] */ IDiaSectionContrib **rgelt,
+            /* [out] */ ULONG *pceltFetched) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Skip( 
+            /* [in] */ ULONG celt) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Reset( void) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Clone( 
+            /* [out] */ IDiaEnumSectionContribs **ppenum) = 0;
+        
+    };
+    
+#else 	/* C style interface */
+
+    typedef struct IDiaEnumSectionContribsVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            IDiaEnumSectionContribs * This,
+            /* [in] */ REFIID riid,
+            /* [iid_is][out] */ 
+            __RPC__deref_out  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            IDiaEnumSectionContribs * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            IDiaEnumSectionContribs * This);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get__NewEnum )( 
+            IDiaEnumSectionContribs * This,
+            /* [retval][out] */ IUnknown **pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Count )( 
+            IDiaEnumSectionContribs * This,
+            /* [retval][out] */ LONG *pRetVal);
+        
+        /* [helpstring][id] */ HRESULT ( STDMETHODCALLTYPE *Item )( 
+            IDiaEnumSectionContribs * This,
+            /* [in] */ DWORD index,
+            /* [retval][out] */ IDiaSectionContrib **section);
+        
+        HRESULT ( STDMETHODCALLTYPE *Next )( 
+            IDiaEnumSectionContribs * This,
+            /* [in] */ ULONG celt,
+            /* [out] */ IDiaSectionContrib **rgelt,
+            /* [out] */ ULONG *pceltFetched);
+        
+        HRESULT ( STDMETHODCALLTYPE *Skip )( 
+            IDiaEnumSectionContribs * This,
+            /* [in] */ ULONG celt);
+        
+        HRESULT ( STDMETHODCALLTYPE *Reset )( 
+            IDiaEnumSectionContribs * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *Clone )( 
+            IDiaEnumSectionContribs * This,
+            /* [out] */ IDiaEnumSectionContribs **ppenum);
+        
+        END_INTERFACE
+    } IDiaEnumSectionContribsVtbl;
+
+    interface IDiaEnumSectionContribs
+    {
+        CONST_VTBL struct IDiaEnumSectionContribsVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define IDiaEnumSectionContribs_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define IDiaEnumSectionContribs_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define IDiaEnumSectionContribs_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define IDiaEnumSectionContribs_get__NewEnum(This,pRetVal)	\
+    ( (This)->lpVtbl -> get__NewEnum(This,pRetVal) ) 
+
+#define IDiaEnumSectionContribs_get_Count(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_Count(This,pRetVal) ) 
+
+#define IDiaEnumSectionContribs_Item(This,index,section)	\
+    ( (This)->lpVtbl -> Item(This,index,section) ) 
+
+#define IDiaEnumSectionContribs_Next(This,celt,rgelt,pceltFetched)	\
+    ( (This)->lpVtbl -> Next(This,celt,rgelt,pceltFetched) ) 
+
+#define IDiaEnumSectionContribs_Skip(This,celt)	\
+    ( (This)->lpVtbl -> Skip(This,celt) ) 
+
+#define IDiaEnumSectionContribs_Reset(This)	\
+    ( (This)->lpVtbl -> Reset(This) ) 
+
+#define IDiaEnumSectionContribs_Clone(This,ppenum)	\
+    ( (This)->lpVtbl -> Clone(This,ppenum) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __IDiaEnumSectionContribs_INTERFACE_DEFINED__ */
+
+
+#ifndef __IDiaEnumFrameData_INTERFACE_DEFINED__
+#define __IDiaEnumFrameData_INTERFACE_DEFINED__
+
+/* interface IDiaEnumFrameData */
+/* [unique][helpstring][local][uuid][object] */ 
+
+
+EXTERN_C const IID IID_IDiaEnumFrameData;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("9FC77A4B-3C1C-44ed-A798-6C1DEEA53E1F")
+    IDiaEnumFrameData : public IUnknown
+    {
+    public:
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get__NewEnum( 
+            /* [retval][out] */ IUnknown **pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_Count( 
+            /* [retval][out] */ LONG *pRetVal) = 0;
+        
+        virtual /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE Item( 
+            /* [in] */ DWORD index,
+            /* [retval][out] */ IDiaFrameData **frame) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Next( 
+            /* [in] */ ULONG celt,
+            /* [out] */ IDiaFrameData **rgelt,
+            /* [out] */ ULONG *pceltFetched) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Skip( 
+            /* [in] */ ULONG celt) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Reset( void) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Clone( 
+            /* [out] */ IDiaEnumFrameData **ppenum) = 0;
+        
+        virtual /* [helpstring] */ HRESULT STDMETHODCALLTYPE frameByRVA( 
+            /* [in] */ DWORD relativeVirtualAddress,
+            /* [retval][out] */ IDiaFrameData **frame) = 0;
+        
+        virtual /* [helpstring] */ HRESULT STDMETHODCALLTYPE frameByVA( 
+            /* [in] */ ULONGLONG virtualAddress,
+            /* [retval][out] */ IDiaFrameData **frame) = 0;
+        
+    };
+    
+#else 	/* C style interface */
+
+    typedef struct IDiaEnumFrameDataVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            IDiaEnumFrameData * This,
+            /* [in] */ REFIID riid,
+            /* [iid_is][out] */ 
+            __RPC__deref_out  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            IDiaEnumFrameData * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            IDiaEnumFrameData * This);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get__NewEnum )( 
+            IDiaEnumFrameData * This,
+            /* [retval][out] */ IUnknown **pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Count )( 
+            IDiaEnumFrameData * This,
+            /* [retval][out] */ LONG *pRetVal);
+        
+        /* [helpstring][id] */ HRESULT ( STDMETHODCALLTYPE *Item )( 
+            IDiaEnumFrameData * This,
+            /* [in] */ DWORD index,
+            /* [retval][out] */ IDiaFrameData **frame);
+        
+        HRESULT ( STDMETHODCALLTYPE *Next )( 
+            IDiaEnumFrameData * This,
+            /* [in] */ ULONG celt,
+            /* [out] */ IDiaFrameData **rgelt,
+            /* [out] */ ULONG *pceltFetched);
+        
+        HRESULT ( STDMETHODCALLTYPE *Skip )( 
+            IDiaEnumFrameData * This,
+            /* [in] */ ULONG celt);
+        
+        HRESULT ( STDMETHODCALLTYPE *Reset )( 
+            IDiaEnumFrameData * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *Clone )( 
+            IDiaEnumFrameData * This,
+            /* [out] */ IDiaEnumFrameData **ppenum);
+        
+        /* [helpstring] */ HRESULT ( STDMETHODCALLTYPE *frameByRVA )( 
+            IDiaEnumFrameData * This,
+            /* [in] */ DWORD relativeVirtualAddress,
+            /* [retval][out] */ IDiaFrameData **frame);
+        
+        /* [helpstring] */ HRESULT ( STDMETHODCALLTYPE *frameByVA )( 
+            IDiaEnumFrameData * This,
+            /* [in] */ ULONGLONG virtualAddress,
+            /* [retval][out] */ IDiaFrameData **frame);
+        
+        END_INTERFACE
+    } IDiaEnumFrameDataVtbl;
+
+    interface IDiaEnumFrameData
+    {
+        CONST_VTBL struct IDiaEnumFrameDataVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define IDiaEnumFrameData_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define IDiaEnumFrameData_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define IDiaEnumFrameData_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define IDiaEnumFrameData_get__NewEnum(This,pRetVal)	\
+    ( (This)->lpVtbl -> get__NewEnum(This,pRetVal) ) 
+
+#define IDiaEnumFrameData_get_Count(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_Count(This,pRetVal) ) 
+
+#define IDiaEnumFrameData_Item(This,index,frame)	\
+    ( (This)->lpVtbl -> Item(This,index,frame) ) 
+
+#define IDiaEnumFrameData_Next(This,celt,rgelt,pceltFetched)	\
+    ( (This)->lpVtbl -> Next(This,celt,rgelt,pceltFetched) ) 
+
+#define IDiaEnumFrameData_Skip(This,celt)	\
+    ( (This)->lpVtbl -> Skip(This,celt) ) 
+
+#define IDiaEnumFrameData_Reset(This)	\
+    ( (This)->lpVtbl -> Reset(This) ) 
+
+#define IDiaEnumFrameData_Clone(This,ppenum)	\
+    ( (This)->lpVtbl -> Clone(This,ppenum) ) 
+
+#define IDiaEnumFrameData_frameByRVA(This,relativeVirtualAddress,frame)	\
+    ( (This)->lpVtbl -> frameByRVA(This,relativeVirtualAddress,frame) ) 
+
+#define IDiaEnumFrameData_frameByVA(This,virtualAddress,frame)	\
+    ( (This)->lpVtbl -> frameByVA(This,virtualAddress,frame) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __IDiaEnumFrameData_INTERFACE_DEFINED__ */
+
+
+#ifndef __IDiaEnumDebugStreamData_INTERFACE_DEFINED__
+#define __IDiaEnumDebugStreamData_INTERFACE_DEFINED__
+
+/* interface IDiaEnumDebugStreamData */
+/* [unique][helpstring][local][uuid][object] */ 
+
+
+EXTERN_C const IID IID_IDiaEnumDebugStreamData;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("486943E8-D187-4a6b-A3C4-291259FFF60D")
+    IDiaEnumDebugStreamData : public IUnknown
+    {
+    public:
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get__NewEnum( 
+            /* [retval][out] */ IUnknown **pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_Count( 
+            /* [retval][out] */ LONG *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_name( 
+            /* [retval][out] */ BSTR *pRetVal) = 0;
+        
+        virtual /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE Item( 
+            /* [in] */ DWORD index,
+            /* [in] */ DWORD cbData,
+            /* [out] */ DWORD *pcbData,
+            /* [size_is][out] */ BYTE *pbData) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Next( 
+            /* [in] */ ULONG celt,
+            /* [in] */ DWORD cbData,
+            /* [out] */ DWORD *pcbData,
+            /* [size_is][out] */ BYTE *pbData,
+            /* [out] */ ULONG *pceltFetched) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Skip( 
+            /* [in] */ ULONG celt) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Reset( void) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Clone( 
+            /* [out] */ IDiaEnumDebugStreamData **ppenum) = 0;
+        
+    };
+    
+#else 	/* C style interface */
+
+    typedef struct IDiaEnumDebugStreamDataVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            IDiaEnumDebugStreamData * This,
+            /* [in] */ REFIID riid,
+            /* [iid_is][out] */ 
+            __RPC__deref_out  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            IDiaEnumDebugStreamData * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            IDiaEnumDebugStreamData * This);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get__NewEnum )( 
+            IDiaEnumDebugStreamData * This,
+            /* [retval][out] */ IUnknown **pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Count )( 
+            IDiaEnumDebugStreamData * This,
+            /* [retval][out] */ LONG *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_name )( 
+            IDiaEnumDebugStreamData * This,
+            /* [retval][out] */ BSTR *pRetVal);
+        
+        /* [helpstring][id] */ HRESULT ( STDMETHODCALLTYPE *Item )( 
+            IDiaEnumDebugStreamData * This,
+            /* [in] */ DWORD index,
+            /* [in] */ DWORD cbData,
+            /* [out] */ DWORD *pcbData,
+            /* [size_is][out] */ BYTE *pbData);
+        
+        HRESULT ( STDMETHODCALLTYPE *Next )( 
+            IDiaEnumDebugStreamData * This,
+            /* [in] */ ULONG celt,
+            /* [in] */ DWORD cbData,
+            /* [out] */ DWORD *pcbData,
+            /* [size_is][out] */ BYTE *pbData,
+            /* [out] */ ULONG *pceltFetched);
+        
+        HRESULT ( STDMETHODCALLTYPE *Skip )( 
+            IDiaEnumDebugStreamData * This,
+            /* [in] */ ULONG celt);
+        
+        HRESULT ( STDMETHODCALLTYPE *Reset )( 
+            IDiaEnumDebugStreamData * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *Clone )( 
+            IDiaEnumDebugStreamData * This,
+            /* [out] */ IDiaEnumDebugStreamData **ppenum);
+        
+        END_INTERFACE
+    } IDiaEnumDebugStreamDataVtbl;
+
+    interface IDiaEnumDebugStreamData
+    {
+        CONST_VTBL struct IDiaEnumDebugStreamDataVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define IDiaEnumDebugStreamData_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define IDiaEnumDebugStreamData_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define IDiaEnumDebugStreamData_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define IDiaEnumDebugStreamData_get__NewEnum(This,pRetVal)	\
+    ( (This)->lpVtbl -> get__NewEnum(This,pRetVal) ) 
+
+#define IDiaEnumDebugStreamData_get_Count(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_Count(This,pRetVal) ) 
+
+#define IDiaEnumDebugStreamData_get_name(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_name(This,pRetVal) ) 
+
+#define IDiaEnumDebugStreamData_Item(This,index,cbData,pcbData,pbData)	\
+    ( (This)->lpVtbl -> Item(This,index,cbData,pcbData,pbData) ) 
+
+#define IDiaEnumDebugStreamData_Next(This,celt,cbData,pcbData,pbData,pceltFetched)	\
+    ( (This)->lpVtbl -> Next(This,celt,cbData,pcbData,pbData,pceltFetched) ) 
+
+#define IDiaEnumDebugStreamData_Skip(This,celt)	\
+    ( (This)->lpVtbl -> Skip(This,celt) ) 
+
+#define IDiaEnumDebugStreamData_Reset(This)	\
+    ( (This)->lpVtbl -> Reset(This) ) 
+
+#define IDiaEnumDebugStreamData_Clone(This,ppenum)	\
+    ( (This)->lpVtbl -> Clone(This,ppenum) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __IDiaEnumDebugStreamData_INTERFACE_DEFINED__ */
+
+
+#ifndef __IDiaEnumDebugStreams_INTERFACE_DEFINED__
+#define __IDiaEnumDebugStreams_INTERFACE_DEFINED__
+
+/* interface IDiaEnumDebugStreams */
+/* [unique][helpstring][local][uuid][object] */ 
+
+
+EXTERN_C const IID IID_IDiaEnumDebugStreams;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("08CBB41E-47A6-4f87-92F1-1C9C87CED044")
+    IDiaEnumDebugStreams : public IUnknown
+    {
+    public:
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get__NewEnum( 
+            /* [retval][out] */ IUnknown **pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_Count( 
+            /* [retval][out] */ LONG *pRetVal) = 0;
+        
+        virtual /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE Item( 
+            /* [in] */ VARIANT index,
+            /* [retval][out] */ IDiaEnumDebugStreamData **stream) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Next( 
+            /* [in] */ ULONG celt,
+            /* [out] */ IDiaEnumDebugStreamData **rgelt,
+            /* [out] */ ULONG *pceltFetched) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Skip( 
+            /* [in] */ ULONG celt) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Reset( void) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Clone( 
+            /* [out] */ IDiaEnumDebugStreams **ppenum) = 0;
+        
+    };
+    
+#else 	/* C style interface */
+
+    typedef struct IDiaEnumDebugStreamsVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            IDiaEnumDebugStreams * This,
+            /* [in] */ REFIID riid,
+            /* [iid_is][out] */ 
+            __RPC__deref_out  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            IDiaEnumDebugStreams * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            IDiaEnumDebugStreams * This);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get__NewEnum )( 
+            IDiaEnumDebugStreams * This,
+            /* [retval][out] */ IUnknown **pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Count )( 
+            IDiaEnumDebugStreams * This,
+            /* [retval][out] */ LONG *pRetVal);
+        
+        /* [helpstring][id] */ HRESULT ( STDMETHODCALLTYPE *Item )( 
+            IDiaEnumDebugStreams * This,
+            /* [in] */ VARIANT index,
+            /* [retval][out] */ IDiaEnumDebugStreamData **stream);
+        
+        HRESULT ( STDMETHODCALLTYPE *Next )( 
+            IDiaEnumDebugStreams * This,
+            /* [in] */ ULONG celt,
+            /* [out] */ IDiaEnumDebugStreamData **rgelt,
+            /* [out] */ ULONG *pceltFetched);
+        
+        HRESULT ( STDMETHODCALLTYPE *Skip )( 
+            IDiaEnumDebugStreams * This,
+            /* [in] */ ULONG celt);
+        
+        HRESULT ( STDMETHODCALLTYPE *Reset )( 
+            IDiaEnumDebugStreams * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *Clone )( 
+            IDiaEnumDebugStreams * This,
+            /* [out] */ IDiaEnumDebugStreams **ppenum);
+        
+        END_INTERFACE
+    } IDiaEnumDebugStreamsVtbl;
+
+    interface IDiaEnumDebugStreams
+    {
+        CONST_VTBL struct IDiaEnumDebugStreamsVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define IDiaEnumDebugStreams_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define IDiaEnumDebugStreams_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define IDiaEnumDebugStreams_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define IDiaEnumDebugStreams_get__NewEnum(This,pRetVal)	\
+    ( (This)->lpVtbl -> get__NewEnum(This,pRetVal) ) 
+
+#define IDiaEnumDebugStreams_get_Count(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_Count(This,pRetVal) ) 
+
+#define IDiaEnumDebugStreams_Item(This,index,stream)	\
+    ( (This)->lpVtbl -> Item(This,index,stream) ) 
+
+#define IDiaEnumDebugStreams_Next(This,celt,rgelt,pceltFetched)	\
+    ( (This)->lpVtbl -> Next(This,celt,rgelt,pceltFetched) ) 
+
+#define IDiaEnumDebugStreams_Skip(This,celt)	\
+    ( (This)->lpVtbl -> Skip(This,celt) ) 
+
+#define IDiaEnumDebugStreams_Reset(This)	\
+    ( (This)->lpVtbl -> Reset(This) ) 
+
+#define IDiaEnumDebugStreams_Clone(This,ppenum)	\
+    ( (This)->lpVtbl -> Clone(This,ppenum) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __IDiaEnumDebugStreams_INTERFACE_DEFINED__ */
+
+
+/* interface __MIDL_itf_dia2_0000_0015 */
+/* [local] */ 
+
+struct DiaAddressMapEntry
+    {
+    DWORD rva;
+    DWORD rvaTo;
+    } ;
+
+
+extern RPC_IF_HANDLE __MIDL_itf_dia2_0000_0015_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_dia2_0000_0015_v0_0_s_ifspec;
+
+#ifndef __IDiaAddressMap_INTERFACE_DEFINED__
+#define __IDiaAddressMap_INTERFACE_DEFINED__
+
+/* interface IDiaAddressMap */
+/* [unique][helpstring][local][uuid][object] */ 
+
+
+EXTERN_C const IID IID_IDiaAddressMap;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("B62A2E7A-067A-4ea3-B598-04C09717502C")
+    IDiaAddressMap : public IUnknown
+    {
+    public:
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_addressMapEnabled( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propput] */ HRESULT STDMETHODCALLTYPE put_addressMapEnabled( 
+            /* [in] */ BOOL NewVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_relativeVirtualAddressEnabled( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propput] */ HRESULT STDMETHODCALLTYPE put_relativeVirtualAddressEnabled( 
+            /* [in] */ BOOL NewVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_imageAlign( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propput] */ HRESULT STDMETHODCALLTYPE put_imageAlign( 
+            /* [in] */ DWORD NewVal) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE set_imageHeaders( 
+            /* [in] */ DWORD cbData,
+            /* [size_is][in] */ BYTE *pbData,
+            /* [in] */ BOOL originalHeaders) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE set_addressMap( 
+            /* [in] */ DWORD cData,
+            /* [size_is][in] */ struct DiaAddressMapEntry *pData,
+            /* [in] */ BOOL imageToSymbols) = 0;
+        
+    };
+    
+#else 	/* C style interface */
+
+    typedef struct IDiaAddressMapVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            IDiaAddressMap * This,
+            /* [in] */ REFIID riid,
+            /* [iid_is][out] */ 
+            __RPC__deref_out  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            IDiaAddressMap * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            IDiaAddressMap * This);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_addressMapEnabled )( 
+            IDiaAddressMap * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propput] */ HRESULT ( STDMETHODCALLTYPE *put_addressMapEnabled )( 
+            IDiaAddressMap * This,
+            /* [in] */ BOOL NewVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_relativeVirtualAddressEnabled )( 
+            IDiaAddressMap * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propput] */ HRESULT ( STDMETHODCALLTYPE *put_relativeVirtualAddressEnabled )( 
+            IDiaAddressMap * This,
+            /* [in] */ BOOL NewVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_imageAlign )( 
+            IDiaAddressMap * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propput] */ HRESULT ( STDMETHODCALLTYPE *put_imageAlign )( 
+            IDiaAddressMap * This,
+            /* [in] */ DWORD NewVal);
+        
+        HRESULT ( STDMETHODCALLTYPE *set_imageHeaders )( 
+            IDiaAddressMap * This,
+            /* [in] */ DWORD cbData,
+            /* [size_is][in] */ BYTE *pbData,
+            /* [in] */ BOOL originalHeaders);
+        
+        HRESULT ( STDMETHODCALLTYPE *set_addressMap )( 
+            IDiaAddressMap * This,
+            /* [in] */ DWORD cData,
+            /* [size_is][in] */ struct DiaAddressMapEntry *pData,
+            /* [in] */ BOOL imageToSymbols);
+        
+        END_INTERFACE
+    } IDiaAddressMapVtbl;
+
+    interface IDiaAddressMap
+    {
+        CONST_VTBL struct IDiaAddressMapVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define IDiaAddressMap_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define IDiaAddressMap_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define IDiaAddressMap_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define IDiaAddressMap_get_addressMapEnabled(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_addressMapEnabled(This,pRetVal) ) 
+
+#define IDiaAddressMap_put_addressMapEnabled(This,NewVal)	\
+    ( (This)->lpVtbl -> put_addressMapEnabled(This,NewVal) ) 
+
+#define IDiaAddressMap_get_relativeVirtualAddressEnabled(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_relativeVirtualAddressEnabled(This,pRetVal) ) 
+
+#define IDiaAddressMap_put_relativeVirtualAddressEnabled(This,NewVal)	\
+    ( (This)->lpVtbl -> put_relativeVirtualAddressEnabled(This,NewVal) ) 
+
+#define IDiaAddressMap_get_imageAlign(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_imageAlign(This,pRetVal) ) 
+
+#define IDiaAddressMap_put_imageAlign(This,NewVal)	\
+    ( (This)->lpVtbl -> put_imageAlign(This,NewVal) ) 
+
+#define IDiaAddressMap_set_imageHeaders(This,cbData,pbData,originalHeaders)	\
+    ( (This)->lpVtbl -> set_imageHeaders(This,cbData,pbData,originalHeaders) ) 
+
+#define IDiaAddressMap_set_addressMap(This,cData,pData,imageToSymbols)	\
+    ( (This)->lpVtbl -> set_addressMap(This,cData,pData,imageToSymbols) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __IDiaAddressMap_INTERFACE_DEFINED__ */
+
+
+#ifndef __IDiaSession_INTERFACE_DEFINED__
+#define __IDiaSession_INTERFACE_DEFINED__
+
+/* interface IDiaSession */
+/* [unique][helpstring][local][uuid][object] */ 
+
+
+EXTERN_C const IID IID_IDiaSession;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("67138B34-79CD-4b42-B74A-A18ADBB799DF")
+    IDiaSession : public IUnknown
+    {
+    public:
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_loadAddress( 
+            /* [retval][out] */ ULONGLONG *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propput] */ HRESULT STDMETHODCALLTYPE put_loadAddress( 
+            /* [in] */ ULONGLONG NewVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_globalScope( 
+            /* [retval][out] */ IDiaSymbol **pRetVal) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE getEnumTables( 
+            /* [out] */ IDiaEnumTables **ppEnumTables) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE getSymbolsByAddr( 
+            /* [out] */ IDiaEnumSymbolsByAddr **ppEnumbyAddr) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE findChildren( 
+            /* [in] */ IDiaSymbol *parent,
+            /* [in] */ enum SymTagEnum symtag,
+            /* [in] */ LPCOLESTR name,
+            /* [in] */ DWORD compareFlags,
+            /* [out] */ IDiaEnumSymbols **ppResult) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE findChildrenEx( 
+            /* [in] */ IDiaSymbol *parent,
+            /* [in] */ enum SymTagEnum symtag,
+            /* [in] */ LPCOLESTR name,
+            /* [in] */ DWORD compareFlags,
+            /* [out] */ IDiaEnumSymbols **ppResult) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE findChildrenExByAddr( 
+            /* [in] */ IDiaSymbol *parent,
+            /* [in] */ enum SymTagEnum symtag,
+            /* [in] */ LPCOLESTR name,
+            /* [in] */ DWORD compareFlags,
+            /* [in] */ DWORD isect,
+            /* [in] */ DWORD offset,
+            /* [out] */ IDiaEnumSymbols **ppResult) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE findChildrenExByVA( 
+            /* [in] */ IDiaSymbol *parent,
+            /* [in] */ enum SymTagEnum symtag,
+            /* [in] */ LPCOLESTR name,
+            /* [in] */ DWORD compareFlags,
+            /* [in] */ ULONGLONG va,
+            /* [out] */ IDiaEnumSymbols **ppResult) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE findChildrenExByRVA( 
+            /* [in] */ IDiaSymbol *parent,
+            /* [in] */ enum SymTagEnum symtag,
+            /* [in] */ LPCOLESTR name,
+            /* [in] */ DWORD compareFlags,
+            /* [in] */ DWORD rva,
+            /* [out] */ IDiaEnumSymbols **ppResult) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE findSymbolByAddr( 
+            /* [in] */ DWORD isect,
+            /* [in] */ DWORD offset,
+            /* [in] */ enum SymTagEnum symtag,
+            /* [out] */ IDiaSymbol **ppSymbol) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE findSymbolByRVA( 
+            /* [in] */ DWORD rva,
+            /* [in] */ enum SymTagEnum symtag,
+            /* [out] */ IDiaSymbol **ppSymbol) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE findSymbolByVA( 
+            /* [in] */ ULONGLONG va,
+            /* [in] */ enum SymTagEnum symtag,
+            /* [out] */ IDiaSymbol **ppSymbol) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE findSymbolByToken( 
+            /* [in] */ ULONG token,
+            /* [in] */ enum SymTagEnum symtag,
+            /* [out] */ IDiaSymbol **ppSymbol) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE symsAreEquiv( 
+            /* [in] */ IDiaSymbol *symbolA,
+            /* [in] */ IDiaSymbol *symbolB) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE symbolById( 
+            /* [in] */ DWORD id,
+            /* [out] */ IDiaSymbol **ppSymbol) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE findSymbolByRVAEx( 
+            /* [in] */ DWORD rva,
+            /* [in] */ enum SymTagEnum symtag,
+            /* [out] */ IDiaSymbol **ppSymbol,
+            /* [out] */ long *displacement) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE findSymbolByVAEx( 
+            /* [in] */ ULONGLONG va,
+            /* [in] */ enum SymTagEnum symtag,
+            /* [out] */ IDiaSymbol **ppSymbol,
+            /* [out] */ long *displacement) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE findFile( 
+            /* [in] */ IDiaSymbol *pCompiland,
+            /* [in] */ LPCOLESTR name,
+            /* [in] */ DWORD compareFlags,
+            /* [out] */ IDiaEnumSourceFiles **ppResult) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE findFileById( 
+            /* [in] */ DWORD uniqueId,
+            /* [out] */ IDiaSourceFile **ppResult) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE findLines( 
+            /* [in] */ IDiaSymbol *compiland,
+            /* [in] */ IDiaSourceFile *file,
+            /* [out] */ IDiaEnumLineNumbers **ppResult) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE findLinesByAddr( 
+            /* [in] */ DWORD seg,
+            /* [in] */ DWORD offset,
+            /* [in] */ DWORD length,
+            /* [out] */ IDiaEnumLineNumbers **ppResult) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE findLinesByRVA( 
+            /* [in] */ DWORD rva,
+            /* [in] */ DWORD length,
+            /* [out] */ IDiaEnumLineNumbers **ppResult) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE findLinesByVA( 
+            /* [in] */ ULONGLONG va,
+            /* [in] */ DWORD length,
+            /* [out] */ IDiaEnumLineNumbers **ppResult) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE findLinesByLinenum( 
+            /* [in] */ IDiaSymbol *compiland,
+            /* [in] */ IDiaSourceFile *file,
+            /* [in] */ DWORD linenum,
+            /* [in] */ DWORD column,
+            /* [out] */ IDiaEnumLineNumbers **ppResult) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE findInjectedSource( 
+            /* [in] */ LPCOLESTR srcFile,
+            /* [out] */ IDiaEnumInjectedSources **ppResult) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE getEnumDebugStreams( 
+            /* [out] */ IDiaEnumDebugStreams **ppEnumDebugStreams) = 0;
+        
+    };
+    
+#else 	/* C style interface */
+
+    typedef struct IDiaSessionVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            IDiaSession * This,
+            /* [in] */ REFIID riid,
+            /* [iid_is][out] */ 
+            __RPC__deref_out  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            IDiaSession * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            IDiaSession * This);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_loadAddress )( 
+            IDiaSession * This,
+            /* [retval][out] */ ULONGLONG *pRetVal);
+        
+        /* [id][helpstring][propput] */ HRESULT ( STDMETHODCALLTYPE *put_loadAddress )( 
+            IDiaSession * This,
+            /* [in] */ ULONGLONG NewVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_globalScope )( 
+            IDiaSession * This,
+            /* [retval][out] */ IDiaSymbol **pRetVal);
+        
+        HRESULT ( STDMETHODCALLTYPE *getEnumTables )( 
+            IDiaSession * This,
+            /* [out] */ IDiaEnumTables **ppEnumTables);
+        
+        HRESULT ( STDMETHODCALLTYPE *getSymbolsByAddr )( 
+            IDiaSession * This,
+            /* [out] */ IDiaEnumSymbolsByAddr **ppEnumbyAddr);
+        
+        HRESULT ( STDMETHODCALLTYPE *findChildren )( 
+            IDiaSession * This,
+            /* [in] */ IDiaSymbol *parent,
+            /* [in] */ enum SymTagEnum symtag,
+            /* [in] */ LPCOLESTR name,
+            /* [in] */ DWORD compareFlags,
+            /* [out] */ IDiaEnumSymbols **ppResult);
+        
+        HRESULT ( STDMETHODCALLTYPE *findChildrenEx )( 
+            IDiaSession * This,
+            /* [in] */ IDiaSymbol *parent,
+            /* [in] */ enum SymTagEnum symtag,
+            /* [in] */ LPCOLESTR name,
+            /* [in] */ DWORD compareFlags,
+            /* [out] */ IDiaEnumSymbols **ppResult);
+        
+        HRESULT ( STDMETHODCALLTYPE *findChildrenExByAddr )( 
+            IDiaSession * This,
+            /* [in] */ IDiaSymbol *parent,
+            /* [in] */ enum SymTagEnum symtag,
+            /* [in] */ LPCOLESTR name,
+            /* [in] */ DWORD compareFlags,
+            /* [in] */ DWORD isect,
+            /* [in] */ DWORD offset,
+            /* [out] */ IDiaEnumSymbols **ppResult);
+        
+        HRESULT ( STDMETHODCALLTYPE *findChildrenExByVA )( 
+            IDiaSession * This,
+            /* [in] */ IDiaSymbol *parent,
+            /* [in] */ enum SymTagEnum symtag,
+            /* [in] */ LPCOLESTR name,
+            /* [in] */ DWORD compareFlags,
+            /* [in] */ ULONGLONG va,
+            /* [out] */ IDiaEnumSymbols **ppResult);
+        
+        HRESULT ( STDMETHODCALLTYPE *findChildrenExByRVA )( 
+            IDiaSession * This,
+            /* [in] */ IDiaSymbol *parent,
+            /* [in] */ enum SymTagEnum symtag,
+            /* [in] */ LPCOLESTR name,
+            /* [in] */ DWORD compareFlags,
+            /* [in] */ DWORD rva,
+            /* [out] */ IDiaEnumSymbols **ppResult);
+        
+        HRESULT ( STDMETHODCALLTYPE *findSymbolByAddr )( 
+            IDiaSession * This,
+            /* [in] */ DWORD isect,
+            /* [in] */ DWORD offset,
+            /* [in] */ enum SymTagEnum symtag,
+            /* [out] */ IDiaSymbol **ppSymbol);
+        
+        HRESULT ( STDMETHODCALLTYPE *findSymbolByRVA )( 
+            IDiaSession * This,
+            /* [in] */ DWORD rva,
+            /* [in] */ enum SymTagEnum symtag,
+            /* [out] */ IDiaSymbol **ppSymbol);
+        
+        HRESULT ( STDMETHODCALLTYPE *findSymbolByVA )( 
+            IDiaSession * This,
+            /* [in] */ ULONGLONG va,
+            /* [in] */ enum SymTagEnum symtag,
+            /* [out] */ IDiaSymbol **ppSymbol);
+        
+        HRESULT ( STDMETHODCALLTYPE *findSymbolByToken )( 
+            IDiaSession * This,
+            /* [in] */ ULONG token,
+            /* [in] */ enum SymTagEnum symtag,
+            /* [out] */ IDiaSymbol **ppSymbol);
+        
+        HRESULT ( STDMETHODCALLTYPE *symsAreEquiv )( 
+            IDiaSession * This,
+            /* [in] */ IDiaSymbol *symbolA,
+            /* [in] */ IDiaSymbol *symbolB);
+        
+        HRESULT ( STDMETHODCALLTYPE *symbolById )( 
+            IDiaSession * This,
+            /* [in] */ DWORD id,
+            /* [out] */ IDiaSymbol **ppSymbol);
+        
+        HRESULT ( STDMETHODCALLTYPE *findSymbolByRVAEx )( 
+            IDiaSession * This,
+            /* [in] */ DWORD rva,
+            /* [in] */ enum SymTagEnum symtag,
+            /* [out] */ IDiaSymbol **ppSymbol,
+            /* [out] */ long *displacement);
+        
+        HRESULT ( STDMETHODCALLTYPE *findSymbolByVAEx )( 
+            IDiaSession * This,
+            /* [in] */ ULONGLONG va,
+            /* [in] */ enum SymTagEnum symtag,
+            /* [out] */ IDiaSymbol **ppSymbol,
+            /* [out] */ long *displacement);
+        
+        HRESULT ( STDMETHODCALLTYPE *findFile )( 
+            IDiaSession * This,
+            /* [in] */ IDiaSymbol *pCompiland,
+            /* [in] */ LPCOLESTR name,
+            /* [in] */ DWORD compareFlags,
+            /* [out] */ IDiaEnumSourceFiles **ppResult);
+        
+        HRESULT ( STDMETHODCALLTYPE *findFileById )( 
+            IDiaSession * This,
+            /* [in] */ DWORD uniqueId,
+            /* [out] */ IDiaSourceFile **ppResult);
+        
+        HRESULT ( STDMETHODCALLTYPE *findLines )( 
+            IDiaSession * This,
+            /* [in] */ IDiaSymbol *compiland,
+            /* [in] */ IDiaSourceFile *file,
+            /* [out] */ IDiaEnumLineNumbers **ppResult);
+        
+        HRESULT ( STDMETHODCALLTYPE *findLinesByAddr )( 
+            IDiaSession * This,
+            /* [in] */ DWORD seg,
+            /* [in] */ DWORD offset,
+            /* [in] */ DWORD length,
+            /* [out] */ IDiaEnumLineNumbers **ppResult);
+        
+        HRESULT ( STDMETHODCALLTYPE *findLinesByRVA )( 
+            IDiaSession * This,
+            /* [in] */ DWORD rva,
+            /* [in] */ DWORD length,
+            /* [out] */ IDiaEnumLineNumbers **ppResult);
+        
+        HRESULT ( STDMETHODCALLTYPE *findLinesByVA )( 
+            IDiaSession * This,
+            /* [in] */ ULONGLONG va,
+            /* [in] */ DWORD length,
+            /* [out] */ IDiaEnumLineNumbers **ppResult);
+        
+        HRESULT ( STDMETHODCALLTYPE *findLinesByLinenum )( 
+            IDiaSession * This,
+            /* [in] */ IDiaSymbol *compiland,
+            /* [in] */ IDiaSourceFile *file,
+            /* [in] */ DWORD linenum,
+            /* [in] */ DWORD column,
+            /* [out] */ IDiaEnumLineNumbers **ppResult);
+        
+        HRESULT ( STDMETHODCALLTYPE *findInjectedSource )( 
+            IDiaSession * This,
+            /* [in] */ LPCOLESTR srcFile,
+            /* [out] */ IDiaEnumInjectedSources **ppResult);
+        
+        HRESULT ( STDMETHODCALLTYPE *getEnumDebugStreams )( 
+            IDiaSession * This,
+            /* [out] */ IDiaEnumDebugStreams **ppEnumDebugStreams);
+        
+        END_INTERFACE
+    } IDiaSessionVtbl;
+
+    interface IDiaSession
+    {
+        CONST_VTBL struct IDiaSessionVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define IDiaSession_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define IDiaSession_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define IDiaSession_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define IDiaSession_get_loadAddress(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_loadAddress(This,pRetVal) ) 
+
+#define IDiaSession_put_loadAddress(This,NewVal)	\
+    ( (This)->lpVtbl -> put_loadAddress(This,NewVal) ) 
+
+#define IDiaSession_get_globalScope(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_globalScope(This,pRetVal) ) 
+
+#define IDiaSession_getEnumTables(This,ppEnumTables)	\
+    ( (This)->lpVtbl -> getEnumTables(This,ppEnumTables) ) 
+
+#define IDiaSession_getSymbolsByAddr(This,ppEnumbyAddr)	\
+    ( (This)->lpVtbl -> getSymbolsByAddr(This,ppEnumbyAddr) ) 
+
+#define IDiaSession_findChildren(This,parent,symtag,name,compareFlags,ppResult)	\
+    ( (This)->lpVtbl -> findChildren(This,parent,symtag,name,compareFlags,ppResult) ) 
+
+#define IDiaSession_findChildrenEx(This,parent,symtag,name,compareFlags,ppResult)	\
+    ( (This)->lpVtbl -> findChildrenEx(This,parent,symtag,name,compareFlags,ppResult) ) 
+
+#define IDiaSession_findChildrenExByAddr(This,parent,symtag,name,compareFlags,isect,offset,ppResult)	\
+    ( (This)->lpVtbl -> findChildrenExByAddr(This,parent,symtag,name,compareFlags,isect,offset,ppResult) ) 
+
+#define IDiaSession_findChildrenExByVA(This,parent,symtag,name,compareFlags,va,ppResult)	\
+    ( (This)->lpVtbl -> findChildrenExByVA(This,parent,symtag,name,compareFlags,va,ppResult) ) 
+
+#define IDiaSession_findChildrenExByRVA(This,parent,symtag,name,compareFlags,rva,ppResult)	\
+    ( (This)->lpVtbl -> findChildrenExByRVA(This,parent,symtag,name,compareFlags,rva,ppResult) ) 
+
+#define IDiaSession_findSymbolByAddr(This,isect,offset,symtag,ppSymbol)	\
+    ( (This)->lpVtbl -> findSymbolByAddr(This,isect,offset,symtag,ppSymbol) ) 
+
+#define IDiaSession_findSymbolByRVA(This,rva,symtag,ppSymbol)	\
+    ( (This)->lpVtbl -> findSymbolByRVA(This,rva,symtag,ppSymbol) ) 
+
+#define IDiaSession_findSymbolByVA(This,va,symtag,ppSymbol)	\
+    ( (This)->lpVtbl -> findSymbolByVA(This,va,symtag,ppSymbol) ) 
+
+#define IDiaSession_findSymbolByToken(This,token,symtag,ppSymbol)	\
+    ( (This)->lpVtbl -> findSymbolByToken(This,token,symtag,ppSymbol) ) 
+
+#define IDiaSession_symsAreEquiv(This,symbolA,symbolB)	\
+    ( (This)->lpVtbl -> symsAreEquiv(This,symbolA,symbolB) ) 
+
+#define IDiaSession_symbolById(This,id,ppSymbol)	\
+    ( (This)->lpVtbl -> symbolById(This,id,ppSymbol) ) 
+
+#define IDiaSession_findSymbolByRVAEx(This,rva,symtag,ppSymbol,displacement)	\
+    ( (This)->lpVtbl -> findSymbolByRVAEx(This,rva,symtag,ppSymbol,displacement) ) 
+
+#define IDiaSession_findSymbolByVAEx(This,va,symtag,ppSymbol,displacement)	\
+    ( (This)->lpVtbl -> findSymbolByVAEx(This,va,symtag,ppSymbol,displacement) ) 
+
+#define IDiaSession_findFile(This,pCompiland,name,compareFlags,ppResult)	\
+    ( (This)->lpVtbl -> findFile(This,pCompiland,name,compareFlags,ppResult) ) 
+
+#define IDiaSession_findFileById(This,uniqueId,ppResult)	\
+    ( (This)->lpVtbl -> findFileById(This,uniqueId,ppResult) ) 
+
+#define IDiaSession_findLines(This,compiland,file,ppResult)	\
+    ( (This)->lpVtbl -> findLines(This,compiland,file,ppResult) ) 
+
+#define IDiaSession_findLinesByAddr(This,seg,offset,length,ppResult)	\
+    ( (This)->lpVtbl -> findLinesByAddr(This,seg,offset,length,ppResult) ) 
+
+#define IDiaSession_findLinesByRVA(This,rva,length,ppResult)	\
+    ( (This)->lpVtbl -> findLinesByRVA(This,rva,length,ppResult) ) 
+
+#define IDiaSession_findLinesByVA(This,va,length,ppResult)	\
+    ( (This)->lpVtbl -> findLinesByVA(This,va,length,ppResult) ) 
+
+#define IDiaSession_findLinesByLinenum(This,compiland,file,linenum,column,ppResult)	\
+    ( (This)->lpVtbl -> findLinesByLinenum(This,compiland,file,linenum,column,ppResult) ) 
+
+#define IDiaSession_findInjectedSource(This,srcFile,ppResult)	\
+    ( (This)->lpVtbl -> findInjectedSource(This,srcFile,ppResult) ) 
+
+#define IDiaSession_getEnumDebugStreams(This,ppEnumDebugStreams)	\
+    ( (This)->lpVtbl -> getEnumDebugStreams(This,ppEnumDebugStreams) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __IDiaSession_INTERFACE_DEFINED__ */
+
+
+#ifndef __IDiaSymbol_INTERFACE_DEFINED__
+#define __IDiaSymbol_INTERFACE_DEFINED__
+
+/* interface IDiaSymbol */
+/* [unique][helpstring][local][uuid][object] */ 
+
+
+EXTERN_C const IID IID_IDiaSymbol;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("cb787b2f-bd6c-4635-ba52-933126bd2dcd")
+    IDiaSymbol : public IUnknown
+    {
+    public:
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_symIndexId( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_symTag( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_name( 
+            /* [retval][out] */ BSTR *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_lexicalParent( 
+            /* [retval][out] */ IDiaSymbol **pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_classParent( 
+            /* [retval][out] */ IDiaSymbol **pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_type( 
+            /* [retval][out] */ IDiaSymbol **pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_dataKind( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_locationType( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_addressSection( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_addressOffset( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_relativeVirtualAddress( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_virtualAddress( 
+            /* [retval][out] */ ULONGLONG *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_registerId( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_offset( 
+            /* [retval][out] */ LONG *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_length( 
+            /* [retval][out] */ ULONGLONG *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_slot( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_volatileType( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_constType( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_unalignedType( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_access( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_libraryName( 
+            /* [retval][out] */ BSTR *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_platform( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_language( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_editAndContinueEnabled( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_frontEndMajor( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_frontEndMinor( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_frontEndBuild( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_backEndMajor( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_backEndMinor( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_backEndBuild( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_sourceFileName( 
+            /* [retval][out] */ BSTR *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_unused( 
+            /* [retval][out] */ BSTR *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_thunkOrdinal( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_thisAdjust( 
+            /* [retval][out] */ LONG *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_virtualBaseOffset( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_virtual( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_intro( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_pure( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_callingConvention( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_value( 
+            /* [retval][out] */ VARIANT *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_baseType( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_token( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_timeStamp( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_guid( 
+            /* [retval][out] */ GUID *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_symbolsFileName( 
+            /* [retval][out] */ BSTR *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_reference( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_count( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_bitPosition( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_arrayIndexType( 
+            /* [retval][out] */ IDiaSymbol **pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_packed( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_constructor( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_overloadedOperator( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_nested( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_hasNestedTypes( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_hasAssignmentOperator( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_hasCastOperator( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_scoped( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_virtualBaseClass( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_indirectVirtualBaseClass( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_virtualBasePointerOffset( 
+            /* [retval][out] */ LONG *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_virtualTableShape( 
+            /* [retval][out] */ IDiaSymbol **pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_lexicalParentId( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_classParentId( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_typeId( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_arrayIndexTypeId( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_virtualTableShapeId( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_code( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_function( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_managed( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_msil( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_virtualBaseDispIndex( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_undecoratedName( 
+            /* [retval][out] */ BSTR *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_age( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_signature( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_compilerGenerated( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_addressTaken( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_rank( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_lowerBound( 
+            /* [retval][out] */ IDiaSymbol **pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_upperBound( 
+            /* [retval][out] */ IDiaSymbol **pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_lowerBoundId( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_upperBoundId( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE get_dataBytes( 
+            /* [in] */ DWORD cbData,
+            /* [out] */ DWORD *pcbData,
+            /* [size_is][out] */ BYTE *pbData) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE findChildren( 
+            /* [in] */ enum SymTagEnum symtag,
+            /* [in] */ LPCOLESTR name,
+            /* [in] */ DWORD compareFlags,
+            /* [out] */ IDiaEnumSymbols **ppResult) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE findChildrenEx( 
+            /* [in] */ enum SymTagEnum symtag,
+            /* [in] */ LPCOLESTR name,
+            /* [in] */ DWORD compareFlags,
+            /* [out] */ IDiaEnumSymbols **ppResult) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE findChildrenExByAddr( 
+            /* [in] */ enum SymTagEnum symtag,
+            /* [in] */ LPCOLESTR name,
+            /* [in] */ DWORD compareFlags,
+            /* [in] */ DWORD isect,
+            /* [in] */ DWORD offset,
+            /* [out] */ IDiaEnumSymbols **ppResult) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE findChildrenExByVA( 
+            /* [in] */ enum SymTagEnum symtag,
+            /* [in] */ LPCOLESTR name,
+            /* [in] */ DWORD compareFlags,
+            /* [in] */ ULONGLONG va,
+            /* [out] */ IDiaEnumSymbols **ppResult) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE findChildrenExByRVA( 
+            /* [in] */ enum SymTagEnum symtag,
+            /* [in] */ LPCOLESTR name,
+            /* [in] */ DWORD compareFlags,
+            /* [in] */ DWORD rva,
+            /* [out] */ IDiaEnumSymbols **ppResult) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_targetSection( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_targetOffset( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_targetRelativeVirtualAddress( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_targetVirtualAddress( 
+            /* [retval][out] */ ULONGLONG *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_machineType( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_oemId( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_oemSymbolId( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE get_types( 
+            /* [in] */ DWORD cTypes,
+            /* [out] */ DWORD *pcTypes,
+            /* [size_is][size_is][out] */ IDiaSymbol **pTypes) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE get_typeIds( 
+            /* [in] */ DWORD cTypeIds,
+            /* [out] */ DWORD *pcTypeIds,
+            /* [size_is][out] */ DWORD *pdwTypeIds) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_objectPointerType( 
+            /* [retval][out] */ IDiaSymbol **pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_udtKind( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE get_undecoratedNameEx( 
+            /* [in] */ DWORD undecorateOptions,
+            /* [out] */ BSTR *name) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_noReturn( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_customCallingConvention( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_noInline( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_optimizedCodeDebugInfo( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_notReached( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_interruptReturn( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_farReturn( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_isStatic( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_hasDebugInfo( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_isLTCG( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_isDataAligned( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_hasSecurityChecks( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_compilerName( 
+            /* [retval][out] */ BSTR *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_hasAlloca( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_hasSetJump( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_hasLongJump( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_hasInlAsm( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_hasEH( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_hasSEH( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_hasEHa( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_isNaked( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_isAggregated( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_isSplitted( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_container( 
+            /* [retval][out] */ IDiaSymbol **pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_inlSpec( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_noStackOrdering( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_virtualBaseTableType( 
+            /* [retval][out] */ IDiaSymbol **pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_hasManagedCode( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_isHotpatchable( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_isCVTCIL( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_isMSILNetmodule( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_isCTypes( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_isStripped( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_frontEndQFE( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_backEndQFE( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_wasInlined( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_strictGSCheck( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_isCxxReturnUdt( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_isConstructorVirtualBase( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_RValueReference( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_unmodifiedType( 
+            /* [retval][out] */ IDiaSymbol **pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_framePointerPresent( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_isSafeBuffers( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_intrinsic( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_sealed( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_hfaFloat( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_hfaDouble( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_liveRangeStartAddressSection( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_liveRangeStartAddressOffset( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_liveRangeStartRelativeVirtualAddress( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_countLiveRanges( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_liveRangeLength( 
+            /* [retval][out] */ ULONGLONG *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_offsetInUdt( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_paramBasePointerRegisterId( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_localBasePointerRegisterId( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+    };
+    
+#else 	/* C style interface */
+
+    typedef struct IDiaSymbolVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            IDiaSymbol * This,
+            /* [in] */ REFIID riid,
+            /* [iid_is][out] */ 
+            __RPC__deref_out  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            IDiaSymbol * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            IDiaSymbol * This);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_symIndexId )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_symTag )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_name )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BSTR *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lexicalParent )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ IDiaSymbol **pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_classParent )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ IDiaSymbol **pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_type )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ IDiaSymbol **pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_dataKind )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_locationType )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_addressSection )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_addressOffset )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_relativeVirtualAddress )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualAddress )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ ULONGLONG *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_registerId )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_offset )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ LONG *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_length )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ ULONGLONG *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_slot )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_volatileType )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_constType )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_unalignedType )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_access )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_libraryName )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BSTR *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_platform )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_language )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_editAndContinueEnabled )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_frontEndMajor )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_frontEndMinor )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_frontEndBuild )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_backEndMajor )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_backEndMinor )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_backEndBuild )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_sourceFileName )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BSTR *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_unused )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BSTR *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_thunkOrdinal )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_thisAdjust )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ LONG *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualBaseOffset )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtual )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_intro )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_pure )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_callingConvention )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_value )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ VARIANT *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_baseType )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_token )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_timeStamp )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_guid )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ GUID *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_symbolsFileName )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BSTR *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_reference )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_count )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_bitPosition )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_arrayIndexType )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ IDiaSymbol **pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_packed )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_constructor )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_overloadedOperator )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_nested )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasNestedTypes )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasAssignmentOperator )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasCastOperator )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_scoped )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualBaseClass )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_indirectVirtualBaseClass )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualBasePointerOffset )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ LONG *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualTableShape )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ IDiaSymbol **pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lexicalParentId )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_classParentId )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_typeId )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_arrayIndexTypeId )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualTableShapeId )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_code )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_function )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_managed )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_msil )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualBaseDispIndex )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_undecoratedName )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BSTR *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_age )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_signature )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_compilerGenerated )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_addressTaken )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_rank )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lowerBound )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ IDiaSymbol **pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_upperBound )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ IDiaSymbol **pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lowerBoundId )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_upperBoundId )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        HRESULT ( STDMETHODCALLTYPE *get_dataBytes )( 
+            IDiaSymbol * This,
+            /* [in] */ DWORD cbData,
+            /* [out] */ DWORD *pcbData,
+            /* [size_is][out] */ BYTE *pbData);
+        
+        HRESULT ( STDMETHODCALLTYPE *findChildren )( 
+            IDiaSymbol * This,
+            /* [in] */ enum SymTagEnum symtag,
+            /* [in] */ LPCOLESTR name,
+            /* [in] */ DWORD compareFlags,
+            /* [out] */ IDiaEnumSymbols **ppResult);
+        
+        HRESULT ( STDMETHODCALLTYPE *findChildrenEx )( 
+            IDiaSymbol * This,
+            /* [in] */ enum SymTagEnum symtag,
+            /* [in] */ LPCOLESTR name,
+            /* [in] */ DWORD compareFlags,
+            /* [out] */ IDiaEnumSymbols **ppResult);
+        
+        HRESULT ( STDMETHODCALLTYPE *findChildrenExByAddr )( 
+            IDiaSymbol * This,
+            /* [in] */ enum SymTagEnum symtag,
+            /* [in] */ LPCOLESTR name,
+            /* [in] */ DWORD compareFlags,
+            /* [in] */ DWORD isect,
+            /* [in] */ DWORD offset,
+            /* [out] */ IDiaEnumSymbols **ppResult);
+        
+        HRESULT ( STDMETHODCALLTYPE *findChildrenExByVA )( 
+            IDiaSymbol * This,
+            /* [in] */ enum SymTagEnum symtag,
+            /* [in] */ LPCOLESTR name,
+            /* [in] */ DWORD compareFlags,
+            /* [in] */ ULONGLONG va,
+            /* [out] */ IDiaEnumSymbols **ppResult);
+        
+        HRESULT ( STDMETHODCALLTYPE *findChildrenExByRVA )( 
+            IDiaSymbol * This,
+            /* [in] */ enum SymTagEnum symtag,
+            /* [in] */ LPCOLESTR name,
+            /* [in] */ DWORD compareFlags,
+            /* [in] */ DWORD rva,
+            /* [out] */ IDiaEnumSymbols **ppResult);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_targetSection )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_targetOffset )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_targetRelativeVirtualAddress )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_targetVirtualAddress )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ ULONGLONG *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_machineType )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_oemId )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_oemSymbolId )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        HRESULT ( STDMETHODCALLTYPE *get_types )( 
+            IDiaSymbol * This,
+            /* [in] */ DWORD cTypes,
+            /* [out] */ DWORD *pcTypes,
+            /* [size_is][size_is][out] */ IDiaSymbol **pTypes);
+        
+        HRESULT ( STDMETHODCALLTYPE *get_typeIds )( 
+            IDiaSymbol * This,
+            /* [in] */ DWORD cTypeIds,
+            /* [out] */ DWORD *pcTypeIds,
+            /* [size_is][out] */ DWORD *pdwTypeIds);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_objectPointerType )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ IDiaSymbol **pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_udtKind )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        HRESULT ( STDMETHODCALLTYPE *get_undecoratedNameEx )( 
+            IDiaSymbol * This,
+            /* [in] */ DWORD undecorateOptions,
+            /* [out] */ BSTR *name);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_noReturn )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_customCallingConvention )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_noInline )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_optimizedCodeDebugInfo )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_notReached )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_interruptReturn )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_farReturn )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isStatic )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasDebugInfo )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isLTCG )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isDataAligned )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasSecurityChecks )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_compilerName )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BSTR *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasAlloca )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasSetJump )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasLongJump )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasInlAsm )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasEH )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasSEH )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasEHa )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isNaked )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isAggregated )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isSplitted )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_container )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ IDiaSymbol **pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_inlSpec )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_noStackOrdering )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualBaseTableType )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ IDiaSymbol **pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasManagedCode )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isHotpatchable )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isCVTCIL )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isMSILNetmodule )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isCTypes )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isStripped )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_frontEndQFE )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_backEndQFE )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_wasInlined )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_strictGSCheck )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isCxxReturnUdt )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isConstructorVirtualBase )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_RValueReference )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_unmodifiedType )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ IDiaSymbol **pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_framePointerPresent )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isSafeBuffers )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_intrinsic )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_sealed )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hfaFloat )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hfaDouble )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_liveRangeStartAddressSection )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_liveRangeStartAddressOffset )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_liveRangeStartRelativeVirtualAddress )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_countLiveRanges )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_liveRangeLength )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ ULONGLONG *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_offsetInUdt )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_paramBasePointerRegisterId )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_localBasePointerRegisterId )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        END_INTERFACE
+    } IDiaSymbolVtbl;
+
+    interface IDiaSymbol
+    {
+        CONST_VTBL struct IDiaSymbolVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define IDiaSymbol_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define IDiaSymbol_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define IDiaSymbol_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define IDiaSymbol_get_symIndexId(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_symIndexId(This,pRetVal) ) 
+
+#define IDiaSymbol_get_symTag(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_symTag(This,pRetVal) ) 
+
+#define IDiaSymbol_get_name(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_name(This,pRetVal) ) 
+
+#define IDiaSymbol_get_lexicalParent(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_lexicalParent(This,pRetVal) ) 
+
+#define IDiaSymbol_get_classParent(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_classParent(This,pRetVal) ) 
+
+#define IDiaSymbol_get_type(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_type(This,pRetVal) ) 
+
+#define IDiaSymbol_get_dataKind(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_dataKind(This,pRetVal) ) 
+
+#define IDiaSymbol_get_locationType(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_locationType(This,pRetVal) ) 
+
+#define IDiaSymbol_get_addressSection(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_addressSection(This,pRetVal) ) 
+
+#define IDiaSymbol_get_addressOffset(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_addressOffset(This,pRetVal) ) 
+
+#define IDiaSymbol_get_relativeVirtualAddress(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_relativeVirtualAddress(This,pRetVal) ) 
+
+#define IDiaSymbol_get_virtualAddress(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_virtualAddress(This,pRetVal) ) 
+
+#define IDiaSymbol_get_registerId(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_registerId(This,pRetVal) ) 
+
+#define IDiaSymbol_get_offset(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_offset(This,pRetVal) ) 
+
+#define IDiaSymbol_get_length(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_length(This,pRetVal) ) 
+
+#define IDiaSymbol_get_slot(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_slot(This,pRetVal) ) 
+
+#define IDiaSymbol_get_volatileType(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_volatileType(This,pRetVal) ) 
+
+#define IDiaSymbol_get_constType(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_constType(This,pRetVal) ) 
+
+#define IDiaSymbol_get_unalignedType(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_unalignedType(This,pRetVal) ) 
+
+#define IDiaSymbol_get_access(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_access(This,pRetVal) ) 
+
+#define IDiaSymbol_get_libraryName(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_libraryName(This,pRetVal) ) 
+
+#define IDiaSymbol_get_platform(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_platform(This,pRetVal) ) 
+
+#define IDiaSymbol_get_language(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_language(This,pRetVal) ) 
+
+#define IDiaSymbol_get_editAndContinueEnabled(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_editAndContinueEnabled(This,pRetVal) ) 
+
+#define IDiaSymbol_get_frontEndMajor(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_frontEndMajor(This,pRetVal) ) 
+
+#define IDiaSymbol_get_frontEndMinor(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_frontEndMinor(This,pRetVal) ) 
+
+#define IDiaSymbol_get_frontEndBuild(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_frontEndBuild(This,pRetVal) ) 
+
+#define IDiaSymbol_get_backEndMajor(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_backEndMajor(This,pRetVal) ) 
+
+#define IDiaSymbol_get_backEndMinor(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_backEndMinor(This,pRetVal) ) 
+
+#define IDiaSymbol_get_backEndBuild(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_backEndBuild(This,pRetVal) ) 
+
+#define IDiaSymbol_get_sourceFileName(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_sourceFileName(This,pRetVal) ) 
+
+#define IDiaSymbol_get_unused(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_unused(This,pRetVal) ) 
+
+#define IDiaSymbol_get_thunkOrdinal(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_thunkOrdinal(This,pRetVal) ) 
+
+#define IDiaSymbol_get_thisAdjust(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_thisAdjust(This,pRetVal) ) 
+
+#define IDiaSymbol_get_virtualBaseOffset(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_virtualBaseOffset(This,pRetVal) ) 
+
+#define IDiaSymbol_get_virtual(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_virtual(This,pRetVal) ) 
+
+#define IDiaSymbol_get_intro(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_intro(This,pRetVal) ) 
+
+#define IDiaSymbol_get_pure(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_pure(This,pRetVal) ) 
+
+#define IDiaSymbol_get_callingConvention(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_callingConvention(This,pRetVal) ) 
+
+#define IDiaSymbol_get_value(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_value(This,pRetVal) ) 
+
+#define IDiaSymbol_get_baseType(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_baseType(This,pRetVal) ) 
+
+#define IDiaSymbol_get_token(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_token(This,pRetVal) ) 
+
+#define IDiaSymbol_get_timeStamp(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_timeStamp(This,pRetVal) ) 
+
+#define IDiaSymbol_get_guid(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_guid(This,pRetVal) ) 
+
+#define IDiaSymbol_get_symbolsFileName(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_symbolsFileName(This,pRetVal) ) 
+
+#define IDiaSymbol_get_reference(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_reference(This,pRetVal) ) 
+
+#define IDiaSymbol_get_count(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_count(This,pRetVal) ) 
+
+#define IDiaSymbol_get_bitPosition(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_bitPosition(This,pRetVal) ) 
+
+#define IDiaSymbol_get_arrayIndexType(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_arrayIndexType(This,pRetVal) ) 
+
+#define IDiaSymbol_get_packed(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_packed(This,pRetVal) ) 
+
+#define IDiaSymbol_get_constructor(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_constructor(This,pRetVal) ) 
+
+#define IDiaSymbol_get_overloadedOperator(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_overloadedOperator(This,pRetVal) ) 
+
+#define IDiaSymbol_get_nested(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_nested(This,pRetVal) ) 
+
+#define IDiaSymbol_get_hasNestedTypes(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_hasNestedTypes(This,pRetVal) ) 
+
+#define IDiaSymbol_get_hasAssignmentOperator(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_hasAssignmentOperator(This,pRetVal) ) 
+
+#define IDiaSymbol_get_hasCastOperator(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_hasCastOperator(This,pRetVal) ) 
+
+#define IDiaSymbol_get_scoped(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_scoped(This,pRetVal) ) 
+
+#define IDiaSymbol_get_virtualBaseClass(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_virtualBaseClass(This,pRetVal) ) 
+
+#define IDiaSymbol_get_indirectVirtualBaseClass(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_indirectVirtualBaseClass(This,pRetVal) ) 
+
+#define IDiaSymbol_get_virtualBasePointerOffset(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_virtualBasePointerOffset(This,pRetVal) ) 
+
+#define IDiaSymbol_get_virtualTableShape(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_virtualTableShape(This,pRetVal) ) 
+
+#define IDiaSymbol_get_lexicalParentId(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_lexicalParentId(This,pRetVal) ) 
+
+#define IDiaSymbol_get_classParentId(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_classParentId(This,pRetVal) ) 
+
+#define IDiaSymbol_get_typeId(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_typeId(This,pRetVal) ) 
+
+#define IDiaSymbol_get_arrayIndexTypeId(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_arrayIndexTypeId(This,pRetVal) ) 
+
+#define IDiaSymbol_get_virtualTableShapeId(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_virtualTableShapeId(This,pRetVal) ) 
+
+#define IDiaSymbol_get_code(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_code(This,pRetVal) ) 
+
+#define IDiaSymbol_get_function(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_function(This,pRetVal) ) 
+
+#define IDiaSymbol_get_managed(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_managed(This,pRetVal) ) 
+
+#define IDiaSymbol_get_msil(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_msil(This,pRetVal) ) 
+
+#define IDiaSymbol_get_virtualBaseDispIndex(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_virtualBaseDispIndex(This,pRetVal) ) 
+
+#define IDiaSymbol_get_undecoratedName(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_undecoratedName(This,pRetVal) ) 
+
+#define IDiaSymbol_get_age(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_age(This,pRetVal) ) 
+
+#define IDiaSymbol_get_signature(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_signature(This,pRetVal) ) 
+
+#define IDiaSymbol_get_compilerGenerated(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_compilerGenerated(This,pRetVal) ) 
+
+#define IDiaSymbol_get_addressTaken(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_addressTaken(This,pRetVal) ) 
+
+#define IDiaSymbol_get_rank(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_rank(This,pRetVal) ) 
+
+#define IDiaSymbol_get_lowerBound(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_lowerBound(This,pRetVal) ) 
+
+#define IDiaSymbol_get_upperBound(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_upperBound(This,pRetVal) ) 
+
+#define IDiaSymbol_get_lowerBoundId(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_lowerBoundId(This,pRetVal) ) 
+
+#define IDiaSymbol_get_upperBoundId(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_upperBoundId(This,pRetVal) ) 
+
+#define IDiaSymbol_get_dataBytes(This,cbData,pcbData,pbData)	\
+    ( (This)->lpVtbl -> get_dataBytes(This,cbData,pcbData,pbData) ) 
+
+#define IDiaSymbol_findChildren(This,symtag,name,compareFlags,ppResult)	\
+    ( (This)->lpVtbl -> findChildren(This,symtag,name,compareFlags,ppResult) ) 
+
+#define IDiaSymbol_findChildrenEx(This,symtag,name,compareFlags,ppResult)	\
+    ( (This)->lpVtbl -> findChildrenEx(This,symtag,name,compareFlags,ppResult) ) 
+
+#define IDiaSymbol_findChildrenExByAddr(This,symtag,name,compareFlags,isect,offset,ppResult)	\
+    ( (This)->lpVtbl -> findChildrenExByAddr(This,symtag,name,compareFlags,isect,offset,ppResult) ) 
+
+#define IDiaSymbol_findChildrenExByVA(This,symtag,name,compareFlags,va,ppResult)	\
+    ( (This)->lpVtbl -> findChildrenExByVA(This,symtag,name,compareFlags,va,ppResult) ) 
+
+#define IDiaSymbol_findChildrenExByRVA(This,symtag,name,compareFlags,rva,ppResult)	\
+    ( (This)->lpVtbl -> findChildrenExByRVA(This,symtag,name,compareFlags,rva,ppResult) ) 
+
+#define IDiaSymbol_get_targetSection(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_targetSection(This,pRetVal) ) 
+
+#define IDiaSymbol_get_targetOffset(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_targetOffset(This,pRetVal) ) 
+
+#define IDiaSymbol_get_targetRelativeVirtualAddress(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_targetRelativeVirtualAddress(This,pRetVal) ) 
+
+#define IDiaSymbol_get_targetVirtualAddress(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_targetVirtualAddress(This,pRetVal) ) 
+
+#define IDiaSymbol_get_machineType(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_machineType(This,pRetVal) ) 
+
+#define IDiaSymbol_get_oemId(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_oemId(This,pRetVal) ) 
+
+#define IDiaSymbol_get_oemSymbolId(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_oemSymbolId(This,pRetVal) ) 
+
+#define IDiaSymbol_get_types(This,cTypes,pcTypes,pTypes)	\
+    ( (This)->lpVtbl -> get_types(This,cTypes,pcTypes,pTypes) ) 
+
+#define IDiaSymbol_get_typeIds(This,cTypeIds,pcTypeIds,pdwTypeIds)	\
+    ( (This)->lpVtbl -> get_typeIds(This,cTypeIds,pcTypeIds,pdwTypeIds) ) 
+
+#define IDiaSymbol_get_objectPointerType(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_objectPointerType(This,pRetVal) ) 
+
+#define IDiaSymbol_get_udtKind(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_udtKind(This,pRetVal) ) 
+
+#define IDiaSymbol_get_undecoratedNameEx(This,undecorateOptions,name)	\
+    ( (This)->lpVtbl -> get_undecoratedNameEx(This,undecorateOptions,name) ) 
+
+#define IDiaSymbol_get_noReturn(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_noReturn(This,pRetVal) ) 
+
+#define IDiaSymbol_get_customCallingConvention(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_customCallingConvention(This,pRetVal) ) 
+
+#define IDiaSymbol_get_noInline(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_noInline(This,pRetVal) ) 
+
+#define IDiaSymbol_get_optimizedCodeDebugInfo(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_optimizedCodeDebugInfo(This,pRetVal) ) 
+
+#define IDiaSymbol_get_notReached(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_notReached(This,pRetVal) ) 
+
+#define IDiaSymbol_get_interruptReturn(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_interruptReturn(This,pRetVal) ) 
+
+#define IDiaSymbol_get_farReturn(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_farReturn(This,pRetVal) ) 
+
+#define IDiaSymbol_get_isStatic(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_isStatic(This,pRetVal) ) 
+
+#define IDiaSymbol_get_hasDebugInfo(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_hasDebugInfo(This,pRetVal) ) 
+
+#define IDiaSymbol_get_isLTCG(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_isLTCG(This,pRetVal) ) 
+
+#define IDiaSymbol_get_isDataAligned(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_isDataAligned(This,pRetVal) ) 
+
+#define IDiaSymbol_get_hasSecurityChecks(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_hasSecurityChecks(This,pRetVal) ) 
+
+#define IDiaSymbol_get_compilerName(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_compilerName(This,pRetVal) ) 
+
+#define IDiaSymbol_get_hasAlloca(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_hasAlloca(This,pRetVal) ) 
+
+#define IDiaSymbol_get_hasSetJump(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_hasSetJump(This,pRetVal) ) 
+
+#define IDiaSymbol_get_hasLongJump(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_hasLongJump(This,pRetVal) ) 
+
+#define IDiaSymbol_get_hasInlAsm(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_hasInlAsm(This,pRetVal) ) 
+
+#define IDiaSymbol_get_hasEH(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_hasEH(This,pRetVal) ) 
+
+#define IDiaSymbol_get_hasSEH(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_hasSEH(This,pRetVal) ) 
+
+#define IDiaSymbol_get_hasEHa(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_hasEHa(This,pRetVal) ) 
+
+#define IDiaSymbol_get_isNaked(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_isNaked(This,pRetVal) ) 
+
+#define IDiaSymbol_get_isAggregated(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_isAggregated(This,pRetVal) ) 
+
+#define IDiaSymbol_get_isSplitted(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_isSplitted(This,pRetVal) ) 
+
+#define IDiaSymbol_get_container(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_container(This,pRetVal) ) 
+
+#define IDiaSymbol_get_inlSpec(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_inlSpec(This,pRetVal) ) 
+
+#define IDiaSymbol_get_noStackOrdering(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_noStackOrdering(This,pRetVal) ) 
+
+#define IDiaSymbol_get_virtualBaseTableType(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_virtualBaseTableType(This,pRetVal) ) 
+
+#define IDiaSymbol_get_hasManagedCode(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_hasManagedCode(This,pRetVal) ) 
+
+#define IDiaSymbol_get_isHotpatchable(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_isHotpatchable(This,pRetVal) ) 
+
+#define IDiaSymbol_get_isCVTCIL(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_isCVTCIL(This,pRetVal) ) 
+
+#define IDiaSymbol_get_isMSILNetmodule(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_isMSILNetmodule(This,pRetVal) ) 
+
+#define IDiaSymbol_get_isCTypes(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_isCTypes(This,pRetVal) ) 
+
+#define IDiaSymbol_get_isStripped(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_isStripped(This,pRetVal) ) 
+
+#define IDiaSymbol_get_frontEndQFE(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_frontEndQFE(This,pRetVal) ) 
+
+#define IDiaSymbol_get_backEndQFE(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_backEndQFE(This,pRetVal) ) 
+
+#define IDiaSymbol_get_wasInlined(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_wasInlined(This,pRetVal) ) 
+
+#define IDiaSymbol_get_strictGSCheck(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_strictGSCheck(This,pRetVal) ) 
+
+#define IDiaSymbol_get_isCxxReturnUdt(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_isCxxReturnUdt(This,pRetVal) ) 
+
+#define IDiaSymbol_get_isConstructorVirtualBase(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_isConstructorVirtualBase(This,pRetVal) ) 
+
+#define IDiaSymbol_get_RValueReference(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_RValueReference(This,pRetVal) ) 
+
+#define IDiaSymbol_get_unmodifiedType(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_unmodifiedType(This,pRetVal) ) 
+
+#define IDiaSymbol_get_framePointerPresent(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_framePointerPresent(This,pRetVal) ) 
+
+#define IDiaSymbol_get_isSafeBuffers(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_isSafeBuffers(This,pRetVal) ) 
+
+#define IDiaSymbol_get_intrinsic(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_intrinsic(This,pRetVal) ) 
+
+#define IDiaSymbol_get_sealed(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_sealed(This,pRetVal) ) 
+
+#define IDiaSymbol_get_hfaFloat(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_hfaFloat(This,pRetVal) ) 
+
+#define IDiaSymbol_get_hfaDouble(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_hfaDouble(This,pRetVal) ) 
+
+#define IDiaSymbol_get_liveRangeStartAddressSection(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_liveRangeStartAddressSection(This,pRetVal) ) 
+
+#define IDiaSymbol_get_liveRangeStartAddressOffset(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_liveRangeStartAddressOffset(This,pRetVal) ) 
+
+#define IDiaSymbol_get_liveRangeStartRelativeVirtualAddress(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_liveRangeStartRelativeVirtualAddress(This,pRetVal) ) 
+
+#define IDiaSymbol_get_countLiveRanges(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_countLiveRanges(This,pRetVal) ) 
+
+#define IDiaSymbol_get_liveRangeLength(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_liveRangeLength(This,pRetVal) ) 
+
+#define IDiaSymbol_get_offsetInUdt(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_offsetInUdt(This,pRetVal) ) 
+
+#define IDiaSymbol_get_paramBasePointerRegisterId(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_paramBasePointerRegisterId(This,pRetVal) ) 
+
+#define IDiaSymbol_get_localBasePointerRegisterId(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_localBasePointerRegisterId(This,pRetVal) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_virtualBaseTableType_Proxy( 
+    IDiaSymbol * This,
+    /* [retval][out] */ IDiaSymbol **pRetVal);
+
+
+void __RPC_STUB IDiaSymbol_get_virtualBaseTableType_Stub(
+    IRpcStubBuffer *This,
+    IRpcChannelBuffer *_pRpcChannelBuffer,
+    PRPC_MESSAGE _pRpcMessage,
+    DWORD *_pdwStubPhase);
+
+
+/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_hasManagedCode_Proxy( 
+    IDiaSymbol * This,
+    /* [retval][out] */ BOOL *pRetVal);
+
+
+void __RPC_STUB IDiaSymbol_get_hasManagedCode_Stub(
+    IRpcStubBuffer *This,
+    IRpcChannelBuffer *_pRpcChannelBuffer,
+    PRPC_MESSAGE _pRpcMessage,
+    DWORD *_pdwStubPhase);
+
+
+/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_isHotpatchable_Proxy( 
+    IDiaSymbol * This,
+    /* [retval][out] */ BOOL *pRetVal);
+
+
+void __RPC_STUB IDiaSymbol_get_isHotpatchable_Stub(
+    IRpcStubBuffer *This,
+    IRpcChannelBuffer *_pRpcChannelBuffer,
+    PRPC_MESSAGE _pRpcMessage,
+    DWORD *_pdwStubPhase);
+
+
+/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_isCVTCIL_Proxy( 
+    IDiaSymbol * This,
+    /* [retval][out] */ BOOL *pRetVal);
+
+
+void __RPC_STUB IDiaSymbol_get_isCVTCIL_Stub(
+    IRpcStubBuffer *This,
+    IRpcChannelBuffer *_pRpcChannelBuffer,
+    PRPC_MESSAGE _pRpcMessage,
+    DWORD *_pdwStubPhase);
+
+
+/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_isMSILNetmodule_Proxy( 
+    IDiaSymbol * This,
+    /* [retval][out] */ BOOL *pRetVal);
+
+
+void __RPC_STUB IDiaSymbol_get_isMSILNetmodule_Stub(
+    IRpcStubBuffer *This,
+    IRpcChannelBuffer *_pRpcChannelBuffer,
+    PRPC_MESSAGE _pRpcMessage,
+    DWORD *_pdwStubPhase);
+
+
+/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_isCTypes_Proxy( 
+    IDiaSymbol * This,
+    /* [retval][out] */ BOOL *pRetVal);
+
+
+void __RPC_STUB IDiaSymbol_get_isCTypes_Stub(
+    IRpcStubBuffer *This,
+    IRpcChannelBuffer *_pRpcChannelBuffer,
+    PRPC_MESSAGE _pRpcMessage,
+    DWORD *_pdwStubPhase);
+
+
+/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_isStripped_Proxy( 
+    IDiaSymbol * This,
+    /* [retval][out] */ BOOL *pRetVal);
+
+
+void __RPC_STUB IDiaSymbol_get_isStripped_Stub(
+    IRpcStubBuffer *This,
+    IRpcChannelBuffer *_pRpcChannelBuffer,
+    PRPC_MESSAGE _pRpcMessage,
+    DWORD *_pdwStubPhase);
+
+
+/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_frontEndQFE_Proxy( 
+    IDiaSymbol * This,
+    /* [retval][out] */ DWORD *pRetVal);
+
+
+void __RPC_STUB IDiaSymbol_get_frontEndQFE_Stub(
+    IRpcStubBuffer *This,
+    IRpcChannelBuffer *_pRpcChannelBuffer,
+    PRPC_MESSAGE _pRpcMessage,
+    DWORD *_pdwStubPhase);
+
+
+/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_backEndQFE_Proxy( 
+    IDiaSymbol * This,
+    /* [retval][out] */ DWORD *pRetVal);
+
+
+void __RPC_STUB IDiaSymbol_get_backEndQFE_Stub(
+    IRpcStubBuffer *This,
+    IRpcChannelBuffer *_pRpcChannelBuffer,
+    PRPC_MESSAGE _pRpcMessage,
+    DWORD *_pdwStubPhase);
+
+
+/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_wasInlined_Proxy( 
+    IDiaSymbol * This,
+    /* [retval][out] */ BOOL *pRetVal);
+
+
+void __RPC_STUB IDiaSymbol_get_wasInlined_Stub(
+    IRpcStubBuffer *This,
+    IRpcChannelBuffer *_pRpcChannelBuffer,
+    PRPC_MESSAGE _pRpcMessage,
+    DWORD *_pdwStubPhase);
+
+
+/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_strictGSCheck_Proxy( 
+    IDiaSymbol * This,
+    /* [retval][out] */ BOOL *pRetVal);
+
+
+void __RPC_STUB IDiaSymbol_get_strictGSCheck_Stub(
+    IRpcStubBuffer *This,
+    IRpcChannelBuffer *_pRpcChannelBuffer,
+    PRPC_MESSAGE _pRpcMessage,
+    DWORD *_pdwStubPhase);
+
+
+/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_isCxxReturnUdt_Proxy( 
+    IDiaSymbol * This,
+    /* [retval][out] */ BOOL *pRetVal);
+
+
+void __RPC_STUB IDiaSymbol_get_isCxxReturnUdt_Stub(
+    IRpcStubBuffer *This,
+    IRpcChannelBuffer *_pRpcChannelBuffer,
+    PRPC_MESSAGE _pRpcMessage,
+    DWORD *_pdwStubPhase);
+
+
+/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_isConstructorVirtualBase_Proxy( 
+    IDiaSymbol * This,
+    /* [retval][out] */ BOOL *pRetVal);
+
+
+void __RPC_STUB IDiaSymbol_get_isConstructorVirtualBase_Stub(
+    IRpcStubBuffer *This,
+    IRpcChannelBuffer *_pRpcChannelBuffer,
+    PRPC_MESSAGE _pRpcMessage,
+    DWORD *_pdwStubPhase);
+
+
+/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_RValueReference_Proxy( 
+    IDiaSymbol * This,
+    /* [retval][out] */ BOOL *pRetVal);
+
+
+void __RPC_STUB IDiaSymbol_get_RValueReference_Stub(
+    IRpcStubBuffer *This,
+    IRpcChannelBuffer *_pRpcChannelBuffer,
+    PRPC_MESSAGE _pRpcMessage,
+    DWORD *_pdwStubPhase);
+
+
+/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_unmodifiedType_Proxy( 
+    IDiaSymbol * This,
+    /* [retval][out] */ IDiaSymbol **pRetVal);
+
+
+void __RPC_STUB IDiaSymbol_get_unmodifiedType_Stub(
+    IRpcStubBuffer *This,
+    IRpcChannelBuffer *_pRpcChannelBuffer,
+    PRPC_MESSAGE _pRpcMessage,
+    DWORD *_pdwStubPhase);
+
+
+/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_framePointerPresent_Proxy( 
+    IDiaSymbol * This,
+    /* [retval][out] */ BOOL *pRetVal);
+
+
+void __RPC_STUB IDiaSymbol_get_framePointerPresent_Stub(
+    IRpcStubBuffer *This,
+    IRpcChannelBuffer *_pRpcChannelBuffer,
+    PRPC_MESSAGE _pRpcMessage,
+    DWORD *_pdwStubPhase);
+
+
+/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_isSafeBuffers_Proxy( 
+    IDiaSymbol * This,
+    /* [retval][out] */ BOOL *pRetVal);
+
+
+void __RPC_STUB IDiaSymbol_get_isSafeBuffers_Stub(
+    IRpcStubBuffer *This,
+    IRpcChannelBuffer *_pRpcChannelBuffer,
+    PRPC_MESSAGE _pRpcMessage,
+    DWORD *_pdwStubPhase);
+
+
+/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_intrinsic_Proxy( 
+    IDiaSymbol * This,
+    /* [retval][out] */ BOOL *pRetVal);
+
+
+void __RPC_STUB IDiaSymbol_get_intrinsic_Stub(
+    IRpcStubBuffer *This,
+    IRpcChannelBuffer *_pRpcChannelBuffer,
+    PRPC_MESSAGE _pRpcMessage,
+    DWORD *_pdwStubPhase);
+
+
+/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_sealed_Proxy( 
+    IDiaSymbol * This,
+    /* [retval][out] */ BOOL *pRetVal);
+
+
+void __RPC_STUB IDiaSymbol_get_sealed_Stub(
+    IRpcStubBuffer *This,
+    IRpcChannelBuffer *_pRpcChannelBuffer,
+    PRPC_MESSAGE _pRpcMessage,
+    DWORD *_pdwStubPhase);
+
+
+/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_hfaFloat_Proxy( 
+    IDiaSymbol * This,
+    /* [retval][out] */ BOOL *pRetVal);
+
+
+void __RPC_STUB IDiaSymbol_get_hfaFloat_Stub(
+    IRpcStubBuffer *This,
+    IRpcChannelBuffer *_pRpcChannelBuffer,
+    PRPC_MESSAGE _pRpcMessage,
+    DWORD *_pdwStubPhase);
+
+
+/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_hfaDouble_Proxy( 
+    IDiaSymbol * This,
+    /* [retval][out] */ BOOL *pRetVal);
+
+
+void __RPC_STUB IDiaSymbol_get_hfaDouble_Stub(
+    IRpcStubBuffer *This,
+    IRpcChannelBuffer *_pRpcChannelBuffer,
+    PRPC_MESSAGE _pRpcMessage,
+    DWORD *_pdwStubPhase);
+
+
+/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_liveRangeStartAddressSection_Proxy( 
+    IDiaSymbol * This,
+    /* [retval][out] */ DWORD *pRetVal);
+
+
+void __RPC_STUB IDiaSymbol_get_liveRangeStartAddressSection_Stub(
+    IRpcStubBuffer *This,
+    IRpcChannelBuffer *_pRpcChannelBuffer,
+    PRPC_MESSAGE _pRpcMessage,
+    DWORD *_pdwStubPhase);
+
+
+/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_liveRangeStartAddressOffset_Proxy( 
+    IDiaSymbol * This,
+    /* [retval][out] */ DWORD *pRetVal);
+
+
+void __RPC_STUB IDiaSymbol_get_liveRangeStartAddressOffset_Stub(
+    IRpcStubBuffer *This,
+    IRpcChannelBuffer *_pRpcChannelBuffer,
+    PRPC_MESSAGE _pRpcMessage,
+    DWORD *_pdwStubPhase);
+
+
+/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_liveRangeStartRelativeVirtualAddress_Proxy( 
+    IDiaSymbol * This,
+    /* [retval][out] */ DWORD *pRetVal);
+
+
+void __RPC_STUB IDiaSymbol_get_liveRangeStartRelativeVirtualAddress_Stub(
+    IRpcStubBuffer *This,
+    IRpcChannelBuffer *_pRpcChannelBuffer,
+    PRPC_MESSAGE _pRpcMessage,
+    DWORD *_pdwStubPhase);
+
+
+/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_countLiveRanges_Proxy( 
+    IDiaSymbol * This,
+    /* [retval][out] */ DWORD *pRetVal);
+
+
+void __RPC_STUB IDiaSymbol_get_countLiveRanges_Stub(
+    IRpcStubBuffer *This,
+    IRpcChannelBuffer *_pRpcChannelBuffer,
+    PRPC_MESSAGE _pRpcMessage,
+    DWORD *_pdwStubPhase);
+
+
+/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_liveRangeLength_Proxy( 
+    IDiaSymbol * This,
+    /* [retval][out] */ ULONGLONG *pRetVal);
+
+
+void __RPC_STUB IDiaSymbol_get_liveRangeLength_Stub(
+    IRpcStubBuffer *This,
+    IRpcChannelBuffer *_pRpcChannelBuffer,
+    PRPC_MESSAGE _pRpcMessage,
+    DWORD *_pdwStubPhase);
+
+
+/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_offsetInUdt_Proxy( 
+    IDiaSymbol * This,
+    /* [retval][out] */ DWORD *pRetVal);
+
+
+void __RPC_STUB IDiaSymbol_get_offsetInUdt_Stub(
+    IRpcStubBuffer *This,
+    IRpcChannelBuffer *_pRpcChannelBuffer,
+    PRPC_MESSAGE _pRpcMessage,
+    DWORD *_pdwStubPhase);
+
+
+/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_paramBasePointerRegisterId_Proxy( 
+    IDiaSymbol * This,
+    /* [retval][out] */ DWORD *pRetVal);
+
+
+void __RPC_STUB IDiaSymbol_get_paramBasePointerRegisterId_Stub(
+    IRpcStubBuffer *This,
+    IRpcChannelBuffer *_pRpcChannelBuffer,
+    PRPC_MESSAGE _pRpcMessage,
+    DWORD *_pdwStubPhase);
+
+
+/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_localBasePointerRegisterId_Proxy( 
+    IDiaSymbol * This,
+    /* [retval][out] */ DWORD *pRetVal);
+
+
+void __RPC_STUB IDiaSymbol_get_localBasePointerRegisterId_Stub(
+    IRpcStubBuffer *This,
+    IRpcChannelBuffer *_pRpcChannelBuffer,
+    PRPC_MESSAGE _pRpcMessage,
+    DWORD *_pdwStubPhase);
+
+
+
+#endif 	/* __IDiaSymbol_INTERFACE_DEFINED__ */
+
+
+#ifndef __IDiaSourceFile_INTERFACE_DEFINED__
+#define __IDiaSourceFile_INTERFACE_DEFINED__
+
+/* interface IDiaSourceFile */
+/* [unique][helpstring][local][uuid][object] */ 
+
+
+EXTERN_C const IID IID_IDiaSourceFile;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("A2EF5353-F5A8-4eb3-90D2-CB526ACB3CDD")
+    IDiaSourceFile : public IUnknown
+    {
+    public:
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_uniqueId( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_fileName( 
+            /* [retval][out] */ BSTR *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_checksumType( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_compilands( 
+            /* [retval][out] */ IDiaEnumSymbols **pRetVal) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE get_checksum( 
+            /* [in] */ DWORD cbData,
+            /* [out] */ DWORD *pcbData,
+            /* [size_is][out] */ BYTE *pbData) = 0;
+        
+    };
+    
+#else 	/* C style interface */
+
+    typedef struct IDiaSourceFileVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            IDiaSourceFile * This,
+            /* [in] */ REFIID riid,
+            /* [iid_is][out] */ 
+            __RPC__deref_out  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            IDiaSourceFile * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            IDiaSourceFile * This);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_uniqueId )( 
+            IDiaSourceFile * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_fileName )( 
+            IDiaSourceFile * This,
+            /* [retval][out] */ BSTR *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_checksumType )( 
+            IDiaSourceFile * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_compilands )( 
+            IDiaSourceFile * This,
+            /* [retval][out] */ IDiaEnumSymbols **pRetVal);
+        
+        HRESULT ( STDMETHODCALLTYPE *get_checksum )( 
+            IDiaSourceFile * This,
+            /* [in] */ DWORD cbData,
+            /* [out] */ DWORD *pcbData,
+            /* [size_is][out] */ BYTE *pbData);
+        
+        END_INTERFACE
+    } IDiaSourceFileVtbl;
+
+    interface IDiaSourceFile
+    {
+        CONST_VTBL struct IDiaSourceFileVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define IDiaSourceFile_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define IDiaSourceFile_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define IDiaSourceFile_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define IDiaSourceFile_get_uniqueId(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_uniqueId(This,pRetVal) ) 
+
+#define IDiaSourceFile_get_fileName(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_fileName(This,pRetVal) ) 
+
+#define IDiaSourceFile_get_checksumType(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_checksumType(This,pRetVal) ) 
+
+#define IDiaSourceFile_get_compilands(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_compilands(This,pRetVal) ) 
+
+#define IDiaSourceFile_get_checksum(This,cbData,pcbData,pbData)	\
+    ( (This)->lpVtbl -> get_checksum(This,cbData,pcbData,pbData) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __IDiaSourceFile_INTERFACE_DEFINED__ */
+
+
+#ifndef __IDiaLineNumber_INTERFACE_DEFINED__
+#define __IDiaLineNumber_INTERFACE_DEFINED__
+
+/* interface IDiaLineNumber */
+/* [unique][helpstring][local][uuid][object] */ 
+
+
+EXTERN_C const IID IID_IDiaLineNumber;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("B388EB14-BE4D-421d-A8A1-6CF7AB057086")
+    IDiaLineNumber : public IUnknown
+    {
+    public:
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_compiland( 
+            /* [retval][out] */ IDiaSymbol **pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_sourceFile( 
+            /* [retval][out] */ IDiaSourceFile **pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_lineNumber( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_lineNumberEnd( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_columnNumber( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_columnNumberEnd( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_addressSection( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_addressOffset( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_relativeVirtualAddress( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_virtualAddress( 
+            /* [retval][out] */ ULONGLONG *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_length( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_sourceFileId( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_statement( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_compilandId( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+    };
+    
+#else 	/* C style interface */
+
+    typedef struct IDiaLineNumberVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            IDiaLineNumber * This,
+            /* [in] */ REFIID riid,
+            /* [iid_is][out] */ 
+            __RPC__deref_out  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            IDiaLineNumber * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            IDiaLineNumber * This);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_compiland )( 
+            IDiaLineNumber * This,
+            /* [retval][out] */ IDiaSymbol **pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_sourceFile )( 
+            IDiaLineNumber * This,
+            /* [retval][out] */ IDiaSourceFile **pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lineNumber )( 
+            IDiaLineNumber * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lineNumberEnd )( 
+            IDiaLineNumber * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_columnNumber )( 
+            IDiaLineNumber * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_columnNumberEnd )( 
+            IDiaLineNumber * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_addressSection )( 
+            IDiaLineNumber * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_addressOffset )( 
+            IDiaLineNumber * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_relativeVirtualAddress )( 
+            IDiaLineNumber * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualAddress )( 
+            IDiaLineNumber * This,
+            /* [retval][out] */ ULONGLONG *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_length )( 
+            IDiaLineNumber * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_sourceFileId )( 
+            IDiaLineNumber * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_statement )( 
+            IDiaLineNumber * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_compilandId )( 
+            IDiaLineNumber * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        END_INTERFACE
+    } IDiaLineNumberVtbl;
+
+    interface IDiaLineNumber
+    {
+        CONST_VTBL struct IDiaLineNumberVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define IDiaLineNumber_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define IDiaLineNumber_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define IDiaLineNumber_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define IDiaLineNumber_get_compiland(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_compiland(This,pRetVal) ) 
+
+#define IDiaLineNumber_get_sourceFile(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_sourceFile(This,pRetVal) ) 
+
+#define IDiaLineNumber_get_lineNumber(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_lineNumber(This,pRetVal) ) 
+
+#define IDiaLineNumber_get_lineNumberEnd(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_lineNumberEnd(This,pRetVal) ) 
+
+#define IDiaLineNumber_get_columnNumber(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_columnNumber(This,pRetVal) ) 
+
+#define IDiaLineNumber_get_columnNumberEnd(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_columnNumberEnd(This,pRetVal) ) 
+
+#define IDiaLineNumber_get_addressSection(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_addressSection(This,pRetVal) ) 
+
+#define IDiaLineNumber_get_addressOffset(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_addressOffset(This,pRetVal) ) 
+
+#define IDiaLineNumber_get_relativeVirtualAddress(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_relativeVirtualAddress(This,pRetVal) ) 
+
+#define IDiaLineNumber_get_virtualAddress(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_virtualAddress(This,pRetVal) ) 
+
+#define IDiaLineNumber_get_length(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_length(This,pRetVal) ) 
+
+#define IDiaLineNumber_get_sourceFileId(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_sourceFileId(This,pRetVal) ) 
+
+#define IDiaLineNumber_get_statement(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_statement(This,pRetVal) ) 
+
+#define IDiaLineNumber_get_compilandId(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_compilandId(This,pRetVal) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __IDiaLineNumber_INTERFACE_DEFINED__ */
+
+
+#ifndef __IDiaSectionContrib_INTERFACE_DEFINED__
+#define __IDiaSectionContrib_INTERFACE_DEFINED__
+
+/* interface IDiaSectionContrib */
+/* [unique][helpstring][local][uuid][object] */ 
+
+
+EXTERN_C const IID IID_IDiaSectionContrib;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("0CF4B60E-35B1-4c6c-BDD8-854B9C8E3857")
+    IDiaSectionContrib : public IUnknown
+    {
+    public:
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_compiland( 
+            /* [retval][out] */ IDiaSymbol **pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_addressSection( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_addressOffset( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_relativeVirtualAddress( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_virtualAddress( 
+            /* [retval][out] */ ULONGLONG *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_length( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_notPaged( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_code( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_initializedData( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_uninitializedData( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_remove( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_comdat( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_discardable( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_notCached( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_share( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_execute( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_read( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_write( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_dataCrc( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_relocationsCrc( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_compilandId( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_code16bit( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+    };
+    
+#else 	/* C style interface */
+
+    typedef struct IDiaSectionContribVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            IDiaSectionContrib * This,
+            /* [in] */ REFIID riid,
+            /* [iid_is][out] */ 
+            __RPC__deref_out  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            IDiaSectionContrib * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            IDiaSectionContrib * This);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_compiland )( 
+            IDiaSectionContrib * This,
+            /* [retval][out] */ IDiaSymbol **pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_addressSection )( 
+            IDiaSectionContrib * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_addressOffset )( 
+            IDiaSectionContrib * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_relativeVirtualAddress )( 
+            IDiaSectionContrib * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualAddress )( 
+            IDiaSectionContrib * This,
+            /* [retval][out] */ ULONGLONG *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_length )( 
+            IDiaSectionContrib * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_notPaged )( 
+            IDiaSectionContrib * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_code )( 
+            IDiaSectionContrib * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_initializedData )( 
+            IDiaSectionContrib * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_uninitializedData )( 
+            IDiaSectionContrib * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_remove )( 
+            IDiaSectionContrib * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_comdat )( 
+            IDiaSectionContrib * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_discardable )( 
+            IDiaSectionContrib * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_notCached )( 
+            IDiaSectionContrib * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_share )( 
+            IDiaSectionContrib * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_execute )( 
+            IDiaSectionContrib * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_read )( 
+            IDiaSectionContrib * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_write )( 
+            IDiaSectionContrib * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_dataCrc )( 
+            IDiaSectionContrib * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_relocationsCrc )( 
+            IDiaSectionContrib * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_compilandId )( 
+            IDiaSectionContrib * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_code16bit )( 
+            IDiaSectionContrib * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        END_INTERFACE
+    } IDiaSectionContribVtbl;
+
+    interface IDiaSectionContrib
+    {
+        CONST_VTBL struct IDiaSectionContribVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define IDiaSectionContrib_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define IDiaSectionContrib_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define IDiaSectionContrib_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define IDiaSectionContrib_get_compiland(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_compiland(This,pRetVal) ) 
+
+#define IDiaSectionContrib_get_addressSection(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_addressSection(This,pRetVal) ) 
+
+#define IDiaSectionContrib_get_addressOffset(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_addressOffset(This,pRetVal) ) 
+
+#define IDiaSectionContrib_get_relativeVirtualAddress(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_relativeVirtualAddress(This,pRetVal) ) 
+
+#define IDiaSectionContrib_get_virtualAddress(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_virtualAddress(This,pRetVal) ) 
+
+#define IDiaSectionContrib_get_length(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_length(This,pRetVal) ) 
+
+#define IDiaSectionContrib_get_notPaged(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_notPaged(This,pRetVal) ) 
+
+#define IDiaSectionContrib_get_code(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_code(This,pRetVal) ) 
+
+#define IDiaSectionContrib_get_initializedData(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_initializedData(This,pRetVal) ) 
+
+#define IDiaSectionContrib_get_uninitializedData(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_uninitializedData(This,pRetVal) ) 
+
+#define IDiaSectionContrib_get_remove(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_remove(This,pRetVal) ) 
+
+#define IDiaSectionContrib_get_comdat(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_comdat(This,pRetVal) ) 
+
+#define IDiaSectionContrib_get_discardable(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_discardable(This,pRetVal) ) 
+
+#define IDiaSectionContrib_get_notCached(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_notCached(This,pRetVal) ) 
+
+#define IDiaSectionContrib_get_share(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_share(This,pRetVal) ) 
+
+#define IDiaSectionContrib_get_execute(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_execute(This,pRetVal) ) 
+
+#define IDiaSectionContrib_get_read(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_read(This,pRetVal) ) 
+
+#define IDiaSectionContrib_get_write(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_write(This,pRetVal) ) 
+
+#define IDiaSectionContrib_get_dataCrc(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_dataCrc(This,pRetVal) ) 
+
+#define IDiaSectionContrib_get_relocationsCrc(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_relocationsCrc(This,pRetVal) ) 
+
+#define IDiaSectionContrib_get_compilandId(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_compilandId(This,pRetVal) ) 
+
+#define IDiaSectionContrib_get_code16bit(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_code16bit(This,pRetVal) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __IDiaSectionContrib_INTERFACE_DEFINED__ */
+
+
+#ifndef __IDiaSegment_INTERFACE_DEFINED__
+#define __IDiaSegment_INTERFACE_DEFINED__
+
+/* interface IDiaSegment */
+/* [unique][helpstring][local][uuid][object] */ 
+
+
+EXTERN_C const IID IID_IDiaSegment;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("0775B784-C75B-4449-848B-B7BD3159545B")
+    IDiaSegment : public IUnknown
+    {
+    public:
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_frame( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_offset( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_length( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_read( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_write( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_execute( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_addressSection( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_relativeVirtualAddress( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_virtualAddress( 
+            /* [retval][out] */ ULONGLONG *pRetVal) = 0;
+        
+    };
+    
+#else 	/* C style interface */
+
+    typedef struct IDiaSegmentVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            IDiaSegment * This,
+            /* [in] */ REFIID riid,
+            /* [iid_is][out] */ 
+            __RPC__deref_out  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            IDiaSegment * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            IDiaSegment * This);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_frame )( 
+            IDiaSegment * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_offset )( 
+            IDiaSegment * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_length )( 
+            IDiaSegment * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_read )( 
+            IDiaSegment * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_write )( 
+            IDiaSegment * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_execute )( 
+            IDiaSegment * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_addressSection )( 
+            IDiaSegment * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_relativeVirtualAddress )( 
+            IDiaSegment * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualAddress )( 
+            IDiaSegment * This,
+            /* [retval][out] */ ULONGLONG *pRetVal);
+        
+        END_INTERFACE
+    } IDiaSegmentVtbl;
+
+    interface IDiaSegment
+    {
+        CONST_VTBL struct IDiaSegmentVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define IDiaSegment_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define IDiaSegment_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define IDiaSegment_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define IDiaSegment_get_frame(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_frame(This,pRetVal) ) 
+
+#define IDiaSegment_get_offset(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_offset(This,pRetVal) ) 
+
+#define IDiaSegment_get_length(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_length(This,pRetVal) ) 
+
+#define IDiaSegment_get_read(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_read(This,pRetVal) ) 
+
+#define IDiaSegment_get_write(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_write(This,pRetVal) ) 
+
+#define IDiaSegment_get_execute(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_execute(This,pRetVal) ) 
+
+#define IDiaSegment_get_addressSection(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_addressSection(This,pRetVal) ) 
+
+#define IDiaSegment_get_relativeVirtualAddress(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_relativeVirtualAddress(This,pRetVal) ) 
+
+#define IDiaSegment_get_virtualAddress(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_virtualAddress(This,pRetVal) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __IDiaSegment_INTERFACE_DEFINED__ */
+
+
+#ifndef __IDiaInjectedSource_INTERFACE_DEFINED__
+#define __IDiaInjectedSource_INTERFACE_DEFINED__
+
+/* interface IDiaInjectedSource */
+/* [unique][helpstring][local][uuid][object] */ 
+
+
+EXTERN_C const IID IID_IDiaInjectedSource;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("AE605CDC-8105-4a23-B710-3259F1E26112")
+    IDiaInjectedSource : public IUnknown
+    {
+    public:
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_crc( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_length( 
+            /* [retval][out] */ ULONGLONG *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_filename( 
+            /* [retval][out] */ BSTR *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_objectFilename( 
+            /* [retval][out] */ BSTR *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_virtualFilename( 
+            /* [retval][out] */ BSTR *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_sourceCompression( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE get_source( 
+            /* [in] */ DWORD cbData,
+            /* [out] */ DWORD *pcbData,
+            /* [size_is][out] */ BYTE *pbData) = 0;
+        
+    };
+    
+#else 	/* C style interface */
+
+    typedef struct IDiaInjectedSourceVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            IDiaInjectedSource * This,
+            /* [in] */ REFIID riid,
+            /* [iid_is][out] */ 
+            __RPC__deref_out  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            IDiaInjectedSource * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            IDiaInjectedSource * This);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_crc )( 
+            IDiaInjectedSource * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_length )( 
+            IDiaInjectedSource * This,
+            /* [retval][out] */ ULONGLONG *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_filename )( 
+            IDiaInjectedSource * This,
+            /* [retval][out] */ BSTR *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_objectFilename )( 
+            IDiaInjectedSource * This,
+            /* [retval][out] */ BSTR *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualFilename )( 
+            IDiaInjectedSource * This,
+            /* [retval][out] */ BSTR *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_sourceCompression )( 
+            IDiaInjectedSource * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        HRESULT ( STDMETHODCALLTYPE *get_source )( 
+            IDiaInjectedSource * This,
+            /* [in] */ DWORD cbData,
+            /* [out] */ DWORD *pcbData,
+            /* [size_is][out] */ BYTE *pbData);
+        
+        END_INTERFACE
+    } IDiaInjectedSourceVtbl;
+
+    interface IDiaInjectedSource
+    {
+        CONST_VTBL struct IDiaInjectedSourceVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define IDiaInjectedSource_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define IDiaInjectedSource_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define IDiaInjectedSource_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define IDiaInjectedSource_get_crc(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_crc(This,pRetVal) ) 
+
+#define IDiaInjectedSource_get_length(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_length(This,pRetVal) ) 
+
+#define IDiaInjectedSource_get_filename(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_filename(This,pRetVal) ) 
+
+#define IDiaInjectedSource_get_objectFilename(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_objectFilename(This,pRetVal) ) 
+
+#define IDiaInjectedSource_get_virtualFilename(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_virtualFilename(This,pRetVal) ) 
+
+#define IDiaInjectedSource_get_sourceCompression(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_sourceCompression(This,pRetVal) ) 
+
+#define IDiaInjectedSource_get_source(This,cbData,pcbData,pbData)	\
+    ( (This)->lpVtbl -> get_source(This,cbData,pcbData,pbData) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __IDiaInjectedSource_INTERFACE_DEFINED__ */
+
+
+/* interface __MIDL_itf_dia2_0000_0023 */
+/* [local] */ 
+
+
+enum __MIDL___MIDL_itf_dia2_0000_0023_0001
+    {	E_DIA_INPROLOG	= ( HRESULT  )(( ( ( ( unsigned long  )1 << 31 )  | ( ( unsigned long  )( LONG  )0x6d << 16 )  )  | ( unsigned long  )100 ) ),
+	E_DIA_SYNTAX	= ( E_DIA_INPROLOG + 1 ) ,
+	E_DIA_FRAME_ACCESS	= ( E_DIA_SYNTAX + 1 ) ,
+	E_DIA_VALUE	= ( E_DIA_FRAME_ACCESS + 1 ) 
+    } ;
+
+
+extern RPC_IF_HANDLE __MIDL_itf_dia2_0000_0023_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_dia2_0000_0023_v0_0_s_ifspec;
+
+#ifndef __IDiaStackWalkFrame_INTERFACE_DEFINED__
+#define __IDiaStackWalkFrame_INTERFACE_DEFINED__
+
+/* interface IDiaStackWalkFrame */
+/* [unique][helpstring][local][uuid][object] */ 
+
+
+EXTERN_C const IID IID_IDiaStackWalkFrame;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("97F0F1A6-E04E-4ea4-B4F9-B0D0E8D90F5D")
+    IDiaStackWalkFrame : public IUnknown
+    {
+    public:
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_registerValue( 
+            /* [in] */ DWORD index,
+            /* [retval][out] */ ULONGLONG *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propput] */ HRESULT STDMETHODCALLTYPE put_registerValue( 
+            /* [in] */ DWORD index,
+            /* [in] */ ULONGLONG NewVal) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE readMemory( 
+            /* [in] */ ULONGLONG va,
+            /* [in] */ DWORD cbData,
+            /* [out] */ DWORD *pcbData,
+            /* [size_is][out] */ BYTE *pbData) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE searchForReturnAddress( 
+            /* [in] */ IDiaFrameData *frame,
+            /* [out] */ ULONGLONG *returnAddress) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE searchForReturnAddressStart( 
+            /* [in] */ IDiaFrameData *frame,
+            /* [in] */ ULONGLONG startAddress,
+            /* [out] */ ULONGLONG *returnAddress) = 0;
+        
+    };
+    
+#else 	/* C style interface */
+
+    typedef struct IDiaStackWalkFrameVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            IDiaStackWalkFrame * This,
+            /* [in] */ REFIID riid,
+            /* [iid_is][out] */ 
+            __RPC__deref_out  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            IDiaStackWalkFrame * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            IDiaStackWalkFrame * This);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_registerValue )( 
+            IDiaStackWalkFrame * This,
+            /* [in] */ DWORD index,
+            /* [retval][out] */ ULONGLONG *pRetVal);
+        
+        /* [id][helpstring][propput] */ HRESULT ( STDMETHODCALLTYPE *put_registerValue )( 
+            IDiaStackWalkFrame * This,
+            /* [in] */ DWORD index,
+            /* [in] */ ULONGLONG NewVal);
+        
+        HRESULT ( STDMETHODCALLTYPE *readMemory )( 
+            IDiaStackWalkFrame * This,
+            /* [in] */ ULONGLONG va,
+            /* [in] */ DWORD cbData,
+            /* [out] */ DWORD *pcbData,
+            /* [size_is][out] */ BYTE *pbData);
+        
+        HRESULT ( STDMETHODCALLTYPE *searchForReturnAddress )( 
+            IDiaStackWalkFrame * This,
+            /* [in] */ IDiaFrameData *frame,
+            /* [out] */ ULONGLONG *returnAddress);
+        
+        HRESULT ( STDMETHODCALLTYPE *searchForReturnAddressStart )( 
+            IDiaStackWalkFrame * This,
+            /* [in] */ IDiaFrameData *frame,
+            /* [in] */ ULONGLONG startAddress,
+            /* [out] */ ULONGLONG *returnAddress);
+        
+        END_INTERFACE
+    } IDiaStackWalkFrameVtbl;
+
+    interface IDiaStackWalkFrame
+    {
+        CONST_VTBL struct IDiaStackWalkFrameVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define IDiaStackWalkFrame_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define IDiaStackWalkFrame_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define IDiaStackWalkFrame_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define IDiaStackWalkFrame_get_registerValue(This,index,pRetVal)	\
+    ( (This)->lpVtbl -> get_registerValue(This,index,pRetVal) ) 
+
+#define IDiaStackWalkFrame_put_registerValue(This,index,NewVal)	\
+    ( (This)->lpVtbl -> put_registerValue(This,index,NewVal) ) 
+
+#define IDiaStackWalkFrame_readMemory(This,va,cbData,pcbData,pbData)	\
+    ( (This)->lpVtbl -> readMemory(This,va,cbData,pcbData,pbData) ) 
+
+#define IDiaStackWalkFrame_searchForReturnAddress(This,frame,returnAddress)	\
+    ( (This)->lpVtbl -> searchForReturnAddress(This,frame,returnAddress) ) 
+
+#define IDiaStackWalkFrame_searchForReturnAddressStart(This,frame,startAddress,returnAddress)	\
+    ( (This)->lpVtbl -> searchForReturnAddressStart(This,frame,startAddress,returnAddress) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __IDiaStackWalkFrame_INTERFACE_DEFINED__ */
+
+
+#ifndef __IDiaFrameData_INTERFACE_DEFINED__
+#define __IDiaFrameData_INTERFACE_DEFINED__
+
+/* interface IDiaFrameData */
+/* [unique][helpstring][local][uuid][object] */ 
+
+
+EXTERN_C const IID IID_IDiaFrameData;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("A39184B7-6A36-42de-8EEC-7DF9F3F59F33")
+    IDiaFrameData : public IUnknown
+    {
+    public:
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_addressSection( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_addressOffset( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_relativeVirtualAddress( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_virtualAddress( 
+            /* [retval][out] */ ULONGLONG *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_lengthBlock( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_lengthLocals( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_lengthParams( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_maxStack( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_lengthProlog( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_lengthSavedRegisters( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_program( 
+            /* [retval][out] */ BSTR *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_systemExceptionHandling( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_cplusplusExceptionHandling( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_functionStart( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_allocatesBasePointer( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_type( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_functionParent( 
+            /* [retval][out] */ IDiaFrameData **pRetVal) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE execute( 
+            IDiaStackWalkFrame *frame) = 0;
+        
+    };
+    
+#else 	/* C style interface */
+
+    typedef struct IDiaFrameDataVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            IDiaFrameData * This,
+            /* [in] */ REFIID riid,
+            /* [iid_is][out] */ 
+            __RPC__deref_out  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            IDiaFrameData * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            IDiaFrameData * This);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_addressSection )( 
+            IDiaFrameData * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_addressOffset )( 
+            IDiaFrameData * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_relativeVirtualAddress )( 
+            IDiaFrameData * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualAddress )( 
+            IDiaFrameData * This,
+            /* [retval][out] */ ULONGLONG *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lengthBlock )( 
+            IDiaFrameData * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lengthLocals )( 
+            IDiaFrameData * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lengthParams )( 
+            IDiaFrameData * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_maxStack )( 
+            IDiaFrameData * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lengthProlog )( 
+            IDiaFrameData * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lengthSavedRegisters )( 
+            IDiaFrameData * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_program )( 
+            IDiaFrameData * This,
+            /* [retval][out] */ BSTR *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_systemExceptionHandling )( 
+            IDiaFrameData * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_cplusplusExceptionHandling )( 
+            IDiaFrameData * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_functionStart )( 
+            IDiaFrameData * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_allocatesBasePointer )( 
+            IDiaFrameData * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_type )( 
+            IDiaFrameData * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_functionParent )( 
+            IDiaFrameData * This,
+            /* [retval][out] */ IDiaFrameData **pRetVal);
+        
+        HRESULT ( STDMETHODCALLTYPE *execute )( 
+            IDiaFrameData * This,
+            IDiaStackWalkFrame *frame);
+        
+        END_INTERFACE
+    } IDiaFrameDataVtbl;
+
+    interface IDiaFrameData
+    {
+        CONST_VTBL struct IDiaFrameDataVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define IDiaFrameData_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define IDiaFrameData_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define IDiaFrameData_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define IDiaFrameData_get_addressSection(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_addressSection(This,pRetVal) ) 
+
+#define IDiaFrameData_get_addressOffset(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_addressOffset(This,pRetVal) ) 
+
+#define IDiaFrameData_get_relativeVirtualAddress(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_relativeVirtualAddress(This,pRetVal) ) 
+
+#define IDiaFrameData_get_virtualAddress(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_virtualAddress(This,pRetVal) ) 
+
+#define IDiaFrameData_get_lengthBlock(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_lengthBlock(This,pRetVal) ) 
+
+#define IDiaFrameData_get_lengthLocals(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_lengthLocals(This,pRetVal) ) 
+
+#define IDiaFrameData_get_lengthParams(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_lengthParams(This,pRetVal) ) 
+
+#define IDiaFrameData_get_maxStack(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_maxStack(This,pRetVal) ) 
+
+#define IDiaFrameData_get_lengthProlog(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_lengthProlog(This,pRetVal) ) 
+
+#define IDiaFrameData_get_lengthSavedRegisters(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_lengthSavedRegisters(This,pRetVal) ) 
+
+#define IDiaFrameData_get_program(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_program(This,pRetVal) ) 
+
+#define IDiaFrameData_get_systemExceptionHandling(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_systemExceptionHandling(This,pRetVal) ) 
+
+#define IDiaFrameData_get_cplusplusExceptionHandling(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_cplusplusExceptionHandling(This,pRetVal) ) 
+
+#define IDiaFrameData_get_functionStart(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_functionStart(This,pRetVal) ) 
+
+#define IDiaFrameData_get_allocatesBasePointer(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_allocatesBasePointer(This,pRetVal) ) 
+
+#define IDiaFrameData_get_type(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_type(This,pRetVal) ) 
+
+#define IDiaFrameData_get_functionParent(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_functionParent(This,pRetVal) ) 
+
+#define IDiaFrameData_execute(This,frame)	\
+    ( (This)->lpVtbl -> execute(This,frame) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __IDiaFrameData_INTERFACE_DEFINED__ */
+
+
+#ifndef __IDiaImageData_INTERFACE_DEFINED__
+#define __IDiaImageData_INTERFACE_DEFINED__
+
+/* interface IDiaImageData */
+/* [unique][helpstring][local][uuid][object] */ 
+
+
+EXTERN_C const IID IID_IDiaImageData;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("C8E40ED2-A1D9-4221-8692-3CE661184B44")
+    IDiaImageData : public IUnknown
+    {
+    public:
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_relativeVirtualAddress( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_virtualAddress( 
+            /* [retval][out] */ ULONGLONG *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_imageBase( 
+            /* [retval][out] */ ULONGLONG *pRetVal) = 0;
+        
+    };
+    
+#else 	/* C style interface */
+
+    typedef struct IDiaImageDataVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            IDiaImageData * This,
+            /* [in] */ REFIID riid,
+            /* [iid_is][out] */ 
+            __RPC__deref_out  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            IDiaImageData * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            IDiaImageData * This);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_relativeVirtualAddress )( 
+            IDiaImageData * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualAddress )( 
+            IDiaImageData * This,
+            /* [retval][out] */ ULONGLONG *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_imageBase )( 
+            IDiaImageData * This,
+            /* [retval][out] */ ULONGLONG *pRetVal);
+        
+        END_INTERFACE
+    } IDiaImageDataVtbl;
+
+    interface IDiaImageData
+    {
+        CONST_VTBL struct IDiaImageDataVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define IDiaImageData_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define IDiaImageData_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define IDiaImageData_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define IDiaImageData_get_relativeVirtualAddress(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_relativeVirtualAddress(This,pRetVal) ) 
+
+#define IDiaImageData_get_virtualAddress(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_virtualAddress(This,pRetVal) ) 
+
+#define IDiaImageData_get_imageBase(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_imageBase(This,pRetVal) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __IDiaImageData_INTERFACE_DEFINED__ */
+
+
+#ifndef __IDiaTable_INTERFACE_DEFINED__
+#define __IDiaTable_INTERFACE_DEFINED__
+
+/* interface IDiaTable */
+/* [unique][helpstring][local][uuid][object] */ 
+
+
+EXTERN_C const IID IID_IDiaTable;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("4A59FB77-ABAC-469b-A30B-9ECC85BFEF14")
+    IDiaTable : public IEnumUnknown
+    {
+    public:
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get__NewEnum( 
+            /* [retval][out] */ IUnknown **pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_name( 
+            /* [retval][out] */ BSTR *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_Count( 
+            /* [retval][out] */ LONG *pRetVal) = 0;
+        
+        virtual /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE Item( 
+            /* [in] */ DWORD index,
+            /* [retval][out] */ IUnknown **element) = 0;
+        
+    };
+    
+#else 	/* C style interface */
+
+    typedef struct IDiaTableVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            IDiaTable * This,
+            /* [in] */ REFIID riid,
+            /* [iid_is][out] */ 
+            __RPC__deref_out  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            IDiaTable * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            IDiaTable * This);
+        
+        /* [local] */ HRESULT ( STDMETHODCALLTYPE *Next )( 
+            IDiaTable * This,
+            /* [in] */ 
+            __in  ULONG celt,
+            /* [out] */ 
+            __out_ecount_part(celt,*pceltFetched)  IUnknown **rgelt,
+            /* [out] */ 
+            __out_opt  ULONG *pceltFetched);
+        
+        HRESULT ( STDMETHODCALLTYPE *Skip )( 
+            IDiaTable * This,
+            /* [in] */ ULONG celt);
+        
+        HRESULT ( STDMETHODCALLTYPE *Reset )( 
+            IDiaTable * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *Clone )( 
+            IDiaTable * This,
+            /* [out] */ IEnumUnknown **ppenum);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get__NewEnum )( 
+            IDiaTable * This,
+            /* [retval][out] */ IUnknown **pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_name )( 
+            IDiaTable * This,
+            /* [retval][out] */ BSTR *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Count )( 
+            IDiaTable * This,
+            /* [retval][out] */ LONG *pRetVal);
+        
+        /* [helpstring][id] */ HRESULT ( STDMETHODCALLTYPE *Item )( 
+            IDiaTable * This,
+            /* [in] */ DWORD index,
+            /* [retval][out] */ IUnknown **element);
+        
+        END_INTERFACE
+    } IDiaTableVtbl;
+
+    interface IDiaTable
+    {
+        CONST_VTBL struct IDiaTableVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define IDiaTable_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define IDiaTable_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define IDiaTable_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define IDiaTable_Next(This,celt,rgelt,pceltFetched)	\
+    ( (This)->lpVtbl -> Next(This,celt,rgelt,pceltFetched) ) 
+
+#define IDiaTable_Skip(This,celt)	\
+    ( (This)->lpVtbl -> Skip(This,celt) ) 
+
+#define IDiaTable_Reset(This)	\
+    ( (This)->lpVtbl -> Reset(This) ) 
+
+#define IDiaTable_Clone(This,ppenum)	\
+    ( (This)->lpVtbl -> Clone(This,ppenum) ) 
+
+
+#define IDiaTable_get__NewEnum(This,pRetVal)	\
+    ( (This)->lpVtbl -> get__NewEnum(This,pRetVal) ) 
+
+#define IDiaTable_get_name(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_name(This,pRetVal) ) 
+
+#define IDiaTable_get_Count(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_Count(This,pRetVal) ) 
+
+#define IDiaTable_Item(This,index,element)	\
+    ( (This)->lpVtbl -> Item(This,index,element) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __IDiaTable_INTERFACE_DEFINED__ */
+
+
+#ifndef __IDiaEnumTables_INTERFACE_DEFINED__
+#define __IDiaEnumTables_INTERFACE_DEFINED__
+
+/* interface IDiaEnumTables */
+/* [unique][helpstring][local][uuid][object] */ 
+
+
+EXTERN_C const IID IID_IDiaEnumTables;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("C65C2B0A-1150-4d7a-AFCC-E05BF3DEE81E")
+    IDiaEnumTables : public IUnknown
+    {
+    public:
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get__NewEnum( 
+            /* [retval][out] */ IUnknown **pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_Count( 
+            /* [retval][out] */ LONG *pRetVal) = 0;
+        
+        virtual /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE Item( 
+            /* [in] */ VARIANT index,
+            /* [retval][out] */ IDiaTable **table) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Next( 
+            ULONG celt,
+            IDiaTable **rgelt,
+            ULONG *pceltFetched) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Skip( 
+            /* [in] */ ULONG celt) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Reset( void) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Clone( 
+            /* [out] */ IDiaEnumTables **ppenum) = 0;
+        
+    };
+    
+#else 	/* C style interface */
+
+    typedef struct IDiaEnumTablesVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            IDiaEnumTables * This,
+            /* [in] */ REFIID riid,
+            /* [iid_is][out] */ 
+            __RPC__deref_out  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            IDiaEnumTables * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            IDiaEnumTables * This);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get__NewEnum )( 
+            IDiaEnumTables * This,
+            /* [retval][out] */ IUnknown **pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Count )( 
+            IDiaEnumTables * This,
+            /* [retval][out] */ LONG *pRetVal);
+        
+        /* [helpstring][id] */ HRESULT ( STDMETHODCALLTYPE *Item )( 
+            IDiaEnumTables * This,
+            /* [in] */ VARIANT index,
+            /* [retval][out] */ IDiaTable **table);
+        
+        HRESULT ( STDMETHODCALLTYPE *Next )( 
+            IDiaEnumTables * This,
+            ULONG celt,
+            IDiaTable **rgelt,
+            ULONG *pceltFetched);
+        
+        HRESULT ( STDMETHODCALLTYPE *Skip )( 
+            IDiaEnumTables * This,
+            /* [in] */ ULONG celt);
+        
+        HRESULT ( STDMETHODCALLTYPE *Reset )( 
+            IDiaEnumTables * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *Clone )( 
+            IDiaEnumTables * This,
+            /* [out] */ IDiaEnumTables **ppenum);
+        
+        END_INTERFACE
+    } IDiaEnumTablesVtbl;
+
+    interface IDiaEnumTables
+    {
+        CONST_VTBL struct IDiaEnumTablesVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define IDiaEnumTables_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define IDiaEnumTables_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define IDiaEnumTables_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define IDiaEnumTables_get__NewEnum(This,pRetVal)	\
+    ( (This)->lpVtbl -> get__NewEnum(This,pRetVal) ) 
+
+#define IDiaEnumTables_get_Count(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_Count(This,pRetVal) ) 
+
+#define IDiaEnumTables_Item(This,index,table)	\
+    ( (This)->lpVtbl -> Item(This,index,table) ) 
+
+#define IDiaEnumTables_Next(This,celt,rgelt,pceltFetched)	\
+    ( (This)->lpVtbl -> Next(This,celt,rgelt,pceltFetched) ) 
+
+#define IDiaEnumTables_Skip(This,celt)	\
+    ( (This)->lpVtbl -> Skip(This,celt) ) 
+
+#define IDiaEnumTables_Reset(This)	\
+    ( (This)->lpVtbl -> Reset(This) ) 
+
+#define IDiaEnumTables_Clone(This,ppenum)	\
+    ( (This)->lpVtbl -> Clone(This,ppenum) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __IDiaEnumTables_INTERFACE_DEFINED__ */
+
+
+
+#ifndef __Dia2Lib_LIBRARY_DEFINED__
+#define __Dia2Lib_LIBRARY_DEFINED__
+
+/* library Dia2Lib */
+/* [helpstring][version][uuid] */ 
+
+
+EXTERN_C const IID LIBID_Dia2Lib;
+
+EXTERN_C const CLSID CLSID_DiaSource;
+
+#ifdef __cplusplus
+
+class DECLSPEC_UUID("B86AE24D-BF2F-4ac9-B5A2-34B14E4CE11D")
+DiaSource;
+#endif
+
+EXTERN_C const CLSID CLSID_DiaSourceAlt;
+
+#ifdef __cplusplus
+
+class DECLSPEC_UUID("E3E90253-8E14-49a5-AA30-2E7B798AB839")
+DiaSourceAlt;
+#endif
+
+EXTERN_C const CLSID CLSID_DiaStackWalker;
+
+#ifdef __cplusplus
+
+class DECLSPEC_UUID("EBA05B6F-BD22-490e-A7B0-32D821C9046C")
+DiaStackWalker;
+#endif
+#endif /* __Dia2Lib_LIBRARY_DEFINED__ */
+
+/* interface __MIDL_itf_dia2_0000_0028 */
+/* [local] */ 
+
+#define	DiaTable_Symbols	( L"Symbols" )
+
+#define	DiaTable_Sections	( L"Sections" )
+
+#define	DiaTable_SrcFiles	( L"SourceFiles" )
+
+#define	DiaTable_LineNums	( L"LineNumbers" )
+
+#define	DiaTable_SegMap	( L"SegmentMap" )
+
+#define	DiaTable_Dbg	( L"Dbg" )
+
+#define	DiaTable_InjSrc	( L"InjectedSource" )
+
+#define	DiaTable_FrameData	( L"FrameData" )
+
+
+
+extern RPC_IF_HANDLE __MIDL_itf_dia2_0000_0028_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_dia2_0000_0028_v0_0_s_ifspec;
+
+#ifndef __IDiaPropertyStorage_INTERFACE_DEFINED__
+#define __IDiaPropertyStorage_INTERFACE_DEFINED__
+
+/* interface IDiaPropertyStorage */
+/* [unique][helpstring][local][uuid][object] */ 
+
+
+EXTERN_C const IID IID_IDiaPropertyStorage;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("9d416f9c-e184-45b2-a4f0-ce517f719e9b")
+    IDiaPropertyStorage : public IUnknown
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE ReadMultiple( 
+            /* [in] */ ULONG cpspec,
+            /* [size_is][in] */ const PROPSPEC *rgpspec,
+            /* [size_is][out] */ PROPVARIANT *rgvar) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE ReadPropertyNames( 
+            /* [in] */ ULONG cpropid,
+            /* [size_is][in] */ const PROPID *rgpropid,
+            /* [size_is][out][in] */ BSTR *rglpwstrName) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Enum( 
+            /* [out] */ IEnumSTATPROPSTG **ppenum) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE ReadDWORD( 
+            /* [in] */ PROPID id,
+            /* [out] */ DWORD *pValue) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE ReadLONG( 
+            /* [in] */ PROPID id,
+            /* [out] */ LONG *pValue) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE ReadBOOL( 
+            /* [in] */ PROPID id,
+            /* [out] */ BOOL *pValue) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE ReadULONGLONG( 
+            /* [in] */ PROPID id,
+            /* [out] */ ULONGLONG *pValue) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE ReadBSTR( 
+            /* [in] */ PROPID id,
+            /* [out] */ BSTR *pValue) = 0;
+        
+    };
+    
+#else 	/* C style interface */
+
+    typedef struct IDiaPropertyStorageVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            IDiaPropertyStorage * This,
+            /* [in] */ REFIID riid,
+            /* [iid_is][out] */ 
+            __RPC__deref_out  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            IDiaPropertyStorage * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            IDiaPropertyStorage * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *ReadMultiple )( 
+            IDiaPropertyStorage * This,
+            /* [in] */ ULONG cpspec,
+            /* [size_is][in] */ const PROPSPEC *rgpspec,
+            /* [size_is][out] */ PROPVARIANT *rgvar);
+        
+        HRESULT ( STDMETHODCALLTYPE *ReadPropertyNames )( 
+            IDiaPropertyStorage * This,
+            /* [in] */ ULONG cpropid,
+            /* [size_is][in] */ const PROPID *rgpropid,
+            /* [size_is][out][in] */ BSTR *rglpwstrName);
+        
+        HRESULT ( STDMETHODCALLTYPE *Enum )( 
+            IDiaPropertyStorage * This,
+            /* [out] */ IEnumSTATPROPSTG **ppenum);
+        
+        HRESULT ( STDMETHODCALLTYPE *ReadDWORD )( 
+            IDiaPropertyStorage * This,
+            /* [in] */ PROPID id,
+            /* [out] */ DWORD *pValue);
+        
+        HRESULT ( STDMETHODCALLTYPE *ReadLONG )( 
+            IDiaPropertyStorage * This,
+            /* [in] */ PROPID id,
+            /* [out] */ LONG *pValue);
+        
+        HRESULT ( STDMETHODCALLTYPE *ReadBOOL )( 
+            IDiaPropertyStorage * This,
+            /* [in] */ PROPID id,
+            /* [out] */ BOOL *pValue);
+        
+        HRESULT ( STDMETHODCALLTYPE *ReadULONGLONG )( 
+            IDiaPropertyStorage * This,
+            /* [in] */ PROPID id,
+            /* [out] */ ULONGLONG *pValue);
+        
+        HRESULT ( STDMETHODCALLTYPE *ReadBSTR )( 
+            IDiaPropertyStorage * This,
+            /* [in] */ PROPID id,
+            /* [out] */ BSTR *pValue);
+        
+        END_INTERFACE
+    } IDiaPropertyStorageVtbl;
+
+    interface IDiaPropertyStorage
+    {
+        CONST_VTBL struct IDiaPropertyStorageVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define IDiaPropertyStorage_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define IDiaPropertyStorage_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define IDiaPropertyStorage_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define IDiaPropertyStorage_ReadMultiple(This,cpspec,rgpspec,rgvar)	\
+    ( (This)->lpVtbl -> ReadMultiple(This,cpspec,rgpspec,rgvar) ) 
+
+#define IDiaPropertyStorage_ReadPropertyNames(This,cpropid,rgpropid,rglpwstrName)	\
+    ( (This)->lpVtbl -> ReadPropertyNames(This,cpropid,rgpropid,rglpwstrName) ) 
+
+#define IDiaPropertyStorage_Enum(This,ppenum)	\
+    ( (This)->lpVtbl -> Enum(This,ppenum) ) 
+
+#define IDiaPropertyStorage_ReadDWORD(This,id,pValue)	\
+    ( (This)->lpVtbl -> ReadDWORD(This,id,pValue) ) 
+
+#define IDiaPropertyStorage_ReadLONG(This,id,pValue)	\
+    ( (This)->lpVtbl -> ReadLONG(This,id,pValue) ) 
+
+#define IDiaPropertyStorage_ReadBOOL(This,id,pValue)	\
+    ( (This)->lpVtbl -> ReadBOOL(This,id,pValue) ) 
+
+#define IDiaPropertyStorage_ReadULONGLONG(This,id,pValue)	\
+    ( (This)->lpVtbl -> ReadULONGLONG(This,id,pValue) ) 
+
+#define IDiaPropertyStorage_ReadBSTR(This,id,pValue)	\
+    ( (This)->lpVtbl -> ReadBSTR(This,id,pValue) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __IDiaPropertyStorage_INTERFACE_DEFINED__ */
+
+
+#ifndef __IDiaStackFrame_INTERFACE_DEFINED__
+#define __IDiaStackFrame_INTERFACE_DEFINED__
+
+/* interface IDiaStackFrame */
+/* [unique][helpstring][local][uuid][object] */ 
+
+
+EXTERN_C const IID IID_IDiaStackFrame;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("5edbc96d-cdd6-4792-afbe-cc89007d9610")
+    IDiaStackFrame : public IUnknown
+    {
+    public:
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_type( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_base( 
+            /* [retval][out] */ ULONGLONG *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_size( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_returnAddress( 
+            /* [retval][out] */ ULONGLONG *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_localsBase( 
+            /* [retval][out] */ ULONGLONG *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_lengthLocals( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_lengthParams( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_lengthProlog( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_lengthSavedRegisters( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_systemExceptionHandling( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_cplusplusExceptionHandling( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_functionStart( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_allocatesBasePointer( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_maxStack( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_registerValue( 
+            /* [in] */ DWORD index,
+            /* [retval][out] */ ULONGLONG *pRetVal) = 0;
+        
+    };
+    
+#else 	/* C style interface */
+
+    typedef struct IDiaStackFrameVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            IDiaStackFrame * This,
+            /* [in] */ REFIID riid,
+            /* [iid_is][out] */ 
+            __RPC__deref_out  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            IDiaStackFrame * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            IDiaStackFrame * This);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_type )( 
+            IDiaStackFrame * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_base )( 
+            IDiaStackFrame * This,
+            /* [retval][out] */ ULONGLONG *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_size )( 
+            IDiaStackFrame * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_returnAddress )( 
+            IDiaStackFrame * This,
+            /* [retval][out] */ ULONGLONG *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_localsBase )( 
+            IDiaStackFrame * This,
+            /* [retval][out] */ ULONGLONG *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lengthLocals )( 
+            IDiaStackFrame * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lengthParams )( 
+            IDiaStackFrame * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lengthProlog )( 
+            IDiaStackFrame * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lengthSavedRegisters )( 
+            IDiaStackFrame * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_systemExceptionHandling )( 
+            IDiaStackFrame * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_cplusplusExceptionHandling )( 
+            IDiaStackFrame * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_functionStart )( 
+            IDiaStackFrame * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_allocatesBasePointer )( 
+            IDiaStackFrame * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_maxStack )( 
+            IDiaStackFrame * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_registerValue )( 
+            IDiaStackFrame * This,
+            /* [in] */ DWORD index,
+            /* [retval][out] */ ULONGLONG *pRetVal);
+        
+        END_INTERFACE
+    } IDiaStackFrameVtbl;
+
+    interface IDiaStackFrame
+    {
+        CONST_VTBL struct IDiaStackFrameVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define IDiaStackFrame_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define IDiaStackFrame_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define IDiaStackFrame_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define IDiaStackFrame_get_type(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_type(This,pRetVal) ) 
+
+#define IDiaStackFrame_get_base(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_base(This,pRetVal) ) 
+
+#define IDiaStackFrame_get_size(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_size(This,pRetVal) ) 
+
+#define IDiaStackFrame_get_returnAddress(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_returnAddress(This,pRetVal) ) 
+
+#define IDiaStackFrame_get_localsBase(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_localsBase(This,pRetVal) ) 
+
+#define IDiaStackFrame_get_lengthLocals(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_lengthLocals(This,pRetVal) ) 
+
+#define IDiaStackFrame_get_lengthParams(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_lengthParams(This,pRetVal) ) 
+
+#define IDiaStackFrame_get_lengthProlog(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_lengthProlog(This,pRetVal) ) 
+
+#define IDiaStackFrame_get_lengthSavedRegisters(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_lengthSavedRegisters(This,pRetVal) ) 
+
+#define IDiaStackFrame_get_systemExceptionHandling(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_systemExceptionHandling(This,pRetVal) ) 
+
+#define IDiaStackFrame_get_cplusplusExceptionHandling(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_cplusplusExceptionHandling(This,pRetVal) ) 
+
+#define IDiaStackFrame_get_functionStart(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_functionStart(This,pRetVal) ) 
+
+#define IDiaStackFrame_get_allocatesBasePointer(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_allocatesBasePointer(This,pRetVal) ) 
+
+#define IDiaStackFrame_get_maxStack(This,pRetVal)	\
+    ( (This)->lpVtbl -> get_maxStack(This,pRetVal) ) 
+
+#define IDiaStackFrame_get_registerValue(This,index,pRetVal)	\
+    ( (This)->lpVtbl -> get_registerValue(This,index,pRetVal) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __IDiaStackFrame_INTERFACE_DEFINED__ */
+
+
+#ifndef __IDiaEnumStackFrames_INTERFACE_DEFINED__
+#define __IDiaEnumStackFrames_INTERFACE_DEFINED__
+
+/* interface IDiaEnumStackFrames */
+/* [unique][helpstring][local][uuid][object] */ 
+
+
+EXTERN_C const IID IID_IDiaEnumStackFrames;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("ec9d461d-ce74-4711-a020-7d8f9a1dd255")
+    IDiaEnumStackFrames : public IUnknown
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE Next( 
+            /* [in] */ ULONG celt,
+            /* [out] */ IDiaStackFrame **rgelt,
+            /* [out] */ ULONG *pceltFetched) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Reset( void) = 0;
+        
+    };
+    
+#else 	/* C style interface */
+
+    typedef struct IDiaEnumStackFramesVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            IDiaEnumStackFrames * This,
+            /* [in] */ REFIID riid,
+            /* [iid_is][out] */ 
+            __RPC__deref_out  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            IDiaEnumStackFrames * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            IDiaEnumStackFrames * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *Next )( 
+            IDiaEnumStackFrames * This,
+            /* [in] */ ULONG celt,
+            /* [out] */ IDiaStackFrame **rgelt,
+            /* [out] */ ULONG *pceltFetched);
+        
+        HRESULT ( STDMETHODCALLTYPE *Reset )( 
+            IDiaEnumStackFrames * This);
+        
+        END_INTERFACE
+    } IDiaEnumStackFramesVtbl;
+
+    interface IDiaEnumStackFrames
+    {
+        CONST_VTBL struct IDiaEnumStackFramesVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define IDiaEnumStackFrames_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define IDiaEnumStackFrames_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define IDiaEnumStackFrames_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define IDiaEnumStackFrames_Next(This,celt,rgelt,pceltFetched)	\
+    ( (This)->lpVtbl -> Next(This,celt,rgelt,pceltFetched) ) 
+
+#define IDiaEnumStackFrames_Reset(This)	\
+    ( (This)->lpVtbl -> Reset(This) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __IDiaEnumStackFrames_INTERFACE_DEFINED__ */
+
+
+/* interface __MIDL_itf_dia2_0000_0031 */
+/* [local] */ 
+
+typedef /* [public] */ struct __MIDL___MIDL_itf_dia2_0000_0031_0001
+    {
+    DWORD ulOffStart;
+    DWORD cbProcSize;
+    DWORD cdwLocals;
+    WORD cdwParams;
+    WORD cdwFlags;
+    } 	FPODATA;
+
+
+
+extern RPC_IF_HANDLE __MIDL_itf_dia2_0000_0031_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_dia2_0000_0031_v0_0_s_ifspec;
+
+#ifndef __IDiaStackWalkHelper_INTERFACE_DEFINED__
+#define __IDiaStackWalkHelper_INTERFACE_DEFINED__
+
+/* interface IDiaStackWalkHelper */
+/* [unique][helpstring][local][uuid][object] */ 
+
+
+EXTERN_C const IID IID_IDiaStackWalkHelper;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("feb0155d-35a8-42d4-8328-bf458f429a3a")
+    IDiaStackWalkHelper : public IUnknown
+    {
+    public:
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_registerValue( 
+            /* [in] */ DWORD index,
+            /* [retval][out] */ ULONGLONG *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propput] */ HRESULT STDMETHODCALLTYPE put_registerValue( 
+            /* [in] */ DWORD index,
+            /* [in] */ ULONGLONG NewVal) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE readMemory( 
+            /* [in] */ enum MemoryTypeEnum type,
+            /* [in] */ ULONGLONG va,
+            /* [in] */ DWORD cbData,
+            /* [out] */ DWORD *pcbData,
+            /* [size_is][out] */ BYTE *pbData) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE searchForReturnAddress( 
+            /* [in] */ IDiaFrameData *frame,
+            /* [out] */ ULONGLONG *returnAddress) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE searchForReturnAddressStart( 
+            /* [in] */ IDiaFrameData *frame,
+            /* [in] */ ULONGLONG startAddress,
+            /* [out] */ ULONGLONG *returnAddress) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE frameForVA( 
+            /* [in] */ ULONGLONG va,
+            /* [out] */ IDiaFrameData **ppFrame) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE symbolForVA( 
+            /* [in] */ ULONGLONG va,
+            /* [out] */ IDiaSymbol **ppSymbol) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE pdataForVA( 
+            /* [in] */ ULONGLONG va,
+            /* [in] */ DWORD cbData,
+            /* [out] */ DWORD *pcbData,
+            /* [size_is][out] */ BYTE *pbData) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE imageForVA( 
+            /* [in] */ ULONGLONG vaContext,
+            /* [out] */ ULONGLONG *pvaImageStart) = 0;
+        
+    };
+    
+#else 	/* C style interface */
+
+    typedef struct IDiaStackWalkHelperVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            IDiaStackWalkHelper * This,
+            /* [in] */ REFIID riid,
+            /* [iid_is][out] */ 
+            __RPC__deref_out  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            IDiaStackWalkHelper * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            IDiaStackWalkHelper * This);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_registerValue )( 
+            IDiaStackWalkHelper * This,
+            /* [in] */ DWORD index,
+            /* [retval][out] */ ULONGLONG *pRetVal);
+        
+        /* [id][helpstring][propput] */ HRESULT ( STDMETHODCALLTYPE *put_registerValue )( 
+            IDiaStackWalkHelper * This,
+            /* [in] */ DWORD index,
+            /* [in] */ ULONGLONG NewVal);
+        
+        HRESULT ( STDMETHODCALLTYPE *readMemory )( 
+            IDiaStackWalkHelper * This,
+            /* [in] */ enum MemoryTypeEnum type,
+            /* [in] */ ULONGLONG va,
+            /* [in] */ DWORD cbData,
+            /* [out] */ DWORD *pcbData,
+            /* [size_is][out] */ BYTE *pbData);
+        
+        HRESULT ( STDMETHODCALLTYPE *searchForReturnAddress )( 
+            IDiaStackWalkHelper * This,
+            /* [in] */ IDiaFrameData *frame,
+            /* [out] */ ULONGLONG *returnAddress);
+        
+        HRESULT ( STDMETHODCALLTYPE *searchForReturnAddressStart )( 
+            IDiaStackWalkHelper * This,
+            /* [in] */ IDiaFrameData *frame,
+            /* [in] */ ULONGLONG startAddress,
+            /* [out] */ ULONGLONG *returnAddress);
+        
+        HRESULT ( STDMETHODCALLTYPE *frameForVA )( 
+            IDiaStackWalkHelper * This,
+            /* [in] */ ULONGLONG va,
+            /* [out] */ IDiaFrameData **ppFrame);
+        
+        HRESULT ( STDMETHODCALLTYPE *symbolForVA )( 
+            IDiaStackWalkHelper * This,
+            /* [in] */ ULONGLONG va,
+            /* [out] */ IDiaSymbol **ppSymbol);
+        
+        HRESULT ( STDMETHODCALLTYPE *pdataForVA )( 
+            IDiaStackWalkHelper * This,
+            /* [in] */ ULONGLONG va,
+            /* [in] */ DWORD cbData,
+            /* [out] */ DWORD *pcbData,
+            /* [size_is][out] */ BYTE *pbData);
+        
+        HRESULT ( STDMETHODCALLTYPE *imageForVA )( 
+            IDiaStackWalkHelper * This,
+            /* [in] */ ULONGLONG vaContext,
+            /* [out] */ ULONGLONG *pvaImageStart);
+        
+        END_INTERFACE
+    } IDiaStackWalkHelperVtbl;
+
+    interface IDiaStackWalkHelper
+    {
+        CONST_VTBL struct IDiaStackWalkHelperVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define IDiaStackWalkHelper_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define IDiaStackWalkHelper_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define IDiaStackWalkHelper_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define IDiaStackWalkHelper_get_registerValue(This,index,pRetVal)	\
+    ( (This)->lpVtbl -> get_registerValue(This,index,pRetVal) ) 
+
+#define IDiaStackWalkHelper_put_registerValue(This,index,NewVal)	\
+    ( (This)->lpVtbl -> put_registerValue(This,index,NewVal) ) 
+
+#define IDiaStackWalkHelper_readMemory(This,type,va,cbData,pcbData,pbData)	\
+    ( (This)->lpVtbl -> readMemory(This,type,va,cbData,pcbData,pbData) ) 
+
+#define IDiaStackWalkHelper_searchForReturnAddress(This,frame,returnAddress)	\
+    ( (This)->lpVtbl -> searchForReturnAddress(This,frame,returnAddress) ) 
+
+#define IDiaStackWalkHelper_searchForReturnAddressStart(This,frame,startAddress,returnAddress)	\
+    ( (This)->lpVtbl -> searchForReturnAddressStart(This,frame,startAddress,returnAddress) ) 
+
+#define IDiaStackWalkHelper_frameForVA(This,va,ppFrame)	\
+    ( (This)->lpVtbl -> frameForVA(This,va,ppFrame) ) 
+
+#define IDiaStackWalkHelper_symbolForVA(This,va,ppSymbol)	\
+    ( (This)->lpVtbl -> symbolForVA(This,va,ppSymbol) ) 
+
+#define IDiaStackWalkHelper_pdataForVA(This,va,cbData,pcbData,pbData)	\
+    ( (This)->lpVtbl -> pdataForVA(This,va,cbData,pcbData,pbData) ) 
+
+#define IDiaStackWalkHelper_imageForVA(This,vaContext,pvaImageStart)	\
+    ( (This)->lpVtbl -> imageForVA(This,vaContext,pvaImageStart) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __IDiaStackWalkHelper_INTERFACE_DEFINED__ */
+
+
+#ifndef __IDiaStackWalker_INTERFACE_DEFINED__
+#define __IDiaStackWalker_INTERFACE_DEFINED__
+
+/* interface IDiaStackWalker */
+/* [unique][helpstring][local][uuid][object] */ 
+
+
+EXTERN_C const IID IID_IDiaStackWalker;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("5485216b-a54c-469f-9670-52b24d5229bb")
+    IDiaStackWalker : public IUnknown
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE getEnumFrames( 
+            /* [in] */ IDiaStackWalkHelper *pHelper,
+            /* [out] */ IDiaEnumStackFrames **ppEnum) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE getEnumFrames2( 
+            /* [in] */ enum CV_CPU_TYPE_e cpuid,
+            /* [in] */ IDiaStackWalkHelper *pHelper,
+            /* [out] */ IDiaEnumStackFrames **ppEnum) = 0;
+        
+    };
+    
+#else 	/* C style interface */
+
+    typedef struct IDiaStackWalkerVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            IDiaStackWalker * This,
+            /* [in] */ REFIID riid,
+            /* [iid_is][out] */ 
+            __RPC__deref_out  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            IDiaStackWalker * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            IDiaStackWalker * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *getEnumFrames )( 
+            IDiaStackWalker * This,
+            /* [in] */ IDiaStackWalkHelper *pHelper,
+            /* [out] */ IDiaEnumStackFrames **ppEnum);
+        
+        HRESULT ( STDMETHODCALLTYPE *getEnumFrames2 )( 
+            IDiaStackWalker * This,
+            /* [in] */ enum CV_CPU_TYPE_e cpuid,
+            /* [in] */ IDiaStackWalkHelper *pHelper,
+            /* [out] */ IDiaEnumStackFrames **ppEnum);
+        
+        END_INTERFACE
+    } IDiaStackWalkerVtbl;
+
+    interface IDiaStackWalker
+    {
+        CONST_VTBL struct IDiaStackWalkerVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define IDiaStackWalker_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define IDiaStackWalker_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define IDiaStackWalker_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define IDiaStackWalker_getEnumFrames(This,pHelper,ppEnum)	\
+    ( (This)->lpVtbl -> getEnumFrames(This,pHelper,ppEnum) ) 
+
+#define IDiaStackWalker_getEnumFrames2(This,cpuid,pHelper,ppEnum)	\
+    ( (This)->lpVtbl -> getEnumFrames2(This,cpuid,pHelper,ppEnum) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __IDiaStackWalker_INTERFACE_DEFINED__ */
+
+
+#ifndef __IDiaStackWalkHelper2_INTERFACE_DEFINED__
+#define __IDiaStackWalkHelper2_INTERFACE_DEFINED__
+
+/* interface IDiaStackWalkHelper2 */
+/* [unique][helpstring][local][uuid][object] */ 
+
+
+EXTERN_C const IID IID_IDiaStackWalkHelper2;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("8222c490-507b-4bef-b3bd-41dca7b5934c")
+    IDiaStackWalkHelper2 : public IDiaStackWalkHelper
+    {
+    public:
+    };
+    
+#else 	/* C style interface */
+
+    typedef struct IDiaStackWalkHelper2Vtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            IDiaStackWalkHelper2 * This,
+            /* [in] */ REFIID riid,
+            /* [iid_is][out] */ 
+            __RPC__deref_out  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            IDiaStackWalkHelper2 * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            IDiaStackWalkHelper2 * This);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_registerValue )( 
+            IDiaStackWalkHelper2 * This,
+            /* [in] */ DWORD index,
+            /* [retval][out] */ ULONGLONG *pRetVal);
+        
+        /* [id][helpstring][propput] */ HRESULT ( STDMETHODCALLTYPE *put_registerValue )( 
+            IDiaStackWalkHelper2 * This,
+            /* [in] */ DWORD index,
+            /* [in] */ ULONGLONG NewVal);
+        
+        HRESULT ( STDMETHODCALLTYPE *readMemory )( 
+            IDiaStackWalkHelper2 * This,
+            /* [in] */ enum MemoryTypeEnum type,
+            /* [in] */ ULONGLONG va,
+            /* [in] */ DWORD cbData,
+            /* [out] */ DWORD *pcbData,
+            /* [size_is][out] */ BYTE *pbData);
+        
+        HRESULT ( STDMETHODCALLTYPE *searchForReturnAddress )( 
+            IDiaStackWalkHelper2 * This,
+            /* [in] */ IDiaFrameData *frame,
+            /* [out] */ ULONGLONG *returnAddress);
+        
+        HRESULT ( STDMETHODCALLTYPE *searchForReturnAddressStart )( 
+            IDiaStackWalkHelper2 * This,
+            /* [in] */ IDiaFrameData *frame,
+            /* [in] */ ULONGLONG startAddress,
+            /* [out] */ ULONGLONG *returnAddress);
+        
+        HRESULT ( STDMETHODCALLTYPE *frameForVA )( 
+            IDiaStackWalkHelper2 * This,
+            /* [in] */ ULONGLONG va,
+            /* [out] */ IDiaFrameData **ppFrame);
+        
+        HRESULT ( STDMETHODCALLTYPE *symbolForVA )( 
+            IDiaStackWalkHelper2 * This,
+            /* [in] */ ULONGLONG va,
+            /* [out] */ IDiaSymbol **ppSymbol);
+        
+        HRESULT ( STDMETHODCALLTYPE *pdataForVA )( 
+            IDiaStackWalkHelper2 * This,
+            /* [in] */ ULONGLONG va,
+            /* [in] */ DWORD cbData,
+            /* [out] */ DWORD *pcbData,
+            /* [size_is][out] */ BYTE *pbData);
+        
+        HRESULT ( STDMETHODCALLTYPE *imageForVA )( 
+            IDiaStackWalkHelper2 * This,
+            /* [in] */ ULONGLONG vaContext,
+            /* [out] */ ULONGLONG *pvaImageStart);
+        
+        END_INTERFACE
+    } IDiaStackWalkHelper2Vtbl;
+
+    interface IDiaStackWalkHelper2
+    {
+        CONST_VTBL struct IDiaStackWalkHelper2Vtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define IDiaStackWalkHelper2_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define IDiaStackWalkHelper2_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define IDiaStackWalkHelper2_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define IDiaStackWalkHelper2_get_registerValue(This,index,pRetVal)	\
+    ( (This)->lpVtbl -> get_registerValue(This,index,pRetVal) ) 
+
+#define IDiaStackWalkHelper2_put_registerValue(This,index,NewVal)	\
+    ( (This)->lpVtbl -> put_registerValue(This,index,NewVal) ) 
+
+#define IDiaStackWalkHelper2_readMemory(This,type,va,cbData,pcbData,pbData)	\
+    ( (This)->lpVtbl -> readMemory(This,type,va,cbData,pcbData,pbData) ) 
+
+#define IDiaStackWalkHelper2_searchForReturnAddress(This,frame,returnAddress)	\
+    ( (This)->lpVtbl -> searchForReturnAddress(This,frame,returnAddress) ) 
+
+#define IDiaStackWalkHelper2_searchForReturnAddressStart(This,frame,startAddress,returnAddress)	\
+    ( (This)->lpVtbl -> searchForReturnAddressStart(This,frame,startAddress,returnAddress) ) 
+
+#define IDiaStackWalkHelper2_frameForVA(This,va,ppFrame)	\
+    ( (This)->lpVtbl -> frameForVA(This,va,ppFrame) ) 
+
+#define IDiaStackWalkHelper2_symbolForVA(This,va,ppSymbol)	\
+    ( (This)->lpVtbl -> symbolForVA(This,va,ppSymbol) ) 
+
+#define IDiaStackWalkHelper2_pdataForVA(This,va,cbData,pcbData,pbData)	\
+    ( (This)->lpVtbl -> pdataForVA(This,va,cbData,pcbData,pbData) ) 
+
+#define IDiaStackWalkHelper2_imageForVA(This,vaContext,pvaImageStart)	\
+    ( (This)->lpVtbl -> imageForVA(This,vaContext,pvaImageStart) ) 
+
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __IDiaStackWalkHelper2_INTERFACE_DEFINED__ */
+
+
+#ifndef __IDiaStackWalker2_INTERFACE_DEFINED__
+#define __IDiaStackWalker2_INTERFACE_DEFINED__
+
+/* interface IDiaStackWalker2 */
+/* [unique][helpstring][local][uuid][object] */ 
+
+
+EXTERN_C const IID IID_IDiaStackWalker2;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("7c185885-a015-4cac-9411-0f4fb39b1f3a")
+    IDiaStackWalker2 : public IDiaStackWalker
+    {
+    public:
+    };
+    
+#else 	/* C style interface */
+
+    typedef struct IDiaStackWalker2Vtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            IDiaStackWalker2 * This,
+            /* [in] */ REFIID riid,
+            /* [iid_is][out] */ 
+            __RPC__deref_out  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            IDiaStackWalker2 * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            IDiaStackWalker2 * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *getEnumFrames )( 
+            IDiaStackWalker2 * This,
+            /* [in] */ IDiaStackWalkHelper *pHelper,
+            /* [out] */ IDiaEnumStackFrames **ppEnum);
+        
+        HRESULT ( STDMETHODCALLTYPE *getEnumFrames2 )( 
+            IDiaStackWalker2 * This,
+            /* [in] */ enum CV_CPU_TYPE_e cpuid,
+            /* [in] */ IDiaStackWalkHelper *pHelper,
+            /* [out] */ IDiaEnumStackFrames **ppEnum);
+        
+        END_INTERFACE
+    } IDiaStackWalker2Vtbl;
+
+    interface IDiaStackWalker2
+    {
+        CONST_VTBL struct IDiaStackWalker2Vtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define IDiaStackWalker2_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define IDiaStackWalker2_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define IDiaStackWalker2_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define IDiaStackWalker2_getEnumFrames(This,pHelper,ppEnum)	\
+    ( (This)->lpVtbl -> getEnumFrames(This,pHelper,ppEnum) ) 
+
+#define IDiaStackWalker2_getEnumFrames2(This,cpuid,pHelper,ppEnum)	\
+    ( (This)->lpVtbl -> getEnumFrames2(This,cpuid,pHelper,ppEnum) ) 
+
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __IDiaStackWalker2_INTERFACE_DEFINED__ */
+
+
+/* Additional Prototypes for ALL interfaces */
+
+/* end of Additional Prototypes */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+
diff --git a/src/ToolBox/PdbTypeMatch/include/diacreate.h b/src/ToolBox/PdbTypeMatch/include/diacreate.h
new file mode 100644
index 0000000000..fac6668752
--- /dev/null
+++ b/src/ToolBox/PdbTypeMatch/include/diacreate.h
@@ -0,0 +1,42 @@
+// diacreate.h - creation helper functions for DIA initialization
+//-----------------------------------------------------------------
+// 
+// Copyright Microsoft Corporation.  All Rights Reserved.
+//
+//---------------------------------------------------------------
+#ifndef _DIACREATE_H_
+#define _DIACREATE_H_
+
+//
+// Create a dia data source object from the dia dll (by dll name - does not access the registry).
+//
+
+HRESULT STDMETHODCALLTYPE NoRegCoCreate(  const __wchar_t *dllName,
+                        REFCLSID   rclsid,
+                        REFIID     riid,
+                        void     **ppv);
+
+#ifndef _NATIVE_WCHAR_T_DEFINED
+#ifdef __cplusplus
+
+HRESULT STDMETHODCALLTYPE NoRegCoCreate(  const wchar_t *dllName,
+                        REFCLSID   rclsid,
+                        REFIID     riid,
+                        void     **ppv) 
+{
+    return NoRegCoCreate( (const __wchar_t *)dllName, rclsid, riid, ppv );
+}
+
+#endif
+#endif
+
+
+
+//
+// Create a dia data source object from the dia dll (looks up the class id in the registry).
+//
+HRESULT STDMETHODCALLTYPE NoOleCoCreate(  REFCLSID   rclsid,
+                        REFIID     riid,
+                        void     **ppv);
+
+#endif
diff --git a/src/ToolBox/PdbTypeMatch/native.rc b/src/ToolBox/PdbTypeMatch/native.rc
new file mode 100644
index 0000000000..c4474f2ae4
--- /dev/null
+++ b/src/ToolBox/PdbTypeMatch/native.rc
@@ -0,0 +1,4 @@
+#define FX_VER_FILEDESCRIPTION_STR "Microsoft\0"
+
+#include <fxver.h>
+#include <fxver.rc>
diff --git a/src/ToolBox/PdbTypeMatch/regs.cpp b/src/ToolBox/PdbTypeMatch/regs.cpp
new file mode 100644
index 0000000000..4358f8141c
--- /dev/null
+++ b/src/ToolBox/PdbTypeMatch/regs.cpp
@@ -0,0 +1,1704 @@
+#include "stdafx.h"
+#include "cvconst.h"
+#include "regs.h"
+
+const wchar_t * const rgRegX86[] = {
+    L"None",         // 0   CV_REG_NONE
+    L"al",           // 1   CV_REG_AL
+    L"cl",           // 2   CV_REG_CL
+    L"dl",           // 3   CV_REG_DL
+    L"bl",           // 4   CV_REG_BL
+    L"ah",           // 5   CV_REG_AH
+    L"ch",           // 6   CV_REG_CH
+    L"dh",           // 7   CV_REG_DH
+    L"bh",           // 8   CV_REG_BH
+    L"ax",           // 9   CV_REG_AX
+    L"cx",           // 10  CV_REG_CX
+    L"dx",           // 11  CV_REG_DX
+    L"bx",           // 12  CV_REG_BX
+    L"sp",           // 13  CV_REG_SP
+    L"bp",           // 14  CV_REG_BP
+    L"si",           // 15  CV_REG_SI
+    L"di",           // 16  CV_REG_DI
+    L"eax",          // 17  CV_REG_EAX
+    L"ecx",          // 18  CV_REG_ECX
+    L"edx",          // 19  CV_REG_EDX
+    L"ebx",          // 20  CV_REG_EBX
+    L"esp",          // 21  CV_REG_ESP
+    L"ebp",          // 22  CV_REG_EBP
+    L"esi",          // 23  CV_REG_ESI
+    L"edi",          // 24  CV_REG_EDI
+    L"es",           // 25  CV_REG_ES
+    L"cs",           // 26  CV_REG_CS
+    L"ss",           // 27  CV_REG_SS
+    L"ds",           // 28  CV_REG_DS
+    L"fs",           // 29  CV_REG_FS
+    L"gs",           // 30  CV_REG_GS
+    L"IP",           // 31  CV_REG_IP
+    L"FLAGS",        // 32  CV_REG_FLAGS
+    L"EIP",          // 33  CV_REG_EIP
+    L"EFLAGS",       // 34  CV_REG_EFLAG
+    L"???",          // 35
+    L"???",          // 36
+    L"???",          // 37
+    L"???",          // 38
+    L"???",          // 39
+    L"TEMP",         // 40  CV_REG_TEMP
+    L"TEMPH"         // 41  CV_REG_TEMPH
+    L"QUOTE",        // 42  CV_REG_QUOTE
+    L"PCDR3",        // 43  CV_REG_PCDR3
+    L"PCDR4",        // 44  CV_REG_PCDR4
+    L"PCDR5",        // 45  CV_REG_PCDR5
+    L"PCDR6",        // 46  CV_REG_PCDR6
+    L"PCDR7",        // 47  CV_REG_PCDR7
+    L"???",          // 48
+    L"???",          // 49
+    L"???",          // 50
+    L"???",          // 51
+    L"???",          // 52
+    L"???",          // 53
+    L"???",          // 54
+    L"???",          // 55
+    L"???",          // 56
+    L"???",          // 57
+    L"???",          // 58
+    L"???",          // 59
+    L"???",          // 60
+    L"???",          // 61
+    L"???",          // 62
+    L"???",          // 63
+    L"???",          // 64
+    L"???",          // 65
+    L"???",          // 66
+    L"???",          // 67
+    L"???",          // 68
+    L"???",          // 69
+    L"???",          // 70
+    L"???",          // 71
+    L"???",          // 72
+    L"???",          // 73
+    L"???",          // 74
+    L"???",          // 75
+    L"???",          // 76
+    L"???",          // 77
+    L"???",          // 78
+    L"???",          // 79
+    L"cr0",          // 80  CV_REG_CR0
+    L"cr1",          // 81  CV_REG_CR1
+    L"cr2",          // 82  CV_REG_CR2
+    L"cr3",          // 83  CV_REG_CR3
+    L"cr4",          // 84  CV_REG_CR4
+    L"???",          // 85
+    L"???",          // 86
+    L"???",          // 87
+    L"???",          // 88
+    L"???",          // 89
+    L"dr0",          // 90  CV_REG_DR0
+    L"dr1",          // 91  CV_REG_DR1
+    L"dr2",          // 92  CV_REG_DR2
+    L"dr3",          // 93  CV_REG_DR3
+    L"dr4",          // 94  CV_REG_DR4
+    L"dr5",          // 95  CV_REG_DR5
+    L"dr6",          // 96  CV_REG_DR6
+    L"dr7",          // 97  CV_REG_DR7
+    L"???",          // 98
+    L"???",          // 99
+    L"???",          // 10
+    L"???",          // 101
+    L"???",          // 102
+    L"???",          // 103
+    L"???",          // 104
+    L"???",          // 105
+    L"???",          // 106
+    L"???",          // 107
+    L"???",          // 108
+    L"???",          // 109
+    L"GDTR",         // 110 CV_REG_GDTR
+    L"GDTL",         // 111 CV_REG_GDTL
+    L"IDTR",         // 112 CV_REG_IDTR
+    L"IDTL",         // 113 CV_REG_IDTL
+    L"LDTR",         // 114 CV_REG_LDTR
+    L"TR",           // 115 CV_REG_TR
+    L"???",          // 116
+    L"???",          // 117
+    L"???",          // 118
+    L"???",          // 119
+    L"???",          // 120
+    L"???",          // 121
+    L"???",          // 122
+    L"???",          // 123
+    L"???",          // 124
+    L"???",          // 125
+    L"???",          // 126
+    L"???",          // 127
+    L"st(0)",        // 128 CV_REG_ST0
+    L"st(1)",        // 129 CV_REG_ST1
+    L"st(2)",        // 130 CV_REG_ST2
+    L"st(3)",        // 131 CV_REG_ST3
+    L"st(4)",        // 132 CV_REG_ST4
+    L"st(5)",        // 133 CV_REG_ST5
+    L"st(6)",        // 134 CV_REG_ST6
+    L"st(7)",        // 135 CV_REG_ST7
+    L"CTRL",         // 136 CV_REG_CTRL
+    L"STAT",         // 137 CV_REG_STAT
+    L"TAG",          // 138 CV_REG_TAG
+    L"FPIP",         // 139 CV_REG_FPIP
+    L"FPCS",         // 140 CV_REG_FPCS
+    L"FPDO",         // 141 CV_REG_FPDO
+    L"FPDS",         // 142 CV_REG_FPDS
+    L"ISEM",         // 143 CV_REG_ISEM
+    L"FPEIP",        // 144 CV_REG_FPEIP
+    L"FPED0"         // 145 CV_REG_FPEDO
+};
+
+const wchar_t * const rgRegAMD64[] = {
+    L"None",         // 0   CV_REG_NONE
+    L"al",           // 1   CV_AMD64_AL
+    L"cl",           // 2   CV_AMD64_CL
+    L"dl",           // 3   CV_AMD64_DL
+    L"bl",           // 4   CV_AMD64_BL
+    L"ah",           // 5   CV_AMD64_AH
+    L"ch",           // 6   CV_AMD64_CH
+    L"dh",           // 7   CV_AMD64_DH
+    L"bh",           // 8   CV_AMD64_BH
+    L"ax",           // 9   CV_AMD64_AX
+    L"cx",           // 10  CV_AMD64_CX
+    L"dx",           // 11  CV_AMD64_DX
+    L"bx",           // 12  CV_AMD64_BX
+    L"sp",           // 13  CV_AMD64_SP
+    L"bp",           // 14  CV_AMD64_BP
+    L"si",           // 15  CV_AMD64_SI
+    L"di",           // 16  CV_AMD64_DI
+    L"eax",          // 17  CV_AMD64_EAX
+    L"ecx",          // 18  CV_AMD64_ECX
+    L"edx",          // 19  CV_AMD64_EDX
+    L"ebx",          // 20  CV_AMD64_EBX
+    L"esp",          // 21  CV_AMD64_ESP
+    L"ebp",          // 22  CV_AMD64_EBP
+    L"esi",          // 23  CV_AMD64_ESI
+    L"edi",          // 24  CV_AMD64_EDI
+    L"es",           // 25  CV_AMD64_ES
+    L"cs",           // 26  CV_AMD64_CS
+    L"ss",           // 27  CV_AMD64_SS
+    L"ds",           // 28  CV_AMD64_DS
+    L"fs",           // 29  CV_AMD64_FS
+    L"gs",           // 30  CV_AMD64_GS
+    L"???",          // 31  Not filled up
+    L"flags",        // 32  CV_AMD64_FLAGS
+    L"rip",          // 33  CV_AMD64_RIP
+    L"eflags",       // 34  CV_AMD64_EFLAGS
+    L"???",          // 35
+    L"???",          // 36
+    L"???",          // 37
+    L"???",          // 38
+    L"???",          // 39
+    L"???",          // 40
+    L"???",          // 41
+    L"???",          // 42
+    L"???",          // 43
+    L"???",          // 44
+    L"???",          // 45
+    L"???",          // 46
+    L"???",          // 47
+    L"???",          // 48
+    L"???",          // 49
+    L"???",          // 50
+    L"???",          // 51
+    L"???",          // 52
+    L"???",          // 53
+    L"???",          // 54
+    L"???",          // 55
+    L"???",          // 56
+    L"???",          // 57
+    L"???",          // 58
+    L"???",          // 59
+    L"???",          // 60
+    L"???",          // 61
+    L"???",          // 62
+    L"???",          // 63
+    L"???",          // 64
+    L"???",          // 65
+    L"???",          // 66
+    L"???",          // 67
+    L"???",          // 68
+    L"???",          // 69
+    L"???",          // 70
+    L"???",          // 71
+    L"???",          // 72
+    L"???",          // 73
+    L"???",          // 74
+    L"???",          // 75
+    L"???",          // 76
+    L"???",          // 77
+    L"???",          // 78
+    L"???",          // 79
+    L"cr0",          // 80  CV_AMD64_CR0
+    L"cr1",          // 81  CV_AMD64_CR1
+    L"cr2",          // 82  CV_AMD64_CR2
+    L"cr3",          // 83  CV_AMD64_CR3
+    L"cr4",          // 84  CV_AMD64_CR4
+    L"???",          // 85
+    L"???",          // 86
+    L"???",          // 87
+    L"cr8",          // 88  CV_AMD64_CR8
+    L"???",          // 89
+    L"dr0",          // 90  CV_AMD64_DR0
+    L"dr1",          // 91  CV_AMD64_DR1
+    L"dr2",          // 92  CV_AMD64_DR2
+    L"dr3",          // 93  CV_AMD64_DR3
+    L"dr4",          // 94  CV_AMD64_DR4
+    L"dr5",          // 95  CV_AMD64_DR5
+    L"dr6",          // 96  CV_AMD64_DR6
+    L"dr7",          // 97  CV_AMD64_DR7
+    L"dr8",          // 98  CV_AMD64_DR8
+    L"dr9",          // 99  CV_AMD64_DR9
+    L"dr10",         // 100 CV_AMD64_DR10
+    L"dr11",         // 101 CV_AMD64_DR11
+    L"dr12",         // 102 CV_AMD64_DR12
+    L"dr13",         // 103 CV_AMD64_DR13
+    L"dr14",         // 104 CV_AMD64_DR14
+    L"dr15",         // 105 CV_AMD64_DR15
+    L"???",          // 106
+    L"???",          // 107
+    L"???",          // 108
+    L"???",          // 109
+    L"gdtr",         // 110 CV_AMD64_GDTR
+    L"gdt",         // 111 CV_AMD64_GDTL
+    L"idtr",         // 112 CV_AMD64_IDTR
+    L"idt",         // 113 CV_AMD64_IDTL
+    L"ldtr",         // 114 CV_AMD64_LDTR
+    L"tr",           // 115 CV_AMD64_TR
+    L"???",          // 116
+    L"???",          // 117
+    L"???",          // 118
+    L"???",          // 119
+    L"???",          // 120
+    L"???",          // 121
+    L"???",          // 122
+    L"???",          // 123
+    L"???",          // 124
+    L"???",          // 125
+    L"???",          // 126
+    L"???",          // 127
+    L"st(0)",        // 128 CV_AMD64_ST0
+    L"st(1)",        // 129 CV_AMD64_ST1
+    L"st(2)",        // 130 CV_AMD64_ST2
+    L"st(3)",        // 131 CV_AMD64_ST3
+    L"st(4)",        // 132 CV_AMD64_ST4
+    L"st(5)",        // 133 CV_AMD64_ST5
+    L"st(6)",        // 134 CV_AMD64_ST6
+    L"st(7)",        // 135 CV_AMD64_ST7
+    L"ctr",         // 136 CV_AMD64_CTRL
+    L"stat",         // 137 CV_AMD64_STAT
+    L"tag",          // 138 CV_AMD64_TAG
+    L"fpip",         // 139 CV_AMD64_FPIP
+    L"fpcs",         // 140 CV_AMD64_FPCS
+    L"fpdo",         // 141 CV_AMD64_FPDO
+    L"fpds",         // 142 CV_AMD64_FPDS
+    L"isem",         // 143 CV_AMD64_ISEM
+    L"fpeip",        // 144 CV_AMD64_FPEIP
+    L"fped0",        // 145 CV_AMD64_FPEDO
+    L"mm0",          // 146 CV_AMD64_MM0
+    L"mm1",          // 147 CV_AMD64_MM1
+    L"mm2",          // 148 CV_AMD64_MM2
+    L"mm3",          // 149 CV_AMD64_MM3
+    L"mm4",          // 150 CV_AMD64_MM4
+    L"mm5",          // 151 CV_AMD64_MM5
+    L"mm6",          // 152 CV_AMD64_MM6
+    L"mm7",          // 153 CV_AMD64_MM7
+    L"xmm0",         // 154 CV_AMD64_XMM0
+    L"xmm1",         // 155 CV_AMD64_XMM1
+    L"xmm2",         // 156 CV_AMD64_XMM2
+    L"xmm3",         // 157 CV_AMD64_XMM3
+    L"xmm4",         // 158 CV_AMD64_XMM4
+    L"xmm5",         // 159 CV_AMD64_XMM5
+    L"xmm6",         // 160 CV_AMD64_XMM6
+    L"xmm7",         // 161 CV_AMD64_XMM7
+    L"xmm0_0",       // 162 CV_AMD64_XMM0_0
+    L"xmm0_1",       // 163 CV_AMD64_XMM0_1
+    L"xmm0_2",       // 164 CV_AMD64_XMM0_2
+    L"xmm0_3",       // 165 CV_AMD64_XMM0_3
+    L"xmm1_0",       // 166 CV_AMD64_XMM1_0
+    L"xmm1_1",       // 167 CV_AMD64_XMM1_1
+    L"xmm1_2",       // 168 CV_AMD64_XMM1_2
+    L"xmm1_3",       // 169 CV_AMD64_XMM1_3
+    L"xmm2_0",       // 170 CV_AMD64_XMM2_0
+    L"xmm2_1",       // 171 CV_AMD64_XMM2_1
+    L"xmm2_2",       // 172 CV_AMD64_XMM2_2
+    L"xmm2_3",       // 173 CV_AMD64_XMM2_3
+    L"xmm3_0",       // 174 CV_AMD64_XMM3_0
+    L"xmm3_1",       // 175 CV_AMD64_XMM3_1
+    L"xmm3_2",       // 176 CV_AMD64_XMM3_2
+    L"xmm3_3",       // 177 CV_AMD64_XMM3_3
+    L"xmm4_0",       // 178 CV_AMD64_XMM4_0
+    L"xmm4_1",       // 179 CV_AMD64_XMM4_1
+    L"xmm4_2",       // 180 CV_AMD64_XMM4_2
+    L"xmm4_3",       // 181 CV_AMD64_XMM4_3
+    L"xmm5_0",       // 182 CV_AMD64_XMM5_0
+    L"xmm5_1",       // 183 CV_AMD64_XMM5_1
+    L"xmm5_2",       // 184 CV_AMD64_XMM5_2
+    L"xmm5_3",       // 185 CV_AMD64_XMM5_3
+    L"xmm6_0",       // 186 CV_AMD64_XMM6_0
+    L"xmm6_1",       // 187 CV_AMD64_XMM6_1
+    L"xmm6_2",       // 188 CV_AMD64_XMM6_2
+    L"xmm6_3",       // 189 CV_AMD64_XMM6_3
+    L"xmm7_0",       // 190 CV_AMD64_XMM7_0
+    L"xmm7_1",       // 191 CV_AMD64_XMM7_1
+    L"xmm7_2",       // 192 CV_AMD64_XMM7_2
+    L"xmm7_3",       // 193 CV_AMD64_XMM7_3
+    L"xmm0",        // 194 CV_AMD64_XMM0L
+    L"xmm1",        // 195 CV_AMD64_XMM1L
+    L"xmm2",        // 196 CV_AMD64_XMM2L
+    L"xmm3",        // 197 CV_AMD64_XMM3L
+    L"xmm4",        // 198 CV_AMD64_XMM4L
+    L"xmm5",        // 199 CV_AMD64_XMM5L
+    L"xmm6",        // 200 CV_AMD64_XMM6L
+    L"xmm7",        // 201 CV_AMD64_XMM7L
+    L"xmm0h",        // 202 CV_AMD64_XMM0H
+    L"xmm1h",        // 203 CV_AMD64_XMM1H
+    L"xmm2h",        // 204 CV_AMD64_XMM2H
+    L"xmm3h",        // 205 CV_AMD64_XMM3H
+    L"xmm4h",        // 206 CV_AMD64_XMM4H
+    L"xmm5h",        // 207 CV_AMD64_XMM5H
+    L"xmm6h",        // 208 CV_AMD64_XMM6H
+    L"xmm7h",        // 209 CV_AMD64_XMM7H
+    L"???",          // 210
+    L"mxcsr",        // 211 CV_AMD64_MXCSR
+    L"???",          // 212
+    L"???",          // 213
+    L"???",          // 214
+    L"???",          // 215
+    L"???",          // 216
+    L"???",          // 217
+    L"???",          // 218
+    L"???",          // 219
+    L"emm0",        // 220 CV_AMD64_EMM0L
+    L"emm1",        // 221 CV_AMD64_EMM1L
+    L"emm2",        // 222 CV_AMD64_EMM2L
+    L"emm3",        // 223 CV_AMD64_EMM3L
+    L"emm4",        // 224 CV_AMD64_EMM4L
+    L"emm5",        // 225 CV_AMD64_EMM5L
+    L"emm6",        // 226 CV_AMD64_EMM6L
+    L"emm7",        // 227 CV_AMD64_EMM7L
+    L"emm0h",        // 228 CV_AMD64_EMM0H
+    L"emm1h",        // 229 CV_AMD64_EMM1H
+    L"emm2h",        // 230 CV_AMD64_EMM2H
+    L"emm3h",        // 231 CV_AMD64_EMM3H
+    L"emm4h",        // 232 CV_AMD64_EMM4H
+    L"emm5h",        // 233 CV_AMD64_EMM5H
+    L"emm6h",        // 234 CV_AMD64_EMM6H
+    L"emm7h",        // 235 CV_AMD64_EMM7H
+    L"mm00",         // 236 CV_AMD64_MM00
+    L"mm01",         // 237 CV_AMD64_MM01
+    L"mm10",         // 238 CV_AMD64_MM10
+    L"mm11",         // 239 CV_AMD64_MM11
+    L"mm20",         // 240 CV_AMD64_MM20
+    L"mm21",         // 241 CV_AMD64_MM21
+    L"mm30",         // 242 CV_AMD64_MM30
+    L"mm31",         // 243 CV_AMD64_MM31
+    L"mm40",         // 244 CV_AMD64_MM40
+    L"mm41",         // 245 CV_AMD64_MM41
+    L"mm50",         // 246 CV_AMD64_MM50
+    L"mm51",         // 247 CV_AMD64_MM51
+    L"mm60",         // 248 CV_AMD64_MM60
+    L"mm61",         // 249 CV_AMD64_MM61
+    L"mm70",         // 250 CV_AMD64_MM70
+    L"mm71",         // 251 CV_AMD64_MM71
+    L"xmm8",         // 252 CV_AMD64_XMM8
+    L"xmm9",         // 253 CV_AMD64_XMM9
+    L"xmm10",        // 254 CV_AMD64_XMM10
+    L"xmm11",        // 255 CV_AMD64_XMM11
+    L"xmm12",        // 256 CV_AMD64_XMM12
+    L"xmm13",        // 257 CV_AMD64_XMM13
+    L"xmm14",        // 258 CV_AMD64_XMM14
+    L"xmm15",        // 259 CV_AMD64_XMM15
+    L"xmm8_0",       // 260 CV_AMD64_XMM8_0
+    L"xmm8_1",       // 261 CV_AMD64_XMM8_1
+    L"xmm8_2",       // 262 CV_AMD64_XMM8_2
+    L"xmm8_3",       // 263 CV_AMD64_XMM8_3
+    L"xmm9_0",       // 264 CV_AMD64_XMM9_0
+    L"xmm9_1",       // 265 CV_AMD64_XMM9_1
+    L"xmm9_2",       // 266 CV_AMD64_XMM9_2
+    L"xmm9_3",       // 267 CV_AMD64_XMM9_3
+    L"xmm10_0",      // 268 CV_AMD64_XMM10_0
+    L"xmm10_1",      // 269 CV_AMD64_XMM10_1
+    L"xmm10_2",      // 270 CV_AMD64_XMM10_2
+    L"xmm10_3",      // 271 CV_AMD64_XMM10_3
+    L"xmm11_0",      // 272 CV_AMD64_XMM11_0
+    L"xmm11_1",      // 273 CV_AMD64_XMM11_1
+    L"xmm11_2",      // 274 CV_AMD64_XMM11_2
+    L"xmm11_3",      // 275 CV_AMD64_XMM11_3
+    L"xmm12_0",      // 276 CV_AMD64_XMM12_0
+    L"xmm12_1",      // 277 CV_AMD64_XMM12_1
+    L"xmm12_2",      // 278 CV_AMD64_XMM12_2
+    L"xmm12_3",      // 279 CV_AMD64_XMM12_3
+    L"xmm13_0",      // 280 CV_AMD64_XMM13_0
+    L"xmm13_1",      // 281 CV_AMD64_XMM13_1
+    L"xmm13_2",      // 282 CV_AMD64_XMM13_2
+    L"xmm13_3",      // 283 CV_AMD64_XMM13_3
+    L"xmm14_0",      // 284 CV_AMD64_XMM14_0
+    L"xmm14_1",      // 285 CV_AMD64_XMM14_1
+    L"xmm14_2",      // 286 CV_AMD64_XMM14_2
+    L"xmm14_3",      // 287 CV_AMD64_XMM14_3
+    L"xmm15_0",      // 288 CV_AMD64_XMM15_0
+    L"xmm15_1",      // 289 CV_AMD64_XMM15_1
+    L"xmm15_2",      // 290 CV_AMD64_XMM15_2
+    L"xmm15_3",      // 291 CV_AMD64_XMM15_3
+    L"xmm8",        // 292 CV_AMD64_XMM8L
+    L"xmm9",        // 293 CV_AMD64_XMM9L
+    L"xmm10",       // 294 CV_AMD64_XMM10L
+    L"xmm11",       // 295 CV_AMD64_XMM11L
+    L"xmm12",       // 296 CV_AMD64_XMM12L
+    L"xmm13",       // 297 CV_AMD64_XMM13L
+    L"xmm14",       // 298 CV_AMD64_XMM14L
+    L"xmm15",       // 299 CV_AMD64_XMM15L
+    L"xmm8h",        // 300 CV_AMD64_XMM8H
+    L"xmm9h",        // 301 CV_AMD64_XMM9H
+    L"xmm10h",       // 302 CV_AMD64_XMM10H
+    L"xmm11h",       // 303 CV_AMD64_XMM11H
+    L"xmm12h",       // 304 CV_AMD64_XMM12H
+    L"xmm13h",       // 305 CV_AMD64_XMM13H
+    L"xmm14h",       // 306 CV_AMD64_XMM14H
+    L"xmm15h",       // 307 CV_AMD64_XMM15H
+    L"emm8",        // 308 CV_AMD64_EMM8L
+    L"emm9",        // 309 CV_AMD64_EMM9L
+    L"emm10",       // 310 CV_AMD64_EMM10L
+    L"emm11",       // 311 CV_AMD64_EMM11L
+    L"emm12",       // 312 CV_AMD64_EMM12L
+    L"emm13",       // 313 CV_AMD64_EMM13L
+    L"emm14",       // 314 CV_AMD64_EMM14L
+    L"emm15",       // 315 CV_AMD64_EMM15L
+    L"emm8h",        // 316 CV_AMD64_EMM8H
+    L"emm9h",        // 317 CV_AMD64_EMM9H
+    L"emm10h",       // 318 CV_AMD64_EMM10H
+    L"emm11h",       // 319 CV_AMD64_EMM11H
+    L"emm12h",       // 320 CV_AMD64_EMM12H
+    L"emm13h",       // 321 CV_AMD64_EMM13H
+    L"emm14h",       // 322 CV_AMD64_EMM14H
+    L"emm15h",       // 323 CV_AMD64_EMM15H
+    L"si",          // 324 CV_AMD64_SIL
+    L"di",          // 325 CV_AMD64_DIL
+    L"bp",          // 326 CV_AMD64_BPL
+    L"sp",          // 327 CV_AMD64_SPL
+    L"rax",          // 328 CV_AMD64_RAX
+    L"rbx",          // 329 CV_AMD64_RBX
+    L"rcx",          // 330 CV_AMD64_RCX
+    L"rdx",          // 331 CV_AMD64_RDX
+    L"rsi",          // 332 CV_AMD64_RSI
+    L"rdi",          // 333 CV_AMD64_RDI
+    L"rbp",          // 334 CV_AMD64_RBP
+    L"rsp",          // 335 CV_AMD64_RSP
+    L"r8",           // 336 CV_AMD64_R8
+    L"r9",           // 337 CV_AMD64_R9
+    L"r10",          // 338 CV_AMD64_R10
+    L"r11",          // 339 CV_AMD64_R11
+    L"r12",          // 340 CV_AMD64_R12
+    L"r13",          // 341 CV_AMD64_R13
+    L"r14",          // 342 CV_AMD64_R14
+    L"r15",          // 343 CV_AMD64_R15
+    L"r8b",          // 344 CV_AMD64_R8B
+    L"r9b",          // 345 CV_AMD64_R9B
+    L"r10b",         // 346 CV_AMD64_R10B
+    L"r11b",         // 347 CV_AMD64_R11B
+    L"r12b",         // 348 CV_AMD64_R12B
+    L"r13b",         // 349 CV_AMD64_R13B
+    L"r14b",         // 350 CV_AMD64_R14B
+    L"r15b",         // 351 CV_AMD64_R15B
+    L"r8w",          // 352 CV_AMD64_R8W
+    L"r9w",          // 353 CV_AMD64_R9W
+    L"r10w",         // 354 CV_AMD64_R10W
+    L"r11w",         // 355 CV_AMD64_R11W
+    L"r12w",         // 356 CV_AMD64_R12W
+    L"r13w",         // 357 CV_AMD64_R13W
+    L"r14w",         // 358 CV_AMD64_R14W
+    L"r15w",         // 359 CV_AMD64_R15W
+    L"r8d",          // 360 CV_AMD64_R8D
+    L"r9d",          // 361 CV_AMD64_R9D
+    L"r10d",         // 362 CV_AMD64_R10D
+    L"r11d",         // 363 CV_AMD64_R11D
+    L"r12d",         // 364 CV_AMD64_R12D
+    L"r13d",         // 365 CV_AMD64_R13D
+    L"r14d",         // 366 CV_AMD64_R14D
+    L"r15d"          // 367 CV_AMD64_R15D
+};
+
+const wchar_t * const rgRegMips[] = {
+    L"None",         // 0   CV_M4_NOREG
+    L"???",          // 1
+    L"???",          // 2
+    L"???",          // 3
+    L"???",          // 4
+    L"???",          // 5
+    L"???",          // 6
+    L"???",          // 7
+    L"???",          // 8
+    L"???",          // 9
+    L"zero",         // 10  CV_M4_IntZERO
+    L"at",           // 11  CV_M4_IntAT
+    L"v0",           // 12  CV_M4_IntV0
+    L"v1",           // 13  CV_M4_IntV1
+    L"a0",           // 14  CV_M4_IntA0
+    L"a1",           // 15  CV_M4_IntA1
+    L"a2",           // 16  CV_M4_IntA2
+    L"a3",           // 17  CV_M4_IntA3
+    L"t0",           // 18  CV_M4_IntT0
+    L"t1",           // 19  CV_M4_IntT1
+    L"t2",           // 20  CV_M4_IntT2
+    L"t3",           // 21  CV_M4_IntT3
+    L"t4",           // 22  CV_M4_IntT4
+    L"t5",           // 23  CV_M4_IntT5
+    L"t6",           // 24  CV_M4_IntT6
+    L"t7",           // 25  CV_M4_IntT7
+    L"s0",           // 26  CV_M4_IntS0
+    L"s1",           // 27  CV_M4_IntS1
+    L"s2",           // 28  CV_M4_IntS2
+    L"s3",           // 29  CV_M4_IntS3
+    L"s4",           // 30  CV_M4_IntS4
+    L"s5",           // 31  CV_M4_IntS5
+    L"s6",           // 32  CV_M4_IntS6
+    L"s7",           // 33  CV_M4_IntS7
+    L"t8",           // 34  CV_M4_IntT8
+    L"t9",           // 35  CV_M4_IntT9
+    L"k0",           // 36  CV_M4_IntKT0
+    L"k1",           // 37  CV_M4_IntKT1
+    L"gp",           // 38  CV_M4_IntGP
+    L"sp",           // 39  CV_M4_IntSP
+    L"s8",           // 40  CV_M4_IntS8
+    L"ra",           // 41  CV_M4_IntRA
+    L"lo",           // 42  CV_M4_IntLO
+    L"hi",           // 43  CV_M4_IntHI
+    L"???",          // 44
+    L"???",          // 45
+    L"???",          // 46
+    L"???",          // 47
+    L"???",          // 48
+    L"???",          // 49
+    L"Fir",          // 50  CV_M4_Fir
+    L"Psr",          // 51  CV_M4_Psr
+    L"???",          // 52
+    L"???",          // 53
+    L"???",          // 54
+    L"???",          // 55
+    L"???",          // 56
+    L"???",          // 57
+    L"???",          // 58
+    L"???",          // 59
+    L"$f0",          // 60  CV_M4_FltF0
+    L"$f1",          // 61  CV_M4_FltF1
+    L"$f2",          // 62  CV_M4_FltF2
+    L"$f3",          // 63  CV_M4_FltF3
+    L"$f4",          // 64  CV_M4_FltF4
+    L"$f5",          // 65  CV_M4_FltF5
+    L"$f6",          // 66  CV_M4_FltF6
+    L"$f7",          // 67  CV_M4_FltF7
+    L"$f8",          // 68  CV_M4_FltF8
+    L"$f9",          // 69  CV_M4_FltF9
+    L"$f10",         // 70  CV_M4_FltF10
+    L"$f11",         // 71  CV_M4_FltF11
+    L"$f12",         // 72  CV_M4_FltF12
+    L"$f13",         // 73  CV_M4_FltF13
+    L"$f14",         // 74  CV_M4_FltF14
+    L"$f15",         // 75  CV_M4_FltF15
+    L"$f16",         // 76  CV_M4_FltF16
+    L"$f17",         // 77  CV_M4_FltF17
+    L"$f18",         // 78  CV_M4_FltF18
+    L"$f19",         // 79  CV_M4_FltF19
+    L"$f20",         // 80  CV_M4_FltF20
+    L"$f21",         // 81  CV_M4_FltF21
+    L"$f22",         // 82  CV_M4_FltF22
+    L"$f23",         // 83  CV_M4_FltF23
+    L"$f24",         // 84  CV_M4_FltF24
+    L"$f25",         // 85  CV_M4_FltF25
+    L"$f26",         // 86  CV_M4_FltF26
+    L"$f27",         // 87  CV_M4_FltF27
+    L"$f28",         // 88  CV_M4_FltF28
+    L"$f29",         // 89  CV_M4_FltF29
+    L"$f30",         // 90  CV_M4_FltF30
+    L"$f31",         // 91  CV_M4_FltF31
+    L"Fsr"           // 92  CV_M4_FltFsr
+};
+
+const wchar_t * const rgReg68k[] = {
+    L"D0",           // 0   CV_R68_D0
+    L"D1",           // 1   CV_R68_D1
+    L"D2",           // 2   CV_R68_D2
+    L"D3",           // 3   CV_R68_D3
+    L"D4",           // 4   CV_R68_D4
+    L"D5",           // 5   CV_R68_D5
+    L"D6",           // 6   CV_R68_D6
+    L"D7",           // 7   CV_R68_D7
+    L"A0",           // 8   CV_R68_A0
+    L"A1",           // 9   CV_R68_A1
+    L"A2",           // 10  CV_R68_A2
+    L"A3",           // 11  CV_R68_A3
+    L"A4",           // 12  CV_R68_A4
+    L"A5",           // 13  CV_R68_A5
+    L"A6",           // 14  CV_R68_A6
+    L"A7",           // 15  CV_R68_A7
+    L"CCR",          // 16  CV_R68_CCR
+    L"SR",           // 17  CV_R68_SR
+    L"USP",          // 18  CV_R68_USP
+    L"MSP",          // 19  CV_R68_MSP
+    L"SFC",          // 20  CV_R68_SFC
+    L"DFC",          // 21  CV_R68_DFC
+    L"CACR",         // 22  CV_R68_CACR
+    L"VBR",          // 23  CV_R68_VBR
+    L"CAAR",         // 24  CV_R68_CAAR
+    L"ISP",          // 25  CV_R68_ISP
+    L"PC",           // 26  CV_R68_PC
+    L"???",          // 27
+    L"FPCR",         // 28  CV_R68_FPCR
+    L"FPSR",         // 29  CV_R68_FPSR
+    L"FPIAR",        // 30  CV_R68_FPIAR
+    L"???",          // 31
+    L"FP0",          // 32  CV_R68_FP0
+    L"FP1",          // 33  CV_R68_FP1
+    L"FP2",          // 34  CV_R68_FP2
+    L"FP3",          // 35  CV_R68_FP3
+    L"FP4",          // 36  CV_R68_FP4
+    L"FP5",          // 37  CV_R68_FP5
+    L"FP6",          // 38  CV_R68_FP6
+    L"FP7",          // 39  CV_R68_FP7
+    L"???",          // 40
+    L"???",          // 41  CV_R68_MMUSR030
+    L"???",          // 42  CV_R68_MMUSR
+    L"???",          // 43  CV_R68_URP
+    L"???",          // 44  CV_R68_DTT0
+    L"???",          // 45  CV_R68_DTT1
+    L"???",          // 46  CV_R68_ITT0
+    L"???",          // 47  CV_R68_ITT1
+    L"???",          // 48
+    L"???",          // 49
+    L"???",          // 50
+    L"PSR",          // 51  CV_R68_PSR
+    L"PCSR",         // 52  CV_R68_PCSR
+    L"VAL",          // 53  CV_R68_VAL
+    L"CRP",          // 54  CV_R68_CRP
+    L"SRP",          // 55  CV_R68_SRP
+    L"DRP",          // 56  CV_R68_DRP
+    L"TC",           // 57  CV_R68_TC
+    L"AC",           // 58  CV_R68_AC
+    L"SCC",          // 59  CV_R68_SCC
+    L"CAL",          // 60  CV_R68_CAL
+    L"TT0",          // 61  CV_R68_TT0
+    L"TT1",          // 62  CV_R68_TT1
+    L"???",          // 63
+    L"BAD0",         // 64  CV_R68_BAD0
+    L"BAD1",         // 65  CV_R68_BAD1
+    L"BAD2",         // 66  CV_R68_BAD2
+    L"BAD3",         // 67  CV_R68_BAD3
+    L"BAD4",         // 68  CV_R68_BAD4
+    L"BAD5",         // 69  CV_R68_BAD5
+    L"BAD6",         // 70  CV_R68_BAD6
+    L"BAD7",         // 71  CV_R68_BAD7
+    L"BAC0",         // 72  CV_R68_BAC0
+    L"BAC1",         // 73  CV_R68_BAC1
+    L"BAC2",         // 74  CV_R68_BAC2
+    L"BAC3",         // 75  CV_R68_BAC3
+    L"BAC4",         // 76  CV_R68_BAC4
+    L"BAC5",         // 77  CV_R68_BAC5
+    L"BAC6",         // 78  CV_R68_BAC6
+    L"BAC7"          // 79  CV_R68_BAC7
+};
+
+const wchar_t * const rgRegAlpha[] = {
+    L"None",         // 0   CV_ALPHA_NOREG
+    L"???",          // 1
+    L"???",          // 2
+    L"???",          // 3
+    L"???",          // 4
+    L"???",          // 5
+    L"???",          // 6
+    L"???",          // 7
+    L"???",          // 8
+    L"???",          // 9
+    L"$f0",          // 10  CV_ALPHA_FltF0
+    L"$f1",          // 11  CV_ALPHA_FltF1
+    L"$f2",          // 12  CV_ALPHA_FltF2
+    L"$f3",          // 13  CV_ALPHA_FltF3
+    L"$f4",          // 14  CV_ALPHA_FltF4
+    L"$f5",          // 15  CV_ALPHA_FltF5
+    L"$f6",          // 16  CV_ALPHA_FltF6
+    L"$f7",          // 17  CV_ALPHA_FltF7
+    L"$f8",          // 18  CV_ALPHA_FltF8
+    L"$f9",          // 19  CV_ALPHA_FltF9
+    L"$f10",         // 20  CV_ALPHA_FltF10
+    L"$f11",         // 21  CV_ALPHA_FltF11
+    L"$f12",         // 22  CV_ALPHA_FltF12
+    L"$f13",         // 23  CV_ALPHA_FltF13
+    L"$f14",         // 24  CV_ALPHA_FltF14
+    L"$f15",         // 25  CV_ALPHA_FltF15
+    L"$f16",         // 26  CV_ALPHA_FltF16
+    L"$f17",         // 27  CV_ALPHA_FltF17
+    L"$f18",         // 28  CV_ALPHA_FltF18
+    L"$f19",         // 29  CV_ALPHA_FltF19
+    L"$f20",         // 30  CV_ALPHA_FltF20
+    L"$f21",         // 31  CV_ALPHA_FltF21
+    L"$f22",         // 32  CV_ALPHA_FltF22
+    L"$f23",         // 33  CV_ALPHA_FltF23
+    L"$f24",         // 34  CV_ALPHA_FltF24
+    L"$f25",         // 35  CV_ALPHA_FltF25
+    L"$f26",         // 36  CV_ALPHA_FltF26
+    L"$f27",         // 37  CV_ALPHA_FltF27
+    L"$f28",         // 38  CV_ALPHA_FltF28
+    L"$f29",         // 39  CV_ALPHA_FltF29
+    L"$f30",         // 40  CV_ALPHA_FltF30
+    L"$f31",         // 41  CV_ALPHA_FltF31
+    L"v0",           // 42  CV_ALPHA_IntV0
+    L"t0",           // 43  CV_ALPHA_IntT0
+    L"t1",           // 44  CV_ALPHA_IntT1
+    L"t2",           // 45  CV_ALPHA_IntT2
+    L"t3",           // 46  CV_ALPHA_IntT3
+    L"t4",           // 47  CV_ALPHA_IntT4
+    L"t5",           // 48  CV_ALPHA_IntT5
+    L"t6",           // 49  CV_ALPHA_IntT6
+    L"t7",           // 50  CV_ALPHA_IntT7
+    L"s0",           // 51  CV_ALPHA_IntS0
+    L"s1",           // 52  CV_ALPHA_IntS1
+    L"s2",           // 53  CV_ALPHA_IntS2
+    L"s3",           // 54  CV_ALPHA_IntS3
+    L"s4",           // 55  CV_ALPHA_IntS4
+    L"s5",           // 56  CV_ALPHA_IntS5
+    L"fp",           // 57  CV_ALPHA_IntFP
+    L"a0",           // 58  CV_ALPHA_IntA0
+    L"a1",           // 59  CV_ALPHA_IntA1
+    L"a2",           // 60  CV_ALPHA_IntA2
+    L"a3",           // 61  CV_ALPHA_IntA3
+    L"a4",           // 62  CV_ALPHA_IntA4
+    L"a5",           // 63  CV_ALPHA_IntA5
+    L"t8",           // 64  CV_ALPHA_IntT8
+    L"t9",           // 65  CV_ALPHA_IntT9
+    L"t10",          // 66  CV_ALPHA_IntT10
+    L"t11",          // 67  CV_ALPHA_IntT11
+    L"ra",           // 68  CV_ALPHA_IntRA
+    L"t12",          // 69  CV_ALPHA_IntT12
+    L"at",           // 70  CV_ALPHA_IntAT
+    L"gp",           // 71  CV_ALPHA_IntGP
+    L"sp",           // 72  CV_ALPHA_IntSP
+    L"zero",         // 73  CV_ALPHA_IntZERO
+    L"Fpcr",         // 74  CV_ALPHA_Fpcr
+    L"Fir",          // 75  CV_ALPHA_Fir
+    L"Psr",          // 76  CV_ALPHA_Psr
+    L"FltFsr"        // 77  CV_ALPHA_FltFsr
+};
+
+const wchar_t * const rgRegPpc[] = {
+    L"None",         // 0
+    L"r0",           // 1   CV_PPC_GPR0
+    L"r1",           // 2   CV_PPC_GPR1
+    L"r2",           // 3   CV_PPC_GPR2
+    L"r3",           // 4   CV_PPC_GPR3
+    L"r4",           // 5   CV_PPC_GPR4
+    L"r5",           // 6   CV_PPC_GPR5
+    L"r6",           // 7   CV_PPC_GPR6
+    L"r7",           // 8   CV_PPC_GPR7
+    L"r8",           // 9   CV_PPC_GPR8
+    L"r9",           // 10  CV_PPC_GPR9
+    L"r10",          // 11  CV_PPC_GPR10
+    L"r11",          // 12  CV_PPC_GPR11
+    L"r12",          // 13  CV_PPC_GPR12
+    L"r13",          // 14  CV_PPC_GPR13
+    L"r14",          // 15  CV_PPC_GPR14
+    L"r15",          // 16  CV_PPC_GPR15
+    L"r16",          // 17  CV_PPC_GPR16
+    L"r17",          // 18  CV_PPC_GPR17
+    L"r18",          // 19  CV_PPC_GPR18
+    L"r19",          // 20  CV_PPC_GPR19
+    L"r20",          // 21  CV_PPC_GPR20
+    L"r21",          // 22  CV_PPC_GPR21
+    L"r22",          // 23  CV_PPC_GPR22
+    L"r23",          // 24  CV_PPC_GPR23
+    L"r24",          // 25  CV_PPC_GPR24
+    L"r25",          // 26  CV_PPC_GPR25
+    L"r26",          // 27  CV_PPC_GPR26
+    L"r27",          // 28  CV_PPC_GPR27
+    L"r28",          // 29  CV_PPC_GPR28
+    L"r29",          // 30  CV_PPC_GPR29
+    L"r30",          // 31  CV_PPC_GPR30
+    L"r31",          // 32  CV_PPC_GPR31
+    L"cr",           // 33  CV_PPC_CR
+    L"cr0",          // 34  CV_PPC_CR0
+    L"cr1",          // 35  CV_PPC_CR1
+    L"cr2",          // 36  CV_PPC_CR2
+    L"cr3",          // 37  CV_PPC_CR3
+    L"cr4",          // 38  CV_PPC_CR4
+    L"cr5",          // 39  CV_PPC_CR5
+    L"cr6",          // 40  CV_PPC_CR6
+    L"cr7",          // 41  CV_PPC_CR7
+    L"f0",           // 42  CV_PPC_FPR0
+    L"f1",           // 43  CV_PPC_FPR1
+    L"f2",           // 44  CV_PPC_FPR2
+    L"f3",           // 45  CV_PPC_FPR3
+    L"f4",           // 46  CV_PPC_FPR4
+    L"f5",           // 47  CV_PPC_FPR5
+    L"f6",           // 48  CV_PPC_FPR6
+    L"f7",           // 49  CV_PPC_FPR7
+    L"f8",           // 50  CV_PPC_FPR8
+    L"f9",           // 51  CV_PPC_FPR9
+    L"f10",          // 52  CV_PPC_FPR10
+    L"f11",          // 53  CV_PPC_FPR11
+    L"f12",          // 54  CV_PPC_FPR12
+    L"f13",          // 55  CV_PPC_FPR13
+    L"f14",          // 56  CV_PPC_FPR14
+    L"f15",          // 57  CV_PPC_FPR15
+    L"f16",          // 58  CV_PPC_FPR16
+    L"f17",          // 59  CV_PPC_FPR17
+    L"f18",          // 60  CV_PPC_FPR18
+    L"f19",          // 61  CV_PPC_FPR19
+    L"f20",          // 62  CV_PPC_FPR20
+    L"f21",          // 63  CV_PPC_FPR21
+    L"f22",          // 64  CV_PPC_FPR22
+    L"f23",          // 65  CV_PPC_FPR23
+    L"f24",          // 66  CV_PPC_FPR24
+    L"f25",          // 67  CV_PPC_FPR25
+    L"f26",          // 68  CV_PPC_FPR26
+    L"f27",          // 69  CV_PPC_FPR27
+    L"f28",          // 70  CV_PPC_FPR28
+    L"f29",          // 71  CV_PPC_FPR29
+    L"f30",          // 72  CV_PPC_FPR30
+    L"f31",          // 73  CV_PPC_FPR31
+    L"Fpscr",        // 74  CV_PPC_FPSCR
+    L"Msr"           // 75  CV_PPC_MSR
+};
+
+const wchar_t * const rgRegSh[] = {
+    L"None",         // 0   CV_SH3_NOREG
+    L"???",          // 1
+    L"???",          // 2
+    L"???",          // 3
+    L"???",          // 4
+    L"???",          // 5
+    L"???",          // 6
+    L"???",          // 7
+    L"???",          // 8
+    L"???",          // 9
+    L"r0",           // 10  CV_SH3_IntR0
+    L"r1",           // 11  CV_SH3_IntR1
+    L"r2",           // 12  CV_SH3_IntR2
+    L"r3",           // 13  CV_SH3_IntR3
+    L"r4",           // 14  CV_SH3_IntR4
+    L"r5",           // 15  CV_SH3_IntR5
+    L"r6",           // 16  CV_SH3_IntR6
+    L"r7",           // 17  CV_SH3_IntR7
+    L"r8",           // 18  CV_SH3_IntR8
+    L"r9",           // 19  CV_SH3_IntR9
+    L"r10",          // 20  CV_SH3_IntR10
+    L"r11",          // 21  CV_SH3_IntR11
+    L"r12",          // 22  CV_SH3_IntR12
+    L"r13",          // 23  CV_SH3_IntR13
+    L"fp",           // 24  CV_SH3_IntFp
+    L"sp",           // 25  CV_SH3_IntSp
+    L"???",          // 26
+    L"???",          // 27
+    L"???",          // 28
+    L"???",          // 29
+    L"???",          // 30
+    L"???",          // 31
+    L"???",          // 32
+    L"???",          // 33
+    L"???",          // 34
+    L"???",          // 35
+    L"???",          // 36
+    L"???",          // 37
+    L"gbr",          // 38  CV_SH3_Gbr
+    L"pr",           // 39  CV_SH3_Pr
+    L"mach",         // 40  CV_SH3_Mach
+    L"macl",         // 41  CV_SH3_Macl
+    L"???",          // 42
+    L"???",          // 43
+    L"???",          // 44
+    L"???",          // 45
+    L"???",          // 46
+    L"???",          // 47
+    L"???",          // 48
+    L"???",          // 49
+    L"pc",           // 50
+    L"sr",           // 51
+    L"???",          // 52
+    L"???",          // 53
+    L"???",          // 54
+    L"???",          // 55
+    L"???",          // 56
+    L"???",          // 57
+    L"???",          // 58
+    L"???",          // 59
+    L"bara",         // 60  CV_SH3_BarA
+    L"basra",        // 61  CV_SH3_BasrA
+    L"bamra",        // 62  CV_SH3_BamrA
+    L"bbra",         // 63  CV_SH3_BbrA
+    L"barb",         // 64  CV_SH3_BarB
+    L"basrb",        // 65  CV_SH3_BasrB
+    L"bamrb",        // 66  CV_SH3_BamrB
+    L"bbrb",         // 67  CV_SH3_BbrB
+    L"bdrb",         // 68  CV_SH3_BdrB
+    L"bdmrb",        // 69  CV_SH3_BdmrB
+    L"brcr"          // 70  CV_SH3_Brcr
+};
+
+const wchar_t * const rgRegArm[] = {
+    L"None",         // 0   CV_ARM_NOREG
+    L"???",          // 1
+    L"???",          // 2
+    L"???",          // 3
+    L"???",          // 4
+    L"???",          // 5
+    L"???",          // 6
+    L"???",          // 7
+    L"???",          // 8
+    L"???",          // 9
+    L"r0",           // 10  CV_ARM_R0
+    L"r1",           // 11  CV_ARM_R1
+    L"r2",           // 12  CV_ARM_R2
+    L"r3",           // 13  CV_ARM_R3
+    L"r4",           // 14  CV_ARM_R4
+    L"r5",           // 15  CV_ARM_R5
+    L"r6",           // 16  CV_ARM_R6
+    L"r7",           // 17  CV_ARM_R7
+    L"r8",           // 18  CV_ARM_R8
+    L"r9",           // 19  CV_ARM_R9
+    L"r10",          // 20  CV_ARM_R10
+    L"r11",          // 21  CV_ARM_R11
+    L"r12",          // 22  CV_ARM_R12
+    L"sp",           // 23  CV_ARM_SP
+    L"lr",           // 24  CV_ARM_LR
+    L"pc",           // 25  CV_ARM_PC
+    L"cpsr"          // 26  CV_ARM_CPSR
+};
+
+const MapIa64Reg mpIa64regSz[] = {
+    { CV_IA64_Br0, L"Br0" },
+    { CV_IA64_Br1, L"Br1" },
+    { CV_IA64_Br2, L"Br2" },
+    { CV_IA64_Br3, L"Br3" },
+    { CV_IA64_Br4, L"Br4" },
+    { CV_IA64_Br5, L"Br5" },
+    { CV_IA64_Br6, L"Br6" },
+    { CV_IA64_Br7, L"Br7" },
+    { CV_IA64_Preds, L"Preds" },
+    { CV_IA64_IntH0, L"IntH0" },
+    { CV_IA64_IntH1, L"IntH1" },
+    { CV_IA64_IntH2, L"IntH2" },
+    { CV_IA64_IntH3, L"IntH3" },
+    { CV_IA64_IntH4, L"IntH4" },
+    { CV_IA64_IntH5, L"IntH5" },
+    { CV_IA64_IntH6, L"IntH6" },
+    { CV_IA64_IntH7, L"IntH7" },
+    { CV_IA64_IntH8, L"IntH8" },
+    { CV_IA64_IntH9, L"IntH9" },
+    { CV_IA64_IntH10, L"IntH10" },
+    { CV_IA64_IntH11, L"IntH11" },
+    { CV_IA64_IntH12, L"IntH12" },
+    { CV_IA64_IntH13, L"IntH13" },
+    { CV_IA64_IntH14, L"IntH14" },
+    { CV_IA64_IntH15, L"IntH15" },
+    { CV_IA64_Ip, L"Ip" },
+    { CV_IA64_Umask, L"Umask" },
+    { CV_IA64_Cfm, L"Cfm" },
+    { CV_IA64_Psr, L"Psr" },
+    { CV_IA64_Nats, L"Nats" },
+    { CV_IA64_Nats2, L"Nats2" },
+    { CV_IA64_Nats3, L"Nats3" },
+    { CV_IA64_IntR0, L"IntR0" },
+    { CV_IA64_IntR1, L"IntR1" },
+    { CV_IA64_IntR2, L"IntR2" },
+    { CV_IA64_IntR3, L"IntR3" },
+    { CV_IA64_IntR4, L"IntR4" },
+    { CV_IA64_IntR5, L"IntR5" },
+    { CV_IA64_IntR6, L"IntR6" },
+    { CV_IA64_IntR7, L"IntR7" },
+    { CV_IA64_IntR8, L"IntR8" },
+    { CV_IA64_IntR9, L"IntR9" },
+    { CV_IA64_IntR10, L"IntR10" },
+    { CV_IA64_IntR11, L"IntR11" },
+    { CV_IA64_IntR12, L"IntR12" },
+    { CV_IA64_IntR13, L"IntR13" },
+    { CV_IA64_IntR14, L"IntR14" },
+    { CV_IA64_IntR15, L"IntR15" },
+    { CV_IA64_IntR16, L"IntR16" },
+    { CV_IA64_IntR17, L"IntR17" },
+    { CV_IA64_IntR18, L"IntR18" },
+    { CV_IA64_IntR19, L"IntR19" },
+    { CV_IA64_IntR20, L"IntR20" },
+    { CV_IA64_IntR21, L"IntR21" },
+    { CV_IA64_IntR22, L"IntR22" },
+    { CV_IA64_IntR23, L"IntR23" },
+    { CV_IA64_IntR24, L"IntR24" },
+    { CV_IA64_IntR25, L"IntR25" },
+    { CV_IA64_IntR26, L"IntR26" },
+    { CV_IA64_IntR27, L"IntR27" },
+    { CV_IA64_IntR28, L"IntR28" },
+    { CV_IA64_IntR29, L"IntR29" },
+    { CV_IA64_IntR30, L"IntR30" },
+    { CV_IA64_IntR31, L"IntR31" },
+    { CV_IA64_IntR32, L"IntR32" },
+    { CV_IA64_IntR33, L"IntR33" },
+    { CV_IA64_IntR34, L"IntR34" },
+    { CV_IA64_IntR35, L"IntR35" },
+    { CV_IA64_IntR36, L"IntR36" },
+    { CV_IA64_IntR37, L"IntR37" },
+    { CV_IA64_IntR38, L"IntR38" },
+    { CV_IA64_IntR39, L"IntR39" },
+    { CV_IA64_IntR40, L"IntR40" },
+    { CV_IA64_IntR41, L"IntR41" },
+    { CV_IA64_IntR42, L"IntR42" },
+    { CV_IA64_IntR43, L"IntR43" },
+    { CV_IA64_IntR44, L"IntR44" },
+    { CV_IA64_IntR45, L"IntR45" },
+    { CV_IA64_IntR46, L"IntR46" },
+    { CV_IA64_IntR47, L"IntR47" },
+    { CV_IA64_IntR48, L"IntR48" },
+    { CV_IA64_IntR49, L"IntR49" },
+    { CV_IA64_IntR50, L"IntR50" },
+    { CV_IA64_IntR51, L"IntR51" },
+    { CV_IA64_IntR52, L"IntR52" },
+    { CV_IA64_IntR53, L"IntR53" },
+    { CV_IA64_IntR54, L"IntR54" },
+    { CV_IA64_IntR55, L"IntR55" },
+    { CV_IA64_IntR56, L"IntR56" },
+    { CV_IA64_IntR57, L"IntR57" },
+    { CV_IA64_IntR58, L"IntR58" },
+    { CV_IA64_IntR59, L"IntR59" },
+    { CV_IA64_IntR60, L"IntR60" },
+    { CV_IA64_IntR61, L"IntR61" },
+    { CV_IA64_IntR62, L"IntR62" },
+    { CV_IA64_IntR63, L"IntR63" },
+    { CV_IA64_IntR64, L"IntR64" },
+    { CV_IA64_IntR65, L"IntR65" },
+    { CV_IA64_IntR66, L"IntR66" },
+    { CV_IA64_IntR67, L"IntR67" },
+    { CV_IA64_IntR68, L"IntR68" },
+    { CV_IA64_IntR69, L"IntR69" },
+    { CV_IA64_IntR70, L"IntR70" },
+    { CV_IA64_IntR71, L"IntR71" },
+    { CV_IA64_IntR72, L"IntR72" },
+    { CV_IA64_IntR73, L"IntR73" },
+    { CV_IA64_IntR74, L"IntR74" },
+    { CV_IA64_IntR75, L"IntR75" },
+    { CV_IA64_IntR76, L"IntR76" },
+    { CV_IA64_IntR77, L"IntR77" },
+    { CV_IA64_IntR78, L"IntR78" },
+    { CV_IA64_IntR79, L"IntR79" },
+    { CV_IA64_IntR80, L"IntR80" },
+    { CV_IA64_IntR81, L"IntR81" },
+    { CV_IA64_IntR82, L"IntR82" },
+    { CV_IA64_IntR83, L"IntR83" },
+    { CV_IA64_IntR84, L"IntR84" },
+    { CV_IA64_IntR85, L"IntR85" },
+    { CV_IA64_IntR86, L"IntR86" },
+    { CV_IA64_IntR87, L"IntR87" },
+    { CV_IA64_IntR88, L"IntR88" },
+    { CV_IA64_IntR89, L"IntR89" },
+    { CV_IA64_IntR90, L"IntR90" },
+    { CV_IA64_IntR91, L"IntR91" },
+    { CV_IA64_IntR92, L"IntR92" },
+    { CV_IA64_IntR93, L"IntR93" },
+    { CV_IA64_IntR94, L"IntR94" },
+    { CV_IA64_IntR95, L"IntR95" },
+    { CV_IA64_IntR96, L"IntR96" },
+    { CV_IA64_IntR97, L"IntR97" },
+    { CV_IA64_IntR98, L"IntR98" },
+    { CV_IA64_IntR99, L"IntR99" },
+    { CV_IA64_IntR100, L"IntR100" },
+    { CV_IA64_IntR101, L"IntR101" },
+    { CV_IA64_IntR102, L"IntR102" },
+    { CV_IA64_IntR103, L"IntR103" },
+    { CV_IA64_IntR104, L"IntR104" },
+    { CV_IA64_IntR105, L"IntR105" },
+    { CV_IA64_IntR106, L"IntR106" },
+    { CV_IA64_IntR107, L"IntR107" },
+    { CV_IA64_IntR108, L"IntR108" },
+    { CV_IA64_IntR109, L"IntR109" },
+    { CV_IA64_IntR110, L"IntR110" },
+    { CV_IA64_IntR111, L"IntR111" },
+    { CV_IA64_IntR112, L"IntR112" },
+    { CV_IA64_IntR113, L"IntR113" },
+    { CV_IA64_IntR114, L"IntR114" },
+    { CV_IA64_IntR115, L"IntR115" },
+    { CV_IA64_IntR116, L"IntR116" },
+    { CV_IA64_IntR117, L"IntR117" },
+    { CV_IA64_IntR118, L"IntR118" },
+    { CV_IA64_IntR119, L"IntR119" },
+    { CV_IA64_IntR120, L"IntR120" },
+    { CV_IA64_IntR121, L"IntR121" },
+    { CV_IA64_IntR122, L"IntR122" },
+    { CV_IA64_IntR123, L"IntR123" },
+    { CV_IA64_IntR124, L"IntR124" },
+    { CV_IA64_IntR125, L"IntR125" },
+    { CV_IA64_IntR126, L"IntR126" },
+    { CV_IA64_IntR127, L"IntR127" },
+    { CV_IA64_FltF0, L"FltF0" },
+    { CV_IA64_FltF1, L"FltF1" },
+    { CV_IA64_FltF2, L"FltF2" },
+    { CV_IA64_FltF3, L"FltF3" },
+    { CV_IA64_FltF4, L"FltF4" },
+    { CV_IA64_FltF5, L"FltF5" },
+    { CV_IA64_FltF6, L"FltF6" },
+    { CV_IA64_FltF7, L"FltF7" },
+    { CV_IA64_FltF8, L"FltF8" },
+    { CV_IA64_FltF9, L"FltF9" },
+    { CV_IA64_FltF10, L"FltF10" },
+    { CV_IA64_FltF11, L"FltF11" },
+    { CV_IA64_FltF12, L"FltF12" },
+    { CV_IA64_FltF13, L"FltF13" },
+    { CV_IA64_FltF14, L"FltF14" },
+    { CV_IA64_FltF15, L"FltF15" },
+    { CV_IA64_FltF16, L"FltF16" },
+    { CV_IA64_FltF17, L"FltF17" },
+    { CV_IA64_FltF18, L"FltF18" },
+    { CV_IA64_FltF19, L"FltF19" },
+    { CV_IA64_FltF20, L"FltF20" },
+    { CV_IA64_FltF21, L"FltF21" },
+    { CV_IA64_FltF22, L"FltF22" },
+    { CV_IA64_FltF23, L"FltF23" },
+    { CV_IA64_FltF24, L"FltF24" },
+    { CV_IA64_FltF25, L"FltF25" },
+    { CV_IA64_FltF26, L"FltF26" },
+    { CV_IA64_FltF27, L"FltF27" },
+    { CV_IA64_FltF28, L"FltF28" },
+    { CV_IA64_FltF29, L"FltF29" },
+    { CV_IA64_FltF30, L"FltF30" },
+    { CV_IA64_FltF31, L"FltF31" },
+    { CV_IA64_FltF32, L"FltF32" },
+    { CV_IA64_FltF33, L"FltF33" },
+    { CV_IA64_FltF34, L"FltF34" },
+    { CV_IA64_FltF35, L"FltF35" },
+    { CV_IA64_FltF36, L"FltF36" },
+    { CV_IA64_FltF37, L"FltF37" },
+    { CV_IA64_FltF38, L"FltF38" },
+    { CV_IA64_FltF39, L"FltF39" },
+    { CV_IA64_FltF40, L"FltF40" },
+    { CV_IA64_FltF41, L"FltF41" },
+    { CV_IA64_FltF42, L"FltF42" },
+    { CV_IA64_FltF43, L"FltF43" },
+    { CV_IA64_FltF44, L"FltF44" },
+    { CV_IA64_FltF45, L"FltF45" },
+    { CV_IA64_FltF46, L"FltF46" },
+    { CV_IA64_FltF47, L"FltF47" },
+    { CV_IA64_FltF48, L"FltF48" },
+    { CV_IA64_FltF49, L"FltF49" },
+    { CV_IA64_FltF50, L"FltF50" },
+    { CV_IA64_FltF51, L"FltF51" },
+    { CV_IA64_FltF52, L"FltF52" },
+    { CV_IA64_FltF53, L"FltF53" },
+    { CV_IA64_FltF54, L"FltF54" },
+    { CV_IA64_FltF55, L"FltF55" },
+    { CV_IA64_FltF56, L"FltF56" },
+    { CV_IA64_FltF57, L"FltF57" },
+    { CV_IA64_FltF58, L"FltF58" },
+    { CV_IA64_FltF59, L"FltF59" },
+    { CV_IA64_FltF60, L"FltF60" },
+    { CV_IA64_FltF61, L"FltF61" },
+    { CV_IA64_FltF62, L"FltF62" },
+    { CV_IA64_FltF63, L"FltF63" },
+    { CV_IA64_FltF64, L"FltF64" },
+    { CV_IA64_FltF65, L"FltF65" },
+    { CV_IA64_FltF66, L"FltF66" },
+    { CV_IA64_FltF67, L"FltF67" },
+    { CV_IA64_FltF68, L"FltF68" },
+    { CV_IA64_FltF69, L"FltF69" },
+    { CV_IA64_FltF70, L"FltF70" },
+    { CV_IA64_FltF71, L"FltF71" },
+    { CV_IA64_FltF72, L"FltF72" },
+    { CV_IA64_FltF73, L"FltF73" },
+    { CV_IA64_FltF74, L"FltF74" },
+    { CV_IA64_FltF75, L"FltF75" },
+    { CV_IA64_FltF76, L"FltF76" },
+    { CV_IA64_FltF77, L"FltF77" },
+    { CV_IA64_FltF78, L"FltF78" },
+    { CV_IA64_FltF79, L"FltF79" },
+    { CV_IA64_FltF80, L"FltF80" },
+    { CV_IA64_FltF81, L"FltF81" },
+    { CV_IA64_FltF82, L"FltF82" },
+    { CV_IA64_FltF83, L"FltF83" },
+    { CV_IA64_FltF84, L"FltF84" },
+    { CV_IA64_FltF85, L"FltF85" },
+    { CV_IA64_FltF86, L"FltF86" },
+    { CV_IA64_FltF87, L"FltF87" },
+    { CV_IA64_FltF88, L"FltF88" },
+    { CV_IA64_FltF89, L"FltF89" },
+    { CV_IA64_FltF90, L"FltF90" },
+    { CV_IA64_FltF91, L"FltF91" },
+    { CV_IA64_FltF92, L"FltF92" },
+    { CV_IA64_FltF93, L"FltF93" },
+    { CV_IA64_FltF94, L"FltF94" },
+    { CV_IA64_FltF95, L"FltF95" },
+    { CV_IA64_FltF96, L"FltF96" },
+    { CV_IA64_FltF97, L"FltF97" },
+    { CV_IA64_FltF98, L"FltF98" },
+    { CV_IA64_FltF99, L"FltF99" },
+    { CV_IA64_FltF100, L"FltF100" },
+    { CV_IA64_FltF101, L"FltF101" },
+    { CV_IA64_FltF102, L"FltF102" },
+    { CV_IA64_FltF103, L"FltF103" },
+    { CV_IA64_FltF104, L"FltF104" },
+    { CV_IA64_FltF105, L"FltF105" },
+    { CV_IA64_FltF106, L"FltF106" },
+    { CV_IA64_FltF107, L"FltF107" },
+    { CV_IA64_FltF108, L"FltF108" },
+    { CV_IA64_FltF109, L"FltF109" },
+    { CV_IA64_FltF110, L"FltF110" },
+    { CV_IA64_FltF111, L"FltF111" },
+    { CV_IA64_FltF112, L"FltF112" },
+    { CV_IA64_FltF113, L"FltF113" },
+    { CV_IA64_FltF114, L"FltF114" },
+    { CV_IA64_FltF115, L"FltF115" },
+    { CV_IA64_FltF116, L"FltF116" },
+    { CV_IA64_FltF117, L"FltF117" },
+    { CV_IA64_FltF118, L"FltF118" },
+    { CV_IA64_FltF119, L"FltF119" },
+    { CV_IA64_FltF120, L"FltF120" },
+    { CV_IA64_FltF121, L"FltF121" },
+    { CV_IA64_FltF122, L"FltF122" },
+    { CV_IA64_FltF123, L"FltF123" },
+    { CV_IA64_FltF124, L"FltF124" },
+    { CV_IA64_FltF125, L"FltF125" },
+    { CV_IA64_FltF126, L"FltF126" },
+    { CV_IA64_FltF127, L"FltF127" },
+    { CV_IA64_ApKR0, L"ApKR0" },
+    { CV_IA64_ApKR1, L"ApKR1" },
+    { CV_IA64_ApKR2, L"ApKR2" },
+    { CV_IA64_ApKR3, L"ApKR3" },
+    { CV_IA64_ApKR4, L"ApKR4" },
+    { CV_IA64_ApKR5, L"ApKR5" },
+    { CV_IA64_ApKR6, L"ApKR6" },
+    { CV_IA64_ApKR7, L"ApKR7" },
+    { CV_IA64_AR8, L"AR8" },
+    { CV_IA64_AR9, L"AR9" },
+    { CV_IA64_AR10, L"AR10" },
+    { CV_IA64_AR11, L"AR11" },
+    { CV_IA64_AR12, L"AR12" },
+    { CV_IA64_AR13, L"AR13" },
+    { CV_IA64_AR14, L"AR14" },
+    { CV_IA64_AR15, L"AR15" },
+    { CV_IA64_RsRSC, L"RsRSC" },
+    { CV_IA64_RsBSP, L"RsBSP" },
+    { CV_IA64_RsBSPSTORE, L"RsBSPSTORE" },
+    { CV_IA64_RsRNAT, L"RsRNAT" },
+    { CV_IA64_AR20, L"AR20" },
+    { CV_IA64_StFCR, L"StFCR" },
+    { CV_IA64_AR22, L"AR22" },
+    { CV_IA64_AR23, L"AR23" },
+    { CV_IA64_EFLAG, L"EFLAG" },
+    { CV_IA64_CSD, L"CSD" },
+    { CV_IA64_SSD, L"SSD" },
+    { CV_IA64_CFLG, L"CFLG" },
+    { CV_IA64_StFSR, L"StFSR" },
+    { CV_IA64_StFIR, L"StFIR" },
+    { CV_IA64_StFDR, L"StFDR" },
+    { CV_IA64_AR31, L"AR31" },
+    { CV_IA64_ApCCV, L"ApCCV" },
+    { CV_IA64_AR33, L"AR33" },
+    { CV_IA64_AR34, L"AR34" },
+    { CV_IA64_AR35, L"AR35" },
+    { CV_IA64_ApUNAT, L"ApUNAT" },
+    { CV_IA64_AR37, L"AR37" },
+    { CV_IA64_AR38, L"AR38" },
+    { CV_IA64_AR39, L"AR39" },
+    { CV_IA64_StFPSR, L"StFPSR" },
+    { CV_IA64_AR41, L"AR41" },
+    { CV_IA64_AR42, L"AR42" },
+    { CV_IA64_AR43, L"AR43" },
+    { CV_IA64_ApITC, L"ApITC" },
+    { CV_IA64_AR45, L"AR45" },
+    { CV_IA64_AR46, L"AR46" },
+    { CV_IA64_AR47, L"AR47" },
+    { CV_IA64_AR48, L"AR48" },
+    { CV_IA64_AR49, L"AR49" },
+    { CV_IA64_AR50, L"AR50" },
+    { CV_IA64_AR51, L"AR51" },
+    { CV_IA64_AR52, L"AR52" },
+    { CV_IA64_AR53, L"AR53" },
+    { CV_IA64_AR54, L"AR54" },
+    { CV_IA64_AR55, L"AR55" },
+    { CV_IA64_AR56, L"AR56" },
+    { CV_IA64_AR57, L"AR57" },
+    { CV_IA64_AR58, L"AR58" },
+    { CV_IA64_AR59, L"AR59" },
+    { CV_IA64_AR60, L"AR60" },
+    { CV_IA64_AR61, L"AR61" },
+    { CV_IA64_AR62, L"AR62" },
+    { CV_IA64_AR63, L"AR63" },
+    { CV_IA64_RsPFS, L"RsPFS" },
+    { CV_IA64_ApLC, L"ApLC" },
+    { CV_IA64_ApEC, L"ApEC" },
+    { CV_IA64_AR67, L"AR67" },
+    { CV_IA64_AR68, L"AR68" },
+    { CV_IA64_AR69, L"AR69" },
+    { CV_IA64_AR70, L"AR70" },
+    { CV_IA64_AR71, L"AR71" },
+    { CV_IA64_AR72, L"AR72" },
+    { CV_IA64_AR73, L"AR73" },
+    { CV_IA64_AR74, L"AR74" },
+    { CV_IA64_AR75, L"AR75" },
+    { CV_IA64_AR76, L"AR76" },
+    { CV_IA64_AR77, L"AR77" },
+    { CV_IA64_AR78, L"AR78" },
+    { CV_IA64_AR79, L"AR79" },
+    { CV_IA64_AR80, L"AR80" },
+    { CV_IA64_AR81, L"AR81" },
+    { CV_IA64_AR82, L"AR82" },
+    { CV_IA64_AR83, L"AR83" },
+    { CV_IA64_AR84, L"AR84" },
+    { CV_IA64_AR85, L"AR85" },
+    { CV_IA64_AR86, L"AR86" },
+    { CV_IA64_AR87, L"AR87" },
+    { CV_IA64_AR88, L"AR88" },
+    { CV_IA64_AR89, L"AR89" },
+    { CV_IA64_AR90, L"AR90" },
+    { CV_IA64_AR91, L"AR91" },
+    { CV_IA64_AR92, L"AR92" },
+    { CV_IA64_AR93, L"AR93" },
+    { CV_IA64_AR94, L"AR94" },
+    { CV_IA64_AR95, L"AR95" },
+    { CV_IA64_AR96, L"AR96" },
+    { CV_IA64_AR97, L"AR97" },
+    { CV_IA64_AR98, L"AR98" },
+    { CV_IA64_AR99, L"AR99" },
+    { CV_IA64_AR100, L"AR100" },
+    { CV_IA64_AR101, L"AR101" },
+    { CV_IA64_AR102, L"AR102" },
+    { CV_IA64_AR103, L"AR103" },
+    { CV_IA64_AR104, L"AR104" },
+    { CV_IA64_AR105, L"AR105" },
+    { CV_IA64_AR106, L"AR106" },
+    { CV_IA64_AR107, L"AR107" },
+    { CV_IA64_AR108, L"AR108" },
+    { CV_IA64_AR109, L"AR109" },
+    { CV_IA64_AR110, L"AR110" },
+    { CV_IA64_AR111, L"AR111" },
+    { CV_IA64_AR112, L"AR112" },
+    { CV_IA64_AR113, L"AR113" },
+    { CV_IA64_AR114, L"AR114" },
+    { CV_IA64_AR115, L"AR115" },
+    { CV_IA64_AR116, L"AR116" },
+    { CV_IA64_AR117, L"AR117" },
+    { CV_IA64_AR118, L"AR118" },
+    { CV_IA64_AR119, L"AR119" },
+    { CV_IA64_AR120, L"AR120" },
+    { CV_IA64_AR121, L"AR121" },
+    { CV_IA64_AR122, L"AR122" },
+    { CV_IA64_AR123, L"AR123" },
+    { CV_IA64_AR124, L"AR124" },
+    { CV_IA64_AR125, L"AR125" },
+    { CV_IA64_AR126, L"AR126" },
+    { CV_IA64_AR127, L"AR127" },
+    { CV_IA64_ApDCR, L"ApDCR" },
+    { CV_IA64_ApITM, L"ApITM" },
+    { CV_IA64_ApIVA, L"ApIVA" },
+    { CV_IA64_CR3, L"CR3" },
+    { CV_IA64_CR4, L"CR4" },
+    { CV_IA64_CR5, L"CR5" },
+    { CV_IA64_CR6, L"CR6" },
+    { CV_IA64_CR7, L"CR7" },
+    { CV_IA64_ApPTA, L"ApPTA" },
+    { CV_IA64_ApGPTA, L"ApGPTA" },
+    { CV_IA64_CR10, L"CR10" },
+    { CV_IA64_CR11, L"CR11" },
+    { CV_IA64_CR12, L"CR12" },
+    { CV_IA64_CR13, L"CR13" },
+    { CV_IA64_CR14, L"CR14" },
+    { CV_IA64_CR15, L"CR15" },
+    { CV_IA64_StIPSR, L"StIPSR" },
+    { CV_IA64_StISR, L"StISR" },
+    { CV_IA64_CR18, L"CR18" },
+    { CV_IA64_StIIP, L"StIIP" },
+    { CV_IA64_StIFA, L"StIFA" },
+    { CV_IA64_StITIR, L"StITIR" },
+    { CV_IA64_StIIPA, L"StIIPA" },
+    { CV_IA64_StIFS, L"StIFS" },
+    { CV_IA64_StIIM, L"StIIM" },
+    { CV_IA64_StIHA, L"StIHA" },
+    { CV_IA64_CR26, L"CR26" },
+    { CV_IA64_CR27, L"CR27" },
+    { CV_IA64_CR28, L"CR28" },
+    { CV_IA64_CR29, L"CR29" },
+    { CV_IA64_CR30, L"CR30" },
+    { CV_IA64_CR31, L"CR31" },
+    { CV_IA64_CR32, L"CR32" },
+    { CV_IA64_CR33, L"CR33" },
+    { CV_IA64_CR34, L"CR34" },
+    { CV_IA64_CR35, L"CR35" },
+    { CV_IA64_CR36, L"CR36" },
+    { CV_IA64_CR37, L"CR37" },
+    { CV_IA64_CR38, L"CR38" },
+    { CV_IA64_CR39, L"CR39" },
+    { CV_IA64_CR40, L"CR40" },
+    { CV_IA64_CR41, L"CR41" },
+    { CV_IA64_CR42, L"CR42" },
+    { CV_IA64_CR43, L"CR43" },
+    { CV_IA64_CR44, L"CR44" },
+    { CV_IA64_CR45, L"CR45" },
+    { CV_IA64_CR46, L"CR46" },
+    { CV_IA64_CR47, L"CR47" },
+    { CV_IA64_CR48, L"CR48" },
+    { CV_IA64_CR49, L"CR49" },
+    { CV_IA64_CR50, L"CR50" },
+    { CV_IA64_CR51, L"CR51" },
+    { CV_IA64_CR52, L"CR52" },
+    { CV_IA64_CR53, L"CR53" },
+    { CV_IA64_CR54, L"CR54" },
+    { CV_IA64_CR55, L"CR55" },
+    { CV_IA64_CR56, L"CR56" },
+    { CV_IA64_CR57, L"CR57" },
+    { CV_IA64_CR58, L"CR58" },
+    { CV_IA64_CR59, L"CR59" },
+    { CV_IA64_CR60, L"CR60" },
+    { CV_IA64_CR61, L"CR61" },
+    { CV_IA64_CR62, L"CR62" },
+    { CV_IA64_CR63, L"CR63" },
+    { CV_IA64_SaLID, L"SaLID" },
+    { CV_IA64_SaIVR, L"SaIVR" },
+    { CV_IA64_SaTPR, L"SaTPR" },
+    { CV_IA64_SaEOI, L"SaEOI" },
+    { CV_IA64_SaIRR0, L"SaIRR0" },
+    { CV_IA64_SaIRR1, L"SaIRR1" },
+    { CV_IA64_SaIRR2, L"SaIRR2" },
+    { CV_IA64_SaIRR3, L"SaIRR3" },
+    { CV_IA64_SaITV, L"SaITV" },
+    { CV_IA64_SaPMV, L"SaPMV" },
+    { CV_IA64_SaCMCV, L"SaCMCV" },
+    { CV_IA64_CR75, L"CR75" },
+    { CV_IA64_CR76, L"CR76" },
+    { CV_IA64_CR77, L"CR77" },
+    { CV_IA64_CR78, L"CR78" },
+    { CV_IA64_CR79, L"CR79" },
+    { CV_IA64_SaLRR0, L"SaLRR0" },
+    { CV_IA64_SaLRR1, L"SaLRR1" },
+    { CV_IA64_CR82, L"CR82" },
+    { CV_IA64_CR83, L"CR83" },
+    { CV_IA64_CR84, L"CR84" },
+    { CV_IA64_CR85, L"CR85" },
+    { CV_IA64_CR86, L"CR86" },
+    { CV_IA64_CR87, L"CR87" },
+    { CV_IA64_CR88, L"CR88" },
+    { CV_IA64_CR89, L"CR89" },
+    { CV_IA64_CR90, L"CR90" },
+    { CV_IA64_CR91, L"CR91" },
+    { CV_IA64_CR92, L"CR92" },
+    { CV_IA64_CR93, L"CR93" },
+    { CV_IA64_CR94, L"CR94" },
+    { CV_IA64_CR95, L"CR95" },
+    { CV_IA64_SaIRR0, L"SaIRR0" },
+    { CV_IA64_CR97, L"CR97" },
+    { CV_IA64_SaIRR1, L"SaIRR1" },
+    { CV_IA64_CR99, L"CR99" },
+    { CV_IA64_SaIRR2, L"SaIRR2" },
+    { CV_IA64_CR101, L"CR101" },
+    { CV_IA64_SaIRR3, L"SaIRR3" },
+    { CV_IA64_CR103, L"CR103" },
+    { CV_IA64_CR104, L"CR104" },
+    { CV_IA64_CR105, L"CR105" },
+    { CV_IA64_CR106, L"CR106" },
+    { CV_IA64_CR107, L"CR107" },
+    { CV_IA64_CR108, L"CR108" },
+    { CV_IA64_CR109, L"CR109" },
+    { CV_IA64_CR110, L"CR110" },
+    { CV_IA64_CR111, L"CR111" },
+    { CV_IA64_CR112, L"CR112" },
+    { CV_IA64_CR113, L"CR113" },
+    { CV_IA64_SaITV, L"SaITV" },
+    { CV_IA64_CR115, L"CR115" },
+    { CV_IA64_SaPMV, L"SaPMV" },
+    { CV_IA64_SaLRR0, L"SaLRR0" },
+    { CV_IA64_SaLRR1, L"SaLRR1" },
+    { CV_IA64_SaCMCV, L"SaCMCV" },
+    { CV_IA64_CR120, L"CR120" },
+    { CV_IA64_CR121, L"CR121" },
+    { CV_IA64_CR122, L"CR122" },
+    { CV_IA64_CR123, L"CR123" },
+    { CV_IA64_CR124, L"CR124" },
+    { CV_IA64_CR125, L"CR125" },
+    { CV_IA64_CR126, L"CR126" },
+    { CV_IA64_CR127, L"CR127" },
+    { CV_IA64_Pkr0, L"Pkr0" },
+    { CV_IA64_Pkr1, L"Pkr1" },
+    { CV_IA64_Pkr2, L"Pkr2" },
+    { CV_IA64_Pkr3, L"Pkr3" },
+    { CV_IA64_Pkr4, L"Pkr4" },
+    { CV_IA64_Pkr5, L"Pkr5" },
+    { CV_IA64_Pkr6, L"Pkr6" },
+    { CV_IA64_Pkr7, L"Pkr7" },
+    { CV_IA64_Pkr8, L"Pkr8" },
+    { CV_IA64_Pkr9, L"Pkr9" },
+    { CV_IA64_Pkr10, L"Pkr10" },
+    { CV_IA64_Pkr11, L"Pkr11" },
+    { CV_IA64_Pkr12, L"Pkr12" },
+    { CV_IA64_Pkr13, L"Pkr13" },
+    { CV_IA64_Pkr14, L"Pkr14" },
+    { CV_IA64_Pkr15, L"Pkr15" },
+    { CV_IA64_Rr0, L"Rr0" },
+    { CV_IA64_Rr1, L"Rr1" },
+    { CV_IA64_Rr2, L"Rr2" },
+    { CV_IA64_Rr3, L"Rr3" },
+    { CV_IA64_Rr4, L"Rr4" },
+    { CV_IA64_Rr5, L"Rr5" },
+    { CV_IA64_Rr6, L"Rr6" },
+    { CV_IA64_Rr7, L"Rr7" },
+    { CV_IA64_PFD0, L"PFD0" },
+    { CV_IA64_PFD1, L"PFD1" },
+    { CV_IA64_PFD2, L"PFD2" },
+    { CV_IA64_PFD3, L"PFD3" },
+    { CV_IA64_PFD4, L"PFD4" },
+    { CV_IA64_PFD5, L"PFD5" },
+    { CV_IA64_PFD6, L"PFD6" },
+    { CV_IA64_PFD7, L"PFD7" },
+    { CV_IA64_PFC0, L"PFC0" },
+    { CV_IA64_PFC1, L"PFC1" },
+    { CV_IA64_PFC2, L"PFC2" },
+    { CV_IA64_PFC3, L"PFC3" },
+    { CV_IA64_PFC4, L"PFC4" },
+    { CV_IA64_PFC5, L"PFC5" },
+    { CV_IA64_PFC6, L"PFC6" },
+    { CV_IA64_PFC7, L"PFC7" },
+    { CV_IA64_TrI0, L"TrI0" },
+    { CV_IA64_TrI1, L"TrI1" },
+    { CV_IA64_TrI2, L"TrI2" },
+    { CV_IA64_TrI3, L"TrI3" },
+    { CV_IA64_TrI4, L"TrI4" },
+    { CV_IA64_TrI5, L"TrI5" },
+    { CV_IA64_TrI6, L"TrI6" },
+    { CV_IA64_TrI7, L"TrI7" },
+    { CV_IA64_TrD0, L"TrD0" },
+    { CV_IA64_TrD1, L"TrD1" },
+    { CV_IA64_TrD2, L"TrD2" },
+    { CV_IA64_TrD3, L"TrD3" },
+    { CV_IA64_TrD4, L"TrD4" },
+    { CV_IA64_TrD5, L"TrD5" },
+    { CV_IA64_TrD6, L"TrD6" },
+    { CV_IA64_TrD7, L"TrD7" },
+    { CV_IA64_DbI0, L"DbI0" },
+    { CV_IA64_DbI1, L"DbI1" },
+    { CV_IA64_DbI2, L"DbI2" },
+    { CV_IA64_DbI3, L"DbI3" },
+    { CV_IA64_DbI4, L"DbI4" },
+    { CV_IA64_DbI5, L"DbI5" },
+    { CV_IA64_DbI6, L"DbI6" },
+    { CV_IA64_DbI7, L"DbI7" },
+    { CV_IA64_DbD0, L"DbD0" },
+    { CV_IA64_DbD1, L"DbD1" },
+    { CV_IA64_DbD2, L"DbD2" },
+    { CV_IA64_DbD3, L"DbD3" },
+    { CV_IA64_DbD4, L"DbD4" },
+    { CV_IA64_DbD5, L"DbD5" },
+    { CV_IA64_DbD6, L"DbD6" },
+    { CV_IA64_DbD7, L"DbD7" }
+};
+
+////////////////////////////////////////////////////////////
+// Map an IA64 registry ID with the corresponding string name
+//
+int __cdecl cmpIa64regSz(const void *pv1, const void *pv2) {
+  const MapIa64Reg *p1 = (MapIa64Reg *) pv1;
+  const MapIa64Reg *p2 = (MapIa64Reg *) pv2;
+  
+  if(p1->iCvReg < p2->iCvReg){
+    return -1;
+  }
+  if(p1->iCvReg > p2->iCvReg){
+    return 1;
+  }
+  return 0;
+}
+
+////////////////////////////////////////////////////////////
+// Map a registry id code with the corresponding string name
+//
+const wchar_t* SzNameC7Reg(USHORT reg, DWORD MachineType){
+  static wchar_t wszRegNum[64];
+  
+	switch(reg){
+		case CV_ALLREG_LOCALS : return L"BaseOfLocals";
+		case CV_ALLREG_PARAMS : return L"BaseOfParams";
+		case CV_ALLREG_VFRAME : return L"VFrame";
+	}
+  swprintf_s(wszRegNum, L"???(0x%x)", reg);
+  switch(MachineType) {
+    case CV_CFL_8080:
+    case CV_CFL_8086:
+    case CV_CFL_80286:
+    case CV_CFL_80386:
+    case CV_CFL_80486:
+    case CV_CFL_PENTIUM:
+      if(reg < (sizeof(rgRegX86)/sizeof(*rgRegX86))){
+        return(rgRegX86[reg]);
+      }
+      return wszRegNum;
+      break;
+    case CV_CFL_ALPHA:
+      if(reg < (sizeof(rgRegAlpha)/sizeof(*rgRegAlpha))){
+        return(rgRegAlpha[reg]);
+      }
+      return wszRegNum;
+      break;
+    case CV_CFL_MIPSR4000:
+    case CV_CFL_MIPS16:
+      if(reg < (sizeof(rgRegMips)/sizeof(*rgRegMips))) {
+        return(rgRegMips[reg]);
+      }
+      return wszRegNum;
+      break;
+    case CV_CFL_M68000:
+    case CV_CFL_M68010:
+    case CV_CFL_M68020:
+    case CV_CFL_M68030:
+    case CV_CFL_M68040:
+      if(reg < (sizeof(rgReg68k)/sizeof(*rgReg68k))){
+        return(rgReg68k[reg]);
+      }
+      return wszRegNum;
+      break;
+    case CV_CFL_PPC601:
+    case CV_CFL_PPC603:
+    case CV_CFL_PPC604:
+    case CV_CFL_PPC620:
+      if(reg < (sizeof(rgRegPpc)/sizeof(*rgRegPpc))){
+        return(rgRegPpc[reg]);
+      }
+      return wszRegNum;
+      break;
+    case CV_CFL_SH3:
+      if(reg < (sizeof(rgRegSh)/sizeof(*rgRegSh))){
+        return(rgRegSh[reg]);
+      }
+      return wszRegNum;
+      break;
+    case CV_CFL_ARM3:
+    case CV_CFL_ARM4:
+    case CV_CFL_ARM4T:
+      if(reg < (sizeof(rgRegArm)/sizeof(*rgRegArm))){
+        return(rgRegArm[reg]);
+      }
+      return wszRegNum;
+      break;
+    case CV_CFL_IA64: {
+      MapIa64Reg *p;
+      MapIa64Reg  m = {(CV_HREG_e) reg};
+      p = (MapIa64Reg *) bsearch(&m,
+                                 mpIa64regSz,
+                                 sizeof(mpIa64regSz)/sizeof(*mpIa64regSz),
+                                 sizeof(MapIa64Reg),
+                                 cmpIa64regSz);
+      if (p) {
+        return p->wszRegName;
+      }else{
+        return wszRegNum;
+      }
+      break;
+    }
+    case CV_CFL_AMD64 :
+      if (reg < sizeof(rgRegAMD64)/sizeof(*rgRegAMD64)) {
+        return rgRegAMD64[reg];
+      }else{
+        return wszRegNum;
+      }
+      break;
+    default:
+      return wszRegNum;
+      break;
+  }
+}
+
+const wchar_t* SzNameC7Reg(USHORT reg){
+    return SzNameC7Reg(reg, g_dwMachineType);
+}
+
diff --git a/src/ToolBox/PdbTypeMatch/regs.h b/src/ToolBox/PdbTypeMatch/regs.h
new file mode 100644
index 0000000000..85d67c66ac
--- /dev/null
+++ b/src/ToolBox/PdbTypeMatch/regs.h
@@ -0,0 +1,19 @@
+extern const wchar_t * const rgRegX86[];
+extern const wchar_t * const rgRegAMD64[];
+extern const wchar_t * const rgRegMips[];
+extern const wchar_t * const rgReg68k[];
+extern const wchar_t * const rgRegAlpha[];
+extern const wchar_t * const rgRegPpc[];
+extern const wchar_t * const rgRegSh[];
+extern const wchar_t * const rgRegArm[];
+
+typedef struct MapIa64Reg{
+    CV_HREG_e  iCvReg;
+    const wchar_t* wszRegName;
+}MapIa64Reg;
+extern const MapIa64Reg mpIa64regSz[];
+int __cdecl cmpIa64regSz( const void* , const void* );
+
+extern DWORD g_dwMachineType;
+const wchar_t* SzNameC7Reg( USHORT , DWORD );
+const wchar_t* SzNameC7Reg( USHORT );
diff --git a/src/ToolBox/PdbTypeMatch/stdafx.cpp b/src/ToolBox/PdbTypeMatch/stdafx.cpp
new file mode 100644
index 0000000000..56e618785b
--- /dev/null
+++ b/src/ToolBox/PdbTypeMatch/stdafx.cpp
@@ -0,0 +1,6 @@
+// stdafx.obj will contain the pre-compiled type information
+
+#include "stdafx.h"
+
+// TODO: reference any additional headers you need in STDAFX.H
+// and not in this file
diff --git a/src/ToolBox/PdbTypeMatch/stdafx.h b/src/ToolBox/PdbTypeMatch/stdafx.h
new file mode 100644
index 0000000000..7b7ebb2904
--- /dev/null
+++ b/src/ToolBox/PdbTypeMatch/stdafx.h
@@ -0,0 +1,22 @@
+// stdafx.h : include file for standard system include files,
+// or project specific include files that are used frequently, but
+// are changed infrequently
+//
+
+#pragma once
+
+
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN		// Exclude rarely-used stuff from Windows headers
+#endif
+
+#include <stdio.h>
+#include <tchar.h>
+#include <string.h>
+#include <comdef.h>
+
+#define _WIN32_FUSION 0x0100 // this causes activation context 
+
+// TODO: reference additional headers your program requires here
+#include "dia2.h"
+
diff --git a/src/ToolBox/SOS/diasdk/diasdk.nativeproj b/src/ToolBox/SOS/diasdk/diasdk.nativeproj
index 4e460a216b..230e2d9f93 100644
--- a/src/ToolBox/SOS/diasdk/diasdk.nativeproj
+++ b/src/ToolBox/SOS/diasdk/diasdk.nativeproj
@@ -15,19 +15,29 @@
         $(VCToolsIncPath)</UserIncludes>
     <MidlTlbDir>$(IntermediateOutputDirectory)</MidlTlbDir>
     <TlbImportFlags>/namespace:Dia /unsafe</TlbImportFlags>
-    <BinplaceSymbols>false</BinplaceSymbols>
   </PropertyGroup>
-  
+
   <ItemGroup>
     <Idl Include="$(VCToolsIncPath)\dia2.idl" />
-
     <PublishPartLinked  Include="$(IntermediateOutputDirectory)\dialib.dll">
       <Visibility>Intra</Visibility>
       <FileType>Binary</FileType>      
     </PublishPartLinked>
+  </ItemGroup>
 
+  <ItemGroup>
+    <RCResourceFile Include="native.rc" />
   </ItemGroup>
+
   <!--Leaf Project Items-->
   <!--Import the targets-->
   <Import Project="$(_NTDRIVE)$(_NTROOT)\ndp\clr\clr.targets" />
+
+  <PropertyGroup>
+    <BuildLinkedDependsOn>
+      $(BuildLinkedDependsOn)
+      PlaceSymbols
+    </BuildLinkedDependsOn>
+  </PropertyGroup>
+
 </Project>
diff --git a/src/ToolBox/SOS/diasdk/native.rc b/src/ToolBox/SOS/diasdk/native.rc
new file mode 100644
index 0000000000..c4474f2ae4
--- /dev/null
+++ b/src/ToolBox/SOS/diasdk/native.rc
@@ -0,0 +1,4 @@
+#define FX_VER_FILEDESCRIPTION_STR "Microsoft\0"
+
+#include <fxver.h>
+#include <fxver.rc>
diff --git a/src/ToolBox/SOS/dirs.proj b/src/ToolBox/SOS/dirs.proj
index e1ec0c6c4b..028d4c27cb 100644
--- a/src/ToolBox/SOS/dirs.proj
+++ b/src/ToolBox/SOS/dirs.proj
@@ -14,8 +14,12 @@
   </ItemGroup>
 
   <ItemGroup Condition="'$(BuildExePhase)' == '1' and '$(BuildArchitecture)' == 'i386' and '$(FeatureCoreClr)' != 'true'">
-    <ProjectFile Include="diasdk\diasdk.nativeproj" />
-    <ProjectFile Include="dactablegen\dactablegen.csproj" />
+    <ProjectFile Include="diasdk\diasdk.nativeproj" >
+        <ProductGroups>FX;PK</ProductGroups>
+    </ProjectFile>
+    <ProjectFile Include="dactablegen\dactablegen.csproj" >
+        <ProductGroups>FX;PK</ProductGroups>
+    </ProjectFile>
   </ItemGroup>
   
   <Import Project="$(_NTDRIVE)$(_NTROOT)\tools\Microsoft.DevDiv.Traversal.targets" />
diff --git a/src/ToolBox/dirs.proj b/src/ToolBox/dirs.proj
index b4c4137bad..bd47b72875 100644
--- a/src/ToolBox/dirs.proj
+++ b/src/ToolBox/dirs.proj
@@ -77,6 +77,9 @@
     <ProjectFile Include="winmdexp\dirs.proj" />
     <ProjectFile Include="winverify\dirs.proj" />
     <ProjectFile Include="wpf\wpf.proj" Condition="'$(BuildArchitecture)' == 'i386' or '$(BuildArchitecture)' == 'amd64'" />
+    <ProjectFile Include="PdbTypeMatch\PdbTypeMatch.nativeproj" Condition="'$(BuildArchitecture)' == 'i386' and '$(_BuildType)' == 'ret'" >
+        <ProductGroups>PK</ProductGroups>
+    </ProjectFile>
   </ItemGroup>
   
   <!--The following projects will build during PHASE 1 of the CoreCLR build-->
diff --git a/src/tools/GenClrDebugResource/GenClrDebugResource.nativeproj b/src/tools/GenClrDebugResource/GenClrDebugResource.nativeproj
index d5ce2158ca..9bd544d8d0 100644
--- a/src/tools/GenClrDebugResource/GenClrDebugResource.nativeproj
+++ b/src/tools/GenClrDebugResource/GenClrDebugResource.nativeproj
@@ -10,7 +10,6 @@
     <OutputName>GenClrDebugResource</OutputName>
     <TargetType>PROGRAM</TargetType>
     <LinkSubsystem>console</LinkSubsystem>
-    <BinplaceSymbols>false</BinplaceSymbols>
     <LinkGenerateManifest>true</LinkGenerateManifest>
     <LinkAdditionalOptions>$(LinkAdditionalOptions) /MANIFEST</LinkAdditionalOptions>
     <UseMsvcrt>false</UseMsvcrt>
@@ -19,6 +18,9 @@
   <ItemGroup>
     <CppCompile Include="GenClrDebugResource.cpp" />
   </ItemGroup>
+  <ItemGroup>
+    <RCResourceFile Include="native.rc" />
+  </ItemGroup>
   <!--Import the targets-->
   <Import Project="$(_NTDRIVE)$(_NTROOT)\ndp\clr\clr.targets" />
 </Project>
\ No newline at end of file
diff --git a/src/tools/GenClrDebugResource/native.rc b/src/tools/GenClrDebugResource/native.rc
new file mode 100644
index 0000000000..c4474f2ae4
--- /dev/null
+++ b/src/tools/GenClrDebugResource/native.rc
@@ -0,0 +1,4 @@
+#define FX_VER_FILEDESCRIPTION_STR "Microsoft\0"
+
+#include <fxver.h>
+#include <fxver.rc>
diff --git a/src/tools/InjectResource/InjectResource.nativeproj b/src/tools/InjectResource/InjectResource.nativeproj
index fc77425a2e..057d01f4ec 100644
--- a/src/tools/InjectResource/InjectResource.nativeproj
+++ b/src/tools/InjectResource/InjectResource.nativeproj
@@ -10,7 +10,7 @@
     <OutputName>InjectResource</OutputName>
     <TargetType>PROGRAM</TargetType>
     <LinkSubsystem>console</LinkSubsystem>
-    <BinplaceSymbols>false</BinplaceSymbols>
+    <BinplaceSymbols>true</BinplaceSymbols>
     <LinkGenerateManifest>true</LinkGenerateManifest>
     <LinkAdditionalOptions>$(LinkAdditionalOptions) /MANIFEST</LinkAdditionalOptions>
     <UseMsvcrt>false</UseMsvcrt>
@@ -19,6 +19,9 @@
   <ItemGroup>
     <CppCompile Include="InjectResource.cpp" />
   </ItemGroup>
+  <ItemGroup>
+    <RCResourceFile Include="native.rc" />
+  </ItemGroup>
   <!--Import the targets-->
   <Import Project="$(_NTDRIVE)$(_NTROOT)\ndp\clr\clr.targets" />
 </Project>
\ No newline at end of file
diff --git a/src/tools/InjectResource/native.rc b/src/tools/InjectResource/native.rc
new file mode 100644
index 0000000000..c4474f2ae4
--- /dev/null
+++ b/src/tools/InjectResource/native.rc
@@ -0,0 +1,4 @@
+#define FX_VER_FILEDESCRIPTION_STR "Microsoft\0"
+
+#include <fxver.h>
+#include <fxver.rc>
diff --git a/src/tools/dirs.proj b/src/tools/dirs.proj
index 2a17d6d703..21f28331ca 100644
--- a/src/tools/dirs.proj
+++ b/src/tools/dirs.proj
@@ -48,7 +48,12 @@
     <ProjectFile Include="McjProfofileUtil\McjProfileUtil.csproj" Condition="'$(BuildArchitecture)' != 'arm' and '$(BuildArchitecture)' != 'arm64'" />
     <ProjectFile Include="winphoneintegrate\winphoneintegrate.csproj" />
     <ProjectFile Include="crossgen\crossgen.nativeproj" />
-    <ProjectFile Include="GenClrDebugResource\GenClrDebugResource.nativeproj" />
+    <ProjectFile Include="GenClrDebugResource\GenClrDebugResource.nativeproj" >
+        <ProductGroups>FX;PK</ProductGroups>
+    </ProjectFile>
+    <ProjectFile Include="InjectResource\InjectResource.nativeproj" Condition="'$(BuildArchitecture)' == 'i386'">
+        <ProductGroups>FX;PK</ProductGroups>
+    </ProjectFile>
   </ItemGroup>
   
   <!-- CoreClr -->