From 62849f08ea5f3c7829b8af520d2504a21b978bfb Mon Sep 17 00:00:00 2001
From: Rafael Rivera <rafael@withinwindows.com>
Date: Wed, 21 Aug 2024 12:28:21 -0700
Subject: [PATCH] Update dependencies (#25)

---
 .github/README.md                   |     4 +-
 .metadata/generate.proj             |     2 +-
 .metadata/options.rsp               |     2 +
 .windows/winmd/Microsoft.Dia.winmd  |   Bin 139776 -> 142848 bytes
 Cargo.toml                          |    19 +-
 crates/samples/checksum/Cargo.toml  |     2 +-
 crates/samples/checksum/src/main.rs |     5 +-
 crates/samples/functions/Cargo.toml |     2 +-
 src/bindings.rs                     | 44047 ++++----------------------
 9 files changed, 5324 insertions(+), 38759 deletions(-)

diff --git a/.github/README.md b/.github/README.md
index 1683ad9..3d74142 100644
--- a/.github/README.md
+++ b/.github/README.md
@@ -10,13 +10,13 @@ Start by adding `windows` and `microsoft-dia` dependencies to Cargo.toml:
 
 ```toml
 [dependencies.windows]
-version = "0.53.0"
+version = "0.58.0"
 features = [
     "Win32_System_Com"
 ]
 
 [dependencies.microsoft-dia]
-version = "0.10.0"
+version = "0.11.0"
 ```
 
 Make use of any DIA SDK APIs as needed.
diff --git a/.metadata/generate.proj b/.metadata/generate.proj
index ec5a8b3..3e6d121 100644
--- a/.metadata/generate.proj
+++ b/.metadata/generate.proj
@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
-<Project Sdk="Microsoft.Windows.WinmdGenerator/0.59.13-preview">
+<Project Sdk="Microsoft.Windows.WinmdGenerator/0.61.15-preview">
     <PropertyGroup Label="Globals">
         <OutputWinmd>../.windows/winmd/Microsoft.Dia.winmd</OutputWinmd>
         <WinmdVersion>255.255.255.255</WinmdVersion>
diff --git a/.metadata/options.rsp b/.metadata/options.rsp
index 4889b1f..e12f7bf 100644
--- a/.metadata/options.rsp
+++ b/.metadata/options.rsp
@@ -10,3 +10,5 @@ PfnPDBDebugDirV
 --memberRemap
 IDiaSourceFile::get_checksum::pbData=[Optional]
 IDiaSymbol10::get_sourceLink::pb=[Optional]
+IDiaSession::findChildren::parent=[Optional]
+IDiaSession::findFile::pCompiland=[Optional]
diff --git a/.windows/winmd/Microsoft.Dia.winmd b/.windows/winmd/Microsoft.Dia.winmd
index a97c73252168a2616e8b21f4b2e9273d47a72131..0c685a3dbf71a03c6a6b13ce676c6cd7171d36f2 100644
GIT binary patch
literal 142848
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

literal 139776
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%0DmsoxKRopu7+Fc1e1<*Fj4AL&E>0
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

diff --git a/Cargo.toml b/Cargo.toml
index 003ed85..66f0b11 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "microsoft-dia"
-version = "0.10.0"
+version = "0.11.0"
 authors = ["Microsoft"]
 edition = "2021"
 license = "MIT OR Apache-2.0"
@@ -10,27 +10,20 @@ readme = ".github/README.md"
 exclude = [".github", ".metadata", "docs", "tests"]
 
 [workspace]
-members = [
-    "crates/samples/*",
-]
+members = ["crates/samples/*"]
 
 [dependencies.windows]
-version = "0.53"
+version = "0.58"
 features = [
     "implement",
-    "Win32_Foundation",
-    "Win32_System_Com",
     "Win32_System_Variant",
     "Win32_System_LibraryLoader",
     "Win32_System_Com_StructuredStorage",
-    "Win32_System_Ole"
+    "Win32_System_Ole",
 ]
 
 [dependencies.windows-core]
-version = "0.53"
-features = [
-    "implement"
-]
+version = "0.58"
 
 [build-dependencies.windows-bindgen]
-version = "0.53"
+version = "0.58"
diff --git a/crates/samples/checksum/Cargo.toml b/crates/samples/checksum/Cargo.toml
index 10628d2..89bd25e 100644
--- a/crates/samples/checksum/Cargo.toml
+++ b/crates/samples/checksum/Cargo.toml
@@ -5,7 +5,7 @@ edition = "2021"
 publish = false
 
 [dependencies.windows]
-version = "0.53"
+version = "0.58"
 
 [dependencies.microsoft-dia]
 path = "../../../"
diff --git a/crates/samples/checksum/src/main.rs b/crates/samples/checksum/src/main.rs
index 87a2562..c18a203 100644
--- a/crates/samples/checksum/src/main.rs
+++ b/crates/samples/checksum/src/main.rs
@@ -27,9 +27,8 @@ fn main() -> Result<()> {
                 .findChildren(SymTagCompiland, None, nsNone.0 as u32)?;
 
         // Get source files
-        for i in 0..symbols.Count()? {
-            let symbol = symbols.Item(i as u32)?;
-            let files = session.findFile(&symbol, PCWSTR::null(), nsNone.0 as u32)?;
+        for _i in 0..symbols.Count()? {
+            let files = session.findFile(None, PCWSTR::null(), nsNone.0 as u32)?;
 
             // Find files with a checksum and print out details
             for j in 0..files.Count()? {
diff --git a/crates/samples/functions/Cargo.toml b/crates/samples/functions/Cargo.toml
index fa47a8c..5e567f3 100644
--- a/crates/samples/functions/Cargo.toml
+++ b/crates/samples/functions/Cargo.toml
@@ -5,7 +5,7 @@ edition = "2021"
 publish = false
 
 [dependencies.windows]
-version = "0.53"
+version = "0.58"
 
 [dependencies.microsoft-dia]
 path = "../../../"
diff --git a/src/bindings.rs b/src/bindings.rs
index e8ed00b..9f98ca9 100644
--- a/src/bindings.rs
+++ b/src/bindings.rs
@@ -1,4 +1,4 @@
-// Bindings generated by `windows-bindgen` 0.53.0
+// Bindings generated by `windows-bindgen` 0.58.0
 
 #![allow(
     non_snake_case,
@@ -8,39 +8,45 @@
     clippy::all
 )]
 pub mod Dia {
-    ::windows_core::imp::com_interface!(
+    windows_core::imp::define_interface!(
         IDiaAddressMap,
         IDiaAddressMap_Vtbl,
         0xb62a2e7a_067a_4ea3_b598_04c09717502c
     );
-    ::windows_core::imp::interface_hierarchy!(IDiaAddressMap, ::windows_core::IUnknown);
+    impl core::ops::Deref for IDiaAddressMap {
+        type Target = windows_core::IUnknown;
+        fn deref(&self) -> &Self::Target {
+            unsafe { core::mem::transmute(self) }
+        }
+    }
+    windows_core::imp::interface_hierarchy!(IDiaAddressMap, windows_core::IUnknown);
     impl IDiaAddressMap {
         pub unsafe fn addressMapEnabled(
             &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).addressMapEnabled)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).addressMapEnabled)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn SetaddressMapEnabled<P0>(&self, newval: P0) -> ::windows_core::Result<()>
+        pub unsafe fn SetaddressMapEnabled<P0>(&self, newval: P0) -> windows_core::Result<()>
         where
-            P0: ::windows_core::IntoParam<::windows::Win32::Foundation::BOOL>,
+            P0: windows_core::Param<windows::Win32::Foundation::BOOL>,
         {
-            (::windows_core::Interface::vtable(self).SetaddressMapEnabled)(
-                ::windows_core::Interface::as_raw(self),
-                newval.into_param().abi(),
+            (windows_core::Interface::vtable(self).SetaddressMapEnabled)(
+                windows_core::Interface::as_raw(self),
+                newval.param().abi(),
             )
             .ok()
         }
         pub unsafe fn relativeVirtualAddressEnabled(
             &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).relativeVirtualAddressEnabled)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).relativeVirtualAddressEnabled)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
@@ -48,27 +54,27 @@ pub mod Dia {
         pub unsafe fn SetrelativeVirtualAddressEnabled<P0>(
             &self,
             newval: P0,
-        ) -> ::windows_core::Result<()>
+        ) -> windows_core::Result<()>
         where
-            P0: ::windows_core::IntoParam<::windows::Win32::Foundation::BOOL>,
+            P0: windows_core::Param<windows::Win32::Foundation::BOOL>,
         {
-            (::windows_core::Interface::vtable(self).SetrelativeVirtualAddressEnabled)(
-                ::windows_core::Interface::as_raw(self),
-                newval.into_param().abi(),
+            (windows_core::Interface::vtable(self).SetrelativeVirtualAddressEnabled)(
+                windows_core::Interface::as_raw(self),
+                newval.param().abi(),
             )
             .ok()
         }
-        pub unsafe fn imageAlign(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).imageAlign)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn imageAlign(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).imageAlign)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn SetimageAlign(&self, newval: u32) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self).SetimageAlign)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn SetimageAlign(&self, newval: u32) -> windows_core::Result<()> {
+            (windows_core::Interface::vtable(self).SetimageAlign)(
+                windows_core::Interface::as_raw(self),
                 newval,
             )
             .ok()
@@ -77,15 +83,15 @@ pub mod Dia {
             &self,
             pbdata: &[u8],
             originalheaders: P0,
-        ) -> ::windows_core::Result<()>
+        ) -> windows_core::Result<()>
         where
-            P0: ::windows_core::IntoParam<::windows::Win32::Foundation::BOOL>,
+            P0: windows_core::Param<windows::Win32::Foundation::BOOL>,
         {
-            (::windows_core::Interface::vtable(self).set_imageHeaders)(
-                ::windows_core::Interface::as_raw(self),
+            (windows_core::Interface::vtable(self).set_imageHeaders)(
+                windows_core::Interface::as_raw(self),
                 pbdata.len().try_into().unwrap(),
-                ::core::mem::transmute(pbdata.as_ptr()),
-                originalheaders.into_param().abi(),
+                core::mem::transmute(pbdata.as_ptr()),
+                originalheaders.param().abi(),
             )
             .ok()
         }
@@ -93,97 +99,101 @@ pub mod Dia {
             &self,
             pdata: &[DiaAddressMapEntry],
             imagetosymbols: P0,
-        ) -> ::windows_core::Result<()>
+        ) -> windows_core::Result<()>
         where
-            P0: ::windows_core::IntoParam<::windows::Win32::Foundation::BOOL>,
+            P0: windows_core::Param<windows::Win32::Foundation::BOOL>,
         {
-            (::windows_core::Interface::vtable(self).set_addressMap)(
-                ::windows_core::Interface::as_raw(self),
+            (windows_core::Interface::vtable(self).set_addressMap)(
+                windows_core::Interface::as_raw(self),
                 pdata.len().try_into().unwrap(),
-                ::core::mem::transmute(pdata.as_ptr()),
-                imagetosymbols.into_param().abi(),
+                core::mem::transmute(pdata.as_ptr()),
+                imagetosymbols.param().abi(),
             )
             .ok()
         }
     }
     #[repr(C)]
     pub struct IDiaAddressMap_Vtbl {
-        pub base__: ::windows_core::IUnknown_Vtbl,
+        pub base__: windows_core::IUnknown_Vtbl,
         pub addressMapEnabled: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub SetaddressMapEnabled: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub relativeVirtualAddressEnabled: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
         )
-            -> ::windows_core::HRESULT,
+            -> windows_core::HRESULT,
         pub SetrelativeVirtualAddressEnabled: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            ::windows::Win32::Foundation::BOOL,
+            *mut core::ffi::c_void,
+            windows::Win32::Foundation::BOOL,
         )
-            -> ::windows_core::HRESULT,
-        pub imageAlign: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
+            -> windows_core::HRESULT,
+        pub imageAlign:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
         pub SetimageAlign:
-            unsafe extern "system" fn(*mut ::core::ffi::c_void, u32) -> ::windows_core::HRESULT,
+            unsafe extern "system" fn(*mut core::ffi::c_void, u32) -> windows_core::HRESULT,
         pub set_imageHeaders: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             u32,
             *const u8,
-            ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub set_addressMap: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             u32,
             *const DiaAddressMapEntry,
-            ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
     }
-    ::windows_core::imp::com_interface!(
+    windows_core::imp::define_interface!(
         IDiaDataSource,
         IDiaDataSource_Vtbl,
         0x79f1bb5f_b66e_48e5_b6a9_1545c323ca3d
     );
-    ::windows_core::imp::interface_hierarchy!(IDiaDataSource, ::windows_core::IUnknown);
+    impl core::ops::Deref for IDiaDataSource {
+        type Target = windows_core::IUnknown;
+        fn deref(&self) -> &Self::Target {
+            unsafe { core::mem::transmute(self) }
+        }
+    }
+    windows_core::imp::interface_hierarchy!(IDiaDataSource, windows_core::IUnknown);
     impl IDiaDataSource {
-        pub unsafe fn lastError(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).lastError)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn lastError(&self) -> windows_core::Result<windows_core::BSTR> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).lastError)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
-        pub unsafe fn loadDataFromPdb<P0>(&self, pdbpath: P0) -> ::windows_core::Result<()>
+        pub unsafe fn loadDataFromPdb<P0>(&self, pdbpath: P0) -> windows_core::Result<()>
         where
-            P0: ::windows_core::IntoParam<::windows_core::PCWSTR>,
+            P0: windows_core::Param<windows_core::PCWSTR>,
         {
-            (::windows_core::Interface::vtable(self).loadDataFromPdb)(
-                ::windows_core::Interface::as_raw(self),
-                pdbpath.into_param().abi(),
+            (windows_core::Interface::vtable(self).loadDataFromPdb)(
+                windows_core::Interface::as_raw(self),
+                pdbpath.param().abi(),
             )
             .ok()
         }
         pub unsafe fn loadAndValidateDataFromPdb<P0>(
             &self,
             pdbpath: P0,
-            pcsig70: *const ::windows_core::GUID,
+            pcsig70: *const windows_core::GUID,
             sig: u32,
             age: u32,
-        ) -> ::windows_core::Result<()>
+        ) -> windows_core::Result<()>
         where
-            P0: ::windows_core::IntoParam<::windows_core::PCWSTR>,
+            P0: windows_core::Param<windows_core::PCWSTR>,
         {
-            (::windows_core::Interface::vtable(self).loadAndValidateDataFromPdb)(
-                ::windows_core::Interface::as_raw(self),
-                pdbpath.into_param().abi(),
+            (windows_core::Interface::vtable(self).loadAndValidateDataFromPdb)(
+                windows_core::Interface::as_raw(self),
+                pdbpath.param().abi(),
                 pcsig70,
                 sig,
                 age,
@@ -195,37 +205,37 @@ pub mod Dia {
             executable: P0,
             searchpath: P1,
             pcallback: P2,
-        ) -> ::windows_core::Result<()>
+        ) -> windows_core::Result<()>
         where
-            P0: ::windows_core::IntoParam<::windows_core::PCWSTR>,
-            P1: ::windows_core::IntoParam<::windows_core::PCWSTR>,
-            P2: ::windows_core::IntoParam<::windows_core::IUnknown>,
+            P0: windows_core::Param<windows_core::PCWSTR>,
+            P1: windows_core::Param<windows_core::PCWSTR>,
+            P2: windows_core::Param<windows_core::IUnknown>,
         {
-            (::windows_core::Interface::vtable(self).loadDataForExe)(
-                ::windows_core::Interface::as_raw(self),
-                executable.into_param().abi(),
-                searchpath.into_param().abi(),
-                pcallback.into_param().abi(),
+            (windows_core::Interface::vtable(self).loadDataForExe)(
+                windows_core::Interface::as_raw(self),
+                executable.param().abi(),
+                searchpath.param().abi(),
+                pcallback.param().abi(),
             )
             .ok()
         }
-        pub unsafe fn loadDataFromIStream<P0>(&self, pistream: P0) -> ::windows_core::Result<()>
+        pub unsafe fn loadDataFromIStream<P0>(&self, pistream: P0) -> windows_core::Result<()>
         where
-            P0: ::windows_core::IntoParam<::windows::Win32::System::Com::IStream>,
+            P0: windows_core::Param<windows::Win32::System::Com::IStream>,
         {
-            (::windows_core::Interface::vtable(self).loadDataFromIStream)(
-                ::windows_core::Interface::as_raw(self),
-                pistream.into_param().abi(),
+            (windows_core::Interface::vtable(self).loadDataFromIStream)(
+                windows_core::Interface::as_raw(self),
+                pistream.param().abi(),
             )
             .ok()
         }
-        pub unsafe fn openSession(&self) -> ::windows_core::Result<IDiaSession> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).openSession)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn openSession(&self) -> windows_core::Result<IDiaSession> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).openSession)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
         pub unsafe fn loadDataFromCodeViewInfo<P0, P1, P2>(
             &self,
@@ -233,19 +243,19 @@ pub mod Dia {
             searchpath: P1,
             pbcvinfo: &[u8],
             pcallback: P2,
-        ) -> ::windows_core::Result<()>
+        ) -> windows_core::Result<()>
         where
-            P0: ::windows_core::IntoParam<::windows_core::PCWSTR>,
-            P1: ::windows_core::IntoParam<::windows_core::PCWSTR>,
-            P2: ::windows_core::IntoParam<::windows_core::IUnknown>,
+            P0: windows_core::Param<windows_core::PCWSTR>,
+            P1: windows_core::Param<windows_core::PCWSTR>,
+            P2: windows_core::Param<windows_core::IUnknown>,
         {
-            (::windows_core::Interface::vtable(self).loadDataFromCodeViewInfo)(
-                ::windows_core::Interface::as_raw(self),
-                executable.into_param().abi(),
-                searchpath.into_param().abi(),
+            (windows_core::Interface::vtable(self).loadDataFromCodeViewInfo)(
+                windows_core::Interface::as_raw(self),
+                executable.param().abi(),
+                searchpath.param().abi(),
                 pbcvinfo.len().try_into().unwrap(),
-                ::core::mem::transmute(pbcvinfo.as_ptr()),
-                pcallback.into_param().abi(),
+                core::mem::transmute(pbcvinfo.as_ptr()),
+                pcallback.param().abi(),
             )
             .ok()
         }
@@ -258,122 +268,343 @@ pub mod Dia {
             sizeofexe: u32,
             pbmiscinfo: &[u8],
             pcallback: P2,
-        ) -> ::windows_core::Result<()>
+        ) -> windows_core::Result<()>
         where
-            P0: ::windows_core::IntoParam<::windows_core::PCWSTR>,
-            P1: ::windows_core::IntoParam<::windows_core::PCWSTR>,
-            P2: ::windows_core::IntoParam<::windows_core::IUnknown>,
+            P0: windows_core::Param<windows_core::PCWSTR>,
+            P1: windows_core::Param<windows_core::PCWSTR>,
+            P2: windows_core::Param<windows_core::IUnknown>,
         {
-            (::windows_core::Interface::vtable(self).loadDataFromMiscInfo)(
-                ::windows_core::Interface::as_raw(self),
-                executable.into_param().abi(),
-                searchpath.into_param().abi(),
+            (windows_core::Interface::vtable(self).loadDataFromMiscInfo)(
+                windows_core::Interface::as_raw(self),
+                executable.param().abi(),
+                searchpath.param().abi(),
                 timestampexe,
                 timestampdbg,
                 sizeofexe,
                 pbmiscinfo.len().try_into().unwrap(),
-                ::core::mem::transmute(pbmiscinfo.as_ptr()),
-                pcallback.into_param().abi(),
+                core::mem::transmute(pbmiscinfo.as_ptr()),
+                pcallback.param().abi(),
             )
             .ok()
         }
     }
     #[repr(C)]
     pub struct IDiaDataSource_Vtbl {
-        pub base__: ::windows_core::IUnknown_Vtbl,
+        pub base__: windows_core::IUnknown_Vtbl,
         pub lastError: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::std::mem::MaybeUninit<::windows_core::BSTR>,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut core::mem::MaybeUninit<windows_core::BSTR>,
+        ) -> windows_core::HRESULT,
         pub loadDataFromPdb: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            ::windows_core::PCWSTR,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            windows_core::PCWSTR,
+        ) -> windows_core::HRESULT,
         pub loadAndValidateDataFromPdb: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            ::windows_core::PCWSTR,
-            *const ::windows_core::GUID,
+            *mut core::ffi::c_void,
+            windows_core::PCWSTR,
+            *const windows_core::GUID,
             u32,
             u32,
-        )
-            -> ::windows_core::HRESULT,
+        ) -> windows_core::HRESULT,
         pub loadDataForExe: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            ::windows_core::PCWSTR,
-            ::windows_core::PCWSTR,
-            *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            windows_core::PCWSTR,
+            windows_core::PCWSTR,
+            *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
         pub loadDataFromIStream: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
         pub openSession: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
         pub loadDataFromCodeViewInfo: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            ::windows_core::PCWSTR,
-            ::windows_core::PCWSTR,
+            *mut core::ffi::c_void,
+            windows_core::PCWSTR,
+            windows_core::PCWSTR,
             u32,
             *const u8,
-            *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
         pub loadDataFromMiscInfo: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            ::windows_core::PCWSTR,
-            ::windows_core::PCWSTR,
+            *mut core::ffi::c_void,
+            windows_core::PCWSTR,
+            windows_core::PCWSTR,
             u32,
             u32,
             u32,
             u32,
             *const u8,
-            *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
+    }
+    windows_core::imp::define_interface!(
+        IDiaDataSourceEx,
+        IDiaDataSourceEx_Vtbl,
+        0x1a21eb69_962a_4bc4_8bd3_681797d38b23
+    );
+    impl core::ops::Deref for IDiaDataSourceEx {
+        type Target = IDiaDataSource;
+        fn deref(&self) -> &Self::Target {
+            unsafe { core::mem::transmute(self) }
+        }
+    }
+    windows_core::imp::interface_hierarchy!(
+        IDiaDataSourceEx,
+        windows_core::IUnknown,
+        IDiaDataSource
+    );
+    impl IDiaDataSourceEx {
+        pub unsafe fn loadDataFromPdbEx<P0, P1>(
+            &self,
+            pdbpath: P0,
+            fpdbprefetching: P1,
+        ) -> windows_core::Result<()>
+        where
+            P0: windows_core::Param<windows_core::PCWSTR>,
+            P1: windows_core::Param<windows::Win32::Foundation::BOOL>,
+        {
+            (windows_core::Interface::vtable(self).loadDataFromPdbEx)(
+                windows_core::Interface::as_raw(self),
+                pdbpath.param().abi(),
+                fpdbprefetching.param().abi(),
+            )
+            .ok()
+        }
+        pub unsafe fn loadAndValidateDataFromPdbEx<P0, P1>(
+            &self,
+            pdbpath: P0,
+            pcsig70: *const windows_core::GUID,
+            sig: u32,
+            age: u32,
+            fpdbprefetching: P1,
+        ) -> windows_core::Result<()>
+        where
+            P0: windows_core::Param<windows_core::PCWSTR>,
+            P1: windows_core::Param<windows::Win32::Foundation::BOOL>,
+        {
+            (windows_core::Interface::vtable(self).loadAndValidateDataFromPdbEx)(
+                windows_core::Interface::as_raw(self),
+                pdbpath.param().abi(),
+                pcsig70,
+                sig,
+                age,
+                fpdbprefetching.param().abi(),
+            )
+            .ok()
+        }
+        pub unsafe fn loadDataForExeEx<P0, P1, P2, P3>(
+            &self,
+            executable: P0,
+            searchpath: P1,
+            pcallback: P2,
+            fpdbprefetching: P3,
+        ) -> windows_core::Result<()>
+        where
+            P0: windows_core::Param<windows_core::PCWSTR>,
+            P1: windows_core::Param<windows_core::PCWSTR>,
+            P2: windows_core::Param<windows_core::IUnknown>,
+            P3: windows_core::Param<windows::Win32::Foundation::BOOL>,
+        {
+            (windows_core::Interface::vtable(self).loadDataForExeEx)(
+                windows_core::Interface::as_raw(self),
+                executable.param().abi(),
+                searchpath.param().abi(),
+                pcallback.param().abi(),
+                fpdbprefetching.param().abi(),
+            )
+            .ok()
+        }
+        pub unsafe fn loadDataFromIStreamEx<P0, P1>(
+            &self,
+            pistream: P0,
+            fpdbprefetching: P1,
+        ) -> windows_core::Result<()>
+        where
+            P0: windows_core::Param<windows::Win32::System::Com::IStream>,
+            P1: windows_core::Param<windows::Win32::Foundation::BOOL>,
+        {
+            (windows_core::Interface::vtable(self).loadDataFromIStreamEx)(
+                windows_core::Interface::as_raw(self),
+                pistream.param().abi(),
+                fpdbprefetching.param().abi(),
+            )
+            .ok()
+        }
+        pub unsafe fn getStreamSize<P0>(&self, stream: P0) -> windows_core::Result<u64>
+        where
+            P0: windows_core::Param<windows_core::PCWSTR>,
+        {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).getStreamSize)(
+                windows_core::Interface::as_raw(self),
+                stream.param().abi(),
+                &mut result__,
+            )
+            .map(|| result__)
+        }
+        pub unsafe fn getStreamRawData<P0>(
+            &self,
+            stream: P0,
+            cboffset: u64,
+            pcbread: *mut u64,
+            pbdata: &mut [u8],
+        ) -> windows_core::Result<()>
+        where
+            P0: windows_core::Param<windows_core::PCWSTR>,
+        {
+            (windows_core::Interface::vtable(self).getStreamRawData)(
+                windows_core::Interface::as_raw(self),
+                stream.param().abi(),
+                cboffset,
+                pbdata.len().try_into().unwrap(),
+                pcbread,
+                core::mem::transmute(pbdata.as_ptr()),
+            )
+            .ok()
+        }
+        pub unsafe fn setPfnMiniPDBErrorCallback2(
+            &self,
+            pvcontext: *const core::ffi::c_void,
+            pfn: PFNMINIPDBERRORCALLBACK2,
+        ) -> windows_core::Result<()> {
+            (windows_core::Interface::vtable(self).setPfnMiniPDBErrorCallback2)(
+                windows_core::Interface::as_raw(self),
+                pvcontext,
+                pfn,
+            )
+            .ok()
+        }
+        pub unsafe fn ValidatePdb<P0>(
+            &self,
+            pdbpath: P0,
+            pcsig70: *const windows_core::GUID,
+            sig: u32,
+            age: u32,
+        ) -> windows_core::Result<windows::Win32::Foundation::BOOL>
+        where
+            P0: windows_core::Param<windows_core::PCWSTR>,
+        {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).ValidatePdb)(
+                windows_core::Interface::as_raw(self),
+                pdbpath.param().abi(),
+                pcsig70,
+                sig,
+                age,
+                &mut result__,
+            )
+            .map(|| result__)
+        }
+    }
+    #[repr(C)]
+    pub struct IDiaDataSourceEx_Vtbl {
+        pub base__: IDiaDataSource_Vtbl,
+        pub loadDataFromPdbEx: unsafe extern "system" fn(
+            *mut core::ffi::c_void,
+            windows_core::PCWSTR,
+            windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
+        pub loadAndValidateDataFromPdbEx: unsafe extern "system" fn(
+            *mut core::ffi::c_void,
+            windows_core::PCWSTR,
+            *const windows_core::GUID,
+            u32,
+            u32,
+            windows::Win32::Foundation::BOOL,
+        )
+            -> windows_core::HRESULT,
+        pub loadDataForExeEx: unsafe extern "system" fn(
+            *mut core::ffi::c_void,
+            windows_core::PCWSTR,
+            windows_core::PCWSTR,
+            *mut core::ffi::c_void,
+            windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
+        pub loadDataFromIStreamEx: unsafe extern "system" fn(
+            *mut core::ffi::c_void,
+            *mut core::ffi::c_void,
+            windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
+        pub getStreamSize: unsafe extern "system" fn(
+            *mut core::ffi::c_void,
+            windows_core::PCWSTR,
+            *mut u64,
+        ) -> windows_core::HRESULT,
+        pub getStreamRawData: unsafe extern "system" fn(
+            *mut core::ffi::c_void,
+            windows_core::PCWSTR,
+            u64,
+            u64,
+            *mut u64,
+            *mut u8,
+        ) -> windows_core::HRESULT,
+        pub setPfnMiniPDBErrorCallback2: unsafe extern "system" fn(
+            *mut core::ffi::c_void,
+            *const core::ffi::c_void,
+            PFNMINIPDBERRORCALLBACK2,
+        )
+            -> windows_core::HRESULT,
+        pub ValidatePdb: unsafe extern "system" fn(
+            *mut core::ffi::c_void,
+            windows_core::PCWSTR,
+            *const windows_core::GUID,
+            u32,
+            u32,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
     }
-    ::windows_core::imp::com_interface!(
+    windows_core::imp::define_interface!(
         IDiaEnumDebugStreamData,
         IDiaEnumDebugStreamData_Vtbl,
         0x486943e8_d187_4a6b_a3c4_291259fff60d
     );
-    ::windows_core::imp::interface_hierarchy!(IDiaEnumDebugStreamData, ::windows_core::IUnknown);
+    impl core::ops::Deref for IDiaEnumDebugStreamData {
+        type Target = windows_core::IUnknown;
+        fn deref(&self) -> &Self::Target {
+            unsafe { core::mem::transmute(self) }
+        }
+    }
+    windows_core::imp::interface_hierarchy!(IDiaEnumDebugStreamData, windows_core::IUnknown);
     impl IDiaEnumDebugStreamData {
-        pub unsafe fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)._NewEnum)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn _NewEnum(&self) -> windows_core::Result<windows_core::IUnknown> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self)._NewEnum)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
-        pub unsafe fn Count(&self) -> ::windows_core::Result<i32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).Count)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn Count(&self) -> windows_core::Result<i32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).Count)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn name(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).name)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn name(&self) -> windows_core::Result<windows_core::BSTR> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).name)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
         pub unsafe fn Item(
             &self,
             index: u32,
             pcbdata: *mut u32,
             pbdata: &mut [u8],
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self).Item)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<()> {
+            (windows_core::Interface::vtable(self).Item)(
+                windows_core::Interface::as_raw(self),
                 index,
                 pbdata.len().try_into().unwrap(),
                 pcbdata,
-                ::core::mem::transmute(pbdata.as_ptr()),
+                core::mem::transmute(pbdata.as_ptr()),
             )
             .ok()
         }
@@ -383,1065 +614,1220 @@ pub mod Dia {
             pcbdata: *mut u32,
             pbdata: &mut [u8],
             pceltfetched: *mut u32,
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self).Next)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<()> {
+            (windows_core::Interface::vtable(self).Next)(
+                windows_core::Interface::as_raw(self),
                 celt,
                 pbdata.len().try_into().unwrap(),
                 pcbdata,
-                ::core::mem::transmute(pbdata.as_ptr()),
+                core::mem::transmute(pbdata.as_ptr()),
                 pceltfetched,
             )
             .ok()
         }
-        pub unsafe fn Skip(&self, celt: u32) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self).Skip)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn Skip(&self, celt: u32) -> windows_core::Result<()> {
+            (windows_core::Interface::vtable(self).Skip)(
+                windows_core::Interface::as_raw(self),
                 celt,
             )
             .ok()
         }
-        pub unsafe fn Reset(&self) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self).Reset)(::windows_core::Interface::as_raw(self))
+        pub unsafe fn Reset(&self) -> windows_core::Result<()> {
+            (windows_core::Interface::vtable(self).Reset)(windows_core::Interface::as_raw(self))
                 .ok()
         }
-        pub unsafe fn Clone(&self) -> ::windows_core::Result<IDiaEnumDebugStreamData> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).Clone)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn Clone(&self) -> windows_core::Result<IDiaEnumDebugStreamData> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).Clone)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
     }
     #[repr(C)]
     pub struct IDiaEnumDebugStreamData_Vtbl {
-        pub base__: ::windows_core::IUnknown_Vtbl,
+        pub base__: windows_core::IUnknown_Vtbl,
         pub _NewEnum: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
-        pub Count: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut i32,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
+        pub Count:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut i32) -> windows_core::HRESULT,
         pub name: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::std::mem::MaybeUninit<::windows_core::BSTR>,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut core::mem::MaybeUninit<windows_core::BSTR>,
+        ) -> windows_core::HRESULT,
         pub Item: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             u32,
             u32,
             *mut u32,
             *mut u8,
-        ) -> ::windows_core::HRESULT,
+        ) -> windows_core::HRESULT,
         pub Next: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             u32,
             u32,
             *mut u32,
             *mut u8,
             *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub Skip:
-            unsafe extern "system" fn(*mut ::core::ffi::c_void, u32) -> ::windows_core::HRESULT,
-        pub Reset: unsafe extern "system" fn(*mut ::core::ffi::c_void) -> ::windows_core::HRESULT,
+        ) -> windows_core::HRESULT,
+        pub Skip: unsafe extern "system" fn(*mut core::ffi::c_void, u32) -> windows_core::HRESULT,
+        pub Reset: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
         pub Clone: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
     }
-    ::windows_core::imp::com_interface!(
+    windows_core::imp::define_interface!(
         IDiaEnumDebugStreams,
         IDiaEnumDebugStreams_Vtbl,
         0x08cbb41e_47a6_4f87_92f1_1c9c87ced044
     );
-    ::windows_core::imp::interface_hierarchy!(IDiaEnumDebugStreams, ::windows_core::IUnknown);
+    impl core::ops::Deref for IDiaEnumDebugStreams {
+        type Target = windows_core::IUnknown;
+        fn deref(&self) -> &Self::Target {
+            unsafe { core::mem::transmute(self) }
+        }
+    }
+    windows_core::imp::interface_hierarchy!(IDiaEnumDebugStreams, windows_core::IUnknown);
     impl IDiaEnumDebugStreams {
-        pub unsafe fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)._NewEnum)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn _NewEnum(&self) -> windows_core::Result<windows_core::IUnknown> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self)._NewEnum)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
-        pub unsafe fn Count(&self) -> ::windows_core::Result<i32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).Count)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn Count(&self) -> windows_core::Result<i32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).Count)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn Item<P0>(&self, index: P0) -> ::windows_core::Result<IDiaEnumDebugStreamData>
+        pub unsafe fn Item<P0>(&self, index: P0) -> windows_core::Result<IDiaEnumDebugStreamData>
         where
-            P0: ::windows_core::IntoParam<::windows_core::VARIANT>,
+            P0: windows_core::Param<windows_core::VARIANT>,
         {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).Item)(
-                ::windows_core::Interface::as_raw(self),
-                index.into_param().abi(),
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).Item)(
+                windows_core::Interface::as_raw(self),
+                index.param().abi(),
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
         pub unsafe fn Next(
             &self,
             celt: u32,
-            rgelt: *mut ::core::option::Option<IDiaEnumDebugStreamData>,
+            rgelt: *mut Option<IDiaEnumDebugStreamData>,
             pceltfetched: *mut u32,
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self).Next)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<()> {
+            (windows_core::Interface::vtable(self).Next)(
+                windows_core::Interface::as_raw(self),
                 celt,
-                ::core::mem::transmute(rgelt),
+                core::mem::transmute(rgelt),
                 pceltfetched,
             )
             .ok()
         }
-        pub unsafe fn Skip(&self, celt: u32) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self).Skip)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn Skip(&self, celt: u32) -> windows_core::Result<()> {
+            (windows_core::Interface::vtable(self).Skip)(
+                windows_core::Interface::as_raw(self),
                 celt,
             )
             .ok()
         }
-        pub unsafe fn Reset(&self) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self).Reset)(::windows_core::Interface::as_raw(self))
+        pub unsafe fn Reset(&self) -> windows_core::Result<()> {
+            (windows_core::Interface::vtable(self).Reset)(windows_core::Interface::as_raw(self))
                 .ok()
         }
-        pub unsafe fn Clone(&self) -> ::windows_core::Result<IDiaEnumDebugStreams> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).Clone)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn Clone(&self) -> windows_core::Result<IDiaEnumDebugStreams> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).Clone)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
     }
     #[repr(C)]
     pub struct IDiaEnumDebugStreams_Vtbl {
-        pub base__: ::windows_core::IUnknown_Vtbl,
+        pub base__: windows_core::IUnknown_Vtbl,
         pub _NewEnum: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
-        pub Count: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut i32,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
+        pub Count:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut i32) -> windows_core::HRESULT,
         pub Item: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            ::std::mem::MaybeUninit<::windows_core::VARIANT>,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            core::mem::MaybeUninit<windows_core::VARIANT>,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
         pub Next: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             u32,
-            *mut *mut ::core::ffi::c_void,
+            *mut *mut core::ffi::c_void,
             *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub Skip:
-            unsafe extern "system" fn(*mut ::core::ffi::c_void, u32) -> ::windows_core::HRESULT,
-        pub Reset: unsafe extern "system" fn(*mut ::core::ffi::c_void) -> ::windows_core::HRESULT,
+        ) -> windows_core::HRESULT,
+        pub Skip: unsafe extern "system" fn(*mut core::ffi::c_void, u32) -> windows_core::HRESULT,
+        pub Reset: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
         pub Clone: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
     }
-    ::windows_core::imp::com_interface!(
+    windows_core::imp::define_interface!(
         IDiaEnumFrameData,
         IDiaEnumFrameData_Vtbl,
         0x9fc77a4b_3c1c_44ed_a798_6c1deea53e1f
     );
-    ::windows_core::imp::interface_hierarchy!(IDiaEnumFrameData, ::windows_core::IUnknown);
+    impl core::ops::Deref for IDiaEnumFrameData {
+        type Target = windows_core::IUnknown;
+        fn deref(&self) -> &Self::Target {
+            unsafe { core::mem::transmute(self) }
+        }
+    }
+    windows_core::imp::interface_hierarchy!(IDiaEnumFrameData, windows_core::IUnknown);
     impl IDiaEnumFrameData {
-        pub unsafe fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)._NewEnum)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn _NewEnum(&self) -> windows_core::Result<windows_core::IUnknown> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self)._NewEnum)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
-        pub unsafe fn Count(&self) -> ::windows_core::Result<i32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).Count)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn Count(&self) -> windows_core::Result<i32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).Count)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn Item(&self, index: u32) -> ::windows_core::Result<IDiaFrameData> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).Item)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn Item(&self, index: u32) -> windows_core::Result<IDiaFrameData> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).Item)(
+                windows_core::Interface::as_raw(self),
                 index,
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
         pub unsafe fn Next(
             &self,
             celt: u32,
-            rgelt: *mut ::core::option::Option<IDiaFrameData>,
+            rgelt: *mut Option<IDiaFrameData>,
             pceltfetched: *mut u32,
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self).Next)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<()> {
+            (windows_core::Interface::vtable(self).Next)(
+                windows_core::Interface::as_raw(self),
                 celt,
-                ::core::mem::transmute(rgelt),
+                core::mem::transmute(rgelt),
                 pceltfetched,
             )
             .ok()
         }
-        pub unsafe fn Skip(&self, celt: u32) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self).Skip)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn Skip(&self, celt: u32) -> windows_core::Result<()> {
+            (windows_core::Interface::vtable(self).Skip)(
+                windows_core::Interface::as_raw(self),
                 celt,
             )
             .ok()
         }
-        pub unsafe fn Reset(&self) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self).Reset)(::windows_core::Interface::as_raw(self))
+        pub unsafe fn Reset(&self) -> windows_core::Result<()> {
+            (windows_core::Interface::vtable(self).Reset)(windows_core::Interface::as_raw(self))
                 .ok()
         }
-        pub unsafe fn Clone(&self) -> ::windows_core::Result<IDiaEnumFrameData> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).Clone)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn Clone(&self) -> windows_core::Result<IDiaEnumFrameData> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).Clone)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
         pub unsafe fn frameByRVA(
             &self,
             relativevirtualaddress: u32,
-        ) -> ::windows_core::Result<IDiaFrameData> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).frameByRVA)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<IDiaFrameData> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).frameByRVA)(
+                windows_core::Interface::as_raw(self),
                 relativevirtualaddress,
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
-        pub unsafe fn frameByVA(
-            &self,
-            virtualaddress: u64,
-        ) -> ::windows_core::Result<IDiaFrameData> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).frameByVA)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn frameByVA(&self, virtualaddress: u64) -> windows_core::Result<IDiaFrameData> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).frameByVA)(
+                windows_core::Interface::as_raw(self),
                 virtualaddress,
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
     }
     #[repr(C)]
     pub struct IDiaEnumFrameData_Vtbl {
-        pub base__: ::windows_core::IUnknown_Vtbl,
+        pub base__: windows_core::IUnknown_Vtbl,
         pub _NewEnum: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
-        pub Count: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut i32,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
+        pub Count:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut i32) -> windows_core::HRESULT,
         pub Item: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             u32,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
         pub Next: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             u32,
-            *mut *mut ::core::ffi::c_void,
+            *mut *mut core::ffi::c_void,
             *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub Skip:
-            unsafe extern "system" fn(*mut ::core::ffi::c_void, u32) -> ::windows_core::HRESULT,
-        pub Reset: unsafe extern "system" fn(*mut ::core::ffi::c_void) -> ::windows_core::HRESULT,
+        ) -> windows_core::HRESULT,
+        pub Skip: unsafe extern "system" fn(*mut core::ffi::c_void, u32) -> windows_core::HRESULT,
+        pub Reset: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
         pub Clone: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
         pub frameByRVA: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             u32,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
         pub frameByVA: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             u64,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
     }
-    ::windows_core::imp::com_interface!(
+    windows_core::imp::define_interface!(
         IDiaEnumInjectedSources,
         IDiaEnumInjectedSources_Vtbl,
         0xd5612573_6925_4468_8883_98cdec8c384a
     );
-    ::windows_core::imp::interface_hierarchy!(IDiaEnumInjectedSources, ::windows_core::IUnknown);
+    impl core::ops::Deref for IDiaEnumInjectedSources {
+        type Target = windows_core::IUnknown;
+        fn deref(&self) -> &Self::Target {
+            unsafe { core::mem::transmute(self) }
+        }
+    }
+    windows_core::imp::interface_hierarchy!(IDiaEnumInjectedSources, windows_core::IUnknown);
     impl IDiaEnumInjectedSources {
-        pub unsafe fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)._NewEnum)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn _NewEnum(&self) -> windows_core::Result<windows_core::IUnknown> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self)._NewEnum)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
-        pub unsafe fn Count(&self) -> ::windows_core::Result<i32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).Count)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn Count(&self) -> windows_core::Result<i32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).Count)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn Item(&self, index: u32) -> ::windows_core::Result<IDiaInjectedSource> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).Item)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn Item(&self, index: u32) -> windows_core::Result<IDiaInjectedSource> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).Item)(
+                windows_core::Interface::as_raw(self),
                 index,
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
         pub unsafe fn Next(
             &self,
             celt: u32,
-            rgelt: *mut ::core::option::Option<IDiaInjectedSource>,
+            rgelt: *mut Option<IDiaInjectedSource>,
             pceltfetched: *mut u32,
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self).Next)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<()> {
+            (windows_core::Interface::vtable(self).Next)(
+                windows_core::Interface::as_raw(self),
                 celt,
-                ::core::mem::transmute(rgelt),
+                core::mem::transmute(rgelt),
                 pceltfetched,
             )
             .ok()
         }
-        pub unsafe fn Skip(&self, celt: u32) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self).Skip)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn Skip(&self, celt: u32) -> windows_core::Result<()> {
+            (windows_core::Interface::vtable(self).Skip)(
+                windows_core::Interface::as_raw(self),
                 celt,
             )
             .ok()
         }
-        pub unsafe fn Reset(&self) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self).Reset)(::windows_core::Interface::as_raw(self))
+        pub unsafe fn Reset(&self) -> windows_core::Result<()> {
+            (windows_core::Interface::vtable(self).Reset)(windows_core::Interface::as_raw(self))
                 .ok()
         }
-        pub unsafe fn Clone(&self) -> ::windows_core::Result<IDiaEnumInjectedSources> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).Clone)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn Clone(&self) -> windows_core::Result<IDiaEnumInjectedSources> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).Clone)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
     }
     #[repr(C)]
     pub struct IDiaEnumInjectedSources_Vtbl {
-        pub base__: ::windows_core::IUnknown_Vtbl,
+        pub base__: windows_core::IUnknown_Vtbl,
         pub _NewEnum: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
-        pub Count: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut i32,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
+        pub Count:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut i32) -> windows_core::HRESULT,
         pub Item: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             u32,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
         pub Next: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             u32,
-            *mut *mut ::core::ffi::c_void,
+            *mut *mut core::ffi::c_void,
             *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub Skip:
-            unsafe extern "system" fn(*mut ::core::ffi::c_void, u32) -> ::windows_core::HRESULT,
-        pub Reset: unsafe extern "system" fn(*mut ::core::ffi::c_void) -> ::windows_core::HRESULT,
+        ) -> windows_core::HRESULT,
+        pub Skip: unsafe extern "system" fn(*mut core::ffi::c_void, u32) -> windows_core::HRESULT,
+        pub Reset: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
         pub Clone: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
     }
-    ::windows_core::imp::com_interface!(
+    windows_core::imp::define_interface!(
         IDiaEnumInputAssemblyFiles,
         IDiaEnumInputAssemblyFiles_Vtbl,
         0x1c7ff653_51f7_457e_8419_b20f57ef7e4d
     );
-    ::windows_core::imp::interface_hierarchy!(IDiaEnumInputAssemblyFiles, ::windows_core::IUnknown);
+    impl core::ops::Deref for IDiaEnumInputAssemblyFiles {
+        type Target = windows_core::IUnknown;
+        fn deref(&self) -> &Self::Target {
+            unsafe { core::mem::transmute(self) }
+        }
+    }
+    windows_core::imp::interface_hierarchy!(IDiaEnumInputAssemblyFiles, windows_core::IUnknown);
     impl IDiaEnumInputAssemblyFiles {
-        pub unsafe fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)._NewEnum)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn _NewEnum(&self) -> windows_core::Result<windows_core::IUnknown> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self)._NewEnum)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
-        pub unsafe fn Count(&self) -> ::windows_core::Result<i32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).Count)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn Count(&self) -> windows_core::Result<i32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).Count)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn Item(&self, index: u32) -> ::windows_core::Result<IDiaInputAssemblyFile> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).Item)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn Item(&self, index: u32) -> windows_core::Result<IDiaInputAssemblyFile> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).Item)(
+                windows_core::Interface::as_raw(self),
                 index,
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
         pub unsafe fn Next(
             &self,
             celt: u32,
-            rgelt: *mut ::core::option::Option<IDiaInputAssemblyFile>,
+            rgelt: *mut Option<IDiaInputAssemblyFile>,
             pceltfetched: *mut u32,
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self).Next)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<()> {
+            (windows_core::Interface::vtable(self).Next)(
+                windows_core::Interface::as_raw(self),
                 celt,
-                ::core::mem::transmute(rgelt),
+                core::mem::transmute(rgelt),
                 pceltfetched,
             )
             .ok()
         }
-        pub unsafe fn Skip(&self, celt: u32) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self).Skip)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn Skip(&self, celt: u32) -> windows_core::Result<()> {
+            (windows_core::Interface::vtable(self).Skip)(
+                windows_core::Interface::as_raw(self),
                 celt,
             )
             .ok()
         }
-        pub unsafe fn Reset(&self) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self).Reset)(::windows_core::Interface::as_raw(self))
+        pub unsafe fn Reset(&self) -> windows_core::Result<()> {
+            (windows_core::Interface::vtable(self).Reset)(windows_core::Interface::as_raw(self))
                 .ok()
         }
-        pub unsafe fn Clone(&self) -> ::windows_core::Result<IDiaEnumInputAssemblyFiles> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).Clone)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn Clone(&self) -> windows_core::Result<IDiaEnumInputAssemblyFiles> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).Clone)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
     }
     #[repr(C)]
     pub struct IDiaEnumInputAssemblyFiles_Vtbl {
-        pub base__: ::windows_core::IUnknown_Vtbl,
+        pub base__: windows_core::IUnknown_Vtbl,
         pub _NewEnum: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
-        pub Count: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut i32,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
+        pub Count:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut i32) -> windows_core::HRESULT,
         pub Item: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             u32,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
         pub Next: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             u32,
-            *mut *mut ::core::ffi::c_void,
+            *mut *mut core::ffi::c_void,
             *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub Skip:
-            unsafe extern "system" fn(*mut ::core::ffi::c_void, u32) -> ::windows_core::HRESULT,
-        pub Reset: unsafe extern "system" fn(*mut ::core::ffi::c_void) -> ::windows_core::HRESULT,
+        ) -> windows_core::HRESULT,
+        pub Skip: unsafe extern "system" fn(*mut core::ffi::c_void, u32) -> windows_core::HRESULT,
+        pub Reset: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
         pub Clone: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
     }
-    ::windows_core::imp::com_interface!(
+    windows_core::imp::define_interface!(
         IDiaEnumLineNumbers,
         IDiaEnumLineNumbers_Vtbl,
         0xfe30e878_54ac_44f1_81ba_39de940f6052
     );
-    ::windows_core::imp::interface_hierarchy!(IDiaEnumLineNumbers, ::windows_core::IUnknown);
+    impl core::ops::Deref for IDiaEnumLineNumbers {
+        type Target = windows_core::IUnknown;
+        fn deref(&self) -> &Self::Target {
+            unsafe { core::mem::transmute(self) }
+        }
+    }
+    windows_core::imp::interface_hierarchy!(IDiaEnumLineNumbers, windows_core::IUnknown);
     impl IDiaEnumLineNumbers {
-        pub unsafe fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)._NewEnum)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn _NewEnum(&self) -> windows_core::Result<windows_core::IUnknown> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self)._NewEnum)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
-        pub unsafe fn Count(&self) -> ::windows_core::Result<i32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).Count)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn Count(&self) -> windows_core::Result<i32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).Count)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn Item(&self, index: u32) -> ::windows_core::Result<IDiaLineNumber> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).Item)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn Item(&self, index: u32) -> windows_core::Result<IDiaLineNumber> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).Item)(
+                windows_core::Interface::as_raw(self),
                 index,
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
         pub unsafe fn Next(
             &self,
             celt: u32,
-            rgelt: *mut ::core::option::Option<IDiaLineNumber>,
+            rgelt: *mut Option<IDiaLineNumber>,
             pceltfetched: *mut u32,
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self).Next)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<()> {
+            (windows_core::Interface::vtable(self).Next)(
+                windows_core::Interface::as_raw(self),
                 celt,
-                ::core::mem::transmute(rgelt),
+                core::mem::transmute(rgelt),
                 pceltfetched,
             )
             .ok()
         }
-        pub unsafe fn Skip(&self, celt: u32) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self).Skip)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn Skip(&self, celt: u32) -> windows_core::Result<()> {
+            (windows_core::Interface::vtable(self).Skip)(
+                windows_core::Interface::as_raw(self),
                 celt,
             )
             .ok()
         }
-        pub unsafe fn Reset(&self) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self).Reset)(::windows_core::Interface::as_raw(self))
+        pub unsafe fn Reset(&self) -> windows_core::Result<()> {
+            (windows_core::Interface::vtable(self).Reset)(windows_core::Interface::as_raw(self))
                 .ok()
         }
-        pub unsafe fn Clone(&self) -> ::windows_core::Result<IDiaEnumLineNumbers> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).Clone)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn Clone(&self) -> windows_core::Result<IDiaEnumLineNumbers> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).Clone)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
     }
     #[repr(C)]
     pub struct IDiaEnumLineNumbers_Vtbl {
-        pub base__: ::windows_core::IUnknown_Vtbl,
+        pub base__: windows_core::IUnknown_Vtbl,
         pub _NewEnum: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
-        pub Count: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut i32,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
+        pub Count:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut i32) -> windows_core::HRESULT,
         pub Item: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             u32,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
         pub Next: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             u32,
-            *mut *mut ::core::ffi::c_void,
+            *mut *mut core::ffi::c_void,
             *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub Skip:
-            unsafe extern "system" fn(*mut ::core::ffi::c_void, u32) -> ::windows_core::HRESULT,
-        pub Reset: unsafe extern "system" fn(*mut ::core::ffi::c_void) -> ::windows_core::HRESULT,
+        ) -> windows_core::HRESULT,
+        pub Skip: unsafe extern "system" fn(*mut core::ffi::c_void, u32) -> windows_core::HRESULT,
+        pub Reset: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
         pub Clone: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
     }
-    ::windows_core::imp::com_interface!(
+    windows_core::imp::define_interface!(
         IDiaEnumSectionContribs,
         IDiaEnumSectionContribs_Vtbl,
         0x1994deb2_2c82_4b1d_a57f_aff424d54a68
     );
-    ::windows_core::imp::interface_hierarchy!(IDiaEnumSectionContribs, ::windows_core::IUnknown);
+    impl core::ops::Deref for IDiaEnumSectionContribs {
+        type Target = windows_core::IUnknown;
+        fn deref(&self) -> &Self::Target {
+            unsafe { core::mem::transmute(self) }
+        }
+    }
+    windows_core::imp::interface_hierarchy!(IDiaEnumSectionContribs, windows_core::IUnknown);
     impl IDiaEnumSectionContribs {
-        pub unsafe fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)._NewEnum)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn _NewEnum(&self) -> windows_core::Result<windows_core::IUnknown> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self)._NewEnum)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
-        pub unsafe fn Count(&self) -> ::windows_core::Result<i32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).Count)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn Count(&self) -> windows_core::Result<i32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).Count)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn Item(&self, index: u32) -> ::windows_core::Result<IDiaSectionContrib> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).Item)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn Item(&self, index: u32) -> windows_core::Result<IDiaSectionContrib> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).Item)(
+                windows_core::Interface::as_raw(self),
                 index,
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
         pub unsafe fn Next(
             &self,
             celt: u32,
-            rgelt: *mut ::core::option::Option<IDiaSectionContrib>,
+            rgelt: *mut Option<IDiaSectionContrib>,
             pceltfetched: *mut u32,
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self).Next)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<()> {
+            (windows_core::Interface::vtable(self).Next)(
+                windows_core::Interface::as_raw(self),
                 celt,
-                ::core::mem::transmute(rgelt),
+                core::mem::transmute(rgelt),
                 pceltfetched,
             )
             .ok()
         }
-        pub unsafe fn Skip(&self, celt: u32) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self).Skip)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn Skip(&self, celt: u32) -> windows_core::Result<()> {
+            (windows_core::Interface::vtable(self).Skip)(
+                windows_core::Interface::as_raw(self),
                 celt,
             )
             .ok()
         }
-        pub unsafe fn Reset(&self) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self).Reset)(::windows_core::Interface::as_raw(self))
+        pub unsafe fn Reset(&self) -> windows_core::Result<()> {
+            (windows_core::Interface::vtable(self).Reset)(windows_core::Interface::as_raw(self))
                 .ok()
         }
-        pub unsafe fn Clone(&self) -> ::windows_core::Result<IDiaEnumSectionContribs> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).Clone)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn Clone(&self) -> windows_core::Result<IDiaEnumSectionContribs> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).Clone)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
     }
     #[repr(C)]
     pub struct IDiaEnumSectionContribs_Vtbl {
-        pub base__: ::windows_core::IUnknown_Vtbl,
+        pub base__: windows_core::IUnknown_Vtbl,
         pub _NewEnum: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
-        pub Count: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut i32,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
+        pub Count:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut i32) -> windows_core::HRESULT,
         pub Item: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             u32,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
         pub Next: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             u32,
-            *mut *mut ::core::ffi::c_void,
+            *mut *mut core::ffi::c_void,
             *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub Skip:
-            unsafe extern "system" fn(*mut ::core::ffi::c_void, u32) -> ::windows_core::HRESULT,
-        pub Reset: unsafe extern "system" fn(*mut ::core::ffi::c_void) -> ::windows_core::HRESULT,
+        ) -> windows_core::HRESULT,
+        pub Skip: unsafe extern "system" fn(*mut core::ffi::c_void, u32) -> windows_core::HRESULT,
+        pub Reset: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
         pub Clone: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
     }
-    ::windows_core::imp::com_interface!(
+    windows_core::imp::define_interface!(
         IDiaEnumSegments,
         IDiaEnumSegments_Vtbl,
         0xe8368ca9_01d1_419d_ac0c_e31235dbda9f
     );
-    ::windows_core::imp::interface_hierarchy!(IDiaEnumSegments, ::windows_core::IUnknown);
+    impl core::ops::Deref for IDiaEnumSegments {
+        type Target = windows_core::IUnknown;
+        fn deref(&self) -> &Self::Target {
+            unsafe { core::mem::transmute(self) }
+        }
+    }
+    windows_core::imp::interface_hierarchy!(IDiaEnumSegments, windows_core::IUnknown);
     impl IDiaEnumSegments {
-        pub unsafe fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)._NewEnum)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn _NewEnum(&self) -> windows_core::Result<windows_core::IUnknown> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self)._NewEnum)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
-        pub unsafe fn Count(&self) -> ::windows_core::Result<i32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).Count)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn Count(&self) -> windows_core::Result<i32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).Count)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn Item(&self, index: u32) -> ::windows_core::Result<IDiaSegment> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).Item)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn Item(&self, index: u32) -> windows_core::Result<IDiaSegment> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).Item)(
+                windows_core::Interface::as_raw(self),
                 index,
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
         pub unsafe fn Next(
             &self,
             celt: u32,
-            rgelt: *mut ::core::option::Option<IDiaSegment>,
+            rgelt: *mut Option<IDiaSegment>,
             pceltfetched: *mut u32,
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self).Next)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<()> {
+            (windows_core::Interface::vtable(self).Next)(
+                windows_core::Interface::as_raw(self),
                 celt,
-                ::core::mem::transmute(rgelt),
+                core::mem::transmute(rgelt),
                 pceltfetched,
             )
             .ok()
         }
-        pub unsafe fn Skip(&self, celt: u32) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self).Skip)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn Skip(&self, celt: u32) -> windows_core::Result<()> {
+            (windows_core::Interface::vtable(self).Skip)(
+                windows_core::Interface::as_raw(self),
                 celt,
             )
             .ok()
         }
-        pub unsafe fn Reset(&self) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self).Reset)(::windows_core::Interface::as_raw(self))
+        pub unsafe fn Reset(&self) -> windows_core::Result<()> {
+            (windows_core::Interface::vtable(self).Reset)(windows_core::Interface::as_raw(self))
                 .ok()
         }
-        pub unsafe fn Clone(&self) -> ::windows_core::Result<IDiaEnumSegments> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).Clone)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn Clone(&self) -> windows_core::Result<IDiaEnumSegments> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).Clone)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
     }
     #[repr(C)]
     pub struct IDiaEnumSegments_Vtbl {
-        pub base__: ::windows_core::IUnknown_Vtbl,
+        pub base__: windows_core::IUnknown_Vtbl,
         pub _NewEnum: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
-        pub Count: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut i32,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
+        pub Count:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut i32) -> windows_core::HRESULT,
         pub Item: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             u32,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
         pub Next: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             u32,
-            *mut *mut ::core::ffi::c_void,
+            *mut *mut core::ffi::c_void,
             *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub Skip:
-            unsafe extern "system" fn(*mut ::core::ffi::c_void, u32) -> ::windows_core::HRESULT,
-        pub Reset: unsafe extern "system" fn(*mut ::core::ffi::c_void) -> ::windows_core::HRESULT,
+        ) -> windows_core::HRESULT,
+        pub Skip: unsafe extern "system" fn(*mut core::ffi::c_void, u32) -> windows_core::HRESULT,
+        pub Reset: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
         pub Clone: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
     }
-    ::windows_core::imp::com_interface!(
+    windows_core::imp::define_interface!(
         IDiaEnumSourceFiles,
         IDiaEnumSourceFiles_Vtbl,
         0x10f3dbd9_664f_4469_b808_9471c7a50538
     );
-    ::windows_core::imp::interface_hierarchy!(IDiaEnumSourceFiles, ::windows_core::IUnknown);
+    impl core::ops::Deref for IDiaEnumSourceFiles {
+        type Target = windows_core::IUnknown;
+        fn deref(&self) -> &Self::Target {
+            unsafe { core::mem::transmute(self) }
+        }
+    }
+    windows_core::imp::interface_hierarchy!(IDiaEnumSourceFiles, windows_core::IUnknown);
     impl IDiaEnumSourceFiles {
-        pub unsafe fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)._NewEnum)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn _NewEnum(&self) -> windows_core::Result<windows_core::IUnknown> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self)._NewEnum)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
-        pub unsafe fn Count(&self) -> ::windows_core::Result<i32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).Count)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn Count(&self) -> windows_core::Result<i32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).Count)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn Item(&self, index: u32) -> ::windows_core::Result<IDiaSourceFile> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).Item)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn Item(&self, index: u32) -> windows_core::Result<IDiaSourceFile> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).Item)(
+                windows_core::Interface::as_raw(self),
                 index,
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
         pub unsafe fn Next(
             &self,
             celt: u32,
-            rgelt: *mut ::core::option::Option<IDiaSourceFile>,
+            rgelt: *mut Option<IDiaSourceFile>,
             pceltfetched: *mut u32,
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self).Next)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<()> {
+            (windows_core::Interface::vtable(self).Next)(
+                windows_core::Interface::as_raw(self),
                 celt,
-                ::core::mem::transmute(rgelt),
+                core::mem::transmute(rgelt),
                 pceltfetched,
             )
             .ok()
         }
-        pub unsafe fn Skip(&self, celt: u32) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self).Skip)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn Skip(&self, celt: u32) -> windows_core::Result<()> {
+            (windows_core::Interface::vtable(self).Skip)(
+                windows_core::Interface::as_raw(self),
                 celt,
             )
             .ok()
         }
-        pub unsafe fn Reset(&self) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self).Reset)(::windows_core::Interface::as_raw(self))
+        pub unsafe fn Reset(&self) -> windows_core::Result<()> {
+            (windows_core::Interface::vtable(self).Reset)(windows_core::Interface::as_raw(self))
                 .ok()
         }
-        pub unsafe fn Clone(&self) -> ::windows_core::Result<IDiaEnumSourceFiles> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).Clone)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn Clone(&self) -> windows_core::Result<IDiaEnumSourceFiles> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).Clone)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
     }
     #[repr(C)]
     pub struct IDiaEnumSourceFiles_Vtbl {
-        pub base__: ::windows_core::IUnknown_Vtbl,
+        pub base__: windows_core::IUnknown_Vtbl,
         pub _NewEnum: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
-        pub Count: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut i32,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
+        pub Count:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut i32) -> windows_core::HRESULT,
         pub Item: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             u32,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
+        pub Next: unsafe extern "system" fn(
+            *mut core::ffi::c_void,
+            u32,
+            *mut *mut core::ffi::c_void,
+            *mut u32,
+        ) -> windows_core::HRESULT,
+        pub Skip: unsafe extern "system" fn(*mut core::ffi::c_void, u32) -> windows_core::HRESULT,
+        pub Reset: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
+        pub Clone: unsafe extern "system" fn(
+            *mut core::ffi::c_void,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
+    }
+    windows_core::imp::define_interface!(
+        IDiaEnumSourceLink,
+        IDiaEnumSourceLink_Vtbl,
+        0x45cd1eb3_5c6c_43e3_b20a_a4d8035de4e2
+    );
+    impl core::ops::Deref for IDiaEnumSourceLink {
+        type Target = windows_core::IUnknown;
+        fn deref(&self) -> &Self::Target {
+            unsafe { core::mem::transmute(self) }
+        }
+    }
+    windows_core::imp::interface_hierarchy!(IDiaEnumSourceLink, windows_core::IUnknown);
+    impl IDiaEnumSourceLink {
+        pub unsafe fn Count(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).Count)(
+                windows_core::Interface::as_raw(self),
+                &mut result__,
+            )
+            .map(|| result__)
+        }
+        pub unsafe fn SizeOfNext(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).SizeOfNext)(
+                windows_core::Interface::as_raw(self),
+                &mut result__,
+            )
+            .map(|| result__)
+        }
+        pub unsafe fn Next(&self, pcb: *mut u32, pb: &mut [u8]) -> windows_core::Result<()> {
+            (windows_core::Interface::vtable(self).Next)(
+                windows_core::Interface::as_raw(self),
+                pb.len().try_into().unwrap(),
+                pcb,
+                core::mem::transmute(pb.as_ptr()),
+            )
+            .ok()
+        }
+        pub unsafe fn Skip(&self, cnt: u32) -> windows_core::Result<()> {
+            (windows_core::Interface::vtable(self).Skip)(windows_core::Interface::as_raw(self), cnt)
+                .ok()
+        }
+        pub unsafe fn Reset(&self) -> windows_core::Result<()> {
+            (windows_core::Interface::vtable(self).Reset)(windows_core::Interface::as_raw(self))
+                .ok()
+        }
+        pub unsafe fn Clone(&self) -> windows_core::Result<IDiaEnumSourceLink> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).Clone)(
+                windows_core::Interface::as_raw(self),
+                &mut result__,
+            )
+            .and_then(|| windows_core::Type::from_abi(result__))
+        }
+    }
+    #[repr(C)]
+    pub struct IDiaEnumSourceLink_Vtbl {
+        pub base__: windows_core::IUnknown_Vtbl,
+        pub Count:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+        pub SizeOfNext:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
         pub Next: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             u32,
-            *mut *mut ::core::ffi::c_void,
             *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub Skip:
-            unsafe extern "system" fn(*mut ::core::ffi::c_void, u32) -> ::windows_core::HRESULT,
-        pub Reset: unsafe extern "system" fn(*mut ::core::ffi::c_void) -> ::windows_core::HRESULT,
+            *mut u8,
+        ) -> windows_core::HRESULT,
+        pub Skip: unsafe extern "system" fn(*mut core::ffi::c_void, u32) -> windows_core::HRESULT,
+        pub Reset: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
         pub Clone: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
+    }
+    windows_core::imp::define_interface!(
+        IDiaEnumSourceLink2,
+        IDiaEnumSourceLink2_Vtbl,
+        0x136d8151_ade7_4704_af13_324080762e8f
+    );
+    impl core::ops::Deref for IDiaEnumSourceLink2 {
+        type Target = IDiaEnumSourceLink;
+        fn deref(&self) -> &Self::Target {
+            unsafe { core::mem::transmute(self) }
+        }
+    }
+    windows_core::imp::interface_hierarchy!(
+        IDiaEnumSourceLink2,
+        windows_core::IUnknown,
+        IDiaEnumSourceLink
+    );
+    impl IDiaEnumSourceLink2 {
+        pub unsafe fn SizeOfNext2(&self) -> windows_core::Result<u64> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).SizeOfNext2)(
+                windows_core::Interface::as_raw(self),
+                &mut result__,
+            )
+            .map(|| result__)
+        }
+        pub unsafe fn Next2(&self, pcb: *mut u64, pb: &mut [u8]) -> windows_core::Result<()> {
+            (windows_core::Interface::vtable(self).Next2)(
+                windows_core::Interface::as_raw(self),
+                pb.len().try_into().unwrap(),
+                pcb,
+                core::mem::transmute(pb.as_ptr()),
+            )
+            .ok()
+        }
+    }
+    #[repr(C)]
+    pub struct IDiaEnumSourceLink2_Vtbl {
+        pub base__: IDiaEnumSourceLink_Vtbl,
+        pub SizeOfNext2:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u64) -> windows_core::HRESULT,
+        pub Next2: unsafe extern "system" fn(
+            *mut core::ffi::c_void,
+            u64,
+            *mut u64,
+            *mut u8,
+        ) -> windows_core::HRESULT,
     }
-    ::windows_core::imp::com_interface!(
+    windows_core::imp::define_interface!(
         IDiaEnumStackFrames,
         IDiaEnumStackFrames_Vtbl,
         0xec9d461d_ce74_4711_a020_7d8f9a1dd255
     );
-    ::windows_core::imp::interface_hierarchy!(IDiaEnumStackFrames, ::windows_core::IUnknown);
+    impl core::ops::Deref for IDiaEnumStackFrames {
+        type Target = windows_core::IUnknown;
+        fn deref(&self) -> &Self::Target {
+            unsafe { core::mem::transmute(self) }
+        }
+    }
+    windows_core::imp::interface_hierarchy!(IDiaEnumStackFrames, windows_core::IUnknown);
     impl IDiaEnumStackFrames {
         pub unsafe fn Next(
             &self,
             celt: u32,
-            rgelt: *mut ::core::option::Option<IDiaStackFrame>,
+            rgelt: *mut Option<IDiaStackFrame>,
             pceltfetched: *mut u32,
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self).Next)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<()> {
+            (windows_core::Interface::vtable(self).Next)(
+                windows_core::Interface::as_raw(self),
                 celt,
-                ::core::mem::transmute(rgelt),
+                core::mem::transmute(rgelt),
                 pceltfetched,
             )
             .ok()
         }
-        pub unsafe fn Reset(&self) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self).Reset)(::windows_core::Interface::as_raw(self))
+        pub unsafe fn Reset(&self) -> windows_core::Result<()> {
+            (windows_core::Interface::vtable(self).Reset)(windows_core::Interface::as_raw(self))
                 .ok()
         }
     }
     #[repr(C)]
     pub struct IDiaEnumStackFrames_Vtbl {
-        pub base__: ::windows_core::IUnknown_Vtbl,
+        pub base__: windows_core::IUnknown_Vtbl,
         pub Next: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             u32,
-            *mut *mut ::core::ffi::c_void,
+            *mut *mut core::ffi::c_void,
             *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub Reset: unsafe extern "system" fn(*mut ::core::ffi::c_void) -> ::windows_core::HRESULT,
+        ) -> windows_core::HRESULT,
+        pub Reset: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
     }
-    ::windows_core::imp::com_interface!(
+    windows_core::imp::define_interface!(
         IDiaEnumSymbols,
         IDiaEnumSymbols_Vtbl,
         0xcab72c48_443b_48f5_9b0b_42f0820ab29a
     );
-    ::windows_core::imp::interface_hierarchy!(IDiaEnumSymbols, ::windows_core::IUnknown);
+    impl core::ops::Deref for IDiaEnumSymbols {
+        type Target = windows_core::IUnknown;
+        fn deref(&self) -> &Self::Target {
+            unsafe { core::mem::transmute(self) }
+        }
+    }
+    windows_core::imp::interface_hierarchy!(IDiaEnumSymbols, windows_core::IUnknown);
     impl IDiaEnumSymbols {
-        pub unsafe fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)._NewEnum)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn _NewEnum(&self) -> windows_core::Result<windows_core::IUnknown> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self)._NewEnum)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
-        pub unsafe fn Count(&self) -> ::windows_core::Result<i32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).Count)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn Count(&self) -> windows_core::Result<i32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).Count)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn Item(&self, index: u32) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).Item)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn Item(&self, index: u32) -> windows_core::Result<IDiaSymbol> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).Item)(
+                windows_core::Interface::as_raw(self),
                 index,
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
         pub unsafe fn Next(
             &self,
             celt: u32,
-            rgelt: *mut ::core::option::Option<IDiaSymbol>,
+            rgelt: *mut Option<IDiaSymbol>,
             pceltfetched: *mut u32,
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self).Next)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<()> {
+            (windows_core::Interface::vtable(self).Next)(
+                windows_core::Interface::as_raw(self),
                 celt,
-                ::core::mem::transmute(rgelt),
+                core::mem::transmute(rgelt),
                 pceltfetched,
             )
             .ok()
         }
-        pub unsafe fn Skip(&self, celt: u32) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self).Skip)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn Skip(&self, celt: u32) -> windows_core::Result<()> {
+            (windows_core::Interface::vtable(self).Skip)(
+                windows_core::Interface::as_raw(self),
                 celt,
             )
             .ok()
         }
-        pub unsafe fn Reset(&self) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self).Reset)(::windows_core::Interface::as_raw(self))
+        pub unsafe fn Reset(&self) -> windows_core::Result<()> {
+            (windows_core::Interface::vtable(self).Reset)(windows_core::Interface::as_raw(self))
                 .ok()
         }
-        pub unsafe fn Clone(&self) -> ::windows_core::Result<IDiaEnumSymbols> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).Clone)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn Clone(&self) -> windows_core::Result<IDiaEnumSymbols> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).Clone)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
     }
     #[repr(C)]
     pub struct IDiaEnumSymbols_Vtbl {
-        pub base__: ::windows_core::IUnknown_Vtbl,
+        pub base__: windows_core::IUnknown_Vtbl,
         pub _NewEnum: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
-        pub Count: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut i32,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
+        pub Count:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut i32) -> windows_core::HRESULT,
         pub Item: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             u32,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
         pub Next: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             u32,
-            *mut *mut ::core::ffi::c_void,
+            *mut *mut core::ffi::c_void,
             *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub Skip:
-            unsafe extern "system" fn(*mut ::core::ffi::c_void, u32) -> ::windows_core::HRESULT,
-        pub Reset: unsafe extern "system" fn(*mut ::core::ffi::c_void) -> ::windows_core::HRESULT,
+        ) -> windows_core::HRESULT,
+        pub Skip: unsafe extern "system" fn(*mut core::ffi::c_void, u32) -> windows_core::HRESULT,
+        pub Reset: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
         pub Clone: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
     }
-    ::windows_core::imp::com_interface!(
+    windows_core::imp::define_interface!(
         IDiaEnumSymbolsByAddr,
         IDiaEnumSymbolsByAddr_Vtbl,
         0x624b7d9c_24ea_4421_9d06_3b577471c1fa
     );
-    ::windows_core::imp::interface_hierarchy!(IDiaEnumSymbolsByAddr, ::windows_core::IUnknown);
+    impl core::ops::Deref for IDiaEnumSymbolsByAddr {
+        type Target = windows_core::IUnknown;
+        fn deref(&self) -> &Self::Target {
+            unsafe { core::mem::transmute(self) }
+        }
+    }
+    windows_core::imp::interface_hierarchy!(IDiaEnumSymbolsByAddr, windows_core::IUnknown);
     impl IDiaEnumSymbolsByAddr {
         pub unsafe fn symbolByAddr(
             &self,
             isect: u32,
             offset: u32,
-        ) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).symbolByAddr)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<IDiaSymbol> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).symbolByAddr)(
+                windows_core::Interface::as_raw(self),
                 isect,
                 offset,
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
         pub unsafe fn symbolByRVA(
             &self,
             relativevirtualaddress: u32,
-        ) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).symbolByRVA)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<IDiaSymbol> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).symbolByRVA)(
+                windows_core::Interface::as_raw(self),
                 relativevirtualaddress,
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
-        pub unsafe fn symbolByVA(&self, virtualaddress: u64) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).symbolByVA)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn symbolByVA(&self, virtualaddress: u64) -> windows_core::Result<IDiaSymbol> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).symbolByVA)(
+                windows_core::Interface::as_raw(self),
                 virtualaddress,
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
         pub unsafe fn Next(
             &self,
             celt: u32,
-            rgelt: *mut ::core::option::Option<IDiaSymbol>,
+            rgelt: *mut Option<IDiaSymbol>,
             pceltfetched: *mut u32,
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self).Next)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<()> {
+            (windows_core::Interface::vtable(self).Next)(
+                windows_core::Interface::as_raw(self),
                 celt,
-                ::core::mem::transmute(rgelt),
+                core::mem::transmute(rgelt),
                 pceltfetched,
             )
             .ok()
@@ -1449,212 +1835,147 @@ pub mod Dia {
         pub unsafe fn Prev(
             &self,
             celt: u32,
-            rgelt: *mut ::core::option::Option<IDiaSymbol>,
+            rgelt: *mut Option<IDiaSymbol>,
             pceltfetched: *mut u32,
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self).Prev)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<()> {
+            (windows_core::Interface::vtable(self).Prev)(
+                windows_core::Interface::as_raw(self),
                 celt,
-                ::core::mem::transmute(rgelt),
+                core::mem::transmute(rgelt),
                 pceltfetched,
             )
             .ok()
         }
-        pub unsafe fn Clone(&self) -> ::windows_core::Result<IDiaEnumSymbolsByAddr> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).Clone)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn Clone(&self) -> windows_core::Result<IDiaEnumSymbolsByAddr> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).Clone)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
     }
     #[repr(C)]
     pub struct IDiaEnumSymbolsByAddr_Vtbl {
-        pub base__: ::windows_core::IUnknown_Vtbl,
+        pub base__: windows_core::IUnknown_Vtbl,
         pub symbolByAddr: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             u32,
             u32,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
         pub symbolByRVA: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             u32,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
         pub symbolByVA: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             u64,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
         pub Next: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             u32,
-            *mut *mut ::core::ffi::c_void,
+            *mut *mut core::ffi::c_void,
             *mut u32,
-        ) -> ::windows_core::HRESULT,
+        ) -> windows_core::HRESULT,
         pub Prev: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             u32,
-            *mut *mut ::core::ffi::c_void,
+            *mut *mut core::ffi::c_void,
             *mut u32,
-        ) -> ::windows_core::HRESULT,
+        ) -> windows_core::HRESULT,
         pub Clone: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
     }
-    ::windows_core::imp::com_interface!(
+    windows_core::imp::define_interface!(
         IDiaEnumSymbolsByAddr2,
         IDiaEnumSymbolsByAddr2_Vtbl,
         0x1e45bd02_be45_4d71_ba32_0e576cfcd59f
     );
-    ::windows_core::imp::interface_hierarchy!(
+    impl core::ops::Deref for IDiaEnumSymbolsByAddr2 {
+        type Target = IDiaEnumSymbolsByAddr;
+        fn deref(&self) -> &Self::Target {
+            unsafe { core::mem::transmute(self) }
+        }
+    }
+    windows_core::imp::interface_hierarchy!(
         IDiaEnumSymbolsByAddr2,
-        ::windows_core::IUnknown,
+        windows_core::IUnknown,
         IDiaEnumSymbolsByAddr
     );
     impl IDiaEnumSymbolsByAddr2 {
-        pub unsafe fn symbolByAddr(
-            &self,
-            isect: u32,
-            offset: u32,
-        ) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.symbolByAddr)(
-                ::windows_core::Interface::as_raw(self),
-                isect,
-                offset,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn symbolByRVA(
-            &self,
-            relativevirtualaddress: u32,
-        ) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.symbolByRVA)(
-                ::windows_core::Interface::as_raw(self),
-                relativevirtualaddress,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn symbolByVA(&self, virtualaddress: u64) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.symbolByVA)(
-                ::windows_core::Interface::as_raw(self),
-                virtualaddress,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn Next(
-            &self,
-            celt: u32,
-            rgelt: *mut ::core::option::Option<IDiaSymbol>,
-            pceltfetched: *mut u32,
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self).base__.Next)(
-                ::windows_core::Interface::as_raw(self),
-                celt,
-                ::core::mem::transmute(rgelt),
-                pceltfetched,
-            )
-            .ok()
-        }
-        pub unsafe fn Prev(
-            &self,
-            celt: u32,
-            rgelt: *mut ::core::option::Option<IDiaSymbol>,
-            pceltfetched: *mut u32,
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self).base__.Prev)(
-                ::windows_core::Interface::as_raw(self),
-                celt,
-                ::core::mem::transmute(rgelt),
-                pceltfetched,
-            )
-            .ok()
-        }
-        pub unsafe fn Clone(&self) -> ::windows_core::Result<IDiaEnumSymbolsByAddr> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.Clone)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
         pub unsafe fn symbolByAddrEx<P0>(
             &self,
             fpromoteblocksym: P0,
             isect: u32,
             offset: u32,
-        ) -> ::windows_core::Result<IDiaSymbol>
+        ) -> windows_core::Result<IDiaSymbol>
         where
-            P0: ::windows_core::IntoParam<::windows::Win32::Foundation::BOOL>,
+            P0: windows_core::Param<windows::Win32::Foundation::BOOL>,
         {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).symbolByAddrEx)(
-                ::windows_core::Interface::as_raw(self),
-                fpromoteblocksym.into_param().abi(),
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).symbolByAddrEx)(
+                windows_core::Interface::as_raw(self),
+                fpromoteblocksym.param().abi(),
                 isect,
                 offset,
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
         pub unsafe fn symbolByRVAEx<P0>(
             &self,
             fpromoteblocksym: P0,
             relativevirtualaddress: u32,
-        ) -> ::windows_core::Result<IDiaSymbol>
+        ) -> windows_core::Result<IDiaSymbol>
         where
-            P0: ::windows_core::IntoParam<::windows::Win32::Foundation::BOOL>,
+            P0: windows_core::Param<windows::Win32::Foundation::BOOL>,
         {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).symbolByRVAEx)(
-                ::windows_core::Interface::as_raw(self),
-                fpromoteblocksym.into_param().abi(),
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).symbolByRVAEx)(
+                windows_core::Interface::as_raw(self),
+                fpromoteblocksym.param().abi(),
                 relativevirtualaddress,
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
         pub unsafe fn symbolByVAEx<P0>(
             &self,
             fpromoteblocksym: P0,
             virtualaddress: u64,
-        ) -> ::windows_core::Result<IDiaSymbol>
+        ) -> windows_core::Result<IDiaSymbol>
         where
-            P0: ::windows_core::IntoParam<::windows::Win32::Foundation::BOOL>,
+            P0: windows_core::Param<windows::Win32::Foundation::BOOL>,
         {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).symbolByVAEx)(
-                ::windows_core::Interface::as_raw(self),
-                fpromoteblocksym.into_param().abi(),
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).symbolByVAEx)(
+                windows_core::Interface::as_raw(self),
+                fpromoteblocksym.param().abi(),
                 virtualaddress,
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
         pub unsafe fn NextEx<P0>(
             &self,
             fpromoteblocksym: P0,
             celt: u32,
-            rgelt: *mut ::core::option::Option<IDiaSymbol>,
+            rgelt: *mut Option<IDiaSymbol>,
             pceltfetched: *mut u32,
-        ) -> ::windows_core::Result<()>
+        ) -> windows_core::Result<()>
         where
-            P0: ::windows_core::IntoParam<::windows::Win32::Foundation::BOOL>,
+            P0: windows_core::Param<windows::Win32::Foundation::BOOL>,
         {
-            (::windows_core::Interface::vtable(self).NextEx)(
-                ::windows_core::Interface::as_raw(self),
-                fpromoteblocksym.into_param().abi(),
+            (windows_core::Interface::vtable(self).NextEx)(
+                windows_core::Interface::as_raw(self),
+                fpromoteblocksym.param().abi(),
                 celt,
-                ::core::mem::transmute(rgelt),
+                core::mem::transmute(rgelt),
                 pceltfetched,
             )
             .ok()
@@ -1663,17 +1984,17 @@ pub mod Dia {
             &self,
             fpromoteblocksym: P0,
             celt: u32,
-            rgelt: *mut ::core::option::Option<IDiaSymbol>,
+            rgelt: *mut Option<IDiaSymbol>,
             pceltfetched: *mut u32,
-        ) -> ::windows_core::Result<()>
+        ) -> windows_core::Result<()>
         where
-            P0: ::windows_core::IntoParam<::windows::Win32::Foundation::BOOL>,
+            P0: windows_core::Param<windows::Win32::Foundation::BOOL>,
         {
-            (::windows_core::Interface::vtable(self).PrevEx)(
-                ::windows_core::Interface::as_raw(self),
-                fpromoteblocksym.into_param().abi(),
+            (windows_core::Interface::vtable(self).PrevEx)(
+                windows_core::Interface::as_raw(self),
+                fpromoteblocksym.param().abi(),
                 celt,
-                ::core::mem::transmute(rgelt),
+                core::mem::transmute(rgelt),
                 pceltfetched,
             )
             .ok()
@@ -1683,404 +2004,396 @@ pub mod Dia {
     pub struct IDiaEnumSymbolsByAddr2_Vtbl {
         pub base__: IDiaEnumSymbolsByAddr_Vtbl,
         pub symbolByAddrEx: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            ::windows::Win32::Foundation::BOOL,
+            *mut core::ffi::c_void,
+            windows::Win32::Foundation::BOOL,
             u32,
             u32,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
         pub symbolByRVAEx: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            ::windows::Win32::Foundation::BOOL,
+            *mut core::ffi::c_void,
+            windows::Win32::Foundation::BOOL,
             u32,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
         pub symbolByVAEx: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            ::windows::Win32::Foundation::BOOL,
+            *mut core::ffi::c_void,
+            windows::Win32::Foundation::BOOL,
             u64,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
         pub NextEx: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            ::windows::Win32::Foundation::BOOL,
+            *mut core::ffi::c_void,
+            windows::Win32::Foundation::BOOL,
             u32,
-            *mut *mut ::core::ffi::c_void,
+            *mut *mut core::ffi::c_void,
             *mut u32,
-        ) -> ::windows_core::HRESULT,
+        ) -> windows_core::HRESULT,
         pub PrevEx: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            ::windows::Win32::Foundation::BOOL,
+            *mut core::ffi::c_void,
+            windows::Win32::Foundation::BOOL,
             u32,
-            *mut *mut ::core::ffi::c_void,
+            *mut *mut core::ffi::c_void,
             *mut u32,
-        ) -> ::windows_core::HRESULT,
+        ) -> windows_core::HRESULT,
     }
-    ::windows_core::imp::com_interface!(
+    windows_core::imp::define_interface!(
         IDiaEnumTables,
         IDiaEnumTables_Vtbl,
         0xc65c2b0a_1150_4d7a_afcc_e05bf3dee81e
     );
-    ::windows_core::imp::interface_hierarchy!(IDiaEnumTables, ::windows_core::IUnknown);
+    impl core::ops::Deref for IDiaEnumTables {
+        type Target = windows_core::IUnknown;
+        fn deref(&self) -> &Self::Target {
+            unsafe { core::mem::transmute(self) }
+        }
+    }
+    windows_core::imp::interface_hierarchy!(IDiaEnumTables, windows_core::IUnknown);
     impl IDiaEnumTables {
-        pub unsafe fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)._NewEnum)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn _NewEnum(&self) -> windows_core::Result<windows_core::IUnknown> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self)._NewEnum)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
-        pub unsafe fn Count(&self) -> ::windows_core::Result<i32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).Count)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn Count(&self) -> windows_core::Result<i32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).Count)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn Item<P0>(&self, index: P0) -> ::windows_core::Result<IDiaTable>
+        pub unsafe fn Item<P0>(&self, index: P0) -> windows_core::Result<IDiaTable>
         where
-            P0: ::windows_core::IntoParam<::windows_core::VARIANT>,
+            P0: windows_core::Param<windows_core::VARIANT>,
         {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).Item)(
-                ::windows_core::Interface::as_raw(self),
-                index.into_param().abi(),
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).Item)(
+                windows_core::Interface::as_raw(self),
+                index.param().abi(),
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
         pub unsafe fn Next(
             &self,
             celt: u32,
-            rgelt: *mut ::core::option::Option<IDiaTable>,
+            rgelt: *mut Option<IDiaTable>,
             pceltfetched: *mut u32,
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self).Next)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<()> {
+            (windows_core::Interface::vtable(self).Next)(
+                windows_core::Interface::as_raw(self),
                 celt,
-                ::core::mem::transmute(rgelt),
+                core::mem::transmute(rgelt),
                 pceltfetched,
             )
             .ok()
         }
-        pub unsafe fn Skip(&self, celt: u32) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self).Skip)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn Skip(&self, celt: u32) -> windows_core::Result<()> {
+            (windows_core::Interface::vtable(self).Skip)(
+                windows_core::Interface::as_raw(self),
                 celt,
             )
             .ok()
         }
-        pub unsafe fn Reset(&self) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self).Reset)(::windows_core::Interface::as_raw(self))
+        pub unsafe fn Reset(&self) -> windows_core::Result<()> {
+            (windows_core::Interface::vtable(self).Reset)(windows_core::Interface::as_raw(self))
                 .ok()
         }
-        pub unsafe fn Clone(&self) -> ::windows_core::Result<IDiaEnumTables> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).Clone)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn Clone(&self) -> windows_core::Result<IDiaEnumTables> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).Clone)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
     }
     #[repr(C)]
     pub struct IDiaEnumTables_Vtbl {
-        pub base__: ::windows_core::IUnknown_Vtbl,
+        pub base__: windows_core::IUnknown_Vtbl,
         pub _NewEnum: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
-        pub Count: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut i32,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
+        pub Count:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut i32) -> windows_core::HRESULT,
         pub Item: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            ::std::mem::MaybeUninit<::windows_core::VARIANT>,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            core::mem::MaybeUninit<windows_core::VARIANT>,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
         pub Next: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             u32,
-            *mut *mut ::core::ffi::c_void,
+            *mut *mut core::ffi::c_void,
             *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub Skip:
-            unsafe extern "system" fn(*mut ::core::ffi::c_void, u32) -> ::windows_core::HRESULT,
-        pub Reset: unsafe extern "system" fn(*mut ::core::ffi::c_void) -> ::windows_core::HRESULT,
+        ) -> windows_core::HRESULT,
+        pub Skip: unsafe extern "system" fn(*mut core::ffi::c_void, u32) -> windows_core::HRESULT,
+        pub Reset: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
         pub Clone: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
     }
-    ::windows_core::imp::com_interface!(
+    windows_core::imp::define_interface!(
         IDiaFrameData,
         IDiaFrameData_Vtbl,
         0xa39184b7_6a36_42de_8eec_7df9f3f59f33
     );
-    ::windows_core::imp::interface_hierarchy!(IDiaFrameData, ::windows_core::IUnknown);
+    impl core::ops::Deref for IDiaFrameData {
+        type Target = windows_core::IUnknown;
+        fn deref(&self) -> &Self::Target {
+            unsafe { core::mem::transmute(self) }
+        }
+    }
+    windows_core::imp::interface_hierarchy!(IDiaFrameData, windows_core::IUnknown);
     impl IDiaFrameData {
-        pub unsafe fn addressSection(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).addressSection)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn addressSection(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).addressSection)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn addressOffset(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).addressOffset)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn addressOffset(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).addressOffset)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn relativeVirtualAddress(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).relativeVirtualAddress)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn relativeVirtualAddress(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).relativeVirtualAddress)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn virtualAddress(&self) -> ::windows_core::Result<u64> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).virtualAddress)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn virtualAddress(&self) -> windows_core::Result<u64> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).virtualAddress)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn lengthBlock(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).lengthBlock)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn lengthBlock(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).lengthBlock)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn lengthLocals(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).lengthLocals)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn lengthLocals(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).lengthLocals)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn lengthParams(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).lengthParams)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn lengthParams(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).lengthParams)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn maxStack(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).maxStack)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn maxStack(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).maxStack)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn lengthProlog(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).lengthProlog)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn lengthProlog(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).lengthProlog)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn lengthSavedRegisters(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).lengthSavedRegisters)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn lengthSavedRegisters(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).lengthSavedRegisters)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn program(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).program)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn program(&self) -> windows_core::Result<windows_core::BSTR> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).program)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
         pub unsafe fn systemExceptionHandling(
             &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).systemExceptionHandling)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).systemExceptionHandling)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
         pub unsafe fn cplusplusExceptionHandling(
             &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).cplusplusExceptionHandling)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).cplusplusExceptionHandling)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
         pub unsafe fn functionStart(
             &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).functionStart)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).functionStart)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
         pub unsafe fn allocatesBasePointer(
             &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).allocatesBasePointer)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).allocatesBasePointer)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn r#type(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).r#type)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn r#type(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).r#type)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn functionParent(&self) -> ::windows_core::Result<IDiaFrameData> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).functionParent)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn functionParent(&self) -> windows_core::Result<IDiaFrameData> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).functionParent)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
-        pub unsafe fn execute<P0>(&self, frame: P0) -> ::windows_core::Result<()>
+        pub unsafe fn execute<P0>(&self, frame: P0) -> windows_core::Result<()>
         where
-            P0: ::windows_core::IntoParam<IDiaStackWalkFrame>,
+            P0: windows_core::Param<IDiaStackWalkFrame>,
         {
-            (::windows_core::Interface::vtable(self).execute)(
-                ::windows_core::Interface::as_raw(self),
-                frame.into_param().abi(),
+            (windows_core::Interface::vtable(self).execute)(
+                windows_core::Interface::as_raw(self),
+                frame.param().abi(),
             )
             .ok()
         }
     }
     #[repr(C)]
     pub struct IDiaFrameData_Vtbl {
-        pub base__: ::windows_core::IUnknown_Vtbl,
-        pub addressSection: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub addressOffset: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub relativeVirtualAddress: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub virtualAddress: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u64,
-        ) -> ::windows_core::HRESULT,
-        pub lengthBlock: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub lengthLocals: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub lengthParams: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub maxStack: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub lengthProlog: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub lengthSavedRegisters: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
+        pub base__: windows_core::IUnknown_Vtbl,
+        pub addressSection:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+        pub addressOffset:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+        pub relativeVirtualAddress:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+        pub virtualAddress:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u64) -> windows_core::HRESULT,
+        pub lengthBlock:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+        pub lengthLocals:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+        pub lengthParams:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+        pub maxStack:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+        pub lengthProlog:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+        pub lengthSavedRegisters:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
         pub program: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::std::mem::MaybeUninit<::windows_core::BSTR>,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut core::mem::MaybeUninit<windows_core::BSTR>,
+        ) -> windows_core::HRESULT,
         pub systemExceptionHandling: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub cplusplusExceptionHandling: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        )
-            -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub functionStart: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub allocatesBasePointer: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
-        pub r#type: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
+        pub r#type:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
         pub functionParent: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
         pub execute: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
     }
-    ::windows_core::imp::com_interface!(
+    windows_core::imp::define_interface!(
         IDiaImageData,
         IDiaImageData_Vtbl,
         0xc8e40ed2_a1d9_4221_8692_3ce661184b44
     );
-    ::windows_core::imp::interface_hierarchy!(IDiaImageData, ::windows_core::IUnknown);
+    impl core::ops::Deref for IDiaImageData {
+        type Target = windows_core::IUnknown;
+        fn deref(&self) -> &Self::Target {
+            unsafe { core::mem::transmute(self) }
+        }
+    }
+    windows_core::imp::interface_hierarchy!(IDiaImageData, windows_core::IUnknown);
     impl IDiaImageData {
-        pub unsafe fn relativeVirtualAddress(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).relativeVirtualAddress)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn relativeVirtualAddress(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).relativeVirtualAddress)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn virtualAddress(&self) -> ::windows_core::Result<u64> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).virtualAddress)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn virtualAddress(&self) -> windows_core::Result<u64> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).virtualAddress)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn imageBase(&self) -> ::windows_core::Result<u64> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).imageBase)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn imageBase(&self) -> windows_core::Result<u64> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).imageBase)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
@@ -2088,71 +2401,71 @@ pub mod Dia {
     }
     #[repr(C)]
     pub struct IDiaImageData_Vtbl {
-        pub base__: ::windows_core::IUnknown_Vtbl,
-        pub relativeVirtualAddress: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub virtualAddress: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u64,
-        ) -> ::windows_core::HRESULT,
-        pub imageBase: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u64,
-        ) -> ::windows_core::HRESULT,
-    }
-    ::windows_core::imp::com_interface!(
+        pub base__: windows_core::IUnknown_Vtbl,
+        pub relativeVirtualAddress:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+        pub virtualAddress:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u64) -> windows_core::HRESULT,
+        pub imageBase:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u64) -> windows_core::HRESULT,
+    }
+    windows_core::imp::define_interface!(
         IDiaInjectedSource,
         IDiaInjectedSource_Vtbl,
         0xae605cdc_8105_4a23_b710_3259f1e26112
     );
-    ::windows_core::imp::interface_hierarchy!(IDiaInjectedSource, ::windows_core::IUnknown);
+    impl core::ops::Deref for IDiaInjectedSource {
+        type Target = windows_core::IUnknown;
+        fn deref(&self) -> &Self::Target {
+            unsafe { core::mem::transmute(self) }
+        }
+    }
+    windows_core::imp::interface_hierarchy!(IDiaInjectedSource, windows_core::IUnknown);
     impl IDiaInjectedSource {
-        pub unsafe fn crc(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).crc)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn crc(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).crc)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn length(&self) -> ::windows_core::Result<u64> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).length)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn length(&self) -> windows_core::Result<u64> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).length)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn filename(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).filename)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn filename(&self) -> windows_core::Result<windows_core::BSTR> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).filename)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
-        pub unsafe fn objectFilename(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).objectFilename)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn objectFilename(&self) -> windows_core::Result<windows_core::BSTR> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).objectFilename)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
-        pub unsafe fn virtualFilename(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).virtualFilename)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn virtualFilename(&self) -> windows_core::Result<windows_core::BSTR> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).virtualFilename)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
-        pub unsafe fn sourceCompression(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).sourceCompression)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn sourceCompression(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).sourceCompression)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
@@ -2161,260 +2474,258 @@ pub mod Dia {
             &self,
             pcbdata: *mut u32,
             pbdata: &mut [u8],
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self).get_source)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<()> {
+            (windows_core::Interface::vtable(self).get_source)(
+                windows_core::Interface::as_raw(self),
                 pbdata.len().try_into().unwrap(),
                 pcbdata,
-                ::core::mem::transmute(pbdata.as_ptr()),
+                core::mem::transmute(pbdata.as_ptr()),
             )
             .ok()
         }
     }
     #[repr(C)]
     pub struct IDiaInjectedSource_Vtbl {
-        pub base__: ::windows_core::IUnknown_Vtbl,
-        pub crc: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub length: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u64,
-        ) -> ::windows_core::HRESULT,
+        pub base__: windows_core::IUnknown_Vtbl,
+        pub crc:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+        pub length:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u64) -> windows_core::HRESULT,
         pub filename: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::std::mem::MaybeUninit<::windows_core::BSTR>,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut core::mem::MaybeUninit<windows_core::BSTR>,
+        ) -> windows_core::HRESULT,
         pub objectFilename: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::std::mem::MaybeUninit<::windows_core::BSTR>,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut core::mem::MaybeUninit<windows_core::BSTR>,
+        ) -> windows_core::HRESULT,
         pub virtualFilename: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::std::mem::MaybeUninit<::windows_core::BSTR>,
-        ) -> ::windows_core::HRESULT,
-        pub sourceCompression: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut core::mem::MaybeUninit<windows_core::BSTR>,
+        ) -> windows_core::HRESULT,
+        pub sourceCompression:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
         pub get_source: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             u32,
             *mut u32,
             *mut u8,
-        ) -> ::windows_core::HRESULT,
+        ) -> windows_core::HRESULT,
     }
-    ::windows_core::imp::com_interface!(
+    windows_core::imp::define_interface!(
         IDiaInputAssemblyFile,
         IDiaInputAssemblyFile_Vtbl,
         0x3bfe56b0_390c_4863_9430_1f3d083b7684
     );
-    ::windows_core::imp::interface_hierarchy!(IDiaInputAssemblyFile, ::windows_core::IUnknown);
+    impl core::ops::Deref for IDiaInputAssemblyFile {
+        type Target = windows_core::IUnknown;
+        fn deref(&self) -> &Self::Target {
+            unsafe { core::mem::transmute(self) }
+        }
+    }
+    windows_core::imp::interface_hierarchy!(IDiaInputAssemblyFile, windows_core::IUnknown);
     impl IDiaInputAssemblyFile {
-        pub unsafe fn uniqueId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).uniqueId)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn uniqueId(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).uniqueId)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn index(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).index)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn index(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).index)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn timestamp(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).timestamp)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn timestamp(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).timestamp)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
         pub unsafe fn pdbAvailableAtILMerge(
             &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).pdbAvailableAtILMerge)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).pdbAvailableAtILMerge)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn fileName(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).fileName)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn fileName(&self) -> windows_core::Result<windows_core::BSTR> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).fileName)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
         pub unsafe fn get_version(
             &self,
             pcbdata: *mut u32,
             pbdata: &mut [u8],
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self).get_version)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<()> {
+            (windows_core::Interface::vtable(self).get_version)(
+                windows_core::Interface::as_raw(self),
                 pbdata.len().try_into().unwrap(),
                 pcbdata,
-                ::core::mem::transmute(pbdata.as_ptr()),
+                core::mem::transmute(pbdata.as_ptr()),
             )
             .ok()
         }
     }
     #[repr(C)]
     pub struct IDiaInputAssemblyFile_Vtbl {
-        pub base__: ::windows_core::IUnknown_Vtbl,
-        pub uniqueId: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub index: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub timestamp: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
+        pub base__: windows_core::IUnknown_Vtbl,
+        pub uniqueId:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+        pub index:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+        pub timestamp:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
         pub pdbAvailableAtILMerge: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub fileName: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::std::mem::MaybeUninit<::windows_core::BSTR>,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut core::mem::MaybeUninit<windows_core::BSTR>,
+        ) -> windows_core::HRESULT,
         pub get_version: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             u32,
             *mut u32,
             *mut u8,
-        ) -> ::windows_core::HRESULT,
+        ) -> windows_core::HRESULT,
     }
-    ::windows_core::imp::com_interface!(
+    windows_core::imp::define_interface!(
         IDiaLineNumber,
         IDiaLineNumber_Vtbl,
         0xb388eb14_be4d_421d_a8a1_6cf7ab057086
     );
-    ::windows_core::imp::interface_hierarchy!(IDiaLineNumber, ::windows_core::IUnknown);
+    impl core::ops::Deref for IDiaLineNumber {
+        type Target = windows_core::IUnknown;
+        fn deref(&self) -> &Self::Target {
+            unsafe { core::mem::transmute(self) }
+        }
+    }
+    windows_core::imp::interface_hierarchy!(IDiaLineNumber, windows_core::IUnknown);
     impl IDiaLineNumber {
-        pub unsafe fn compiland(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).compiland)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn compiland(&self) -> windows_core::Result<IDiaSymbol> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).compiland)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
-        pub unsafe fn sourceFile(&self) -> ::windows_core::Result<IDiaSourceFile> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).sourceFile)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn sourceFile(&self) -> windows_core::Result<IDiaSourceFile> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).sourceFile)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
-        pub unsafe fn lineNumber(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).lineNumber)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn lineNumber(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).lineNumber)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn lineNumberEnd(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).lineNumberEnd)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn lineNumberEnd(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).lineNumberEnd)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn columnNumber(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).columnNumber)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn columnNumber(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).columnNumber)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn columnNumberEnd(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).columnNumberEnd)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn columnNumberEnd(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).columnNumberEnd)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn addressSection(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).addressSection)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn addressSection(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).addressSection)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn addressOffset(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).addressOffset)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn addressOffset(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).addressOffset)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn relativeVirtualAddress(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).relativeVirtualAddress)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn relativeVirtualAddress(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).relativeVirtualAddress)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn virtualAddress(&self) -> ::windows_core::Result<u64> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).virtualAddress)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn virtualAddress(&self) -> windows_core::Result<u64> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).virtualAddress)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn length(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).length)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn length(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).length)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn sourceFileId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).sourceFileId)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn sourceFileId(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).sourceFileId)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn statement(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).statement)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn statement(&self) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).statement)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn compilandId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).compilandId)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn compilandId(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).compilandId)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
@@ -2422,98 +2733,82 @@ pub mod Dia {
     }
     #[repr(C)]
     pub struct IDiaLineNumber_Vtbl {
-        pub base__: ::windows_core::IUnknown_Vtbl,
+        pub base__: windows_core::IUnknown_Vtbl,
         pub compiland: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
         pub sourceFile: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
-        pub lineNumber: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub lineNumberEnd: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub columnNumber: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub columnNumberEnd: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub addressSection: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub addressOffset: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub relativeVirtualAddress: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub virtualAddress: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u64,
-        ) -> ::windows_core::HRESULT,
-        pub length: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub sourceFileId: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
+        pub lineNumber:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+        pub lineNumberEnd:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+        pub columnNumber:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+        pub columnNumberEnd:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+        pub addressSection:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+        pub addressOffset:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+        pub relativeVirtualAddress:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+        pub virtualAddress:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u64) -> windows_core::HRESULT,
+        pub length:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+        pub sourceFileId:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
         pub statement: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
-        pub compilandId: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
+        pub compilandId:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
     }
-    ::windows_core::imp::com_interface!(
+    windows_core::imp::define_interface!(
         IDiaLoadCallback,
         IDiaLoadCallback_Vtbl,
         0xc32adb82_73f4_421b_95d5_a4706edf5dbe
     );
-    ::windows_core::imp::interface_hierarchy!(IDiaLoadCallback, ::windows_core::IUnknown);
+    impl core::ops::Deref for IDiaLoadCallback {
+        type Target = windows_core::IUnknown;
+        fn deref(&self) -> &Self::Target {
+            unsafe { core::mem::transmute(self) }
+        }
+    }
+    windows_core::imp::interface_hierarchy!(IDiaLoadCallback, windows_core::IUnknown);
     impl IDiaLoadCallback {
         pub unsafe fn NotifyDebugDir<P0>(
             &self,
             fexecutable: P0,
             pbdata: &[u8],
-        ) -> ::windows_core::Result<()>
+        ) -> windows_core::Result<()>
         where
-            P0: ::windows_core::IntoParam<::windows::Win32::Foundation::BOOL>,
+            P0: windows_core::Param<windows::Win32::Foundation::BOOL>,
         {
-            (::windows_core::Interface::vtable(self).NotifyDebugDir)(
-                ::windows_core::Interface::as_raw(self),
-                fexecutable.into_param().abi(),
+            (windows_core::Interface::vtable(self).NotifyDebugDir)(
+                windows_core::Interface::as_raw(self),
+                fexecutable.param().abi(),
                 pbdata.len().try_into().unwrap(),
-                ::core::mem::transmute(pbdata.as_ptr()),
+                core::mem::transmute(pbdata.as_ptr()),
             )
             .ok()
         }
         pub unsafe fn NotifyOpenDBG<P0>(
             &self,
             dbgpath: P0,
-            resultcode: ::windows_core::HRESULT,
-        ) -> ::windows_core::Result<()>
+            resultcode: windows_core::HRESULT,
+        ) -> windows_core::Result<()>
         where
-            P0: ::windows_core::IntoParam<::windows_core::PCWSTR>,
+            P0: windows_core::Param<windows_core::PCWSTR>,
         {
-            (::windows_core::Interface::vtable(self).NotifyOpenDBG)(
-                ::windows_core::Interface::as_raw(self),
-                dbgpath.into_param().abi(),
+            (windows_core::Interface::vtable(self).NotifyOpenDBG)(
+                windows_core::Interface::as_raw(self),
+                dbgpath.param().abi(),
                 resultcode,
             )
             .ok()
@@ -2521,147 +2816,93 @@ pub mod Dia {
         pub unsafe fn NotifyOpenPDB<P0>(
             &self,
             pdbpath: P0,
-            resultcode: ::windows_core::HRESULT,
-        ) -> ::windows_core::Result<()>
+            resultcode: windows_core::HRESULT,
+        ) -> windows_core::Result<()>
         where
-            P0: ::windows_core::IntoParam<::windows_core::PCWSTR>,
+            P0: windows_core::Param<windows_core::PCWSTR>,
         {
-            (::windows_core::Interface::vtable(self).NotifyOpenPDB)(
-                ::windows_core::Interface::as_raw(self),
-                pdbpath.into_param().abi(),
+            (windows_core::Interface::vtable(self).NotifyOpenPDB)(
+                windows_core::Interface::as_raw(self),
+                pdbpath.param().abi(),
                 resultcode,
             )
             .ok()
         }
-        pub unsafe fn RestrictRegistryAccess(&self) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self).RestrictRegistryAccess)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn RestrictRegistryAccess(&self) -> windows_core::Result<()> {
+            (windows_core::Interface::vtable(self).RestrictRegistryAccess)(
+                windows_core::Interface::as_raw(self),
             )
             .ok()
         }
-        pub unsafe fn RestrictSymbolServerAccess(&self) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self).RestrictSymbolServerAccess)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn RestrictSymbolServerAccess(&self) -> windows_core::Result<()> {
+            (windows_core::Interface::vtable(self).RestrictSymbolServerAccess)(
+                windows_core::Interface::as_raw(self),
             )
             .ok()
         }
     }
     #[repr(C)]
     pub struct IDiaLoadCallback_Vtbl {
-        pub base__: ::windows_core::IUnknown_Vtbl,
+        pub base__: windows_core::IUnknown_Vtbl,
         pub NotifyDebugDir: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            ::windows::Win32::Foundation::BOOL,
+            *mut core::ffi::c_void,
+            windows::Win32::Foundation::BOOL,
             u32,
             *const u8,
-        ) -> ::windows_core::HRESULT,
+        ) -> windows_core::HRESULT,
         pub NotifyOpenDBG: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            ::windows_core::PCWSTR,
-            ::windows_core::HRESULT,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            windows_core::PCWSTR,
+            windows_core::HRESULT,
+        ) -> windows_core::HRESULT,
         pub NotifyOpenPDB: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            ::windows_core::PCWSTR,
-            ::windows_core::HRESULT,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            windows_core::PCWSTR,
+            windows_core::HRESULT,
+        ) -> windows_core::HRESULT,
         pub RestrictRegistryAccess:
-            unsafe extern "system" fn(*mut ::core::ffi::c_void) -> ::windows_core::HRESULT,
+            unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
         pub RestrictSymbolServerAccess:
-            unsafe extern "system" fn(*mut ::core::ffi::c_void) -> ::windows_core::HRESULT,
+            unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
     }
-    ::windows_core::imp::com_interface!(
+    windows_core::imp::define_interface!(
         IDiaLoadCallback2,
         IDiaLoadCallback2_Vtbl,
         0x4688a074_5a4d_4486_aea8_7b90711d9f7c
     );
-    ::windows_core::imp::interface_hierarchy!(
+    impl core::ops::Deref for IDiaLoadCallback2 {
+        type Target = IDiaLoadCallback;
+        fn deref(&self) -> &Self::Target {
+            unsafe { core::mem::transmute(self) }
+        }
+    }
+    windows_core::imp::interface_hierarchy!(
         IDiaLoadCallback2,
-        ::windows_core::IUnknown,
+        windows_core::IUnknown,
         IDiaLoadCallback
     );
     impl IDiaLoadCallback2 {
-        pub unsafe fn NotifyDebugDir<P0>(
-            &self,
-            fexecutable: P0,
-            pbdata: &[u8],
-        ) -> ::windows_core::Result<()>
-        where
-            P0: ::windows_core::IntoParam<::windows::Win32::Foundation::BOOL>,
-        {
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .NotifyDebugDir)(
-                ::windows_core::Interface::as_raw(self),
-                fexecutable.into_param().abi(),
-                pbdata.len().try_into().unwrap(),
-                ::core::mem::transmute(pbdata.as_ptr()),
-            )
-            .ok()
-        }
-        pub unsafe fn NotifyOpenDBG<P0>(
-            &self,
-            dbgpath: P0,
-            resultcode: ::windows_core::HRESULT,
-        ) -> ::windows_core::Result<()>
-        where
-            P0: ::windows_core::IntoParam<::windows_core::PCWSTR>,
-        {
-            (::windows_core::Interface::vtable(self).base__.NotifyOpenDBG)(
-                ::windows_core::Interface::as_raw(self),
-                dbgpath.into_param().abi(),
-                resultcode,
-            )
-            .ok()
-        }
-        pub unsafe fn NotifyOpenPDB<P0>(
-            &self,
-            pdbpath: P0,
-            resultcode: ::windows_core::HRESULT,
-        ) -> ::windows_core::Result<()>
-        where
-            P0: ::windows_core::IntoParam<::windows_core::PCWSTR>,
-        {
-            (::windows_core::Interface::vtable(self).base__.NotifyOpenPDB)(
-                ::windows_core::Interface::as_raw(self),
-                pdbpath.into_param().abi(),
-                resultcode,
-            )
-            .ok()
-        }
-        pub unsafe fn RestrictRegistryAccess(&self) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .RestrictRegistryAccess)(::windows_core::Interface::as_raw(self))
-            .ok()
-        }
-        pub unsafe fn RestrictSymbolServerAccess(&self) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .RestrictSymbolServerAccess)(::windows_core::Interface::as_raw(self))
-            .ok()
-        }
-        pub unsafe fn RestrictOriginalPathAccess(&self) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self).RestrictOriginalPathAccess)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn RestrictOriginalPathAccess(&self) -> windows_core::Result<()> {
+            (windows_core::Interface::vtable(self).RestrictOriginalPathAccess)(
+                windows_core::Interface::as_raw(self),
             )
             .ok()
         }
-        pub unsafe fn RestrictReferencePathAccess(&self) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self).RestrictReferencePathAccess)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn RestrictReferencePathAccess(&self) -> windows_core::Result<()> {
+            (windows_core::Interface::vtable(self).RestrictReferencePathAccess)(
+                windows_core::Interface::as_raw(self),
             )
             .ok()
         }
-        pub unsafe fn RestrictDBGAccess(&self) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self).RestrictDBGAccess)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn RestrictDBGAccess(&self) -> windows_core::Result<()> {
+            (windows_core::Interface::vtable(self).RestrictDBGAccess)(
+                windows_core::Interface::as_raw(self),
             )
             .ok()
         }
-        pub unsafe fn RestrictSystemRootAccess(&self) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self).RestrictSystemRootAccess)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn RestrictSystemRootAccess(&self) -> windows_core::Result<()> {
+            (windows_core::Interface::vtable(self).RestrictSystemRootAccess)(
+                windows_core::Interface::as_raw(self),
             )
             .ok()
         }
@@ -2670,32 +2911,38 @@ pub mod Dia {
     pub struct IDiaLoadCallback2_Vtbl {
         pub base__: IDiaLoadCallback_Vtbl,
         pub RestrictOriginalPathAccess:
-            unsafe extern "system" fn(*mut ::core::ffi::c_void) -> ::windows_core::HRESULT,
+            unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
         pub RestrictReferencePathAccess:
-            unsafe extern "system" fn(*mut ::core::ffi::c_void) -> ::windows_core::HRESULT,
+            unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
         pub RestrictDBGAccess:
-            unsafe extern "system" fn(*mut ::core::ffi::c_void) -> ::windows_core::HRESULT,
+            unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
         pub RestrictSystemRootAccess:
-            unsafe extern "system" fn(*mut ::core::ffi::c_void) -> ::windows_core::HRESULT,
+            unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
     }
-    ::windows_core::imp::com_interface!(
+    windows_core::imp::define_interface!(
         IDiaPropertyStorage,
         IDiaPropertyStorage_Vtbl,
         0x9d416f9c_e184_45b2_a4f0_ce517f719e9b
     );
-    ::windows_core::imp::interface_hierarchy!(IDiaPropertyStorage, ::windows_core::IUnknown);
+    impl core::ops::Deref for IDiaPropertyStorage {
+        type Target = windows_core::IUnknown;
+        fn deref(&self) -> &Self::Target {
+            unsafe { core::mem::transmute(self) }
+        }
+    }
+    windows_core::imp::interface_hierarchy!(IDiaPropertyStorage, windows_core::IUnknown);
     impl IDiaPropertyStorage {
         pub unsafe fn ReadMultiple(
             &self,
             cpspec: u32,
-            rgpspec: *const ::windows::Win32::System::Com::StructuredStorage::PROPSPEC,
-            rgvar: *mut ::windows_core::PROPVARIANT,
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self).ReadMultiple)(
-                ::windows_core::Interface::as_raw(self),
+            rgpspec: *const windows::Win32::System::Com::StructuredStorage::PROPSPEC,
+            rgvar: *mut windows_core::PROPVARIANT,
+        ) -> windows_core::Result<()> {
+            (windows_core::Interface::vtable(self).ReadMultiple)(
+                windows_core::Interface::as_raw(self),
                 cpspec,
                 rgpspec,
-                ::core::mem::transmute(rgvar),
+                core::mem::transmute(rgvar),
             )
             .ok()
         }
@@ -2703,41 +2950,40 @@ pub mod Dia {
             &self,
             cpropid: u32,
             rgpropid: *const u32,
-            rglpwstrname: *mut ::windows_core::BSTR,
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self).ReadPropertyNames)(
-                ::windows_core::Interface::as_raw(self),
+            rglpwstrname: *mut windows_core::BSTR,
+        ) -> windows_core::Result<()> {
+            (windows_core::Interface::vtable(self).ReadPropertyNames)(
+                windows_core::Interface::as_raw(self),
                 cpropid,
                 rgpropid,
-                ::core::mem::transmute(rglpwstrname),
+                core::mem::transmute(rglpwstrname),
             )
             .ok()
         }
         pub unsafe fn Enum(
             &self,
-        ) -> ::windows_core::Result<
-            ::windows::Win32::System::Com::StructuredStorage::IEnumSTATPROPSTG,
-        > {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).Enum)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<windows::Win32::System::Com::StructuredStorage::IEnumSTATPROPSTG>
+        {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).Enum)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
-        pub unsafe fn ReadDWORD(&self, id: u32) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).ReadDWORD)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn ReadDWORD(&self, id: u32) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).ReadDWORD)(
+                windows_core::Interface::as_raw(self),
                 id,
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn ReadLONG(&self, id: u32) -> ::windows_core::Result<i32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).ReadLONG)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn ReadLONG(&self, id: u32) -> windows_core::Result<i32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).ReadLONG)(
+                windows_core::Interface::as_raw(self),
                 id,
                 &mut result__,
             )
@@ -2746,341 +2992,348 @@ pub mod Dia {
         pub unsafe fn ReadBOOL(
             &self,
             id: u32,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).ReadBOOL)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).ReadBOOL)(
+                windows_core::Interface::as_raw(self),
                 id,
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn ReadULONGLONG(&self, id: u32) -> ::windows_core::Result<u64> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).ReadULONGLONG)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn ReadULONGLONG(&self, id: u32) -> windows_core::Result<u64> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).ReadULONGLONG)(
+                windows_core::Interface::as_raw(self),
                 id,
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn ReadBSTR(&self, id: u32) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).ReadBSTR)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn ReadBSTR(&self, id: u32) -> windows_core::Result<windows_core::BSTR> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).ReadBSTR)(
+                windows_core::Interface::as_raw(self),
                 id,
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
     }
     #[repr(C)]
     pub struct IDiaPropertyStorage_Vtbl {
-        pub base__: ::windows_core::IUnknown_Vtbl,
+        pub base__: windows_core::IUnknown_Vtbl,
         pub ReadMultiple: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             u32,
-            *const ::windows::Win32::System::Com::StructuredStorage::PROPSPEC,
-            *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>,
-        ) -> ::windows_core::HRESULT,
+            *const windows::Win32::System::Com::StructuredStorage::PROPSPEC,
+            *mut core::mem::MaybeUninit<windows_core::PROPVARIANT>,
+        ) -> windows_core::HRESULT,
         pub ReadPropertyNames: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             u32,
             *const u32,
-            *mut ::std::mem::MaybeUninit<::windows_core::BSTR>,
-        ) -> ::windows_core::HRESULT,
+            *mut core::mem::MaybeUninit<windows_core::BSTR>,
+        ) -> windows_core::HRESULT,
         pub Enum: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
         pub ReadDWORD: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             u32,
             *mut u32,
-        ) -> ::windows_core::HRESULT,
+        ) -> windows_core::HRESULT,
         pub ReadLONG: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             u32,
             *mut i32,
-        ) -> ::windows_core::HRESULT,
+        ) -> windows_core::HRESULT,
         pub ReadBOOL: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             u32,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub ReadULONGLONG: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             u32,
             *mut u64,
-        ) -> ::windows_core::HRESULT,
+        ) -> windows_core::HRESULT,
         pub ReadBSTR: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             u32,
-            *mut ::std::mem::MaybeUninit<::windows_core::BSTR>,
-        ) -> ::windows_core::HRESULT,
+            *mut core::mem::MaybeUninit<windows_core::BSTR>,
+        ) -> windows_core::HRESULT,
     }
-    ::windows_core::imp::com_interface!(
+    windows_core::imp::define_interface!(
         IDiaReadExeAtOffsetCallback,
         IDiaReadExeAtOffsetCallback_Vtbl,
         0x587a461c_b80b_4f54_9194_5032589a6319
     );
-    ::windows_core::imp::interface_hierarchy!(
-        IDiaReadExeAtOffsetCallback,
-        ::windows_core::IUnknown
-    );
+    impl core::ops::Deref for IDiaReadExeAtOffsetCallback {
+        type Target = windows_core::IUnknown;
+        fn deref(&self) -> &Self::Target {
+            unsafe { core::mem::transmute(self) }
+        }
+    }
+    windows_core::imp::interface_hierarchy!(IDiaReadExeAtOffsetCallback, windows_core::IUnknown);
     impl IDiaReadExeAtOffsetCallback {
         pub unsafe fn ReadExecutableAt(
             &self,
             fileoffset: u64,
             pcbdata: *mut u32,
             pbdata: &mut [u8],
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self).ReadExecutableAt)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<()> {
+            (windows_core::Interface::vtable(self).ReadExecutableAt)(
+                windows_core::Interface::as_raw(self),
                 fileoffset,
                 pbdata.len().try_into().unwrap(),
                 pcbdata,
-                ::core::mem::transmute(pbdata.as_ptr()),
+                core::mem::transmute(pbdata.as_ptr()),
             )
             .ok()
         }
     }
     #[repr(C)]
     pub struct IDiaReadExeAtOffsetCallback_Vtbl {
-        pub base__: ::windows_core::IUnknown_Vtbl,
+        pub base__: windows_core::IUnknown_Vtbl,
         pub ReadExecutableAt: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             u64,
             u32,
             *mut u32,
             *mut u8,
-        ) -> ::windows_core::HRESULT,
+        ) -> windows_core::HRESULT,
     }
-    ::windows_core::imp::com_interface!(
+    windows_core::imp::define_interface!(
         IDiaReadExeAtRVACallback,
         IDiaReadExeAtRVACallback_Vtbl,
         0x8e3f80ca_7517_432a_ba07_285134aaea8e
     );
-    ::windows_core::imp::interface_hierarchy!(IDiaReadExeAtRVACallback, ::windows_core::IUnknown);
+    impl core::ops::Deref for IDiaReadExeAtRVACallback {
+        type Target = windows_core::IUnknown;
+        fn deref(&self) -> &Self::Target {
+            unsafe { core::mem::transmute(self) }
+        }
+    }
+    windows_core::imp::interface_hierarchy!(IDiaReadExeAtRVACallback, windows_core::IUnknown);
     impl IDiaReadExeAtRVACallback {
         pub unsafe fn ReadExecutableAtRVA(
             &self,
             relativevirtualaddress: u32,
             pcbdata: *mut u32,
             pbdata: &mut [u8],
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self).ReadExecutableAtRVA)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<()> {
+            (windows_core::Interface::vtable(self).ReadExecutableAtRVA)(
+                windows_core::Interface::as_raw(self),
                 relativevirtualaddress,
                 pbdata.len().try_into().unwrap(),
                 pcbdata,
-                ::core::mem::transmute(pbdata.as_ptr()),
+                core::mem::transmute(pbdata.as_ptr()),
             )
             .ok()
         }
     }
     #[repr(C)]
     pub struct IDiaReadExeAtRVACallback_Vtbl {
-        pub base__: ::windows_core::IUnknown_Vtbl,
+        pub base__: windows_core::IUnknown_Vtbl,
         pub ReadExecutableAtRVA: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             u32,
             u32,
             *mut u32,
             *mut u8,
-        ) -> ::windows_core::HRESULT,
+        ) -> windows_core::HRESULT,
     }
-    ::windows_core::imp::com_interface!(
+    windows_core::imp::define_interface!(
         IDiaSectionContrib,
         IDiaSectionContrib_Vtbl,
         0x0cf4b60e_35b1_4c6c_bdd8_854b9c8e3857
     );
-    ::windows_core::imp::interface_hierarchy!(IDiaSectionContrib, ::windows_core::IUnknown);
+    impl core::ops::Deref for IDiaSectionContrib {
+        type Target = windows_core::IUnknown;
+        fn deref(&self) -> &Self::Target {
+            unsafe { core::mem::transmute(self) }
+        }
+    }
+    windows_core::imp::interface_hierarchy!(IDiaSectionContrib, windows_core::IUnknown);
     impl IDiaSectionContrib {
-        pub unsafe fn compiland(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).compiland)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn compiland(&self) -> windows_core::Result<IDiaSymbol> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).compiland)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
-        pub unsafe fn addressSection(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).addressSection)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn addressSection(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).addressSection)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn addressOffset(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).addressOffset)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn addressOffset(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).addressOffset)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn relativeVirtualAddress(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).relativeVirtualAddress)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn relativeVirtualAddress(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).relativeVirtualAddress)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn virtualAddress(&self) -> ::windows_core::Result<u64> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).virtualAddress)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn virtualAddress(&self) -> windows_core::Result<u64> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).virtualAddress)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn length(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).length)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn length(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).length)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn notPaged(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).notPaged)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn notPaged(&self) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).notPaged)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn code(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).code)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn code(&self) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).code)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
         pub unsafe fn initializedData(
             &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).initializedData)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).initializedData)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
         pub unsafe fn uninitializedData(
             &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).uninitializedData)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).uninitializedData)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn remove(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).remove)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn remove(&self) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).remove)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn comdat(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).comdat)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn comdat(&self) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).comdat)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn discardable(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).discardable)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn discardable(&self) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).discardable)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn notCached(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).notCached)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn notCached(&self) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).notCached)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn share(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).share)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn share(&self) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).share)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn execute(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).execute)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn execute(&self) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).execute)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn read(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).read)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn read(&self) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).read)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn write(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).write)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn write(&self) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).write)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn dataCrc(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).dataCrc)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn dataCrc(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).dataCrc)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn relocationsCrc(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).relocationsCrc)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn relocationsCrc(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).relocationsCrc)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn compilandId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).compilandId)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn compilandId(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).compilandId)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn code16bit(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).code16bit)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn code16bit(&self) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).code16bit)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
@@ -3088,171 +3341,161 @@ pub mod Dia {
     }
     #[repr(C)]
     pub struct IDiaSectionContrib_Vtbl {
-        pub base__: ::windows_core::IUnknown_Vtbl,
+        pub base__: windows_core::IUnknown_Vtbl,
         pub compiland: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
-        pub addressSection: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub addressOffset: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub relativeVirtualAddress: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub virtualAddress: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u64,
-        ) -> ::windows_core::HRESULT,
-        pub length: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
+        pub addressSection:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+        pub addressOffset:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+        pub relativeVirtualAddress:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+        pub virtualAddress:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u64) -> windows_core::HRESULT,
+        pub length:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
         pub notPaged: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub code: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub initializedData: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub uninitializedData: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub remove: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub comdat: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub discardable: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub notCached: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub share: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub execute: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub read: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub write: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
-        pub dataCrc: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub relocationsCrc: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub compilandId: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
+        pub dataCrc:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+        pub relocationsCrc:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+        pub compilandId:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
         pub code16bit: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
     }
-    ::windows_core::imp::com_interface!(
+    windows_core::imp::define_interface!(
         IDiaSegment,
         IDiaSegment_Vtbl,
         0x0775b784_c75b_4449_848b_b7bd3159545b
     );
-    ::windows_core::imp::interface_hierarchy!(IDiaSegment, ::windows_core::IUnknown);
+    impl core::ops::Deref for IDiaSegment {
+        type Target = windows_core::IUnknown;
+        fn deref(&self) -> &Self::Target {
+            unsafe { core::mem::transmute(self) }
+        }
+    }
+    windows_core::imp::interface_hierarchy!(IDiaSegment, windows_core::IUnknown);
     impl IDiaSegment {
-        pub unsafe fn frame(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).frame)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn frame(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).frame)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn offset(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).offset)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn offset(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).offset)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn length(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).length)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn length(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).length)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn read(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).read)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn read(&self) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).read)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn write(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).write)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn write(&self) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).write)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn execute(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).execute)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn execute(&self) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).execute)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn addressSection(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).addressSection)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn addressSection(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).addressSection)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn relativeVirtualAddress(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).relativeVirtualAddress)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn relativeVirtualAddress(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).relativeVirtualAddress)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn virtualAddress(&self) -> ::windows_core::Result<u64> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).virtualAddress)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn virtualAddress(&self) -> windows_core::Result<u64> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).virtualAddress)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
@@ -3260,89 +3503,83 @@ pub mod Dia {
     }
     #[repr(C)]
     pub struct IDiaSegment_Vtbl {
-        pub base__: ::windows_core::IUnknown_Vtbl,
-        pub frame: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub offset: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub length: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
+        pub base__: windows_core::IUnknown_Vtbl,
+        pub frame:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+        pub offset:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+        pub length:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
         pub read: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub write: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub execute: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
-        pub addressSection: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub relativeVirtualAddress: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub virtualAddress: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u64,
-        ) -> ::windows_core::HRESULT,
-    }
-    ::windows_core::imp::com_interface!(
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
+        pub addressSection:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+        pub relativeVirtualAddress:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+        pub virtualAddress:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u64) -> windows_core::HRESULT,
+    }
+    windows_core::imp::define_interface!(
         IDiaSession,
         IDiaSession_Vtbl,
         0x2f609ee1_d1c8_4e24_8288_3326badcd211
     );
-    ::windows_core::imp::interface_hierarchy!(IDiaSession, ::windows_core::IUnknown);
+    impl core::ops::Deref for IDiaSession {
+        type Target = windows_core::IUnknown;
+        fn deref(&self) -> &Self::Target {
+            unsafe { core::mem::transmute(self) }
+        }
+    }
+    windows_core::imp::interface_hierarchy!(IDiaSession, windows_core::IUnknown);
     impl IDiaSession {
-        pub unsafe fn loadAddress(&self) -> ::windows_core::Result<u64> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).loadAddress)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn loadAddress(&self) -> windows_core::Result<u64> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).loadAddress)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn SetloadAddress(&self, newval: u64) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self).SetloadAddress)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn SetloadAddress(&self, newval: u64) -> windows_core::Result<()> {
+            (windows_core::Interface::vtable(self).SetloadAddress)(
+                windows_core::Interface::as_raw(self),
                 newval,
             )
             .ok()
         }
-        pub unsafe fn globalScope(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).globalScope)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn globalScope(&self) -> windows_core::Result<IDiaSymbol> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).globalScope)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
-        pub unsafe fn getEnumTables(&self) -> ::windows_core::Result<IDiaEnumTables> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).getEnumTables)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn getEnumTables(&self) -> windows_core::Result<IDiaEnumTables> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).getEnumTables)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
-        pub unsafe fn getSymbolsByAddr(&self) -> ::windows_core::Result<IDiaEnumSymbolsByAddr> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).getSymbolsByAddr)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn getSymbolsByAddr(&self) -> windows_core::Result<IDiaEnumSymbolsByAddr> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).getSymbolsByAddr)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
         pub unsafe fn findChildren<P0, P1>(
             &self,
@@ -3350,21 +3587,21 @@ pub mod Dia {
             symtag: SymTag,
             name: P1,
             compareflags: u32,
-        ) -> ::windows_core::Result<IDiaEnumSymbols>
+        ) -> windows_core::Result<IDiaEnumSymbols>
         where
-            P0: ::windows_core::IntoParam<IDiaSymbol>,
-            P1: ::windows_core::IntoParam<::windows_core::PCWSTR>,
+            P0: windows_core::Param<IDiaSymbol>,
+            P1: windows_core::Param<windows_core::PCWSTR>,
         {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).findChildren)(
-                ::windows_core::Interface::as_raw(self),
-                parent.into_param().abi(),
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).findChildren)(
+                windows_core::Interface::as_raw(self),
+                parent.param().abi(),
                 symtag,
-                name.into_param().abi(),
+                name.param().abi(),
                 compareflags,
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
         pub unsafe fn findChildrenEx<P0, P1>(
             &self,
@@ -3372,21 +3609,21 @@ pub mod Dia {
             symtag: SymTag,
             name: P1,
             compareflags: u32,
-        ) -> ::windows_core::Result<IDiaEnumSymbols>
+        ) -> windows_core::Result<IDiaEnumSymbols>
         where
-            P0: ::windows_core::IntoParam<IDiaSymbol>,
-            P1: ::windows_core::IntoParam<::windows_core::PCWSTR>,
+            P0: windows_core::Param<IDiaSymbol>,
+            P1: windows_core::Param<windows_core::PCWSTR>,
         {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).findChildrenEx)(
-                ::windows_core::Interface::as_raw(self),
-                parent.into_param().abi(),
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).findChildrenEx)(
+                windows_core::Interface::as_raw(self),
+                parent.param().abi(),
                 symtag,
-                name.into_param().abi(),
+                name.param().abi(),
                 compareflags,
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
         pub unsafe fn findChildrenExByAddr<P0, P1>(
             &self,
@@ -3396,23 +3633,23 @@ pub mod Dia {
             compareflags: u32,
             isect: u32,
             offset: u32,
-        ) -> ::windows_core::Result<IDiaEnumSymbols>
+        ) -> windows_core::Result<IDiaEnumSymbols>
         where
-            P0: ::windows_core::IntoParam<IDiaSymbol>,
-            P1: ::windows_core::IntoParam<::windows_core::PCWSTR>,
+            P0: windows_core::Param<IDiaSymbol>,
+            P1: windows_core::Param<windows_core::PCWSTR>,
         {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).findChildrenExByAddr)(
-                ::windows_core::Interface::as_raw(self),
-                parent.into_param().abi(),
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).findChildrenExByAddr)(
+                windows_core::Interface::as_raw(self),
+                parent.param().abi(),
                 symtag,
-                name.into_param().abi(),
+                name.param().abi(),
                 compareflags,
                 isect,
                 offset,
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
         pub unsafe fn findChildrenExByVA<P0, P1>(
             &self,
@@ -3421,22 +3658,22 @@ pub mod Dia {
             name: P1,
             compareflags: u32,
             va: u64,
-        ) -> ::windows_core::Result<IDiaEnumSymbols>
+        ) -> windows_core::Result<IDiaEnumSymbols>
         where
-            P0: ::windows_core::IntoParam<IDiaSymbol>,
-            P1: ::windows_core::IntoParam<::windows_core::PCWSTR>,
+            P0: windows_core::Param<IDiaSymbol>,
+            P1: windows_core::Param<windows_core::PCWSTR>,
         {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).findChildrenExByVA)(
-                ::windows_core::Interface::as_raw(self),
-                parent.into_param().abi(),
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).findChildrenExByVA)(
+                windows_core::Interface::as_raw(self),
+                parent.param().abi(),
                 symtag,
-                name.into_param().abi(),
+                name.param().abi(),
                 compareflags,
                 va,
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
         pub unsafe fn findChildrenExByRVA<P0, P1>(
             &self,
@@ -3445,118 +3682,118 @@ pub mod Dia {
             name: P1,
             compareflags: u32,
             rva: u32,
-        ) -> ::windows_core::Result<IDiaEnumSymbols>
+        ) -> windows_core::Result<IDiaEnumSymbols>
         where
-            P0: ::windows_core::IntoParam<IDiaSymbol>,
-            P1: ::windows_core::IntoParam<::windows_core::PCWSTR>,
+            P0: windows_core::Param<IDiaSymbol>,
+            P1: windows_core::Param<windows_core::PCWSTR>,
         {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).findChildrenExByRVA)(
-                ::windows_core::Interface::as_raw(self),
-                parent.into_param().abi(),
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).findChildrenExByRVA)(
+                windows_core::Interface::as_raw(self),
+                parent.param().abi(),
                 symtag,
-                name.into_param().abi(),
+                name.param().abi(),
                 compareflags,
                 rva,
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
         pub unsafe fn findSymbolByAddr(
             &self,
             isect: u32,
             offset: u32,
             symtag: SymTag,
-        ) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).findSymbolByAddr)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<IDiaSymbol> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).findSymbolByAddr)(
+                windows_core::Interface::as_raw(self),
                 isect,
                 offset,
                 symtag,
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
         pub unsafe fn findSymbolByRVA(
             &self,
             rva: u32,
             symtag: SymTag,
-        ) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).findSymbolByRVA)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<IDiaSymbol> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).findSymbolByRVA)(
+                windows_core::Interface::as_raw(self),
                 rva,
                 symtag,
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
         pub unsafe fn findSymbolByVA(
             &self,
             va: u64,
             symtag: SymTag,
-        ) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).findSymbolByVA)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<IDiaSymbol> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).findSymbolByVA)(
+                windows_core::Interface::as_raw(self),
                 va,
                 symtag,
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
         pub unsafe fn findSymbolByToken(
             &self,
             token: u32,
             symtag: SymTag,
-        ) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).findSymbolByToken)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<IDiaSymbol> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).findSymbolByToken)(
+                windows_core::Interface::as_raw(self),
                 token,
                 symtag,
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
         pub unsafe fn symsAreEquiv<P0, P1>(
             &self,
             symbola: P0,
             symbolb: P1,
-        ) -> ::windows_core::Result<()>
+        ) -> windows_core::Result<()>
         where
-            P0: ::windows_core::IntoParam<IDiaSymbol>,
-            P1: ::windows_core::IntoParam<IDiaSymbol>,
+            P0: windows_core::Param<IDiaSymbol>,
+            P1: windows_core::Param<IDiaSymbol>,
         {
-            (::windows_core::Interface::vtable(self).symsAreEquiv)(
-                ::windows_core::Interface::as_raw(self),
-                symbola.into_param().abi(),
-                symbolb.into_param().abi(),
+            (windows_core::Interface::vtable(self).symsAreEquiv)(
+                windows_core::Interface::as_raw(self),
+                symbola.param().abi(),
+                symbolb.param().abi(),
             )
             .ok()
         }
-        pub unsafe fn symbolById(&self, id: u32) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).symbolById)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn symbolById(&self, id: u32) -> windows_core::Result<IDiaSymbol> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).symbolById)(
+                windows_core::Interface::as_raw(self),
                 id,
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
         pub unsafe fn findSymbolByRVAEx(
             &self,
             rva: u32,
             symtag: SymTag,
-            ppsymbol: *mut ::core::option::Option<IDiaSymbol>,
+            ppsymbol: *mut Option<IDiaSymbol>,
             displacement: *mut i32,
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self).findSymbolByRVAEx)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<()> {
+            (windows_core::Interface::vtable(self).findSymbolByRVAEx)(
+                windows_core::Interface::as_raw(self),
                 rva,
                 symtag,
-                ::core::mem::transmute(ppsymbol),
+                core::mem::transmute(ppsymbol),
                 displacement,
             )
             .ok()
@@ -3565,14 +3802,14 @@ pub mod Dia {
             &self,
             va: u64,
             symtag: SymTag,
-            ppsymbol: *mut ::core::option::Option<IDiaSymbol>,
+            ppsymbol: *mut Option<IDiaSymbol>,
             displacement: *mut i32,
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self).findSymbolByVAEx)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<()> {
+            (windows_core::Interface::vtable(self).findSymbolByVAEx)(
+                windows_core::Interface::as_raw(self),
                 va,
                 symtag,
-                ::core::mem::transmute(ppsymbol),
+                core::mem::transmute(ppsymbol),
                 displacement,
             )
             .ok()
@@ -3582,91 +3819,91 @@ pub mod Dia {
             pcompiland: P0,
             name: P1,
             compareflags: u32,
-        ) -> ::windows_core::Result<IDiaEnumSourceFiles>
+        ) -> windows_core::Result<IDiaEnumSourceFiles>
         where
-            P0: ::windows_core::IntoParam<IDiaSymbol>,
-            P1: ::windows_core::IntoParam<::windows_core::PCWSTR>,
+            P0: windows_core::Param<IDiaSymbol>,
+            P1: windows_core::Param<windows_core::PCWSTR>,
         {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).findFile)(
-                ::windows_core::Interface::as_raw(self),
-                pcompiland.into_param().abi(),
-                name.into_param().abi(),
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).findFile)(
+                windows_core::Interface::as_raw(self),
+                pcompiland.param().abi(),
+                name.param().abi(),
                 compareflags,
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
-        pub unsafe fn findFileById(&self, uniqueid: u32) -> ::windows_core::Result<IDiaSourceFile> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).findFileById)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn findFileById(&self, uniqueid: u32) -> windows_core::Result<IDiaSourceFile> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).findFileById)(
+                windows_core::Interface::as_raw(self),
                 uniqueid,
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
         pub unsafe fn findLines<P0, P1>(
             &self,
             compiland: P0,
             file: P1,
-        ) -> ::windows_core::Result<IDiaEnumLineNumbers>
+        ) -> windows_core::Result<IDiaEnumLineNumbers>
         where
-            P0: ::windows_core::IntoParam<IDiaSymbol>,
-            P1: ::windows_core::IntoParam<IDiaSourceFile>,
+            P0: windows_core::Param<IDiaSymbol>,
+            P1: windows_core::Param<IDiaSourceFile>,
         {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).findLines)(
-                ::windows_core::Interface::as_raw(self),
-                compiland.into_param().abi(),
-                file.into_param().abi(),
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).findLines)(
+                windows_core::Interface::as_raw(self),
+                compiland.param().abi(),
+                file.param().abi(),
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
         pub unsafe fn findLinesByAddr(
             &self,
             seg: u32,
             offset: u32,
             length: u32,
-        ) -> ::windows_core::Result<IDiaEnumLineNumbers> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).findLinesByAddr)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<IDiaEnumLineNumbers> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).findLinesByAddr)(
+                windows_core::Interface::as_raw(self),
                 seg,
                 offset,
                 length,
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
         pub unsafe fn findLinesByRVA(
             &self,
             rva: u32,
             length: u32,
-        ) -> ::windows_core::Result<IDiaEnumLineNumbers> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).findLinesByRVA)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<IDiaEnumLineNumbers> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).findLinesByRVA)(
+                windows_core::Interface::as_raw(self),
                 rva,
                 length,
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
         pub unsafe fn findLinesByVA(
             &self,
             va: u64,
             length: u32,
-        ) -> ::windows_core::Result<IDiaEnumLineNumbers> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).findLinesByVA)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<IDiaEnumLineNumbers> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).findLinesByVA)(
+                windows_core::Interface::as_raw(self),
                 va,
                 length,
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
         pub unsafe fn findLinesByLinenum<P0, P1>(
             &self,
@@ -3674,112 +3911,112 @@ pub mod Dia {
             file: P1,
             linenum: u32,
             column: u32,
-        ) -> ::windows_core::Result<IDiaEnumLineNumbers>
+        ) -> windows_core::Result<IDiaEnumLineNumbers>
         where
-            P0: ::windows_core::IntoParam<IDiaSymbol>,
-            P1: ::windows_core::IntoParam<IDiaSourceFile>,
+            P0: windows_core::Param<IDiaSymbol>,
+            P1: windows_core::Param<IDiaSourceFile>,
         {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).findLinesByLinenum)(
-                ::windows_core::Interface::as_raw(self),
-                compiland.into_param().abi(),
-                file.into_param().abi(),
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).findLinesByLinenum)(
+                windows_core::Interface::as_raw(self),
+                compiland.param().abi(),
+                file.param().abi(),
                 linenum,
                 column,
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
         pub unsafe fn findInjectedSource<P0>(
             &self,
             srcfile: P0,
-        ) -> ::windows_core::Result<IDiaEnumInjectedSources>
+        ) -> windows_core::Result<IDiaEnumInjectedSources>
         where
-            P0: ::windows_core::IntoParam<::windows_core::PCWSTR>,
+            P0: windows_core::Param<windows_core::PCWSTR>,
         {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).findInjectedSource)(
-                ::windows_core::Interface::as_raw(self),
-                srcfile.into_param().abi(),
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).findInjectedSource)(
+                windows_core::Interface::as_raw(self),
+                srcfile.param().abi(),
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
-        pub unsafe fn getEnumDebugStreams(&self) -> ::windows_core::Result<IDiaEnumDebugStreams> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).getEnumDebugStreams)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn getEnumDebugStreams(&self) -> windows_core::Result<IDiaEnumDebugStreams> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).getEnumDebugStreams)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
         pub unsafe fn findInlineFramesByAddr<P0>(
             &self,
             parent: P0,
             isect: u32,
             offset: u32,
-        ) -> ::windows_core::Result<IDiaEnumSymbols>
+        ) -> windows_core::Result<IDiaEnumSymbols>
         where
-            P0: ::windows_core::IntoParam<IDiaSymbol>,
+            P0: windows_core::Param<IDiaSymbol>,
         {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).findInlineFramesByAddr)(
-                ::windows_core::Interface::as_raw(self),
-                parent.into_param().abi(),
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).findInlineFramesByAddr)(
+                windows_core::Interface::as_raw(self),
+                parent.param().abi(),
                 isect,
                 offset,
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
         pub unsafe fn findInlineFramesByRVA<P0>(
             &self,
             parent: P0,
             rva: u32,
-        ) -> ::windows_core::Result<IDiaEnumSymbols>
+        ) -> windows_core::Result<IDiaEnumSymbols>
         where
-            P0: ::windows_core::IntoParam<IDiaSymbol>,
+            P0: windows_core::Param<IDiaSymbol>,
         {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).findInlineFramesByRVA)(
-                ::windows_core::Interface::as_raw(self),
-                parent.into_param().abi(),
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).findInlineFramesByRVA)(
+                windows_core::Interface::as_raw(self),
+                parent.param().abi(),
                 rva,
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
         pub unsafe fn findInlineFramesByVA<P0>(
             &self,
             parent: P0,
             va: u64,
-        ) -> ::windows_core::Result<IDiaEnumSymbols>
+        ) -> windows_core::Result<IDiaEnumSymbols>
         where
-            P0: ::windows_core::IntoParam<IDiaSymbol>,
+            P0: windows_core::Param<IDiaSymbol>,
         {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).findInlineFramesByVA)(
-                ::windows_core::Interface::as_raw(self),
-                parent.into_param().abi(),
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).findInlineFramesByVA)(
+                windows_core::Interface::as_raw(self),
+                parent.param().abi(),
                 va,
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
         pub unsafe fn findInlineeLines<P0>(
             &self,
             parent: P0,
-        ) -> ::windows_core::Result<IDiaEnumLineNumbers>
+        ) -> windows_core::Result<IDiaEnumLineNumbers>
         where
-            P0: ::windows_core::IntoParam<IDiaSymbol>,
+            P0: windows_core::Param<IDiaSymbol>,
         {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).findInlineeLines)(
-                ::windows_core::Interface::as_raw(self),
-                parent.into_param().abi(),
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).findInlineeLines)(
+                windows_core::Interface::as_raw(self),
+                parent.param().abi(),
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
         pub unsafe fn findInlineeLinesByAddr<P0>(
             &self,
@@ -3787,58 +4024,58 @@ pub mod Dia {
             isect: u32,
             offset: u32,
             length: u32,
-        ) -> ::windows_core::Result<IDiaEnumLineNumbers>
+        ) -> windows_core::Result<IDiaEnumLineNumbers>
         where
-            P0: ::windows_core::IntoParam<IDiaSymbol>,
+            P0: windows_core::Param<IDiaSymbol>,
         {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).findInlineeLinesByAddr)(
-                ::windows_core::Interface::as_raw(self),
-                parent.into_param().abi(),
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).findInlineeLinesByAddr)(
+                windows_core::Interface::as_raw(self),
+                parent.param().abi(),
                 isect,
                 offset,
                 length,
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
         pub unsafe fn findInlineeLinesByRVA<P0>(
             &self,
             parent: P0,
             rva: u32,
             length: u32,
-        ) -> ::windows_core::Result<IDiaEnumLineNumbers>
+        ) -> windows_core::Result<IDiaEnumLineNumbers>
         where
-            P0: ::windows_core::IntoParam<IDiaSymbol>,
+            P0: windows_core::Param<IDiaSymbol>,
         {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).findInlineeLinesByRVA)(
-                ::windows_core::Interface::as_raw(self),
-                parent.into_param().abi(),
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).findInlineeLinesByRVA)(
+                windows_core::Interface::as_raw(self),
+                parent.param().abi(),
                 rva,
                 length,
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
         pub unsafe fn findInlineeLinesByVA<P0>(
             &self,
             parent: P0,
             va: u64,
             length: u32,
-        ) -> ::windows_core::Result<IDiaEnumLineNumbers>
+        ) -> windows_core::Result<IDiaEnumLineNumbers>
         where
-            P0: ::windows_core::IntoParam<IDiaSymbol>,
+            P0: windows_core::Param<IDiaSymbol>,
         {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).findInlineeLinesByVA)(
-                ::windows_core::Interface::as_raw(self),
-                parent.into_param().abi(),
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).findInlineeLinesByVA)(
+                windows_core::Interface::as_raw(self),
+                parent.param().abi(),
                 va,
                 length,
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
         pub unsafe fn findInlineeLinesByLinenum<P0, P1>(
             &self,
@@ -3846,38 +4083,38 @@ pub mod Dia {
             file: P1,
             linenum: u32,
             column: u32,
-        ) -> ::windows_core::Result<IDiaEnumLineNumbers>
+        ) -> windows_core::Result<IDiaEnumLineNumbers>
         where
-            P0: ::windows_core::IntoParam<IDiaSymbol>,
-            P1: ::windows_core::IntoParam<IDiaSourceFile>,
+            P0: windows_core::Param<IDiaSymbol>,
+            P1: windows_core::Param<IDiaSourceFile>,
         {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).findInlineeLinesByLinenum)(
-                ::windows_core::Interface::as_raw(self),
-                compiland.into_param().abi(),
-                file.into_param().abi(),
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).findInlineeLinesByLinenum)(
+                windows_core::Interface::as_raw(self),
+                compiland.param().abi(),
+                file.param().abi(),
                 linenum,
                 column,
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
         pub unsafe fn findInlineesByName<P0>(
             &self,
             name: P0,
             option: u32,
-        ) -> ::windows_core::Result<IDiaEnumSymbols>
+        ) -> windows_core::Result<IDiaEnumSymbols>
         where
-            P0: ::windows_core::IntoParam<::windows_core::PCWSTR>,
+            P0: windows_core::Param<windows_core::PCWSTR>,
         {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).findInlineesByName)(
-                ::windows_core::Interface::as_raw(self),
-                name.into_param().abi(),
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).findInlineesByName)(
+                windows_core::Interface::as_raw(self),
+                name.param().abi(),
                 option,
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
         pub unsafe fn findAcceleratorInlineeLinesByLinenum<P0, P1>(
             &self,
@@ -3885,83 +4122,83 @@ pub mod Dia {
             file: P1,
             linenum: u32,
             column: u32,
-        ) -> ::windows_core::Result<IDiaEnumLineNumbers>
+        ) -> windows_core::Result<IDiaEnumLineNumbers>
         where
-            P0: ::windows_core::IntoParam<IDiaSymbol>,
-            P1: ::windows_core::IntoParam<IDiaSourceFile>,
+            P0: windows_core::Param<IDiaSymbol>,
+            P1: windows_core::Param<IDiaSourceFile>,
         {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).findAcceleratorInlineeLinesByLinenum)(
-                ::windows_core::Interface::as_raw(self),
-                parent.into_param().abi(),
-                file.into_param().abi(),
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).findAcceleratorInlineeLinesByLinenum)(
+                windows_core::Interface::as_raw(self),
+                parent.param().abi(),
+                file.param().abi(),
                 linenum,
                 column,
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
         pub unsafe fn findSymbolsForAcceleratorPointerTag<P0>(
             &self,
             parent: P0,
             tagvalue: u32,
-        ) -> ::windows_core::Result<IDiaEnumSymbols>
+        ) -> windows_core::Result<IDiaEnumSymbols>
         where
-            P0: ::windows_core::IntoParam<IDiaSymbol>,
+            P0: windows_core::Param<IDiaSymbol>,
         {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).findSymbolsForAcceleratorPointerTag)(
-                ::windows_core::Interface::as_raw(self),
-                parent.into_param().abi(),
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).findSymbolsForAcceleratorPointerTag)(
+                windows_core::Interface::as_raw(self),
+                parent.param().abi(),
                 tagvalue,
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
         pub unsafe fn findSymbolsByRVAForAcceleratorPointerTag<P0>(
             &self,
             parent: P0,
             tagvalue: u32,
             rva: u32,
-        ) -> ::windows_core::Result<IDiaEnumSymbols>
+        ) -> windows_core::Result<IDiaEnumSymbols>
         where
-            P0: ::windows_core::IntoParam<IDiaSymbol>,
+            P0: windows_core::Param<IDiaSymbol>,
         {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).findSymbolsByRVAForAcceleratorPointerTag)(
-                ::windows_core::Interface::as_raw(self),
-                parent.into_param().abi(),
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).findSymbolsByRVAForAcceleratorPointerTag)(
+                windows_core::Interface::as_raw(self),
+                parent.param().abi(),
                 tagvalue,
                 rva,
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
         pub unsafe fn findAcceleratorInlineesByName<P0>(
             &self,
             name: P0,
             option: u32,
-        ) -> ::windows_core::Result<IDiaEnumSymbols>
+        ) -> windows_core::Result<IDiaEnumSymbols>
         where
-            P0: ::windows_core::IntoParam<::windows_core::PCWSTR>,
+            P0: windows_core::Param<windows_core::PCWSTR>,
         {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).findAcceleratorInlineesByName)(
-                ::windows_core::Interface::as_raw(self),
-                name.into_param().abi(),
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).findAcceleratorInlineesByName)(
+                windows_core::Interface::as_raw(self),
+                name.param().abi(),
                 option,
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
         pub unsafe fn addressForVA(
             &self,
             va: u64,
             pisect: *mut u32,
             poffset: *mut u32,
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self).addressForVA)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<()> {
+            (windows_core::Interface::vtable(self).addressForVA)(
+                windows_core::Interface::as_raw(self),
                 va,
                 pisect,
                 poffset,
@@ -3973,9 +4210,9 @@ pub mod Dia {
             rva: u32,
             pisect: *mut u32,
             poffset: *mut u32,
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self).addressForRVA)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<()> {
+            (windows_core::Interface::vtable(self).addressForRVA)(
+                windows_core::Interface::as_raw(self),
                 rva,
                 pisect,
                 poffset,
@@ -3987,83 +4224,83 @@ pub mod Dia {
             isect: u32,
             offset: u32,
             length: u32,
-        ) -> ::windows_core::Result<IDiaEnumLineNumbers> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).findILOffsetsByAddr)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<IDiaEnumLineNumbers> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).findILOffsetsByAddr)(
+                windows_core::Interface::as_raw(self),
                 isect,
                 offset,
                 length,
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
         pub unsafe fn findILOffsetsByRVA(
             &self,
             rva: u32,
             length: u32,
-        ) -> ::windows_core::Result<IDiaEnumLineNumbers> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).findILOffsetsByRVA)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<IDiaEnumLineNumbers> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).findILOffsetsByRVA)(
+                windows_core::Interface::as_raw(self),
                 rva,
                 length,
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
         pub unsafe fn findILOffsetsByVA(
             &self,
             va: u64,
             length: u32,
-        ) -> ::windows_core::Result<IDiaEnumLineNumbers> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).findILOffsetsByVA)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<IDiaEnumLineNumbers> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).findILOffsetsByVA)(
+                windows_core::Interface::as_raw(self),
                 va,
                 length,
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
         pub unsafe fn findInputAssemblyFiles(
             &self,
-        ) -> ::windows_core::Result<IDiaEnumInputAssemblyFiles> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).findInputAssemblyFiles)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<IDiaEnumInputAssemblyFiles> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).findInputAssemblyFiles)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
         pub unsafe fn findInputAssembly(
             &self,
             index: u32,
-        ) -> ::windows_core::Result<IDiaInputAssemblyFile> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).findInputAssembly)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<IDiaInputAssemblyFile> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).findInputAssembly)(
+                windows_core::Interface::as_raw(self),
                 index,
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
         pub unsafe fn findInputAssemblyById(
             &self,
             uniqueid: u32,
-        ) -> ::windows_core::Result<IDiaInputAssemblyFile> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).findInputAssemblyById)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<IDiaInputAssemblyFile> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).findInputAssemblyById)(
+                windows_core::Interface::as_raw(self),
                 uniqueid,
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
-        pub unsafe fn getFuncMDTokenMapSize(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).getFuncMDTokenMapSize)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn getFuncMDTokenMapSize(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).getFuncMDTokenMapSize)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
@@ -4072,19 +4309,19 @@ pub mod Dia {
             &self,
             pcb: *mut u32,
             pb: &mut [u8],
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self).getFuncMDTokenMap)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<()> {
+            (windows_core::Interface::vtable(self).getFuncMDTokenMap)(
+                windows_core::Interface::as_raw(self),
                 pb.len().try_into().unwrap(),
                 pcb,
-                ::core::mem::transmute(pb.as_ptr()),
+                core::mem::transmute(pb.as_ptr()),
             )
             .ok()
         }
-        pub unsafe fn getTypeMDTokenMapSize(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).getTypeMDTokenMapSize)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn getTypeMDTokenMapSize(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).getTypeMDTokenMapSize)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
@@ -4093,12 +4330,12 @@ pub mod Dia {
             &self,
             pcb: *mut u32,
             pb: &mut [u8],
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self).getTypeMDTokenMap)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<()> {
+            (windows_core::Interface::vtable(self).getTypeMDTokenMap)(
+                windows_core::Interface::as_raw(self),
                 pb.len().try_into().unwrap(),
                 pcb,
-                ::core::mem::transmute(pb.as_ptr()),
+                core::mem::transmute(pb.as_ptr()),
             )
             .ok()
         }
@@ -4106,10 +4343,10 @@ pub mod Dia {
             &self,
             vafunc: u64,
             cbfunc: u32,
-        ) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).getNumberOfFunctionFragments_VA)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).getNumberOfFunctionFragments_VA)(
+                windows_core::Interface::as_raw(self),
                 vafunc,
                 cbfunc,
                 &mut result__,
@@ -4120,10 +4357,10 @@ pub mod Dia {
             &self,
             rvafunc: u32,
             cbfunc: u32,
-        ) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).getNumberOfFunctionFragments_RVA)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).getNumberOfFunctionFragments_RVA)(
+                windows_core::Interface::as_raw(self),
                 rvafunc,
                 cbfunc,
                 &mut result__,
@@ -4137,9 +4374,9 @@ pub mod Dia {
             cfragments: u32,
             pvafragment: *mut u64,
             plenfragment: *mut u32,
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self).getFunctionFragments_VA)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<()> {
+            (windows_core::Interface::vtable(self).getFunctionFragments_VA)(
+                windows_core::Interface::as_raw(self),
                 vafunc,
                 cbfunc,
                 cfragments,
@@ -4155,9 +4392,9 @@ pub mod Dia {
             cfragments: u32,
             prvafragment: *mut u32,
             plenfragment: *mut u32,
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self).getFunctionFragments_RVA)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<()> {
+            (windows_core::Interface::vtable(self).getFunctionFragments_RVA)(
+                windows_core::Interface::as_raw(self),
                 rvafunc,
                 cbfunc,
                 cfragments,
@@ -4166,461 +4403,526 @@ pub mod Dia {
             )
             .ok()
         }
-        pub unsafe fn getExports(&self) -> ::windows_core::Result<IDiaEnumSymbols> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).getExports)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn getExports(&self) -> windows_core::Result<IDiaEnumSymbols> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).getExports)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
-        pub unsafe fn getHeapAllocationSites(&self) -> ::windows_core::Result<IDiaEnumSymbols> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).getHeapAllocationSites)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn getHeapAllocationSites(&self) -> windows_core::Result<IDiaEnumSymbols> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).getHeapAllocationSites)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
         pub unsafe fn findInputAssemblyFile<P0>(
             &self,
             psymbol: P0,
-        ) -> ::windows_core::Result<IDiaInputAssemblyFile>
+        ) -> windows_core::Result<IDiaInputAssemblyFile>
         where
-            P0: ::windows_core::IntoParam<IDiaSymbol>,
+            P0: windows_core::Param<IDiaSymbol>,
         {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).findInputAssemblyFile)(
-                ::windows_core::Interface::as_raw(self),
-                psymbol.into_param().abi(),
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).findInputAssemblyFile)(
+                windows_core::Interface::as_raw(self),
+                psymbol.param().abi(),
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
     }
     #[repr(C)]
     pub struct IDiaSession_Vtbl {
-        pub base__: ::windows_core::IUnknown_Vtbl,
-        pub loadAddress: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u64,
-        ) -> ::windows_core::HRESULT,
+        pub base__: windows_core::IUnknown_Vtbl,
+        pub loadAddress:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u64) -> windows_core::HRESULT,
         pub SetloadAddress:
-            unsafe extern "system" fn(*mut ::core::ffi::c_void, u64) -> ::windows_core::HRESULT,
+            unsafe extern "system" fn(*mut core::ffi::c_void, u64) -> windows_core::HRESULT,
         pub globalScope: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
         pub getEnumTables: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
         pub getSymbolsByAddr: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
         pub findChildren: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
+            *mut core::ffi::c_void,
             SymTag,
-            ::windows_core::PCWSTR,
+            windows_core::PCWSTR,
             u32,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
         pub findChildrenEx: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
+            *mut core::ffi::c_void,
             SymTag,
-            ::windows_core::PCWSTR,
+            windows_core::PCWSTR,
             u32,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
         pub findChildrenExByAddr: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
+            *mut core::ffi::c_void,
             SymTag,
-            ::windows_core::PCWSTR,
+            windows_core::PCWSTR,
             u32,
             u32,
             u32,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
         pub findChildrenExByVA: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
+            *mut core::ffi::c_void,
             SymTag,
-            ::windows_core::PCWSTR,
+            windows_core::PCWSTR,
             u32,
             u64,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
         pub findChildrenExByRVA: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
+            *mut core::ffi::c_void,
             SymTag,
-            ::windows_core::PCWSTR,
+            windows_core::PCWSTR,
             u32,
             u32,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
         pub findSymbolByAddr: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             u32,
             u32,
             SymTag,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
         pub findSymbolByRVA: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             u32,
             SymTag,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
         pub findSymbolByVA: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             u64,
             SymTag,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
         pub findSymbolByToken: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             u32,
             SymTag,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
         pub symsAreEquiv: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::core::ffi::c_void,
-            *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut core::ffi::c_void,
+            *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
         pub symbolById: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             u32,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
         pub findSymbolByRVAEx: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             u32,
             SymTag,
-            *mut *mut ::core::ffi::c_void,
+            *mut *mut core::ffi::c_void,
             *mut i32,
-        ) -> ::windows_core::HRESULT,
+        ) -> windows_core::HRESULT,
         pub findSymbolByVAEx: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             u64,
             SymTag,
-            *mut *mut ::core::ffi::c_void,
+            *mut *mut core::ffi::c_void,
             *mut i32,
-        ) -> ::windows_core::HRESULT,
+        ) -> windows_core::HRESULT,
         pub findFile: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::core::ffi::c_void,
-            ::windows_core::PCWSTR,
+            *mut core::ffi::c_void,
+            *mut core::ffi::c_void,
+            windows_core::PCWSTR,
             u32,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
         pub findFileById: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             u32,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
         pub findLines: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::core::ffi::c_void,
-            *mut ::core::ffi::c_void,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut core::ffi::c_void,
+            *mut core::ffi::c_void,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
         pub findLinesByAddr: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             u32,
             u32,
             u32,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
         pub findLinesByRVA: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             u32,
             u32,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
         pub findLinesByVA: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             u64,
             u32,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
         pub findLinesByLinenum: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::core::ffi::c_void,
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
+            *mut core::ffi::c_void,
+            *mut core::ffi::c_void,
             u32,
             u32,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
         pub findInjectedSource: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            ::windows_core::PCWSTR,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            windows_core::PCWSTR,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
         pub getEnumDebugStreams: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
         pub findInlineFramesByAddr: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
+            *mut core::ffi::c_void,
             u32,
             u32,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
         pub findInlineFramesByRVA: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
+            *mut core::ffi::c_void,
             u32,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
         pub findInlineFramesByVA: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
+            *mut core::ffi::c_void,
             u64,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
         pub findInlineeLines: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::core::ffi::c_void,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut core::ffi::c_void,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
         pub findInlineeLinesByAddr: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
+            *mut core::ffi::c_void,
             u32,
             u32,
             u32,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
         pub findInlineeLinesByRVA: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
+            *mut core::ffi::c_void,
             u32,
             u32,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
         pub findInlineeLinesByVA: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
+            *mut core::ffi::c_void,
             u64,
             u32,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
         pub findInlineeLinesByLinenum: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::core::ffi::c_void,
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
+            *mut core::ffi::c_void,
+            *mut core::ffi::c_void,
             u32,
             u32,
-            *mut *mut ::core::ffi::c_void,
-        )
-            -> ::windows_core::HRESULT,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
         pub findInlineesByName: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            ::windows_core::PCWSTR,
+            *mut core::ffi::c_void,
+            windows_core::PCWSTR,
             u32,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
         pub findAcceleratorInlineeLinesByLinenum:
             unsafe extern "system" fn(
-                *mut ::core::ffi::c_void,
-                *mut ::core::ffi::c_void,
-                *mut ::core::ffi::c_void,
+                *mut core::ffi::c_void,
+                *mut core::ffi::c_void,
+                *mut core::ffi::c_void,
                 u32,
                 u32,
-                *mut *mut ::core::ffi::c_void,
-            ) -> ::windows_core::HRESULT,
-        pub findSymbolsForAcceleratorPointerTag:
-            unsafe extern "system" fn(
-                *mut ::core::ffi::c_void,
-                *mut ::core::ffi::c_void,
-                u32,
-                *mut *mut ::core::ffi::c_void,
-            ) -> ::windows_core::HRESULT,
+                *mut *mut core::ffi::c_void,
+            ) -> windows_core::HRESULT,
+        pub findSymbolsForAcceleratorPointerTag: unsafe extern "system" fn(
+            *mut core::ffi::c_void,
+            *mut core::ffi::c_void,
+            u32,
+            *mut *mut core::ffi::c_void,
+        )
+            -> windows_core::HRESULT,
         pub findSymbolsByRVAForAcceleratorPointerTag:
             unsafe extern "system" fn(
-                *mut ::core::ffi::c_void,
-                *mut ::core::ffi::c_void,
+                *mut core::ffi::c_void,
+                *mut core::ffi::c_void,
                 u32,
                 u32,
-                *mut *mut ::core::ffi::c_void,
-            ) -> ::windows_core::HRESULT,
+                *mut *mut core::ffi::c_void,
+            ) -> windows_core::HRESULT,
         pub findAcceleratorInlineesByName: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            ::windows_core::PCWSTR,
+            *mut core::ffi::c_void,
+            windows_core::PCWSTR,
             u32,
-            *mut *mut ::core::ffi::c_void,
+            *mut *mut core::ffi::c_void,
         )
-            -> ::windows_core::HRESULT,
+            -> windows_core::HRESULT,
         pub addressForVA: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             u64,
             *mut u32,
             *mut u32,
-        ) -> ::windows_core::HRESULT,
+        ) -> windows_core::HRESULT,
         pub addressForRVA: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             u32,
             *mut u32,
             *mut u32,
-        ) -> ::windows_core::HRESULT,
+        ) -> windows_core::HRESULT,
         pub findILOffsetsByAddr: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             u32,
             u32,
             u32,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
         pub findILOffsetsByRVA: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             u32,
             u32,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
         pub findILOffsetsByVA: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             u64,
             u32,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
         pub findInputAssemblyFiles: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
         pub findInputAssembly: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             u32,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
         pub findInputAssemblyById: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             u32,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
-        pub getFuncMDTokenMapSize: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
+        pub getFuncMDTokenMapSize:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
         pub getFuncMDTokenMap: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             u32,
             *mut u32,
             *mut u8,
-        ) -> ::windows_core::HRESULT,
-        pub getTypeMDTokenMapSize: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
+        ) -> windows_core::HRESULT,
+        pub getTypeMDTokenMapSize:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
         pub getTypeMDTokenMap: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             u32,
             *mut u32,
             *mut u8,
-        ) -> ::windows_core::HRESULT,
+        ) -> windows_core::HRESULT,
         pub getNumberOfFunctionFragments_VA: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             u64,
             u32,
             *mut u32,
         )
-            -> ::windows_core::HRESULT,
+            -> windows_core::HRESULT,
         pub getNumberOfFunctionFragments_RVA: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             u32,
             u32,
             *mut u32,
         )
-            -> ::windows_core::HRESULT,
+            -> windows_core::HRESULT,
         pub getFunctionFragments_VA: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             u64,
             u32,
             u32,
             *mut u64,
             *mut u32,
-        ) -> ::windows_core::HRESULT,
+        ) -> windows_core::HRESULT,
         pub getFunctionFragments_RVA: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             u32,
             u32,
             u32,
             *mut u32,
             *mut u32,
-        ) -> ::windows_core::HRESULT,
+        ) -> windows_core::HRESULT,
         pub getExports: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
         pub getHeapAllocationSites: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
         pub findInputAssemblyFile: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::core::ffi::c_void,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut core::ffi::c_void,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
+    }
+    windows_core::imp::define_interface!(
+        IDiaSessionEx,
+        IDiaSessionEx_Vtbl,
+        0xcd24eed5_5fea_4742_a320_6254c920e78b
+    );
+    impl core::ops::Deref for IDiaSessionEx {
+        type Target = IDiaSession;
+        fn deref(&self) -> &Self::Target {
+            unsafe { core::mem::transmute(self) }
+        }
+    }
+    windows_core::imp::interface_hierarchy!(IDiaSessionEx, windows_core::IUnknown, IDiaSession);
+    impl IDiaSessionEx {
+        pub unsafe fn isFastLinkPDB(
+            &self,
+        ) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).isFastLinkPDB)(
+                windows_core::Interface::as_raw(self),
+                &mut result__,
+            )
+            .map(|| result__)
+        }
+        pub unsafe fn isPortablePDB(
+            &self,
+        ) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).isPortablePDB)(
+                windows_core::Interface::as_raw(self),
+                &mut result__,
+            )
+            .map(|| result__)
+        }
+        pub unsafe fn getSourceLinkInfo<P0>(
+            &self,
+            parent: P0,
+        ) -> windows_core::Result<IDiaEnumSourceLink>
+        where
+            P0: windows_core::Param<IDiaSymbol>,
+        {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).getSourceLinkInfo)(
+                windows_core::Interface::as_raw(self),
+                parent.param().abi(),
+                &mut result__,
+            )
+            .and_then(|| windows_core::Type::from_abi(result__))
+        }
     }
-    ::windows_core::imp::com_interface!(
+    #[repr(C)]
+    pub struct IDiaSessionEx_Vtbl {
+        pub base__: IDiaSession_Vtbl,
+        pub isFastLinkPDB: unsafe extern "system" fn(
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
+        pub isPortablePDB: unsafe extern "system" fn(
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
+        pub getSourceLinkInfo: unsafe extern "system" fn(
+            *mut core::ffi::c_void,
+            *mut core::ffi::c_void,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
+    }
+    windows_core::imp::define_interface!(
         IDiaSourceFile,
         IDiaSourceFile_Vtbl,
         0xa2ef5353_f5a8_4eb3_90d2_cb526acb3cdd
     );
-    ::windows_core::imp::interface_hierarchy!(IDiaSourceFile, ::windows_core::IUnknown);
+    impl core::ops::Deref for IDiaSourceFile {
+        type Target = windows_core::IUnknown;
+        fn deref(&self) -> &Self::Target {
+            unsafe { core::mem::transmute(self) }
+        }
+    }
+    windows_core::imp::interface_hierarchy!(IDiaSourceFile, windows_core::IUnknown);
     impl IDiaSourceFile {
-        pub unsafe fn uniqueId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).uniqueId)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn uniqueId(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).uniqueId)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn fileName(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).fileName)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn fileName(&self) -> windows_core::Result<windows_core::BSTR> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).fileName)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
-        pub unsafe fn checksumType(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).checksumType)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn checksumType(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).checksumType)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn compilands(&self) -> ::windows_core::Result<IDiaEnumSymbols> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).compilands)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn compilands(&self) -> windows_core::Result<IDiaEnumSymbols> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).compilands)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
         pub unsafe fn get_checksum(
             &self,
             pcbdata: *mut u32,
-            pbdata: ::core::option::Option<&mut [u8]>,
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self).get_checksum)(
-                ::windows_core::Interface::as_raw(self),
+            pbdata: Option<&mut [u8]>,
+        ) -> windows_core::Result<()> {
+            (windows_core::Interface::vtable(self).get_checksum)(
+                windows_core::Interface::as_raw(self),
                 pbdata
                     .as_deref()
                     .map_or(0, |slice| slice.len().try_into().unwrap()),
                 pcbdata,
-                ::core::mem::transmute(
+                core::mem::transmute(
                     pbdata
                         .as_deref()
-                        .map_or(::core::ptr::null(), |slice| slice.as_ptr()),
+                        .map_or(core::ptr::null(), |slice| slice.as_ptr()),
                 ),
             )
             .ok()
@@ -4628,161 +4930,163 @@ pub mod Dia {
     }
     #[repr(C)]
     pub struct IDiaSourceFile_Vtbl {
-        pub base__: ::windows_core::IUnknown_Vtbl,
-        pub uniqueId: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
+        pub base__: windows_core::IUnknown_Vtbl,
+        pub uniqueId:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
         pub fileName: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::std::mem::MaybeUninit<::windows_core::BSTR>,
-        ) -> ::windows_core::HRESULT,
-        pub checksumType: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut core::mem::MaybeUninit<windows_core::BSTR>,
+        ) -> windows_core::HRESULT,
+        pub checksumType:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
         pub compilands: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
         pub get_checksum: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             u32,
             *mut u32,
             *mut u8,
-        ) -> ::windows_core::HRESULT,
+        ) -> windows_core::HRESULT,
     }
-    ::windows_core::imp::com_interface!(
+    windows_core::imp::define_interface!(
         IDiaStackFrame,
         IDiaStackFrame_Vtbl,
         0x5edbc96d_cdd6_4792_afbe_cc89007d9610
     );
-    ::windows_core::imp::interface_hierarchy!(IDiaStackFrame, ::windows_core::IUnknown);
+    impl core::ops::Deref for IDiaStackFrame {
+        type Target = windows_core::IUnknown;
+        fn deref(&self) -> &Self::Target {
+            unsafe { core::mem::transmute(self) }
+        }
+    }
+    windows_core::imp::interface_hierarchy!(IDiaStackFrame, windows_core::IUnknown);
     impl IDiaStackFrame {
-        pub unsafe fn r#type(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).r#type)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn r#type(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).r#type)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn base(&self) -> ::windows_core::Result<u64> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn base(&self) -> windows_core::Result<u64> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).base)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn size(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).size)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn size(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).size)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn returnAddress(&self) -> ::windows_core::Result<u64> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).returnAddress)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn returnAddress(&self) -> windows_core::Result<u64> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).returnAddress)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn localsBase(&self) -> ::windows_core::Result<u64> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).localsBase)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn localsBase(&self) -> windows_core::Result<u64> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).localsBase)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn lengthLocals(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).lengthLocals)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn lengthLocals(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).lengthLocals)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn lengthParams(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).lengthParams)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn lengthParams(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).lengthParams)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn lengthProlog(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).lengthProlog)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn lengthProlog(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).lengthProlog)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn lengthSavedRegisters(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).lengthSavedRegisters)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn lengthSavedRegisters(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).lengthSavedRegisters)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
         pub unsafe fn systemExceptionHandling(
             &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).systemExceptionHandling)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).systemExceptionHandling)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
         pub unsafe fn cplusplusExceptionHandling(
             &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).cplusplusExceptionHandling)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).cplusplusExceptionHandling)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
         pub unsafe fn functionStart(
             &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).functionStart)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).functionStart)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
         pub unsafe fn allocatesBasePointer(
             &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).allocatesBasePointer)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).allocatesBasePointer)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn maxStack(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).maxStack)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn maxStack(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).maxStack)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn get_registerValue(&self, index: u32) -> ::windows_core::Result<u64> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).get_registerValue)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn get_registerValue(&self, index: u32) -> windows_core::Result<u64> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).get_registerValue)(
+                windows_core::Interface::as_raw(self),
                 index,
                 &mut result__,
             )
@@ -4791,81 +5095,66 @@ pub mod Dia {
     }
     #[repr(C)]
     pub struct IDiaStackFrame_Vtbl {
-        pub base__: ::windows_core::IUnknown_Vtbl,
-        pub r#type: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub base: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u64,
-        ) -> ::windows_core::HRESULT,
-        pub size: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub returnAddress: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u64,
-        ) -> ::windows_core::HRESULT,
-        pub localsBase: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u64,
-        ) -> ::windows_core::HRESULT,
-        pub lengthLocals: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub lengthParams: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub lengthProlog: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub lengthSavedRegisters: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
+        pub base__: windows_core::IUnknown_Vtbl,
+        pub r#type:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+        pub base:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u64) -> windows_core::HRESULT,
+        pub size:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+        pub returnAddress:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u64) -> windows_core::HRESULT,
+        pub localsBase:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u64) -> windows_core::HRESULT,
+        pub lengthLocals:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+        pub lengthParams:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+        pub lengthProlog:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+        pub lengthSavedRegisters:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
         pub systemExceptionHandling: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub cplusplusExceptionHandling: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        )
-            -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub functionStart: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub allocatesBasePointer: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
-        pub maxStack: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
+        pub maxStack:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
         pub get_registerValue: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             u32,
             *mut u64,
-        ) -> ::windows_core::HRESULT,
+        ) -> windows_core::HRESULT,
     }
-    ::windows_core::imp::com_interface!(
+    windows_core::imp::define_interface!(
         IDiaStackWalkFrame,
         IDiaStackWalkFrame_Vtbl,
         0x07c590c1_438d_4f47_bdcd_4397bc81ad75
     );
-    ::windows_core::imp::interface_hierarchy!(IDiaStackWalkFrame, ::windows_core::IUnknown);
+    impl core::ops::Deref for IDiaStackWalkFrame {
+        type Target = windows_core::IUnknown;
+        fn deref(&self) -> &Self::Target {
+            unsafe { core::mem::transmute(self) }
+        }
+    }
+    windows_core::imp::interface_hierarchy!(IDiaStackWalkFrame, windows_core::IUnknown);
     impl IDiaStackWalkFrame {
-        pub unsafe fn get_registerValue(&self, index: u32) -> ::windows_core::Result<u64> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).get_registerValue)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn get_registerValue(&self, index: u32) -> windows_core::Result<u64> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).get_registerValue)(
+                windows_core::Interface::as_raw(self),
                 index,
                 &mut result__,
             )
@@ -4875,9 +5164,9 @@ pub mod Dia {
             &self,
             index: u32,
             newval: u64,
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self).put_registerValue)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<()> {
+            (windows_core::Interface::vtable(self).put_registerValue)(
+                windows_core::Interface::as_raw(self),
                 index,
                 newval,
             )
@@ -4889,25 +5178,25 @@ pub mod Dia {
             va: u64,
             pcbdata: *mut u32,
             pbdata: &mut [u8],
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self).readMemory)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<()> {
+            (windows_core::Interface::vtable(self).readMemory)(
+                windows_core::Interface::as_raw(self),
                 r#type,
                 va,
                 pbdata.len().try_into().unwrap(),
                 pcbdata,
-                ::core::mem::transmute(pbdata.as_ptr()),
+                core::mem::transmute(pbdata.as_ptr()),
             )
             .ok()
         }
-        pub unsafe fn searchForReturnAddress<P0>(&self, frame: P0) -> ::windows_core::Result<u64>
+        pub unsafe fn searchForReturnAddress<P0>(&self, frame: P0) -> windows_core::Result<u64>
         where
-            P0: ::windows_core::IntoParam<IDiaFrameData>,
+            P0: windows_core::Param<IDiaFrameData>,
         {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).searchForReturnAddress)(
-                ::windows_core::Interface::as_raw(self),
-                frame.into_param().abi(),
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).searchForReturnAddress)(
+                windows_core::Interface::as_raw(self),
+                frame.param().abi(),
                 &mut result__,
             )
             .map(|| result__)
@@ -4916,14 +5205,14 @@ pub mod Dia {
             &self,
             frame: P0,
             startaddress: u64,
-        ) -> ::windows_core::Result<u64>
+        ) -> windows_core::Result<u64>
         where
-            P0: ::windows_core::IntoParam<IDiaFrameData>,
+            P0: windows_core::Param<IDiaFrameData>,
         {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).searchForReturnAddressStart)(
-                ::windows_core::Interface::as_raw(self),
-                frame.into_param().abi(),
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).searchForReturnAddressStart)(
+                windows_core::Interface::as_raw(self),
+                frame.param().abi(),
                 startaddress,
                 &mut result__,
             )
@@ -4932,49 +5221,52 @@ pub mod Dia {
     }
     #[repr(C)]
     pub struct IDiaStackWalkFrame_Vtbl {
-        pub base__: ::windows_core::IUnknown_Vtbl,
+        pub base__: windows_core::IUnknown_Vtbl,
         pub get_registerValue: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             u32,
             *mut u64,
-        ) -> ::windows_core::HRESULT,
-        pub put_registerValue: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            u32,
-            u64,
-        ) -> ::windows_core::HRESULT,
+        ) -> windows_core::HRESULT,
+        pub put_registerValue:
+            unsafe extern "system" fn(*mut core::ffi::c_void, u32, u64) -> windows_core::HRESULT,
         pub readMemory: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             MemoryTypeEnum,
             u64,
             u32,
             *mut u32,
             *mut u8,
-        ) -> ::windows_core::HRESULT,
+        ) -> windows_core::HRESULT,
         pub searchForReturnAddress: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
+            *mut core::ffi::c_void,
             *mut u64,
-        ) -> ::windows_core::HRESULT,
+        ) -> windows_core::HRESULT,
         pub searchForReturnAddressStart: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
+            *mut core::ffi::c_void,
             u64,
             *mut u64,
         )
-            -> ::windows_core::HRESULT,
+            -> windows_core::HRESULT,
     }
-    ::windows_core::imp::com_interface!(
+    windows_core::imp::define_interface!(
         IDiaStackWalkHelper,
         IDiaStackWalkHelper_Vtbl,
         0x21f81b1b_c5bb_42a3_bc4f_ccbaa75b9f19
     );
-    ::windows_core::imp::interface_hierarchy!(IDiaStackWalkHelper, ::windows_core::IUnknown);
+    impl core::ops::Deref for IDiaStackWalkHelper {
+        type Target = windows_core::IUnknown;
+        fn deref(&self) -> &Self::Target {
+            unsafe { core::mem::transmute(self) }
+        }
+    }
+    windows_core::imp::interface_hierarchy!(IDiaStackWalkHelper, windows_core::IUnknown);
     impl IDiaStackWalkHelper {
-        pub unsafe fn get_registerValue(&self, index: u32) -> ::windows_core::Result<u64> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).get_registerValue)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn get_registerValue(&self, index: u32) -> windows_core::Result<u64> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).get_registerValue)(
+                windows_core::Interface::as_raw(self),
                 index,
                 &mut result__,
             )
@@ -4984,9 +5276,9 @@ pub mod Dia {
             &self,
             index: u32,
             newval: u64,
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self).put_registerValue)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<()> {
+            (windows_core::Interface::vtable(self).put_registerValue)(
+                windows_core::Interface::as_raw(self),
                 index,
                 newval,
             )
@@ -4998,25 +5290,25 @@ pub mod Dia {
             va: u64,
             pcbdata: *mut u32,
             pbdata: &mut [u8],
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self).readMemory)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<()> {
+            (windows_core::Interface::vtable(self).readMemory)(
+                windows_core::Interface::as_raw(self),
                 r#type,
                 va,
                 pbdata.len().try_into().unwrap(),
                 pcbdata,
-                ::core::mem::transmute(pbdata.as_ptr()),
+                core::mem::transmute(pbdata.as_ptr()),
             )
             .ok()
         }
-        pub unsafe fn searchForReturnAddress<P0>(&self, frame: P0) -> ::windows_core::Result<u64>
+        pub unsafe fn searchForReturnAddress<P0>(&self, frame: P0) -> windows_core::Result<u64>
         where
-            P0: ::windows_core::IntoParam<IDiaFrameData>,
+            P0: windows_core::Param<IDiaFrameData>,
         {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).searchForReturnAddress)(
-                ::windows_core::Interface::as_raw(self),
-                frame.into_param().abi(),
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).searchForReturnAddress)(
+                windows_core::Interface::as_raw(self),
+                frame.param().abi(),
                 &mut result__,
             )
             .map(|| result__)
@@ -5025,56 +5317,56 @@ pub mod Dia {
             &self,
             frame: P0,
             startaddress: u64,
-        ) -> ::windows_core::Result<u64>
+        ) -> windows_core::Result<u64>
         where
-            P0: ::windows_core::IntoParam<IDiaFrameData>,
+            P0: windows_core::Param<IDiaFrameData>,
         {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).searchForReturnAddressStart)(
-                ::windows_core::Interface::as_raw(self),
-                frame.into_param().abi(),
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).searchForReturnAddressStart)(
+                windows_core::Interface::as_raw(self),
+                frame.param().abi(),
                 startaddress,
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn frameForVA(&self, va: u64) -> ::windows_core::Result<IDiaFrameData> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).frameForVA)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn frameForVA(&self, va: u64) -> windows_core::Result<IDiaFrameData> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).frameForVA)(
+                windows_core::Interface::as_raw(self),
                 va,
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
-        pub unsafe fn symbolForVA(&self, va: u64) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).symbolForVA)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn symbolForVA(&self, va: u64) -> windows_core::Result<IDiaSymbol> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).symbolForVA)(
+                windows_core::Interface::as_raw(self),
                 va,
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
         pub unsafe fn pdataForVA(
             &self,
             va: u64,
             pcbdata: *mut u32,
             pbdata: &mut [u8],
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self).pdataForVA)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<()> {
+            (windows_core::Interface::vtable(self).pdataForVA)(
+                windows_core::Interface::as_raw(self),
                 va,
                 pbdata.len().try_into().unwrap(),
                 pcbdata,
-                ::core::mem::transmute(pbdata.as_ptr()),
+                core::mem::transmute(pbdata.as_ptr()),
             )
             .ok()
         }
-        pub unsafe fn imageForVA(&self, vacontext: u64) -> ::windows_core::Result<u64> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).imageForVA)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn imageForVA(&self, vacontext: u64) -> windows_core::Result<u64> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).imageForVA)(
+                windows_core::Interface::as_raw(self),
                 vacontext,
                 &mut result__,
             )
@@ -5085,9 +5377,9 @@ pub mod Dia {
             va: u64,
             pisect: *mut u32,
             poffset: *mut u32,
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self).addressForVA)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<()> {
+            (windows_core::Interface::vtable(self).addressForVA)(
+                windows_core::Interface::as_raw(self),
                 va,
                 pisect,
                 poffset,
@@ -5098,10 +5390,10 @@ pub mod Dia {
             &self,
             vafunc: u64,
             cbfunc: u32,
-        ) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).numberOfFunctionFragmentsForVA)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).numberOfFunctionFragmentsForVA)(
+                windows_core::Interface::as_raw(self),
                 vafunc,
                 cbfunc,
                 &mut result__,
@@ -5115,9 +5407,9 @@ pub mod Dia {
             cfragments: u32,
             pvafragment: *mut u64,
             plenfragment: *mut u32,
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self).functionFragmentsForVA)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<()> {
+            (windows_core::Interface::vtable(self).functionFragmentsForVA)(
+                windows_core::Interface::as_raw(self),
                 vafunc,
                 cbfunc,
                 cfragments,
@@ -5129,264 +5421,102 @@ pub mod Dia {
     }
     #[repr(C)]
     pub struct IDiaStackWalkHelper_Vtbl {
-        pub base__: ::windows_core::IUnknown_Vtbl,
+        pub base__: windows_core::IUnknown_Vtbl,
         pub get_registerValue: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             u32,
             *mut u64,
-        ) -> ::windows_core::HRESULT,
-        pub put_registerValue: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            u32,
-            u64,
-        ) -> ::windows_core::HRESULT,
+        ) -> windows_core::HRESULT,
+        pub put_registerValue:
+            unsafe extern "system" fn(*mut core::ffi::c_void, u32, u64) -> windows_core::HRESULT,
         pub readMemory: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             MemoryTypeEnum,
             u64,
             u32,
             *mut u32,
             *mut u8,
-        ) -> ::windows_core::HRESULT,
+        ) -> windows_core::HRESULT,
         pub searchForReturnAddress: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
+            *mut core::ffi::c_void,
             *mut u64,
-        ) -> ::windows_core::HRESULT,
+        ) -> windows_core::HRESULT,
         pub searchForReturnAddressStart: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
+            *mut core::ffi::c_void,
             u64,
             *mut u64,
         )
-            -> ::windows_core::HRESULT,
+            -> windows_core::HRESULT,
         pub frameForVA: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             u64,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
         pub symbolForVA: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             u64,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
         pub pdataForVA: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             u64,
             u32,
             *mut u32,
             *mut u8,
-        ) -> ::windows_core::HRESULT,
+        ) -> windows_core::HRESULT,
         pub imageForVA: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             u64,
             *mut u64,
-        ) -> ::windows_core::HRESULT,
+        ) -> windows_core::HRESULT,
         pub addressForVA: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             u64,
             *mut u32,
             *mut u32,
-        ) -> ::windows_core::HRESULT,
+        ) -> windows_core::HRESULT,
         pub numberOfFunctionFragmentsForVA: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             u64,
             u32,
             *mut u32,
         )
-            -> ::windows_core::HRESULT,
+            -> windows_core::HRESULT,
         pub functionFragmentsForVA: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             u64,
             u32,
             u32,
             *mut u64,
             *mut u32,
-        ) -> ::windows_core::HRESULT,
+        ) -> windows_core::HRESULT,
     }
-    ::windows_core::imp::com_interface!(
+    windows_core::imp::define_interface!(
         IDiaStackWalkHelper2,
         IDiaStackWalkHelper2_Vtbl,
         0x8222c490_507b_4bef_b3bd_41dca7b5934c
     );
-    ::windows_core::imp::interface_hierarchy!(
+    impl core::ops::Deref for IDiaStackWalkHelper2 {
+        type Target = IDiaStackWalkHelper;
+        fn deref(&self) -> &Self::Target {
+            unsafe { core::mem::transmute(self) }
+        }
+    }
+    windows_core::imp::interface_hierarchy!(
         IDiaStackWalkHelper2,
-        ::windows_core::IUnknown,
+        windows_core::IUnknown,
         IDiaStackWalkHelper
     );
     impl IDiaStackWalkHelper2 {
-        pub unsafe fn get_registerValue(&self, index: u32) -> ::windows_core::Result<u64> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .get_registerValue)(
-                ::windows_core::Interface::as_raw(self),
-                index,
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn put_registerValue(
-            &self,
-            index: u32,
-            newval: u64,
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .put_registerValue)(
-                ::windows_core::Interface::as_raw(self), index, newval
-            )
-            .ok()
-        }
-        pub unsafe fn readMemory(
-            &self,
-            r#type: MemoryTypeEnum,
-            va: u64,
-            pcbdata: *mut u32,
-            pbdata: &mut [u8],
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self).base__.readMemory)(
-                ::windows_core::Interface::as_raw(self),
-                r#type,
-                va,
-                pbdata.len().try_into().unwrap(),
-                pcbdata,
-                ::core::mem::transmute(pbdata.as_ptr()),
-            )
-            .ok()
-        }
-        pub unsafe fn searchForReturnAddress<P0>(&self, frame: P0) -> ::windows_core::Result<u64>
-        where
-            P0: ::windows_core::IntoParam<IDiaFrameData>,
-        {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .searchForReturnAddress)(
-                ::windows_core::Interface::as_raw(self),
-                frame.into_param().abi(),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn searchForReturnAddressStart<P0>(
-            &self,
-            frame: P0,
-            startaddress: u64,
-        ) -> ::windows_core::Result<u64>
-        where
-            P0: ::windows_core::IntoParam<IDiaFrameData>,
-        {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .searchForReturnAddressStart)(
-                ::windows_core::Interface::as_raw(self),
-                frame.into_param().abi(),
-                startaddress,
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn frameForVA(&self, va: u64) -> ::windows_core::Result<IDiaFrameData> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.frameForVA)(
-                ::windows_core::Interface::as_raw(self),
-                va,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn symbolForVA(&self, va: u64) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.symbolForVA)(
-                ::windows_core::Interface::as_raw(self),
-                va,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn pdataForVA(
-            &self,
-            va: u64,
-            pcbdata: *mut u32,
-            pbdata: &mut [u8],
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self).base__.pdataForVA)(
-                ::windows_core::Interface::as_raw(self),
-                va,
-                pbdata.len().try_into().unwrap(),
-                pcbdata,
-                ::core::mem::transmute(pbdata.as_ptr()),
-            )
-            .ok()
-        }
-        pub unsafe fn imageForVA(&self, vacontext: u64) -> ::windows_core::Result<u64> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.imageForVA)(
-                ::windows_core::Interface::as_raw(self),
-                vacontext,
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn addressForVA(
-            &self,
-            va: u64,
-            pisect: *mut u32,
-            poffset: *mut u32,
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self).base__.addressForVA)(
-                ::windows_core::Interface::as_raw(self),
-                va,
-                pisect,
-                poffset,
-            )
-            .ok()
-        }
-        pub unsafe fn numberOfFunctionFragmentsForVA(
-            &self,
-            vafunc: u64,
-            cbfunc: u32,
-        ) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .numberOfFunctionFragmentsForVA)(
-                ::windows_core::Interface::as_raw(self),
-                vafunc,
-                cbfunc,
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn functionFragmentsForVA(
-            &self,
-            vafunc: u64,
-            cbfunc: u32,
-            cfragments: u32,
-            pvafragment: *mut u64,
-            plenfragment: *mut u32,
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .functionFragmentsForVA)(
-                ::windows_core::Interface::as_raw(self),
-                vafunc,
-                cbfunc,
-                cfragments,
-                pvafragment,
-                plenfragment,
-            )
-            .ok()
-        }
         pub unsafe fn GetPointerAuthenticationMask(
             &self,
             ptrval: u64,
-        ) -> ::windows_core::Result<u64> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).GetPointerAuthenticationMask)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<u64> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).GetPointerAuthenticationMask)(
+                windows_core::Interface::as_raw(self),
                 ptrval,
                 &mut result__,
             )
@@ -5397,800 +5527,773 @@ pub mod Dia {
     pub struct IDiaStackWalkHelper2_Vtbl {
         pub base__: IDiaStackWalkHelper_Vtbl,
         pub GetPointerAuthenticationMask: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             u64,
             *mut u64,
         )
-            -> ::windows_core::HRESULT,
+            -> windows_core::HRESULT,
     }
-    ::windows_core::imp::com_interface!(
+    windows_core::imp::define_interface!(
         IDiaStackWalker,
         IDiaStackWalker_Vtbl,
         0x5485216b_a54c_469f_9670_52b24d5229bb
     );
-    ::windows_core::imp::interface_hierarchy!(IDiaStackWalker, ::windows_core::IUnknown);
+    impl core::ops::Deref for IDiaStackWalker {
+        type Target = windows_core::IUnknown;
+        fn deref(&self) -> &Self::Target {
+            unsafe { core::mem::transmute(self) }
+        }
+    }
+    windows_core::imp::interface_hierarchy!(IDiaStackWalker, windows_core::IUnknown);
     impl IDiaStackWalker {
         pub unsafe fn getEnumFrames<P0>(
             &self,
             phelper: P0,
-        ) -> ::windows_core::Result<IDiaEnumStackFrames>
+        ) -> windows_core::Result<IDiaEnumStackFrames>
         where
-            P0: ::windows_core::IntoParam<IDiaStackWalkHelper>,
+            P0: windows_core::Param<IDiaStackWalkHelper>,
         {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).getEnumFrames)(
-                ::windows_core::Interface::as_raw(self),
-                phelper.into_param().abi(),
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).getEnumFrames)(
+                windows_core::Interface::as_raw(self),
+                phelper.param().abi(),
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
         pub unsafe fn getEnumFrames2<P0>(
             &self,
             cpuid: CV_CPU_TYPE_e,
             phelper: P0,
-        ) -> ::windows_core::Result<IDiaEnumStackFrames>
+        ) -> windows_core::Result<IDiaEnumStackFrames>
         where
-            P0: ::windows_core::IntoParam<IDiaStackWalkHelper>,
+            P0: windows_core::Param<IDiaStackWalkHelper>,
         {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).getEnumFrames2)(
-                ::windows_core::Interface::as_raw(self),
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).getEnumFrames2)(
+                windows_core::Interface::as_raw(self),
                 cpuid,
-                phelper.into_param().abi(),
+                phelper.param().abi(),
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
     }
     #[repr(C)]
     pub struct IDiaStackWalker_Vtbl {
-        pub base__: ::windows_core::IUnknown_Vtbl,
+        pub base__: windows_core::IUnknown_Vtbl,
         pub getEnumFrames: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::core::ffi::c_void,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut core::ffi::c_void,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
         pub getEnumFrames2: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             CV_CPU_TYPE_e,
-            *mut ::core::ffi::c_void,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
     }
-    ::windows_core::imp::com_interface!(
+    windows_core::imp::define_interface!(
         IDiaStackWalker2,
         IDiaStackWalker2_Vtbl,
         0x7c185885_a015_4cac_9411_0f4fb39b1f3a
     );
-    ::windows_core::imp::interface_hierarchy!(
+    impl core::ops::Deref for IDiaStackWalker2 {
+        type Target = IDiaStackWalker;
+        fn deref(&self) -> &Self::Target {
+            unsafe { core::mem::transmute(self) }
+        }
+    }
+    windows_core::imp::interface_hierarchy!(
         IDiaStackWalker2,
-        ::windows_core::IUnknown,
+        windows_core::IUnknown,
         IDiaStackWalker
     );
-    impl IDiaStackWalker2 {
-        pub unsafe fn getEnumFrames<P0>(
-            &self,
-            phelper: P0,
-        ) -> ::windows_core::Result<IDiaEnumStackFrames>
-        where
-            P0: ::windows_core::IntoParam<IDiaStackWalkHelper>,
-        {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.getEnumFrames)(
-                ::windows_core::Interface::as_raw(self),
-                phelper.into_param().abi(),
+    impl IDiaStackWalker2 {}
+    #[repr(C)]
+    pub struct IDiaStackWalker2_Vtbl {
+        pub base__: IDiaStackWalker_Vtbl,
+    }
+    windows_core::imp::define_interface!(
+        IDiaSymbol,
+        IDiaSymbol_Vtbl,
+        0xcb787b2f_bd6c_4635_ba52_933126bd2dcd
+    );
+    impl core::ops::Deref for IDiaSymbol {
+        type Target = windows_core::IUnknown;
+        fn deref(&self) -> &Self::Target {
+            unsafe { core::mem::transmute(self) }
+        }
+    }
+    windows_core::imp::interface_hierarchy!(IDiaSymbol, windows_core::IUnknown);
+    impl IDiaSymbol {
+        pub unsafe fn symIndexId(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).symIndexId)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .map(|| result__)
         }
-        pub unsafe fn getEnumFrames2<P0>(
-            &self,
-            cpuid: CV_CPU_TYPE_e,
-            phelper: P0,
-        ) -> ::windows_core::Result<IDiaEnumStackFrames>
-        where
-            P0: ::windows_core::IntoParam<IDiaStackWalkHelper>,
-        {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .getEnumFrames2)(
-                ::windows_core::Interface::as_raw(self),
-                cpuid,
-                phelper.into_param().abi(),
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-    }
-    #[repr(C)]
-    pub struct IDiaStackWalker2_Vtbl {
-        pub base__: IDiaStackWalker_Vtbl,
-    }
-    ::windows_core::imp::com_interface!(
-        IDiaSymbol,
-        IDiaSymbol_Vtbl,
-        0xcb787b2f_bd6c_4635_ba52_933126bd2dcd
-    );
-    ::windows_core::imp::interface_hierarchy!(IDiaSymbol, ::windows_core::IUnknown);
-    impl IDiaSymbol {
-        pub unsafe fn symIndexId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).symIndexId)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn symTag(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).symTag)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn symTag(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).symTag)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn name(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).name)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn name(&self) -> windows_core::Result<windows_core::BSTR> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).name)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
-        pub unsafe fn lexicalParent(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).lexicalParent)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn lexicalParent(&self) -> windows_core::Result<IDiaSymbol> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).lexicalParent)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
-        pub unsafe fn classParent(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).classParent)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn classParent(&self) -> windows_core::Result<IDiaSymbol> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).classParent)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
-        pub unsafe fn r#type(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).r#type)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn r#type(&self) -> windows_core::Result<IDiaSymbol> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).r#type)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
-        pub unsafe fn dataKind(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).dataKind)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn dataKind(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).dataKind)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn locationType(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).locationType)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn locationType(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).locationType)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn addressSection(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).addressSection)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn addressSection(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).addressSection)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn addressOffset(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).addressOffset)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn addressOffset(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).addressOffset)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn relativeVirtualAddress(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).relativeVirtualAddress)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn relativeVirtualAddress(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).relativeVirtualAddress)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn virtualAddress(&self) -> ::windows_core::Result<u64> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).virtualAddress)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn virtualAddress(&self) -> windows_core::Result<u64> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).virtualAddress)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn registerId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).registerId)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn registerId(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).registerId)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn offset(&self) -> ::windows_core::Result<i32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).offset)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn offset(&self) -> windows_core::Result<i32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).offset)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn length(&self) -> ::windows_core::Result<u64> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).length)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn length(&self) -> windows_core::Result<u64> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).length)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn slot(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).slot)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn slot(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).slot)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
         pub unsafe fn volatileType(
             &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).volatileType)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).volatileType)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn constType(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).constType)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn constType(&self) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).constType)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
         pub unsafe fn unalignedType(
             &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).unalignedType)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).unalignedType)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn access(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).access)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn access(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).access)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn libraryName(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).libraryName)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn libraryName(&self) -> windows_core::Result<windows_core::BSTR> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).libraryName)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
-        pub unsafe fn platform(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).platform)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn platform(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).platform)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn language(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).language)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn language(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).language)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
         pub unsafe fn editAndContinueEnabled(
             &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).editAndContinueEnabled)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).editAndContinueEnabled)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn frontEndMajor(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).frontEndMajor)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn frontEndMajor(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).frontEndMajor)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn frontEndMinor(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).frontEndMinor)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn frontEndMinor(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).frontEndMinor)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn frontEndBuild(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).frontEndBuild)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn frontEndBuild(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).frontEndBuild)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn backEndMajor(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).backEndMajor)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn backEndMajor(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).backEndMajor)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn backEndMinor(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).backEndMinor)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn backEndMinor(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).backEndMinor)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn backEndBuild(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).backEndBuild)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn backEndBuild(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).backEndBuild)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn sourceFileName(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).sourceFileName)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn sourceFileName(&self) -> windows_core::Result<windows_core::BSTR> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).sourceFileName)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
-        pub unsafe fn unused(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).unused)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn unused(&self) -> windows_core::Result<windows_core::BSTR> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).unused)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
-        pub unsafe fn thunkOrdinal(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).thunkOrdinal)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn thunkOrdinal(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).thunkOrdinal)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn thisAdjust(&self) -> ::windows_core::Result<i32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).thisAdjust)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn thisAdjust(&self) -> windows_core::Result<i32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).thisAdjust)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn virtualBaseOffset(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).virtualBaseOffset)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn virtualBaseOffset(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).virtualBaseOffset)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn r#virtual(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).r#virtual)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn r#virtual(&self) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).r#virtual)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn intro(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).intro)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn intro(&self) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).intro)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn pure(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).pure)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn pure(&self) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).pure)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn callingConvention(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).callingConvention)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn callingConvention(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).callingConvention)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn value(&self) -> ::windows_core::Result<::windows_core::VARIANT> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).value)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn value(&self) -> windows_core::Result<windows_core::VARIANT> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).value)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
-        pub unsafe fn baseType(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).baseType)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn baseType(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).baseType)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn token(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).token)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn token(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).token)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn timeStamp(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).timeStamp)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn timeStamp(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).timeStamp)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn guid(&self) -> ::windows_core::Result<::windows_core::GUID> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).guid)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn guid(&self) -> windows_core::Result<windows_core::GUID> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).guid)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn symbolsFileName(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).symbolsFileName)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn symbolsFileName(&self) -> windows_core::Result<windows_core::BSTR> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).symbolsFileName)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
-        pub unsafe fn reference(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).reference)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn reference(&self) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).reference)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn count(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).count)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn count(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).count)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn bitPosition(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).bitPosition)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn bitPosition(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).bitPosition)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn arrayIndexType(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).arrayIndexType)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn arrayIndexType(&self) -> windows_core::Result<IDiaSymbol> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).arrayIndexType)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
-        pub unsafe fn packed(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).packed)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn packed(&self) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).packed)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn constructor(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).constructor)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn constructor(&self) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).constructor)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
         pub unsafe fn overloadedOperator(
             &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).overloadedOperator)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).overloadedOperator)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn nested(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).nested)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn nested(&self) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).nested)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
         pub unsafe fn hasNestedTypes(
             &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).hasNestedTypes)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).hasNestedTypes)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
         pub unsafe fn hasAssignmentOperator(
             &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).hasAssignmentOperator)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).hasAssignmentOperator)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
         pub unsafe fn hasCastOperator(
             &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).hasCastOperator)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).hasCastOperator)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn scoped(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).scoped)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn scoped(&self) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).scoped)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
         pub unsafe fn virtualBaseClass(
             &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).virtualBaseClass)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).virtualBaseClass)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
         pub unsafe fn indirectVirtualBaseClass(
             &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).indirectVirtualBaseClass)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).indirectVirtualBaseClass)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn virtualBasePointerOffset(&self) -> ::windows_core::Result<i32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).virtualBasePointerOffset)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn virtualBasePointerOffset(&self) -> windows_core::Result<i32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).virtualBasePointerOffset)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn virtualTableShape(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).virtualTableShape)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn virtualTableShape(&self) -> windows_core::Result<IDiaSymbol> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).virtualTableShape)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
-        pub unsafe fn lexicalParentId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).lexicalParentId)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn lexicalParentId(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).lexicalParentId)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn classParentId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).classParentId)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn classParentId(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).classParentId)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn typeId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).typeId)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn typeId(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).typeId)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn arrayIndexTypeId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).arrayIndexTypeId)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn arrayIndexTypeId(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).arrayIndexTypeId)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn virtualTableShapeId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).virtualTableShapeId)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn virtualTableShapeId(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).virtualTableShapeId)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn code(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).code)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn code(&self) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).code)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn function(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).function)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn function(&self) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).function)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn managed(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).managed)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn managed(&self) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).managed)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn msil(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).msil)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn msil(&self) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).msil)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn virtualBaseDispIndex(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).virtualBaseDispIndex)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn virtualBaseDispIndex(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).virtualBaseDispIndex)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn undecoratedName(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).undecoratedName)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn undecoratedName(&self) -> windows_core::Result<windows_core::BSTR> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).undecoratedName)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
-        pub unsafe fn age(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).age)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn age(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).age)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn signature(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).signature)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn signature(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).signature)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
         pub unsafe fn compilerGenerated(
             &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).compilerGenerated)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).compilerGenerated)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
         pub unsafe fn addressTaken(
             &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).addressTaken)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).addressTaken)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn rank(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).rank)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn rank(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).rank)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn lowerBound(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).lowerBound)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn lowerBound(&self) -> windows_core::Result<IDiaSymbol> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).lowerBound)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
-        pub unsafe fn upperBound(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).upperBound)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn upperBound(&self) -> windows_core::Result<IDiaSymbol> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).upperBound)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
-        pub unsafe fn lowerBoundId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).lowerBoundId)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn lowerBoundId(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).lowerBoundId)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn upperBoundId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).upperBoundId)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn upperBoundId(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).upperBoundId)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
@@ -6199,12 +6302,12 @@ pub mod Dia {
             &self,
             pcbdata: *mut u32,
             pbdata: &mut [u8],
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self).get_dataBytes)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<()> {
+            (windows_core::Interface::vtable(self).get_dataBytes)(
+                windows_core::Interface::as_raw(self),
                 pbdata.len().try_into().unwrap(),
                 pcbdata,
-                ::core::mem::transmute(pbdata.as_ptr()),
+                core::mem::transmute(pbdata.as_ptr()),
             )
             .ok()
         }
@@ -6213,38 +6316,38 @@ pub mod Dia {
             symtag: SymTag,
             name: P0,
             compareflags: u32,
-        ) -> ::windows_core::Result<IDiaEnumSymbols>
+        ) -> windows_core::Result<IDiaEnumSymbols>
         where
-            P0: ::windows_core::IntoParam<::windows_core::PCWSTR>,
+            P0: windows_core::Param<windows_core::PCWSTR>,
         {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).findChildren)(
-                ::windows_core::Interface::as_raw(self),
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).findChildren)(
+                windows_core::Interface::as_raw(self),
                 symtag,
-                name.into_param().abi(),
+                name.param().abi(),
                 compareflags,
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
         pub unsafe fn findChildrenEx<P0>(
             &self,
             symtag: SymTag,
             name: P0,
             compareflags: u32,
-        ) -> ::windows_core::Result<IDiaEnumSymbols>
+        ) -> windows_core::Result<IDiaEnumSymbols>
         where
-            P0: ::windows_core::IntoParam<::windows_core::PCWSTR>,
+            P0: windows_core::Param<windows_core::PCWSTR>,
         {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).findChildrenEx)(
-                ::windows_core::Interface::as_raw(self),
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).findChildrenEx)(
+                windows_core::Interface::as_raw(self),
                 symtag,
-                name.into_param().abi(),
+                name.param().abi(),
                 compareflags,
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
         pub unsafe fn findChildrenExByAddr<P0>(
             &self,
@@ -6253,21 +6356,21 @@ pub mod Dia {
             compareflags: u32,
             isect: u32,
             offset: u32,
-        ) -> ::windows_core::Result<IDiaEnumSymbols>
+        ) -> windows_core::Result<IDiaEnumSymbols>
         where
-            P0: ::windows_core::IntoParam<::windows_core::PCWSTR>,
+            P0: windows_core::Param<windows_core::PCWSTR>,
         {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).findChildrenExByAddr)(
-                ::windows_core::Interface::as_raw(self),
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).findChildrenExByAddr)(
+                windows_core::Interface::as_raw(self),
                 symtag,
-                name.into_param().abi(),
+                name.param().abi(),
                 compareflags,
                 isect,
                 offset,
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
         pub unsafe fn findChildrenExByVA<P0>(
             &self,
@@ -6275,20 +6378,20 @@ pub mod Dia {
             name: P0,
             compareflags: u32,
             va: u64,
-        ) -> ::windows_core::Result<IDiaEnumSymbols>
+        ) -> windows_core::Result<IDiaEnumSymbols>
         where
-            P0: ::windows_core::IntoParam<::windows_core::PCWSTR>,
+            P0: windows_core::Param<windows_core::PCWSTR>,
         {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).findChildrenExByVA)(
-                ::windows_core::Interface::as_raw(self),
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).findChildrenExByVA)(
+                windows_core::Interface::as_raw(self),
                 symtag,
-                name.into_param().abi(),
+                name.param().abi(),
                 compareflags,
                 va,
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
         pub unsafe fn findChildrenExByRVA<P0>(
             &self,
@@ -6296,73 +6399,73 @@ pub mod Dia {
             name: P0,
             compareflags: u32,
             rva: u32,
-        ) -> ::windows_core::Result<IDiaEnumSymbols>
+        ) -> windows_core::Result<IDiaEnumSymbols>
         where
-            P0: ::windows_core::IntoParam<::windows_core::PCWSTR>,
+            P0: windows_core::Param<windows_core::PCWSTR>,
         {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).findChildrenExByRVA)(
-                ::windows_core::Interface::as_raw(self),
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).findChildrenExByRVA)(
+                windows_core::Interface::as_raw(self),
                 symtag,
-                name.into_param().abi(),
+                name.param().abi(),
                 compareflags,
                 rva,
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
-        pub unsafe fn targetSection(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).targetSection)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn targetSection(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).targetSection)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn targetOffset(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).targetOffset)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn targetOffset(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).targetOffset)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn targetRelativeVirtualAddress(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).targetRelativeVirtualAddress)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn targetRelativeVirtualAddress(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).targetRelativeVirtualAddress)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn targetVirtualAddress(&self) -> ::windows_core::Result<u64> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).targetVirtualAddress)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn targetVirtualAddress(&self) -> windows_core::Result<u64> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).targetVirtualAddress)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn machineType(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).machineType)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn machineType(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).machineType)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn oemId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).oemId)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn oemId(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).oemId)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn oemSymbolId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).oemSymbolId)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn oemSymbolId(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).oemSymbolId)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
@@ -6370,13 +6473,13 @@ pub mod Dia {
         pub unsafe fn get_types(
             &self,
             pctypes: *mut u32,
-            ptypes: &mut [::core::option::Option<IDiaSymbol>],
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self).get_types)(
-                ::windows_core::Interface::as_raw(self),
+            ptypes: &mut [Option<IDiaSymbol>],
+        ) -> windows_core::Result<()> {
+            (windows_core::Interface::vtable(self).get_types)(
+                windows_core::Interface::as_raw(self),
                 ptypes.len().try_into().unwrap(),
                 pctypes,
-                ::core::mem::transmute(ptypes.as_ptr()),
+                core::mem::transmute(ptypes.as_ptr()),
             )
             .ok()
         }
@@ -6384,27 +6487,27 @@ pub mod Dia {
             &self,
             pctypeids: *mut u32,
             pdwtypeids: &mut [u32],
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self).get_typeIds)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<()> {
+            (windows_core::Interface::vtable(self).get_typeIds)(
+                windows_core::Interface::as_raw(self),
                 pdwtypeids.len().try_into().unwrap(),
                 pctypeids,
-                ::core::mem::transmute(pdwtypeids.as_ptr()),
+                core::mem::transmute(pdwtypeids.as_ptr()),
             )
             .ok()
         }
-        pub unsafe fn objectPointerType(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).objectPointerType)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn objectPointerType(&self) -> windows_core::Result<IDiaSymbol> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).objectPointerType)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
-        pub unsafe fn udtKind(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).udtKind)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn udtKind(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).udtKind)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
@@ -6412,563 +6515,529 @@ pub mod Dia {
         pub unsafe fn get_undecoratedNameEx(
             &self,
             undecorateoptions: u32,
-        ) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).get_undecoratedNameEx)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<windows_core::BSTR> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).get_undecoratedNameEx)(
+                windows_core::Interface::as_raw(self),
                 undecorateoptions,
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
-        pub unsafe fn noReturn(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).noReturn)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn noReturn(&self) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).noReturn)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
         pub unsafe fn customCallingConvention(
             &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).customCallingConvention)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).customCallingConvention)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn noInline(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).noInline)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn noInline(&self) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).noInline)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
         pub unsafe fn optimizedCodeDebugInfo(
             &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).optimizedCodeDebugInfo)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).optimizedCodeDebugInfo)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn notReached(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).notReached)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn notReached(&self) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).notReached)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
         pub unsafe fn interruptReturn(
             &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).interruptReturn)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).interruptReturn)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn farReturn(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).farReturn)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn farReturn(&self) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).farReturn)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn isStatic(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).isStatic)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn isStatic(&self) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).isStatic)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
         pub unsafe fn hasDebugInfo(
             &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).hasDebugInfo)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).hasDebugInfo)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn isLTCG(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).isLTCG)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn isLTCG(&self) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).isLTCG)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
         pub unsafe fn isDataAligned(
             &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).isDataAligned)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).isDataAligned)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
         pub unsafe fn hasSecurityChecks(
             &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).hasSecurityChecks)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).hasSecurityChecks)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn compilerName(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).compilerName)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn compilerName(&self) -> windows_core::Result<windows_core::BSTR> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).compilerName)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
-        pub unsafe fn hasAlloca(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).hasAlloca)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn hasAlloca(&self) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).hasAlloca)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn hasSetJump(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).hasSetJump)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn hasSetJump(&self) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).hasSetJump)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn hasLongJump(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).hasLongJump)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn hasLongJump(&self) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).hasLongJump)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn hasInlAsm(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).hasInlAsm)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn hasInlAsm(&self) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).hasInlAsm)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn hasEH(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).hasEH)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn hasEH(&self) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).hasEH)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn hasSEH(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).hasSEH)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn hasSEH(&self) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).hasSEH)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn hasEHa(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).hasEHa)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn hasEHa(&self) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).hasEHa)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn isNaked(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).isNaked)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn isNaked(&self) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).isNaked)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
         pub unsafe fn isAggregated(
             &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).isAggregated)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).isAggregated)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn isSplitted(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).isSplitted)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn isSplitted(&self) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).isSplitted)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn container(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).container)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn container(&self) -> windows_core::Result<IDiaSymbol> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).container)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
-        pub unsafe fn inlSpec(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).inlSpec)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn inlSpec(&self) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).inlSpec)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
         pub unsafe fn noStackOrdering(
             &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).noStackOrdering)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).noStackOrdering)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn virtualBaseTableType(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).virtualBaseTableType)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn virtualBaseTableType(&self) -> windows_core::Result<IDiaSymbol> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).virtualBaseTableType)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
         pub unsafe fn hasManagedCode(
             &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).hasManagedCode)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).hasManagedCode)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
         pub unsafe fn isHotpatchable(
             &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).isHotpatchable)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).isHotpatchable)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn isCVTCIL(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).isCVTCIL)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn isCVTCIL(&self) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).isCVTCIL)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
         pub unsafe fn isMSILNetmodule(
             &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).isMSILNetmodule)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).isMSILNetmodule)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn isCTypes(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).isCTypes)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn isCTypes(&self) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).isCTypes)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn isStripped(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).isStripped)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn isStripped(&self) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).isStripped)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn frontEndQFE(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).frontEndQFE)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn frontEndQFE(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).frontEndQFE)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn backEndQFE(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).backEndQFE)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn backEndQFE(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).backEndQFE)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn wasInlined(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).wasInlined)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn wasInlined(&self) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).wasInlined)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
         pub unsafe fn strictGSCheck(
             &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).strictGSCheck)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).strictGSCheck)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
         pub unsafe fn isCxxReturnUdt(
             &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).isCxxReturnUdt)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).isCxxReturnUdt)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
         pub unsafe fn isConstructorVirtualBase(
             &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).isConstructorVirtualBase)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).isConstructorVirtualBase)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
         pub unsafe fn RValueReference(
             &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).RValueReference)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).RValueReference)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn unmodifiedType(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).unmodifiedType)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn unmodifiedType(&self) -> windows_core::Result<IDiaSymbol> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).unmodifiedType)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
         pub unsafe fn framePointerPresent(
             &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).framePointerPresent)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).framePointerPresent)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
         pub unsafe fn isSafeBuffers(
             &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).isSafeBuffers)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).isSafeBuffers)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn intrinsic(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).intrinsic)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn intrinsic(&self) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).intrinsic)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn sealed(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).sealed)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn sealed(&self) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).sealed)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn hfaFloat(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).hfaFloat)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn hfaFloat(&self) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).hfaFloat)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn hfaDouble(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).hfaDouble)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn hfaDouble(&self) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).hfaDouble)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn liveRangeStartAddressSection(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).liveRangeStartAddressSection)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn liveRangeStartAddressSection(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).liveRangeStartAddressSection)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn liveRangeStartAddressOffset(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).liveRangeStartAddressOffset)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn liveRangeStartAddressOffset(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).liveRangeStartAddressOffset)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn liveRangeStartRelativeVirtualAddress(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).liveRangeStartRelativeVirtualAddress)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn liveRangeStartRelativeVirtualAddress(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).liveRangeStartRelativeVirtualAddress)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn countLiveRanges(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).countLiveRanges)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn countLiveRanges(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).countLiveRanges)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn liveRangeLength(&self) -> ::windows_core::Result<u64> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).liveRangeLength)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn liveRangeLength(&self) -> windows_core::Result<u64> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).liveRangeLength)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn offsetInUdt(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).offsetInUdt)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn offsetInUdt(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).offsetInUdt)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn paramBasePointerRegisterId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).paramBasePointerRegisterId)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn paramBasePointerRegisterId(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).paramBasePointerRegisterId)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn localBasePointerRegisterId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).localBasePointerRegisterId)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn localBasePointerRegisterId(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).localBasePointerRegisterId)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
         pub unsafe fn isLocationControlFlowDependent(
             &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).isLocationControlFlowDependent)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).isLocationControlFlowDependent)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn stride(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).stride)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn stride(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).stride)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn numberOfRows(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).numberOfRows)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn numberOfRows(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).numberOfRows)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn numberOfColumns(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).numberOfColumns)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn numberOfColumns(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).numberOfColumns)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
         pub unsafe fn isMatrixRowMajor(
             &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).isMatrixRowMajor)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).isMatrixRowMajor)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
@@ -6977,12 +7046,12 @@ pub mod Dia {
             &self,
             pcnt: *mut u32,
             pproperties: &mut [u32],
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self).get_numericProperties)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<()> {
+            (windows_core::Interface::vtable(self).get_numericProperties)(
+                windows_core::Interface::as_raw(self),
                 pproperties.len().try_into().unwrap(),
                 pcnt,
-                ::core::mem::transmute(pproperties.as_ptr()),
+                core::mem::transmute(pproperties.as_ptr()),
             )
             .ok()
         }
@@ -6990,333 +7059,327 @@ pub mod Dia {
             &self,
             pcnt: *mut u32,
             pmodifiers: &mut [u16],
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self).get_modifierValues)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<()> {
+            (windows_core::Interface::vtable(self).get_modifierValues)(
+                windows_core::Interface::as_raw(self),
                 pmodifiers.len().try_into().unwrap(),
                 pcnt,
-                ::core::mem::transmute(pmodifiers.as_ptr()),
+                core::mem::transmute(pmodifiers.as_ptr()),
             )
             .ok()
         }
         pub unsafe fn isReturnValue(
             &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).isReturnValue)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).isReturnValue)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
         pub unsafe fn isOptimizedAway(
             &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).isOptimizedAway)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).isOptimizedAway)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn builtInKind(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).builtInKind)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn builtInKind(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).builtInKind)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn registerType(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).registerType)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn registerType(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).registerType)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn baseDataSlot(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).baseDataSlot)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn baseDataSlot(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).baseDataSlot)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn baseDataOffset(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).baseDataOffset)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn baseDataOffset(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).baseDataOffset)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn textureSlot(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).textureSlot)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn textureSlot(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).textureSlot)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn samplerSlot(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).samplerSlot)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn samplerSlot(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).samplerSlot)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn uavSlot(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).uavSlot)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn uavSlot(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).uavSlot)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn sizeInUdt(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).sizeInUdt)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn sizeInUdt(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).sizeInUdt)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn memorySpaceKind(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).memorySpaceKind)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn memorySpaceKind(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).memorySpaceKind)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn unmodifiedTypeId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).unmodifiedTypeId)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn unmodifiedTypeId(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).unmodifiedTypeId)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn subTypeId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).subTypeId)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn subTypeId(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).subTypeId)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn subType(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).subType)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn subType(&self) -> windows_core::Result<IDiaSymbol> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).subType)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
-        pub unsafe fn numberOfModifiers(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).numberOfModifiers)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn numberOfModifiers(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).numberOfModifiers)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn numberOfRegisterIndices(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).numberOfRegisterIndices)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn numberOfRegisterIndices(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).numberOfRegisterIndices)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn isHLSLData(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).isHLSLData)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn isHLSLData(&self) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).isHLSLData)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
         pub unsafe fn isPointerToDataMember(
             &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).isPointerToDataMember)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).isPointerToDataMember)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
         pub unsafe fn isPointerToMemberFunction(
             &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).isPointerToMemberFunction)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).isPointerToMemberFunction)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
         pub unsafe fn isSingleInheritance(
             &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).isSingleInheritance)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).isSingleInheritance)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
         pub unsafe fn isMultipleInheritance(
             &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).isMultipleInheritance)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).isMultipleInheritance)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
         pub unsafe fn isVirtualInheritance(
             &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).isVirtualInheritance)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).isVirtualInheritance)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
         pub unsafe fn restrictedType(
             &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).restrictedType)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).restrictedType)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
         pub unsafe fn isPointerBasedOnSymbolValue(
             &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).isPointerBasedOnSymbolValue)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).isPointerBasedOnSymbolValue)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn baseSymbol(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).baseSymbol)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn baseSymbol(&self) -> windows_core::Result<IDiaSymbol> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).baseSymbol)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
-        pub unsafe fn baseSymbolId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).baseSymbolId)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn baseSymbolId(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).baseSymbolId)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn objectFileName(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).objectFileName)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn objectFileName(&self) -> windows_core::Result<windows_core::BSTR> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).objectFileName)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
         pub unsafe fn isAcceleratorGroupSharedLocal(
             &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).isAcceleratorGroupSharedLocal)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).isAcceleratorGroupSharedLocal)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
         pub unsafe fn isAcceleratorPointerTagLiveRange(
             &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).isAcceleratorPointerTagLiveRange)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).isAcceleratorPointerTagLiveRange)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
         pub unsafe fn isAcceleratorStubFunction(
             &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).isAcceleratorStubFunction)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).isAcceleratorStubFunction)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn numberOfAcceleratorPointerTags(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).numberOfAcceleratorPointerTags)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn numberOfAcceleratorPointerTags(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).numberOfAcceleratorPointerTags)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn isSdl(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).isSdl)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn isSdl(&self) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).isSdl)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
         pub unsafe fn isWinRTPointer(
             &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).isWinRTPointer)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).isWinRTPointer)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn isRefUdt(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).isRefUdt)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn isRefUdt(&self) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).isRefUdt)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn isValueUdt(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).isValueUdt)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn isValueUdt(&self) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).isValueUdt)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
         pub unsafe fn isInterfaceUdt(
             &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).isInterfaceUdt)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).isInterfaceUdt)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
@@ -7325,379 +7388,375 @@ pub mod Dia {
             &self,
             isect: u32,
             offset: u32,
-        ) -> ::windows_core::Result<IDiaEnumSymbols> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).findInlineFramesByAddr)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<IDiaEnumSymbols> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).findInlineFramesByAddr)(
+                windows_core::Interface::as_raw(self),
                 isect,
                 offset,
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
         pub unsafe fn findInlineFramesByRVA(
             &self,
             rva: u32,
-        ) -> ::windows_core::Result<IDiaEnumSymbols> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).findInlineFramesByRVA)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<IDiaEnumSymbols> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).findInlineFramesByRVA)(
+                windows_core::Interface::as_raw(self),
                 rva,
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
         pub unsafe fn findInlineFramesByVA(
             &self,
             va: u64,
-        ) -> ::windows_core::Result<IDiaEnumSymbols> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).findInlineFramesByVA)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<IDiaEnumSymbols> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).findInlineFramesByVA)(
+                windows_core::Interface::as_raw(self),
                 va,
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
-        pub unsafe fn findInlineeLines(&self) -> ::windows_core::Result<IDiaEnumLineNumbers> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).findInlineeLines)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn findInlineeLines(&self) -> windows_core::Result<IDiaEnumLineNumbers> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).findInlineeLines)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
         pub unsafe fn findInlineeLinesByAddr(
             &self,
             isect: u32,
             offset: u32,
             length: u32,
-        ) -> ::windows_core::Result<IDiaEnumLineNumbers> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).findInlineeLinesByAddr)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<IDiaEnumLineNumbers> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).findInlineeLinesByAddr)(
+                windows_core::Interface::as_raw(self),
                 isect,
                 offset,
                 length,
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
         pub unsafe fn findInlineeLinesByRVA(
             &self,
             rva: u32,
             length: u32,
-        ) -> ::windows_core::Result<IDiaEnumLineNumbers> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).findInlineeLinesByRVA)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<IDiaEnumLineNumbers> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).findInlineeLinesByRVA)(
+                windows_core::Interface::as_raw(self),
                 rva,
                 length,
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
         pub unsafe fn findInlineeLinesByVA(
             &self,
             va: u64,
             length: u32,
-        ) -> ::windows_core::Result<IDiaEnumLineNumbers> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).findInlineeLinesByVA)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<IDiaEnumLineNumbers> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).findInlineeLinesByVA)(
+                windows_core::Interface::as_raw(self),
                 va,
                 length,
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
         pub unsafe fn findSymbolsForAcceleratorPointerTag(
             &self,
             tagvalue: u32,
-        ) -> ::windows_core::Result<IDiaEnumSymbols> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).findSymbolsForAcceleratorPointerTag)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<IDiaEnumSymbols> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).findSymbolsForAcceleratorPointerTag)(
+                windows_core::Interface::as_raw(self),
                 tagvalue,
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
         pub unsafe fn findSymbolsByRVAForAcceleratorPointerTag(
             &self,
             tagvalue: u32,
             rva: u32,
-        ) -> ::windows_core::Result<IDiaEnumSymbols> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).findSymbolsByRVAForAcceleratorPointerTag)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<IDiaEnumSymbols> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).findSymbolsByRVAForAcceleratorPointerTag)(
+                windows_core::Interface::as_raw(self),
                 tagvalue,
                 rva,
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
         pub unsafe fn get_acceleratorPointerTags(
             &self,
             pcnt: *mut u32,
             ppointertags: &mut [u32],
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self).get_acceleratorPointerTags)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<()> {
+            (windows_core::Interface::vtable(self).get_acceleratorPointerTags)(
+                windows_core::Interface::as_raw(self),
                 ppointertags.len().try_into().unwrap(),
                 pcnt,
-                ::core::mem::transmute(ppointertags.as_ptr()),
+                core::mem::transmute(ppointertags.as_ptr()),
             )
             .ok()
         }
-        pub unsafe fn getSrcLineOnTypeDefn(&self) -> ::windows_core::Result<IDiaLineNumber> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).getSrcLineOnTypeDefn)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn getSrcLineOnTypeDefn(&self) -> windows_core::Result<IDiaLineNumber> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).getSrcLineOnTypeDefn)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
-        pub unsafe fn isPGO(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).isPGO)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn isPGO(&self) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).isPGO)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
         pub unsafe fn hasValidPGOCounts(
             &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).hasValidPGOCounts)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).hasValidPGOCounts)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
         pub unsafe fn isOptimizedForSpeed(
             &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).isOptimizedForSpeed)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).isOptimizedForSpeed)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn PGOEntryCount(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).PGOEntryCount)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn PGOEntryCount(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).PGOEntryCount)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn PGOEdgeCount(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).PGOEdgeCount)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn PGOEdgeCount(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).PGOEdgeCount)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn PGODynamicInstructionCount(&self) -> ::windows_core::Result<u64> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).PGODynamicInstructionCount)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn PGODynamicInstructionCount(&self) -> windows_core::Result<u64> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).PGODynamicInstructionCount)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn staticSize(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).staticSize)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn staticSize(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).staticSize)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn finalLiveStaticSize(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).finalLiveStaticSize)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn finalLiveStaticSize(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).finalLiveStaticSize)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn phaseName(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).phaseName)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn phaseName(&self) -> windows_core::Result<windows_core::BSTR> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).phaseName)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
         pub unsafe fn hasControlFlowCheck(
             &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).hasControlFlowCheck)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).hasControlFlowCheck)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
         pub unsafe fn constantExport(
             &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).constantExport)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).constantExport)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn dataExport(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).dataExport)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn dataExport(&self) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).dataExport)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
         pub unsafe fn privateExport(
             &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).privateExport)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).privateExport)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
         pub unsafe fn noNameExport(
             &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).noNameExport)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).noNameExport)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
         pub unsafe fn exportHasExplicitlyAssignedOrdinal(
             &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).exportHasExplicitlyAssignedOrdinal)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).exportHasExplicitlyAssignedOrdinal)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
         pub unsafe fn exportIsForwarder(
             &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).exportIsForwarder)(
-                ::windows_core::Interface::as_raw(self),
+        ) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).exportIsForwarder)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn ordinal(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).ordinal)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn ordinal(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).ordinal)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn frameSize(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).frameSize)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn frameSize(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).frameSize)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn exceptionHandlerAddressSection(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).exceptionHandlerAddressSection)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn exceptionHandlerAddressSection(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).exceptionHandlerAddressSection)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn exceptionHandlerAddressOffset(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).exceptionHandlerAddressOffset)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn exceptionHandlerAddressOffset(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).exceptionHandlerAddressOffset)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn exceptionHandlerRelativeVirtualAddress(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).exceptionHandlerRelativeVirtualAddress)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn exceptionHandlerRelativeVirtualAddress(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).exceptionHandlerRelativeVirtualAddress)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn exceptionHandlerVirtualAddress(&self) -> ::windows_core::Result<u64> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).exceptionHandlerVirtualAddress)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn exceptionHandlerVirtualAddress(&self) -> windows_core::Result<u64> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).exceptionHandlerVirtualAddress)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn findInputAssemblyFile(
-            &self,
-        ) -> ::windows_core::Result<IDiaInputAssemblyFile> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).findInputAssemblyFile)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn findInputAssemblyFile(&self) -> windows_core::Result<IDiaInputAssemblyFile> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).findInputAssemblyFile)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
-        pub unsafe fn characteristics(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).characteristics)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn characteristics(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).characteristics)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn coffGroup(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).coffGroup)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn coffGroup(&self) -> windows_core::Result<IDiaSymbol> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).coffGroup)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
-        pub unsafe fn bindID(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).bindID)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn bindID(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).bindID)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn bindSpace(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).bindSpace)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn bindSpace(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).bindSpace)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn bindSlot(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).bindSlot)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn bindSlot(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).bindSlot)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
@@ -7705,1028 +7764,833 @@ pub mod Dia {
     }
     #[repr(C)]
     pub struct IDiaSymbol_Vtbl {
-        pub base__: ::windows_core::IUnknown_Vtbl,
-        pub symIndexId: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub symTag: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
+        pub base__: windows_core::IUnknown_Vtbl,
+        pub symIndexId:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+        pub symTag:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
         pub name: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::std::mem::MaybeUninit<::windows_core::BSTR>,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut core::mem::MaybeUninit<windows_core::BSTR>,
+        ) -> windows_core::HRESULT,
         pub lexicalParent: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
         pub classParent: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
         pub r#type: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
-        pub dataKind: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub locationType: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub addressSection: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub addressOffset: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub relativeVirtualAddress: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub virtualAddress: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u64,
-        ) -> ::windows_core::HRESULT,
-        pub registerId: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub offset: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut i32,
-        ) -> ::windows_core::HRESULT,
-        pub length: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u64,
-        ) -> ::windows_core::HRESULT,
-        pub slot: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
+        pub dataKind:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+        pub locationType:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+        pub addressSection:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+        pub addressOffset:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+        pub relativeVirtualAddress:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+        pub virtualAddress:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u64) -> windows_core::HRESULT,
+        pub registerId:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+        pub offset:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut i32) -> windows_core::HRESULT,
+        pub length:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u64) -> windows_core::HRESULT,
+        pub slot:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
         pub volatileType: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub constType: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub unalignedType: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
-        pub access: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
+        pub access:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
         pub libraryName: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::std::mem::MaybeUninit<::windows_core::BSTR>,
-        ) -> ::windows_core::HRESULT,
-        pub platform: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub language: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut core::mem::MaybeUninit<windows_core::BSTR>,
+        ) -> windows_core::HRESULT,
+        pub platform:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+        pub language:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
         pub editAndContinueEnabled: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
-        pub frontEndMajor: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub frontEndMinor: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub frontEndBuild: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub backEndMajor: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub backEndMinor: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub backEndBuild: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
+        pub frontEndMajor:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+        pub frontEndMinor:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+        pub frontEndBuild:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+        pub backEndMajor:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+        pub backEndMinor:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+        pub backEndBuild:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
         pub sourceFileName: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::std::mem::MaybeUninit<::windows_core::BSTR>,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut core::mem::MaybeUninit<windows_core::BSTR>,
+        ) -> windows_core::HRESULT,
         pub unused: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::std::mem::MaybeUninit<::windows_core::BSTR>,
-        ) -> ::windows_core::HRESULT,
-        pub thunkOrdinal: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub thisAdjust: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut i32,
-        ) -> ::windows_core::HRESULT,
-        pub virtualBaseOffset: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut core::mem::MaybeUninit<windows_core::BSTR>,
+        ) -> windows_core::HRESULT,
+        pub thunkOrdinal:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+        pub thisAdjust:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut i32) -> windows_core::HRESULT,
+        pub virtualBaseOffset:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
         pub r#virtual: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub intro: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub pure: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
-        pub callingConvention: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
+        pub callingConvention:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
         pub value: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>,
-        ) -> ::windows_core::HRESULT,
-        pub baseType: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub token: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub timeStamp: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut core::mem::MaybeUninit<windows_core::VARIANT>,
+        ) -> windows_core::HRESULT,
+        pub baseType:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+        pub token:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+        pub timeStamp:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
         pub guid: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows_core::GUID,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows_core::GUID,
+        ) -> windows_core::HRESULT,
         pub symbolsFileName: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::std::mem::MaybeUninit<::windows_core::BSTR>,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut core::mem::MaybeUninit<windows_core::BSTR>,
+        ) -> windows_core::HRESULT,
         pub reference: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
-        pub count: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub bitPosition: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
+        pub count:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+        pub bitPosition:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
         pub arrayIndexType: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
         pub packed: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub constructor: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub overloadedOperator: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub nested: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub hasNestedTypes: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub hasAssignmentOperator: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub hasCastOperator: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub scoped: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub virtualBaseClass: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub indirectVirtualBaseClass: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
-        pub virtualBasePointerOffset: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut i32,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
+        pub virtualBasePointerOffset:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut i32) -> windows_core::HRESULT,
         pub virtualTableShape: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
-        pub lexicalParentId: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub classParentId: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub typeId: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub arrayIndexTypeId: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub virtualTableShapeId: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
+        pub lexicalParentId:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+        pub classParentId:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+        pub typeId:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+        pub arrayIndexTypeId:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+        pub virtualTableShapeId:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
         pub code: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub function: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub managed: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub msil: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
-        pub virtualBaseDispIndex: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
+        pub virtualBaseDispIndex:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
         pub undecoratedName: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::std::mem::MaybeUninit<::windows_core::BSTR>,
-        ) -> ::windows_core::HRESULT,
-        pub age: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub signature: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut core::mem::MaybeUninit<windows_core::BSTR>,
+        ) -> windows_core::HRESULT,
+        pub age:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+        pub signature:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
         pub compilerGenerated: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub addressTaken: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
-        pub rank: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
+        pub rank:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
         pub lowerBound: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
         pub upperBound: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
-        pub lowerBoundId: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub upperBoundId: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
+        pub lowerBoundId:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+        pub upperBoundId:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
         pub get_dataBytes: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             u32,
             *mut u32,
             *mut u8,
-        ) -> ::windows_core::HRESULT,
+        ) -> windows_core::HRESULT,
         pub findChildren: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             SymTag,
-            ::windows_core::PCWSTR,
+            windows_core::PCWSTR,
             u32,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
         pub findChildrenEx: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             SymTag,
-            ::windows_core::PCWSTR,
+            windows_core::PCWSTR,
             u32,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
         pub findChildrenExByAddr: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             SymTag,
-            ::windows_core::PCWSTR,
+            windows_core::PCWSTR,
             u32,
             u32,
             u32,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
         pub findChildrenExByVA: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             SymTag,
-            ::windows_core::PCWSTR,
+            windows_core::PCWSTR,
             u32,
             u64,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
         pub findChildrenExByRVA: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             SymTag,
-            ::windows_core::PCWSTR,
-            u32,
-            u32,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
-        pub targetSection: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub targetOffset: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub targetRelativeVirtualAddress: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        )
-            -> ::windows_core::HRESULT,
-        pub targetVirtualAddress: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u64,
-        ) -> ::windows_core::HRESULT,
-        pub machineType: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub oemId: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub oemSymbolId: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
+            windows_core::PCWSTR,
+            u32,
+            u32,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
+        pub targetSection:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+        pub targetOffset:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+        pub targetRelativeVirtualAddress:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+        pub targetVirtualAddress:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u64) -> windows_core::HRESULT,
+        pub machineType:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+        pub oemId:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+        pub oemSymbolId:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
         pub get_types: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             u32,
             *mut u32,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
         pub get_typeIds: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             u32,
             *mut u32,
             *mut u32,
-        ) -> ::windows_core::HRESULT,
+        ) -> windows_core::HRESULT,
         pub objectPointerType: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
-        pub udtKind: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
+        pub udtKind:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
         pub get_undecoratedNameEx: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             u32,
-            *mut ::std::mem::MaybeUninit<::windows_core::BSTR>,
-        ) -> ::windows_core::HRESULT,
+            *mut core::mem::MaybeUninit<windows_core::BSTR>,
+        ) -> windows_core::HRESULT,
         pub noReturn: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub customCallingConvention: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub noInline: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub optimizedCodeDebugInfo: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub notReached: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub interruptReturn: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub farReturn: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub isStatic: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub hasDebugInfo: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub isLTCG: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub isDataAligned: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub hasSecurityChecks: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub compilerName: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::std::mem::MaybeUninit<::windows_core::BSTR>,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut core::mem::MaybeUninit<windows_core::BSTR>,
+        ) -> windows_core::HRESULT,
         pub hasAlloca: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub hasSetJump: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub hasLongJump: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub hasInlAsm: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub hasEH: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub hasSEH: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub hasEHa: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub isNaked: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub isAggregated: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub isSplitted: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub container: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
         pub inlSpec: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub noStackOrdering: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub virtualBaseTableType: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
         pub hasManagedCode: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub isHotpatchable: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub isCVTCIL: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub isMSILNetmodule: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub isCTypes: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub isStripped: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
-        pub frontEndQFE: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub backEndQFE: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
+        pub frontEndQFE:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+        pub backEndQFE:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
         pub wasInlined: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub strictGSCheck: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub isCxxReturnUdt: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub isConstructorVirtualBase: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub RValueReference: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub unmodifiedType: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
         pub framePointerPresent: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub isSafeBuffers: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub intrinsic: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub sealed: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub hfaFloat: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub hfaDouble: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
-        pub liveRangeStartAddressSection: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        )
-            -> ::windows_core::HRESULT,
-        pub liveRangeStartAddressOffset: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        )
-            -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
+        pub liveRangeStartAddressSection:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+        pub liveRangeStartAddressOffset:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
         pub liveRangeStartRelativeVirtualAddress:
-            unsafe extern "system" fn(
-                *mut ::core::ffi::c_void,
-                *mut u32,
-            ) -> ::windows_core::HRESULT,
-        pub countLiveRanges: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub liveRangeLength: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u64,
-        ) -> ::windows_core::HRESULT,
-        pub offsetInUdt: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub paramBasePointerRegisterId: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        )
-            -> ::windows_core::HRESULT,
-        pub localBasePointerRegisterId: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        )
-            -> ::windows_core::HRESULT,
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+        pub countLiveRanges:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+        pub liveRangeLength:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u64) -> windows_core::HRESULT,
+        pub offsetInUdt:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+        pub paramBasePointerRegisterId:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+        pub localBasePointerRegisterId:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
         pub isLocationControlFlowDependent: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
         )
-            -> ::windows_core::HRESULT,
-        pub stride: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub numberOfRows: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub numberOfColumns: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
+            -> windows_core::HRESULT,
+        pub stride:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+        pub numberOfRows:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+        pub numberOfColumns:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
         pub isMatrixRowMajor: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub get_numericProperties: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             u32,
             *mut u32,
             *mut u32,
-        ) -> ::windows_core::HRESULT,
+        ) -> windows_core::HRESULT,
         pub get_modifierValues: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             u32,
             *mut u32,
             *mut u16,
-        ) -> ::windows_core::HRESULT,
+        ) -> windows_core::HRESULT,
         pub isReturnValue: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub isOptimizedAway: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
-        pub builtInKind: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub registerType: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub baseDataSlot: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub baseDataOffset: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub textureSlot: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub samplerSlot: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub uavSlot: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub sizeInUdt: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub memorySpaceKind: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub unmodifiedTypeId: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub subTypeId: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
+        pub builtInKind:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+        pub registerType:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+        pub baseDataSlot:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+        pub baseDataOffset:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+        pub textureSlot:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+        pub samplerSlot:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+        pub uavSlot:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+        pub sizeInUdt:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+        pub memorySpaceKind:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+        pub unmodifiedTypeId:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+        pub subTypeId:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
         pub subType: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
-        pub numberOfModifiers: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub numberOfRegisterIndices: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
+        pub numberOfModifiers:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+        pub numberOfRegisterIndices:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
         pub isHLSLData: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub isPointerToDataMember: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub isPointerToMemberFunction: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        )
-            -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub isSingleInheritance: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub isMultipleInheritance: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub isVirtualInheritance: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub restrictedType: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub isPointerBasedOnSymbolValue: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
         )
-            -> ::windows_core::HRESULT,
+            -> windows_core::HRESULT,
         pub baseSymbol: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
-        pub baseSymbolId: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
+        pub baseSymbolId:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
         pub objectFileName: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::std::mem::MaybeUninit<::windows_core::BSTR>,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut core::mem::MaybeUninit<windows_core::BSTR>,
+        ) -> windows_core::HRESULT,
         pub isAcceleratorGroupSharedLocal: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
         )
-            -> ::windows_core::HRESULT,
+            -> windows_core::HRESULT,
         pub isAcceleratorPointerTagLiveRange: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
         )
-            -> ::windows_core::HRESULT,
+            -> windows_core::HRESULT,
         pub isAcceleratorStubFunction: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        )
-            -> ::windows_core::HRESULT,
-        pub numberOfAcceleratorPointerTags: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        )
-            -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
+        pub numberOfAcceleratorPointerTags:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
         pub isSdl: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub isWinRTPointer: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub isRefUdt: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub isValueUdt: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub isInterfaceUdt: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub findInlineFramesByAddr: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             u32,
             u32,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
         pub findInlineFramesByRVA: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             u32,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
         pub findInlineFramesByVA: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             u64,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
         pub findInlineeLines: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
         pub findInlineeLinesByAddr: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             u32,
             u32,
             u32,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
         pub findInlineeLinesByRVA: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             u32,
             u32,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
         pub findInlineeLinesByVA: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             u64,
             u32,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
-        pub findSymbolsForAcceleratorPointerTag:
-            unsafe extern "system" fn(
-                *mut ::core::ffi::c_void,
-                u32,
-                *mut *mut ::core::ffi::c_void,
-            ) -> ::windows_core::HRESULT,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
+        pub findSymbolsForAcceleratorPointerTag: unsafe extern "system" fn(
+            *mut core::ffi::c_void,
+            u32,
+            *mut *mut core::ffi::c_void,
+        )
+            -> windows_core::HRESULT,
         pub findSymbolsByRVAForAcceleratorPointerTag:
             unsafe extern "system" fn(
-                *mut ::core::ffi::c_void,
+                *mut core::ffi::c_void,
                 u32,
                 u32,
-                *mut *mut ::core::ffi::c_void,
-            ) -> ::windows_core::HRESULT,
+                *mut *mut core::ffi::c_void,
+            ) -> windows_core::HRESULT,
         pub get_acceleratorPointerTags: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             u32,
             *mut u32,
             *mut u32,
-        )
-            -> ::windows_core::HRESULT,
+        ) -> windows_core::HRESULT,
         pub getSrcLineOnTypeDefn: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
         pub isPGO: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub hasValidPGOCounts: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub isOptimizedForSpeed: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
-        pub PGOEntryCount: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub PGOEdgeCount: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub PGODynamicInstructionCount: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u64,
-        )
-            -> ::windows_core::HRESULT,
-        pub staticSize: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub finalLiveStaticSize: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
+        pub PGOEntryCount:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+        pub PGOEdgeCount:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+        pub PGODynamicInstructionCount:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u64) -> windows_core::HRESULT,
+        pub staticSize:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+        pub finalLiveStaticSize:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
         pub phaseName: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::std::mem::MaybeUninit<::windows_core::BSTR>,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut core::mem::MaybeUninit<windows_core::BSTR>,
+        ) -> windows_core::HRESULT,
         pub hasControlFlowCheck: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub constantExport: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub dataExport: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub privateExport: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
         pub noNameExport: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
-        pub exportHasExplicitlyAssignedOrdinal:
-            unsafe extern "system" fn(
-                *mut ::core::ffi::c_void,
-                *mut ::windows::Win32::Foundation::BOOL,
-            ) -> ::windows_core::HRESULT,
-        pub exportIsForwarder: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
-        pub ordinal: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub frameSize: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub exceptionHandlerAddressSection: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        )
-            -> ::windows_core::HRESULT,
-        pub exceptionHandlerAddressOffset: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
+        pub exportHasExplicitlyAssignedOrdinal: unsafe extern "system" fn(
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
         )
-            -> ::windows_core::HRESULT,
+            -> windows_core::HRESULT,
+        pub exportIsForwarder: unsafe extern "system" fn(
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
+        pub ordinal:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+        pub frameSize:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+        pub exceptionHandlerAddressSection:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+        pub exceptionHandlerAddressOffset:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
         pub exceptionHandlerRelativeVirtualAddress:
-            unsafe extern "system" fn(
-                *mut ::core::ffi::c_void,
-                *mut u32,
-            ) -> ::windows_core::HRESULT,
-        pub exceptionHandlerVirtualAddress: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u64,
-        )
-            -> ::windows_core::HRESULT,
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+        pub exceptionHandlerVirtualAddress:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u64) -> windows_core::HRESULT,
         pub findInputAssemblyFile: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
-        pub characteristics: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
+        pub characteristics:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
         pub coffGroup: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
-        pub bindID: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub bindSpace: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub bindSlot: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
-    }
-    ::windows_core::imp::com_interface!(
+            *mut core::ffi::c_void,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
+        pub bindID:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+        pub bindSpace:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+        pub bindSlot:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+    }
+    windows_core::imp::define_interface!(
         IDiaSymbol10,
         IDiaSymbol10_Vtbl,
         0x9034a70b_b0b7_4605_8a97_33772f3a7b8c
     );
-    ::windows_core::imp::interface_hierarchy!(
+    impl core::ops::Deref for IDiaSymbol10 {
+        type Target = IDiaSymbol9;
+        fn deref(&self) -> &Self::Target {
+            unsafe { core::mem::transmute(self) }
+        }
+    }
+    windows_core::imp::interface_hierarchy!(
         IDiaSymbol10,
-        ::windows_core::IUnknown,
+        windows_core::IUnknown,
         IDiaSymbol,
         IDiaSymbol2,
         IDiaSymbol3,
@@ -8738,33589 +8602,493 @@ pub mod Dia {
         IDiaSymbol9
     );
     impl IDiaSymbol10 {
-        pub unsafe fn symIndexId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .symIndexId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn symTag(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .symTag)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn name(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .name)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn lexicalParent(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .lexicalParent)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn classParent(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .classParent)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn r#type(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .r#type)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn dataKind(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .dataKind)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn locationType(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .locationType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn addressSection(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .addressSection)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn addressOffset(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .addressOffset)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn relativeVirtualAddress(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .relativeVirtualAddress)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn virtualAddress(&self) -> ::windows_core::Result<u64> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .virtualAddress)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn registerId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .registerId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn offset(&self) -> ::windows_core::Result<i32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .offset)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn length(&self) -> ::windows_core::Result<u64> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .length)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn slot(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .slot)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn volatileType(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .volatileType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn constType(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .constType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn unalignedType(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .unalignedType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn access(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .access)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn libraryName(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .libraryName)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn platform(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .platform)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn language(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .language)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn editAndContinueEnabled(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .editAndContinueEnabled)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn frontEndMajor(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .frontEndMajor)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn frontEndMinor(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .frontEndMinor)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn frontEndBuild(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .frontEndBuild)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn backEndMajor(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .backEndMajor)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn backEndMinor(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .backEndMinor)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn backEndBuild(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .backEndBuild)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn sourceFileName(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .sourceFileName)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn unused(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .unused)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn thunkOrdinal(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .thunkOrdinal)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn thisAdjust(&self) -> ::windows_core::Result<i32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .thisAdjust)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn virtualBaseOffset(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .virtualBaseOffset)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn r#virtual(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .r#virtual)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn intro(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .intro)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn pure(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .pure)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn callingConvention(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .callingConvention)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn value(&self) -> ::windows_core::Result<::windows_core::VARIANT> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .value)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn baseType(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .baseType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn token(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .token)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn timeStamp(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .timeStamp)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn guid(&self) -> ::windows_core::Result<::windows_core::GUID> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .guid)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn symbolsFileName(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .symbolsFileName)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn reference(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .reference)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn count(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .count)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn bitPosition(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .bitPosition)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn arrayIndexType(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .arrayIndexType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn packed(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .packed)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn constructor(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .constructor)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn overloadedOperator(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .overloadedOperator)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn nested(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .nested)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasNestedTypes(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasNestedTypes)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasAssignmentOperator(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasAssignmentOperator)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn hasCastOperator(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasCastOperator)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn scoped(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .scoped)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn virtualBaseClass(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .virtualBaseClass)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn indirectVirtualBaseClass(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .indirectVirtualBaseClass)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn virtualBasePointerOffset(&self) -> ::windows_core::Result<i32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .virtualBasePointerOffset)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn virtualTableShape(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .virtualTableShape)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn lexicalParentId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .lexicalParentId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn classParentId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .classParentId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn typeId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .typeId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn arrayIndexTypeId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .arrayIndexTypeId)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn virtualTableShapeId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .virtualTableShapeId)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn code(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .code)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn function(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .function)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn managed(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .managed)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn msil(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .msil)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn virtualBaseDispIndex(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .virtualBaseDispIndex)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn undecoratedName(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .undecoratedName)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn age(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .age)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn signature(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .signature)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn compilerGenerated(
+        pub unsafe fn get_sourceLink(
             &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .compilerGenerated)(
-                ::windows_core::Interface::as_raw(self), &mut result__
+            pcb: *mut u32,
+            pb: Option<&mut [u8]>,
+        ) -> windows_core::Result<()> {
+            (windows_core::Interface::vtable(self).get_sourceLink)(
+                windows_core::Interface::as_raw(self),
+                pb.as_deref()
+                    .map_or(0, |slice| slice.len().try_into().unwrap()),
+                pcb,
+                core::mem::transmute(
+                    pb.as_deref()
+                        .map_or(core::ptr::null(), |slice| slice.as_ptr()),
+                ),
             )
-            .map(|| result__)
+            .ok()
         }
-        pub unsafe fn addressTaken(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .addressTaken)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn rank(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .rank)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn lowerBound(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .lowerBound)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn upperBound(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .upperBound)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn lowerBoundId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .lowerBoundId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn upperBoundId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .upperBoundId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
+    }
+    #[repr(C)]
+    pub struct IDiaSymbol10_Vtbl {
+        pub base__: IDiaSymbol9_Vtbl,
+        pub get_sourceLink: unsafe extern "system" fn(
+            *mut core::ffi::c_void,
+            u32,
+            *mut u32,
+            *mut u8,
+        ) -> windows_core::HRESULT,
+    }
+    windows_core::imp::define_interface!(
+        IDiaSymbol11,
+        IDiaSymbol11_Vtbl,
+        0xb6f54fcd_05e3_433d_b305_b0c1437d2d16
+    );
+    impl core::ops::Deref for IDiaSymbol11 {
+        type Target = IDiaSymbol10;
+        fn deref(&self) -> &Self::Target {
+            unsafe { core::mem::transmute(self) }
         }
-        pub unsafe fn get_dataBytes(
+    }
+    windows_core::imp::interface_hierarchy!(
+        IDiaSymbol11,
+        windows_core::IUnknown,
+        IDiaSymbol,
+        IDiaSymbol2,
+        IDiaSymbol3,
+        IDiaSymbol4,
+        IDiaSymbol5,
+        IDiaSymbol6,
+        IDiaSymbol7,
+        IDiaSymbol8,
+        IDiaSymbol9,
+        IDiaSymbol10
+    );
+    impl IDiaSymbol11 {
+        pub unsafe fn get_discriminatedUnionTag(
             &self,
-            pcbdata: *mut u32,
-            pbdata: &mut [u8],
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .get_dataBytes)(
-                ::windows_core::Interface::as_raw(self),
-                pbdata.len().try_into().unwrap(),
-                pcbdata,
-                ::core::mem::transmute(pbdata.as_ptr()),
-            )
-            .ok()
-        }
-        pub unsafe fn findChildren<P0>(
-            &self,
-            symtag: SymTag,
-            name: P0,
-            compareflags: u32,
-        ) -> ::windows_core::Result<IDiaEnumSymbols>
-        where
-            P0: ::windows_core::IntoParam<::windows_core::PCWSTR>,
-        {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .findChildren)(
-                ::windows_core::Interface::as_raw(self),
-                symtag,
-                name.into_param().abi(),
-                compareflags,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findChildrenEx<P0>(
-            &self,
-            symtag: SymTag,
-            name: P0,
-            compareflags: u32,
-        ) -> ::windows_core::Result<IDiaEnumSymbols>
-        where
-            P0: ::windows_core::IntoParam<::windows_core::PCWSTR>,
-        {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .findChildrenEx)(
-                ::windows_core::Interface::as_raw(self),
-                symtag,
-                name.into_param().abi(),
-                compareflags,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findChildrenExByAddr<P0>(
-            &self,
-            symtag: SymTag,
-            name: P0,
-            compareflags: u32,
-            isect: u32,
-            offset: u32,
-        ) -> ::windows_core::Result<IDiaEnumSymbols>
-        where
-            P0: ::windows_core::IntoParam<::windows_core::PCWSTR>,
-        {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .findChildrenExByAddr)(
-                ::windows_core::Interface::as_raw(self),
-                symtag,
-                name.into_param().abi(),
-                compareflags,
-                isect,
-                offset,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findChildrenExByVA<P0>(
-            &self,
-            symtag: SymTag,
-            name: P0,
-            compareflags: u32,
-            va: u64,
-        ) -> ::windows_core::Result<IDiaEnumSymbols>
-        where
-            P0: ::windows_core::IntoParam<::windows_core::PCWSTR>,
-        {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .findChildrenExByVA)(
-                ::windows_core::Interface::as_raw(self),
-                symtag,
-                name.into_param().abi(),
-                compareflags,
-                va,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findChildrenExByRVA<P0>(
-            &self,
-            symtag: SymTag,
-            name: P0,
-            compareflags: u32,
-            rva: u32,
-        ) -> ::windows_core::Result<IDiaEnumSymbols>
-        where
-            P0: ::windows_core::IntoParam<::windows_core::PCWSTR>,
-        {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .findChildrenExByRVA)(
-                ::windows_core::Interface::as_raw(self),
-                symtag,
-                name.into_param().abi(),
-                compareflags,
-                rva,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn targetSection(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .targetSection)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn targetOffset(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .targetOffset)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn targetRelativeVirtualAddress(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .targetRelativeVirtualAddress)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn targetVirtualAddress(&self) -> ::windows_core::Result<u64> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .targetVirtualAddress)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn machineType(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .machineType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn oemId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .oemId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn oemSymbolId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .oemSymbolId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn get_types(
-            &self,
-            pctypes: *mut u32,
-            ptypes: &mut [::core::option::Option<IDiaSymbol>],
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .get_types)(
-                ::windows_core::Interface::as_raw(self),
-                ptypes.len().try_into().unwrap(),
-                pctypes,
-                ::core::mem::transmute(ptypes.as_ptr()),
-            )
-            .ok()
-        }
-        pub unsafe fn get_typeIds(
-            &self,
-            pctypeids: *mut u32,
-            pdwtypeids: &mut [u32],
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .get_typeIds)(
-                ::windows_core::Interface::as_raw(self),
-                pdwtypeids.len().try_into().unwrap(),
-                pctypeids,
-                ::core::mem::transmute(pdwtypeids.as_ptr()),
-            )
-            .ok()
-        }
-        pub unsafe fn objectPointerType(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .objectPointerType)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn udtKind(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .udtKind)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn get_undecoratedNameEx(
-            &self,
-            undecorateoptions: u32,
-        ) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .get_undecoratedNameEx)(
-                ::windows_core::Interface::as_raw(self),
-                undecorateoptions,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn noReturn(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .noReturn)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn customCallingConvention(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .customCallingConvention)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn noInline(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .noInline)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn optimizedCodeDebugInfo(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .optimizedCodeDebugInfo)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn notReached(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .notReached)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn interruptReturn(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .interruptReturn)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn farReturn(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .farReturn)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isStatic(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isStatic)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasDebugInfo(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasDebugInfo)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isLTCG(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isLTCG)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isDataAligned(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isDataAligned)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasSecurityChecks(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasSecurityChecks)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn compilerName(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .compilerName)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn hasAlloca(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasAlloca)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasSetJump(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasSetJump)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasLongJump(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasLongJump)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasInlAsm(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasInlAsm)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasEH(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasEH)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasSEH(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasSEH)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasEHa(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasEHa)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isNaked(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isNaked)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isAggregated(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isAggregated)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isSplitted(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isSplitted)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn container(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .container)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn inlSpec(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .inlSpec)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn noStackOrdering(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .noStackOrdering)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn virtualBaseTableType(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .virtualBaseTableType)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn hasManagedCode(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasManagedCode)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isHotpatchable(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isHotpatchable)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isCVTCIL(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isCVTCIL)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isMSILNetmodule(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isMSILNetmodule)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isCTypes(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isCTypes)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isStripped(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isStripped)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn frontEndQFE(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .frontEndQFE)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn backEndQFE(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .backEndQFE)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn wasInlined(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .wasInlined)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn strictGSCheck(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .strictGSCheck)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isCxxReturnUdt(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isCxxReturnUdt)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isConstructorVirtualBase(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isConstructorVirtualBase)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn RValueReference(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .RValueReference)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn unmodifiedType(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .unmodifiedType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn framePointerPresent(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .framePointerPresent)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isSafeBuffers(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isSafeBuffers)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn intrinsic(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .intrinsic)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn sealed(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .sealed)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hfaFloat(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hfaFloat)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hfaDouble(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hfaDouble)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn liveRangeStartAddressSection(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .liveRangeStartAddressSection)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn liveRangeStartAddressOffset(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .liveRangeStartAddressOffset)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn liveRangeStartRelativeVirtualAddress(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .liveRangeStartRelativeVirtualAddress)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn countLiveRanges(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .countLiveRanges)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn liveRangeLength(&self) -> ::windows_core::Result<u64> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .liveRangeLength)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn offsetInUdt(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .offsetInUdt)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn paramBasePointerRegisterId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .paramBasePointerRegisterId)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn localBasePointerRegisterId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .localBasePointerRegisterId)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isLocationControlFlowDependent(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isLocationControlFlowDependent)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn stride(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .stride)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn numberOfRows(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .numberOfRows)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn numberOfColumns(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .numberOfColumns)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isMatrixRowMajor(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isMatrixRowMajor)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn get_numericProperties(
-            &self,
-            pcnt: *mut u32,
-            pproperties: &mut [u32],
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .get_numericProperties)(
-                ::windows_core::Interface::as_raw(self),
-                pproperties.len().try_into().unwrap(),
-                pcnt,
-                ::core::mem::transmute(pproperties.as_ptr()),
-            )
-            .ok()
-        }
-        pub unsafe fn get_modifierValues(
-            &self,
-            pcnt: *mut u32,
-            pmodifiers: &mut [u16],
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .get_modifierValues)(
-                ::windows_core::Interface::as_raw(self),
-                pmodifiers.len().try_into().unwrap(),
-                pcnt,
-                ::core::mem::transmute(pmodifiers.as_ptr()),
-            )
-            .ok()
-        }
-        pub unsafe fn isReturnValue(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isReturnValue)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isOptimizedAway(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isOptimizedAway)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn builtInKind(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .builtInKind)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn registerType(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .registerType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn baseDataSlot(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .baseDataSlot)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn baseDataOffset(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .baseDataOffset)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn textureSlot(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .textureSlot)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn samplerSlot(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .samplerSlot)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn uavSlot(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .uavSlot)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn sizeInUdt(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .sizeInUdt)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn memorySpaceKind(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .memorySpaceKind)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn unmodifiedTypeId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .unmodifiedTypeId)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn subTypeId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .subTypeId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn subType(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .subType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn numberOfModifiers(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .numberOfModifiers)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn numberOfRegisterIndices(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .numberOfRegisterIndices)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isHLSLData(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isHLSLData)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isPointerToDataMember(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isPointerToDataMember)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isPointerToMemberFunction(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isPointerToMemberFunction)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isSingleInheritance(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isSingleInheritance)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isMultipleInheritance(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isMultipleInheritance)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isVirtualInheritance(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isVirtualInheritance)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn restrictedType(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .restrictedType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isPointerBasedOnSymbolValue(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isPointerBasedOnSymbolValue)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn baseSymbol(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .baseSymbol)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn baseSymbolId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .baseSymbolId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn objectFileName(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .objectFileName)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn isAcceleratorGroupSharedLocal(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isAcceleratorGroupSharedLocal)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isAcceleratorPointerTagLiveRange(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isAcceleratorPointerTagLiveRange)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isAcceleratorStubFunction(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isAcceleratorStubFunction)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn numberOfAcceleratorPointerTags(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .numberOfAcceleratorPointerTags)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isSdl(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isSdl)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isWinRTPointer(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isWinRTPointer)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isRefUdt(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isRefUdt)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isValueUdt(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isValueUdt)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isInterfaceUdt(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isInterfaceUdt)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn findInlineFramesByAddr(
-            &self,
-            isect: u32,
-            offset: u32,
-        ) -> ::windows_core::Result<IDiaEnumSymbols> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .findInlineFramesByAddr)(
-                ::windows_core::Interface::as_raw(self),
-                isect,
-                offset,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findInlineFramesByRVA(
-            &self,
-            rva: u32,
-        ) -> ::windows_core::Result<IDiaEnumSymbols> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .findInlineFramesByRVA)(
-                ::windows_core::Interface::as_raw(self), rva, &mut result__
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findInlineFramesByVA(
-            &self,
-            va: u64,
-        ) -> ::windows_core::Result<IDiaEnumSymbols> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .findInlineFramesByVA)(
-                ::windows_core::Interface::as_raw(self), va, &mut result__
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findInlineeLines(&self) -> ::windows_core::Result<IDiaEnumLineNumbers> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .findInlineeLines)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findInlineeLinesByAddr(
-            &self,
-            isect: u32,
-            offset: u32,
-            length: u32,
-        ) -> ::windows_core::Result<IDiaEnumLineNumbers> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .findInlineeLinesByAddr)(
-                ::windows_core::Interface::as_raw(self),
-                isect,
-                offset,
-                length,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findInlineeLinesByRVA(
-            &self,
-            rva: u32,
-            length: u32,
-        ) -> ::windows_core::Result<IDiaEnumLineNumbers> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .findInlineeLinesByRVA)(
-                ::windows_core::Interface::as_raw(self),
-                rva,
-                length,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findInlineeLinesByVA(
-            &self,
-            va: u64,
-            length: u32,
-        ) -> ::windows_core::Result<IDiaEnumLineNumbers> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .findInlineeLinesByVA)(
-                ::windows_core::Interface::as_raw(self),
-                va,
-                length,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findSymbolsForAcceleratorPointerTag(
-            &self,
-            tagvalue: u32,
-        ) -> ::windows_core::Result<IDiaEnumSymbols> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .findSymbolsForAcceleratorPointerTag)(
-                ::windows_core::Interface::as_raw(self),
-                tagvalue,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findSymbolsByRVAForAcceleratorPointerTag(
-            &self,
-            tagvalue: u32,
-            rva: u32,
-        ) -> ::windows_core::Result<IDiaEnumSymbols> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .findSymbolsByRVAForAcceleratorPointerTag)(
-                ::windows_core::Interface::as_raw(self),
-                tagvalue,
-                rva,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn get_acceleratorPointerTags(
-            &self,
-            pcnt: *mut u32,
-            ppointertags: &mut [u32],
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .get_acceleratorPointerTags)(
-                ::windows_core::Interface::as_raw(self),
-                ppointertags.len().try_into().unwrap(),
-                pcnt,
-                ::core::mem::transmute(ppointertags.as_ptr()),
-            )
-            .ok()
-        }
-        pub unsafe fn getSrcLineOnTypeDefn(&self) -> ::windows_core::Result<IDiaLineNumber> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .getSrcLineOnTypeDefn)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn isPGO(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isPGO)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasValidPGOCounts(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasValidPGOCounts)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isOptimizedForSpeed(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isOptimizedForSpeed)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn PGOEntryCount(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .PGOEntryCount)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn PGOEdgeCount(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .PGOEdgeCount)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn PGODynamicInstructionCount(&self) -> ::windows_core::Result<u64> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .PGODynamicInstructionCount)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn staticSize(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .staticSize)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn finalLiveStaticSize(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .finalLiveStaticSize)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn phaseName(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .phaseName)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn hasControlFlowCheck(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasControlFlowCheck)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn constantExport(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .constantExport)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn dataExport(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .dataExport)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn privateExport(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .privateExport)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn noNameExport(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .noNameExport)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn exportHasExplicitlyAssignedOrdinal(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .exportHasExplicitlyAssignedOrdinal)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn exportIsForwarder(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .exportIsForwarder)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn ordinal(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .ordinal)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn frameSize(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .frameSize)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn exceptionHandlerAddressSection(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .exceptionHandlerAddressSection)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn exceptionHandlerAddressOffset(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .exceptionHandlerAddressOffset)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn exceptionHandlerRelativeVirtualAddress(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .exceptionHandlerRelativeVirtualAddress)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn exceptionHandlerVirtualAddress(&self) -> ::windows_core::Result<u64> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .exceptionHandlerVirtualAddress)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn findInputAssemblyFile(
-            &self,
-        ) -> ::windows_core::Result<IDiaInputAssemblyFile> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .findInputAssemblyFile)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn characteristics(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .characteristics)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn coffGroup(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .coffGroup)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn bindID(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .bindID)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn bindSpace(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .bindSpace)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn bindSlot(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .bindSlot)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isObjCClass(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isObjCClass)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isObjCCategory(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isObjCCategory)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isObjCProtocol(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isObjCProtocol)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn inlinee(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .inlinee)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn inlineeId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .inlineeId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn noexcept(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .noexcept)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasAbsoluteAddress(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasAbsoluteAddress)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isStaticMemberFunc(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .isStaticMemberFunc)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isSignRet(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .isSignRet)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn coroutineKind(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .coroutineKind)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn associatedSymbolKind(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .associatedSymbolKind)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn associatedSymbolSection(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .associatedSymbolSection)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn associatedSymbolOffset(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .associatedSymbolOffset)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn associatedSymbolRva(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .associatedSymbolRva)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn associatedSymbolAddr(&self) -> ::windows_core::Result<u64> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .associatedSymbolAddr)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn framePadSize(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.framePadSize)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn framePadOffset(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .framePadOffset)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isRTCs(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.isRTCs)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn get_sourceLink(
-            &self,
-            pcb: *mut u32,
-            pb: ::core::option::Option<&mut [u8]>,
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self).get_sourceLink)(
-                ::windows_core::Interface::as_raw(self),
-                pb.as_deref()
-                    .map_or(0, |slice| slice.len().try_into().unwrap()),
-                pcb,
-                ::core::mem::transmute(
-                    pb.as_deref()
-                        .map_or(::core::ptr::null(), |slice| slice.as_ptr()),
-                ),
-            )
-            .ok()
-        }
-    }
-    #[repr(C)]
-    pub struct IDiaSymbol10_Vtbl {
-        pub base__: IDiaSymbol9_Vtbl,
-        pub get_sourceLink: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            u32,
-            *mut u32,
-            *mut u8,
-        ) -> ::windows_core::HRESULT,
-    }
-    ::windows_core::imp::com_interface!(
-        IDiaSymbol11,
-        IDiaSymbol11_Vtbl,
-        0xb6f54fcd_05e3_433d_b305_b0c1437d2d16
-    );
-    ::windows_core::imp::interface_hierarchy!(
-        IDiaSymbol11,
-        ::windows_core::IUnknown,
-        IDiaSymbol,
-        IDiaSymbol2,
-        IDiaSymbol3,
-        IDiaSymbol4,
-        IDiaSymbol5,
-        IDiaSymbol6,
-        IDiaSymbol7,
-        IDiaSymbol8,
-        IDiaSymbol9,
-        IDiaSymbol10
-    );
-    impl IDiaSymbol11 {
-        pub unsafe fn symIndexId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .symIndexId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn symTag(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .symTag)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn name(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .name)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn lexicalParent(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .lexicalParent)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn classParent(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .classParent)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn r#type(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .r#type)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn dataKind(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .dataKind)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn locationType(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .locationType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn addressSection(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .addressSection)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn addressOffset(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .addressOffset)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn relativeVirtualAddress(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .relativeVirtualAddress)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn virtualAddress(&self) -> ::windows_core::Result<u64> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .virtualAddress)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn registerId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .registerId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn offset(&self) -> ::windows_core::Result<i32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .offset)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn length(&self) -> ::windows_core::Result<u64> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .length)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn slot(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .slot)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn volatileType(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .volatileType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn constType(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .constType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn unalignedType(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .unalignedType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn access(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .access)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn libraryName(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .libraryName)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn platform(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .platform)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn language(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .language)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn editAndContinueEnabled(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .editAndContinueEnabled)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn frontEndMajor(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .frontEndMajor)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn frontEndMinor(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .frontEndMinor)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn frontEndBuild(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .frontEndBuild)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn backEndMajor(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .backEndMajor)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn backEndMinor(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .backEndMinor)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn backEndBuild(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .backEndBuild)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn sourceFileName(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .sourceFileName)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn unused(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .unused)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn thunkOrdinal(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .thunkOrdinal)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn thisAdjust(&self) -> ::windows_core::Result<i32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .thisAdjust)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn virtualBaseOffset(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .virtualBaseOffset)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn r#virtual(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .r#virtual)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn intro(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .intro)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn pure(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .pure)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn callingConvention(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .callingConvention)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn value(&self) -> ::windows_core::Result<::windows_core::VARIANT> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .value)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn baseType(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .baseType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn token(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .token)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn timeStamp(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .timeStamp)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn guid(&self) -> ::windows_core::Result<::windows_core::GUID> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .guid)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn symbolsFileName(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .symbolsFileName)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn reference(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .reference)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn count(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .count)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn bitPosition(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .bitPosition)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn arrayIndexType(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .arrayIndexType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn packed(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .packed)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn constructor(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .constructor)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn overloadedOperator(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .overloadedOperator)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn nested(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .nested)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasNestedTypes(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasNestedTypes)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasAssignmentOperator(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasAssignmentOperator)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn hasCastOperator(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasCastOperator)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn scoped(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .scoped)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn virtualBaseClass(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .virtualBaseClass)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn indirectVirtualBaseClass(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .indirectVirtualBaseClass)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn virtualBasePointerOffset(&self) -> ::windows_core::Result<i32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .virtualBasePointerOffset)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn virtualTableShape(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .virtualTableShape)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn lexicalParentId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .lexicalParentId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn classParentId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .classParentId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn typeId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .typeId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn arrayIndexTypeId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .arrayIndexTypeId)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn virtualTableShapeId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .virtualTableShapeId)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn code(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .code)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn function(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .function)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn managed(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .managed)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn msil(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .msil)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn virtualBaseDispIndex(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .virtualBaseDispIndex)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn undecoratedName(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .undecoratedName)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn age(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .age)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn signature(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .signature)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn compilerGenerated(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .compilerGenerated)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn addressTaken(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .addressTaken)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn rank(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .rank)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn lowerBound(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .lowerBound)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn upperBound(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .upperBound)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn lowerBoundId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .lowerBoundId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn upperBoundId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .upperBoundId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn get_dataBytes(
-            &self,
-            pcbdata: *mut u32,
-            pbdata: &mut [u8],
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .get_dataBytes)(
-                ::windows_core::Interface::as_raw(self),
-                pbdata.len().try_into().unwrap(),
-                pcbdata,
-                ::core::mem::transmute(pbdata.as_ptr()),
-            )
-            .ok()
-        }
-        pub unsafe fn findChildren<P0>(
-            &self,
-            symtag: SymTag,
-            name: P0,
-            compareflags: u32,
-        ) -> ::windows_core::Result<IDiaEnumSymbols>
-        where
-            P0: ::windows_core::IntoParam<::windows_core::PCWSTR>,
-        {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .findChildren)(
-                ::windows_core::Interface::as_raw(self),
-                symtag,
-                name.into_param().abi(),
-                compareflags,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findChildrenEx<P0>(
-            &self,
-            symtag: SymTag,
-            name: P0,
-            compareflags: u32,
-        ) -> ::windows_core::Result<IDiaEnumSymbols>
-        where
-            P0: ::windows_core::IntoParam<::windows_core::PCWSTR>,
-        {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .findChildrenEx)(
-                ::windows_core::Interface::as_raw(self),
-                symtag,
-                name.into_param().abi(),
-                compareflags,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findChildrenExByAddr<P0>(
-            &self,
-            symtag: SymTag,
-            name: P0,
-            compareflags: u32,
-            isect: u32,
-            offset: u32,
-        ) -> ::windows_core::Result<IDiaEnumSymbols>
-        where
-            P0: ::windows_core::IntoParam<::windows_core::PCWSTR>,
-        {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .findChildrenExByAddr)(
-                ::windows_core::Interface::as_raw(self),
-                symtag,
-                name.into_param().abi(),
-                compareflags,
-                isect,
-                offset,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findChildrenExByVA<P0>(
-            &self,
-            symtag: SymTag,
-            name: P0,
-            compareflags: u32,
-            va: u64,
-        ) -> ::windows_core::Result<IDiaEnumSymbols>
-        where
-            P0: ::windows_core::IntoParam<::windows_core::PCWSTR>,
-        {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .findChildrenExByVA)(
-                ::windows_core::Interface::as_raw(self),
-                symtag,
-                name.into_param().abi(),
-                compareflags,
-                va,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findChildrenExByRVA<P0>(
-            &self,
-            symtag: SymTag,
-            name: P0,
-            compareflags: u32,
-            rva: u32,
-        ) -> ::windows_core::Result<IDiaEnumSymbols>
-        where
-            P0: ::windows_core::IntoParam<::windows_core::PCWSTR>,
-        {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .findChildrenExByRVA)(
-                ::windows_core::Interface::as_raw(self),
-                symtag,
-                name.into_param().abi(),
-                compareflags,
-                rva,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn targetSection(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .targetSection)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn targetOffset(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .targetOffset)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn targetRelativeVirtualAddress(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .targetRelativeVirtualAddress)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn targetVirtualAddress(&self) -> ::windows_core::Result<u64> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .targetVirtualAddress)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn machineType(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .machineType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn oemId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .oemId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn oemSymbolId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .oemSymbolId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn get_types(
-            &self,
-            pctypes: *mut u32,
-            ptypes: &mut [::core::option::Option<IDiaSymbol>],
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .get_types)(
-                ::windows_core::Interface::as_raw(self),
-                ptypes.len().try_into().unwrap(),
-                pctypes,
-                ::core::mem::transmute(ptypes.as_ptr()),
-            )
-            .ok()
-        }
-        pub unsafe fn get_typeIds(
-            &self,
-            pctypeids: *mut u32,
-            pdwtypeids: &mut [u32],
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .get_typeIds)(
-                ::windows_core::Interface::as_raw(self),
-                pdwtypeids.len().try_into().unwrap(),
-                pctypeids,
-                ::core::mem::transmute(pdwtypeids.as_ptr()),
-            )
-            .ok()
-        }
-        pub unsafe fn objectPointerType(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .objectPointerType)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn udtKind(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .udtKind)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn get_undecoratedNameEx(
-            &self,
-            undecorateoptions: u32,
-        ) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .get_undecoratedNameEx)(
-                ::windows_core::Interface::as_raw(self),
-                undecorateoptions,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn noReturn(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .noReturn)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn customCallingConvention(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .customCallingConvention)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn noInline(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .noInline)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn optimizedCodeDebugInfo(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .optimizedCodeDebugInfo)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn notReached(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .notReached)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn interruptReturn(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .interruptReturn)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn farReturn(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .farReturn)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isStatic(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isStatic)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasDebugInfo(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasDebugInfo)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isLTCG(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isLTCG)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isDataAligned(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isDataAligned)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasSecurityChecks(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasSecurityChecks)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn compilerName(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .compilerName)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn hasAlloca(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasAlloca)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasSetJump(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasSetJump)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasLongJump(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasLongJump)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasInlAsm(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasInlAsm)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasEH(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasEH)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasSEH(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasSEH)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasEHa(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasEHa)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isNaked(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isNaked)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isAggregated(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isAggregated)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isSplitted(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isSplitted)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn container(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .container)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn inlSpec(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .inlSpec)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn noStackOrdering(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .noStackOrdering)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn virtualBaseTableType(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .virtualBaseTableType)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn hasManagedCode(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasManagedCode)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isHotpatchable(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isHotpatchable)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isCVTCIL(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isCVTCIL)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isMSILNetmodule(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isMSILNetmodule)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isCTypes(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isCTypes)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isStripped(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isStripped)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn frontEndQFE(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .frontEndQFE)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn backEndQFE(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .backEndQFE)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn wasInlined(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .wasInlined)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn strictGSCheck(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .strictGSCheck)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isCxxReturnUdt(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isCxxReturnUdt)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isConstructorVirtualBase(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isConstructorVirtualBase)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn RValueReference(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .RValueReference)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn unmodifiedType(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .unmodifiedType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn framePointerPresent(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .framePointerPresent)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isSafeBuffers(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isSafeBuffers)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn intrinsic(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .intrinsic)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn sealed(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .sealed)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hfaFloat(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hfaFloat)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hfaDouble(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hfaDouble)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn liveRangeStartAddressSection(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .liveRangeStartAddressSection)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn liveRangeStartAddressOffset(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .liveRangeStartAddressOffset)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn liveRangeStartRelativeVirtualAddress(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .liveRangeStartRelativeVirtualAddress)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn countLiveRanges(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .countLiveRanges)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn liveRangeLength(&self) -> ::windows_core::Result<u64> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .liveRangeLength)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn offsetInUdt(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .offsetInUdt)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn paramBasePointerRegisterId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .paramBasePointerRegisterId)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn localBasePointerRegisterId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .localBasePointerRegisterId)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isLocationControlFlowDependent(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isLocationControlFlowDependent)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn stride(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .stride)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn numberOfRows(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .numberOfRows)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn numberOfColumns(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .numberOfColumns)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isMatrixRowMajor(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isMatrixRowMajor)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn get_numericProperties(
-            &self,
-            pcnt: *mut u32,
-            pproperties: &mut [u32],
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .get_numericProperties)(
-                ::windows_core::Interface::as_raw(self),
-                pproperties.len().try_into().unwrap(),
-                pcnt,
-                ::core::mem::transmute(pproperties.as_ptr()),
-            )
-            .ok()
-        }
-        pub unsafe fn get_modifierValues(
-            &self,
-            pcnt: *mut u32,
-            pmodifiers: &mut [u16],
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .get_modifierValues)(
-                ::windows_core::Interface::as_raw(self),
-                pmodifiers.len().try_into().unwrap(),
-                pcnt,
-                ::core::mem::transmute(pmodifiers.as_ptr()),
-            )
-            .ok()
-        }
-        pub unsafe fn isReturnValue(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isReturnValue)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isOptimizedAway(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isOptimizedAway)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn builtInKind(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .builtInKind)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn registerType(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .registerType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn baseDataSlot(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .baseDataSlot)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn baseDataOffset(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .baseDataOffset)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn textureSlot(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .textureSlot)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn samplerSlot(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .samplerSlot)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn uavSlot(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .uavSlot)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn sizeInUdt(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .sizeInUdt)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn memorySpaceKind(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .memorySpaceKind)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn unmodifiedTypeId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .unmodifiedTypeId)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn subTypeId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .subTypeId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn subType(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .subType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn numberOfModifiers(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .numberOfModifiers)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn numberOfRegisterIndices(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .numberOfRegisterIndices)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isHLSLData(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isHLSLData)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isPointerToDataMember(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isPointerToDataMember)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isPointerToMemberFunction(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isPointerToMemberFunction)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isSingleInheritance(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isSingleInheritance)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isMultipleInheritance(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isMultipleInheritance)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isVirtualInheritance(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isVirtualInheritance)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn restrictedType(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .restrictedType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isPointerBasedOnSymbolValue(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isPointerBasedOnSymbolValue)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn baseSymbol(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .baseSymbol)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn baseSymbolId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .baseSymbolId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn objectFileName(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .objectFileName)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn isAcceleratorGroupSharedLocal(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isAcceleratorGroupSharedLocal)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isAcceleratorPointerTagLiveRange(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isAcceleratorPointerTagLiveRange)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isAcceleratorStubFunction(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isAcceleratorStubFunction)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn numberOfAcceleratorPointerTags(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .numberOfAcceleratorPointerTags)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isSdl(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isSdl)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isWinRTPointer(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isWinRTPointer)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isRefUdt(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isRefUdt)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isValueUdt(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isValueUdt)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isInterfaceUdt(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isInterfaceUdt)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn findInlineFramesByAddr(
-            &self,
-            isect: u32,
-            offset: u32,
-        ) -> ::windows_core::Result<IDiaEnumSymbols> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .findInlineFramesByAddr)(
-                ::windows_core::Interface::as_raw(self),
-                isect,
-                offset,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findInlineFramesByRVA(
-            &self,
-            rva: u32,
-        ) -> ::windows_core::Result<IDiaEnumSymbols> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .findInlineFramesByRVA)(
-                ::windows_core::Interface::as_raw(self), rva, &mut result__
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findInlineFramesByVA(
-            &self,
-            va: u64,
-        ) -> ::windows_core::Result<IDiaEnumSymbols> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .findInlineFramesByVA)(
-                ::windows_core::Interface::as_raw(self), va, &mut result__
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findInlineeLines(&self) -> ::windows_core::Result<IDiaEnumLineNumbers> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .findInlineeLines)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findInlineeLinesByAddr(
-            &self,
-            isect: u32,
-            offset: u32,
-            length: u32,
-        ) -> ::windows_core::Result<IDiaEnumLineNumbers> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .findInlineeLinesByAddr)(
-                ::windows_core::Interface::as_raw(self),
-                isect,
-                offset,
-                length,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findInlineeLinesByRVA(
-            &self,
-            rva: u32,
-            length: u32,
-        ) -> ::windows_core::Result<IDiaEnumLineNumbers> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .findInlineeLinesByRVA)(
-                ::windows_core::Interface::as_raw(self),
-                rva,
-                length,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findInlineeLinesByVA(
-            &self,
-            va: u64,
-            length: u32,
-        ) -> ::windows_core::Result<IDiaEnumLineNumbers> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .findInlineeLinesByVA)(
-                ::windows_core::Interface::as_raw(self),
-                va,
-                length,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findSymbolsForAcceleratorPointerTag(
-            &self,
-            tagvalue: u32,
-        ) -> ::windows_core::Result<IDiaEnumSymbols> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .findSymbolsForAcceleratorPointerTag)(
-                ::windows_core::Interface::as_raw(self),
-                tagvalue,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findSymbolsByRVAForAcceleratorPointerTag(
-            &self,
-            tagvalue: u32,
-            rva: u32,
-        ) -> ::windows_core::Result<IDiaEnumSymbols> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .findSymbolsByRVAForAcceleratorPointerTag)(
-                ::windows_core::Interface::as_raw(self),
-                tagvalue,
-                rva,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn get_acceleratorPointerTags(
-            &self,
-            pcnt: *mut u32,
-            ppointertags: &mut [u32],
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .get_acceleratorPointerTags)(
-                ::windows_core::Interface::as_raw(self),
-                ppointertags.len().try_into().unwrap(),
-                pcnt,
-                ::core::mem::transmute(ppointertags.as_ptr()),
-            )
-            .ok()
-        }
-        pub unsafe fn getSrcLineOnTypeDefn(&self) -> ::windows_core::Result<IDiaLineNumber> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .getSrcLineOnTypeDefn)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn isPGO(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isPGO)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasValidPGOCounts(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasValidPGOCounts)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isOptimizedForSpeed(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isOptimizedForSpeed)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn PGOEntryCount(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .PGOEntryCount)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn PGOEdgeCount(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .PGOEdgeCount)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn PGODynamicInstructionCount(&self) -> ::windows_core::Result<u64> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .PGODynamicInstructionCount)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn staticSize(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .staticSize)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn finalLiveStaticSize(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .finalLiveStaticSize)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn phaseName(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .phaseName)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn hasControlFlowCheck(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasControlFlowCheck)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn constantExport(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .constantExport)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn dataExport(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .dataExport)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn privateExport(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .privateExport)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn noNameExport(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .noNameExport)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn exportHasExplicitlyAssignedOrdinal(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .exportHasExplicitlyAssignedOrdinal)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn exportIsForwarder(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .exportIsForwarder)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn ordinal(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .ordinal)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn frameSize(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .frameSize)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn exceptionHandlerAddressSection(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .exceptionHandlerAddressSection)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn exceptionHandlerAddressOffset(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .exceptionHandlerAddressOffset)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn exceptionHandlerRelativeVirtualAddress(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .exceptionHandlerRelativeVirtualAddress)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn exceptionHandlerVirtualAddress(&self) -> ::windows_core::Result<u64> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .exceptionHandlerVirtualAddress)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn findInputAssemblyFile(
-            &self,
-        ) -> ::windows_core::Result<IDiaInputAssemblyFile> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .findInputAssemblyFile)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn characteristics(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .characteristics)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn coffGroup(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .coffGroup)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn bindID(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .bindID)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn bindSpace(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .bindSpace)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn bindSlot(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .bindSlot)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isObjCClass(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isObjCClass)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isObjCCategory(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isObjCCategory)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isObjCProtocol(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isObjCProtocol)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn inlinee(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .inlinee)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn inlineeId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .inlineeId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn noexcept(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .noexcept)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasAbsoluteAddress(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasAbsoluteAddress)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isStaticMemberFunc(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isStaticMemberFunc)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isSignRet(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .isSignRet)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn coroutineKind(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .coroutineKind)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn associatedSymbolKind(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .associatedSymbolKind)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn associatedSymbolSection(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .associatedSymbolSection)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn associatedSymbolOffset(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .associatedSymbolOffset)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn associatedSymbolRva(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .associatedSymbolRva)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn associatedSymbolAddr(&self) -> ::windows_core::Result<u64> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .associatedSymbolAddr)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn framePadSize(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .framePadSize)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn framePadOffset(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .framePadOffset)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isRTCs(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.base__.isRTCs)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn get_sourceLink(
-            &self,
-            pcb: *mut u32,
-            pb: ::core::option::Option<&mut [u8]>,
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .get_sourceLink)(
-                ::windows_core::Interface::as_raw(self),
-                pb.as_deref()
-                    .map_or(0, |slice| slice.len().try_into().unwrap()),
-                pcb,
-                ::core::mem::transmute(
-                    pb.as_deref()
-                        .map_or(::core::ptr::null(), |slice| slice.as_ptr()),
-                ),
-            )
-            .ok()
-        }
-        pub unsafe fn get_discriminatedUnionTag(
-            &self,
-            pptagtype: *mut ::core::option::Option<IDiaSymbol>,
-            ptagoffset: *mut u32,
-            ptagmask: *mut DiaTagValue,
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self).get_discriminatedUnionTag)(
-                ::windows_core::Interface::as_raw(self),
-                ::core::mem::transmute(pptagtype),
-                ptagoffset,
-                ptagmask,
-            )
-            .ok()
-        }
-        pub unsafe fn get_tagRanges(
-            &self,
-            pcrangevalues: *mut u32,
-            rangevalues: &mut [DiaTagValue],
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self).get_tagRanges)(
-                ::windows_core::Interface::as_raw(self),
-                rangevalues.len().try_into().unwrap(),
-                pcrangevalues,
-                ::core::mem::transmute(rangevalues.as_ptr()),
-            )
-            .ok()
-        }
-    }
-    #[repr(C)]
-    pub struct IDiaSymbol11_Vtbl {
-        pub base__: IDiaSymbol10_Vtbl,
-        pub get_discriminatedUnionTag: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut *mut ::core::ffi::c_void,
-            *mut u32,
-            *mut DiaTagValue,
-        )
-            -> ::windows_core::HRESULT,
-        pub get_tagRanges: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            u32,
-            *mut u32,
-            *mut DiaTagValue,
-        ) -> ::windows_core::HRESULT,
-    }
-    ::windows_core::imp::com_interface!(
-        IDiaSymbol2,
-        IDiaSymbol2_Vtbl,
-        0x611e86cd_b7d1_4546_8a15_070e2b07a427
-    );
-    ::windows_core::imp::interface_hierarchy!(IDiaSymbol2, ::windows_core::IUnknown, IDiaSymbol);
-    impl IDiaSymbol2 {
-        pub unsafe fn symIndexId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.symIndexId)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn symTag(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.symTag)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn name(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.name)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn lexicalParent(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.lexicalParent)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn classParent(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.classParent)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn r#type(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.r#type)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn dataKind(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.dataKind)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn locationType(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.locationType)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn addressSection(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .addressSection)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn addressOffset(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.addressOffset)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn relativeVirtualAddress(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .relativeVirtualAddress)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn virtualAddress(&self) -> ::windows_core::Result<u64> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .virtualAddress)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn registerId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.registerId)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn offset(&self) -> ::windows_core::Result<i32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.offset)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn length(&self) -> ::windows_core::Result<u64> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.length)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn slot(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.slot)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn volatileType(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.volatileType)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn constType(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.constType)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn unalignedType(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.unalignedType)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn access(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.access)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn libraryName(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.libraryName)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn platform(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.platform)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn language(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.language)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn editAndContinueEnabled(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .editAndContinueEnabled)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn frontEndMajor(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.frontEndMajor)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn frontEndMinor(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.frontEndMinor)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn frontEndBuild(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.frontEndBuild)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn backEndMajor(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.backEndMajor)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn backEndMinor(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.backEndMinor)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn backEndBuild(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.backEndBuild)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn sourceFileName(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .sourceFileName)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn unused(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.unused)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn thunkOrdinal(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.thunkOrdinal)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn thisAdjust(&self) -> ::windows_core::Result<i32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.thisAdjust)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn virtualBaseOffset(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .virtualBaseOffset)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn r#virtual(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.r#virtual)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn intro(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.intro)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn pure(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.pure)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn callingConvention(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .callingConvention)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn value(&self) -> ::windows_core::Result<::windows_core::VARIANT> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.value)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn baseType(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.baseType)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn token(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.token)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn timeStamp(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.timeStamp)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn guid(&self) -> ::windows_core::Result<::windows_core::GUID> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.guid)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn symbolsFileName(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .symbolsFileName)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn reference(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.reference)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn count(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.count)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn bitPosition(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.bitPosition)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn arrayIndexType(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .arrayIndexType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn packed(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.packed)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn constructor(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.constructor)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn overloadedOperator(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .overloadedOperator)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn nested(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.nested)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn hasNestedTypes(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .hasNestedTypes)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasAssignmentOperator(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .hasAssignmentOperator)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn hasCastOperator(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .hasCastOperator)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn scoped(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.scoped)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn virtualBaseClass(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .virtualBaseClass)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn indirectVirtualBaseClass(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .indirectVirtualBaseClass)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn virtualBasePointerOffset(&self) -> ::windows_core::Result<i32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .virtualBasePointerOffset)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn virtualTableShape(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .virtualTableShape)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn lexicalParentId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .lexicalParentId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn classParentId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.classParentId)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn typeId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.typeId)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn arrayIndexTypeId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .arrayIndexTypeId)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn virtualTableShapeId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .virtualTableShapeId)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn code(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.code)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn function(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.function)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn managed(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.managed)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn msil(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.msil)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn virtualBaseDispIndex(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .virtualBaseDispIndex)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn undecoratedName(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .undecoratedName)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn age(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.age)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn signature(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.signature)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn compilerGenerated(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .compilerGenerated)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn addressTaken(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.addressTaken)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn rank(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.rank)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn lowerBound(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.lowerBound)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn upperBound(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.upperBound)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn lowerBoundId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.lowerBoundId)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn upperBoundId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.upperBoundId)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn get_dataBytes(
-            &self,
-            pcbdata: *mut u32,
-            pbdata: &mut [u8],
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self).base__.get_dataBytes)(
-                ::windows_core::Interface::as_raw(self),
-                pbdata.len().try_into().unwrap(),
-                pcbdata,
-                ::core::mem::transmute(pbdata.as_ptr()),
-            )
-            .ok()
-        }
-        pub unsafe fn findChildren<P0>(
-            &self,
-            symtag: SymTag,
-            name: P0,
-            compareflags: u32,
-        ) -> ::windows_core::Result<IDiaEnumSymbols>
-        where
-            P0: ::windows_core::IntoParam<::windows_core::PCWSTR>,
-        {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.findChildren)(
-                ::windows_core::Interface::as_raw(self),
-                symtag,
-                name.into_param().abi(),
-                compareflags,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findChildrenEx<P0>(
-            &self,
-            symtag: SymTag,
-            name: P0,
-            compareflags: u32,
-        ) -> ::windows_core::Result<IDiaEnumSymbols>
-        where
-            P0: ::windows_core::IntoParam<::windows_core::PCWSTR>,
-        {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .findChildrenEx)(
-                ::windows_core::Interface::as_raw(self),
-                symtag,
-                name.into_param().abi(),
-                compareflags,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findChildrenExByAddr<P0>(
-            &self,
-            symtag: SymTag,
-            name: P0,
-            compareflags: u32,
-            isect: u32,
-            offset: u32,
-        ) -> ::windows_core::Result<IDiaEnumSymbols>
-        where
-            P0: ::windows_core::IntoParam<::windows_core::PCWSTR>,
-        {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .findChildrenExByAddr)(
-                ::windows_core::Interface::as_raw(self),
-                symtag,
-                name.into_param().abi(),
-                compareflags,
-                isect,
-                offset,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findChildrenExByVA<P0>(
-            &self,
-            symtag: SymTag,
-            name: P0,
-            compareflags: u32,
-            va: u64,
-        ) -> ::windows_core::Result<IDiaEnumSymbols>
-        where
-            P0: ::windows_core::IntoParam<::windows_core::PCWSTR>,
-        {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .findChildrenExByVA)(
-                ::windows_core::Interface::as_raw(self),
-                symtag,
-                name.into_param().abi(),
-                compareflags,
-                va,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findChildrenExByRVA<P0>(
-            &self,
-            symtag: SymTag,
-            name: P0,
-            compareflags: u32,
-            rva: u32,
-        ) -> ::windows_core::Result<IDiaEnumSymbols>
-        where
-            P0: ::windows_core::IntoParam<::windows_core::PCWSTR>,
-        {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .findChildrenExByRVA)(
-                ::windows_core::Interface::as_raw(self),
-                symtag,
-                name.into_param().abi(),
-                compareflags,
-                rva,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn targetSection(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.targetSection)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn targetOffset(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.targetOffset)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn targetRelativeVirtualAddress(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .targetRelativeVirtualAddress)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn targetVirtualAddress(&self) -> ::windows_core::Result<u64> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .targetVirtualAddress)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn machineType(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.machineType)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn oemId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.oemId)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn oemSymbolId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.oemSymbolId)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn get_types(
-            &self,
-            pctypes: *mut u32,
-            ptypes: &mut [::core::option::Option<IDiaSymbol>],
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self).base__.get_types)(
-                ::windows_core::Interface::as_raw(self),
-                ptypes.len().try_into().unwrap(),
-                pctypes,
-                ::core::mem::transmute(ptypes.as_ptr()),
-            )
-            .ok()
-        }
-        pub unsafe fn get_typeIds(
-            &self,
-            pctypeids: *mut u32,
-            pdwtypeids: &mut [u32],
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self).base__.get_typeIds)(
-                ::windows_core::Interface::as_raw(self),
-                pdwtypeids.len().try_into().unwrap(),
-                pctypeids,
-                ::core::mem::transmute(pdwtypeids.as_ptr()),
-            )
-            .ok()
-        }
-        pub unsafe fn objectPointerType(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .objectPointerType)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn udtKind(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.udtKind)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn get_undecoratedNameEx(
-            &self,
-            undecorateoptions: u32,
-        ) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .get_undecoratedNameEx)(
-                ::windows_core::Interface::as_raw(self),
-                undecorateoptions,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn noReturn(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.noReturn)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn customCallingConvention(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .customCallingConvention)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn noInline(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.noInline)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn optimizedCodeDebugInfo(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .optimizedCodeDebugInfo)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn notReached(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.notReached)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn interruptReturn(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .interruptReturn)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn farReturn(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.farReturn)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isStatic(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.isStatic)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn hasDebugInfo(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.hasDebugInfo)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isLTCG(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.isLTCG)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isDataAligned(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.isDataAligned)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn hasSecurityChecks(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .hasSecurityChecks)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn compilerName(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.compilerName)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn hasAlloca(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.hasAlloca)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn hasSetJump(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.hasSetJump)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn hasLongJump(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.hasLongJump)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn hasInlAsm(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.hasInlAsm)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn hasEH(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.hasEH)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn hasSEH(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.hasSEH)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn hasEHa(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.hasEHa)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isNaked(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.isNaked)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isAggregated(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.isAggregated)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isSplitted(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.isSplitted)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn container(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.container)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn inlSpec(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.inlSpec)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn noStackOrdering(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .noStackOrdering)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn virtualBaseTableType(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .virtualBaseTableType)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn hasManagedCode(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .hasManagedCode)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isHotpatchable(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .isHotpatchable)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isCVTCIL(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.isCVTCIL)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isMSILNetmodule(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .isMSILNetmodule)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isCTypes(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.isCTypes)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isStripped(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.isStripped)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn frontEndQFE(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.frontEndQFE)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn backEndQFE(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.backEndQFE)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn wasInlined(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.wasInlined)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn strictGSCheck(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.strictGSCheck)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isCxxReturnUdt(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .isCxxReturnUdt)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isConstructorVirtualBase(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .isConstructorVirtualBase)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn RValueReference(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .RValueReference)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn unmodifiedType(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .unmodifiedType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn framePointerPresent(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .framePointerPresent)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isSafeBuffers(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.isSafeBuffers)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn intrinsic(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.intrinsic)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn sealed(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.sealed)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn hfaFloat(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.hfaFloat)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn hfaDouble(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.hfaDouble)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn liveRangeStartAddressSection(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .liveRangeStartAddressSection)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn liveRangeStartAddressOffset(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .liveRangeStartAddressOffset)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn liveRangeStartRelativeVirtualAddress(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .liveRangeStartRelativeVirtualAddress)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn countLiveRanges(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .countLiveRanges)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn liveRangeLength(&self) -> ::windows_core::Result<u64> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .liveRangeLength)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn offsetInUdt(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.offsetInUdt)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn paramBasePointerRegisterId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .paramBasePointerRegisterId)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn localBasePointerRegisterId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .localBasePointerRegisterId)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isLocationControlFlowDependent(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .isLocationControlFlowDependent)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn stride(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.stride)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn numberOfRows(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.numberOfRows)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn numberOfColumns(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .numberOfColumns)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isMatrixRowMajor(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .isMatrixRowMajor)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn get_numericProperties(
-            &self,
-            pcnt: *mut u32,
-            pproperties: &mut [u32],
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .get_numericProperties)(
-                ::windows_core::Interface::as_raw(self),
-                pproperties.len().try_into().unwrap(),
-                pcnt,
-                ::core::mem::transmute(pproperties.as_ptr()),
-            )
-            .ok()
-        }
-        pub unsafe fn get_modifierValues(
-            &self,
-            pcnt: *mut u32,
-            pmodifiers: &mut [u16],
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .get_modifierValues)(
-                ::windows_core::Interface::as_raw(self),
-                pmodifiers.len().try_into().unwrap(),
-                pcnt,
-                ::core::mem::transmute(pmodifiers.as_ptr()),
-            )
-            .ok()
-        }
-        pub unsafe fn isReturnValue(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.isReturnValue)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isOptimizedAway(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .isOptimizedAway)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn builtInKind(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.builtInKind)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn registerType(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.registerType)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn baseDataSlot(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.baseDataSlot)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn baseDataOffset(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .baseDataOffset)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn textureSlot(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.textureSlot)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn samplerSlot(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.samplerSlot)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn uavSlot(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.uavSlot)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn sizeInUdt(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.sizeInUdt)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn memorySpaceKind(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .memorySpaceKind)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn unmodifiedTypeId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .unmodifiedTypeId)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn subTypeId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.subTypeId)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn subType(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.subType)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn numberOfModifiers(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .numberOfModifiers)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn numberOfRegisterIndices(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .numberOfRegisterIndices)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isHLSLData(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.isHLSLData)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isPointerToDataMember(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .isPointerToDataMember)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isPointerToMemberFunction(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .isPointerToMemberFunction)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isSingleInheritance(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .isSingleInheritance)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isMultipleInheritance(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .isMultipleInheritance)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isVirtualInheritance(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .isVirtualInheritance)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn restrictedType(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .restrictedType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isPointerBasedOnSymbolValue(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .isPointerBasedOnSymbolValue)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn baseSymbol(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.baseSymbol)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn baseSymbolId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.baseSymbolId)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn objectFileName(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .objectFileName)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn isAcceleratorGroupSharedLocal(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .isAcceleratorGroupSharedLocal)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isAcceleratorPointerTagLiveRange(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .isAcceleratorPointerTagLiveRange)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isAcceleratorStubFunction(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .isAcceleratorStubFunction)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn numberOfAcceleratorPointerTags(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .numberOfAcceleratorPointerTags)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isSdl(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.isSdl)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isWinRTPointer(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .isWinRTPointer)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isRefUdt(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.isRefUdt)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isValueUdt(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.isValueUdt)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isInterfaceUdt(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .isInterfaceUdt)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn findInlineFramesByAddr(
-            &self,
-            isect: u32,
-            offset: u32,
-        ) -> ::windows_core::Result<IDiaEnumSymbols> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .findInlineFramesByAddr)(
-                ::windows_core::Interface::as_raw(self),
-                isect,
-                offset,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findInlineFramesByRVA(
-            &self,
-            rva: u32,
-        ) -> ::windows_core::Result<IDiaEnumSymbols> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .findInlineFramesByRVA)(
-                ::windows_core::Interface::as_raw(self), rva, &mut result__
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findInlineFramesByVA(
-            &self,
-            va: u64,
-        ) -> ::windows_core::Result<IDiaEnumSymbols> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .findInlineFramesByVA)(
-                ::windows_core::Interface::as_raw(self), va, &mut result__
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findInlineeLines(&self) -> ::windows_core::Result<IDiaEnumLineNumbers> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .findInlineeLines)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findInlineeLinesByAddr(
-            &self,
-            isect: u32,
-            offset: u32,
-            length: u32,
-        ) -> ::windows_core::Result<IDiaEnumLineNumbers> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .findInlineeLinesByAddr)(
-                ::windows_core::Interface::as_raw(self),
-                isect,
-                offset,
-                length,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findInlineeLinesByRVA(
-            &self,
-            rva: u32,
-            length: u32,
-        ) -> ::windows_core::Result<IDiaEnumLineNumbers> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .findInlineeLinesByRVA)(
-                ::windows_core::Interface::as_raw(self),
-                rva,
-                length,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findInlineeLinesByVA(
-            &self,
-            va: u64,
-            length: u32,
-        ) -> ::windows_core::Result<IDiaEnumLineNumbers> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .findInlineeLinesByVA)(
-                ::windows_core::Interface::as_raw(self),
-                va,
-                length,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findSymbolsForAcceleratorPointerTag(
-            &self,
-            tagvalue: u32,
-        ) -> ::windows_core::Result<IDiaEnumSymbols> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .findSymbolsForAcceleratorPointerTag)(
-                ::windows_core::Interface::as_raw(self),
-                tagvalue,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findSymbolsByRVAForAcceleratorPointerTag(
-            &self,
-            tagvalue: u32,
-            rva: u32,
-        ) -> ::windows_core::Result<IDiaEnumSymbols> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .findSymbolsByRVAForAcceleratorPointerTag)(
-                ::windows_core::Interface::as_raw(self),
-                tagvalue,
-                rva,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn get_acceleratorPointerTags(
-            &self,
-            pcnt: *mut u32,
-            ppointertags: &mut [u32],
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .get_acceleratorPointerTags)(
-                ::windows_core::Interface::as_raw(self),
-                ppointertags.len().try_into().unwrap(),
-                pcnt,
-                ::core::mem::transmute(ppointertags.as_ptr()),
-            )
-            .ok()
-        }
-        pub unsafe fn getSrcLineOnTypeDefn(&self) -> ::windows_core::Result<IDiaLineNumber> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .getSrcLineOnTypeDefn)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn isPGO(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.isPGO)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn hasValidPGOCounts(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .hasValidPGOCounts)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isOptimizedForSpeed(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .isOptimizedForSpeed)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn PGOEntryCount(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.PGOEntryCount)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn PGOEdgeCount(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.PGOEdgeCount)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn PGODynamicInstructionCount(&self) -> ::windows_core::Result<u64> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .PGODynamicInstructionCount)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn staticSize(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.staticSize)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn finalLiveStaticSize(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .finalLiveStaticSize)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn phaseName(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.phaseName)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn hasControlFlowCheck(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .hasControlFlowCheck)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn constantExport(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .constantExport)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn dataExport(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.dataExport)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn privateExport(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.privateExport)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn noNameExport(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.noNameExport)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn exportHasExplicitlyAssignedOrdinal(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .exportHasExplicitlyAssignedOrdinal)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn exportIsForwarder(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .exportIsForwarder)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn ordinal(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.ordinal)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn frameSize(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.frameSize)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn exceptionHandlerAddressSection(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .exceptionHandlerAddressSection)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn exceptionHandlerAddressOffset(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .exceptionHandlerAddressOffset)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn exceptionHandlerRelativeVirtualAddress(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .exceptionHandlerRelativeVirtualAddress)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn exceptionHandlerVirtualAddress(&self) -> ::windows_core::Result<u64> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .exceptionHandlerVirtualAddress)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn findInputAssemblyFile(
-            &self,
-        ) -> ::windows_core::Result<IDiaInputAssemblyFile> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .findInputAssemblyFile)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn characteristics(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .characteristics)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn coffGroup(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.coffGroup)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn bindID(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.bindID)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn bindSpace(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.bindSpace)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn bindSlot(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.bindSlot)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isObjCClass(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).isObjCClass)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isObjCCategory(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).isObjCCategory)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isObjCProtocol(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).isObjCProtocol)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-    }
-    #[repr(C)]
-    pub struct IDiaSymbol2_Vtbl {
-        pub base__: IDiaSymbol_Vtbl,
-        pub isObjCClass: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
-        pub isObjCCategory: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
-        pub isObjCProtocol: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
-    }
-    ::windows_core::imp::com_interface!(
-        IDiaSymbol3,
-        IDiaSymbol3_Vtbl,
-        0x99b665f7_c1b2_49d3_89b2_a384361acab5
-    );
-    ::windows_core::imp::interface_hierarchy!(
-        IDiaSymbol3,
-        ::windows_core::IUnknown,
-        IDiaSymbol,
-        IDiaSymbol2
-    );
-    impl IDiaSymbol3 {
-        pub unsafe fn symIndexId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .symIndexId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn symTag(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.base__.symTag)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn name(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.base__.name)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn lexicalParent(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .lexicalParent)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn classParent(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .classParent)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn r#type(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.base__.r#type)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn dataKind(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .dataKind)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn locationType(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .locationType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn addressSection(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .addressSection)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn addressOffset(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .addressOffset)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn relativeVirtualAddress(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .relativeVirtualAddress)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn virtualAddress(&self) -> ::windows_core::Result<u64> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .virtualAddress)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn registerId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .registerId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn offset(&self) -> ::windows_core::Result<i32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.base__.offset)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn length(&self) -> ::windows_core::Result<u64> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.base__.length)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn slot(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.base__.slot)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn volatileType(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .volatileType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn constType(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .constType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn unalignedType(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .unalignedType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn access(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.base__.access)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn libraryName(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .libraryName)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn platform(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .platform)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn language(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .language)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn editAndContinueEnabled(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .editAndContinueEnabled)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn frontEndMajor(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .frontEndMajor)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn frontEndMinor(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .frontEndMinor)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn frontEndBuild(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .frontEndBuild)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn backEndMajor(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .backEndMajor)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn backEndMinor(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .backEndMinor)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn backEndBuild(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .backEndBuild)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn sourceFileName(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .sourceFileName)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn unused(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.base__.unused)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn thunkOrdinal(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .thunkOrdinal)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn thisAdjust(&self) -> ::windows_core::Result<i32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .thisAdjust)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn virtualBaseOffset(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .virtualBaseOffset)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn r#virtual(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .r#virtual)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn intro(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.base__.intro)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn pure(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.base__.pure)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn callingConvention(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .callingConvention)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn value(&self) -> ::windows_core::Result<::windows_core::VARIANT> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.base__.value)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn baseType(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .baseType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn token(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.base__.token)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn timeStamp(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .timeStamp)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn guid(&self) -> ::windows_core::Result<::windows_core::GUID> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.base__.guid)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn symbolsFileName(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .symbolsFileName)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn reference(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .reference)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn count(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.base__.count)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn bitPosition(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .bitPosition)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn arrayIndexType(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .arrayIndexType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn packed(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.base__.packed)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn constructor(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .constructor)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn overloadedOperator(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .overloadedOperator)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn nested(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.base__.nested)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn hasNestedTypes(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .hasNestedTypes)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasAssignmentOperator(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .hasAssignmentOperator)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn hasCastOperator(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .hasCastOperator)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn scoped(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.base__.scoped)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn virtualBaseClass(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .virtualBaseClass)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn indirectVirtualBaseClass(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .indirectVirtualBaseClass)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn virtualBasePointerOffset(&self) -> ::windows_core::Result<i32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .virtualBasePointerOffset)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn virtualTableShape(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .virtualTableShape)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn lexicalParentId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .lexicalParentId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn classParentId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .classParentId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn typeId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.base__.typeId)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn arrayIndexTypeId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .arrayIndexTypeId)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn virtualTableShapeId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .virtualTableShapeId)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn code(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.base__.code)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn function(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .function)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn managed(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .managed)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn msil(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.base__.msil)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn virtualBaseDispIndex(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .virtualBaseDispIndex)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn undecoratedName(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .undecoratedName)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn age(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.base__.age)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn signature(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .signature)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn compilerGenerated(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .compilerGenerated)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn addressTaken(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .addressTaken)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn rank(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.base__.rank)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn lowerBound(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .lowerBound)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn upperBound(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .upperBound)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn lowerBoundId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .lowerBoundId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn upperBoundId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .upperBoundId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn get_dataBytes(
-            &self,
-            pcbdata: *mut u32,
-            pbdata: &mut [u8],
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .get_dataBytes)(
-                ::windows_core::Interface::as_raw(self),
-                pbdata.len().try_into().unwrap(),
-                pcbdata,
-                ::core::mem::transmute(pbdata.as_ptr()),
-            )
-            .ok()
-        }
-        pub unsafe fn findChildren<P0>(
-            &self,
-            symtag: SymTag,
-            name: P0,
-            compareflags: u32,
-        ) -> ::windows_core::Result<IDiaEnumSymbols>
-        where
-            P0: ::windows_core::IntoParam<::windows_core::PCWSTR>,
-        {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .findChildren)(
-                ::windows_core::Interface::as_raw(self),
-                symtag,
-                name.into_param().abi(),
-                compareflags,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findChildrenEx<P0>(
-            &self,
-            symtag: SymTag,
-            name: P0,
-            compareflags: u32,
-        ) -> ::windows_core::Result<IDiaEnumSymbols>
-        where
-            P0: ::windows_core::IntoParam<::windows_core::PCWSTR>,
-        {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .findChildrenEx)(
-                ::windows_core::Interface::as_raw(self),
-                symtag,
-                name.into_param().abi(),
-                compareflags,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findChildrenExByAddr<P0>(
-            &self,
-            symtag: SymTag,
-            name: P0,
-            compareflags: u32,
-            isect: u32,
-            offset: u32,
-        ) -> ::windows_core::Result<IDiaEnumSymbols>
-        where
-            P0: ::windows_core::IntoParam<::windows_core::PCWSTR>,
-        {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .findChildrenExByAddr)(
-                ::windows_core::Interface::as_raw(self),
-                symtag,
-                name.into_param().abi(),
-                compareflags,
-                isect,
-                offset,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findChildrenExByVA<P0>(
-            &self,
-            symtag: SymTag,
-            name: P0,
-            compareflags: u32,
-            va: u64,
-        ) -> ::windows_core::Result<IDiaEnumSymbols>
-        where
-            P0: ::windows_core::IntoParam<::windows_core::PCWSTR>,
-        {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .findChildrenExByVA)(
-                ::windows_core::Interface::as_raw(self),
-                symtag,
-                name.into_param().abi(),
-                compareflags,
-                va,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findChildrenExByRVA<P0>(
-            &self,
-            symtag: SymTag,
-            name: P0,
-            compareflags: u32,
-            rva: u32,
-        ) -> ::windows_core::Result<IDiaEnumSymbols>
-        where
-            P0: ::windows_core::IntoParam<::windows_core::PCWSTR>,
-        {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .findChildrenExByRVA)(
-                ::windows_core::Interface::as_raw(self),
-                symtag,
-                name.into_param().abi(),
-                compareflags,
-                rva,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn targetSection(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .targetSection)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn targetOffset(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .targetOffset)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn targetRelativeVirtualAddress(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .targetRelativeVirtualAddress)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn targetVirtualAddress(&self) -> ::windows_core::Result<u64> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .targetVirtualAddress)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn machineType(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .machineType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn oemId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.base__.oemId)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn oemSymbolId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .oemSymbolId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn get_types(
-            &self,
-            pctypes: *mut u32,
-            ptypes: &mut [::core::option::Option<IDiaSymbol>],
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .get_types)(
-                ::windows_core::Interface::as_raw(self),
-                ptypes.len().try_into().unwrap(),
-                pctypes,
-                ::core::mem::transmute(ptypes.as_ptr()),
-            )
-            .ok()
-        }
-        pub unsafe fn get_typeIds(
-            &self,
-            pctypeids: *mut u32,
-            pdwtypeids: &mut [u32],
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .get_typeIds)(
-                ::windows_core::Interface::as_raw(self),
-                pdwtypeids.len().try_into().unwrap(),
-                pctypeids,
-                ::core::mem::transmute(pdwtypeids.as_ptr()),
-            )
-            .ok()
-        }
-        pub unsafe fn objectPointerType(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .objectPointerType)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn udtKind(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .udtKind)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn get_undecoratedNameEx(
-            &self,
-            undecorateoptions: u32,
-        ) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .get_undecoratedNameEx)(
-                ::windows_core::Interface::as_raw(self),
-                undecorateoptions,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn noReturn(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .noReturn)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn customCallingConvention(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .customCallingConvention)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn noInline(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .noInline)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn optimizedCodeDebugInfo(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .optimizedCodeDebugInfo)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn notReached(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .notReached)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn interruptReturn(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .interruptReturn)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn farReturn(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .farReturn)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isStatic(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .isStatic)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasDebugInfo(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .hasDebugInfo)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isLTCG(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.base__.isLTCG)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isDataAligned(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .isDataAligned)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasSecurityChecks(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .hasSecurityChecks)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn compilerName(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .compilerName)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn hasAlloca(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .hasAlloca)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasSetJump(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .hasSetJump)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasLongJump(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .hasLongJump)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasInlAsm(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .hasInlAsm)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasEH(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.base__.hasEH)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn hasSEH(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.base__.hasSEH)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn hasEHa(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.base__.hasEHa)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isNaked(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .isNaked)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isAggregated(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .isAggregated)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isSplitted(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .isSplitted)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn container(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .container)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn inlSpec(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .inlSpec)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn noStackOrdering(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .noStackOrdering)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn virtualBaseTableType(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .virtualBaseTableType)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn hasManagedCode(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .hasManagedCode)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isHotpatchable(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .isHotpatchable)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isCVTCIL(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .isCVTCIL)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isMSILNetmodule(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .isMSILNetmodule)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isCTypes(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .isCTypes)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isStripped(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .isStripped)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn frontEndQFE(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .frontEndQFE)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn backEndQFE(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .backEndQFE)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn wasInlined(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .wasInlined)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn strictGSCheck(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .strictGSCheck)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isCxxReturnUdt(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .isCxxReturnUdt)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isConstructorVirtualBase(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .isConstructorVirtualBase)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn RValueReference(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .RValueReference)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn unmodifiedType(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .unmodifiedType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn framePointerPresent(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .framePointerPresent)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isSafeBuffers(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .isSafeBuffers)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn intrinsic(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .intrinsic)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn sealed(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.base__.sealed)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn hfaFloat(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .hfaFloat)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hfaDouble(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .hfaDouble)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn liveRangeStartAddressSection(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .liveRangeStartAddressSection)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn liveRangeStartAddressOffset(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .liveRangeStartAddressOffset)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn liveRangeStartRelativeVirtualAddress(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .liveRangeStartRelativeVirtualAddress)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn countLiveRanges(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .countLiveRanges)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn liveRangeLength(&self) -> ::windows_core::Result<u64> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .liveRangeLength)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn offsetInUdt(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .offsetInUdt)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn paramBasePointerRegisterId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .paramBasePointerRegisterId)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn localBasePointerRegisterId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .localBasePointerRegisterId)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isLocationControlFlowDependent(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .isLocationControlFlowDependent)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn stride(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.base__.stride)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn numberOfRows(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .numberOfRows)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn numberOfColumns(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .numberOfColumns)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isMatrixRowMajor(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .isMatrixRowMajor)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn get_numericProperties(
-            &self,
-            pcnt: *mut u32,
-            pproperties: &mut [u32],
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .get_numericProperties)(
-                ::windows_core::Interface::as_raw(self),
-                pproperties.len().try_into().unwrap(),
-                pcnt,
-                ::core::mem::transmute(pproperties.as_ptr()),
-            )
-            .ok()
-        }
-        pub unsafe fn get_modifierValues(
-            &self,
-            pcnt: *mut u32,
-            pmodifiers: &mut [u16],
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .get_modifierValues)(
-                ::windows_core::Interface::as_raw(self),
-                pmodifiers.len().try_into().unwrap(),
-                pcnt,
-                ::core::mem::transmute(pmodifiers.as_ptr()),
-            )
-            .ok()
-        }
-        pub unsafe fn isReturnValue(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .isReturnValue)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isOptimizedAway(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .isOptimizedAway)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn builtInKind(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .builtInKind)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn registerType(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .registerType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn baseDataSlot(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .baseDataSlot)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn baseDataOffset(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .baseDataOffset)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn textureSlot(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .textureSlot)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn samplerSlot(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .samplerSlot)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn uavSlot(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .uavSlot)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn sizeInUdt(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .sizeInUdt)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn memorySpaceKind(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .memorySpaceKind)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn unmodifiedTypeId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .unmodifiedTypeId)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn subTypeId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .subTypeId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn subType(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .subType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn numberOfModifiers(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .numberOfModifiers)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn numberOfRegisterIndices(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .numberOfRegisterIndices)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isHLSLData(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .isHLSLData)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isPointerToDataMember(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .isPointerToDataMember)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isPointerToMemberFunction(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .isPointerToMemberFunction)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isSingleInheritance(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .isSingleInheritance)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isMultipleInheritance(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .isMultipleInheritance)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isVirtualInheritance(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .isVirtualInheritance)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn restrictedType(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .restrictedType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isPointerBasedOnSymbolValue(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .isPointerBasedOnSymbolValue)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn baseSymbol(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .baseSymbol)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn baseSymbolId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .baseSymbolId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn objectFileName(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .objectFileName)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn isAcceleratorGroupSharedLocal(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .isAcceleratorGroupSharedLocal)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isAcceleratorPointerTagLiveRange(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .isAcceleratorPointerTagLiveRange)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isAcceleratorStubFunction(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .isAcceleratorStubFunction)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn numberOfAcceleratorPointerTags(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .numberOfAcceleratorPointerTags)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isSdl(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.base__.isSdl)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isWinRTPointer(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .isWinRTPointer)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isRefUdt(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .isRefUdt)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isValueUdt(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .isValueUdt)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isInterfaceUdt(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .isInterfaceUdt)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn findInlineFramesByAddr(
-            &self,
-            isect: u32,
-            offset: u32,
-        ) -> ::windows_core::Result<IDiaEnumSymbols> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .findInlineFramesByAddr)(
-                ::windows_core::Interface::as_raw(self),
-                isect,
-                offset,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findInlineFramesByRVA(
-            &self,
-            rva: u32,
-        ) -> ::windows_core::Result<IDiaEnumSymbols> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .findInlineFramesByRVA)(
-                ::windows_core::Interface::as_raw(self), rva, &mut result__
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findInlineFramesByVA(
-            &self,
-            va: u64,
-        ) -> ::windows_core::Result<IDiaEnumSymbols> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .findInlineFramesByVA)(
-                ::windows_core::Interface::as_raw(self), va, &mut result__
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findInlineeLines(&self) -> ::windows_core::Result<IDiaEnumLineNumbers> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .findInlineeLines)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findInlineeLinesByAddr(
-            &self,
-            isect: u32,
-            offset: u32,
-            length: u32,
-        ) -> ::windows_core::Result<IDiaEnumLineNumbers> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .findInlineeLinesByAddr)(
-                ::windows_core::Interface::as_raw(self),
-                isect,
-                offset,
-                length,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findInlineeLinesByRVA(
-            &self,
-            rva: u32,
-            length: u32,
-        ) -> ::windows_core::Result<IDiaEnumLineNumbers> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .findInlineeLinesByRVA)(
-                ::windows_core::Interface::as_raw(self),
-                rva,
-                length,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findInlineeLinesByVA(
-            &self,
-            va: u64,
-            length: u32,
-        ) -> ::windows_core::Result<IDiaEnumLineNumbers> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .findInlineeLinesByVA)(
-                ::windows_core::Interface::as_raw(self),
-                va,
-                length,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findSymbolsForAcceleratorPointerTag(
-            &self,
-            tagvalue: u32,
-        ) -> ::windows_core::Result<IDiaEnumSymbols> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .findSymbolsForAcceleratorPointerTag)(
-                ::windows_core::Interface::as_raw(self),
-                tagvalue,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findSymbolsByRVAForAcceleratorPointerTag(
-            &self,
-            tagvalue: u32,
-            rva: u32,
-        ) -> ::windows_core::Result<IDiaEnumSymbols> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .findSymbolsByRVAForAcceleratorPointerTag)(
-                ::windows_core::Interface::as_raw(self),
-                tagvalue,
-                rva,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn get_acceleratorPointerTags(
-            &self,
-            pcnt: *mut u32,
-            ppointertags: &mut [u32],
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .get_acceleratorPointerTags)(
-                ::windows_core::Interface::as_raw(self),
-                ppointertags.len().try_into().unwrap(),
-                pcnt,
-                ::core::mem::transmute(ppointertags.as_ptr()),
-            )
-            .ok()
-        }
-        pub unsafe fn getSrcLineOnTypeDefn(&self) -> ::windows_core::Result<IDiaLineNumber> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .getSrcLineOnTypeDefn)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn isPGO(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.base__.isPGO)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn hasValidPGOCounts(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .hasValidPGOCounts)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isOptimizedForSpeed(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .isOptimizedForSpeed)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn PGOEntryCount(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .PGOEntryCount)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn PGOEdgeCount(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .PGOEdgeCount)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn PGODynamicInstructionCount(&self) -> ::windows_core::Result<u64> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .PGODynamicInstructionCount)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn staticSize(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .staticSize)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn finalLiveStaticSize(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .finalLiveStaticSize)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn phaseName(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .phaseName)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn hasControlFlowCheck(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .hasControlFlowCheck)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn constantExport(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .constantExport)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn dataExport(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .dataExport)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn privateExport(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .privateExport)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn noNameExport(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .noNameExport)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn exportHasExplicitlyAssignedOrdinal(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .exportHasExplicitlyAssignedOrdinal)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn exportIsForwarder(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .exportIsForwarder)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn ordinal(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .ordinal)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn frameSize(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .frameSize)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn exceptionHandlerAddressSection(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .exceptionHandlerAddressSection)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn exceptionHandlerAddressOffset(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .exceptionHandlerAddressOffset)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn exceptionHandlerRelativeVirtualAddress(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .exceptionHandlerRelativeVirtualAddress)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn exceptionHandlerVirtualAddress(&self) -> ::windows_core::Result<u64> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .exceptionHandlerVirtualAddress)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn findInputAssemblyFile(
-            &self,
-        ) -> ::windows_core::Result<IDiaInputAssemblyFile> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .findInputAssemblyFile)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn characteristics(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .characteristics)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn coffGroup(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .coffGroup)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn bindID(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.base__.bindID)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn bindSpace(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .bindSpace)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn bindSlot(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .bindSlot)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isObjCClass(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.isObjCClass)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isObjCCategory(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .isObjCCategory)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isObjCProtocol(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .isObjCProtocol)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn inlinee(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).inlinee)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn inlineeId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).inlineeId)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-    }
-    #[repr(C)]
-    pub struct IDiaSymbol3_Vtbl {
-        pub base__: IDiaSymbol2_Vtbl,
-        pub inlinee: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
-        pub inlineeId: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
-    }
-    ::windows_core::imp::com_interface!(
-        IDiaSymbol4,
-        IDiaSymbol4_Vtbl,
-        0xbf6c88a7_e9d6_4346_99a1_d053de5a7808
-    );
-    ::windows_core::imp::interface_hierarchy!(
-        IDiaSymbol4,
-        ::windows_core::IUnknown,
-        IDiaSymbol,
-        IDiaSymbol2,
-        IDiaSymbol3
-    );
-    impl IDiaSymbol4 {
-        pub unsafe fn symIndexId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .symIndexId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn symTag(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .symTag)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn name(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .name)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn lexicalParent(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .lexicalParent)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn classParent(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .classParent)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn r#type(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .r#type)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn dataKind(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .dataKind)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn locationType(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .locationType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn addressSection(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .addressSection)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn addressOffset(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .addressOffset)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn relativeVirtualAddress(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .relativeVirtualAddress)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn virtualAddress(&self) -> ::windows_core::Result<u64> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .virtualAddress)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn registerId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .registerId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn offset(&self) -> ::windows_core::Result<i32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .offset)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn length(&self) -> ::windows_core::Result<u64> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .length)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn slot(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .slot)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn volatileType(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .volatileType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn constType(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .constType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn unalignedType(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .unalignedType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn access(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .access)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn libraryName(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .libraryName)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn platform(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .platform)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn language(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .language)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn editAndContinueEnabled(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .editAndContinueEnabled)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn frontEndMajor(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .frontEndMajor)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn frontEndMinor(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .frontEndMinor)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn frontEndBuild(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .frontEndBuild)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn backEndMajor(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .backEndMajor)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn backEndMinor(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .backEndMinor)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn backEndBuild(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .backEndBuild)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn sourceFileName(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .sourceFileName)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn unused(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .unused)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn thunkOrdinal(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .thunkOrdinal)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn thisAdjust(&self) -> ::windows_core::Result<i32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .thisAdjust)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn virtualBaseOffset(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .virtualBaseOffset)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn r#virtual(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .r#virtual)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn intro(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .intro)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn pure(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .pure)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn callingConvention(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .callingConvention)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn value(&self) -> ::windows_core::Result<::windows_core::VARIANT> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .value)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn baseType(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .baseType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn token(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .token)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn timeStamp(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .timeStamp)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn guid(&self) -> ::windows_core::Result<::windows_core::GUID> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .guid)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn symbolsFileName(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .symbolsFileName)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn reference(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .reference)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn count(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .count)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn bitPosition(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .bitPosition)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn arrayIndexType(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .arrayIndexType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn packed(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .packed)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn constructor(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .constructor)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn overloadedOperator(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .overloadedOperator)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn nested(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .nested)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasNestedTypes(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .hasNestedTypes)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasAssignmentOperator(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .hasAssignmentOperator)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn hasCastOperator(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .hasCastOperator)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn scoped(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .scoped)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn virtualBaseClass(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .virtualBaseClass)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn indirectVirtualBaseClass(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .indirectVirtualBaseClass)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn virtualBasePointerOffset(&self) -> ::windows_core::Result<i32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .virtualBasePointerOffset)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn virtualTableShape(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .virtualTableShape)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn lexicalParentId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .lexicalParentId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn classParentId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .classParentId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn typeId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .typeId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn arrayIndexTypeId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .arrayIndexTypeId)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn virtualTableShapeId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .virtualTableShapeId)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn code(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .code)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn function(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .function)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn managed(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .managed)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn msil(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .msil)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn virtualBaseDispIndex(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .virtualBaseDispIndex)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn undecoratedName(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .undecoratedName)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn age(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .age)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn signature(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .signature)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn compilerGenerated(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .compilerGenerated)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn addressTaken(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .addressTaken)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn rank(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .rank)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn lowerBound(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .lowerBound)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn upperBound(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .upperBound)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn lowerBoundId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .lowerBoundId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn upperBoundId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .upperBoundId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn get_dataBytes(
-            &self,
-            pcbdata: *mut u32,
-            pbdata: &mut [u8],
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .get_dataBytes)(
-                ::windows_core::Interface::as_raw(self),
-                pbdata.len().try_into().unwrap(),
-                pcbdata,
-                ::core::mem::transmute(pbdata.as_ptr()),
-            )
-            .ok()
-        }
-        pub unsafe fn findChildren<P0>(
-            &self,
-            symtag: SymTag,
-            name: P0,
-            compareflags: u32,
-        ) -> ::windows_core::Result<IDiaEnumSymbols>
-        where
-            P0: ::windows_core::IntoParam<::windows_core::PCWSTR>,
-        {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .findChildren)(
-                ::windows_core::Interface::as_raw(self),
-                symtag,
-                name.into_param().abi(),
-                compareflags,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findChildrenEx<P0>(
-            &self,
-            symtag: SymTag,
-            name: P0,
-            compareflags: u32,
-        ) -> ::windows_core::Result<IDiaEnumSymbols>
-        where
-            P0: ::windows_core::IntoParam<::windows_core::PCWSTR>,
-        {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .findChildrenEx)(
-                ::windows_core::Interface::as_raw(self),
-                symtag,
-                name.into_param().abi(),
-                compareflags,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findChildrenExByAddr<P0>(
-            &self,
-            symtag: SymTag,
-            name: P0,
-            compareflags: u32,
-            isect: u32,
-            offset: u32,
-        ) -> ::windows_core::Result<IDiaEnumSymbols>
-        where
-            P0: ::windows_core::IntoParam<::windows_core::PCWSTR>,
-        {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .findChildrenExByAddr)(
-                ::windows_core::Interface::as_raw(self),
-                symtag,
-                name.into_param().abi(),
-                compareflags,
-                isect,
-                offset,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findChildrenExByVA<P0>(
-            &self,
-            symtag: SymTag,
-            name: P0,
-            compareflags: u32,
-            va: u64,
-        ) -> ::windows_core::Result<IDiaEnumSymbols>
-        where
-            P0: ::windows_core::IntoParam<::windows_core::PCWSTR>,
-        {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .findChildrenExByVA)(
-                ::windows_core::Interface::as_raw(self),
-                symtag,
-                name.into_param().abi(),
-                compareflags,
-                va,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findChildrenExByRVA<P0>(
-            &self,
-            symtag: SymTag,
-            name: P0,
-            compareflags: u32,
-            rva: u32,
-        ) -> ::windows_core::Result<IDiaEnumSymbols>
-        where
-            P0: ::windows_core::IntoParam<::windows_core::PCWSTR>,
-        {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .findChildrenExByRVA)(
-                ::windows_core::Interface::as_raw(self),
-                symtag,
-                name.into_param().abi(),
-                compareflags,
-                rva,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn targetSection(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .targetSection)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn targetOffset(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .targetOffset)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn targetRelativeVirtualAddress(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .targetRelativeVirtualAddress)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn targetVirtualAddress(&self) -> ::windows_core::Result<u64> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .targetVirtualAddress)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn machineType(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .machineType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn oemId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .oemId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn oemSymbolId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .oemSymbolId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn get_types(
-            &self,
-            pctypes: *mut u32,
-            ptypes: &mut [::core::option::Option<IDiaSymbol>],
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .get_types)(
-                ::windows_core::Interface::as_raw(self),
-                ptypes.len().try_into().unwrap(),
-                pctypes,
-                ::core::mem::transmute(ptypes.as_ptr()),
-            )
-            .ok()
-        }
-        pub unsafe fn get_typeIds(
-            &self,
-            pctypeids: *mut u32,
-            pdwtypeids: &mut [u32],
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .get_typeIds)(
-                ::windows_core::Interface::as_raw(self),
-                pdwtypeids.len().try_into().unwrap(),
-                pctypeids,
-                ::core::mem::transmute(pdwtypeids.as_ptr()),
-            )
-            .ok()
-        }
-        pub unsafe fn objectPointerType(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .objectPointerType)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn udtKind(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .udtKind)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn get_undecoratedNameEx(
-            &self,
-            undecorateoptions: u32,
-        ) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .get_undecoratedNameEx)(
-                ::windows_core::Interface::as_raw(self),
-                undecorateoptions,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn noReturn(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .noReturn)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn customCallingConvention(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .customCallingConvention)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn noInline(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .noInline)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn optimizedCodeDebugInfo(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .optimizedCodeDebugInfo)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn notReached(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .notReached)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn interruptReturn(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .interruptReturn)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn farReturn(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .farReturn)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isStatic(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .isStatic)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasDebugInfo(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .hasDebugInfo)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isLTCG(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .isLTCG)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isDataAligned(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .isDataAligned)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasSecurityChecks(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .hasSecurityChecks)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn compilerName(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .compilerName)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn hasAlloca(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .hasAlloca)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasSetJump(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .hasSetJump)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasLongJump(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .hasLongJump)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasInlAsm(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .hasInlAsm)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasEH(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .hasEH)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasSEH(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .hasSEH)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasEHa(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .hasEHa)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isNaked(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .isNaked)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isAggregated(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .isAggregated)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isSplitted(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .isSplitted)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn container(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .container)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn inlSpec(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .inlSpec)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn noStackOrdering(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .noStackOrdering)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn virtualBaseTableType(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .virtualBaseTableType)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn hasManagedCode(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .hasManagedCode)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isHotpatchable(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .isHotpatchable)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isCVTCIL(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .isCVTCIL)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isMSILNetmodule(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .isMSILNetmodule)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isCTypes(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .isCTypes)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isStripped(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .isStripped)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn frontEndQFE(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .frontEndQFE)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn backEndQFE(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .backEndQFE)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn wasInlined(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .wasInlined)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn strictGSCheck(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .strictGSCheck)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isCxxReturnUdt(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .isCxxReturnUdt)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isConstructorVirtualBase(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .isConstructorVirtualBase)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn RValueReference(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .RValueReference)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn unmodifiedType(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .unmodifiedType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn framePointerPresent(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .framePointerPresent)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isSafeBuffers(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .isSafeBuffers)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn intrinsic(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .intrinsic)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn sealed(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .sealed)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hfaFloat(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .hfaFloat)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hfaDouble(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .hfaDouble)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn liveRangeStartAddressSection(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .liveRangeStartAddressSection)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn liveRangeStartAddressOffset(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .liveRangeStartAddressOffset)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn liveRangeStartRelativeVirtualAddress(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .liveRangeStartRelativeVirtualAddress)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn countLiveRanges(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .countLiveRanges)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn liveRangeLength(&self) -> ::windows_core::Result<u64> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .liveRangeLength)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn offsetInUdt(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .offsetInUdt)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn paramBasePointerRegisterId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .paramBasePointerRegisterId)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn localBasePointerRegisterId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .localBasePointerRegisterId)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isLocationControlFlowDependent(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .isLocationControlFlowDependent)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn stride(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .stride)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn numberOfRows(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .numberOfRows)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn numberOfColumns(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .numberOfColumns)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isMatrixRowMajor(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .isMatrixRowMajor)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn get_numericProperties(
-            &self,
-            pcnt: *mut u32,
-            pproperties: &mut [u32],
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .get_numericProperties)(
-                ::windows_core::Interface::as_raw(self),
-                pproperties.len().try_into().unwrap(),
-                pcnt,
-                ::core::mem::transmute(pproperties.as_ptr()),
-            )
-            .ok()
-        }
-        pub unsafe fn get_modifierValues(
-            &self,
-            pcnt: *mut u32,
-            pmodifiers: &mut [u16],
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .get_modifierValues)(
-                ::windows_core::Interface::as_raw(self),
-                pmodifiers.len().try_into().unwrap(),
-                pcnt,
-                ::core::mem::transmute(pmodifiers.as_ptr()),
-            )
-            .ok()
-        }
-        pub unsafe fn isReturnValue(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .isReturnValue)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isOptimizedAway(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .isOptimizedAway)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn builtInKind(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .builtInKind)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn registerType(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .registerType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn baseDataSlot(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .baseDataSlot)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn baseDataOffset(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .baseDataOffset)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn textureSlot(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .textureSlot)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn samplerSlot(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .samplerSlot)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn uavSlot(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .uavSlot)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn sizeInUdt(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .sizeInUdt)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn memorySpaceKind(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .memorySpaceKind)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn unmodifiedTypeId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .unmodifiedTypeId)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn subTypeId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .subTypeId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn subType(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .subType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn numberOfModifiers(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .numberOfModifiers)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn numberOfRegisterIndices(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .numberOfRegisterIndices)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isHLSLData(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .isHLSLData)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isPointerToDataMember(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .isPointerToDataMember)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isPointerToMemberFunction(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .isPointerToMemberFunction)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isSingleInheritance(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .isSingleInheritance)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isMultipleInheritance(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .isMultipleInheritance)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isVirtualInheritance(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .isVirtualInheritance)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn restrictedType(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .restrictedType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isPointerBasedOnSymbolValue(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .isPointerBasedOnSymbolValue)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn baseSymbol(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .baseSymbol)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn baseSymbolId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .baseSymbolId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn objectFileName(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .objectFileName)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn isAcceleratorGroupSharedLocal(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .isAcceleratorGroupSharedLocal)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isAcceleratorPointerTagLiveRange(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .isAcceleratorPointerTagLiveRange)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isAcceleratorStubFunction(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .isAcceleratorStubFunction)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn numberOfAcceleratorPointerTags(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .numberOfAcceleratorPointerTags)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isSdl(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .isSdl)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isWinRTPointer(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .isWinRTPointer)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isRefUdt(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .isRefUdt)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isValueUdt(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .isValueUdt)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isInterfaceUdt(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .isInterfaceUdt)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn findInlineFramesByAddr(
-            &self,
-            isect: u32,
-            offset: u32,
-        ) -> ::windows_core::Result<IDiaEnumSymbols> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .findInlineFramesByAddr)(
-                ::windows_core::Interface::as_raw(self),
-                isect,
-                offset,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findInlineFramesByRVA(
-            &self,
-            rva: u32,
-        ) -> ::windows_core::Result<IDiaEnumSymbols> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .findInlineFramesByRVA)(
-                ::windows_core::Interface::as_raw(self), rva, &mut result__
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findInlineFramesByVA(
-            &self,
-            va: u64,
-        ) -> ::windows_core::Result<IDiaEnumSymbols> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .findInlineFramesByVA)(
-                ::windows_core::Interface::as_raw(self), va, &mut result__
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findInlineeLines(&self) -> ::windows_core::Result<IDiaEnumLineNumbers> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .findInlineeLines)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findInlineeLinesByAddr(
-            &self,
-            isect: u32,
-            offset: u32,
-            length: u32,
-        ) -> ::windows_core::Result<IDiaEnumLineNumbers> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .findInlineeLinesByAddr)(
-                ::windows_core::Interface::as_raw(self),
-                isect,
-                offset,
-                length,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findInlineeLinesByRVA(
-            &self,
-            rva: u32,
-            length: u32,
-        ) -> ::windows_core::Result<IDiaEnumLineNumbers> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .findInlineeLinesByRVA)(
-                ::windows_core::Interface::as_raw(self),
-                rva,
-                length,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findInlineeLinesByVA(
-            &self,
-            va: u64,
-            length: u32,
-        ) -> ::windows_core::Result<IDiaEnumLineNumbers> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .findInlineeLinesByVA)(
-                ::windows_core::Interface::as_raw(self),
-                va,
-                length,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findSymbolsForAcceleratorPointerTag(
-            &self,
-            tagvalue: u32,
-        ) -> ::windows_core::Result<IDiaEnumSymbols> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .findSymbolsForAcceleratorPointerTag)(
-                ::windows_core::Interface::as_raw(self),
-                tagvalue,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findSymbolsByRVAForAcceleratorPointerTag(
-            &self,
-            tagvalue: u32,
-            rva: u32,
-        ) -> ::windows_core::Result<IDiaEnumSymbols> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .findSymbolsByRVAForAcceleratorPointerTag)(
-                ::windows_core::Interface::as_raw(self),
-                tagvalue,
-                rva,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn get_acceleratorPointerTags(
-            &self,
-            pcnt: *mut u32,
-            ppointertags: &mut [u32],
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .get_acceleratorPointerTags)(
-                ::windows_core::Interface::as_raw(self),
-                ppointertags.len().try_into().unwrap(),
-                pcnt,
-                ::core::mem::transmute(ppointertags.as_ptr()),
-            )
-            .ok()
-        }
-        pub unsafe fn getSrcLineOnTypeDefn(&self) -> ::windows_core::Result<IDiaLineNumber> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .getSrcLineOnTypeDefn)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn isPGO(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .isPGO)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasValidPGOCounts(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .hasValidPGOCounts)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isOptimizedForSpeed(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .isOptimizedForSpeed)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn PGOEntryCount(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .PGOEntryCount)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn PGOEdgeCount(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .PGOEdgeCount)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn PGODynamicInstructionCount(&self) -> ::windows_core::Result<u64> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .PGODynamicInstructionCount)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn staticSize(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .staticSize)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn finalLiveStaticSize(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .finalLiveStaticSize)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn phaseName(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .phaseName)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn hasControlFlowCheck(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .hasControlFlowCheck)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn constantExport(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .constantExport)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn dataExport(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .dataExport)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn privateExport(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .privateExport)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn noNameExport(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .noNameExport)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn exportHasExplicitlyAssignedOrdinal(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .exportHasExplicitlyAssignedOrdinal)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn exportIsForwarder(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .exportIsForwarder)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn ordinal(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .ordinal)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn frameSize(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .frameSize)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn exceptionHandlerAddressSection(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .exceptionHandlerAddressSection)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn exceptionHandlerAddressOffset(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .exceptionHandlerAddressOffset)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn exceptionHandlerRelativeVirtualAddress(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .exceptionHandlerRelativeVirtualAddress)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn exceptionHandlerVirtualAddress(&self) -> ::windows_core::Result<u64> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .exceptionHandlerVirtualAddress)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn findInputAssemblyFile(
-            &self,
-        ) -> ::windows_core::Result<IDiaInputAssemblyFile> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .findInputAssemblyFile)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn characteristics(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .characteristics)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn coffGroup(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .coffGroup)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn bindID(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .bindID)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn bindSpace(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .bindSpace)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn bindSlot(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .bindSlot)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isObjCClass(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .isObjCClass)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isObjCCategory(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .isObjCCategory)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isObjCProtocol(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .isObjCProtocol)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn inlinee(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.inlinee)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn inlineeId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.inlineeId)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn noexcept(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).noexcept)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-    }
-    #[repr(C)]
-    pub struct IDiaSymbol4_Vtbl {
-        pub base__: IDiaSymbol3_Vtbl,
-        pub noexcept: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
-    }
-    ::windows_core::imp::com_interface!(
-        IDiaSymbol5,
-        IDiaSymbol5_Vtbl,
-        0xabe2de00_dc2d_4793_af9a_ef1d90832644
-    );
-    ::windows_core::imp::interface_hierarchy!(
-        IDiaSymbol5,
-        ::windows_core::IUnknown,
-        IDiaSymbol,
-        IDiaSymbol2,
-        IDiaSymbol3,
-        IDiaSymbol4
-    );
-    impl IDiaSymbol5 {
-        pub unsafe fn symIndexId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .symIndexId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn symTag(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .symTag)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn name(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .name)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn lexicalParent(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .lexicalParent)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn classParent(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .classParent)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn r#type(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .r#type)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn dataKind(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .dataKind)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn locationType(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .locationType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn addressSection(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .addressSection)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn addressOffset(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .addressOffset)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn relativeVirtualAddress(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .relativeVirtualAddress)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn virtualAddress(&self) -> ::windows_core::Result<u64> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .virtualAddress)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn registerId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .registerId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn offset(&self) -> ::windows_core::Result<i32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .offset)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn length(&self) -> ::windows_core::Result<u64> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .length)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn slot(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .slot)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn volatileType(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .volatileType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn constType(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .constType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn unalignedType(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .unalignedType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn access(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .access)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn libraryName(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .libraryName)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn platform(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .platform)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn language(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .language)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn editAndContinueEnabled(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .editAndContinueEnabled)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn frontEndMajor(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .frontEndMajor)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn frontEndMinor(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .frontEndMinor)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn frontEndBuild(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .frontEndBuild)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn backEndMajor(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .backEndMajor)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn backEndMinor(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .backEndMinor)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn backEndBuild(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .backEndBuild)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn sourceFileName(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .sourceFileName)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn unused(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .unused)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn thunkOrdinal(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .thunkOrdinal)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn thisAdjust(&self) -> ::windows_core::Result<i32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .thisAdjust)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn virtualBaseOffset(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .virtualBaseOffset)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn r#virtual(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .r#virtual)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn intro(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .intro)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn pure(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .pure)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn callingConvention(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .callingConvention)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn value(&self) -> ::windows_core::Result<::windows_core::VARIANT> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .value)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn baseType(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .baseType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn token(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .token)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn timeStamp(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .timeStamp)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn guid(&self) -> ::windows_core::Result<::windows_core::GUID> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .guid)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn symbolsFileName(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .symbolsFileName)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn reference(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .reference)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn count(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .count)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn bitPosition(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .bitPosition)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn arrayIndexType(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .arrayIndexType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn packed(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .packed)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn constructor(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .constructor)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn overloadedOperator(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .overloadedOperator)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn nested(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .nested)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasNestedTypes(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasNestedTypes)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasAssignmentOperator(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasAssignmentOperator)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn hasCastOperator(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasCastOperator)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn scoped(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .scoped)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn virtualBaseClass(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .virtualBaseClass)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn indirectVirtualBaseClass(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .indirectVirtualBaseClass)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn virtualBasePointerOffset(&self) -> ::windows_core::Result<i32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .virtualBasePointerOffset)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn virtualTableShape(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .virtualTableShape)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn lexicalParentId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .lexicalParentId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn classParentId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .classParentId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn typeId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .typeId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn arrayIndexTypeId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .arrayIndexTypeId)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn virtualTableShapeId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .virtualTableShapeId)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn code(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .code)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn function(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .function)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn managed(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .managed)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn msil(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .msil)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn virtualBaseDispIndex(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .virtualBaseDispIndex)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn undecoratedName(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .undecoratedName)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn age(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .age)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn signature(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .signature)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn compilerGenerated(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .compilerGenerated)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn addressTaken(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .addressTaken)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn rank(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .rank)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn lowerBound(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .lowerBound)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn upperBound(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .upperBound)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn lowerBoundId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .lowerBoundId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn upperBoundId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .upperBoundId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn get_dataBytes(
-            &self,
-            pcbdata: *mut u32,
-            pbdata: &mut [u8],
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .get_dataBytes)(
-                ::windows_core::Interface::as_raw(self),
-                pbdata.len().try_into().unwrap(),
-                pcbdata,
-                ::core::mem::transmute(pbdata.as_ptr()),
-            )
-            .ok()
-        }
-        pub unsafe fn findChildren<P0>(
-            &self,
-            symtag: SymTag,
-            name: P0,
-            compareflags: u32,
-        ) -> ::windows_core::Result<IDiaEnumSymbols>
-        where
-            P0: ::windows_core::IntoParam<::windows_core::PCWSTR>,
-        {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .findChildren)(
-                ::windows_core::Interface::as_raw(self),
-                symtag,
-                name.into_param().abi(),
-                compareflags,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findChildrenEx<P0>(
-            &self,
-            symtag: SymTag,
-            name: P0,
-            compareflags: u32,
-        ) -> ::windows_core::Result<IDiaEnumSymbols>
-        where
-            P0: ::windows_core::IntoParam<::windows_core::PCWSTR>,
-        {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .findChildrenEx)(
-                ::windows_core::Interface::as_raw(self),
-                symtag,
-                name.into_param().abi(),
-                compareflags,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findChildrenExByAddr<P0>(
-            &self,
-            symtag: SymTag,
-            name: P0,
-            compareflags: u32,
-            isect: u32,
-            offset: u32,
-        ) -> ::windows_core::Result<IDiaEnumSymbols>
-        where
-            P0: ::windows_core::IntoParam<::windows_core::PCWSTR>,
-        {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .findChildrenExByAddr)(
-                ::windows_core::Interface::as_raw(self),
-                symtag,
-                name.into_param().abi(),
-                compareflags,
-                isect,
-                offset,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findChildrenExByVA<P0>(
-            &self,
-            symtag: SymTag,
-            name: P0,
-            compareflags: u32,
-            va: u64,
-        ) -> ::windows_core::Result<IDiaEnumSymbols>
-        where
-            P0: ::windows_core::IntoParam<::windows_core::PCWSTR>,
-        {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .findChildrenExByVA)(
-                ::windows_core::Interface::as_raw(self),
-                symtag,
-                name.into_param().abi(),
-                compareflags,
-                va,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findChildrenExByRVA<P0>(
-            &self,
-            symtag: SymTag,
-            name: P0,
-            compareflags: u32,
-            rva: u32,
-        ) -> ::windows_core::Result<IDiaEnumSymbols>
-        where
-            P0: ::windows_core::IntoParam<::windows_core::PCWSTR>,
-        {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .findChildrenExByRVA)(
-                ::windows_core::Interface::as_raw(self),
-                symtag,
-                name.into_param().abi(),
-                compareflags,
-                rva,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn targetSection(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .targetSection)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn targetOffset(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .targetOffset)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn targetRelativeVirtualAddress(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .targetRelativeVirtualAddress)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn targetVirtualAddress(&self) -> ::windows_core::Result<u64> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .targetVirtualAddress)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn machineType(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .machineType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn oemId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .oemId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn oemSymbolId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .oemSymbolId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn get_types(
-            &self,
-            pctypes: *mut u32,
-            ptypes: &mut [::core::option::Option<IDiaSymbol>],
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .get_types)(
-                ::windows_core::Interface::as_raw(self),
-                ptypes.len().try_into().unwrap(),
-                pctypes,
-                ::core::mem::transmute(ptypes.as_ptr()),
-            )
-            .ok()
-        }
-        pub unsafe fn get_typeIds(
-            &self,
-            pctypeids: *mut u32,
-            pdwtypeids: &mut [u32],
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .get_typeIds)(
-                ::windows_core::Interface::as_raw(self),
-                pdwtypeids.len().try_into().unwrap(),
-                pctypeids,
-                ::core::mem::transmute(pdwtypeids.as_ptr()),
-            )
-            .ok()
-        }
-        pub unsafe fn objectPointerType(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .objectPointerType)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn udtKind(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .udtKind)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn get_undecoratedNameEx(
-            &self,
-            undecorateoptions: u32,
-        ) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .get_undecoratedNameEx)(
-                ::windows_core::Interface::as_raw(self),
-                undecorateoptions,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn noReturn(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .noReturn)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn customCallingConvention(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .customCallingConvention)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn noInline(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .noInline)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn optimizedCodeDebugInfo(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .optimizedCodeDebugInfo)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn notReached(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .notReached)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn interruptReturn(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .interruptReturn)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn farReturn(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .farReturn)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isStatic(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .isStatic)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasDebugInfo(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasDebugInfo)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isLTCG(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .isLTCG)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isDataAligned(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .isDataAligned)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasSecurityChecks(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasSecurityChecks)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn compilerName(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .compilerName)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn hasAlloca(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasAlloca)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasSetJump(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasSetJump)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasLongJump(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasLongJump)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasInlAsm(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasInlAsm)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasEH(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasEH)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasSEH(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasSEH)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasEHa(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasEHa)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isNaked(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .isNaked)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isAggregated(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .isAggregated)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isSplitted(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .isSplitted)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn container(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .container)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn inlSpec(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .inlSpec)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn noStackOrdering(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .noStackOrdering)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn virtualBaseTableType(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .virtualBaseTableType)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn hasManagedCode(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasManagedCode)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isHotpatchable(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .isHotpatchable)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isCVTCIL(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .isCVTCIL)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isMSILNetmodule(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .isMSILNetmodule)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isCTypes(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .isCTypes)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isStripped(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .isStripped)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn frontEndQFE(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .frontEndQFE)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn backEndQFE(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .backEndQFE)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn wasInlined(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .wasInlined)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn strictGSCheck(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .strictGSCheck)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isCxxReturnUdt(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .isCxxReturnUdt)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isConstructorVirtualBase(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .isConstructorVirtualBase)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn RValueReference(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .RValueReference)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn unmodifiedType(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .unmodifiedType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn framePointerPresent(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .framePointerPresent)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isSafeBuffers(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .isSafeBuffers)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn intrinsic(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .intrinsic)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn sealed(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .sealed)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hfaFloat(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .hfaFloat)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hfaDouble(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .hfaDouble)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn liveRangeStartAddressSection(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .liveRangeStartAddressSection)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn liveRangeStartAddressOffset(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .liveRangeStartAddressOffset)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn liveRangeStartRelativeVirtualAddress(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .liveRangeStartRelativeVirtualAddress)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn countLiveRanges(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .countLiveRanges)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn liveRangeLength(&self) -> ::windows_core::Result<u64> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .liveRangeLength)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn offsetInUdt(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .offsetInUdt)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn paramBasePointerRegisterId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .paramBasePointerRegisterId)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn localBasePointerRegisterId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .localBasePointerRegisterId)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isLocationControlFlowDependent(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .isLocationControlFlowDependent)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn stride(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .stride)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn numberOfRows(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .numberOfRows)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn numberOfColumns(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .numberOfColumns)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isMatrixRowMajor(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .isMatrixRowMajor)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn get_numericProperties(
-            &self,
-            pcnt: *mut u32,
-            pproperties: &mut [u32],
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .get_numericProperties)(
-                ::windows_core::Interface::as_raw(self),
-                pproperties.len().try_into().unwrap(),
-                pcnt,
-                ::core::mem::transmute(pproperties.as_ptr()),
-            )
-            .ok()
-        }
-        pub unsafe fn get_modifierValues(
-            &self,
-            pcnt: *mut u32,
-            pmodifiers: &mut [u16],
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .get_modifierValues)(
-                ::windows_core::Interface::as_raw(self),
-                pmodifiers.len().try_into().unwrap(),
-                pcnt,
-                ::core::mem::transmute(pmodifiers.as_ptr()),
-            )
-            .ok()
-        }
-        pub unsafe fn isReturnValue(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .isReturnValue)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isOptimizedAway(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .isOptimizedAway)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn builtInKind(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .builtInKind)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn registerType(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .registerType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn baseDataSlot(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .baseDataSlot)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn baseDataOffset(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .baseDataOffset)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn textureSlot(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .textureSlot)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn samplerSlot(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .samplerSlot)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn uavSlot(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .uavSlot)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn sizeInUdt(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .sizeInUdt)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn memorySpaceKind(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .memorySpaceKind)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn unmodifiedTypeId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .unmodifiedTypeId)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn subTypeId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .subTypeId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn subType(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .subType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn numberOfModifiers(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .numberOfModifiers)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn numberOfRegisterIndices(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .numberOfRegisterIndices)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isHLSLData(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .isHLSLData)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isPointerToDataMember(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .isPointerToDataMember)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isPointerToMemberFunction(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .isPointerToMemberFunction)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isSingleInheritance(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .isSingleInheritance)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isMultipleInheritance(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .isMultipleInheritance)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isVirtualInheritance(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .isVirtualInheritance)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn restrictedType(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .restrictedType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isPointerBasedOnSymbolValue(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .isPointerBasedOnSymbolValue)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn baseSymbol(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .baseSymbol)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn baseSymbolId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .baseSymbolId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn objectFileName(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .objectFileName)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn isAcceleratorGroupSharedLocal(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .isAcceleratorGroupSharedLocal)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isAcceleratorPointerTagLiveRange(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .isAcceleratorPointerTagLiveRange)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isAcceleratorStubFunction(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .isAcceleratorStubFunction)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn numberOfAcceleratorPointerTags(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .numberOfAcceleratorPointerTags)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isSdl(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .isSdl)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isWinRTPointer(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .isWinRTPointer)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isRefUdt(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .isRefUdt)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isValueUdt(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .isValueUdt)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isInterfaceUdt(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .isInterfaceUdt)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn findInlineFramesByAddr(
-            &self,
-            isect: u32,
-            offset: u32,
-        ) -> ::windows_core::Result<IDiaEnumSymbols> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .findInlineFramesByAddr)(
-                ::windows_core::Interface::as_raw(self),
-                isect,
-                offset,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findInlineFramesByRVA(
-            &self,
-            rva: u32,
-        ) -> ::windows_core::Result<IDiaEnumSymbols> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .findInlineFramesByRVA)(
-                ::windows_core::Interface::as_raw(self), rva, &mut result__
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findInlineFramesByVA(
-            &self,
-            va: u64,
-        ) -> ::windows_core::Result<IDiaEnumSymbols> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .findInlineFramesByVA)(
-                ::windows_core::Interface::as_raw(self), va, &mut result__
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findInlineeLines(&self) -> ::windows_core::Result<IDiaEnumLineNumbers> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .findInlineeLines)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findInlineeLinesByAddr(
-            &self,
-            isect: u32,
-            offset: u32,
-            length: u32,
-        ) -> ::windows_core::Result<IDiaEnumLineNumbers> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .findInlineeLinesByAddr)(
-                ::windows_core::Interface::as_raw(self),
-                isect,
-                offset,
-                length,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findInlineeLinesByRVA(
-            &self,
-            rva: u32,
-            length: u32,
-        ) -> ::windows_core::Result<IDiaEnumLineNumbers> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .findInlineeLinesByRVA)(
-                ::windows_core::Interface::as_raw(self),
-                rva,
-                length,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findInlineeLinesByVA(
-            &self,
-            va: u64,
-            length: u32,
-        ) -> ::windows_core::Result<IDiaEnumLineNumbers> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .findInlineeLinesByVA)(
-                ::windows_core::Interface::as_raw(self),
-                va,
-                length,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findSymbolsForAcceleratorPointerTag(
-            &self,
-            tagvalue: u32,
-        ) -> ::windows_core::Result<IDiaEnumSymbols> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .findSymbolsForAcceleratorPointerTag)(
-                ::windows_core::Interface::as_raw(self),
-                tagvalue,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findSymbolsByRVAForAcceleratorPointerTag(
-            &self,
-            tagvalue: u32,
-            rva: u32,
-        ) -> ::windows_core::Result<IDiaEnumSymbols> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .findSymbolsByRVAForAcceleratorPointerTag)(
-                ::windows_core::Interface::as_raw(self),
-                tagvalue,
-                rva,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn get_acceleratorPointerTags(
-            &self,
-            pcnt: *mut u32,
-            ppointertags: &mut [u32],
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .get_acceleratorPointerTags)(
-                ::windows_core::Interface::as_raw(self),
-                ppointertags.len().try_into().unwrap(),
-                pcnt,
-                ::core::mem::transmute(ppointertags.as_ptr()),
-            )
-            .ok()
-        }
-        pub unsafe fn getSrcLineOnTypeDefn(&self) -> ::windows_core::Result<IDiaLineNumber> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .getSrcLineOnTypeDefn)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn isPGO(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .isPGO)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasValidPGOCounts(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasValidPGOCounts)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isOptimizedForSpeed(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .isOptimizedForSpeed)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn PGOEntryCount(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .PGOEntryCount)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn PGOEdgeCount(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .PGOEdgeCount)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn PGODynamicInstructionCount(&self) -> ::windows_core::Result<u64> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .PGODynamicInstructionCount)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn staticSize(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .staticSize)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn finalLiveStaticSize(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .finalLiveStaticSize)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn phaseName(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .phaseName)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn hasControlFlowCheck(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasControlFlowCheck)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn constantExport(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .constantExport)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn dataExport(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .dataExport)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn privateExport(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .privateExport)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn noNameExport(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .noNameExport)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn exportHasExplicitlyAssignedOrdinal(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .exportHasExplicitlyAssignedOrdinal)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn exportIsForwarder(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .exportIsForwarder)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn ordinal(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .ordinal)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn frameSize(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .frameSize)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn exceptionHandlerAddressSection(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .exceptionHandlerAddressSection)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn exceptionHandlerAddressOffset(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .exceptionHandlerAddressOffset)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn exceptionHandlerRelativeVirtualAddress(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .exceptionHandlerRelativeVirtualAddress)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn exceptionHandlerVirtualAddress(&self) -> ::windows_core::Result<u64> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .exceptionHandlerVirtualAddress)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn findInputAssemblyFile(
-            &self,
-        ) -> ::windows_core::Result<IDiaInputAssemblyFile> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .findInputAssemblyFile)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn characteristics(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .characteristics)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn coffGroup(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .coffGroup)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn bindID(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .bindID)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn bindSpace(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .bindSpace)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn bindSlot(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .bindSlot)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isObjCClass(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .isObjCClass)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isObjCCategory(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .isObjCCategory)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isObjCProtocol(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .isObjCProtocol)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn inlinee(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .inlinee)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn inlineeId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .inlineeId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn noexcept(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.noexcept)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn hasAbsoluteAddress(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).hasAbsoluteAddress)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-    }
-    #[repr(C)]
-    pub struct IDiaSymbol5_Vtbl {
-        pub base__: IDiaSymbol4_Vtbl,
-        pub hasAbsoluteAddress: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
-    }
-    ::windows_core::imp::com_interface!(
-        IDiaSymbol6,
-        IDiaSymbol6_Vtbl,
-        0x8133dad3_75fe_4234_ac7e_f8e7a1d3cbb3
-    );
-    ::windows_core::imp::interface_hierarchy!(
-        IDiaSymbol6,
-        ::windows_core::IUnknown,
-        IDiaSymbol,
-        IDiaSymbol2,
-        IDiaSymbol3,
-        IDiaSymbol4,
-        IDiaSymbol5
-    );
-    impl IDiaSymbol6 {
-        pub unsafe fn symIndexId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .symIndexId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn symTag(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .symTag)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn name(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .name)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn lexicalParent(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .lexicalParent)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn classParent(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .classParent)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn r#type(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .r#type)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn dataKind(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .dataKind)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn locationType(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .locationType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn addressSection(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .addressSection)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn addressOffset(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .addressOffset)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn relativeVirtualAddress(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .relativeVirtualAddress)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn virtualAddress(&self) -> ::windows_core::Result<u64> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .virtualAddress)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn registerId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .registerId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn offset(&self) -> ::windows_core::Result<i32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .offset)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn length(&self) -> ::windows_core::Result<u64> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .length)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn slot(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .slot)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn volatileType(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .volatileType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn constType(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .constType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn unalignedType(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .unalignedType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn access(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .access)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn libraryName(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .libraryName)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn platform(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .platform)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn language(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .language)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn editAndContinueEnabled(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .editAndContinueEnabled)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn frontEndMajor(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .frontEndMajor)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn frontEndMinor(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .frontEndMinor)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn frontEndBuild(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .frontEndBuild)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn backEndMajor(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .backEndMajor)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn backEndMinor(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .backEndMinor)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn backEndBuild(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .backEndBuild)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn sourceFileName(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .sourceFileName)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn unused(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .unused)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn thunkOrdinal(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .thunkOrdinal)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn thisAdjust(&self) -> ::windows_core::Result<i32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .thisAdjust)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn virtualBaseOffset(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .virtualBaseOffset)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn r#virtual(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .r#virtual)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn intro(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .intro)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn pure(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .pure)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn callingConvention(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .callingConvention)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn value(&self) -> ::windows_core::Result<::windows_core::VARIANT> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .value)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn baseType(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .baseType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn token(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .token)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn timeStamp(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .timeStamp)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn guid(&self) -> ::windows_core::Result<::windows_core::GUID> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .guid)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn symbolsFileName(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .symbolsFileName)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn reference(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .reference)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn count(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .count)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn bitPosition(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .bitPosition)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn arrayIndexType(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .arrayIndexType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn packed(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .packed)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn constructor(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .constructor)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn overloadedOperator(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .overloadedOperator)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn nested(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .nested)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasNestedTypes(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasNestedTypes)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasAssignmentOperator(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasAssignmentOperator)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn hasCastOperator(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasCastOperator)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn scoped(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .scoped)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn virtualBaseClass(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .virtualBaseClass)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn indirectVirtualBaseClass(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .indirectVirtualBaseClass)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn virtualBasePointerOffset(&self) -> ::windows_core::Result<i32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .virtualBasePointerOffset)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn virtualTableShape(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .virtualTableShape)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn lexicalParentId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .lexicalParentId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn classParentId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .classParentId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn typeId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .typeId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn arrayIndexTypeId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .arrayIndexTypeId)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn virtualTableShapeId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .virtualTableShapeId)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn code(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .code)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn function(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .function)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn managed(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .managed)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn msil(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .msil)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn virtualBaseDispIndex(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .virtualBaseDispIndex)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn undecoratedName(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .undecoratedName)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn age(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .age)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn signature(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .signature)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn compilerGenerated(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .compilerGenerated)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn addressTaken(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .addressTaken)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn rank(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .rank)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn lowerBound(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .lowerBound)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn upperBound(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .upperBound)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn lowerBoundId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .lowerBoundId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn upperBoundId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .upperBoundId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn get_dataBytes(
-            &self,
-            pcbdata: *mut u32,
-            pbdata: &mut [u8],
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .get_dataBytes)(
-                ::windows_core::Interface::as_raw(self),
-                pbdata.len().try_into().unwrap(),
-                pcbdata,
-                ::core::mem::transmute(pbdata.as_ptr()),
-            )
-            .ok()
-        }
-        pub unsafe fn findChildren<P0>(
-            &self,
-            symtag: SymTag,
-            name: P0,
-            compareflags: u32,
-        ) -> ::windows_core::Result<IDiaEnumSymbols>
-        where
-            P0: ::windows_core::IntoParam<::windows_core::PCWSTR>,
-        {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .findChildren)(
-                ::windows_core::Interface::as_raw(self),
-                symtag,
-                name.into_param().abi(),
-                compareflags,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findChildrenEx<P0>(
-            &self,
-            symtag: SymTag,
-            name: P0,
-            compareflags: u32,
-        ) -> ::windows_core::Result<IDiaEnumSymbols>
-        where
-            P0: ::windows_core::IntoParam<::windows_core::PCWSTR>,
-        {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .findChildrenEx)(
-                ::windows_core::Interface::as_raw(self),
-                symtag,
-                name.into_param().abi(),
-                compareflags,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findChildrenExByAddr<P0>(
-            &self,
-            symtag: SymTag,
-            name: P0,
-            compareflags: u32,
-            isect: u32,
-            offset: u32,
-        ) -> ::windows_core::Result<IDiaEnumSymbols>
-        where
-            P0: ::windows_core::IntoParam<::windows_core::PCWSTR>,
-        {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .findChildrenExByAddr)(
-                ::windows_core::Interface::as_raw(self),
-                symtag,
-                name.into_param().abi(),
-                compareflags,
-                isect,
-                offset,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findChildrenExByVA<P0>(
-            &self,
-            symtag: SymTag,
-            name: P0,
-            compareflags: u32,
-            va: u64,
-        ) -> ::windows_core::Result<IDiaEnumSymbols>
-        where
-            P0: ::windows_core::IntoParam<::windows_core::PCWSTR>,
-        {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .findChildrenExByVA)(
-                ::windows_core::Interface::as_raw(self),
-                symtag,
-                name.into_param().abi(),
-                compareflags,
-                va,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findChildrenExByRVA<P0>(
-            &self,
-            symtag: SymTag,
-            name: P0,
-            compareflags: u32,
-            rva: u32,
-        ) -> ::windows_core::Result<IDiaEnumSymbols>
-        where
-            P0: ::windows_core::IntoParam<::windows_core::PCWSTR>,
-        {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .findChildrenExByRVA)(
-                ::windows_core::Interface::as_raw(self),
-                symtag,
-                name.into_param().abi(),
-                compareflags,
-                rva,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn targetSection(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .targetSection)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn targetOffset(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .targetOffset)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn targetRelativeVirtualAddress(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .targetRelativeVirtualAddress)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn targetVirtualAddress(&self) -> ::windows_core::Result<u64> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .targetVirtualAddress)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn machineType(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .machineType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn oemId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .oemId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn oemSymbolId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .oemSymbolId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn get_types(
-            &self,
-            pctypes: *mut u32,
-            ptypes: &mut [::core::option::Option<IDiaSymbol>],
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .get_types)(
-                ::windows_core::Interface::as_raw(self),
-                ptypes.len().try_into().unwrap(),
-                pctypes,
-                ::core::mem::transmute(ptypes.as_ptr()),
-            )
-            .ok()
-        }
-        pub unsafe fn get_typeIds(
-            &self,
-            pctypeids: *mut u32,
-            pdwtypeids: &mut [u32],
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .get_typeIds)(
-                ::windows_core::Interface::as_raw(self),
-                pdwtypeids.len().try_into().unwrap(),
-                pctypeids,
-                ::core::mem::transmute(pdwtypeids.as_ptr()),
-            )
-            .ok()
-        }
-        pub unsafe fn objectPointerType(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .objectPointerType)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn udtKind(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .udtKind)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn get_undecoratedNameEx(
-            &self,
-            undecorateoptions: u32,
-        ) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .get_undecoratedNameEx)(
-                ::windows_core::Interface::as_raw(self),
-                undecorateoptions,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn noReturn(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .noReturn)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn customCallingConvention(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .customCallingConvention)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn noInline(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .noInline)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn optimizedCodeDebugInfo(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .optimizedCodeDebugInfo)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn notReached(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .notReached)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn interruptReturn(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .interruptReturn)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn farReturn(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .farReturn)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isStatic(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isStatic)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasDebugInfo(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasDebugInfo)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isLTCG(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isLTCG)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isDataAligned(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isDataAligned)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasSecurityChecks(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasSecurityChecks)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn compilerName(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .compilerName)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn hasAlloca(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasAlloca)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasSetJump(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasSetJump)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasLongJump(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasLongJump)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasInlAsm(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasInlAsm)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasEH(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasEH)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasSEH(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasSEH)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasEHa(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasEHa)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isNaked(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isNaked)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isAggregated(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isAggregated)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isSplitted(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isSplitted)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn container(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .container)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn inlSpec(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .inlSpec)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn noStackOrdering(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .noStackOrdering)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn virtualBaseTableType(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .virtualBaseTableType)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn hasManagedCode(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasManagedCode)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isHotpatchable(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isHotpatchable)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isCVTCIL(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isCVTCIL)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isMSILNetmodule(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isMSILNetmodule)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isCTypes(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isCTypes)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isStripped(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isStripped)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn frontEndQFE(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .frontEndQFE)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn backEndQFE(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .backEndQFE)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn wasInlined(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .wasInlined)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn strictGSCheck(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .strictGSCheck)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isCxxReturnUdt(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isCxxReturnUdt)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isConstructorVirtualBase(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isConstructorVirtualBase)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn RValueReference(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .RValueReference)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn unmodifiedType(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .unmodifiedType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn framePointerPresent(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .framePointerPresent)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isSafeBuffers(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isSafeBuffers)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn intrinsic(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .intrinsic)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn sealed(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .sealed)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hfaFloat(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hfaFloat)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hfaDouble(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hfaDouble)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn liveRangeStartAddressSection(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .liveRangeStartAddressSection)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn liveRangeStartAddressOffset(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .liveRangeStartAddressOffset)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn liveRangeStartRelativeVirtualAddress(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .liveRangeStartRelativeVirtualAddress)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn countLiveRanges(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .countLiveRanges)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn liveRangeLength(&self) -> ::windows_core::Result<u64> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .liveRangeLength)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn offsetInUdt(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .offsetInUdt)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn paramBasePointerRegisterId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .paramBasePointerRegisterId)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn localBasePointerRegisterId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .localBasePointerRegisterId)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isLocationControlFlowDependent(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isLocationControlFlowDependent)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn stride(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .stride)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn numberOfRows(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .numberOfRows)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn numberOfColumns(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .numberOfColumns)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isMatrixRowMajor(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isMatrixRowMajor)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn get_numericProperties(
-            &self,
-            pcnt: *mut u32,
-            pproperties: &mut [u32],
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .get_numericProperties)(
-                ::windows_core::Interface::as_raw(self),
-                pproperties.len().try_into().unwrap(),
-                pcnt,
-                ::core::mem::transmute(pproperties.as_ptr()),
-            )
-            .ok()
-        }
-        pub unsafe fn get_modifierValues(
-            &self,
-            pcnt: *mut u32,
-            pmodifiers: &mut [u16],
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .get_modifierValues)(
-                ::windows_core::Interface::as_raw(self),
-                pmodifiers.len().try_into().unwrap(),
-                pcnt,
-                ::core::mem::transmute(pmodifiers.as_ptr()),
-            )
-            .ok()
-        }
-        pub unsafe fn isReturnValue(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isReturnValue)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isOptimizedAway(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isOptimizedAway)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn builtInKind(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .builtInKind)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn registerType(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .registerType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn baseDataSlot(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .baseDataSlot)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn baseDataOffset(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .baseDataOffset)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn textureSlot(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .textureSlot)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn samplerSlot(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .samplerSlot)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn uavSlot(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .uavSlot)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn sizeInUdt(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .sizeInUdt)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn memorySpaceKind(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .memorySpaceKind)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn unmodifiedTypeId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .unmodifiedTypeId)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn subTypeId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .subTypeId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn subType(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .subType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn numberOfModifiers(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .numberOfModifiers)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn numberOfRegisterIndices(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .numberOfRegisterIndices)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isHLSLData(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isHLSLData)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isPointerToDataMember(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isPointerToDataMember)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isPointerToMemberFunction(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isPointerToMemberFunction)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isSingleInheritance(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isSingleInheritance)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isMultipleInheritance(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isMultipleInheritance)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isVirtualInheritance(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isVirtualInheritance)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn restrictedType(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .restrictedType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isPointerBasedOnSymbolValue(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isPointerBasedOnSymbolValue)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn baseSymbol(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .baseSymbol)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn baseSymbolId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .baseSymbolId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn objectFileName(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .objectFileName)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn isAcceleratorGroupSharedLocal(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isAcceleratorGroupSharedLocal)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isAcceleratorPointerTagLiveRange(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isAcceleratorPointerTagLiveRange)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isAcceleratorStubFunction(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isAcceleratorStubFunction)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn numberOfAcceleratorPointerTags(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .numberOfAcceleratorPointerTags)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isSdl(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isSdl)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isWinRTPointer(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isWinRTPointer)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isRefUdt(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isRefUdt)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isValueUdt(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isValueUdt)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isInterfaceUdt(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isInterfaceUdt)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn findInlineFramesByAddr(
-            &self,
-            isect: u32,
-            offset: u32,
-        ) -> ::windows_core::Result<IDiaEnumSymbols> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .findInlineFramesByAddr)(
-                ::windows_core::Interface::as_raw(self),
-                isect,
-                offset,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findInlineFramesByRVA(
-            &self,
-            rva: u32,
-        ) -> ::windows_core::Result<IDiaEnumSymbols> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .findInlineFramesByRVA)(
-                ::windows_core::Interface::as_raw(self), rva, &mut result__
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findInlineFramesByVA(
-            &self,
-            va: u64,
-        ) -> ::windows_core::Result<IDiaEnumSymbols> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .findInlineFramesByVA)(
-                ::windows_core::Interface::as_raw(self), va, &mut result__
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findInlineeLines(&self) -> ::windows_core::Result<IDiaEnumLineNumbers> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .findInlineeLines)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findInlineeLinesByAddr(
-            &self,
-            isect: u32,
-            offset: u32,
-            length: u32,
-        ) -> ::windows_core::Result<IDiaEnumLineNumbers> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .findInlineeLinesByAddr)(
-                ::windows_core::Interface::as_raw(self),
-                isect,
-                offset,
-                length,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findInlineeLinesByRVA(
-            &self,
-            rva: u32,
-            length: u32,
-        ) -> ::windows_core::Result<IDiaEnumLineNumbers> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .findInlineeLinesByRVA)(
-                ::windows_core::Interface::as_raw(self),
-                rva,
-                length,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findInlineeLinesByVA(
-            &self,
-            va: u64,
-            length: u32,
-        ) -> ::windows_core::Result<IDiaEnumLineNumbers> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .findInlineeLinesByVA)(
-                ::windows_core::Interface::as_raw(self),
-                va,
-                length,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findSymbolsForAcceleratorPointerTag(
-            &self,
-            tagvalue: u32,
-        ) -> ::windows_core::Result<IDiaEnumSymbols> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .findSymbolsForAcceleratorPointerTag)(
-                ::windows_core::Interface::as_raw(self),
-                tagvalue,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findSymbolsByRVAForAcceleratorPointerTag(
-            &self,
-            tagvalue: u32,
-            rva: u32,
-        ) -> ::windows_core::Result<IDiaEnumSymbols> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .findSymbolsByRVAForAcceleratorPointerTag)(
-                ::windows_core::Interface::as_raw(self),
-                tagvalue,
-                rva,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn get_acceleratorPointerTags(
-            &self,
-            pcnt: *mut u32,
-            ppointertags: &mut [u32],
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .get_acceleratorPointerTags)(
-                ::windows_core::Interface::as_raw(self),
-                ppointertags.len().try_into().unwrap(),
-                pcnt,
-                ::core::mem::transmute(ppointertags.as_ptr()),
-            )
-            .ok()
-        }
-        pub unsafe fn getSrcLineOnTypeDefn(&self) -> ::windows_core::Result<IDiaLineNumber> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .getSrcLineOnTypeDefn)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn isPGO(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isPGO)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasValidPGOCounts(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasValidPGOCounts)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isOptimizedForSpeed(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isOptimizedForSpeed)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn PGOEntryCount(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .PGOEntryCount)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn PGOEdgeCount(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .PGOEdgeCount)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn PGODynamicInstructionCount(&self) -> ::windows_core::Result<u64> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .PGODynamicInstructionCount)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn staticSize(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .staticSize)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn finalLiveStaticSize(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .finalLiveStaticSize)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn phaseName(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .phaseName)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn hasControlFlowCheck(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasControlFlowCheck)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn constantExport(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .constantExport)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn dataExport(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .dataExport)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn privateExport(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .privateExport)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn noNameExport(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .noNameExport)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn exportHasExplicitlyAssignedOrdinal(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .exportHasExplicitlyAssignedOrdinal)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn exportIsForwarder(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .exportIsForwarder)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn ordinal(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .ordinal)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn frameSize(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .frameSize)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn exceptionHandlerAddressSection(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .exceptionHandlerAddressSection)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn exceptionHandlerAddressOffset(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .exceptionHandlerAddressOffset)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn exceptionHandlerRelativeVirtualAddress(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .exceptionHandlerRelativeVirtualAddress)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn exceptionHandlerVirtualAddress(&self) -> ::windows_core::Result<u64> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .exceptionHandlerVirtualAddress)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn findInputAssemblyFile(
-            &self,
-        ) -> ::windows_core::Result<IDiaInputAssemblyFile> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .findInputAssemblyFile)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn characteristics(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .characteristics)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn coffGroup(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .coffGroup)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn bindID(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .bindID)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn bindSpace(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .bindSpace)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn bindSlot(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .bindSlot)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isObjCClass(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .isObjCClass)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isObjCCategory(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .isObjCCategory)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isObjCProtocol(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .isObjCProtocol)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn inlinee(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .inlinee)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn inlineeId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .inlineeId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn noexcept(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .noexcept)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasAbsoluteAddress(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .hasAbsoluteAddress)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isStaticMemberFunc(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).isStaticMemberFunc)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-    }
-    #[repr(C)]
-    pub struct IDiaSymbol6_Vtbl {
-        pub base__: IDiaSymbol5_Vtbl,
-        pub isStaticMemberFunc: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
-    }
-    ::windows_core::imp::com_interface!(
-        IDiaSymbol7,
-        IDiaSymbol7_Vtbl,
-        0x64ce6cd5_7315_4328_86d6_10e303e010b4
-    );
-    ::windows_core::imp::interface_hierarchy!(
-        IDiaSymbol7,
-        ::windows_core::IUnknown,
-        IDiaSymbol,
-        IDiaSymbol2,
-        IDiaSymbol3,
-        IDiaSymbol4,
-        IDiaSymbol5,
-        IDiaSymbol6
-    );
-    impl IDiaSymbol7 {
-        pub unsafe fn symIndexId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .symIndexId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn symTag(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .symTag)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn name(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .name)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn lexicalParent(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .lexicalParent)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn classParent(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .classParent)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn r#type(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .r#type)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn dataKind(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .dataKind)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn locationType(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .locationType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn addressSection(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .addressSection)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn addressOffset(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .addressOffset)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn relativeVirtualAddress(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .relativeVirtualAddress)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn virtualAddress(&self) -> ::windows_core::Result<u64> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .virtualAddress)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn registerId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .registerId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn offset(&self) -> ::windows_core::Result<i32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .offset)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn length(&self) -> ::windows_core::Result<u64> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .length)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn slot(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .slot)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn volatileType(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .volatileType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn constType(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .constType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn unalignedType(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .unalignedType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn access(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .access)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn libraryName(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .libraryName)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn platform(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .platform)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn language(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .language)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn editAndContinueEnabled(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .editAndContinueEnabled)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn frontEndMajor(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .frontEndMajor)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn frontEndMinor(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .frontEndMinor)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn frontEndBuild(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .frontEndBuild)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn backEndMajor(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .backEndMajor)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn backEndMinor(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .backEndMinor)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn backEndBuild(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .backEndBuild)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn sourceFileName(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .sourceFileName)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn unused(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .unused)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn thunkOrdinal(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .thunkOrdinal)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn thisAdjust(&self) -> ::windows_core::Result<i32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .thisAdjust)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn virtualBaseOffset(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .virtualBaseOffset)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn r#virtual(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .r#virtual)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn intro(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .intro)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn pure(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .pure)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn callingConvention(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .callingConvention)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn value(&self) -> ::windows_core::Result<::windows_core::VARIANT> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .value)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn baseType(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .baseType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn token(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .token)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn timeStamp(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .timeStamp)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn guid(&self) -> ::windows_core::Result<::windows_core::GUID> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .guid)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn symbolsFileName(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .symbolsFileName)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn reference(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .reference)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn count(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .count)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn bitPosition(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .bitPosition)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn arrayIndexType(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .arrayIndexType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn packed(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .packed)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn constructor(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .constructor)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn overloadedOperator(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .overloadedOperator)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn nested(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .nested)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasNestedTypes(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasNestedTypes)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasAssignmentOperator(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasAssignmentOperator)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn hasCastOperator(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasCastOperator)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn scoped(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .scoped)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn virtualBaseClass(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .virtualBaseClass)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn indirectVirtualBaseClass(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .indirectVirtualBaseClass)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn virtualBasePointerOffset(&self) -> ::windows_core::Result<i32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .virtualBasePointerOffset)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn virtualTableShape(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .virtualTableShape)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn lexicalParentId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .lexicalParentId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn classParentId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .classParentId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn typeId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .typeId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn arrayIndexTypeId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .arrayIndexTypeId)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn virtualTableShapeId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .virtualTableShapeId)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn code(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .code)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn function(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .function)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn managed(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .managed)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn msil(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .msil)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn virtualBaseDispIndex(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .virtualBaseDispIndex)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn undecoratedName(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .undecoratedName)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn age(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .age)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn signature(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .signature)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn compilerGenerated(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .compilerGenerated)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn addressTaken(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .addressTaken)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn rank(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .rank)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn lowerBound(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .lowerBound)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn upperBound(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .upperBound)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn lowerBoundId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .lowerBoundId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn upperBoundId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .upperBoundId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn get_dataBytes(
-            &self,
-            pcbdata: *mut u32,
-            pbdata: &mut [u8],
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .get_dataBytes)(
-                ::windows_core::Interface::as_raw(self),
-                pbdata.len().try_into().unwrap(),
-                pcbdata,
-                ::core::mem::transmute(pbdata.as_ptr()),
-            )
-            .ok()
-        }
-        pub unsafe fn findChildren<P0>(
-            &self,
-            symtag: SymTag,
-            name: P0,
-            compareflags: u32,
-        ) -> ::windows_core::Result<IDiaEnumSymbols>
-        where
-            P0: ::windows_core::IntoParam<::windows_core::PCWSTR>,
-        {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .findChildren)(
-                ::windows_core::Interface::as_raw(self),
-                symtag,
-                name.into_param().abi(),
-                compareflags,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findChildrenEx<P0>(
-            &self,
-            symtag: SymTag,
-            name: P0,
-            compareflags: u32,
-        ) -> ::windows_core::Result<IDiaEnumSymbols>
-        where
-            P0: ::windows_core::IntoParam<::windows_core::PCWSTR>,
-        {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .findChildrenEx)(
-                ::windows_core::Interface::as_raw(self),
-                symtag,
-                name.into_param().abi(),
-                compareflags,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findChildrenExByAddr<P0>(
-            &self,
-            symtag: SymTag,
-            name: P0,
-            compareflags: u32,
-            isect: u32,
-            offset: u32,
-        ) -> ::windows_core::Result<IDiaEnumSymbols>
-        where
-            P0: ::windows_core::IntoParam<::windows_core::PCWSTR>,
-        {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .findChildrenExByAddr)(
-                ::windows_core::Interface::as_raw(self),
-                symtag,
-                name.into_param().abi(),
-                compareflags,
-                isect,
-                offset,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findChildrenExByVA<P0>(
-            &self,
-            symtag: SymTag,
-            name: P0,
-            compareflags: u32,
-            va: u64,
-        ) -> ::windows_core::Result<IDiaEnumSymbols>
-        where
-            P0: ::windows_core::IntoParam<::windows_core::PCWSTR>,
-        {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .findChildrenExByVA)(
-                ::windows_core::Interface::as_raw(self),
-                symtag,
-                name.into_param().abi(),
-                compareflags,
-                va,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findChildrenExByRVA<P0>(
-            &self,
-            symtag: SymTag,
-            name: P0,
-            compareflags: u32,
-            rva: u32,
-        ) -> ::windows_core::Result<IDiaEnumSymbols>
-        where
-            P0: ::windows_core::IntoParam<::windows_core::PCWSTR>,
-        {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .findChildrenExByRVA)(
-                ::windows_core::Interface::as_raw(self),
-                symtag,
-                name.into_param().abi(),
-                compareflags,
-                rva,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn targetSection(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .targetSection)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn targetOffset(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .targetOffset)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn targetRelativeVirtualAddress(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .targetRelativeVirtualAddress)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn targetVirtualAddress(&self) -> ::windows_core::Result<u64> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .targetVirtualAddress)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn machineType(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .machineType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn oemId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .oemId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn oemSymbolId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .oemSymbolId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn get_types(
-            &self,
-            pctypes: *mut u32,
-            ptypes: &mut [::core::option::Option<IDiaSymbol>],
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .get_types)(
-                ::windows_core::Interface::as_raw(self),
-                ptypes.len().try_into().unwrap(),
-                pctypes,
-                ::core::mem::transmute(ptypes.as_ptr()),
-            )
-            .ok()
-        }
-        pub unsafe fn get_typeIds(
-            &self,
-            pctypeids: *mut u32,
-            pdwtypeids: &mut [u32],
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .get_typeIds)(
-                ::windows_core::Interface::as_raw(self),
-                pdwtypeids.len().try_into().unwrap(),
-                pctypeids,
-                ::core::mem::transmute(pdwtypeids.as_ptr()),
-            )
-            .ok()
-        }
-        pub unsafe fn objectPointerType(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .objectPointerType)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn udtKind(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .udtKind)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn get_undecoratedNameEx(
-            &self,
-            undecorateoptions: u32,
-        ) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .get_undecoratedNameEx)(
-                ::windows_core::Interface::as_raw(self),
-                undecorateoptions,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn noReturn(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .noReturn)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn customCallingConvention(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .customCallingConvention)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn noInline(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .noInline)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn optimizedCodeDebugInfo(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .optimizedCodeDebugInfo)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn notReached(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .notReached)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn interruptReturn(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .interruptReturn)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn farReturn(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .farReturn)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isStatic(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isStatic)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasDebugInfo(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasDebugInfo)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isLTCG(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isLTCG)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isDataAligned(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isDataAligned)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasSecurityChecks(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasSecurityChecks)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn compilerName(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .compilerName)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn hasAlloca(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasAlloca)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasSetJump(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasSetJump)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasLongJump(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasLongJump)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasInlAsm(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasInlAsm)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasEH(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasEH)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasSEH(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasSEH)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasEHa(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasEHa)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isNaked(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isNaked)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isAggregated(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isAggregated)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isSplitted(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isSplitted)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn container(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .container)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn inlSpec(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .inlSpec)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn noStackOrdering(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .noStackOrdering)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn virtualBaseTableType(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .virtualBaseTableType)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn hasManagedCode(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasManagedCode)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isHotpatchable(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isHotpatchable)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isCVTCIL(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isCVTCIL)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isMSILNetmodule(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isMSILNetmodule)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isCTypes(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isCTypes)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isStripped(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isStripped)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn frontEndQFE(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .frontEndQFE)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn backEndQFE(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .backEndQFE)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn wasInlined(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .wasInlined)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn strictGSCheck(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .strictGSCheck)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isCxxReturnUdt(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isCxxReturnUdt)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isConstructorVirtualBase(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isConstructorVirtualBase)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn RValueReference(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .RValueReference)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn unmodifiedType(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .unmodifiedType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn framePointerPresent(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .framePointerPresent)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isSafeBuffers(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isSafeBuffers)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn intrinsic(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .intrinsic)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn sealed(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .sealed)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hfaFloat(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hfaFloat)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hfaDouble(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hfaDouble)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn liveRangeStartAddressSection(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .liveRangeStartAddressSection)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn liveRangeStartAddressOffset(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .liveRangeStartAddressOffset)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn liveRangeStartRelativeVirtualAddress(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .liveRangeStartRelativeVirtualAddress)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn countLiveRanges(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .countLiveRanges)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn liveRangeLength(&self) -> ::windows_core::Result<u64> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .liveRangeLength)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn offsetInUdt(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .offsetInUdt)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn paramBasePointerRegisterId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .paramBasePointerRegisterId)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn localBasePointerRegisterId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .localBasePointerRegisterId)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isLocationControlFlowDependent(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isLocationControlFlowDependent)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn stride(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .stride)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn numberOfRows(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .numberOfRows)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn numberOfColumns(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .numberOfColumns)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isMatrixRowMajor(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isMatrixRowMajor)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn get_numericProperties(
-            &self,
-            pcnt: *mut u32,
-            pproperties: &mut [u32],
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .get_numericProperties)(
-                ::windows_core::Interface::as_raw(self),
-                pproperties.len().try_into().unwrap(),
-                pcnt,
-                ::core::mem::transmute(pproperties.as_ptr()),
-            )
-            .ok()
-        }
-        pub unsafe fn get_modifierValues(
-            &self,
-            pcnt: *mut u32,
-            pmodifiers: &mut [u16],
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .get_modifierValues)(
-                ::windows_core::Interface::as_raw(self),
-                pmodifiers.len().try_into().unwrap(),
-                pcnt,
-                ::core::mem::transmute(pmodifiers.as_ptr()),
-            )
-            .ok()
-        }
-        pub unsafe fn isReturnValue(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isReturnValue)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isOptimizedAway(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isOptimizedAway)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn builtInKind(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .builtInKind)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn registerType(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .registerType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn baseDataSlot(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .baseDataSlot)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn baseDataOffset(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .baseDataOffset)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn textureSlot(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .textureSlot)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn samplerSlot(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .samplerSlot)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn uavSlot(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .uavSlot)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn sizeInUdt(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .sizeInUdt)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn memorySpaceKind(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .memorySpaceKind)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn unmodifiedTypeId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .unmodifiedTypeId)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn subTypeId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .subTypeId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn subType(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .subType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn numberOfModifiers(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .numberOfModifiers)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn numberOfRegisterIndices(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .numberOfRegisterIndices)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isHLSLData(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isHLSLData)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isPointerToDataMember(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isPointerToDataMember)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isPointerToMemberFunction(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isPointerToMemberFunction)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isSingleInheritance(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isSingleInheritance)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isMultipleInheritance(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isMultipleInheritance)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isVirtualInheritance(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isVirtualInheritance)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn restrictedType(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .restrictedType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isPointerBasedOnSymbolValue(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isPointerBasedOnSymbolValue)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn baseSymbol(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .baseSymbol)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn baseSymbolId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .baseSymbolId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn objectFileName(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .objectFileName)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn isAcceleratorGroupSharedLocal(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isAcceleratorGroupSharedLocal)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isAcceleratorPointerTagLiveRange(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isAcceleratorPointerTagLiveRange)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isAcceleratorStubFunction(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isAcceleratorStubFunction)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn numberOfAcceleratorPointerTags(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .numberOfAcceleratorPointerTags)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isSdl(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isSdl)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isWinRTPointer(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isWinRTPointer)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isRefUdt(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isRefUdt)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isValueUdt(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isValueUdt)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isInterfaceUdt(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isInterfaceUdt)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn findInlineFramesByAddr(
-            &self,
-            isect: u32,
-            offset: u32,
-        ) -> ::windows_core::Result<IDiaEnumSymbols> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .findInlineFramesByAddr)(
-                ::windows_core::Interface::as_raw(self),
-                isect,
-                offset,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findInlineFramesByRVA(
-            &self,
-            rva: u32,
-        ) -> ::windows_core::Result<IDiaEnumSymbols> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .findInlineFramesByRVA)(
-                ::windows_core::Interface::as_raw(self), rva, &mut result__
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findInlineFramesByVA(
-            &self,
-            va: u64,
-        ) -> ::windows_core::Result<IDiaEnumSymbols> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .findInlineFramesByVA)(
-                ::windows_core::Interface::as_raw(self), va, &mut result__
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findInlineeLines(&self) -> ::windows_core::Result<IDiaEnumLineNumbers> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .findInlineeLines)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findInlineeLinesByAddr(
-            &self,
-            isect: u32,
-            offset: u32,
-            length: u32,
-        ) -> ::windows_core::Result<IDiaEnumLineNumbers> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .findInlineeLinesByAddr)(
-                ::windows_core::Interface::as_raw(self),
-                isect,
-                offset,
-                length,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findInlineeLinesByRVA(
-            &self,
-            rva: u32,
-            length: u32,
-        ) -> ::windows_core::Result<IDiaEnumLineNumbers> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .findInlineeLinesByRVA)(
-                ::windows_core::Interface::as_raw(self),
-                rva,
-                length,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findInlineeLinesByVA(
-            &self,
-            va: u64,
-            length: u32,
-        ) -> ::windows_core::Result<IDiaEnumLineNumbers> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .findInlineeLinesByVA)(
-                ::windows_core::Interface::as_raw(self),
-                va,
-                length,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findSymbolsForAcceleratorPointerTag(
-            &self,
-            tagvalue: u32,
-        ) -> ::windows_core::Result<IDiaEnumSymbols> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .findSymbolsForAcceleratorPointerTag)(
-                ::windows_core::Interface::as_raw(self),
-                tagvalue,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findSymbolsByRVAForAcceleratorPointerTag(
-            &self,
-            tagvalue: u32,
-            rva: u32,
-        ) -> ::windows_core::Result<IDiaEnumSymbols> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .findSymbolsByRVAForAcceleratorPointerTag)(
-                ::windows_core::Interface::as_raw(self),
-                tagvalue,
-                rva,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn get_acceleratorPointerTags(
-            &self,
-            pcnt: *mut u32,
-            ppointertags: &mut [u32],
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .get_acceleratorPointerTags)(
-                ::windows_core::Interface::as_raw(self),
-                ppointertags.len().try_into().unwrap(),
-                pcnt,
-                ::core::mem::transmute(ppointertags.as_ptr()),
-            )
-            .ok()
-        }
-        pub unsafe fn getSrcLineOnTypeDefn(&self) -> ::windows_core::Result<IDiaLineNumber> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .getSrcLineOnTypeDefn)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn isPGO(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isPGO)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasValidPGOCounts(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasValidPGOCounts)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isOptimizedForSpeed(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isOptimizedForSpeed)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn PGOEntryCount(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .PGOEntryCount)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn PGOEdgeCount(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .PGOEdgeCount)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn PGODynamicInstructionCount(&self) -> ::windows_core::Result<u64> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .PGODynamicInstructionCount)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn staticSize(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .staticSize)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn finalLiveStaticSize(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .finalLiveStaticSize)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn phaseName(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .phaseName)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn hasControlFlowCheck(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasControlFlowCheck)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn constantExport(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .constantExport)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn dataExport(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .dataExport)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn privateExport(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .privateExport)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn noNameExport(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .noNameExport)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn exportHasExplicitlyAssignedOrdinal(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .exportHasExplicitlyAssignedOrdinal)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn exportIsForwarder(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .exportIsForwarder)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn ordinal(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .ordinal)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn frameSize(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .frameSize)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn exceptionHandlerAddressSection(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .exceptionHandlerAddressSection)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn exceptionHandlerAddressOffset(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .exceptionHandlerAddressOffset)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn exceptionHandlerRelativeVirtualAddress(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .exceptionHandlerRelativeVirtualAddress)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn exceptionHandlerVirtualAddress(&self) -> ::windows_core::Result<u64> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .exceptionHandlerVirtualAddress)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn findInputAssemblyFile(
-            &self,
-        ) -> ::windows_core::Result<IDiaInputAssemblyFile> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .findInputAssemblyFile)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn characteristics(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .characteristics)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn coffGroup(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .coffGroup)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn bindID(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .bindID)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn bindSpace(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .bindSpace)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn bindSlot(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .bindSlot)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isObjCClass(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isObjCClass)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isObjCCategory(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isObjCCategory)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isObjCProtocol(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isObjCProtocol)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn inlinee(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .inlinee)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn inlineeId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .inlineeId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn noexcept(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .noexcept)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasAbsoluteAddress(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .hasAbsoluteAddress)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isStaticMemberFunc(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .isStaticMemberFunc)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isSignRet(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).isSignRet)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-    }
-    #[repr(C)]
-    pub struct IDiaSymbol7_Vtbl {
-        pub base__: IDiaSymbol6_Vtbl,
-        pub isSignRet: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
-    }
-    ::windows_core::imp::com_interface!(
-        IDiaSymbol8,
-        IDiaSymbol8_Vtbl,
-        0x7f2e041f_1294_41bd_b83a_e715972d2ce3
-    );
-    ::windows_core::imp::interface_hierarchy!(
-        IDiaSymbol8,
-        ::windows_core::IUnknown,
-        IDiaSymbol,
-        IDiaSymbol2,
-        IDiaSymbol3,
-        IDiaSymbol4,
-        IDiaSymbol5,
-        IDiaSymbol6,
-        IDiaSymbol7
-    );
-    impl IDiaSymbol8 {
-        pub unsafe fn symIndexId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .symIndexId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn symTag(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .symTag)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn name(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .name)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn lexicalParent(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .lexicalParent)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn classParent(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .classParent)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn r#type(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .r#type)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn dataKind(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .dataKind)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn locationType(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .locationType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn addressSection(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .addressSection)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn addressOffset(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .addressOffset)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn relativeVirtualAddress(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .relativeVirtualAddress)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn virtualAddress(&self) -> ::windows_core::Result<u64> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .virtualAddress)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn registerId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .registerId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn offset(&self) -> ::windows_core::Result<i32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .offset)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn length(&self) -> ::windows_core::Result<u64> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .length)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn slot(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .slot)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn volatileType(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .volatileType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn constType(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .constType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn unalignedType(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .unalignedType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn access(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .access)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn libraryName(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .libraryName)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn platform(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .platform)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn language(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .language)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn editAndContinueEnabled(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .editAndContinueEnabled)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn frontEndMajor(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .frontEndMajor)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn frontEndMinor(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .frontEndMinor)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn frontEndBuild(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .frontEndBuild)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn backEndMajor(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .backEndMajor)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn backEndMinor(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .backEndMinor)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn backEndBuild(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .backEndBuild)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn sourceFileName(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .sourceFileName)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn unused(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .unused)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn thunkOrdinal(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .thunkOrdinal)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn thisAdjust(&self) -> ::windows_core::Result<i32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .thisAdjust)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn virtualBaseOffset(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .virtualBaseOffset)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn r#virtual(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .r#virtual)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn intro(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .intro)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn pure(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .pure)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn callingConvention(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .callingConvention)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn value(&self) -> ::windows_core::Result<::windows_core::VARIANT> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .value)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn baseType(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .baseType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn token(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .token)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn timeStamp(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .timeStamp)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn guid(&self) -> ::windows_core::Result<::windows_core::GUID> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .guid)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn symbolsFileName(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .symbolsFileName)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn reference(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .reference)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn count(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .count)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn bitPosition(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .bitPosition)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn arrayIndexType(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .arrayIndexType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn packed(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .packed)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn constructor(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .constructor)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn overloadedOperator(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .overloadedOperator)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn nested(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .nested)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasNestedTypes(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasNestedTypes)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasAssignmentOperator(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasAssignmentOperator)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn hasCastOperator(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasCastOperator)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn scoped(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .scoped)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn virtualBaseClass(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .virtualBaseClass)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn indirectVirtualBaseClass(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .indirectVirtualBaseClass)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn virtualBasePointerOffset(&self) -> ::windows_core::Result<i32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .virtualBasePointerOffset)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn virtualTableShape(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .virtualTableShape)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn lexicalParentId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .lexicalParentId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn classParentId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .classParentId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn typeId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .typeId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn arrayIndexTypeId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .arrayIndexTypeId)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn virtualTableShapeId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .virtualTableShapeId)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn code(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .code)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn function(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .function)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn managed(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .managed)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn msil(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .msil)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn virtualBaseDispIndex(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .virtualBaseDispIndex)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn undecoratedName(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .undecoratedName)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn age(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .age)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn signature(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .signature)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn compilerGenerated(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .compilerGenerated)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn addressTaken(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .addressTaken)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn rank(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .rank)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn lowerBound(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .lowerBound)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn upperBound(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .upperBound)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn lowerBoundId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .lowerBoundId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn upperBoundId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .upperBoundId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn get_dataBytes(
-            &self,
-            pcbdata: *mut u32,
-            pbdata: &mut [u8],
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .get_dataBytes)(
-                ::windows_core::Interface::as_raw(self),
-                pbdata.len().try_into().unwrap(),
-                pcbdata,
-                ::core::mem::transmute(pbdata.as_ptr()),
-            )
-            .ok()
-        }
-        pub unsafe fn findChildren<P0>(
-            &self,
-            symtag: SymTag,
-            name: P0,
-            compareflags: u32,
-        ) -> ::windows_core::Result<IDiaEnumSymbols>
-        where
-            P0: ::windows_core::IntoParam<::windows_core::PCWSTR>,
-        {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .findChildren)(
-                ::windows_core::Interface::as_raw(self),
-                symtag,
-                name.into_param().abi(),
-                compareflags,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findChildrenEx<P0>(
-            &self,
-            symtag: SymTag,
-            name: P0,
-            compareflags: u32,
-        ) -> ::windows_core::Result<IDiaEnumSymbols>
-        where
-            P0: ::windows_core::IntoParam<::windows_core::PCWSTR>,
-        {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .findChildrenEx)(
-                ::windows_core::Interface::as_raw(self),
-                symtag,
-                name.into_param().abi(),
-                compareflags,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findChildrenExByAddr<P0>(
-            &self,
-            symtag: SymTag,
-            name: P0,
-            compareflags: u32,
-            isect: u32,
-            offset: u32,
-        ) -> ::windows_core::Result<IDiaEnumSymbols>
-        where
-            P0: ::windows_core::IntoParam<::windows_core::PCWSTR>,
-        {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .findChildrenExByAddr)(
-                ::windows_core::Interface::as_raw(self),
-                symtag,
-                name.into_param().abi(),
-                compareflags,
-                isect,
-                offset,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findChildrenExByVA<P0>(
-            &self,
-            symtag: SymTag,
-            name: P0,
-            compareflags: u32,
-            va: u64,
-        ) -> ::windows_core::Result<IDiaEnumSymbols>
-        where
-            P0: ::windows_core::IntoParam<::windows_core::PCWSTR>,
-        {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .findChildrenExByVA)(
-                ::windows_core::Interface::as_raw(self),
-                symtag,
-                name.into_param().abi(),
-                compareflags,
-                va,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findChildrenExByRVA<P0>(
-            &self,
-            symtag: SymTag,
-            name: P0,
-            compareflags: u32,
-            rva: u32,
-        ) -> ::windows_core::Result<IDiaEnumSymbols>
-        where
-            P0: ::windows_core::IntoParam<::windows_core::PCWSTR>,
-        {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .findChildrenExByRVA)(
-                ::windows_core::Interface::as_raw(self),
-                symtag,
-                name.into_param().abi(),
-                compareflags,
-                rva,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn targetSection(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .targetSection)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn targetOffset(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .targetOffset)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn targetRelativeVirtualAddress(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .targetRelativeVirtualAddress)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn targetVirtualAddress(&self) -> ::windows_core::Result<u64> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .targetVirtualAddress)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn machineType(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .machineType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn oemId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .oemId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn oemSymbolId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .oemSymbolId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn get_types(
-            &self,
-            pctypes: *mut u32,
-            ptypes: &mut [::core::option::Option<IDiaSymbol>],
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .get_types)(
-                ::windows_core::Interface::as_raw(self),
-                ptypes.len().try_into().unwrap(),
-                pctypes,
-                ::core::mem::transmute(ptypes.as_ptr()),
-            )
-            .ok()
-        }
-        pub unsafe fn get_typeIds(
-            &self,
-            pctypeids: *mut u32,
-            pdwtypeids: &mut [u32],
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .get_typeIds)(
-                ::windows_core::Interface::as_raw(self),
-                pdwtypeids.len().try_into().unwrap(),
-                pctypeids,
-                ::core::mem::transmute(pdwtypeids.as_ptr()),
-            )
-            .ok()
-        }
-        pub unsafe fn objectPointerType(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .objectPointerType)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn udtKind(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .udtKind)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn get_undecoratedNameEx(
-            &self,
-            undecorateoptions: u32,
-        ) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .get_undecoratedNameEx)(
-                ::windows_core::Interface::as_raw(self),
-                undecorateoptions,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn noReturn(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .noReturn)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn customCallingConvention(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .customCallingConvention)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn noInline(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .noInline)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn optimizedCodeDebugInfo(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .optimizedCodeDebugInfo)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn notReached(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .notReached)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn interruptReturn(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .interruptReturn)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn farReturn(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .farReturn)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isStatic(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isStatic)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasDebugInfo(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasDebugInfo)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isLTCG(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isLTCG)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isDataAligned(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isDataAligned)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasSecurityChecks(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasSecurityChecks)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn compilerName(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .compilerName)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn hasAlloca(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasAlloca)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasSetJump(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasSetJump)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasLongJump(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasLongJump)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasInlAsm(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasInlAsm)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasEH(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasEH)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasSEH(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasSEH)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasEHa(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasEHa)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isNaked(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isNaked)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isAggregated(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isAggregated)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isSplitted(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isSplitted)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn container(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .container)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn inlSpec(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .inlSpec)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn noStackOrdering(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .noStackOrdering)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn virtualBaseTableType(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .virtualBaseTableType)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn hasManagedCode(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasManagedCode)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isHotpatchable(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isHotpatchable)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isCVTCIL(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isCVTCIL)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isMSILNetmodule(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isMSILNetmodule)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isCTypes(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isCTypes)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isStripped(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isStripped)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn frontEndQFE(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .frontEndQFE)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn backEndQFE(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .backEndQFE)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn wasInlined(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .wasInlined)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn strictGSCheck(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .strictGSCheck)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isCxxReturnUdt(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isCxxReturnUdt)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isConstructorVirtualBase(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isConstructorVirtualBase)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn RValueReference(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .RValueReference)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn unmodifiedType(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .unmodifiedType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn framePointerPresent(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .framePointerPresent)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isSafeBuffers(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isSafeBuffers)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn intrinsic(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .intrinsic)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn sealed(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .sealed)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hfaFloat(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hfaFloat)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hfaDouble(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hfaDouble)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn liveRangeStartAddressSection(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .liveRangeStartAddressSection)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn liveRangeStartAddressOffset(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .liveRangeStartAddressOffset)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn liveRangeStartRelativeVirtualAddress(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .liveRangeStartRelativeVirtualAddress)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn countLiveRanges(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .countLiveRanges)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn liveRangeLength(&self) -> ::windows_core::Result<u64> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .liveRangeLength)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn offsetInUdt(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .offsetInUdt)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn paramBasePointerRegisterId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .paramBasePointerRegisterId)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn localBasePointerRegisterId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .localBasePointerRegisterId)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isLocationControlFlowDependent(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isLocationControlFlowDependent)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn stride(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .stride)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn numberOfRows(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .numberOfRows)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn numberOfColumns(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .numberOfColumns)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isMatrixRowMajor(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isMatrixRowMajor)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn get_numericProperties(
-            &self,
-            pcnt: *mut u32,
-            pproperties: &mut [u32],
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .get_numericProperties)(
-                ::windows_core::Interface::as_raw(self),
-                pproperties.len().try_into().unwrap(),
-                pcnt,
-                ::core::mem::transmute(pproperties.as_ptr()),
-            )
-            .ok()
-        }
-        pub unsafe fn get_modifierValues(
-            &self,
-            pcnt: *mut u32,
-            pmodifiers: &mut [u16],
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .get_modifierValues)(
-                ::windows_core::Interface::as_raw(self),
-                pmodifiers.len().try_into().unwrap(),
-                pcnt,
-                ::core::mem::transmute(pmodifiers.as_ptr()),
-            )
-            .ok()
-        }
-        pub unsafe fn isReturnValue(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isReturnValue)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isOptimizedAway(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isOptimizedAway)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn builtInKind(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .builtInKind)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn registerType(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .registerType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn baseDataSlot(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .baseDataSlot)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn baseDataOffset(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .baseDataOffset)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn textureSlot(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .textureSlot)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn samplerSlot(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .samplerSlot)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn uavSlot(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .uavSlot)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn sizeInUdt(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .sizeInUdt)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn memorySpaceKind(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .memorySpaceKind)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn unmodifiedTypeId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .unmodifiedTypeId)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn subTypeId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .subTypeId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn subType(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .subType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn numberOfModifiers(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .numberOfModifiers)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn numberOfRegisterIndices(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .numberOfRegisterIndices)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isHLSLData(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isHLSLData)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isPointerToDataMember(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isPointerToDataMember)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isPointerToMemberFunction(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isPointerToMemberFunction)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isSingleInheritance(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isSingleInheritance)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isMultipleInheritance(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isMultipleInheritance)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isVirtualInheritance(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isVirtualInheritance)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn restrictedType(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .restrictedType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isPointerBasedOnSymbolValue(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isPointerBasedOnSymbolValue)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn baseSymbol(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .baseSymbol)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn baseSymbolId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .baseSymbolId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn objectFileName(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .objectFileName)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn isAcceleratorGroupSharedLocal(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isAcceleratorGroupSharedLocal)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isAcceleratorPointerTagLiveRange(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isAcceleratorPointerTagLiveRange)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isAcceleratorStubFunction(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isAcceleratorStubFunction)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn numberOfAcceleratorPointerTags(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .numberOfAcceleratorPointerTags)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isSdl(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isSdl)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isWinRTPointer(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isWinRTPointer)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isRefUdt(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isRefUdt)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isValueUdt(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isValueUdt)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isInterfaceUdt(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isInterfaceUdt)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn findInlineFramesByAddr(
-            &self,
-            isect: u32,
-            offset: u32,
-        ) -> ::windows_core::Result<IDiaEnumSymbols> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .findInlineFramesByAddr)(
-                ::windows_core::Interface::as_raw(self),
-                isect,
-                offset,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findInlineFramesByRVA(
-            &self,
-            rva: u32,
-        ) -> ::windows_core::Result<IDiaEnumSymbols> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .findInlineFramesByRVA)(
-                ::windows_core::Interface::as_raw(self), rva, &mut result__
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findInlineFramesByVA(
-            &self,
-            va: u64,
-        ) -> ::windows_core::Result<IDiaEnumSymbols> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .findInlineFramesByVA)(
-                ::windows_core::Interface::as_raw(self), va, &mut result__
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findInlineeLines(&self) -> ::windows_core::Result<IDiaEnumLineNumbers> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .findInlineeLines)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findInlineeLinesByAddr(
-            &self,
-            isect: u32,
-            offset: u32,
-            length: u32,
-        ) -> ::windows_core::Result<IDiaEnumLineNumbers> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .findInlineeLinesByAddr)(
-                ::windows_core::Interface::as_raw(self),
-                isect,
-                offset,
-                length,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findInlineeLinesByRVA(
-            &self,
-            rva: u32,
-            length: u32,
-        ) -> ::windows_core::Result<IDiaEnumLineNumbers> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .findInlineeLinesByRVA)(
-                ::windows_core::Interface::as_raw(self),
-                rva,
-                length,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findInlineeLinesByVA(
-            &self,
-            va: u64,
-            length: u32,
-        ) -> ::windows_core::Result<IDiaEnumLineNumbers> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .findInlineeLinesByVA)(
-                ::windows_core::Interface::as_raw(self),
-                va,
-                length,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findSymbolsForAcceleratorPointerTag(
-            &self,
-            tagvalue: u32,
-        ) -> ::windows_core::Result<IDiaEnumSymbols> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .findSymbolsForAcceleratorPointerTag)(
-                ::windows_core::Interface::as_raw(self),
-                tagvalue,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findSymbolsByRVAForAcceleratorPointerTag(
-            &self,
-            tagvalue: u32,
-            rva: u32,
-        ) -> ::windows_core::Result<IDiaEnumSymbols> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .findSymbolsByRVAForAcceleratorPointerTag)(
-                ::windows_core::Interface::as_raw(self),
-                tagvalue,
-                rva,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn get_acceleratorPointerTags(
-            &self,
-            pcnt: *mut u32,
-            ppointertags: &mut [u32],
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .get_acceleratorPointerTags)(
-                ::windows_core::Interface::as_raw(self),
-                ppointertags.len().try_into().unwrap(),
-                pcnt,
-                ::core::mem::transmute(ppointertags.as_ptr()),
-            )
-            .ok()
-        }
-        pub unsafe fn getSrcLineOnTypeDefn(&self) -> ::windows_core::Result<IDiaLineNumber> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .getSrcLineOnTypeDefn)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn isPGO(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isPGO)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasValidPGOCounts(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasValidPGOCounts)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isOptimizedForSpeed(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isOptimizedForSpeed)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn PGOEntryCount(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .PGOEntryCount)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn PGOEdgeCount(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .PGOEdgeCount)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn PGODynamicInstructionCount(&self) -> ::windows_core::Result<u64> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .PGODynamicInstructionCount)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn staticSize(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .staticSize)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn finalLiveStaticSize(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .finalLiveStaticSize)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn phaseName(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .phaseName)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn hasControlFlowCheck(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasControlFlowCheck)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn constantExport(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .constantExport)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn dataExport(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .dataExport)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn privateExport(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .privateExport)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn noNameExport(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .noNameExport)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn exportHasExplicitlyAssignedOrdinal(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .exportHasExplicitlyAssignedOrdinal)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn exportIsForwarder(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .exportIsForwarder)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn ordinal(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .ordinal)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn frameSize(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .frameSize)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn exceptionHandlerAddressSection(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .exceptionHandlerAddressSection)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn exceptionHandlerAddressOffset(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .exceptionHandlerAddressOffset)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn exceptionHandlerRelativeVirtualAddress(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .exceptionHandlerRelativeVirtualAddress)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn exceptionHandlerVirtualAddress(&self) -> ::windows_core::Result<u64> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .exceptionHandlerVirtualAddress)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn findInputAssemblyFile(
-            &self,
-        ) -> ::windows_core::Result<IDiaInputAssemblyFile> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .findInputAssemblyFile)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn characteristics(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .characteristics)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn coffGroup(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .coffGroup)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn bindID(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .bindID)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn bindSpace(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .bindSpace)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn bindSlot(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .bindSlot)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isObjCClass(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isObjCClass)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isObjCCategory(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isObjCCategory)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isObjCProtocol(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isObjCProtocol)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn inlinee(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .inlinee)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn inlineeId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .inlineeId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn noexcept(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .noexcept)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasAbsoluteAddress(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .hasAbsoluteAddress)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isStaticMemberFunc(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .isStaticMemberFunc)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isSignRet(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.isSignRet)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn coroutineKind(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).coroutineKind)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn associatedSymbolKind(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).associatedSymbolKind)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn associatedSymbolSection(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).associatedSymbolSection)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn associatedSymbolOffset(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).associatedSymbolOffset)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn associatedSymbolRva(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).associatedSymbolRva)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn associatedSymbolAddr(&self) -> ::windows_core::Result<u64> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).associatedSymbolAddr)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-    }
-    #[repr(C)]
-    pub struct IDiaSymbol8_Vtbl {
-        pub base__: IDiaSymbol7_Vtbl,
-        pub coroutineKind: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub associatedSymbolKind: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub associatedSymbolSection: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub associatedSymbolOffset: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub associatedSymbolRva: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub associatedSymbolAddr: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u64,
-        ) -> ::windows_core::HRESULT,
-    }
-    ::windows_core::imp::com_interface!(
-        IDiaSymbol9,
-        IDiaSymbol9_Vtbl,
-        0xa89e5969_92a1_4f8a_b704_00121c37abbb
-    );
-    ::windows_core::imp::interface_hierarchy!(
-        IDiaSymbol9,
-        ::windows_core::IUnknown,
-        IDiaSymbol,
-        IDiaSymbol2,
-        IDiaSymbol3,
-        IDiaSymbol4,
-        IDiaSymbol5,
-        IDiaSymbol6,
-        IDiaSymbol7,
-        IDiaSymbol8
-    );
-    impl IDiaSymbol9 {
-        pub unsafe fn symIndexId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .symIndexId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn symTag(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .symTag)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn name(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .name)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn lexicalParent(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .lexicalParent)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn classParent(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .classParent)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn r#type(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .r#type)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn dataKind(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .dataKind)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn locationType(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .locationType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn addressSection(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .addressSection)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn addressOffset(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .addressOffset)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn relativeVirtualAddress(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .relativeVirtualAddress)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn virtualAddress(&self) -> ::windows_core::Result<u64> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .virtualAddress)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn registerId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .registerId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn offset(&self) -> ::windows_core::Result<i32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .offset)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn length(&self) -> ::windows_core::Result<u64> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .length)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn slot(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .slot)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn volatileType(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .volatileType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn constType(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .constType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn unalignedType(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .unalignedType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn access(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .access)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn libraryName(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .libraryName)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn platform(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .platform)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn language(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .language)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn editAndContinueEnabled(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .editAndContinueEnabled)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn frontEndMajor(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .frontEndMajor)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn frontEndMinor(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .frontEndMinor)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn frontEndBuild(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .frontEndBuild)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn backEndMajor(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .backEndMajor)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn backEndMinor(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .backEndMinor)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn backEndBuild(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .backEndBuild)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn sourceFileName(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .sourceFileName)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn unused(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .unused)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn thunkOrdinal(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .thunkOrdinal)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn thisAdjust(&self) -> ::windows_core::Result<i32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .thisAdjust)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn virtualBaseOffset(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .virtualBaseOffset)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn r#virtual(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .r#virtual)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn intro(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .intro)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn pure(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .pure)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn callingConvention(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .callingConvention)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn value(&self) -> ::windows_core::Result<::windows_core::VARIANT> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .value)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn baseType(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .baseType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn token(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .token)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn timeStamp(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .timeStamp)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn guid(&self) -> ::windows_core::Result<::windows_core::GUID> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .guid)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn symbolsFileName(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .symbolsFileName)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn reference(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .reference)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn count(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .count)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn bitPosition(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .bitPosition)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn arrayIndexType(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .arrayIndexType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn packed(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .packed)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn constructor(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .constructor)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn overloadedOperator(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .overloadedOperator)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn nested(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .nested)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasNestedTypes(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasNestedTypes)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasAssignmentOperator(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasAssignmentOperator)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn hasCastOperator(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasCastOperator)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn scoped(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .scoped)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn virtualBaseClass(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .virtualBaseClass)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn indirectVirtualBaseClass(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .indirectVirtualBaseClass)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn virtualBasePointerOffset(&self) -> ::windows_core::Result<i32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .virtualBasePointerOffset)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn virtualTableShape(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .virtualTableShape)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn lexicalParentId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .lexicalParentId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn classParentId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .classParentId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn typeId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .typeId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn arrayIndexTypeId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .arrayIndexTypeId)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn virtualTableShapeId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .virtualTableShapeId)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn code(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .code)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn function(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .function)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn managed(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .managed)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn msil(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .msil)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn virtualBaseDispIndex(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .virtualBaseDispIndex)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn undecoratedName(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .undecoratedName)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn age(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .age)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn signature(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .signature)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn compilerGenerated(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .compilerGenerated)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn addressTaken(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .addressTaken)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn rank(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .rank)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn lowerBound(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .lowerBound)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn upperBound(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .upperBound)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn lowerBoundId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .lowerBoundId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn upperBoundId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .upperBoundId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn get_dataBytes(
-            &self,
-            pcbdata: *mut u32,
-            pbdata: &mut [u8],
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .get_dataBytes)(
-                ::windows_core::Interface::as_raw(self),
-                pbdata.len().try_into().unwrap(),
-                pcbdata,
-                ::core::mem::transmute(pbdata.as_ptr()),
-            )
-            .ok()
-        }
-        pub unsafe fn findChildren<P0>(
-            &self,
-            symtag: SymTag,
-            name: P0,
-            compareflags: u32,
-        ) -> ::windows_core::Result<IDiaEnumSymbols>
-        where
-            P0: ::windows_core::IntoParam<::windows_core::PCWSTR>,
-        {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .findChildren)(
-                ::windows_core::Interface::as_raw(self),
-                symtag,
-                name.into_param().abi(),
-                compareflags,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findChildrenEx<P0>(
-            &self,
-            symtag: SymTag,
-            name: P0,
-            compareflags: u32,
-        ) -> ::windows_core::Result<IDiaEnumSymbols>
-        where
-            P0: ::windows_core::IntoParam<::windows_core::PCWSTR>,
-        {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .findChildrenEx)(
-                ::windows_core::Interface::as_raw(self),
-                symtag,
-                name.into_param().abi(),
-                compareflags,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findChildrenExByAddr<P0>(
-            &self,
-            symtag: SymTag,
-            name: P0,
-            compareflags: u32,
-            isect: u32,
-            offset: u32,
-        ) -> ::windows_core::Result<IDiaEnumSymbols>
-        where
-            P0: ::windows_core::IntoParam<::windows_core::PCWSTR>,
-        {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .findChildrenExByAddr)(
-                ::windows_core::Interface::as_raw(self),
-                symtag,
-                name.into_param().abi(),
-                compareflags,
-                isect,
-                offset,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findChildrenExByVA<P0>(
-            &self,
-            symtag: SymTag,
-            name: P0,
-            compareflags: u32,
-            va: u64,
-        ) -> ::windows_core::Result<IDiaEnumSymbols>
-        where
-            P0: ::windows_core::IntoParam<::windows_core::PCWSTR>,
-        {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .findChildrenExByVA)(
-                ::windows_core::Interface::as_raw(self),
-                symtag,
-                name.into_param().abi(),
-                compareflags,
-                va,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findChildrenExByRVA<P0>(
-            &self,
-            symtag: SymTag,
-            name: P0,
-            compareflags: u32,
-            rva: u32,
-        ) -> ::windows_core::Result<IDiaEnumSymbols>
-        where
-            P0: ::windows_core::IntoParam<::windows_core::PCWSTR>,
-        {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .findChildrenExByRVA)(
-                ::windows_core::Interface::as_raw(self),
-                symtag,
-                name.into_param().abi(),
-                compareflags,
-                rva,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn targetSection(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .targetSection)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn targetOffset(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .targetOffset)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn targetRelativeVirtualAddress(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .targetRelativeVirtualAddress)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn targetVirtualAddress(&self) -> ::windows_core::Result<u64> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .targetVirtualAddress)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn machineType(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .machineType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn oemId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .oemId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn oemSymbolId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .oemSymbolId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn get_types(
-            &self,
-            pctypes: *mut u32,
-            ptypes: &mut [::core::option::Option<IDiaSymbol>],
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .get_types)(
-                ::windows_core::Interface::as_raw(self),
-                ptypes.len().try_into().unwrap(),
-                pctypes,
-                ::core::mem::transmute(ptypes.as_ptr()),
-            )
-            .ok()
-        }
-        pub unsafe fn get_typeIds(
-            &self,
-            pctypeids: *mut u32,
-            pdwtypeids: &mut [u32],
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .get_typeIds)(
-                ::windows_core::Interface::as_raw(self),
-                pdwtypeids.len().try_into().unwrap(),
-                pctypeids,
-                ::core::mem::transmute(pdwtypeids.as_ptr()),
-            )
-            .ok()
-        }
-        pub unsafe fn objectPointerType(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .objectPointerType)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn udtKind(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .udtKind)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn get_undecoratedNameEx(
-            &self,
-            undecorateoptions: u32,
-        ) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .get_undecoratedNameEx)(
-                ::windows_core::Interface::as_raw(self),
-                undecorateoptions,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn noReturn(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .noReturn)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn customCallingConvention(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .customCallingConvention)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn noInline(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .noInline)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn optimizedCodeDebugInfo(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .optimizedCodeDebugInfo)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn notReached(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .notReached)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn interruptReturn(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .interruptReturn)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn farReturn(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .farReturn)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isStatic(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isStatic)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasDebugInfo(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasDebugInfo)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isLTCG(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isLTCG)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isDataAligned(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isDataAligned)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasSecurityChecks(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasSecurityChecks)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn compilerName(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .compilerName)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn hasAlloca(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasAlloca)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasSetJump(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasSetJump)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasLongJump(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasLongJump)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasInlAsm(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasInlAsm)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasEH(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasEH)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasSEH(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasSEH)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasEHa(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasEHa)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isNaked(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isNaked)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isAggregated(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isAggregated)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isSplitted(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isSplitted)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn container(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .container)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn inlSpec(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .inlSpec)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn noStackOrdering(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .noStackOrdering)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn virtualBaseTableType(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .virtualBaseTableType)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn hasManagedCode(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasManagedCode)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isHotpatchable(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isHotpatchable)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isCVTCIL(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isCVTCIL)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isMSILNetmodule(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isMSILNetmodule)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isCTypes(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isCTypes)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isStripped(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isStripped)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn frontEndQFE(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .frontEndQFE)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn backEndQFE(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .backEndQFE)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn wasInlined(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .wasInlined)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn strictGSCheck(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .strictGSCheck)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isCxxReturnUdt(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isCxxReturnUdt)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isConstructorVirtualBase(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isConstructorVirtualBase)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn RValueReference(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .RValueReference)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn unmodifiedType(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .unmodifiedType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn framePointerPresent(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .framePointerPresent)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isSafeBuffers(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isSafeBuffers)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn intrinsic(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .intrinsic)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn sealed(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .sealed)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hfaFloat(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hfaFloat)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hfaDouble(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hfaDouble)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn liveRangeStartAddressSection(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .liveRangeStartAddressSection)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn liveRangeStartAddressOffset(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .liveRangeStartAddressOffset)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn liveRangeStartRelativeVirtualAddress(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .liveRangeStartRelativeVirtualAddress)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn countLiveRanges(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .countLiveRanges)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn liveRangeLength(&self) -> ::windows_core::Result<u64> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .liveRangeLength)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn offsetInUdt(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .offsetInUdt)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn paramBasePointerRegisterId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .paramBasePointerRegisterId)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn localBasePointerRegisterId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .localBasePointerRegisterId)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isLocationControlFlowDependent(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isLocationControlFlowDependent)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn stride(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .stride)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn numberOfRows(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .numberOfRows)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn numberOfColumns(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .numberOfColumns)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isMatrixRowMajor(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isMatrixRowMajor)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn get_numericProperties(
-            &self,
-            pcnt: *mut u32,
-            pproperties: &mut [u32],
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .get_numericProperties)(
-                ::windows_core::Interface::as_raw(self),
-                pproperties.len().try_into().unwrap(),
-                pcnt,
-                ::core::mem::transmute(pproperties.as_ptr()),
-            )
-            .ok()
-        }
-        pub unsafe fn get_modifierValues(
-            &self,
-            pcnt: *mut u32,
-            pmodifiers: &mut [u16],
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .get_modifierValues)(
-                ::windows_core::Interface::as_raw(self),
-                pmodifiers.len().try_into().unwrap(),
-                pcnt,
-                ::core::mem::transmute(pmodifiers.as_ptr()),
-            )
-            .ok()
-        }
-        pub unsafe fn isReturnValue(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isReturnValue)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isOptimizedAway(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isOptimizedAway)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn builtInKind(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .builtInKind)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn registerType(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .registerType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn baseDataSlot(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .baseDataSlot)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn baseDataOffset(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .baseDataOffset)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn textureSlot(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .textureSlot)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn samplerSlot(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .samplerSlot)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn uavSlot(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .uavSlot)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn sizeInUdt(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .sizeInUdt)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn memorySpaceKind(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .memorySpaceKind)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn unmodifiedTypeId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .unmodifiedTypeId)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn subTypeId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .subTypeId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn subType(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .subType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn numberOfModifiers(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .numberOfModifiers)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn numberOfRegisterIndices(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .numberOfRegisterIndices)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isHLSLData(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isHLSLData)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isPointerToDataMember(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isPointerToDataMember)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isPointerToMemberFunction(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isPointerToMemberFunction)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isSingleInheritance(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isSingleInheritance)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isMultipleInheritance(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isMultipleInheritance)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isVirtualInheritance(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isVirtualInheritance)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn restrictedType(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .restrictedType)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isPointerBasedOnSymbolValue(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isPointerBasedOnSymbolValue)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn baseSymbol(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .baseSymbol)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn baseSymbolId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .baseSymbolId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn objectFileName(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .objectFileName)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn isAcceleratorGroupSharedLocal(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isAcceleratorGroupSharedLocal)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isAcceleratorPointerTagLiveRange(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isAcceleratorPointerTagLiveRange)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isAcceleratorStubFunction(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isAcceleratorStubFunction)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn numberOfAcceleratorPointerTags(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .numberOfAcceleratorPointerTags)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn isSdl(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isSdl)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isWinRTPointer(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isWinRTPointer)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isRefUdt(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isRefUdt)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isValueUdt(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isValueUdt)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isInterfaceUdt(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isInterfaceUdt)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn findInlineFramesByAddr(
-            &self,
-            isect: u32,
-            offset: u32,
-        ) -> ::windows_core::Result<IDiaEnumSymbols> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .findInlineFramesByAddr)(
-                ::windows_core::Interface::as_raw(self),
-                isect,
-                offset,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findInlineFramesByRVA(
-            &self,
-            rva: u32,
-        ) -> ::windows_core::Result<IDiaEnumSymbols> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .findInlineFramesByRVA)(
-                ::windows_core::Interface::as_raw(self), rva, &mut result__
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findInlineFramesByVA(
-            &self,
-            va: u64,
-        ) -> ::windows_core::Result<IDiaEnumSymbols> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .findInlineFramesByVA)(
-                ::windows_core::Interface::as_raw(self), va, &mut result__
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findInlineeLines(&self) -> ::windows_core::Result<IDiaEnumLineNumbers> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .findInlineeLines)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findInlineeLinesByAddr(
-            &self,
-            isect: u32,
-            offset: u32,
-            length: u32,
-        ) -> ::windows_core::Result<IDiaEnumLineNumbers> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .findInlineeLinesByAddr)(
-                ::windows_core::Interface::as_raw(self),
-                isect,
-                offset,
-                length,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findInlineeLinesByRVA(
-            &self,
-            rva: u32,
-            length: u32,
-        ) -> ::windows_core::Result<IDiaEnumLineNumbers> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .findInlineeLinesByRVA)(
-                ::windows_core::Interface::as_raw(self),
-                rva,
-                length,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findInlineeLinesByVA(
-            &self,
-            va: u64,
-            length: u32,
-        ) -> ::windows_core::Result<IDiaEnumLineNumbers> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .findInlineeLinesByVA)(
-                ::windows_core::Interface::as_raw(self),
-                va,
-                length,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findSymbolsForAcceleratorPointerTag(
-            &self,
-            tagvalue: u32,
-        ) -> ::windows_core::Result<IDiaEnumSymbols> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .findSymbolsForAcceleratorPointerTag)(
-                ::windows_core::Interface::as_raw(self),
-                tagvalue,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn findSymbolsByRVAForAcceleratorPointerTag(
-            &self,
-            tagvalue: u32,
-            rva: u32,
-        ) -> ::windows_core::Result<IDiaEnumSymbols> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .findSymbolsByRVAForAcceleratorPointerTag)(
-                ::windows_core::Interface::as_raw(self),
-                tagvalue,
-                rva,
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn get_acceleratorPointerTags(
-            &self,
-            pcnt: *mut u32,
-            ppointertags: &mut [u32],
-        ) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .get_acceleratorPointerTags)(
-                ::windows_core::Interface::as_raw(self),
-                ppointertags.len().try_into().unwrap(),
-                pcnt,
-                ::core::mem::transmute(ppointertags.as_ptr()),
+            pptagtype: *mut Option<IDiaSymbol>,
+            ptagoffset: *mut u32,
+            ptagmask: *mut DiaTagValue,
+        ) -> windows_core::Result<()> {
+            (windows_core::Interface::vtable(self).get_discriminatedUnionTag)(
+                windows_core::Interface::as_raw(self),
+                core::mem::transmute(pptagtype),
+                ptagoffset,
+                ptagmask,
             )
             .ok()
         }
-        pub unsafe fn getSrcLineOnTypeDefn(&self) -> ::windows_core::Result<IDiaLineNumber> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .getSrcLineOnTypeDefn)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn isPGO(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isPGO)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn hasValidPGOCounts(
+        pub unsafe fn get_tagRanges(
             &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasValidPGOCounts)(
-                ::windows_core::Interface::as_raw(self), &mut result__
+            pcrangevalues: *mut u32,
+            rangevalues: &mut [DiaTagValue],
+        ) -> windows_core::Result<()> {
+            (windows_core::Interface::vtable(self).get_tagRanges)(
+                windows_core::Interface::as_raw(self),
+                rangevalues.len().try_into().unwrap(),
+                pcrangevalues,
+                core::mem::transmute(rangevalues.as_ptr()),
             )
-            .map(|| result__)
+            .ok()
         }
-        pub unsafe fn isOptimizedForSpeed(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isOptimizedForSpeed)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn PGOEntryCount(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .PGOEntryCount)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn PGOEdgeCount(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .PGOEdgeCount)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn PGODynamicInstructionCount(&self) -> ::windows_core::Result<u64> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .PGODynamicInstructionCount)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn staticSize(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .staticSize)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn finalLiveStaticSize(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .finalLiveStaticSize)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn phaseName(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .phaseName)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+    }
+    #[repr(C)]
+    pub struct IDiaSymbol11_Vtbl {
+        pub base__: IDiaSymbol10_Vtbl,
+        pub get_discriminatedUnionTag: unsafe extern "system" fn(
+            *mut core::ffi::c_void,
+            *mut *mut core::ffi::c_void,
+            *mut u32,
+            *mut DiaTagValue,
+        ) -> windows_core::HRESULT,
+        pub get_tagRanges: unsafe extern "system" fn(
+            *mut core::ffi::c_void,
+            u32,
+            *mut u32,
+            *mut DiaTagValue,
+        ) -> windows_core::HRESULT,
+    }
+    windows_core::imp::define_interface!(
+        IDiaSymbol2,
+        IDiaSymbol2_Vtbl,
+        0x611e86cd_b7d1_4546_8a15_070e2b07a427
+    );
+    impl core::ops::Deref for IDiaSymbol2 {
+        type Target = IDiaSymbol;
+        fn deref(&self) -> &Self::Target {
+            unsafe { core::mem::transmute(self) }
         }
-        pub unsafe fn hasControlFlowCheck(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasControlFlowCheck)(
-                ::windows_core::Interface::as_raw(self), &mut result__
+    }
+    windows_core::imp::interface_hierarchy!(IDiaSymbol2, windows_core::IUnknown, IDiaSymbol);
+    impl IDiaSymbol2 {
+        pub unsafe fn isObjCClass(&self) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).isObjCClass)(
+                windows_core::Interface::as_raw(self),
+                &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn constantExport(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .constantExport)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn dataExport(
+        pub unsafe fn isObjCCategory(
             &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .dataExport)(::windows_core::Interface::as_raw(self), &mut result__)
+        ) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).isObjCCategory)(
+                windows_core::Interface::as_raw(self),
+                &mut result__,
+            )
             .map(|| result__)
         }
-        pub unsafe fn privateExport(
+        pub unsafe fn isObjCProtocol(
             &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .privateExport)(::windows_core::Interface::as_raw(self), &mut result__)
+        ) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).isObjCProtocol)(
+                windows_core::Interface::as_raw(self),
+                &mut result__,
+            )
             .map(|| result__)
         }
-        pub unsafe fn noNameExport(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .noNameExport)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
+    }
+    #[repr(C)]
+    pub struct IDiaSymbol2_Vtbl {
+        pub base__: IDiaSymbol_Vtbl,
+        pub isObjCClass: unsafe extern "system" fn(
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
+        pub isObjCCategory: unsafe extern "system" fn(
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
+        pub isObjCProtocol: unsafe extern "system" fn(
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
+    }
+    windows_core::imp::define_interface!(
+        IDiaSymbol3,
+        IDiaSymbol3_Vtbl,
+        0x99b665f7_c1b2_49d3_89b2_a384361acab5
+    );
+    impl core::ops::Deref for IDiaSymbol3 {
+        type Target = IDiaSymbol2;
+        fn deref(&self) -> &Self::Target {
+            unsafe { core::mem::transmute(self) }
         }
-        pub unsafe fn exportHasExplicitlyAssignedOrdinal(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .exportHasExplicitlyAssignedOrdinal)(
-                ::windows_core::Interface::as_raw(self),
+    }
+    windows_core::imp::interface_hierarchy!(
+        IDiaSymbol3,
+        windows_core::IUnknown,
+        IDiaSymbol,
+        IDiaSymbol2
+    );
+    impl IDiaSymbol3 {
+        pub unsafe fn inlinee(&self) -> windows_core::Result<IDiaSymbol> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).inlinee)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
-            .map(|| result__)
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
-        pub unsafe fn exportIsForwarder(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .exportIsForwarder)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn ordinal(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .ordinal)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn frameSize(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .frameSize)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn exceptionHandlerAddressSection(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .exceptionHandlerAddressSection)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn exceptionHandlerAddressOffset(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .exceptionHandlerAddressOffset)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn exceptionHandlerRelativeVirtualAddress(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .exceptionHandlerRelativeVirtualAddress)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn exceptionHandlerVirtualAddress(&self) -> ::windows_core::Result<u64> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .exceptionHandlerVirtualAddress)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-        pub unsafe fn findInputAssemblyFile(
-            &self,
-        ) -> ::windows_core::Result<IDiaInputAssemblyFile> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .findInputAssemblyFile)(
-                ::windows_core::Interface::as_raw(self), &mut result__
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn characteristics(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .characteristics)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn coffGroup(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .coffGroup)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn bindID(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .bindID)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn bindSpace(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .bindSpace)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn bindSlot(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .bindSlot)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn isObjCClass(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isObjCClass)(::windows_core::Interface::as_raw(self), &mut result__)
+        pub unsafe fn inlineeId(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).inlineeId)(
+                windows_core::Interface::as_raw(self),
+                &mut result__,
+            )
             .map(|| result__)
         }
-        pub unsafe fn isObjCCategory(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isObjCCategory)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
+    }
+    #[repr(C)]
+    pub struct IDiaSymbol3_Vtbl {
+        pub base__: IDiaSymbol2_Vtbl,
+        pub inlinee: unsafe extern "system" fn(
+            *mut core::ffi::c_void,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
+        pub inlineeId:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+    }
+    windows_core::imp::define_interface!(
+        IDiaSymbol4,
+        IDiaSymbol4_Vtbl,
+        0xbf6c88a7_e9d6_4346_99a1_d053de5a7808
+    );
+    impl core::ops::Deref for IDiaSymbol4 {
+        type Target = IDiaSymbol3;
+        fn deref(&self) -> &Self::Target {
+            unsafe { core::mem::transmute(self) }
         }
-        pub unsafe fn isObjCProtocol(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .isObjCProtocol)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn inlinee(&self) -> ::windows_core::Result<IDiaSymbol> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .inlinee)(::windows_core::Interface::as_raw(self), &mut result__)
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn inlineeId(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .inlineeId)(::windows_core::Interface::as_raw(self), &mut result__)
-            .map(|| result__)
-        }
-        pub unsafe fn noexcept(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .base__
-                .noexcept)(::windows_core::Interface::as_raw(self), &mut result__)
+    }
+    windows_core::imp::interface_hierarchy!(
+        IDiaSymbol4,
+        windows_core::IUnknown,
+        IDiaSymbol,
+        IDiaSymbol2,
+        IDiaSymbol3
+    );
+    impl IDiaSymbol4 {
+        pub unsafe fn noexcept(&self) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).noexcept)(
+                windows_core::Interface::as_raw(self),
+                &mut result__,
+            )
             .map(|| result__)
         }
+    }
+    #[repr(C)]
+    pub struct IDiaSymbol4_Vtbl {
+        pub base__: IDiaSymbol3_Vtbl,
+        pub noexcept: unsafe extern "system" fn(
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
+    }
+    windows_core::imp::define_interface!(
+        IDiaSymbol5,
+        IDiaSymbol5_Vtbl,
+        0xabe2de00_dc2d_4793_af9a_ef1d90832644
+    );
+    impl core::ops::Deref for IDiaSymbol5 {
+        type Target = IDiaSymbol4;
+        fn deref(&self) -> &Self::Target {
+            unsafe { core::mem::transmute(self) }
+        }
+    }
+    windows_core::imp::interface_hierarchy!(
+        IDiaSymbol5,
+        windows_core::IUnknown,
+        IDiaSymbol,
+        IDiaSymbol2,
+        IDiaSymbol3,
+        IDiaSymbol4
+    );
+    impl IDiaSymbol5 {
         pub unsafe fn hasAbsoluteAddress(
             &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .base__
-                .hasAbsoluteAddress)(
-                ::windows_core::Interface::as_raw(self), &mut result__
+        ) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).hasAbsoluteAddress)(
+                windows_core::Interface::as_raw(self),
+                &mut result__,
             )
             .map(|| result__)
         }
+    }
+    #[repr(C)]
+    pub struct IDiaSymbol5_Vtbl {
+        pub base__: IDiaSymbol4_Vtbl,
+        pub hasAbsoluteAddress: unsafe extern "system" fn(
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
+    }
+    windows_core::imp::define_interface!(
+        IDiaSymbol6,
+        IDiaSymbol6_Vtbl,
+        0x8133dad3_75fe_4234_ac7e_f8e7a1d3cbb3
+    );
+    impl core::ops::Deref for IDiaSymbol6 {
+        type Target = IDiaSymbol5;
+        fn deref(&self) -> &Self::Target {
+            unsafe { core::mem::transmute(self) }
+        }
+    }
+    windows_core::imp::interface_hierarchy!(
+        IDiaSymbol6,
+        windows_core::IUnknown,
+        IDiaSymbol,
+        IDiaSymbol2,
+        IDiaSymbol3,
+        IDiaSymbol4,
+        IDiaSymbol5
+    );
+    impl IDiaSymbol6 {
         pub unsafe fn isStaticMemberFunc(
             &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .base__
-                .isStaticMemberFunc)(
-                ::windows_core::Interface::as_raw(self), &mut result__
+        ) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).isStaticMemberFunc)(
+                windows_core::Interface::as_raw(self),
+                &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn isSignRet(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .base__
-                .isSignRet)(::windows_core::Interface::as_raw(self), &mut result__)
+    }
+    #[repr(C)]
+    pub struct IDiaSymbol6_Vtbl {
+        pub base__: IDiaSymbol5_Vtbl,
+        pub isStaticMemberFunc: unsafe extern "system" fn(
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
+    }
+    windows_core::imp::define_interface!(
+        IDiaSymbol7,
+        IDiaSymbol7_Vtbl,
+        0x64ce6cd5_7315_4328_86d6_10e303e010b4
+    );
+    impl core::ops::Deref for IDiaSymbol7 {
+        type Target = IDiaSymbol6;
+        fn deref(&self) -> &Self::Target {
+            unsafe { core::mem::transmute(self) }
+        }
+    }
+    windows_core::imp::interface_hierarchy!(
+        IDiaSymbol7,
+        windows_core::IUnknown,
+        IDiaSymbol,
+        IDiaSymbol2,
+        IDiaSymbol3,
+        IDiaSymbol4,
+        IDiaSymbol5,
+        IDiaSymbol6
+    );
+    impl IDiaSymbol7 {
+        pub unsafe fn isSignRet(&self) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).isSignRet)(
+                windows_core::Interface::as_raw(self),
+                &mut result__,
+            )
             .map(|| result__)
         }
-        pub unsafe fn coroutineKind(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.coroutineKind)(
-                ::windows_core::Interface::as_raw(self),
+    }
+    #[repr(C)]
+    pub struct IDiaSymbol7_Vtbl {
+        pub base__: IDiaSymbol6_Vtbl,
+        pub isSignRet: unsafe extern "system" fn(
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
+    }
+    windows_core::imp::define_interface!(
+        IDiaSymbol8,
+        IDiaSymbol8_Vtbl,
+        0x7f2e041f_1294_41bd_b83a_e715972d2ce3
+    );
+    impl core::ops::Deref for IDiaSymbol8 {
+        type Target = IDiaSymbol7;
+        fn deref(&self) -> &Self::Target {
+            unsafe { core::mem::transmute(self) }
+        }
+    }
+    windows_core::imp::interface_hierarchy!(
+        IDiaSymbol8,
+        windows_core::IUnknown,
+        IDiaSymbol,
+        IDiaSymbol2,
+        IDiaSymbol3,
+        IDiaSymbol4,
+        IDiaSymbol5,
+        IDiaSymbol6,
+        IDiaSymbol7
+    );
+    impl IDiaSymbol8 {
+        pub unsafe fn coroutineKind(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).coroutineKind)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn associatedSymbolKind(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .associatedSymbolKind)(
-                ::windows_core::Interface::as_raw(self), &mut result__
+        pub unsafe fn associatedSymbolKind(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).associatedSymbolKind)(
+                windows_core::Interface::as_raw(self),
+                &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn associatedSymbolSection(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .associatedSymbolSection)(
-                ::windows_core::Interface::as_raw(self), &mut result__
+        pub unsafe fn associatedSymbolSection(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).associatedSymbolSection)(
+                windows_core::Interface::as_raw(self),
+                &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn associatedSymbolOffset(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .associatedSymbolOffset)(
-                ::windows_core::Interface::as_raw(self), &mut result__
+        pub unsafe fn associatedSymbolOffset(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).associatedSymbolOffset)(
+                windows_core::Interface::as_raw(self),
+                &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn associatedSymbolRva(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .associatedSymbolRva)(
-                ::windows_core::Interface::as_raw(self), &mut result__
+        pub unsafe fn associatedSymbolRva(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).associatedSymbolRva)(
+                windows_core::Interface::as_raw(self),
+                &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn associatedSymbolAddr(&self) -> ::windows_core::Result<u64> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)
-                .base__
-                .associatedSymbolAddr)(
-                ::windows_core::Interface::as_raw(self), &mut result__
+        pub unsafe fn associatedSymbolAddr(&self) -> windows_core::Result<u64> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).associatedSymbolAddr)(
+                windows_core::Interface::as_raw(self),
+                &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn framePadSize(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).framePadSize)(
-                ::windows_core::Interface::as_raw(self),
+    }
+    #[repr(C)]
+    pub struct IDiaSymbol8_Vtbl {
+        pub base__: IDiaSymbol7_Vtbl,
+        pub coroutineKind:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+        pub associatedSymbolKind:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+        pub associatedSymbolSection:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+        pub associatedSymbolOffset:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+        pub associatedSymbolRva:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+        pub associatedSymbolAddr:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u64) -> windows_core::HRESULT,
+    }
+    windows_core::imp::define_interface!(
+        IDiaSymbol9,
+        IDiaSymbol9_Vtbl,
+        0xa89e5969_92a1_4f8a_b704_00121c37abbb
+    );
+    impl core::ops::Deref for IDiaSymbol9 {
+        type Target = IDiaSymbol8;
+        fn deref(&self) -> &Self::Target {
+            unsafe { core::mem::transmute(self) }
+        }
+    }
+    windows_core::imp::interface_hierarchy!(
+        IDiaSymbol9,
+        windows_core::IUnknown,
+        IDiaSymbol,
+        IDiaSymbol2,
+        IDiaSymbol3,
+        IDiaSymbol4,
+        IDiaSymbol5,
+        IDiaSymbol6,
+        IDiaSymbol7,
+        IDiaSymbol8
+    );
+    impl IDiaSymbol9 {
+        pub unsafe fn framePadSize(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).framePadSize)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn framePadOffset(&self) -> ::windows_core::Result<u32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).framePadOffset)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn framePadOffset(&self) -> windows_core::Result<u32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).framePadOffset)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn isRTCs(&self) -> ::windows_core::Result<::windows::Win32::Foundation::BOOL> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).isRTCs)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn isRTCs(&self) -> windows_core::Result<windows::Win32::Foundation::BOOL> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).isRTCs)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
@@ -42329,119 +9097,84 @@ pub mod Dia {
     #[repr(C)]
     pub struct IDiaSymbol9_Vtbl {
         pub base__: IDiaSymbol8_Vtbl,
-        pub framePadSize: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
-        pub framePadOffset: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut u32,
-        ) -> ::windows_core::HRESULT,
+        pub framePadSize:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+        pub framePadOffset:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
         pub isRTCs: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::windows::Win32::Foundation::BOOL,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut windows::Win32::Foundation::BOOL,
+        ) -> windows_core::HRESULT,
     }
-    ::windows_core::imp::com_interface!(
+    windows_core::imp::define_interface!(
         IDiaTable,
         IDiaTable_Vtbl,
         0x4a59fb77_abac_469b_a30b_9ecc85bfef14
     );
-    ::windows_core::imp::interface_hierarchy!(
+    impl core::ops::Deref for IDiaTable {
+        type Target = windows::Win32::System::Com::IEnumUnknown;
+        fn deref(&self) -> &Self::Target {
+            unsafe { core::mem::transmute(self) }
+        }
+    }
+    windows_core::imp::interface_hierarchy!(
         IDiaTable,
-        ::windows_core::IUnknown,
-        ::windows::Win32::System::Com::IEnumUnknown
+        windows_core::IUnknown,
+        windows::Win32::System::Com::IEnumUnknown
     );
     impl IDiaTable {
-        pub unsafe fn Next(
-            &self,
-            rgelt: &mut [::core::option::Option<::windows_core::IUnknown>],
-            pceltfetched: ::core::option::Option<*mut u32>,
-        ) -> ::windows_core::HRESULT {
-            (::windows_core::Interface::vtable(self).base__.Next)(
-                ::windows_core::Interface::as_raw(self),
-                rgelt.len().try_into().unwrap(),
-                ::core::mem::transmute(rgelt.as_ptr()),
-                ::core::mem::transmute(pceltfetched.unwrap_or(::std::ptr::null_mut())),
-            )
-        }
-        pub unsafe fn Skip(&self, celt: u32) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self).base__.Skip)(
-                ::windows_core::Interface::as_raw(self),
-                celt,
-            )
-            .ok()
-        }
-        pub unsafe fn Reset(&self) -> ::windows_core::Result<()> {
-            (::windows_core::Interface::vtable(self).base__.Reset)(
-                ::windows_core::Interface::as_raw(self),
-            )
-            .ok()
-        }
-        pub unsafe fn Clone(
-            &self,
-        ) -> ::windows_core::Result<::windows::Win32::System::Com::IEnumUnknown> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).base__.Clone)(
-                ::windows_core::Interface::as_raw(self),
-                &mut result__,
-            )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
-        }
-        pub unsafe fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self)._NewEnum)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn _NewEnum(&self) -> windows_core::Result<windows_core::IUnknown> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self)._NewEnum)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
-        pub unsafe fn name(&self) -> ::windows_core::Result<::windows_core::BSTR> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).name)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn name(&self) -> windows_core::Result<windows_core::BSTR> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).name)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
-        pub unsafe fn Count(&self) -> ::windows_core::Result<i32> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).Count)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn Count(&self) -> windows_core::Result<i32> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).Count)(
+                windows_core::Interface::as_raw(self),
                 &mut result__,
             )
             .map(|| result__)
         }
-        pub unsafe fn Item(&self, index: u32) -> ::windows_core::Result<::windows_core::IUnknown> {
-            let mut result__ = ::std::mem::zeroed();
-            (::windows_core::Interface::vtable(self).Item)(
-                ::windows_core::Interface::as_raw(self),
+        pub unsafe fn Item(&self, index: u32) -> windows_core::Result<windows_core::IUnknown> {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(self).Item)(
+                windows_core::Interface::as_raw(self),
                 index,
                 &mut result__,
             )
-            .and_then(|| ::windows_core::Type::from_abi(result__))
+            .and_then(|| windows_core::Type::from_abi(result__))
         }
     }
     #[repr(C)]
     pub struct IDiaTable_Vtbl {
-        pub base__: ::windows::Win32::System::Com::IEnumUnknown_Vtbl,
+        pub base__: windows::Win32::System::Com::IEnumUnknown_Vtbl,
         pub _NewEnum: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
         pub name: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut ::std::mem::MaybeUninit<::windows_core::BSTR>,
-        ) -> ::windows_core::HRESULT,
-        pub Count: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
-            *mut i32,
-        ) -> ::windows_core::HRESULT,
+            *mut core::ffi::c_void,
+            *mut core::mem::MaybeUninit<windows_core::BSTR>,
+        ) -> windows_core::HRESULT,
+        pub Count:
+            unsafe extern "system" fn(*mut core::ffi::c_void, *mut i32) -> windows_core::HRESULT,
         pub Item: unsafe extern "system" fn(
-            *mut ::core::ffi::c_void,
+            *mut core::ffi::c_void,
             u32,
-            *mut *mut ::core::ffi::c_void,
-        ) -> ::windows_core::HRESULT,
+            *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT,
     }
     pub const CHKSUM_TYPE_MD5: CV_SourceChksum_t = CV_SourceChksum_t(1i32);
     pub const CHKSUM_TYPE_NONE: CV_SourceChksum_t = CV_SourceChksum_t(0i32);
@@ -43475,6 +10208,22 @@ pub mod Dia {
     pub const CV_ARM64_LR: CV_HREG_e = CV_HREG_e(80i32);
     pub const CV_ARM64_NOREG: CV_HREG_e = CV_HREG_e(0i32);
     pub const CV_ARM64_NZCV: CV_HREG_e = CV_HREG_e(90i32);
+    pub const CV_ARM64_P0: CV_HREG_e = CV_HREG_e(414i32);
+    pub const CV_ARM64_P1: CV_HREG_e = CV_HREG_e(415i32);
+    pub const CV_ARM64_P10: CV_HREG_e = CV_HREG_e(424i32);
+    pub const CV_ARM64_P11: CV_HREG_e = CV_HREG_e(425i32);
+    pub const CV_ARM64_P12: CV_HREG_e = CV_HREG_e(426i32);
+    pub const CV_ARM64_P13: CV_HREG_e = CV_HREG_e(427i32);
+    pub const CV_ARM64_P14: CV_HREG_e = CV_HREG_e(428i32);
+    pub const CV_ARM64_P15: CV_HREG_e = CV_HREG_e(429i32);
+    pub const CV_ARM64_P2: CV_HREG_e = CV_HREG_e(416i32);
+    pub const CV_ARM64_P3: CV_HREG_e = CV_HREG_e(417i32);
+    pub const CV_ARM64_P4: CV_HREG_e = CV_HREG_e(418i32);
+    pub const CV_ARM64_P5: CV_HREG_e = CV_HREG_e(419i32);
+    pub const CV_ARM64_P6: CV_HREG_e = CV_HREG_e(420i32);
+    pub const CV_ARM64_P7: CV_HREG_e = CV_HREG_e(421i32);
+    pub const CV_ARM64_P8: CV_HREG_e = CV_HREG_e(422i32);
+    pub const CV_ARM64_P9: CV_HREG_e = CV_HREG_e(423i32);
     pub const CV_ARM64_PC: CV_HREG_e = CV_HREG_e(83i32);
     pub const CV_ARM64_Q0: CV_HREG_e = CV_HREG_e(180i32);
     pub const CV_ARM64_Q0H: CV_HREG_e = CV_HREG_e(350i32);
@@ -43664,6 +10413,38 @@ pub mod Dia {
     pub const CV_ARM64_X7: CV_HREG_e = CV_HREG_e(57i32);
     pub const CV_ARM64_X8: CV_HREG_e = CV_HREG_e(58i32);
     pub const CV_ARM64_X9: CV_HREG_e = CV_HREG_e(59i32);
+    pub const CV_ARM64_Z0: CV_HREG_e = CV_HREG_e(382i32);
+    pub const CV_ARM64_Z1: CV_HREG_e = CV_HREG_e(383i32);
+    pub const CV_ARM64_Z10: CV_HREG_e = CV_HREG_e(392i32);
+    pub const CV_ARM64_Z11: CV_HREG_e = CV_HREG_e(393i32);
+    pub const CV_ARM64_Z12: CV_HREG_e = CV_HREG_e(394i32);
+    pub const CV_ARM64_Z13: CV_HREG_e = CV_HREG_e(395i32);
+    pub const CV_ARM64_Z14: CV_HREG_e = CV_HREG_e(396i32);
+    pub const CV_ARM64_Z15: CV_HREG_e = CV_HREG_e(397i32);
+    pub const CV_ARM64_Z16: CV_HREG_e = CV_HREG_e(398i32);
+    pub const CV_ARM64_Z17: CV_HREG_e = CV_HREG_e(399i32);
+    pub const CV_ARM64_Z18: CV_HREG_e = CV_HREG_e(400i32);
+    pub const CV_ARM64_Z19: CV_HREG_e = CV_HREG_e(401i32);
+    pub const CV_ARM64_Z2: CV_HREG_e = CV_HREG_e(384i32);
+    pub const CV_ARM64_Z20: CV_HREG_e = CV_HREG_e(402i32);
+    pub const CV_ARM64_Z21: CV_HREG_e = CV_HREG_e(403i32);
+    pub const CV_ARM64_Z22: CV_HREG_e = CV_HREG_e(404i32);
+    pub const CV_ARM64_Z23: CV_HREG_e = CV_HREG_e(405i32);
+    pub const CV_ARM64_Z24: CV_HREG_e = CV_HREG_e(406i32);
+    pub const CV_ARM64_Z25: CV_HREG_e = CV_HREG_e(407i32);
+    pub const CV_ARM64_Z26: CV_HREG_e = CV_HREG_e(408i32);
+    pub const CV_ARM64_Z27: CV_HREG_e = CV_HREG_e(409i32);
+    pub const CV_ARM64_Z28: CV_HREG_e = CV_HREG_e(410i32);
+    pub const CV_ARM64_Z29: CV_HREG_e = CV_HREG_e(411i32);
+    pub const CV_ARM64_Z3: CV_HREG_e = CV_HREG_e(385i32);
+    pub const CV_ARM64_Z30: CV_HREG_e = CV_HREG_e(412i32);
+    pub const CV_ARM64_Z31: CV_HREG_e = CV_HREG_e(413i32);
+    pub const CV_ARM64_Z4: CV_HREG_e = CV_HREG_e(386i32);
+    pub const CV_ARM64_Z5: CV_HREG_e = CV_HREG_e(387i32);
+    pub const CV_ARM64_Z6: CV_HREG_e = CV_HREG_e(388i32);
+    pub const CV_ARM64_Z7: CV_HREG_e = CV_HREG_e(389i32);
+    pub const CV_ARM64_Z8: CV_HREG_e = CV_HREG_e(390i32);
+    pub const CV_ARM64_Z9: CV_HREG_e = CV_HREG_e(391i32);
     pub const CV_ARM64_ZR: CV_HREG_e = CV_HREG_e(82i32);
     pub const CV_ARM_ACC0: CV_HREG_e = CV_HREG_e(27i32);
     pub const CV_ARM_CPSR: CV_HREG_e = CV_HREG_e(26i32);
@@ -45908,65 +12689,50 @@ pub mod Dia {
     pub const DataIsStaticLocal: DataKind = DataKind(2i32);
     pub const DataIsStaticMember: DataKind = DataKind(8i32);
     pub const DataIsUnknown: DataKind = DataKind(0i32);
-    pub const DiaSource: ::windows_core::GUID =
-        ::windows_core::GUID::from_u128(0xe6756135_1e65_4d17_8576_610761398c3c);
-    pub const DiaSourceAlt: ::windows_core::GUID =
-        ::windows_core::GUID::from_u128(0x91904831_49ca_4766_b95c_25397e2dd6dc);
-    pub const DiaStackWalker: ::windows_core::GUID =
-        ::windows_core::GUID::from_u128(0xce4a85db_5768_475b_a4e1_c0bca2112a6b);
-    pub const E_DIA_FRAME_ACCESS: __MIDL___MIDL_itf_dia2_0000_0036_0001 =
-        __MIDL___MIDL_itf_dia2_0000_0036_0001(-2140340122i32);
-    pub const E_DIA_INPROLOG: __MIDL___MIDL_itf_dia2_0000_0036_0001 =
-        __MIDL___MIDL_itf_dia2_0000_0036_0001(-2140340124i32);
-    pub const E_DIA_SYNTAX: __MIDL___MIDL_itf_dia2_0000_0036_0001 =
-        __MIDL___MIDL_itf_dia2_0000_0036_0001(-2140340123i32);
-    pub const E_DIA_VALUE: __MIDL___MIDL_itf_dia2_0000_0036_0001 =
-        __MIDL___MIDL_itf_dia2_0000_0036_0001(-2140340121i32);
-    pub const E_PDB_ACCESS_DENIED: ::windows_core::HRESULT =
-        ::windows_core::HRESULT(0x806D0010_u32 as _);
-    pub const E_PDB_CORRUPT: ::windows_core::HRESULT = ::windows_core::HRESULT(0x806D000E_u32 as _);
-    pub const E_PDB_DBG_NOT_FOUND: ::windows_core::HRESULT =
-        ::windows_core::HRESULT(0x806D0013_u32 as _);
-    pub const E_PDB_DEBUG_INFO_NOT_IN_PDB: ::windows_core::HRESULT =
-        ::windows_core::HRESULT(0x806D0017_u32 as _);
-    pub const E_PDB_FILE_SYSTEM: ::windows_core::HRESULT =
-        ::windows_core::HRESULT(0x806D0004_u32 as _);
-    pub const E_PDB_FORMAT: ::windows_core::HRESULT = ::windows_core::HRESULT(0x806D000C_u32 as _);
-    pub const E_PDB_ILLEGAL_TYPE_EDIT: ::windows_core::HRESULT =
-        ::windows_core::HRESULT(0x806D0011_u32 as _);
-    pub const E_PDB_INVALID_AGE: ::windows_core::HRESULT =
-        ::windows_core::HRESULT(0x806D0007_u32 as _);
-    pub const E_PDB_INVALID_EXECUTABLE: ::windows_core::HRESULT =
-        ::windows_core::HRESULT(0x806D0012_u32 as _);
-    pub const E_PDB_INVALID_EXE_TIMESTAMP: ::windows_core::HRESULT =
-        ::windows_core::HRESULT(0x806D0015_u32 as _);
-    pub const E_PDB_INVALID_SIG: ::windows_core::HRESULT =
-        ::windows_core::HRESULT(0x806D0006_u32 as _);
-    pub const E_PDB_LIMIT: ::windows_core::HRESULT = ::windows_core::HRESULT(0x806D000D_u32 as _);
-    pub const E_PDB_NOT_FOUND: ::windows_core::HRESULT =
-        ::windows_core::HRESULT(0x806D0005_u32 as _);
-    pub const E_PDB_NOT_IMPLEMENTED: ::windows_core::HRESULT =
-        ::windows_core::HRESULT(0x806D000A_u32 as _);
-    pub const E_PDB_NO_DEBUG_INFO: ::windows_core::HRESULT =
-        ::windows_core::HRESULT(0x806D0014_u32 as _);
-    pub const E_PDB_OBJECT_DISPOSED: ::windows_core::HRESULT =
-        ::windows_core::HRESULT(0x806D001A_u32 as _);
-    pub const E_PDB_OK: ::windows_core::HRESULT = ::windows_core::HRESULT(0x806D0001_u32 as _);
-    pub const E_PDB_OUT_OF_MEMORY: ::windows_core::HRESULT =
-        ::windows_core::HRESULT(0x806D0003_u32 as _);
-    pub const E_PDB_OUT_OF_TI: ::windows_core::HRESULT =
-        ::windows_core::HRESULT(0x806D0009_u32 as _);
-    pub const E_PDB_PRECOMP_REQUIRED: ::windows_core::HRESULT =
-        ::windows_core::HRESULT(0x806D0008_u32 as _);
-    pub const E_PDB_RESERVED: ::windows_core::HRESULT =
-        ::windows_core::HRESULT(0x806D0016_u32 as _);
-    pub const E_PDB_SYMSRV_BAD_CACHE_PATH: ::windows_core::HRESULT =
-        ::windows_core::HRESULT(0x806D0018_u32 as _);
-    pub const E_PDB_SYMSRV_CACHE_FULL: ::windows_core::HRESULT =
-        ::windows_core::HRESULT(0x806D0019_u32 as _);
-    pub const E_PDB_TI16: ::windows_core::HRESULT = ::windows_core::HRESULT(0x806D000F_u32 as _);
-    pub const E_PDB_USAGE: ::windows_core::HRESULT = ::windows_core::HRESULT(0x806D0002_u32 as _);
-    pub const E_PDB_V1_PDB: ::windows_core::HRESULT = ::windows_core::HRESULT(0x806D000B_u32 as _);
+    pub const E_DIA_FRAME_ACCESS: windows_core::HRESULT =
+        windows_core::HRESULT(0x806D0066_u32 as _);
+    pub const E_DIA_INPROLOG: windows_core::HRESULT = windows_core::HRESULT(0x806D0064_u32 as _);
+    pub const E_DIA_SYNTAX: windows_core::HRESULT = windows_core::HRESULT(0x806D0065_u32 as _);
+    pub const E_DIA_VALUE: windows_core::HRESULT = windows_core::HRESULT(0x806D0067_u32 as _);
+    pub const E_PDB_ACCESS_DENIED: windows_core::HRESULT =
+        windows_core::HRESULT(0x806D0010_u32 as _);
+    pub const E_PDB_CORRUPT: windows_core::HRESULT = windows_core::HRESULT(0x806D000E_u32 as _);
+    pub const E_PDB_DBG_NOT_FOUND: windows_core::HRESULT =
+        windows_core::HRESULT(0x806D0013_u32 as _);
+    pub const E_PDB_DEBUG_INFO_NOT_IN_PDB: windows_core::HRESULT =
+        windows_core::HRESULT(0x806D0017_u32 as _);
+    pub const E_PDB_FILE_SYSTEM: windows_core::HRESULT = windows_core::HRESULT(0x806D0004_u32 as _);
+    pub const E_PDB_FORMAT: windows_core::HRESULT = windows_core::HRESULT(0x806D000C_u32 as _);
+    pub const E_PDB_ILLEGAL_TYPE_EDIT: windows_core::HRESULT =
+        windows_core::HRESULT(0x806D0011_u32 as _);
+    pub const E_PDB_INVALID_AGE: windows_core::HRESULT = windows_core::HRESULT(0x806D0007_u32 as _);
+    pub const E_PDB_INVALID_EXECUTABLE: windows_core::HRESULT =
+        windows_core::HRESULT(0x806D0012_u32 as _);
+    pub const E_PDB_INVALID_EXE_TIMESTAMP: windows_core::HRESULT =
+        windows_core::HRESULT(0x806D0015_u32 as _);
+    pub const E_PDB_INVALID_SIG: windows_core::HRESULT = windows_core::HRESULT(0x806D0006_u32 as _);
+    pub const E_PDB_LIMIT: windows_core::HRESULT = windows_core::HRESULT(0x806D000D_u32 as _);
+    pub const E_PDB_NOT_FOUND: windows_core::HRESULT = windows_core::HRESULT(0x806D0005_u32 as _);
+    pub const E_PDB_NOT_IMPLEMENTED: windows_core::HRESULT =
+        windows_core::HRESULT(0x806D000A_u32 as _);
+    pub const E_PDB_NO_DEBUG_INFO: windows_core::HRESULT =
+        windows_core::HRESULT(0x806D0014_u32 as _);
+    pub const E_PDB_OBJECT_DISPOSED: windows_core::HRESULT =
+        windows_core::HRESULT(0x806D001A_u32 as _);
+    pub const E_PDB_OK: windows_core::HRESULT = windows_core::HRESULT(0x806D0001_u32 as _);
+    pub const E_PDB_OUT_OF_MEMORY: windows_core::HRESULT =
+        windows_core::HRESULT(0x806D0003_u32 as _);
+    pub const E_PDB_OUT_OF_TI: windows_core::HRESULT = windows_core::HRESULT(0x806D0009_u32 as _);
+    pub const E_PDB_PRECOMP_REQUIRED: windows_core::HRESULT =
+        windows_core::HRESULT(0x806D0008_u32 as _);
+    pub const E_PDB_RESERVED: windows_core::HRESULT = windows_core::HRESULT(0x806D0016_u32 as _);
+    pub const E_PDB_SYMSRV_BAD_CACHE_PATH: windows_core::HRESULT =
+        windows_core::HRESULT(0x806D0018_u32 as _);
+    pub const E_PDB_SYMSRV_CACHE_FULL: windows_core::HRESULT =
+        windows_core::HRESULT(0x806D0019_u32 as _);
+    pub const E_PDB_TI16: windows_core::HRESULT = windows_core::HRESULT(0x806D000F_u32 as _);
+    pub const E_PDB_USAGE: windows_core::HRESULT = windows_core::HRESULT(0x806D0002_u32 as _);
+    pub const E_PDB_V1_PDB: windows_core::HRESULT = windows_core::HRESULT(0x806D000B_u32 as _);
     pub const FrameTypeFPO: StackFrameTypeEnum = StackFrameTypeEnum(0i32);
     pub const FrameTypeFrameData: StackFrameTypeEnum = StackFrameTypeEnum(4i32);
     pub const FrameTypeStandard: StackFrameTypeEnum = StackFrameTypeEnum(3i32);
@@ -46091,492 +12857,297 @@ pub mod Dia {
     pub const nsfRegularExpression: NameSearchOptions = NameSearchOptions(8i32);
     pub const nsfUndecoratedName: NameSearchOptions = NameSearchOptions(16i32);
     #[repr(transparent)]
-    #[derive(
-        ::core::cmp::PartialEq,
-        ::core::cmp::Eq,
-        ::core::marker::Copy,
-        ::core::clone::Clone,
-        ::core::default::Default,
-    )]
+    #[derive(PartialEq, Eq, Copy, Clone, Default)]
     pub struct BasicType(pub i32);
-    impl ::windows_core::TypeKind for BasicType {
-        type TypeKind = ::windows_core::CopyType;
+    impl windows_core::TypeKind for BasicType {
+        type TypeKind = windows_core::CopyType;
     }
-    impl ::core::fmt::Debug for BasicType {
-        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+    impl core::fmt::Debug for BasicType {
+        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
             f.debug_tuple("BasicType").field(&self.0).finish()
         }
     }
     #[repr(transparent)]
-    #[derive(
-        ::core::cmp::PartialEq,
-        ::core::cmp::Eq,
-        ::core::marker::Copy,
-        ::core::clone::Clone,
-        ::core::default::Default,
-    )]
+    #[derive(PartialEq, Eq, Copy, Clone, Default)]
     pub struct CV_AssociationKind_e(pub i32);
-    impl ::windows_core::TypeKind for CV_AssociationKind_e {
-        type TypeKind = ::windows_core::CopyType;
+    impl windows_core::TypeKind for CV_AssociationKind_e {
+        type TypeKind = windows_core::CopyType;
     }
-    impl ::core::fmt::Debug for CV_AssociationKind_e {
-        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+    impl core::fmt::Debug for CV_AssociationKind_e {
+        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
             f.debug_tuple("CV_AssociationKind_e")
                 .field(&self.0)
                 .finish()
         }
     }
     #[repr(transparent)]
-    #[derive(
-        ::core::cmp::PartialEq,
-        ::core::cmp::Eq,
-        ::core::marker::Copy,
-        ::core::clone::Clone,
-        ::core::default::Default,
-    )]
+    #[derive(PartialEq, Eq, Copy, Clone, Default)]
     pub struct CV_CFL_LANG(pub i32);
-    impl ::windows_core::TypeKind for CV_CFL_LANG {
-        type TypeKind = ::windows_core::CopyType;
+    impl windows_core::TypeKind for CV_CFL_LANG {
+        type TypeKind = windows_core::CopyType;
     }
-    impl ::core::fmt::Debug for CV_CFL_LANG {
-        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+    impl core::fmt::Debug for CV_CFL_LANG {
+        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
             f.debug_tuple("CV_CFL_LANG").field(&self.0).finish()
         }
     }
     #[repr(transparent)]
-    #[derive(
-        ::core::cmp::PartialEq,
-        ::core::cmp::Eq,
-        ::core::marker::Copy,
-        ::core::clone::Clone,
-        ::core::default::Default,
-    )]
+    #[derive(PartialEq, Eq, Copy, Clone, Default)]
     pub struct CV_CPU_TYPE_e(pub i32);
-    impl ::windows_core::TypeKind for CV_CPU_TYPE_e {
-        type TypeKind = ::windows_core::CopyType;
+    impl windows_core::TypeKind for CV_CPU_TYPE_e {
+        type TypeKind = windows_core::CopyType;
     }
-    impl ::core::fmt::Debug for CV_CPU_TYPE_e {
-        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+    impl core::fmt::Debug for CV_CPU_TYPE_e {
+        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
             f.debug_tuple("CV_CPU_TYPE_e").field(&self.0).finish()
         }
     }
     #[repr(transparent)]
-    #[derive(
-        ::core::cmp::PartialEq,
-        ::core::cmp::Eq,
-        ::core::marker::Copy,
-        ::core::clone::Clone,
-        ::core::default::Default,
-    )]
+    #[derive(PartialEq, Eq, Copy, Clone, Default)]
     pub struct CV_CoroutineKind_e(pub i32);
-    impl ::windows_core::TypeKind for CV_CoroutineKind_e {
-        type TypeKind = ::windows_core::CopyType;
+    impl windows_core::TypeKind for CV_CoroutineKind_e {
+        type TypeKind = windows_core::CopyType;
     }
-    impl ::core::fmt::Debug for CV_CoroutineKind_e {
-        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+    impl core::fmt::Debug for CV_CoroutineKind_e {
+        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
             f.debug_tuple("CV_CoroutineKind_e").field(&self.0).finish()
         }
     }
     #[repr(transparent)]
-    #[derive(
-        ::core::cmp::PartialEq,
-        ::core::cmp::Eq,
-        ::core::marker::Copy,
-        ::core::clone::Clone,
-        ::core::default::Default,
-    )]
+    #[derive(PartialEq, Eq, Copy, Clone, Default)]
     pub struct CV_HLSLMemorySpace_e(pub i32);
-    impl ::windows_core::TypeKind for CV_HLSLMemorySpace_e {
-        type TypeKind = ::windows_core::CopyType;
+    impl windows_core::TypeKind for CV_HLSLMemorySpace_e {
+        type TypeKind = windows_core::CopyType;
     }
-    impl ::core::fmt::Debug for CV_HLSLMemorySpace_e {
-        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+    impl core::fmt::Debug for CV_HLSLMemorySpace_e {
+        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
             f.debug_tuple("CV_HLSLMemorySpace_e")
                 .field(&self.0)
                 .finish()
         }
     }
     #[repr(transparent)]
-    #[derive(
-        ::core::cmp::PartialEq,
-        ::core::cmp::Eq,
-        ::core::marker::Copy,
-        ::core::clone::Clone,
-        ::core::default::Default,
-    )]
+    #[derive(PartialEq, Eq, Copy, Clone, Default)]
     pub struct CV_HLSLREG_e(pub i32);
-    impl ::windows_core::TypeKind for CV_HLSLREG_e {
-        type TypeKind = ::windows_core::CopyType;
+    impl windows_core::TypeKind for CV_HLSLREG_e {
+        type TypeKind = windows_core::CopyType;
     }
-    impl ::core::fmt::Debug for CV_HLSLREG_e {
-        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+    impl core::fmt::Debug for CV_HLSLREG_e {
+        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
             f.debug_tuple("CV_HLSLREG_e").field(&self.0).finish()
         }
     }
     #[repr(transparent)]
-    #[derive(
-        ::core::cmp::PartialEq,
-        ::core::cmp::Eq,
-        ::core::marker::Copy,
-        ::core::clone::Clone,
-        ::core::default::Default,
-    )]
+    #[derive(PartialEq, Eq, Copy, Clone, Default)]
     pub struct CV_HREG_e(pub i32);
-    impl ::windows_core::TypeKind for CV_HREG_e {
-        type TypeKind = ::windows_core::CopyType;
+    impl windows_core::TypeKind for CV_HREG_e {
+        type TypeKind = windows_core::CopyType;
     }
-    impl ::core::fmt::Debug for CV_HREG_e {
-        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+    impl core::fmt::Debug for CV_HREG_e {
+        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
             f.debug_tuple("CV_HREG_e").field(&self.0).finish()
         }
     }
     #[repr(transparent)]
-    #[derive(
-        ::core::cmp::PartialEq,
-        ::core::cmp::Eq,
-        ::core::marker::Copy,
-        ::core::clone::Clone,
-        ::core::default::Default,
-    )]
+    #[derive(PartialEq, Eq, Copy, Clone, Default)]
     pub struct CV_SourceChksum_t(pub i32);
-    impl ::windows_core::TypeKind for CV_SourceChksum_t {
-        type TypeKind = ::windows_core::CopyType;
+    impl windows_core::TypeKind for CV_SourceChksum_t {
+        type TypeKind = windows_core::CopyType;
     }
-    impl ::core::fmt::Debug for CV_SourceChksum_t {
-        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+    impl core::fmt::Debug for CV_SourceChksum_t {
+        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
             f.debug_tuple("CV_SourceChksum_t").field(&self.0).finish()
         }
     }
     #[repr(transparent)]
-    #[derive(
-        ::core::cmp::PartialEq,
-        ::core::cmp::Eq,
-        ::core::marker::Copy,
-        ::core::clone::Clone,
-        ::core::default::Default,
-    )]
+    #[derive(PartialEq, Eq, Copy, Clone, Default)]
     pub struct CV_access_e(pub i32);
-    impl ::windows_core::TypeKind for CV_access_e {
-        type TypeKind = ::windows_core::CopyType;
+    impl windows_core::TypeKind for CV_access_e {
+        type TypeKind = windows_core::CopyType;
     }
-    impl ::core::fmt::Debug for CV_access_e {
-        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+    impl core::fmt::Debug for CV_access_e {
+        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
             f.debug_tuple("CV_access_e").field(&self.0).finish()
         }
     }
     #[repr(transparent)]
-    #[derive(
-        ::core::cmp::PartialEq,
-        ::core::cmp::Eq,
-        ::core::marker::Copy,
-        ::core::clone::Clone,
-        ::core::default::Default,
-    )]
+    #[derive(PartialEq, Eq, Copy, Clone, Default)]
     pub struct CV_builtin_e(pub i32);
-    impl ::windows_core::TypeKind for CV_builtin_e {
-        type TypeKind = ::windows_core::CopyType;
+    impl windows_core::TypeKind for CV_builtin_e {
+        type TypeKind = windows_core::CopyType;
     }
-    impl ::core::fmt::Debug for CV_builtin_e {
-        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+    impl core::fmt::Debug for CV_builtin_e {
+        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
             f.debug_tuple("CV_builtin_e").field(&self.0).finish()
         }
     }
     #[repr(transparent)]
-    #[derive(
-        ::core::cmp::PartialEq,
-        ::core::cmp::Eq,
-        ::core::marker::Copy,
-        ::core::clone::Clone,
-        ::core::default::Default,
-    )]
+    #[derive(PartialEq, Eq, Copy, Clone, Default)]
     pub struct CV_call_e(pub i32);
-    impl ::windows_core::TypeKind for CV_call_e {
-        type TypeKind = ::windows_core::CopyType;
+    impl windows_core::TypeKind for CV_call_e {
+        type TypeKind = windows_core::CopyType;
     }
-    impl ::core::fmt::Debug for CV_call_e {
-        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+    impl core::fmt::Debug for CV_call_e {
+        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
             f.debug_tuple("CV_call_e").field(&self.0).finish()
         }
     }
     #[repr(transparent)]
-    #[derive(
-        ::core::cmp::PartialEq,
-        ::core::cmp::Eq,
-        ::core::marker::Copy,
-        ::core::clone::Clone,
-        ::core::default::Default,
-    )]
+    #[derive(PartialEq, Eq, Copy, Clone, Default)]
     pub struct CV_modifier_e(pub i32);
-    impl ::windows_core::TypeKind for CV_modifier_e {
-        type TypeKind = ::windows_core::CopyType;
+    impl windows_core::TypeKind for CV_modifier_e {
+        type TypeKind = windows_core::CopyType;
     }
-    impl ::core::fmt::Debug for CV_modifier_e {
-        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+    impl core::fmt::Debug for CV_modifier_e {
+        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
             f.debug_tuple("CV_modifier_e").field(&self.0).finish()
         }
     }
     #[repr(transparent)]
-    #[derive(
-        ::core::cmp::PartialEq,
-        ::core::cmp::Eq,
-        ::core::marker::Copy,
-        ::core::clone::Clone,
-        ::core::default::Default,
-    )]
+    #[derive(PartialEq, Eq, Copy, Clone, Default)]
     pub struct DataKind(pub i32);
-    impl ::windows_core::TypeKind for DataKind {
-        type TypeKind = ::windows_core::CopyType;
+    impl windows_core::TypeKind for DataKind {
+        type TypeKind = windows_core::CopyType;
     }
-    impl ::core::fmt::Debug for DataKind {
-        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+    impl core::fmt::Debug for DataKind {
+        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
             f.debug_tuple("DataKind").field(&self.0).finish()
         }
     }
     #[repr(transparent)]
-    #[derive(
-        ::core::cmp::PartialEq,
-        ::core::cmp::Eq,
-        ::core::marker::Copy,
-        ::core::clone::Clone,
-        ::core::default::Default,
-    )]
+    #[derive(PartialEq, Eq, Copy, Clone, Default)]
     pub struct LocationType(pub i32);
-    impl ::windows_core::TypeKind for LocationType {
-        type TypeKind = ::windows_core::CopyType;
+    impl windows_core::TypeKind for LocationType {
+        type TypeKind = windows_core::CopyType;
     }
-    impl ::core::fmt::Debug for LocationType {
-        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+    impl core::fmt::Debug for LocationType {
+        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
             f.debug_tuple("LocationType").field(&self.0).finish()
         }
     }
     #[repr(transparent)]
-    #[derive(
-        ::core::cmp::PartialEq,
-        ::core::cmp::Eq,
-        ::core::marker::Copy,
-        ::core::clone::Clone,
-        ::core::default::Default,
-    )]
+    #[derive(PartialEq, Eq, Copy, Clone, Default)]
     pub struct MemoryTypeEnum(pub i32);
-    impl ::windows_core::TypeKind for MemoryTypeEnum {
-        type TypeKind = ::windows_core::CopyType;
+    impl windows_core::TypeKind for MemoryTypeEnum {
+        type TypeKind = windows_core::CopyType;
     }
-    impl ::core::fmt::Debug for MemoryTypeEnum {
-        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+    impl core::fmt::Debug for MemoryTypeEnum {
+        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
             f.debug_tuple("MemoryTypeEnum").field(&self.0).finish()
         }
     }
     #[repr(transparent)]
-    #[derive(
-        ::core::cmp::PartialEq,
-        ::core::cmp::Eq,
-        ::core::marker::Copy,
-        ::core::clone::Clone,
-        ::core::default::Default,
-    )]
+    #[derive(PartialEq, Eq, Copy, Clone, Default)]
     pub struct NameSearchOptions(pub i32);
-    impl ::windows_core::TypeKind for NameSearchOptions {
-        type TypeKind = ::windows_core::CopyType;
+    impl windows_core::TypeKind for NameSearchOptions {
+        type TypeKind = windows_core::CopyType;
     }
-    impl ::core::fmt::Debug for NameSearchOptions {
-        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+    impl core::fmt::Debug for NameSearchOptions {
+        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
             f.debug_tuple("NameSearchOptions").field(&self.0).finish()
         }
     }
     #[repr(transparent)]
-    #[derive(
-        ::core::cmp::PartialEq,
-        ::core::cmp::Eq,
-        ::core::marker::Copy,
-        ::core::clone::Clone,
-        ::core::default::Default,
-    )]
+    #[derive(PartialEq, Eq, Copy, Clone, Default)]
     pub struct StackFrameTypeEnum(pub i32);
-    impl ::windows_core::TypeKind for StackFrameTypeEnum {
-        type TypeKind = ::windows_core::CopyType;
+    impl windows_core::TypeKind for StackFrameTypeEnum {
+        type TypeKind = windows_core::CopyType;
     }
-    impl ::core::fmt::Debug for StackFrameTypeEnum {
-        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+    impl core::fmt::Debug for StackFrameTypeEnum {
+        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
             f.debug_tuple("StackFrameTypeEnum").field(&self.0).finish()
         }
     }
     #[repr(transparent)]
-    #[derive(
-        ::core::cmp::PartialEq,
-        ::core::cmp::Eq,
-        ::core::marker::Copy,
-        ::core::clone::Clone,
-        ::core::default::Default,
-    )]
+    #[derive(PartialEq, Eq, Copy, Clone, Default)]
     pub struct SymTag(pub i32);
-    impl ::windows_core::TypeKind for SymTag {
-        type TypeKind = ::windows_core::CopyType;
+    impl windows_core::TypeKind for SymTag {
+        type TypeKind = windows_core::CopyType;
     }
-    impl ::core::fmt::Debug for SymTag {
-        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+    impl core::fmt::Debug for SymTag {
+        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
             f.debug_tuple("SymTag").field(&self.0).finish()
         }
     }
     #[repr(transparent)]
-    #[derive(
-        ::core::cmp::PartialEq,
-        ::core::cmp::Eq,
-        ::core::marker::Copy,
-        ::core::clone::Clone,
-        ::core::default::Default,
-    )]
+    #[derive(PartialEq, Eq, Copy, Clone, Default)]
     pub struct THUNK_ORDINAL(pub i32);
-    impl ::windows_core::TypeKind for THUNK_ORDINAL {
-        type TypeKind = ::windows_core::CopyType;
+    impl windows_core::TypeKind for THUNK_ORDINAL {
+        type TypeKind = windows_core::CopyType;
     }
-    impl ::core::fmt::Debug for THUNK_ORDINAL {
-        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+    impl core::fmt::Debug for THUNK_ORDINAL {
+        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
             f.debug_tuple("THUNK_ORDINAL").field(&self.0).finish()
         }
     }
     #[repr(transparent)]
-    #[derive(
-        ::core::cmp::PartialEq,
-        ::core::cmp::Eq,
-        ::core::marker::Copy,
-        ::core::clone::Clone,
-        ::core::default::Default,
-    )]
+    #[derive(PartialEq, Eq, Copy, Clone, Default)]
     pub struct UdtKind(pub i32);
-    impl ::windows_core::TypeKind for UdtKind {
-        type TypeKind = ::windows_core::CopyType;
+    impl windows_core::TypeKind for UdtKind {
+        type TypeKind = windows_core::CopyType;
     }
-    impl ::core::fmt::Debug for UdtKind {
-        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+    impl core::fmt::Debug for UdtKind {
+        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
             f.debug_tuple("UdtKind").field(&self.0).finish()
         }
     }
-    #[repr(transparent)]
-    #[derive(
-        ::core::cmp::PartialEq,
-        ::core::cmp::Eq,
-        ::core::marker::Copy,
-        ::core::clone::Clone,
-        ::core::default::Default,
-    )]
-    pub struct __MIDL___MIDL_itf_dia2_0000_0036_0001(pub i32);
-    impl ::windows_core::TypeKind for __MIDL___MIDL_itf_dia2_0000_0036_0001 {
-        type TypeKind = ::windows_core::CopyType;
-    }
-    impl ::core::fmt::Debug for __MIDL___MIDL_itf_dia2_0000_0036_0001 {
-        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
-            f.debug_tuple("__MIDL___MIDL_itf_dia2_0000_0036_0001")
-                .field(&self.0)
-                .finish()
-        }
-    }
     #[repr(C)]
+    #[derive(Clone, Copy, Debug, Eq, PartialEq)]
     pub struct DiaAddressMapEntry {
         pub rva: u32,
         pub rvaTo: u32,
     }
-    impl ::core::marker::Copy for DiaAddressMapEntry {}
-    impl ::core::clone::Clone for DiaAddressMapEntry {
-        fn clone(&self) -> Self {
-            *self
-        }
-    }
-    impl ::core::fmt::Debug for DiaAddressMapEntry {
-        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
-            f.debug_struct("DiaAddressMapEntry")
-                .field("rva", &self.rva)
-                .field("rvaTo", &self.rvaTo)
-                .finish()
-        }
-    }
-    impl ::windows_core::TypeKind for DiaAddressMapEntry {
-        type TypeKind = ::windows_core::CopyType;
+    impl windows_core::TypeKind for DiaAddressMapEntry {
+        type TypeKind = windows_core::CopyType;
     }
-    impl ::core::cmp::PartialEq for DiaAddressMapEntry {
-        fn eq(&self, other: &Self) -> bool {
-            self.rva == other.rva && self.rvaTo == other.rvaTo
-        }
-    }
-    impl ::core::cmp::Eq for DiaAddressMapEntry {}
-    impl ::core::default::Default for DiaAddressMapEntry {
+    impl Default for DiaAddressMapEntry {
         fn default() -> Self {
-            unsafe { ::core::mem::zeroed() }
+            unsafe { core::mem::zeroed() }
         }
     }
+    pub const DiaSource: windows_core::GUID =
+        windows_core::GUID::from_u128(0xe6756135_1e65_4d17_8576_610761398c3c);
+    pub const DiaSourceAlt: windows_core::GUID =
+        windows_core::GUID::from_u128(0x91904831_49ca_4766_b95c_25397e2dd6dc);
+    pub const DiaStackWalker: windows_core::GUID =
+        windows_core::GUID::from_u128(0xce4a85db_5768_475b_a4e1_c0bca2112a6b);
     #[repr(C)]
+    #[derive(Clone, Copy, Debug, Eq, PartialEq)]
     pub struct DiaTagValue {
         pub value: [u8; 16],
         pub valueSizeBytes: u8,
     }
-    impl ::core::marker::Copy for DiaTagValue {}
-    impl ::core::clone::Clone for DiaTagValue {
-        fn clone(&self) -> Self {
-            *self
-        }
-    }
-    impl ::core::fmt::Debug for DiaTagValue {
-        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
-            f.debug_struct("DiaTagValue")
-                .field("value", &self.value)
-                .field("valueSizeBytes", &self.valueSizeBytes)
-                .finish()
-        }
-    }
-    impl ::windows_core::TypeKind for DiaTagValue {
-        type TypeKind = ::windows_core::CopyType;
-    }
-    impl ::core::cmp::PartialEq for DiaTagValue {
-        fn eq(&self, other: &Self) -> bool {
-            self.value == other.value && self.valueSizeBytes == other.valueSizeBytes
-        }
+    impl windows_core::TypeKind for DiaTagValue {
+        type TypeKind = windows_core::CopyType;
     }
-    impl ::core::cmp::Eq for DiaTagValue {}
-    impl ::core::default::Default for DiaTagValue {
+    impl Default for DiaTagValue {
         fn default() -> Self {
-            unsafe { ::core::mem::zeroed() }
+            unsafe { core::mem::zeroed() }
         }
     }
     #[repr(C)]
-    pub struct __MIDL___MIDL_itf_dia2_0000_0045_0001 {
+    #[derive(Clone, Copy, Debug, Eq, PartialEq)]
+    pub struct __MIDL___MIDL_itf_dia2_0000_0049_0001 {
         pub ulOffStart: u32,
         pub cbProcSize: u32,
         pub cdwLocals: u32,
         pub cdwParams: u16,
         pub cdwFlags: u16,
     }
-    impl ::core::marker::Copy for __MIDL___MIDL_itf_dia2_0000_0045_0001 {}
-    impl ::core::clone::Clone for __MIDL___MIDL_itf_dia2_0000_0045_0001 {
-        fn clone(&self) -> Self {
-            *self
-        }
-    }
-    impl ::core::fmt::Debug for __MIDL___MIDL_itf_dia2_0000_0045_0001 {
-        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
-            f.debug_struct("__MIDL___MIDL_itf_dia2_0000_0045_0001")
-                .field("ulOffStart", &self.ulOffStart)
-                .field("cbProcSize", &self.cbProcSize)
-                .field("cdwLocals", &self.cdwLocals)
-                .field("cdwParams", &self.cdwParams)
-                .field("cdwFlags", &self.cdwFlags)
-                .finish()
-        }
-    }
-    impl ::windows_core::TypeKind for __MIDL___MIDL_itf_dia2_0000_0045_0001 {
-        type TypeKind = ::windows_core::CopyType;
-    }
-    impl ::core::cmp::PartialEq for __MIDL___MIDL_itf_dia2_0000_0045_0001 {
-        fn eq(&self, other: &Self) -> bool {
-            self.ulOffStart == other.ulOffStart
-                && self.cbProcSize == other.cbProcSize
-                && self.cdwLocals == other.cdwLocals
-                && self.cdwParams == other.cdwParams
-                && self.cdwFlags == other.cdwFlags
-        }
+    impl windows_core::TypeKind for __MIDL___MIDL_itf_dia2_0000_0049_0001 {
+        type TypeKind = windows_core::CopyType;
     }
-    impl ::core::cmp::Eq for __MIDL___MIDL_itf_dia2_0000_0045_0001 {}
-    impl ::core::default::Default for __MIDL___MIDL_itf_dia2_0000_0045_0001 {
+    impl Default for __MIDL___MIDL_itf_dia2_0000_0049_0001 {
         fn default() -> Self {
-            unsafe { ::core::mem::zeroed() }
+            unsafe { core::mem::zeroed() }
         }
     }
+    pub type PFNMINIPDBERRORCALLBACK2 = Option<
+        unsafe extern "system" fn(
+            pvcontext: *mut core::ffi::c_void,
+            dwerrorcode: u32,
+            szobjorpdb: windows_core::PCWSTR,
+            szlib: windows_core::PCWSTR,
+        ) -> windows_core::HRESULT,
+    >;
 }