diff --git a/.github/copilot-instructions.md b/.github/copilot-instructions.md new file mode 100644 index 000000000..7c3e75261 --- /dev/null +++ b/.github/copilot-instructions.md @@ -0,0 +1,75 @@ +# Copilot Instructions for win32metadata + +## Build Commands + +```powershell +# Full build (25-30 min): build tools, scrape headers, emit winmd, package, test +./DoAll.ps1 -Clean + +# Incremental build (faster, skips packages/samples) +./DoAll.ps1 -ExcludePackages -ExcludeSamples + +# Build just the build tools (MetadataTasks, ConstantsScraper, ClangSharpSourceToWinmd, etc.) +dotnet build BuildTools -c Release + +# Build the winmd only (requires tools built first) +dotnet build generation/WinSDK -c Release -t:EmitWinmd + +# Scrape a single partition (useful for debugging) +dotnet build generation/WinSDK -c Release -p:ScanArch=crossarch -t:ScrapeHeaders -p:PartitionFilter=Foundation +``` + +## Test Commands + +```powershell +# Run all tests +./scripts/DoTests.ps1 + +# Individual test suites +dotnet test tests/MetadataUtils.Tests -c Release +dotnet test tests/Windows.Win32.Tests -c Release # winmd integrity tests +dotnet test tests/Win32MetadataScraperTests -c Release # scraper heuristic tests +dotnet test tests/ClangSharpSourceToWinmdTests -c Release + +# Single test +dotnet test tests/Win32MetadataScraperTests -c Release --filter "TransitiveInclude" +``` + +## Architecture + +The toolchain converts Windows SDK C/C++ headers into a .NET metadata assembly (`Windows.Win32.winmd`). + +**Pipeline stages** (in order, defined in `sources/GeneratorSdk/sdk/sdk.targets`): +1. **ScrapeHeaders** — `Win32MetadataScraper` hosts ClangSharp PInvokeGenerator as a library, walks the AST to auto-discover typedef-tag remappings, then generates C# bindings per partition +2. **ScrapeConstants** — `ConstantsScraper` extracts `#define` constants via regex matching on headers +3. **EmitWinmd** — `ClangSharpSourceToWinmd` compiles the generated C# into the final winmd + +**Key projects:** +- `Win32MetadataScraper` — Single-pass scraper: parses the translation unit, discovers remaps from the AST, merges with manual config, calls PInvokeGenerator.GenerateBindings on the same TU +- `ClangSharpSourceToWinmd` — Reads generated C# sources, applies `MetadataSyntaxTreeCleaner` transformations (memberRemap, enum additions), emits the winmd via System.Reflection.Metadata +- `MetadataTasks` — MSBuild tasks (`ScrapeHeaders`, `EmitWinmd`, etc.) that orchestrate the pipeline +- `WinmdUtils` — CLI for winmd inspection (duplicate detection, suggested remappings, etc.) + +**Partition system:** Each Win32 API area (Foundation, Kernel, DirectX, etc.) is a "partition" in `generation/WinSDK/Partitions/`. Each has a `main.cpp` (header includes) and optional `settings.rsp` (per-partition config). Partitions are scraped in parallel. + +**Response files (.rsp):** Configuration is heavily RSP-based. Key files in `generation/WinSDK/`: +- `scraper.settings.rsp` — Type remaps (`--remap`), exclusions (`--exclude`), type overrides (`--with-type`) +- `emitter.settings.rsp` — Member remaps (`--memberRemap`), enum additions +- `autoTypes.json` — Handle/typedef definitions (RAII close functions, invalid values) +- `functionPointerFixups.json` — Function pointer prototype→alias pairs + +**CI pipeline** (`azure-pipelines.yml` / `.github/workflows/pr-validation.yml`): +Three parallel scrape jobs (x64, x86, arm64) → artifacts merged → one build/test/package job. +Each arch job scrapes ALL partitions for that architecture. + +## Key Conventions + +**NuGet feed:** The repo uses a private ADO Artifact Feed (`Win32Metadata-Dependencies`) as its sole package source. New packages from nuget.org must be saved to this feed first. + +**Winmd equivalence:** After any change, the winmd must be compared against the baseline. The `NoSuggestedRemappings` test in `Windows.Win32.Tests` validates that no new unhandled remappings were introduced. Changes to the winmd are tracked in `scripts/ChangesSinceLastRelease.txt`. + +**Cross-partition remaps:** Remaps in `scraper.settings.rsp` are global — they apply to all partitions. Auto-discovered remaps (from `Win32MetadataScraper`) are per-partition. If a tag name is used across partitions but the typedef is only in one partition's headers, the remap must be global (in `scraper.settings.rsp`) OR the referencing partition must `#include` the header with the typedef. + +**C++ namespace types:** Types inside C++ namespaces (`Gdiplus::Status`, `ABI::Windows::*`) are handled by PInvokeGenerator internally. The auto-remap discovery skips namespace-qualified tags. + +**ClangSharp version pinning:** The repo pins ClangSharp v17.0.1. `Win32MetadataScraper` references ClangSharp NuGet packages directly; native libs (`libclang.dll`, `libClangSharp.dll`) are resolved at runtime via NuGet's `runtime.json` mechanism. diff --git a/BuildTools/BuildTools.proj b/BuildTools/BuildTools.proj index 7d002440c..f385d879c 100644 --- a/BuildTools/BuildTools.proj +++ b/BuildTools/BuildTools.proj @@ -4,6 +4,7 @@ + diff --git a/docs/copilot/plans/annotation-validation-results.md b/docs/copilot/plans/annotation-validation-results.md new file mode 100644 index 000000000..dec1ab734 --- /dev/null +++ b/docs/copilot/plans/annotation-validation-results.md @@ -0,0 +1,335 @@ +# Annotation Validation Results + +*Validated: March 2026* +*ClangSharp: v17.0.1 and v18.1.0.4 | Clang: via libclang | Platform: x64* + +--- + +## Key Finding: Upgrade ClangSharp to v18+ + +ClangSharp v17.0.1 (currently pinned in this repo) only preserves +`__attribute__((annotate(...)))` on **parameters**. All other placements +(functions, return values, struct fields, typedefs) are silently dropped. + +ClangSharp v18.1.0.4+ (via PR [#552](https://github.com/dotnet/ClangSharp/pull/552)) +adds `[NativeAnnotation("...")]` support that preserves annotate attributes on +**all declaration types**. We validated this — every proposed annotation works. +**Upgrading to v18+ is the path forward.** + +--- + +## Validation Workflow + +This workflow validates whether a proposed header annotation is carried through +ClangSharp into the generated C# output (and thus into the final .winmd). + +### Prerequisites + +- .NET 8.0+ SDK +- `ClangSharpPInvokeGenerator` **v18.1.0.4+** (installed via `dotnet tool install --global`) + - v17.0.1 only supports parameter-level annotations + - v18+ adds `[NativeAnnotation]` for all declaration types +- Windows SDK headers (or the `RecompiledIdlHeaders` from this repo) + +### Steps + +1. **Create test header** (`test_annotations.h`) with the proposed annotations + using `__attribute__((annotate("w32m:...")))` macros + +2. **Create main.cpp** that includes the test header with: + ```cpp + #define _WIN32METADATA_ 1 + #include + #include "test_annotations.h" + ``` + +3. **Run ClangSharp** with the same flags used by the real build: + ```powershell + ClangSharpPInvokeGenerator ` + --file main.cpp --output output.cs --namespace Test --methodClassName Apis ` + --include-directory ` + --traverse test_annotations.h ` + --additional "-D_USE_DECLSPECS_FOR_SAL=1" ` + --additional "-D_PREFAST_=1" ` + --additional "-D_WIN32METADATA_=1" ` + --additional "-D_AMD64_=1" --additional "-m64" ` + --config compatible-codegen ` + --config generate-cpp-attributes ` + --config exclude-funcs-with-body + ``` + +4. **Examine `output.cs`** for `[CppAttributeList("w32m:...")]` attributes. + - If present on the correct declaration → annotation works ✅ + - If absent → annotation is dropped by ClangSharp ❌ + +5. **Check for warnings** about "Unsupported attribute: 'Annotate'" — + these indicate ClangSharp saw the attribute but doesn't know how to + handle it at that location (v17 only handles annotate on parameters; + v18+ handles all declaration types). + +### Test Files Location + +All validation test files are in `obj/annotation-validation/`: +- `win32metadata.h` — Annotation macro definitions +- `test_annotations.h` — Primary test cases (19 scenarios) +- `test_alternatives.h` — Alternative mechanism tests (8 scenarios) +- `test_returnval.h` — Return value annotation tests (4 scenarios) +- `main.cpp` — Entry point +- `output.cs` — Generated C# output (the evidence) + +--- + +## Results Summary + +### ClangSharp v17.0.1 (currently pinned) + +| Annotation Target | Works? | Output Attribute | +|---|---|---| +| **Function parameter** | ✅ YES | `[CppAttributeList("w32m:...")]` | +| **Multiple attrs on same param** | ✅ YES | Concatenated with `^` separator | +| **Function pointer param** | ✅ YES | Same as regular params | +| **SAL + custom coexistence** | ✅ YES | Both present | +| **Function declaration** | ❌ NO | Dropped — "Unsupported attribute: 'Annotate'" | +| **Return value** | ❌ NO | Dropped | +| **Between return type and name** | ❌ NO | Dropped | +| **`__declspec` on function** | ❌ NO | Dropped | +| **typedef** | ❌ NO | Dropped | +| **struct field** | ❌ NO | Dropped | + +### ClangSharp v18.1.0.4+ (recommended upgrade) + +| Annotation Target | Works? | Output Attribute | +|---|---|---| +| **Function parameter** | ✅ YES | Both `[CppAttributeList]` AND `[NativeAnnotation]` | +| **Multiple attrs on same param** | ✅ YES | Each as separate `[NativeAnnotation]` | +| **Function declaration** | ✅ YES | `[NativeAnnotation("w32m:...")]` on method | +| **Multiple attrs on function** | ✅ YES | Each as separate `[NativeAnnotation]` | +| **Return value** | ✅ YES | `[NativeAnnotation("w32m:...")]` on method | +| **struct field** | ✅ YES | `[NativeAnnotation("w32m:...")]` on field | +| **Function pointer/delegate** | ✅ YES | `[NativeAnnotation("w32m:...")]` on delegate | +| **SAL + custom coexistence** | ✅ YES | Both present without interference | +| **`__declspec` on function** | ❌ NO | Still dropped (not needed) | +| **typedef** | ⚠️ PARTIAL | Annotation preserved but typedef may be flattened | + +### By Proposed Annotation (with v18+) + +| Annotation | Target | v17 | v18 | +|---|---|---|---| +| `_Sets_last_error_` | function | ❌ | ✅ | +| `_Min_os_version_(ver)` | function | ❌ | ✅ | +| `_Must_close_with_(func)` | function/return | ❌ | ✅ | +| `_Can_return_errors_as_success_` | function | ❌ | ✅ | +| `_Multiple_success_values_` | function | ❌ | ✅ | +| `_Com_out_ptr_w32m_` | parameter | ✅ | ✅ | +| `_Do_not_release_` | parameter | ✅ | ✅ | +| `_Not_null_terminated_w32m_` | parameter | ✅ | ✅ | +| `_Null_null_terminated_w32m_` | parameter | ✅ | ✅ | +| `_Array_count_param_(n)` | parameter | ✅ | ✅ | +| `_Array_count_(n)` | parameter | ✅ | ✅ | +| `_Memory_size_param_(n)` | parameter | ✅ | ✅ | +| `_Enum_type_(name)` | parameter | ✅ | ✅ | +| `_Enum_type_(name)` | struct field | ❌ | ✅ | +| `_Not_null_terminated_` | struct field | ❌ | ✅ | +| `_Close_handle_with_(func)` | typedef | ❌ | ⚠️ | +| `_Invalid_handle_(val)` | typedef | ❌ | ⚠️ | +| `_Also_usable_for_(type)` | typedef | ❌ | ⚠️ | + +--- + +## Detailed Evidence (v18.1.0.4) + +### Function-Level Annotations — NOW WORK ✅ + +**Test: `_Sets_last_error_` on function** +```c +// Header: +_Sets_last_error_ // expands to __attribute__((annotate("w32m:setlasterror"))) +BOOL TestSetLastError_FuncDecl(LPCSTR lpFileName); + +// v17 output: NO annotation (dropped) +// v18 output: +[NativeAnnotation("w32m:setlasterror")] // ✅ PRESENT +public static extern int TestSetLastError_FuncDecl(...); +``` + +**Test: Multiple function-level annotations** +```c +_Sets_last_error_ +_Min_os_version_(6.0.6000) +BOOL TestMultipleAnnotations(DWORD dwParam); + +// v18 output — each annotation is a separate attribute: +[NativeAnnotation("w32m:setlasterror")] // ✅ +[NativeAnnotation("w32m:minversion=6.0.6000")] // ✅ +public static extern int TestMultipleAnnotations(...); +``` + +**Test: Combined function + parameter annotations** +```c +_Sets_last_error_ +_Min_os_version_(10.0.22000) +_Must_close_with_(TestClose_Combined) +HANDLE TestCombined( + _Enum_type_(CREATE_FLAGS) DWORD dwFlags, + _Not_null_terminated_w32m_ LPCSTR lpData, + DWORD cbData, + _Com_out_ptr_w32m_ void** ppResult); + +// v18 output: +[NativeAnnotation("w32m:setlasterror")] // ✅ function +[NativeAnnotation("w32m:minversion=10.0.22000")] // ✅ function +[NativeAnnotation("w32m:raiifree=TestClose_Combined")] // ✅ function +public static extern void* TestCombined( + [NativeAnnotation("w32m:enumtype=CREATE_FLAGS")] ..., // ✅ param + [NativeAnnotation("w32m:notnullterm")] ..., // ✅ param + ..., + [NativeAnnotation("w32m:comoutptr")] ...); // ✅ param +``` + +### Return Value Annotations — NOW WORK ✅ + +```c +_Must_close_with_(CloseHandle) +HANDLE TestReturnAnnotate1(LPCSTR lpName); + +HANDLE __attribute__((annotate("w32m:raiifree=FindClose"))) + TestReturnAnnotate2(LPCSTR lpName); + +HANDLE TestReturnAnnotate3(LPCSTR lpName) + __attribute__((annotate("w32m:raiifree=RegCloseKey"))); + +// v18 output — all three placements work: +[NativeAnnotation("w32m:raiifree=CloseHandle")] // ✅ +public static extern void* TestReturnAnnotate1(...); + +[NativeAnnotation("w32m:raiifree=FindClose")] // ✅ +public static extern void* TestReturnAnnotate2(...); + +[NativeAnnotation("w32m:raiifree=RegCloseKey")] // ✅ +public static extern void* TestReturnAnnotate3(...); +``` + +### Struct Field Annotations — NOW WORK ✅ + +```c +typedef struct _TEST_STRUCT { + DWORD dwSize; + _Enum_type_(TEST_FLAGS) DWORD dwFlags; + _Not_null_terminated_w32m_ LPCSTR lpData; + DWORD cbData; +} TEST_STRUCT; + +// v18 output: +public unsafe partial struct _TEST_STRUCT +{ + public uint dwSize; + + [NativeAnnotation("w32m:enumtype=TEST_FLAGS")] // ✅ PRESENT + public uint dwFlags; + + [NativeAnnotation("w32m:notnullterm")] // ✅ PRESENT + public sbyte* lpData; + + public uint cbData; +} +``` + +### SAL + Custom Annotations Coexist ✅ + +```c +_Sets_last_error_ +_Min_os_version_(10.0.10240) +BOOL TestWithSAL( + _In_ LPCSTR lpFileName, + _Out_ DWORD* pdwResult, + _Com_out_ptr_w32m_ void** ppInterface); + +// v18 output: +[NativeAnnotation("w32m:setlasterror")] // ✅ our function annotation +[NativeAnnotation("w32m:minversion=10.0.10240")] // ✅ our function annotation +public static extern int TestWithSAL( + [CppAttributeList("Name=SAL_name; p1=\"_In_\"...")] // SAL preserved + [NativeAnnotation("Name=SAL_name; ...")] // SAL also as NativeAnnotation + sbyte* lpFileName, + ... + [NativeAnnotation("w32m:comoutptr")] // ✅ our param annotation + void** ppInterface); +``` + +### Parameter Annotations — Still Work ✅ + +All parameter annotations from v17 continue to work in v18. In v18, they appear +as BOTH `[CppAttributeList]` (v17 format) AND `[NativeAnnotation]` (v18 format). +Multiple annotations on the same parameter appear as separate `[NativeAnnotation]` +entries (cleaner than v17's `^`-separated concatenation). + +--- + +## What Still Doesn't Work + +| Mechanism | Status | Notes | +|---|---|---| +| `__declspec` on function | ❌ | Not needed — `__attribute__((annotate))` covers everything | +| typedef annotations | ⚠️ | Annotation is preserved on usages, but simple typedefs (e.g., `typedef void* HANDLE`) are flattened by ClangSharp — the typedef itself doesn't appear as a named type in output. Handle types from `autoTypes.json` are structurally generated and will continue to need their JSON definition. | + +--- + +## How v18's `NativeAnnotation` Works + +ClangSharp v18+ (PR [#552](https://github.com/dotnet/ClangSharp/pull/552)) added a +`NativeAnnotation` attribute that is emitted whenever Clang reports an `AnnotateAttr` +on any declaration. This is fundamentally different from v17's `CppAttributeList`: + +| Aspect | v17 `CppAttributeList` | v18 `NativeAnnotation` | +|---|---|---| +| Supported on parameters | ✅ | ✅ | +| Supported on functions | ❌ | ✅ | +| Supported on struct fields | ❌ | ✅ | +| Supported on return values | ❌ | ✅ | +| Supported on types | ❌ | ✅ | +| Multiple annotations | Concatenated with `^` | Separate attributes | +| String escaping | Basic | Proper (PR #572) | + +The `NativeAnnotation` attribute is emitted under the same conditions as +`NativeTypeNameAttribute` — whenever the declaration has at least one +`annotate` attribute. The annotation string is the verbatim argument +to `__attribute__((annotate("...")))`. + +### Emitter Processing Required + +`MetadataSyntaxTreeCleaner` currently processes `CppAttributeList` to extract +SAL annotations. For v18+, it needs a parallel path to process `NativeAnnotation` +attributes with the `w32m:` prefix: + +```csharp +case "NativeAnnotation": +{ + var text = GetAttributeStringArg(firstAttr); + if (text.StartsWith("w32m:")) + return ProcessWin32MetadataAnnotation(text.Substring(5)); + break; +} +``` + +--- + +## Appendix: v17 Workarounds (Retained for Reference) + +These workarounds were validated during v17 testing but are **no longer needed** +with v18+. They are documented here in case v18 upgrade is delayed. + +### Carrier-Parameter Pattern + +Encode function-level metadata as annotations on the first parameter: +```c +BOOL AltC_MetaOnFirstParam( + __attribute__((annotate("w32m:func_setlasterror"))) + __attribute__((annotate("w32m:func_minversion=10.0.19041"))) + DWORD dwParam, HANDLE hObject); + +// v17 output: +[CppAttributeList("w32m:func_setlasterror^w32m:func_minversion=10.0.19041")] +uint dwParam // ✅ Function metadata carried on first param +``` + +**Limitations:** Semantically incorrect; doesn't work for zero-parameter functions. diff --git a/docs/copilot/plans/auto-type-remappings-plan.md b/docs/copilot/plans/auto-type-remappings-plan.md new file mode 100644 index 000000000..a9d10b347 --- /dev/null +++ b/docs/copilot/plans/auto-type-remappings-plan.md @@ -0,0 +1,413 @@ +# Auto-Derive Typedef-Tag Remappings from ClangSharp's AST + +*Created: March 2026* +*Updated: April 2026* +*Branch: user/jevansa/win32metadata-scraper* + +--- + +## Problem Statement + +`scraper.settings.rsp` contained ~12,700 `--remap` entries that tell ClangSharp to +rename C/C++ tag names to their typedef names in generated C# output. For example: + +``` +--remap +_BLUETOOTH_ADDRESS=BLUETOOTH_ADDRESS +tagDEC=DECIMAL +_RTL_BARRIER=SYNCHRONIZATION_BARRIER +__MIDL___MIDL_itf_foo_0001=RealTypeName +``` + +These are manually maintained. When the Windows SDK adds new types, someone must +manually add corresponding remap entries. If they don't, types appear in the winmd +with internal names like `_FOO` instead of their public typedef name `FOO`. + +Similarly, `functionPointerFixups.json` contained ~575 manual entries mapping +function pointer prototypes to their pointer typedef aliases (e.g., +`TIMECALLBACK` → `LPTIMECALLBACK`). + +A previous attempt used a text-based regex scanner to parse raw SDK headers. This +fundamentally failed because it can't handle macro-expanded names (e.g., +`VK_TO_WCHARS1` is produced by `##` token-pasting — it never appears literally in +the header source). + +## Solution: Win32MetadataScraper (Single-Pass AST Discovery) + +A new standalone tool (`Win32MetadataScraper`) replaces the stock +`ClangSharpPInvokeGenerator` CLI. It hosts PInvokeGenerator as a library (via NuGet +package references), parses the translation unit, walks the ClangSharp AST to +discover typedef-tag and function pointer remappings, merges them with the +configured `--remap` entries, then runs `PInvokeGenerator.GenerateBindings` with +the full merged remap set — all in a single parse pass. + +### Why a custom scraper tool? + +- **Single parse per partition** — parses once, walks AST for discovery AND + generates C# output in the same pass. +- **Process isolation** — each partition runs in its own `dotnet` process, + eliminating shared libclang state, thread safety, and file contention concerns. +- **No public API** — `PInvokeGenerator` is `sealed` with no extensibility hooks. + Walking the AST via ClangSharp's public types is the only supported approach. +- **No reflection** — unlike the earlier `ClangSharpWorker` prototype, this tool + uses ClangSharp's public AST types (`TypedefDecl`, `TagType`, `PointerType`, + etc.) directly, not reflection on PInvokeGenerator internals. + +### Architecture + +``` +┌─────────────────────────────────────────────────────────────────┐ +│ ScrapeHeaders.ProcessPartition (per partition, parallel) │ +│ │ +│ 1. Build RSP files + CommandLineBuilder args │ +│ 2. dotnet "Win32MetadataScraper.dll" @rsp1 @rsp2 │ +│ └─ Own process (complete isolation) │ +│ └─ Parses TU via CXTranslationUnit.TryParse │ +│ └─ RemapDiscovery.WalkTranslationUnit(AST) │ +│ ├─ Discovers tag→typedef pairs │ +│ ├─ Discovers fn ptr prototype→alias pairs │ +│ └─ Resolves & filters using heuristics │ +│ └─ Merges auto-remaps + fn ptr fixups + configured remaps │ +│ └─ Runs PInvokeGenerator.GenerateBindings(same TU) │ +│ └─ Writes .remaps sidecar file │ +│ 3. ScrapeHeaders reads .remaps → merges into discovered sets │ +└─────────────────────────────────────────────────────────────────┘ + │ + ▼ + WriteAutoRemapsRsp() in Execute() + → scraper.autoRemaps.generated.rsp (tag remaps) + → emitter.autoFnPtr.generated.rsp (reducePointerLevel) + (consumed on subsequent builds via @(ScraperRsp) / @(EmitterRsp)) +``` + +### Key Components + +**Win32MetadataScraper** (`sources/Win32MetadataScraper/Program.cs`) + +A standalone console app that: +1. Receives ` @rsp1 @rsp2 ...` as CLI args +2. Parses RSP files to extract all PInvokeGenerator settings +3. Parses the translation unit via `CXTranslationUnit.TryParse` +4. Calls `RemapDiscovery.WalkTranslationUnit` to discover typedef-tag and fn ptr relationships +5. Resolves and filters discoveries using heuristics +6. Merges auto-discovered remaps with configured ones (configured wins) +7. Creates `PInvokeGeneratorConfiguration` with merged remaps +8. Runs `GenerateBindings()` → writes C# output via `MemoryStream` factory +9. Writes auto-discovered entries to `.remaps` sidecar file + +**RemapDiscovery** (`sources/Win32MetadataScraper/RemapDiscovery.cs`) + +Static class with AST walking and heuristic resolution: +- `WalkTranslationUnit()` — walks all `TypedefDecl` nodes to find tag→typedef and + function pointer prototype→alias relationships +- `ResolveTagRemaps()` — disambiguates tags with multiple typedefs using heuristics + (strip `_` prefix, strip `tag` prefix, case-insensitive match) +- `FilterTagRemaps()` — removes built-in defaults, identity remaps, conflict with + configured remaps, and suffix-adding remaps +- `ResolveFunctionPointerFixups()` — classifies fn ptr pairs by pointer prefix + (`LP`, `PFN`, `P`) to determine remap direction, excludes, and reducePointerLevel + +**ScrapeHeaders** (`sources/GeneratorSdk/MetadataTasks/ScrapeHeaders.cs`) + +- Locates `Win32MetadataScraper.dll` from `ToolsBinDir` (built with RuntimeIdentifier) +- Spawns `dotnet Win32MetadataScraper.dll` per partition +- Reads `.remaps` sidecar files and merges into thread-safe dictionaries +- After all partitions, calls `WriteAutoRemapsRsp()` to write merged RSP files +- Runs `CheckCrossPartitionRemapConsistency()` to detect types declared with raw + tag names (warnings only) + +**Build integration** (`sources/GeneratorSdk/sdk/sdk.targets`) + +- `ScraperAutoRemapsRsp` property points to auto-generated tag remap RSP +- `EmitterAutoFnPtrRsp` property points to auto-generated reducePointerLevel RSP +- Both included with `Condition="Exists(...)"` for bootstrap +- Auto-remaps placed BEFORE manual RSPs so manual overrides take priority + +### Current Status (April 2026) + +| Aspect | Status | +|--------|--------| +| Win32MetadataScraper | ✅ Single-pass scraper is in place and is the right long-term architecture | +| Tag remap discovery | ✅ Auto-discovers typedef→tag remaps and feeds them back into generation before emit | +| Fn ptr discovery model | ✅ Discovery now distinguishes bare-function typedefs from already-pointer typedef aliases | +| Manual remap removal | ✅ **~12,197 entries removed** from `scraper.settings.rsp` | +| Manual fn ptr removal | ⚠️ Large reduction landed, but the branch still carries temporary manual fixups for delegate correctness while discovery is tightened | +| Main-branch baseline | ✅ A detached `origin/main` worktree passes all 13 `Windows.Win32.Tests` | +| D2D emit regression | ✅ Fixed by changing `ID2D1SimplifiedGeometrySink=ID2D1SimplifiedGeometrySink` | +| Empty delegates | ✅ No longer failing in the current branch validation run | +| Duplicate fn ptr fixups | ✅ Auto-discovery now defers to configured/manual excludes, and sidecar ingestion dedupes against the manual fixup RSPs | +| End-to-end validation | ⚠️ `DoAll.ps1 -ExcludePackages -ExcludeSamples` now builds the winmd and passes all tests except `NoCyclicalNamespaces` | +| Remaining blocker | ⚠️ One 3-node namespace cycle remains: `System.Power → System.SystemServices → System.Threading → System.Power` | + +### Validation Snapshot + +Latest validation was run against a fresh generated tree (`generation\WinSDK\obj` +deleted, `bin\Windows.Win32.winmd` deleted first): + +- `dotnet build BuildTools -c Release` — passed +- `dotnet test tests\Win32MetadataScraperTests -c Release --no-restore` — **34/34 passed** +- `.\DoAll.ps1 -ExcludePackages -ExcludeSamples` — built tools, scraped headers, + emitted `Windows.Win32.winmd`, passed `MetadataUtils.Tests` and scraper tests, + passed **12/13** `Windows.Win32.Tests`, failed only `NoCyclicalNamespaces` + +Latest `showNamespaceCycles` output: + +```text +Windows.Win32.System.Power + Cyclical dependent namespaces: Windows.Win32.System.SystemServices +Windows.Win32.System.SystemServices + Cyclical dependent namespaces: Windows.Win32.System.Threading +Windows.Win32.System.Threading + Cyclical dependent namespaces: Windows.Win32.System.Power +``` + +--- + +## What Was Done + +### 1. Established the correct validation path + +Early validation on this branch only built the tools and ran unit tests. That was +not enough. Real validation for this work must exercise the full scrape + emit + +winmd test pipeline: + +```powershell +.\DoAll.ps1 -ExcludePackages -ExcludeSamples +``` + +That is the command that exposed the real regressions. + +### 2. Fixed the first real end-to-end regression + +The initial full build failed during emit because `scraper.settings.rsp` still had: + +```text +ID2D1SimplifiedGeometrySink=IDWriteGeometrySink +``` + +That remap caused `ID2D1GeometrySink` to inherit from the wrong interface identity +at emit time. Changing it to: + +```text +ID2D1SimplifiedGeometrySink=ID2D1SimplifiedGeometrySink +``` + +unblocked emit and allowed the run to reach the integration tests. + +### 3. Proved the branch regressions against a clean main baseline + +A detached worktree at `C:\repos\win32metadata.2.main` was used to build +`origin/main` with the same real pipeline. Main passes all 13 +`Windows.Win32.Tests`, so both of the branch failures below are genuine branch +regressions: + +- `NoInvalidEmptyDelegates` +- `NoCyclicalNamespaces` + +The scraper response-file parser now skips whole `#` comment lines, so inline +notes in `scraper.settings.rsp` are safe again. The branch now uses a dedicated +`--exclude-auto-remap` switch for temporary compatibility pins rather than +identity remaps. The current pinned tag names are: + +- `DxcBuffer` +- `_DnsRecordOptA` +- `_ERROR_INFOW` +- `D3D12_SERIALIZED_BLOCK_TYPE` +- `_SPLCLIENT_INFO_2_V3` +- `DTC_STATUS_` +- `WHV_PROCESSOR_INTERCEPT_COUNTERS` +- `WHV_PROCESSOR_EVENT_COUNTERS` +- `CompilationRelaxationsEnum` + +With those opt-outs in place, a clean `EmitWinmd` run compares equal to the +clean `main` worktree winmd (`No unknown differences found.`), and the focused +metadata test suites pass again. + +### 4. Tightened fn-ptr discovery semantics + +The scraper no longer treats all function-pointer typedef shapes as equivalent. +Discovery now records: + +- bare-function typedefs (`typedef void CALLBACK(...);`) +- already-pointer typedefs (`typedef DWORD (*PFOO)(...);`) + +That distinction is important because only the first shape should automatically +generate `--remap` / `--exclude` / `--reducePointerLevel` fixups by default. + +Unit tests were expanded to cover: + +- non-standard pointer alias names +- already-pointer alias chains +- versioned/unversioned aliases +- configured excludes suppressing auto-generated fixups + +### 5. Restored delegate correctness conservatively + +The empty-delegate failure was not fully solvable by the structural split alone. +Some legacy cases are still carried by curated fixups. To keep the branch correct +while continuing to shrink the manual file, the following entries were restored to +`functionPointerFixups.json` as a temporary measure: + +- `PTHREAD_START_ROUTINE -> LPTHREAD_START_ROUTINE` (`alreadyPointer: true`) +- `INTERNET_STATUS_CALLBACK -> LPINTERNET_STATUS_CALLBACK` (`alreadyPointer: true`) +- `INSTALLUI_HANDLER_RECORD -> PINSTALLUI_HANDLER_RECORD` +- `PBMCALLBACKFN -> LPBMCALLBACKFN` +- `ACMDRIVERPROC -> LPACMDRIVERPROC` +- `PTOP_LEVEL_EXCEPTION_FILTER -> LPTOP_LEVEL_EXCEPTION_FILTER` +- `LPFNADDPROPSHEETPAGE -> LPFNSVADDPROPSHEETPAGE` +- `PFIBER_START_ROUTINE -> LPFIBER_START_ROUTINE` + +This is a correctness-preserving fallback, not the desired end state. + +### 6. Traced and suppressed the obvious duplicate `reducePointerLevel` sources + +The namespace-cycle investigation found 9 suspect `reducePointerLevel` entries that +were present on this branch but not on main: + +- `LPMAPIALLOCATEBUFFER` +- `LPMAPIALLOCATEMORE` +- `LPMAPIFREEBUFFER` +- `PENCLAVE_TARGET_FUNCTION` +- `PEXCEPTION_ROUTINE` +- `PLSA_GET_EXTENDED_CALL_FLAGS` +- `WHEA_ERROR_SOURCE_CORRECT_DEVICE_DRIVER` +- `WHEA_ERROR_SOURCE_INITIALIZE_DEVICE_DRIVER` +- `WHEA_ERROR_SOURCE_UNINITIALIZE_DEVICE_DRIVER` + +Those resolved to three buckets: + +1. Already manually excluded in partition or global scraper settings +2. Already present in the manual function-pointer fixup RSPs +3. Newly auto-discovered entries that should defer to existing manual configuration + +The current code now does two conservative things: + +1. `Win32MetadataScraper` passes the configured `--exclude` set into + `ResolveFunctionPointerFixups` and skips auto-generating a fn-ptr fixup when the + alias is already manually excluded. +2. `ScrapeHeaders` parses the manual function-pointer fixup RSPs and drops matching + auto-generated remap / exclude / reducePointerLevel entries while reading the + scraper sidecar files. + +After that change: + +- the 9 suspect names above no longer appear in `emitter.autoFnPtr.generated.rsp` +- overlap between auto and manual `--reducePointerLevel` files is now **0** +- the branch still has the same 3-node namespace cycle, so those duplicates were + real noise, but not the last root cause + +### 7. Current interpretation + +The branch is now in a cleaner debugging state: + +- empty delegates are fixed +- duplicate/manual fn-ptr fixups are suppressed correctly +- the remaining failure is isolated to the namespace-cycle regression + +That is a much better place for the next round of investigation than the earlier +state where delegate failures and duplicate fixups were interleaved. + +--- + +## Remaining Work + +### High Priority + +- [ ] **Find the remaining cause of the `Power/SystemServices/Threading` cycle** — + the obvious duplicate fn-ptr fixups are no longer in the auto-generated RSPs, but + the emitted winmd still forms the same 3-namespace cycle. + +- [ ] **Compare namespace dependency edges against `origin/main` again now that the + duplicate fn-ptr entries are gone** — focus on the three namespaces still in the + cycle instead of the broader earlier graph. + +- [ ] **Decide which of the temporary 8 manual function-pointer fixups can be + eliminated next** — they are currently justified by correctness, but the branch + goal is still to keep shrinking `functionPointerFixups.json`, not grow it. + +### Medium Priority + +- [ ] **Audit the remaining cross-partition consistency warnings** — the latest full + build still warned about raw-tag declarations such as `in_addr`, `sockaddr`, + `timeval`, `_CERT_CONTEXT`, and `_SecPkgContext_IssuerListInfoEx`. These may be + orthogonal, but they should be reviewed once the namespace cycle is fixed. + +- [ ] **Continue whittling down `scraper.settings.rsp`** — after the namespace cycle + is understood, resume removing still-auto-derivable tag remaps from the manual + RSP. + +- [ ] **Revisit already-pointer alias handling** — the current model is deliberately + conservative. A future refinement may allow more of those cases to move out of + `functionPointerFixups.json` without reintroducing empty delegates. + +### Low Priority / Future + +- [ ] **Extract `_usedRemappings` for dead-entry detection** — this would make the + remaining manual remap audit much cheaper. + +- [ ] **Upstream recommendation** — if ClangSharp ever exposes remap-discovery data + directly, the repo could stop maintaining its parallel AST walk. + +--- + +## PInvokeGenerator Extensibility Research + +### No public API for remap data (confirmed) + +`PInvokeGenerator` is `sealed partial class : IDisposable` with no public +properties, methods, or events for accessing discovered remapping data. + +Public API surface: +- `Config`, `CurrentContext`, `PreviousContext` (properties) +- `Diagnostics`, `FilePath`, `IndexHandle` (properties) +- `Close()`, `Dispose()`, `GenerateBindings(...)` (methods) + +None return remapping data. + +### No AST hooks or callbacks + +- No `virtual` or `protected` methods to override +- No events or `Action<>`/`Func<>` fields beyond `outputStreamFactory` +- `IOutputBuilder` is internal — receives generation callbacks, not AST events +- Traversal is entirely internal: `GenerateBindings → Visit → VisitDecl` + +### Useful private fields + +| Field | Type | Use | +|-------|------|-----| +| `_allValidNameRemappings` | `Dict>` | ALL typedef-tag relationships | +| `_traversedValidNameRemappings` | `Dict>` | Subset from traversed files | +| `_usedRemappings` | `HashSet` | Which `--remap` entries were used | +| `_visitedFiles` | `HashSet` | Source files visited | +| `_diagnostics` | `List` | Generator diagnostics | + +### How VisitTypedefDecl discovers remaps + +The method walks the typedef's underlying type recursively: +- `FunctionProtoType` → handles function pointer typedefs +- `PointerType` / `ReferenceType` → peels pointer/ref layers +- **`TagType`** → extracts tag name and typedef name; if different, adds to + `_allValidNameRemappings[tagName].Add(typedefName)` +- `TemplateSpecializationType` → recursively follows aliases +- Even **excluded** typedefs contribute (called with `onlyHandleRemappings: true`) + +Constructor seeds defaults: `_GUID→Guid`, `intptr_t→IntPtr`, `size_t→UIntPtr`, etc. + +--- + +## Files Modified + +| File | Change | +|------|--------| +| `sources/Win32MetadataScraper/Program.cs` | New: single-pass scraper hosting PInvokeGenerator | +| `sources/Win32MetadataScraper/RemapDiscovery.cs` | New: AST walker and heuristic resolution | +| `sources/Win32MetadataScraper/Win32MetadataScraper.csproj` | New: project file with ClangSharp v17.0.1 refs | +| `sources/GeneratorSdk/MetadataTasks/ScrapeHeaders.cs` | Modified: uses Win32MetadataScraper, reads .remaps, writes auto RSPs | +| `sources/GeneratorSdk/MetadataTasks/TaskUtils.cs` | Minor cleanup | +| `sources/GeneratorSdk/sdk/sdk.targets` | Added auto-remap and auto-fn-ptr RSP properties | +| `generation/WinSDK/scraper.settings.rsp` | Removed ~12,197 auto-derivable remap entries | +| `generation/WinSDK/functionPointerFixups.json` | Removed ~160 auto-derivable fn ptr fixup entries | +| `generation/WinSDK/Partitions/*/main.cpp` | 7 files: added #include for cross-partition visibility | +| `tests/Win32MetadataScraperTests/` | New: unit tests for discovery heuristics | +| `BuildTools/BuildTools.proj` | Added Win32MetadataScraper project reference | +| `scripts/DoTests.ps1` | Added scraper discovery tests to test suite | diff --git a/docs/copilot/plans/auto-type-remappings-second-opinion.md b/docs/copilot/plans/auto-type-remappings-second-opinion.md new file mode 100644 index 000000000..449f37112 --- /dev/null +++ b/docs/copilot/plans/auto-type-remappings-second-opinion.md @@ -0,0 +1,249 @@ +# Auto Type Remappings: second opinion + +*Based on source inspection only. No build or test execution.* + +## Bottom line + +The overall direction is right. Replacing log/regex-driven suggestion handling with +AST-based, single-pass discovery is much more aligned with the long-term goal of +zero manual remaps than the current "notice it later and hand-edit rsp/json" flow. + +My main concern is not the architecture. It is that the current branch is already +narrower than the existing suggestion/fixup behavior in a few important places, and +those narrower choices make it easier to "give up" and keep a manual tail alive. + +The biggest behavioral differences I see are: + +1. `ResolveTagRemaps` does **not** yet mirror all of ClangSharp's current + recommended-remapping heuristics. +2. `ResolveFunctionPointerFixups` intentionally stops at the + **bare-function + pointer-alias** pattern and explicitly skips + **already-pointer typedef aliases**. That is the biggest place where the current + implementation is normalizing a permanent manual/annotation tail. +3. Cross-partition misses are only warnings today, while the generated + auto-remap rsp can eventually mask the missing-header relationship instead of + forcing the include/annotation fix. + +## What already looks good + +- `sources\Win32MetadataScraper\Program.cs` is using the right shape: + parse once, discover from AST, merge with configured remaps, then call + `PInvokeGenerator.GenerateBindings` on the same translation unit. +- `sources\Win32MetadataScraper\RemapDiscovery.cs` is correctly based on + structural AST relationships instead of raw text scanning. +- Walking both `Decls` and `CursorChildren` to catch transitive includes is + directionally aligned with how ClangSharp's generator sees the world. +- Writing header provenance into the sidecar file and using it in + `ScrapeHeaders.CheckCrossPartitionRemapConsistency()` is a strong idea. + +Those are all improvements over the existing repo flow. + +## Comparison with the existing suggestion / fixup mechanisms + +| Area | Existing behavior | Current branch behavior | Why it matters | +| --- | --- | --- | --- | +| Tag remap suggestions | Upstream `PInvokeGenerator` collects valid typedef/tag relationships during traversal and emits diagnostics like `Potential missing remapping ... Recommended remapping: 'X=Y'`. The repo test path is `tests\Windows.Win32.Tests\IntegrityTests.cs::NoSuggestedRemappings` + `sources\WinmdUtils\Program.cs::ShowSuggestedRemappings`. | `sources\Win32MetadataScraper\RemapDiscovery.cs::ResolveTagRemaps` auto-applies discovered remaps before generation. | Good direction, but the new resolver should stay behaviorally close to the existing recommendation heuristics before it declares a case unsupported. | +| Tag remap heuristics | Upstream recommendation logic currently prefers: single match, strip leading `_`, strip leading `tag`, strip trailing `_`, strip trailing `tag`, then uppercase-name match (see upstream `PInvokeGenerator.cs` diagnostic block around `GetFoundRemappingString`). | Current resolver prefers: configured manual hint, strip leading `_`, strip leading `tag` (only when followed by uppercase), then case-insensitive exact-name match. | This is a real mismatch. Some cases ClangSharp would recommend can now be skipped by the new resolver, which makes the branch look "more hopeless" than the existing signal. | +| Traversal / reachability | Existing suggested-remapping test is based on generator output captured under `obj\scratch`, so it reflects what the generator actually traversed. | The new walker pulls relationships directly from the AST and also reaches transitive includes via `CursorChildren`. | This is a good improvement, but it also means the generated auto-remap rsp can paper over missing per-partition visibility if the consistency check stays warning-only. | +| Function-pointer fixup suggestions | The repo's current fixup path is manual: `generation\WinSDK\functionPointerFixups.json` -> `sources\GeneratorSdk\MetadataTasks\PrepSettingsForFunctionPointerFixups.cs` -> scraper `--exclude/--remap` + emitter `--reducePointerLevel`. Remaining problems are surfaced by `tests\Windows.Win32.Tests\IntegrityTests.cs::NoInvalidPointersToDelegates` + `sources\WinmdUtils\Program.cs::ShowPointersToDelegates`. | `sources\Win32MetadataScraper\RemapDiscovery.cs::ResolveFunctionPointerFixups` auto-discovers only the bare-function + pointer-alias case and explicitly skips already-pointer alias cases. | This is the largest behavior fork. If the zero-manual goal includes those already-pointer alias cases, the current implementation has chosen to stop short. | +| Suggestion plumbing | `ShowSuggestedRemappings` looks for `Recommended remapping:` in scratch output, which matches the current upstream generator diagnostics. | `sources\GeneratorSdk\MetadataTasks\ScrapeHeaders.cs` still parses `Info: Potential remap: ...` into `suggestedRemaps`. | This looks stale. It is probably not the authoritative signal anymore and may confuse anyone comparing old vs new behavior from task logs alone. | + +## The most important gap: already-pointer typedef aliases + +This is the place where I would push back hardest if the goal is eventually zero +manual remaps/fixups. + +Current behavior in the branch: + +- `sources\Win32MetadataScraper\RemapDiscovery.cs::ResolveFunctionPointerFixups` + generates fixups only for: + + ```c + typedef void CALLBACK_NAME(...); + typedef CALLBACK_NAME *LPCALLBACK_NAME; + ``` + +- The same method explicitly chooses **not** to generate fixups for: + + ```c + typedef DWORD (*PFOO)(...); + typedef PFOO LPFOO; + ``` + +- `tests\Win32MetadataScraperTests\RemapDiscoveryTests.cs` now contains tests that + codify that choice (`FnPtr_AlreadyPointer_NoFixupGenerated`, + `FnPtr_BothHavePointerPrefix_NoFixupForAlreadyPointer`, etc.). + +But the existing repo behavior still has live manual entries for exactly that class +of case in `generation\WinSDK\functionPointerFixups.json`, including +`PTHREAD_START_ROUTINE` / `LPTHREAD_START_ROUTINE`, +`INTERNET_STATUS_CALLBACK` / `LPINTERNET_STATUS_CALLBACK`, and the older +`alreadyPointer: true` entries. + +That does **not** automatically mean the new branch is wrong. It does mean the +branch has made a policy choice: + +- either "these cases should remain manual forever", +- or "these cases should become annotation-driven later", +- or "these cases are actually unnecessary once the rest of the pipeline changes". + +Right now the code and tests are taking option 1 by default, and that is the part I +would challenge. If the real goal is zero manual fixups, then these cases need a +deliberate strategy instead of being defined as out-of-scope. + +## What I think the agent should preserve from the existing system + +The existing system is weak in implementation details, but it has two valuable +properties that the new work should preserve: + +1. **It surfaces unresolved cases instead of silently swallowing them.** + - Tag remaps: `NoSuggestedRemappings` + - Fn ptr issues: `NoInvalidPointersToDelegates` + +2. **It does not pretend every unresolved case is the same kind of problem.** + There are at least three buckets: + - structural, unambiguous header relationships -> should be auto-derived + - structural but ambiguous / canonical-name choice required -> should become + annotation-driven + - semantic/public-name overrides -> should stay explicit and separate from + "discoverable from headers" logic + +That three-bucket model is the piece I would keep front-and-center. + +## Specific feedback to the implementing agent + +### 1. Match ClangSharp's recommendation heuristics before giving up + +Before treating a tag as "not auto-derivable", I would make the new resolver at +least as capable as the current ClangSharp recommendation path. + +Today the branch already handles some of the common cases, but it does **not** +currently mirror all of the upstream recommendation heuristics: + +- leading `_` +- leading `tag` +- trailing `_` +- trailing `tag` +- uppercase canonicalization + +If ClangSharp would currently recommend a remap from the same typedef set, the new +AST-based resolver should usually do the same thing instead of skipping and inviting +someone to add a mapping back by hand. + +### 2. Do not let "already-pointer aliases" become a permanent manual bucket by accident + +If the plan is zero manual fixups, then +`typedef PFOO LPFOO`-style cases need an answer. + +I would not accept "both names are valid aliases, so skip" as the final behavior +unless the repo consciously decides that those cases are **not** supposed to be +canonicalized. + +Better options: + +- keep a temporary heuristic fallback for canonical-name selection, +- or emit an explicit "needs annotation" artifact for these cases, +- or define a header annotation that picks the public alias. + +What I would avoid is: + +- changing tests so "we do nothing here" becomes the expected steady state, +- then using that as justification for keeping the remaining json entries forever. + +### 3. Separate "discoverability" from "policy" + +The AST can tell you that two names are related. It cannot always tell you which one +the metadata surface should prefer. + +That distinction matters: + +- **discoverability** -> inferred from typedef/tag/function-pointer structure +- **policy** -> which alias is canonical in emitted metadata + +For ambiguous-but-related cases, the next step should be annotation or a dedicated +policy mechanism, not a hand-edited remap file. + +### 4. Make skipped/ambiguous cases first-class outputs + +Right now the branch is strongest where it can fully auto-resolve, and much weaker +where it cannot. + +I would strongly prefer a machine-readable output for: + +- ambiguous tag remaps +- already-pointer alias pairs with no canonical-name decision +- cross-partition visibility misses + +That gives the team a clean path: + +1. auto-derive when possible +2. annotate headers when needed +3. only keep manual rsp/json as temporary compatibility data + +Without that output, the natural human fallback is to add mappings back manually. + +### 5. Tighten the cross-partition story + +`sources\GeneratorSdk\MetadataTasks\ScrapeHeaders.cs::CheckCrossPartitionRemapConsistency` +is useful, but warning-only is probably too soft for the stated goal. + +My concern is not just the warning level. It is that the generated auto-remap rsp is +global, so one partition's discovery can eventually hide another partition's missing +include. That is convenient for bootstrapping, but it is weaker than the desired +"discoverable from headers themselves" invariant. + +If the real invariant matters, I would eventually either: + +- promote these inconsistencies to a failure, +- or emit a dedicated artifact that must go to zero, +- or otherwise ensure the generated global remap file does not become a substitute + for the missing include/annotation fix. + +### 6. Keep semantic overrides out of the structural-remap success metric + +Some remaining manual mappings are not "failed typedef discovery". They are a +different category: + +- primitive coercions +- public API naming decisions +- MIDL-friendly names +- other semantic overrides + +Those should not be used as evidence that structural auto-remapping has failed. +They either need a separate explicit mechanism or future annotations with different +semantics. + +## The policy I would recommend + +If I were guiding the implementation, I would formalize the end state like this: + +1. **Structural and unambiguous** + - auto-derive from AST + - auto-apply before generation + +2. **Structural but ambiguous** + - emit a deterministic "needs annotation" signal + - do not silently skip + - do not solve by reintroducing manual rsp/json unless absolutely necessary + +3. **Semantic overrides** + - keep them in a separate, explicit mechanism + - do not mix them into the structural auto-remap success metric + +That keeps the implementation aligned with the stated goal and avoids the "we lost +hope, so we added another manual mapping" pattern. + +## Short version to tell the other agent + +The architecture is good. The current risk is behavioral drift, not the idea. + +Specifically: + +- make `ResolveTagRemaps` at least as smart as ClangSharp's current recommended + remapping heuristics before you declare a case unsupported; +- do not normalize `typedef PFOO LPFOO`-style cases as "manual forever" unless that + is an intentional policy decision; +- when the AST proves a relationship but not the canonical alias, treat that as an + **annotation problem**, not as a reason to add manual mappings back; +- keep cross-partition misses visible enough that generated global remaps do not + hide them. diff --git a/docs/copilot/plans/remaining-function-pointer-fixups.md b/docs/copilot/plans/remaining-function-pointer-fixups.md new file mode 100644 index 000000000..e712d9dd2 --- /dev/null +++ b/docs/copilot/plans/remaining-function-pointer-fixups.md @@ -0,0 +1,178 @@ +# Remaining `functionPointerFixups.json` Entries + +## Goal + +Eliminate `functionPointerFixups.json` entirely. All function pointer fixup information should come from the headers — either inferred by simple regular rules in the auto-discovery heuristic, or expressed as `__attribute__((annotate("w32m:...")))` annotations in the headers themselves. See `annotation-validation-results.md` for the annotation validation framework and ClangSharp v18+ requirements. + +## Background + +The `functionPointerFixups.json` file provides manual configuration for function pointer types that ClangSharp's PInvokeGenerator doesn't handle well on its own. Without these fixups, the winmd would contain duplicate delegate types and `Delegate*` (pointer-to-delegate) parameters instead of clean delegate parameters. + +Each entry generates up to three directives: +- `--remap NAME=POINTER_TYPE` — unifies the two typedef names +- `--exclude POINTER_TYPE` — prevents generating a duplicate delegate +- `--reducePointerLevel POINTER_TYPE` — strips an extra `*` so the winmd parameter is the delegate type directly, not a pointer to it + +The auto-discovery heuristic in `RemapDiscovery.cs` handles two common patterns: +```c +// Pattern 1: bare function + pointer alias (fully auto-discovered) +typedef void CALLBACK(int x); // bare function type +typedef CALLBACK *LPCALLBACK; // pointer alias (adds *) + +// Pattern 2: already-pointer + pointer-adding alias (fully auto-discovered) +typedef DWORD (*PFOO)(...); // already a pointer +typedef PFOO *LPPFOO; // adds another * +``` + +As of this writing, the file has been reduced from 184 entries to 27. The remaining 27 fall into three categories described below, with a plan for each. + +--- + +## Category 1: No pointer alias — struct field callbacks (12 entries) + +These are bare function typedefs (or function declarations) used as `NAME *member` in struct fields, but there is no `typedef NAME *PNAME;` anywhere. + +### LDAP referral callbacks (3 entries) +```json +{ "name": "QUERYFORCONNECTION" } +{ "name": "NOTIFYOFNEWCONNECTION" } +{ "name": "DEREFERENCECONNECTION" } +``` +**Header:** `Winldap.h` lines 3163–3221: +```c +typedef ULONG (_cdecl QUERYFORCONNECTION)(PLDAP, PLDAP, PWCHAR, ...); +// used in struct: +typedef struct LdapReferralCallback { + QUERYFORCONNECTION *QueryForConnection; // pointer applied at usage site +} LDAP_REFERRAL_CALLBACK; +``` + +### ICU iterator function pointers (9 entries) +```json +{ "name": "UCharIteratorGetIndex" } +{ "name": "UCharIteratorMove" } +// ... through UCharIteratorSetState +``` +**Header:** `icucommon.h` lines 6448–6743. Function declarations used as function pointer types in struct fields: `UCharIteratorGetIndex *getIndex;`. + +### Plan + +**Option A (heuristic):** Add a new heuristic pass in `RemapDiscovery` that scans `RecordDecl` (struct) fields for `PointerType → FunctionProtoType` or `PointerType → TypedefType` where the pointee is a known bare function typedef. Emit `--reducePointerLevel` automatically. The rule is simple and regular: "any struct field that is a pointer to a bare function type gets `reducePointerLevel`." + +**Option B (annotation fallback):** If the heuristic misfires on edge cases, add a `_Reduce_pointer_level_` annotation on the struct field: +```c +typedef struct LdapReferralCallback { + _Reduce_pointer_level_ QUERYFORCONNECTION *QueryForConnection; +} LDAP_REFERRAL_CALLBACK; +``` +This annotation expands to `__attribute__((annotate("w32m:reduceptrlevel")))` and tells the emitter to strip one `*` on this field. + +**Recommendation:** Try Option A first — the rule is simple. Fall back to Option B only for entries where the heuristic produces incorrect results. + +--- + +## Category 2: Same-level function pointer aliases (10 entries) + +These are already-pointer typedefs (`typedef DWORD (*PFOO)(...)`) with a same-level alias (`typedef PFOO LPFOO`). Both names refer to the identical type. The fixup unifies them under one canonical name. + +### Entries with `alreadyPointer: true` (6 entries) +```json +{ "name": "PTHREAD_START_ROUTINE", "pointerType": "LPTHREAD_START_ROUTINE", "alreadyPointer": true } +{ "name": "INTERNET_STATUS_CALLBACK", "pointerType": "LPINTERNET_STATUS_CALLBACK", "alreadyPointer": true } +{ "name": "OLDFONTENUMPROCA", "pointerType": "FONTENUMPROCA", "alreadyPointer": true } +{ "name": "OLDFONTENUMPROCW", "pointerType": "FONTENUMPROCW", "alreadyPointer": true } +{ "name": "_EVENT_CALLBACK", "pointerType": "RTM_EVENT_CALLBACK", "alreadyPointer": true } +{ "name": "_ENTITY_METHOD", "pointerType": "RTM_ENTITY_EXPORT_METHOD", "alreadyPointer": true } +``` + +### Entries without `alreadyPointer` flag (4 entries) +```json +{ "name": "PBMCALLBACKFN", "pointerType": "LPBMCALLBACKFN" } +{ "name": "PTOP_LEVEL_EXCEPTION_FILTER", "pointerType": "LPTOP_LEVEL_EXCEPTION_FILTER" } +{ "name": "LPFNADDPROPSHEETPAGE", "pointerType": "LPFNSVADDPROPSHEETPAGE" } +{ "name": "PFIBER_START_ROUTINE", "pointerType": "LPFIBER_START_ROUTINE" } +``` + +These behave identically to the `alreadyPointer` group — the alias is at the same pointer level. The missing flag is likely an oversight in the original JSON. + +### Plan + +**Step 1 — try a simple heuristic.** For same-level function pointer aliases, always remap base→alias (the alias name becomes canonical). The rationale: you don't create a typedef alias unless you want the alias used publicly. Generate `--remap` and `--exclude` but NOT `--reducePointerLevel`. + +Implementation: +1. In `ResolveFunctionPointerFixups`, add a pass that iterates `FnPointerFunctionTypedefs`, checks `FnSameLevelAliases` for exactly 1 alias, and generates remap + exclude +2. Remove these 10 entries from `functionPointerFixups.json` +3. Rebuild and run all tests — verify identical winmd output +4. If the 4 non-`alreadyPointer` entries need `reducePointerLevel` to pass, investigate why + +**Step 2 — annotation fallback.** If the "alias is canonical" rule produces wrong results for specific entries (e.g., the winmd test shows the wrong name chosen), add a `_Canonical_name_(ALIAS)` annotation on the original typedef: +```c +_Canonical_name_(LPTHREAD_START_ROUTINE) +typedef DWORD (WINAPI *PTHREAD_START_ROUTINE)(LPVOID lpThreadParameter); +typedef PTHREAD_START_ROUTINE LPTHREAD_START_ROUTINE; +``` +This annotation expands to `__attribute__((annotate("w32m:canonical=LPTHREAD_START_ROUTINE")))` and tells the toolchain which name should appear in the winmd. + +**Recommendation:** The heuristic should work for all 10 entries — try it first. Only add annotations for entries where the rule produces incorrect results. + +--- + +## Category 3: Header inclusion gaps (4 entries) + +These follow patterns the heuristic already handles, but the headers declaring them aren't transitively included by the partition that scrapes them. + +```json +{ "name": "LSA_GET_EXTENDED_CALL_FLAGS", "pointerType": "PLSA_GET_EXTENDED_CALL_FLAGS" } +{ "name": "_WHEA_ERROR_SOURCE_INITIALIZE_DEVICE_DRIVER", "pointerType": "WHEA_ERROR_SOURCE_INITIALIZE_DEVICE_DRIVER" } +{ "name": "_WHEA_ERROR_SOURCE_UNINITIALIZE_DEVICE_DRIVER", "pointerType": "WHEA_ERROR_SOURCE_UNINITIALIZE_DEVICE_DRIVER" } +{ "name": "_WHEA_ERROR_SOURCE_CORRECT_DEVICE_DRIVER", "pointerType": "WHEA_ERROR_SOURCE_CORRECT_DEVICE_DRIVER" } +``` + +**Header details:** +- `LSA_GET_EXTENDED_CALL_FLAGS`: `NTSecPKG.h` (bare function + pointer alias). The ActiveDirectory partition includes `` but that doesn't transitively include `ntsecpkg.h`. +- `_WHEA_ERROR_SOURCE_*`: `wheadef.h` (bare function + pointer alias). Verify whether `wheadef.h` is transitively included by the Base partition. + +### Plan + +1. Search the scraper's `.remaps` sidecar files for these names to confirm they're not being discovered +2. Add `#include ` and/or `#include ` to the relevant partition `main.cpp` files +3. Rebuild and verify the entries appear in `emitter.autoFnPtr.crossarch.generated.rsp` +4. Remove from `functionPointerFixups.json` +5. Run all tests + +**Complexity:** Low — same approach as the 7 partition header adjustments already on this branch. + +--- + +## Summary and Priority + +| Category | Entries | Approach | Complexity | +|----------|---------|----------|------------| +| Header inclusion gaps | 4 | Add `#include` to partitions | Low — do first | +| Same-level aliases | 10 | Heuristic (alias=canonical), annotation fallback | Medium | +| Struct field callbacks | 12 | Heuristic (scan struct fields), annotation fallback | Medium-high | +| **Total** | **27** | | | + +### Suggested order of work +1. **Header inclusion gaps** (4 entries) — lowest risk, immediate payoff +2. **Same-level aliases** (10 entries) — try the "alias is canonical" heuristic +3. **Struct field callbacks** (12 entries) — add struct field scanning or `_Reduce_pointer_level_` annotations + +### Annotation macros to define (if needed) + +Add to a shared header (e.g., `win32metadata.h`) guarded by `#ifdef _WIN32METADATA_`: + +```c +#ifdef _WIN32METADATA_ + // Tells the emitter to reduce pointer level on this struct field + #define _Reduce_pointer_level_ __attribute__((annotate("w32m:reduceptrlevel"))) + + // Tells the toolchain which typedef name is canonical for this function pointer + #define _Canonical_name_(name) __attribute__((annotate("w32m:canonical=" #name))) +#else + #define _Reduce_pointer_level_ + #define _Canonical_name_(name) +#endif +``` + +These annotations require ClangSharp v18+ for full support (see `annotation-validation-results.md`). diff --git a/docs/copilot/plans/shift-left-metadata-plan.md b/docs/copilot/plans/shift-left-metadata-plan.md new file mode 100644 index 000000000..ed9daaf91 --- /dev/null +++ b/docs/copilot/plans/shift-left-metadata-plan.md @@ -0,0 +1,716 @@ +# Shift-Left Metadata: Moving Sidecar Metadata Into Headers + +*Created: March 2026* +*Workstream: 4 — Shift-Left Metadata Definition* +*Branch: user/jevansaks/shift-left-metadata* + +--- + +## Executive Summary + +Win32metadata currently defines critical API semantics — RAII handles, enum groupings, +SetLastError behavior, OS version support, and more — in **sidecar files** (`.rsp`, `.json`) +that live outside the Windows SDK headers. This plan details how to move each class of +metadata into the headers themselves, using a SAL-like annotation mechanism that's already +proven in the Windows SDK. We'll use a structured patch system to apply these annotations +to ingested SDK headers until the official SDK adopts them. + +**Key finding (March 2026):** ClangSharp v18+ (via PR [#552](https://github.com/dotnet/ClangSharp/pull/552)) +added `[NativeAnnotation("...")]` support that preserves `__attribute__((annotate(...)))` +on **all declaration types** — functions, parameters, struct fields, and return values. +This repo currently pins v17.0.1 which only supports parameter-level annotations. +**Upgrading ClangSharp to v18+ unblocks the entire shift-left strategy with no +workarounds or extraction tools needed.** + +--- + +## Problem Statement + +Today, ~170,000+ lines of metadata across 15+ sidecar files encode information that +*should* live in the C/C++ headers: + +| Sidecar File | Lines | Entries | What It Encodes | +|---|---|---|---| +| `supportedOS.rsp` | 17,249 | ~8,600 | OS version each API requires | +| `documentationMappings.rsp` | 90,511 | ~45,000 | Microsoft Learn URLs | +| `enums.json` | 37,096 | ~500+ | Synthetic enum definitions | +| `libMappings.rsp` | 26,808 | ~13,400 | Function → DLL mappings | +| `scraper.settings.rsp` | 12,891 | ~1,600 | Type remaps, tag→name fixes | +| `WithSetLastError.rsp` | 3,366 | ~1,600 | SetLastError functions | +| `autoTypes.json` | 2,984 | ~280 | Handle types with close APIs | +| `emitter.settings.rsp` | 2,396 | varies | Member remaps, enum additions | +| `libMappingsManual.rsp` | 387 | ~190 | Manual DLL overrides | +| `functionPointerFixups.json` | 731 | ~200 | Function pointer name fixes | +| `manual/` (69 C# files) | varies | — | Hand-written type definitions | + +This creates three problems: +1. **Drift** — sidecar data goes stale as SDK headers evolve +2. **Bugs fixed in the wrong place** — SDK errors get papered over here rather than at source +3. **Fragile maintenance** — each SDK update requires hand-curating these files + +--- + +## The SAL Precedent: How This Already Works + +The key insight is that **SAL annotations already do exactly what we need** — they embed +tool-readable metadata in C/C++ headers with zero compilation impact. The mechanism +(from `sal.h` lines 1593-1611): + +```c +// When Clang is the compiler (ClangSharp uses Clang): +#if __clang__ + #define _SA_annotes0(n) __attribute__((annotate("Name=" #n))) + #define _SA_annotes1(n,p) __attribute__((annotate("Name=" #n "; p1=" #p))) + +// When MSVC is the compiler: +#else + #define _SA_annotes0(n) __declspec(#n) + #define _SA_annotes1(n,p) __declspec(#n "(" #p ")") +#endif + +// When no analysis tool is running (_PREFAST_ not defined): +// All of the above expand to nothing — zero cost +``` + +ClangSharp already processes these annotations: +1. `baseSettings.rsp` sets `-D_PREFAST_=1` and `-D_USE_DECLSPECS_FOR_SAL=1` +2. `generate-cpp-attributes` config flag causes ClangSharp to emit them as C# attributes +3. `MetadataSyntaxTreeCleaner.cs` parses `CppAttributeList` nodes, extracts `SalAttribute` + objects with `Name`, `p1`, `p2`, `p3` fields, and converts them to managed attributes + +**Our custom annotations will follow this exact pattern.** + +--- + +## Annotation Mechanism Design + +### Header: `win32metadata.h` + +A new header that defines metadata annotation macros. It follows the SAL conditional +compilation pattern: + +```c +// win32metadata.h — Win32 Metadata Annotations +// +// These annotations encode metadata for the win32metadata tooling. +// When processed by ClangSharp (via Clang), they expand to +// __attribute__((annotate(...))) nodes visible in the AST. +// In normal compilation, they expand to nothing — zero cost. + +#pragma once + +#ifdef _WIN32METADATA_ // Defined in ClangSharp baseSettings.rsp + + #ifdef __clang__ + // Clang path — use annotate attribute (what ClangSharp actually sees) + #define _W32M_anno0(key) __attribute__((annotate("w32m:" key))) + #define _W32M_anno1(key, v1) __attribute__((annotate("w32m:" key "=" v1))) + #define _W32M_anno2(key, v1, v2) __attribute__((annotate("w32m:" key "=" v1 ";" v2))) + #else + // MSVC path — use declspec (for potential future MSVC-based processing) + #define _W32M_anno0(key) __declspec("w32m_" key) + #define _W32M_anno1(key, v1) __declspec("w32m_" key "(" v1 ")") + #define _W32M_anno2(key, v1, v2) __declspec("w32m_" key "(" v1 "," v2 ")") + #endif + +#else + // Normal compilation — expand to nothing + #define _W32M_anno0(key) + #define _W32M_anno1(key, v1) + #define _W32M_anno2(key, v1, v2) +#endif + +// ── Function-Level Annotations ────────────────────────────────────── + +// Function calls SetLastError on failure +#define _Sets_last_error_ _W32M_anno0("setlasterror") + +// Minimum OS version required (e.g., "10.0.19041") +#define _Min_os_version_(ver) _W32M_anno1("minversion", #ver) + +// Function's return value must be freed with the named function +#define _Must_close_with_(func) _W32M_anno1("raiifree", #func) + +// Function may return error codes that look like success (HRESULT) +#define _Can_return_errors_as_success_ _W32M_anno0("errorsassuccess") + +// Function may return multiple distinct success values +#define _Multiple_success_values_ _W32M_anno0("multiplesuccess") + +// ── Type-Level Annotations (on DECLARE_HANDLE / typedef) ──────────── + +// Handle/resource cleanup function +#define _Close_handle_with_(func) _W32M_anno1("closeapi", #func) + +// Sentinel value indicating invalid handle +#define _Invalid_handle_(val) _W32M_anno1("invalidhandle", #val) + +// This handle type is interchangeable with another +#define _Also_usable_for_(type) _W32M_anno1("alsousablefor", #type) + +// ── Parameter-Level Annotations ───────────────────────────────────── + +// Pointer parameter is a COM out-pointer (ppv pattern) +#define _Com_out_ptr_ _W32M_anno0("comoutptr") + +// Caller must not release this handle/pointer +#define _Do_not_release_ _W32M_anno0("donotrelease") + +// Not null-terminated (overrides default assumption for string types) +#define _Not_null_terminated_ _W32M_anno0("notnullterm") + +// Double-null-terminated string (e.g., environment blocks) +#define _Null_null_terminated_ _W32M_anno0("nullnullterm") + +// Array whose count comes from another parameter (by zero-based index) +#define _Array_count_param_(idx) _W32M_anno1("arraycountparam", #idx) + +// Array with a fixed element count +#define _Array_count_(n) _W32M_anno1("arraycountconst", #n) + +// Memory size comes from another parameter (by zero-based index) +#define _Memory_size_param_(idx) _W32M_anno1("memsizeparam", #idx) +``` + +### How It Flows Through ClangSharp + +``` +┌──────────────────────────────────────────────────────────────────┐ +│ SDK Header (with annotations) │ +│ │ +│ _Sets_last_error_ │ +│ BOOL WINAPI CreateFileA( │ +│ _In_ LPCSTR lpFileName, ...); │ +│ │ +│ With -D_WIN32METADATA_=1, expands to: │ +│ __attribute__((annotate("w32m:setlasterror"))) │ +│ BOOL WINAPI CreateFileA( │ +│ __attribute__((annotate("Name=SAL_pre;..."))) ...); │ +└────────────────────┬─────────────────────────────────────────────┘ + │ ClangSharp parses with Clang + ▼ +┌──────────────────────────────────────────────────────────────────┐ +│ Generated C# (ClangSharp output) │ +│ │ +│ [CppAttributeList("w32m:setlasterror")] │ +│ [DllImport("kernel32.dll", SetLastError = true)] │ +│ public static extern BOOL CreateFileA( │ +│ [In, MarshalAs(...)] string lpFileName, ...); │ +└────────────────────┬─────────────────────────────────────────────┘ + │ MetadataSyntaxTreeCleaner processes + ▼ +┌──────────────────────────────────────────────────────────────────┐ +│ Cleaned C# (ready for winmd emission) │ +│ │ +│ [SetLastError] ← converted from w32m: │ +│ [DllImport("kernel32.dll")] │ +│ public static extern BOOL CreateFileA(...); │ +└────────────────────┬─────────────────────────────────────────────┘ + │ ClangSharpSourceWinmdGenerator writes + ▼ +┌──────────────────────────────────────────────────────────────────┐ +│ Windows.Win32.winmd │ +│ Method: CreateFileA [SetLastError, DllImport("kernel32.dll")] │ +└──────────────────────────────────────────────────────────────────┘ +``` + +### Processing Changes in MetadataSyntaxTreeCleaner + +The existing `CreateAttributeListForSal` method processes `CppAttributeList` nodes by +parsing SAL attributes (delimited with `^`, fields delimited with `;`). We need to add +a parallel path for `w32m:` prefixed annotations: + +```csharp +// In CreateAttributeListForSal, after getting the annotate string: +if (annotateText.StartsWith("w32m:")) +{ + return ProcessWin32MetadataAnnotation(annotateText.Substring(5)); +} + +// New method: +private AttributeSyntax ProcessWin32MetadataAnnotation(string annotation) +{ + // Parse "key=value" or just "key" + var eqIndex = annotation.IndexOf('='); + var key = eqIndex >= 0 ? annotation.Substring(0, eqIndex) : annotation; + var value = eqIndex >= 0 ? annotation.Substring(eqIndex + 1) : null; + + return key switch + { + "setlasterror" => /* mark for SetLastError */, + "raiifree" => MakeAttribute("RAIIFree", value), + "closeapi" => MakeAttribute("RAIIFree", value), + "invalidhandle" => MakeAttribute("InvalidHandleValue", long.Parse(value)), + "minversion" => MakeAttribute("SupportedOSPlatform", $"windows{value}"), + "comoutptr" => MakeAttribute("ComOutPtr"), + "donotrelease" => MakeAttribute("DoNotRelease"), + "notnullterm" => MakeAttribute("NotNullTerminated"), + "nullnullterm" => MakeAttribute("NullNullTerminated"), + "errorsassuccess" => MakeAttribute("CanReturnErrorsAsSuccess"), + "multiplesuccess" => MakeAttribute("CanReturnMultipleSuccessValues"), + "arraycountparam" => MakeAttribute("NativeArrayInfo", + namedArg: ("CountParamIndex", int.Parse(value))), + "arraycountconst" => MakeAttribute("NativeArrayInfo", + namedArg: ("CountConst", int.Parse(value))), + "memsizeparam" => MakeAttribute("MemorySize", + namedArg: ("BytesParamIndex", short.Parse(value))), + "alsousablefor" => MakeAttribute("AlsoUsableFor", value), + _ => null // unknown annotation — log warning + }; +} +``` + +--- + +## Taxonomy of Sidecar Metadata Classes + +Each class of sidecar metadata falls into one of three categories: + +### Category A: Belongs in Headers (shift-left target) + +These express *semantic properties of the API* and should be in the headers. + +| Class | Current Location | Header Annotation | Entries | Difficulty | +|---|---|---|---|---| +| **SetLastError** | `WithSetLastError.rsp` | `_Sets_last_error_` on function | ~1,600 | Low | +| **OS Version** | `supportedOS.rsp` | `_Min_os_version_(...)` on function | ~8,600 | Low | +| **RAII/Close API** | `autoTypes.json` | `_Close_handle_with_(...)` on typedef | ~60 | Low | +| **Invalid Handle Values** | `autoTypes.json` | `_Invalid_handle_(...)` on typedef | ~40 | Low | +| **AlsoUsableFor** | `autoTypes.json` | `_Also_usable_for_(...)` on typedef | ~10 | Low | +| **RAII on return** | `emitter.settings.rsp` memberRemap | `_Must_close_with_(...)` on function | ~50 | Medium | +| **ComOutPtr** | `emitter.settings.rsp` memberRemap | `_Com_out_ptr_` on parameter | ~30 | Medium | +| **DoNotRelease** | `emitter.settings.rsp` memberRemap | `_Do_not_release_` on parameter | ~20 | Medium | +| **Const** | `emitter.settings.rsp` memberRemap | Already in SAL (`_Const_`) | ~100 | Low | +| **NotNullTerminated** | `emitter.settings.rsp` memberRemap | `_Not_null_terminated_` on param | ~10 | Low | +| **NullNullTerminated** | `emitter.settings.rsp` memberRemap | `_Null_null_terminated_` on param | ~10 | Low | +| **Array info** | `emitter.settings.rsp` memberRemap | `_Array_count_param_(n)` on param | ~50 | Medium | +| **MemorySize** | `emitter.settings.rsp` memberRemap | `_Memory_size_param_(n)` on param | ~20 | Medium | +| **ErrorsAsSuccess** | `emitter.settings.rsp` memberRemap | `_Can_return_errors_as_success_` | ~30 | Low | +| **MultipleSuccess** | `emitter.settings.rsp` memberRemap | `_Multiple_success_values_` | ~10 | Low | +| **Manual lib mappings** | `libMappingsManual.rsp` | `#pragma comment(lib, "...")` | ~190 | Low | + +### Category B: Requires Header Refactoring (longer-term) + +These require structural changes to the headers, not just annotations. + +| Class | Current Location | What's Needed | Entries | Difficulty | +|---|---|---|---|---| +| **Synthetic enums** | `enums.json` | Change `#define` groups → `enum` types | ~500 | **High** | +| **Enum flags** | `emitter.settings.rsp` | Add annotation to enum typedef | ~80 | Medium | +| **Enum additions** | `emitter.settings.rsp` | Add missing members to enums | ~30 | Medium | +| **Function pointer fixups** | `functionPointerFixups.json` | Fix typedef naming inconsistencies | ~200 | Medium | +| **Tag→name remaps** | `scraper.settings.rsp` | Fix `tagFOO` → `FOO` at source | ~1,000 | Medium | +| **Type corrections** | `scraper/ConstantsScraperSettings` | Use correct types in `#define` | ~600 | High | +| **Manual C# overrides** | `manual/` (69 files) | Fix the APIs in headers/IDL | varies | **Very High** | + +### Category C: Stays as Tooling Configuration + +These are win32metadata tooling concerns, not properties of the APIs themselves. + +| Class | Current Location | Why It Stays | Entries | +|---|---|---|---| +| **Partitions** | `Partitions/` dirs | Namespace organization is our concern | ~240 | +| **Namespace resolution** | `requiredNamespacesForNames.rsp` | Disambiguation for our mapping | ~1,300 | +| **Documentation URLs** | `documentationMappings.rsp` | External data from docs repos | ~45,000 | +| **Auto lib mappings** | `libMappings.rsp` | Generated from .lib files | ~13,400 | +| **Type imports** | `emitter.settings.rsp` | WinRT interop config | ~15 | +| **Cross-arch excludes** | `Windows.Win32.proj` | Build configuration | ~250 | +| **Handle type defs** | `autoTypes.json` (ValueType) | ClangSharp handle struct generation | ~280 | + +--- + +## Patch Management System + +Since the headers come from the Windows SDK NuGet package, we need a system to apply +annotations to them during ingestion. + +### Design Principles + +1. **Patches are structured, not diffs** — a JSON manifest identifies *what* to annotate + on *which* declaration in *which* header, not line-based diffs that break on any change +2. **Idempotent** — applying a patch to a header that already has the annotation is a no-op +3. **Staleness detection** — when the official SDK adopts an annotation, the patch system + detects it and reports the patch as "already applied / no longer needed" +4. **Per-SDK versioning** — patches track which SDK version they target; when the SDK + updates, stale patches are flagged for review + +### Patch Manifest Format: `patches.json` + +```json +{ + "$schema": "patches.schema.json", + "sdkVersion": "10.0.26100", + "patches": [ + { + "id": "setlasterror-CreateFileA", + "header": "um/fileapi.h", + "target": { + "kind": "function", + "name": "CreateFileA" + }, + "annotation": "_Sets_last_error_", + "placement": "before-return-type", + "status": "pending", + "sourceRsp": "WithSetLastError.rsp" + }, + { + "id": "minversion-AmsiInitialize", + "header": "um/amsi.h", + "target": { + "kind": "function", + "name": "AmsiInitialize" + }, + "annotation": "_Min_os_version_(10.0.10240)", + "placement": "before-return-type", + "status": "pending", + "sourceRsp": "supportedOS.rsp" + }, + { + "id": "raii-HANDLE", + "header": "shared/ntdef.h", + "target": { + "kind": "typedef", + "name": "HANDLE" + }, + "annotations": [ + "_Close_handle_with_(CloseHandle)", + "_Invalid_handle_(-1)", + "_Invalid_handle_(0)" + ], + "placement": "before-typedef", + "status": "pending", + "sourceJson": "autoTypes.json" + } + ] +} +``` + +### Patch Application Tool: `Apply-MetadataPatches.ps1` + +A PowerShell script (or .NET tool) that: + +1. Reads `patches.json` +2. For each patch: + a. Locates the target declaration in the header using a lightweight C parser or regex + b. Checks if the annotation is already present (staleness detection) + c. If not present, inserts the annotation at the specified placement + d. If already present, marks the patch as `"adopted"` and logs it +3. Writes a report of applied/skipped/stale patches +4. Updates patch status in the manifest + +### Staleness Detection + +When we ingest a new SDK version: + +``` +┌─ Read patches.json for previous SDK version +│ +├─ For each patch: +│ ├─ Find target declaration in new SDK header +│ ├─ Is annotation already present? ──→ Mark as "adopted by SDK" +│ ├─ Has declaration moved/renamed? ──→ Mark as "needs review" +│ └─ Declaration still exists, no annotation ──→ Re-apply patch +│ +└─ Generate migration report: + - N patches still needed + - M patches adopted by SDK (can be removed) + - K patches need manual review (target moved/removed) +``` + +### Integration with Build Pipeline + +The patch application step runs **before** ClangSharp scraping: + +``` +DoAll.ps1 + 1. Ingest SDK headers (from NuGet or local) + 2. ★ Apply-MetadataPatches.ps1 ← NEW STEP + 3. RecompileIdlFilesForScraping.ps1 + 4. BuildMetadataBin.ps1 (scrape + emit) + 5. Tests, packaging, etc. +``` + +--- + +## Phased Implementation Plan + +### Phase 1: Foundation — Annotation Infrastructure + +**Goal:** Establish the annotation mechanism and prove it works end-to-end. + +**Tasks:** +1. **Upgrade ClangSharp from v17.0.1 to v18.1.0.4+** — This is the critical + prerequisite. v18 adds `[NativeAnnotation("...")]` support for + `__attribute__((annotate(...)))` on all declaration types (functions, + parameters, struct fields, return values). Without this upgrade, only + parameter-level annotations work. Update the version pin in + `global.json` / `ScrapeHeaders.cs` and validate existing builds still pass. +2. Create `win32metadata.h` with the annotation macros +3. Add `-D_WIN32METADATA_=1` to `baseSettings.rsp` +4. Add `#include "win32metadata.h"` to the scraper include chain +5. Modify `MetadataSyntaxTreeCleaner` to recognize `[NativeAnnotation("w32m:...")]` + attributes (v18 emits these instead of / in addition to `CppAttributeList`) +6. Add a canonical-name guardrail for tag/typedef remaps before removing manual + remaps wholesale. When a tag has multiple viable typedef names, prefer the + existing public name that participates in `requiredNamespacesForNames.rsp` + and other emitter namespace policy, rather than choosing purely by lexical + cleanup. This preserves cases like + `_RTL_UMS_THREAD_INFO_CLASS=UMS_THREAD_INFO_CLASS`, where auto-selecting + `RTL_UMS_THREAD_INFO_CLASS` created a namespace-cycle regression + (`System.Power -> System.SystemServices -> System.Threading -> System.Power`). +7. Convert a small pilot set (~20 functions) of `WithSetLastError.rsp` entries into + header annotations and verify the winmd output is identical +8. Write tests comparing winmd output before/after + +**Success criteria:** A header with `_Sets_last_error_` produces the same winmd metadata +as the current `--with-setlasterror` rsp entry. + +### Phase 2: Simple Function Annotations + +**Goal:** Move the three largest function-level sidecar files into header annotations. + +| Sub-phase | Sidecar File | Entries | What Moves | +|---|---|---|---| +| 2a | `WithSetLastError.rsp` | ~1,600 | `_Sets_last_error_` on each function | +| 2b | `supportedOS.rsp` | ~8,600 | `_Min_os_version_(...)` on each function | +| 2c | `libMappingsManual.rsp` | ~190 | `#pragma comment(lib, "...")` in headers | + +**Approach:** For each sub-phase: +1. Generate `patches.json` entries from the current `.rsp` file (scripted conversion) +2. Implement the patch application tool +3. Remove the corresponding `.rsp` entries as patches take over +4. Validate winmd output is identical via `CompareBinToLastRelease.ps1` + +### Phase 3: Parameter and Return Value Annotations + +**Goal:** Move emitter memberRemap annotations into headers. + +| Annotation | Example | Count | +|---|---|---| +| `_Must_close_with_(func)` | `FindFirstFileA` → `FindClose` | ~50 | +| `_Com_out_ptr_` | COM `ppv` parameters | ~30 | +| `_Do_not_release_` | `GetProcessHeaps::ProcessHeaps` | ~20 | +| `_Not_null_terminated_` | Binary buffer parameters | ~10 | +| `_Null_null_terminated_` | Environment block params | ~10 | +| `_Array_count_param_(n)` | Counted array parameters | ~50 | +| `_Memory_size_param_(n)` | Memory size parameters | ~20 | +| `_Can_return_errors_as_success_` | HRESULT functions | ~30 | +| `_Multiple_success_values_` | Functions with multiple S_ codes | ~10 | + +**Challenges:** +- Parameter-level annotations require locating the specific parameter in the + declaration, not just the function name +- The patch tool needs parameter-aware parsing (not just function-level regex) +- Some of these apply to COM interface methods in IDL-generated headers + +### Phase 4: Handle/Type Annotations + +**Goal:** Move `autoTypes.json` RAII metadata into handle typedefs. + +This covers handle types like: +```c +// Before (in autoTypes.json): +// { "Name": "HMODULE", "CloseApi": "FreeLibrary", "InvalidHandleValues": [0] } + +// After (in header): +_Close_handle_with_(FreeLibrary) +_Invalid_handle_(0) +DECLARE_HANDLE(HMODULE); +``` + +**Complexity:** The `DECLARE_HANDLE` macro is a single-line macro, so annotations +must go before it. The patch tool needs to handle this pattern. + +### Phase 5: Enum Reform (Long-term) + +**Goal:** Replace `#define` constant groups with proper C `enum` types. + +This is the hardest phase because it requires actual structural changes to headers: + +```c +// Before (current SDK): +#define FILE_ATTRIBUTE_READONLY 0x00000001 +#define FILE_ATTRIBUTE_HIDDEN 0x00000002 +#define FILE_ATTRIBUTE_SYSTEM 0x00000004 + +// After (desired): +typedef enum FILE_ATTRIBUTE_FLAGS { + FILE_ATTRIBUTE_READONLY = 0x00000001, + FILE_ATTRIBUTE_HIDDEN = 0x00000002, + FILE_ATTRIBUTE_SYSTEM = 0x00000004, +} FILE_ATTRIBUTE_FLAGS; +// Backwards compat #defines still present: +#define FILE_ATTRIBUTE_READONLY FILE_ATTRIBUTE_FLAGS_FILE_ATTRIBUTE_READONLY +``` + +**Challenges:** +- ~500 enum definitions to convert +- Backwards compatibility — existing code uses `#define` values directly +- Some constants are used as both enum values and bitfield flags +- Requires Windows SDK team buy-in for header changes +- `enums.json` auto-populate feature (regex matching `#define` patterns) has no + header equivalent — the enum members must be explicitly listed + +**Interim approach:** Keep `enums.json` but add a header annotation for enum *usage*: + +```c +// Annotate parameters that should use enum types: +// (This is conceptually what enums.json "uses" already express) +BOOL SetFileAttributesA( + _In_ LPCSTR lpFileName, + _W32M_anno1("enumtype", "FILE_ATTRIBUTE_FLAGS") DWORD dwFileAttributes +); +``` + +This can be expressed with a macro: +```c +#define _Enum_type_(name) _W32M_anno1("enumtype", #name) +``` + +--- + +## Risks and Mitigations + +### Risk 1: ClangSharp doesn't preserve custom `__attribute__((annotate(...)))` data + +**Status: RESOLVED** — ClangSharp v17 (currently pinned) only preserves annotate +attributes on parameters. However, ClangSharp v18+ (PR [#552](https://github.com/dotnet/ClangSharp/pull/552)) +added `[NativeAnnotation("...")]` support that preserves annotate attributes on +**all declaration types**: functions, parameters, struct fields, and return values. +We validated this by testing v18.1.0.4 against our full test suite — every proposed +annotation type works. **Upgrading to v18+ is a prerequisite for this workstream.** + +### Risk 2: Annotation placement varies across header styles + +**Likelihood:** Medium — Windows SDK headers are not uniformly formatted. Function +declarations span multiple lines, use macros like `WINAPI`, and have inconsistent +whitespace. + +**Mitigation:** The patch tool should use Clang's own parser (via libclang or a C +parser library) to find declaration locations rather than regex. Alternatively, use +ClangSharp itself to identify declaration locations and generate patch coordinates. + +### Risk 3: Parameter-level annotations are hard to place in macroized declarations + +**Likelihood:** Medium — some SDK declarations use macros that expand to full function +signatures, making it impossible to annotate individual parameters. + +**Mitigation:** For these cases, keep the sidecar remap. Not every annotation needs +to move to headers — the goal is to move *as much as practical*, not necessarily 100%. + +### Risk 4: Windows SDK team may adopt different annotation syntax + +**Likelihood:** Medium — when the SDK team eventually adds metadata annotations to +official headers, they may choose different macro names or syntax. + +**Mitigation:** Our macro names are prefixed with `_W32M_` to avoid collisions. The +public-facing macros (`_Sets_last_error_`, etc.) can be renamed or aliased when the +SDK team standardizes. The patch system's staleness detection handles the transition. + +### Risk 5: Enum reform breaks backwards compatibility + +**Likelihood:** High — changing `#define` to `enum` can break C code that uses the +constants in ways incompatible with enum types (e.g., bitwise OR of different enum types). + +**Mitigation:** Phase 5 is explicitly long-term and requires SDK team coordination. +The interim approach (annotating parameters with `_Enum_type_`) gets most of the +metadata value without touching the constant definitions. + +--- + +## What Stays in Sidecar Files (permanently) + +Some metadata is inherently a win32metadata tooling concern: + +| File | Why It Stays | +|---|---| +| `Partitions/` | Namespace organization is our invention, not an SDK concept | +| `requiredNamespacesForNames.rsp` | Disambiguation for our namespace mapping | +| `documentationMappings.rsp` | URLs are external data, not header properties | +| `libMappings.rsp` (auto) | Generated from .lib scanning — would be redundant in headers | +| `emitter.settings.rsp` (typeImport) | WinRT interop configuration | +| `manual/` (some files) | Hand-written types for APIs that genuinely can't be scraped | +| `scraper.settings.rsp` (config) | ClangSharp behavior flags | + +--- + +## Measuring Progress + +For each sidecar file, track: + +``` +Total entries in sidecar file: N +Entries moved to header annotations: M (patches applied) +Entries adopted by official SDK: A (patches no longer needed) +Entries remaining in sidecar: N - M - A +Coverage: (M + A) / N × 100% +``` + +Target: 80%+ coverage for Category A metadata within the first two phases. + +--- + +## Validation Results (March 2026) + +We rigorously tested every proposed annotation through ClangSharp v17.0.1 and v18.1.0.4. +**Full details in `annotation-validation-results.md`.** Test files in `obj/annotation-validation/`. + +### ClangSharp v17.0.1 (currently pinned): Parameter-Only Support + +`__attribute__((annotate("w32m:...")))` on **function parameters** is preserved as +`[CppAttributeList("w32m:...")]`. All other placements (functions, return values, +struct fields, typedefs) are silently dropped with "Unsupported attribute: 'Annotate'". + +### ClangSharp v18.1.0.4+: Full Support ✅ + +PR [#552](https://github.com/dotnet/ClangSharp/pull/552) added `[NativeAnnotation("...")]` +attribute emission for `__attribute__((annotate(...)))` on **all declaration types**. +We validated every proposed annotation: + +| Annotation | Placement | v17 | v18 | +|---|---|---|---| +| `_Sets_last_error_` | function | ❌ | ✅ `[NativeAnnotation("w32m:setlasterror")]` | +| `_Min_os_version_(ver)` | function | ❌ | ✅ `[NativeAnnotation("w32m:minversion=...")]` | +| `_Must_close_with_(func)` | function/return | ❌ | ✅ `[NativeAnnotation("w32m:raiifree=...")]` | +| `_Can_return_errors_as_success_` | function | ❌ | ✅ `[NativeAnnotation("w32m:errorsassuccess")]` | +| `_Multiple_success_values_` | function | ❌ | ✅ `[NativeAnnotation("w32m:multiplesuccess")]` | +| Multiple annotations on function | function | ❌ | ✅ Each as separate `[NativeAnnotation]` | +| Return value annotations | return | ❌ | ✅ Appears on method | +| `_Enum_type_(name)` on struct field | field | ❌ | ✅ `[NativeAnnotation("w32m:enumtype=...")]` | +| `_Not_null_terminated_` on struct field | field | ❌ | ✅ `[NativeAnnotation("w32m:notnullterm")]` | +| All parameter annotations | param | ✅ | ✅ Both `CppAttributeList` AND `NativeAnnotation` | +| SAL + custom coexistence | param | ✅ | ✅ Both present without interference | +| `__declspec` on function | function | ❌ | ❌ Still dropped (not needed) | + +**Conclusion:** Upgrading ClangSharp to v18+ eliminates all workarounds. No extraction +tools, no carrier-parameter hacks — `__attribute__((annotate(...)))` flows through the +AST into `[NativeAnnotation("...")]` on the correct declaration in the generated C#. +The emitter (`MetadataSyntaxTreeCleaner`) needs to be updated to process +`NativeAnnotation` attributes in addition to `CppAttributeList`. + +**Typedef annotations** are a special case: `__attribute__((annotate(...)))` on a +typedef is preserved on the function parameters that use that typedef, but the typedef +itself is typically flattened by ClangSharp. Handle types from `autoTypes.json` are +generated structurally and will continue to need their JSON definition for the +`DECLARE_HANDLE` pattern, but RAII/close metadata can move to annotations. + +--- + +## Open Questions for Review + +1. **ClangSharp upgrade**: v17→v18 is a major version bump. Are there breaking + changes that affect our existing pipeline? Need a compatibility assessment. + +2. **`NativeAnnotation` vs `CppAttributeList`**: v18 emits BOTH for parameters. + Should `MetadataSyntaxTreeCleaner` process `NativeAnnotation` only (cleaner), + or continue to support both for backwards compat? + +3. **Enum reform strategy**: Annotate parameters with enum types (interim) vs. + actually create enum definitions (requires SDK changes)? + +4. **Macro naming convention**: SAL-style `_Sets_last_error_` vs. + `WIN32META_SETS_LAST_ERROR`? + +5. **Typedef/handle type metadata**: Keep in `autoTypes.json` (structural definition) + but move RAII annotations to headers? Or find a way to express the full typedef + definition as an annotation? diff --git a/generation/WinSDK/Partitions/IpHlp/main.cpp b/generation/WinSDK/Partitions/IpHlp/main.cpp index 4e796cdae..5b71cdf91 100644 --- a/generation/WinSDK/Partitions/IpHlp/main.cpp +++ b/generation/WinSDK/Partitions/IpHlp/main.cpp @@ -18,3 +18,4 @@ #include #include #include +#include diff --git a/generation/WinSDK/Partitions/NetMgmt/main.cpp b/generation/WinSDK/Partitions/NetMgmt/main.cpp index fa40ca80c..b91acbbd1 100644 --- a/generation/WinSDK/Partitions/NetMgmt/main.cpp +++ b/generation/WinSDK/Partitions/NetMgmt/main.cpp @@ -35,3 +35,4 @@ //#include -- won't compile because it includes stm.h which is missing a type #include #include +#include diff --git a/generation/WinSDK/Partitions/RRas/main.cpp b/generation/WinSDK/Partitions/RRas/main.cpp index b101e04ba..56e14dd06 100644 --- a/generation/WinSDK/Partitions/RRas/main.cpp +++ b/generation/WinSDK/Partitions/RRas/main.cpp @@ -19,3 +19,4 @@ extern "C" { } #include #include +#include diff --git a/generation/WinSDK/Partitions/Security.Cryptography.Sip/main.cpp b/generation/WinSDK/Partitions/Security.Cryptography.Sip/main.cpp index 6ee496e18..db0c4188c 100644 --- a/generation/WinSDK/Partitions/Security.Cryptography.Sip/main.cpp +++ b/generation/WinSDK/Partitions/Security.Cryptography.Sip/main.cpp @@ -28,3 +28,4 @@ typedef struct _OLD_LARGE_INTEGER { #include #include #include +#include diff --git a/generation/WinSDK/Partitions/Security.WinTrust/main.cpp b/generation/WinSDK/Partitions/Security.WinTrust/main.cpp index 76d6e7027..d801a95cf 100644 --- a/generation/WinSDK/Partitions/Security.WinTrust/main.cpp +++ b/generation/WinSDK/Partitions/Security.WinTrust/main.cpp @@ -31,3 +31,4 @@ typedef struct _OLD_LARGE_INTEGER { #include #include +#include diff --git a/generation/WinSDK/Partitions/TermServ/main.cpp b/generation/WinSDK/Partitions/TermServ/main.cpp index 16adf0ec2..626853e32 100644 --- a/generation/WinSDK/Partitions/TermServ/main.cpp +++ b/generation/WinSDK/Partitions/TermServ/main.cpp @@ -34,3 +34,4 @@ #include #include #include +#include diff --git a/generation/WinSDK/Partitions/Wsw/main.cpp b/generation/WinSDK/Partitions/Wsw/main.cpp index 52a7b2c4a..ea357a08d 100644 --- a/generation/WinSDK/Partitions/Wsw/main.cpp +++ b/generation/WinSDK/Partitions/Wsw/main.cpp @@ -8,3 +8,4 @@ #include #include +#include diff --git a/generation/WinSDK/functionPointerFixups.json b/generation/WinSDK/functionPointerFixups.json index 45c6cd083..504832200 100644 --- a/generation/WinSDK/functionPointerFixups.json +++ b/generation/WinSDK/functionPointerFixups.json @@ -1,576 +1,8 @@ [ { - "name": "TIMECALLBACK", - "pointerType": "LPTIMECALLBACK" - }, - { - "name": "INTERFACE_TIMESTAMP_CONFIG_CHANGE_CALLBACK", - "pointerType": "PINTERFACE_TIMESTAMP_CONFIG_CHANGE_CALLBACK" - }, - { - "name": "RPCNOTIFICATION_ROUTINE", - "pointerType": "PFN_RPCNOTIFICATION_ROUTINE" - }, - { - "name": "CHANNEL_INIT_EVENT_FN", - "pointerType": "PCHANNEL_INIT_EVENT_FN" - }, - { - "name": "CHANNEL_OPEN_EVENT_FN", - "pointerType": "PCHANNEL_OPEN_EVENT_FN" - }, - { - "name": "VIRTUALCHANNELINIT", - "pointerType": "PVIRTUALCHANNELINIT" - }, - { - "name": "VIRTUALCHANNELOPEN", - "pointerType": "PVIRTUALCHANNELOPEN" - }, - { - "name": "VIRTUALCHANNELCLOSE", - "pointerType": "PVIRTUALCHANNELCLOSE" - }, - { - "name": "VIRTUALCHANNELWRITE", - "pointerType": "PVIRTUALCHANNELWRITE" - }, - { - "name": "VIRTUALCHANNELENTRY", - "pointerType": "PVIRTUALCHANNELENTRY" - }, - { - "name": "ALLOCATEBUFFER", - "pointerType": "LPALLOCATEBUFFER" - }, - { - "name": "ALLOCATEMORE", - "pointerType": "LPALLOCATEMORE" - }, - { - "name": "FREEBUFFER", - "pointerType": "LPFREEBUFFER" - }, - { - "name": "NOTIFCALLBACK", - "pointerType": "LPNOTIFCALLBACK" - }, - { - "name": "ACCELERATEABSDI", - "pointerType": "LPFNABSDI" - }, - { - "name": "DISMISSMODELESS", - "pointerType": "LPFNDISMISS" - }, - { - "name": "WABOPEN", - "pointerType": "LPWABOPEN" - }, - { - "name": "WABOPENEX", - "pointerType": "LPWABOPENEX" - }, - { - "name": "DNS_QUERY_COMPLETION_ROUTINE", - "pointerType": "PDNS_QUERY_COMPLETION_ROUTINE" - }, - { - "name": "DNS_SERVICE_BROWSE_CALLBACK", - "pointerType": "PDNS_SERVICE_BROWSE_CALLBACK" - }, - { - "name": "DNS_SERVICE_RESOLVE_COMPLETE", - "pointerType": "PDNS_SERVICE_RESOLVE_COMPLETE" - }, - { - "name": "DNS_SERVICE_REGISTER_COMPLETE", - "pointerType": "PDNS_SERVICE_REGISTER_COMPLETE" - }, - { - "name": "MDNS_QUERY_CALLBACK", - "pointerType": "PMDNS_QUERY_CALLBACK" - }, - { - "name": "RTL_UMS_SCHEDULER_ENTRY_POINT", - "pointerType": "PRTL_UMS_SCHEDULER_ENTRY_POINT" - }, - { - "name": "PFIBER_START_ROUTINE", - "pointerType": "LPFIBER_START_ROUTINE" - }, - { - "name": "FEATURE_STATE_CHANGE_CALLBACK", - "pointerType": "PFEATURE_STATE_CHANGE_CALLBACK" - }, - { - "name": "BAD_MEMORY_CALLBACK_ROUTINE", - "pointerType": "PBAD_MEMORY_CALLBACK_ROUTINE" - }, - { - "name": "PWRSCHEMESENUMPROC_V2", - "pointerType": "PWRSCHEMESENUMPROC" - }, - { - "name": "DEVICE_NOTIFY_CALLBACK_ROUTINE", - "pointerType": "PDEVICE_NOTIFY_CALLBACK_ROUTINE" - }, - { - "name": "PBMCALLBACKFN", - "pointerType": "LPBMCALLBACKFN" - }, - { - "name": "MAPILOGON", - "pointerType": "LPMAPILOGON" - }, - { - "name": "MAPILOGOFF", - "pointerType": "LPMAPILOGOFF" - }, - { - "name": "MAPISENDMAIL", - "pointerType": "LPMAPISENDMAIL" - }, - { - "name": "MAPISENDMAILW", - "pointerType": "LPMAPISENDMAILW" - }, - { - "name": "MAPIFINDNEXT", - "pointerType": "LPMAPIFINDNEXT" - }, - { - "name": "MAPIREADMAIL", - "pointerType": "LPMAPIREADMAIL" - }, - { - "name": "MAPISAVEMAIL", - "pointerType": "LPMAPISAVEMAIL" - }, - { - "name": "MAPIDELETEMAIL", - "pointerType": "LPMAPIDELETEMAIL" - }, - { - "name": "MAPIADDRESS", - "pointerType": "LPMAPIADDRESS" - }, - { - "name": "MAPIDETAILS", - "pointerType": "LPMAPIDETAILS" - }, - { - "name": "MAPIRESOLVENAME", - "pointerType": "LPMAPIRESOLVENAME" - }, - { - "name": "GET_RESOURCE_STRING_FN", - "pointerType": "PGET_RESOURCE_STRING_FN" - }, - { - "name": "NS_CONTEXT_COMMIT_FN", - "pointerType": "PNS_CONTEXT_COMMIT_FN" - }, - { - "name": "NS_CONTEXT_CONNECT_FN", - "pointerType": "PNS_CONTEXT_CONNECT_FN" - }, - { - "name": "NS_CONTEXT_DUMP_FN", - "pointerType": "PNS_CONTEXT_DUMP_FN" - }, - { - "name": "NS_DLL_STOP_FN", - "pointerType": "PNS_DLL_STOP_FN" - }, - { - "name": "NS_HELPER_START_FN", - "pointerType": "PNS_HELPER_START_FN" - }, - { - "name": "NS_HELPER_STOP_FN", - "pointerType": "PNS_HELPER_STOP_FN" - }, - { - "name": "FN_HANDLE_CMD", - "pointerType": "PFN_HANDLE_CMD" - }, - { - "name": "FN_CUSTOM_HELP", - "pointerType": "PFN_CUSTOM_HELP" - }, - { - "name": "NS_OSVERSIONCHECK", - "pointerType": "PNS_OSVERSIONCHECK" - }, - { - "name": "NS_DLL_INIT_FN", - "pointerType": "PNS_DLL_INIT_FN" - }, - { - "name": "DRVCALLBACK", - "pointerType": "LPDRVCALLBACK" - }, - { - "name": "MMIOPROC", - "pointerType": "LPMMIOPROC" - }, - { - "name": "ACMDRIVERPROC", - "pointerType": "LPACMDRIVERPROC" - }, - { - "name": "JOYDEVMSGPROC", - "pointerType": "LPJOYDEVMSGPROC" - }, - { - "name": "TASKCALLBACK", - "pointerType": "LPTASKCALLBACK" - }, - { - "name": "INSTALLUI_HANDLER_RECORD", - "pointerType": "PINSTALLUI_HANDLER_RECORD" - }, - { - "name": "LPFNADDPROPSHEETPAGE", - "pointerType": "LPFNSVADDPROPSHEETPAGE" - }, - { - "name": "PTOP_LEVEL_EXCEPTION_FILTER", - "pointerType": "LPTOP_LEVEL_EXCEPTION_FILTER" - }, - { - "name": "SC_NOTIFICATION_CALLBACK", - "pointerType": "PSC_NOTIFICATION_CALLBACK" - }, - { - "name": "LSA_CREATE_LOGON_SESSION", - "pointerType": "PLSA_CREATE_LOGON_SESSION" - }, - { - "name": "LSA_DELETE_LOGON_SESSION", - "pointerType": "PLSA_DELETE_LOGON_SESSION" - }, - { - "name": "LSA_ADD_CREDENTIAL", - "pointerType": "PLSA_ADD_CREDENTIAL" - }, - { - "name": "LSA_GET_CREDENTIALS", - "pointerType": "PLSA_GET_CREDENTIALS" - }, - { - "name": "LSA_DELETE_CREDENTIAL", - "pointerType": "PLSA_DELETE_CREDENTIAL" - }, - { - "name": "LSA_ALLOCATE_LSA_HEAP", - "pointerType": "PLSA_ALLOCATE_LSA_HEAP" - }, - { - "name": "LSA_FREE_LSA_HEAP", - "pointerType": "PLSA_FREE_LSA_HEAP" - }, - { - "name": "LSA_ALLOCATE_PRIVATE_HEAP", - "pointerType": "PLSA_ALLOCATE_PRIVATE_HEAP" - }, - { - "name": "LSA_FREE_PRIVATE_HEAP", - "pointerType": "PLSA_FREE_PRIVATE_HEAP" - }, - { - "name": "LSA_ALLOCATE_CLIENT_BUFFER", - "pointerType": "PLSA_ALLOCATE_CLIENT_BUFFER" - }, - { - "name": "LSA_FREE_CLIENT_BUFFER", - "pointerType": "PLSA_FREE_CLIENT_BUFFER" - }, - { - "name": "LSA_COPY_TO_CLIENT_BUFFER", - "pointerType": "PLSA_COPY_TO_CLIENT_BUFFER" - }, - { - "name": "LSA_COPY_FROM_CLIENT_BUFFER", - "pointerType": "PLSA_COPY_FROM_CLIENT_BUFFER" - }, - { - "name": "LSA_AP_INITIALIZE_PACKAGE", - "pointerType": "PLSA_AP_INITIALIZE_PACKAGE" - }, - { - "name": "LSA_AP_LOGON_USER", - "pointerType": "PLSA_AP_LOGON_USER" - }, - { - "name": "LSA_AP_LOGON_USER_EX", - "pointerType": "PLSA_AP_LOGON_USER_EX" - }, - { - "name": "LSA_AP_CALL_PACKAGE", - "pointerType": "PLSA_AP_CALL_PACKAGE" - }, - { - "name": "LSA_AP_CALL_PACKAGE_PASSTHROUGH", - "pointerType": "PLSA_AP_CALL_PACKAGE_PASSTHROUGH" - }, - { - "name": "LSA_AP_LOGON_TERMINATED", - "pointerType": "PLSA_AP_LOGON_TERMINATED" - }, - { - "name": "LSA_CALLBACK_FUNCTION", - "pointerType": "PLSA_CALLBACK_FUNCTION" - }, - { - "name": "LSA_REDIRECTED_LOGON_INIT", - "pointerType": "PLSA_REDIRECTED_LOGON_INIT" - }, - { - "name": "LSA_REDIRECTED_LOGON_CALLBACK", - "pointerType": "PLSA_REDIRECTED_LOGON_CALLBACK" - }, - { - "name": "LSA_REDIRECTED_LOGON_GET_LOGON_CREDS", - "pointerType": "PLSA_REDIRECTED_LOGON_GET_LOGON_CREDS" - }, - { - "name": "LSA_REDIRECTED_LOGON_GET_SUPP_CREDS", - "pointerType": "PLSA_REDIRECTED_LOGON_GET_SUPP_CREDS" - }, - { - "name": "LSA_REDIRECTED_LOGON_CLEANUP_CALLBACK", - "pointerType": "PLSA_REDIRECTED_LOGON_CLEANUP_CALLBACK" - }, - { - "name": "LSA_REDIRECTED_LOGON_GET_SID", - "pointerType": "PLSA_REDIRECTED_LOGON_GET_SID" - }, - { - "name": "LSA_IMPERSONATE_CLIENT", - "pointerType": "PLSA_IMPERSONATE_CLIENT" - }, - { - "name": "LSA_UNLOAD_PACKAGE", - "pointerType": "PLSA_UNLOAD_PACKAGE" - }, - { - "name": "LSA_DUPLICATE_HANDLE", - "pointerType": "PLSA_DUPLICATE_HANDLE" - }, - { - "name": "LSA_SAVE_SUPPLEMENTAL_CREDENTIALS", - "pointerType": "PLSA_SAVE_SUPPLEMENTAL_CREDENTIALS" - }, - { - "name": "LSA_CREATE_THREAD", - "pointerType": "PLSA_CREATE_THREAD" - }, - { - "name": "LSA_GET_CLIENT_INFO", - "pointerType": "PLSA_GET_CLIENT_INFO" - }, - { - "name": "LSA_GET_CLIENT_INFO_EX", - "pointerType": "PLSA_GET_CLIENT_INFO_EX" - }, - { - "name": "LSA_REGISTER_NOTIFICATION", - "pointerType": "PLSA_REGISTER_NOTIFICATION" - }, - { - "name": "LSA_CANCEL_NOTIFICATION", - "pointerType": "PLSA_CANCEL_NOTIFICATION" - }, - { - "name": "LSA_MAP_BUFFER", - "pointerType": "PLSA_MAP_BUFFER" - }, - { - "name": "LSA_CREATE_TOKEN", - "pointerType": "PLSA_CREATE_TOKEN" - }, - { - "name": "LSA_AUDIT_LOGON", - "pointerType": "PLSA_AUDIT_LOGON" - }, - { - "name": "LSA_CALL_PACKAGE", - "pointerType": "PLSA_CALL_PACKAGE" - }, - { - "name": "LSA_CALL_PACKAGEEX", - "pointerType": "PLSA_CALL_PACKAGEEX" - }, - { - "name": "LSA_GET_CALL_INFO", - "pointerType": "PLSA_GET_CALL_INFO" - }, - { - "name": "LSA_AP_LOGON_USER_EX2", - "pointerType": "PLSA_AP_LOGON_USER_EX2" - }, - { - "name": "LSA_AP_LOGON_USER_EX3", - "pointerType": "PLSA_AP_LOGON_USER_EX3" - }, - { - "name": "LSA_CREATE_SHARED_MEMORY", - "pointerType": "PLSA_CREATE_SHARED_MEMORY" - }, - { - "name": "LSA_ALLOCATE_SHARED_MEMORY", - "pointerType": "PLSA_ALLOCATE_SHARED_MEMORY" - }, - { - "name": "LSA_FREE_SHARED_MEMORY", - "pointerType": "PLSA_FREE_SHARED_MEMORY" - }, - { - "name": "LSA_DELETE_SHARED_MEMORY", - "pointerType": "PLSA_DELETE_SHARED_MEMORY" - }, - { - "name": "LSA_OPEN_SAM_USER", - "pointerType": "PLSA_OPEN_SAM_USER" - }, - { - "name": "LSA_GET_USER_CREDENTIALS", - "pointerType": "PLSA_GET_USER_CREDENTIALS" - }, - { - "name": "LSA_GET_USER_AUTH_DATA", - "pointerType": "PLSA_GET_USER_AUTH_DATA" - }, - { - "name": "LSA_CLOSE_SAM_USER", - "pointerType": "PLSA_CLOSE_SAM_USER" - }, - { - "name": "LSA_CONVERT_AUTH_DATA_TO_TOKEN", - "pointerType": "PLSA_CONVERT_AUTH_DATA_TO_TOKEN" - }, - { - "name": "LSA_CLIENT_CALLBACK", - "pointerType": "PLSA_CLIENT_CALLBACK" - }, - { - "name": "LSA_REGISTER_CALLBACK", - "pointerType": "PLSA_REGISTER_CALLBACK" - }, - { - "name": "LSA_UPDATE_PRIMARY_CREDENTIALS", - "pointerType": "PLSA_UPDATE_PRIMARY_CREDENTIALS" - }, - { - "name": "LSA_GET_AUTH_DATA_FOR_USER", - "pointerType": "PLSA_GET_AUTH_DATA_FOR_USER" - }, - { - "name": "LSA_CRACK_SINGLE_NAME", - "pointerType": "PLSA_CRACK_SINGLE_NAME" - }, - { - "name": "LSA_AUDIT_ACCOUNT_LOGON", - "pointerType": "PLSA_AUDIT_ACCOUNT_LOGON" - }, - { - "name": "LSA_CALL_PACKAGE_PASSTHROUGH", - "pointerType": "PLSA_CALL_PACKAGE_PASSTHROUGH" - }, - { - "name": "LSA_PROTECT_MEMORY", - "pointerType": "PLSA_PROTECT_MEMORY" - }, - { - "name": "LSA_OPEN_TOKEN_BY_LOGON_ID", - "pointerType": "PLSA_OPEN_TOKEN_BY_LOGON_ID" - }, - { - "name": "LSA_EXPAND_AUTH_DATA_FOR_DOMAIN", - "pointerType": "PLSA_EXPAND_AUTH_DATA_FOR_DOMAIN" - }, - { - "name": "LSA_CREATE_TOKEN_EX", - "pointerType": "PLSA_CREATE_TOKEN_EX" - }, - { - "name": "LSA_GET_EXTENDED_CALL_FLAGS ", + "name": "LSA_GET_EXTENDED_CALL_FLAGS", "pointerType": "PLSA_GET_EXTENDED_CALL_FLAGS" }, - { - "name": "LSA_GET_SERVICE_ACCOUNT_PASSWORD", - "pointerType": "PLSA_GET_SERVICE_ACCOUNT_PASSWORD" - }, - { - "name": "LSA_AUDIT_LOGON_EX", - "pointerType": "PLSA_AUDIT_LOGON_EX" - }, - { - "name": "LSA_CHECK_PROTECTED_USER_BY_TOKEN", - "pointerType": "PLSA_CHECK_PROTECTED_USER_BY_TOKEN" - }, - { - "name": "LSA_QUERY_CLIENT_REQUEST", - "pointerType": "PLSA_QUERY_CLIENT_REQUEST" - }, - { - "name": "LSA_GET_APP_MODE_INFO", - "pointerType": "PLSA_GET_APP_MODE_INFO" - }, - { - "name": "LSA_SET_APP_MODE_INFO", - "pointerType": "PLSA_SET_APP_MODE_INFO" - }, - { - "name": "KSEC_CREATE_CONTEXT_LIST", - "pointerType": "PKSEC_CREATE_CONTEXT_LIST" - }, - { - "name": "KSEC_INSERT_LIST_ENTRY", - "pointerType": "PKSEC_INSERT_LIST_ENTRY" - }, - { - "name": "KSEC_REFERENCE_LIST_ENTRY", - "pointerType": "PKSEC_REFERENCE_LIST_ENTRY" - }, - { - "name": "KSEC_DEREFERENCE_LIST_ENTRY", - "pointerType": "PKSEC_DEREFERENCE_LIST_ENTRY" - }, - { - "name": "KSEC_SERIALIZE_WINNT_AUTH_DATA", - "pointerType": "PKSEC_SERIALIZE_WINNT_AUTH_DATA" - }, - { - "name": "KSEC_SERIALIZE_SCHANNEL_AUTH_DATA", - "pointerType": "PKSEC_SERIALIZE_SCHANNEL_AUTH_DATA" - }, - { - "name": "KSEC_LOCATE_PKG_BY_ID", - "pointerType": "PKSEC_LOCATE_PKG_BY_ID" - }, - { - "name": "MAPISENDDOCUMENTS", - "pointerType": "LPMAPISENDDOCUMENTS" - }, - { - "name": "QUERYHANDLER", - "pointerType": "PQUERYHANDLER" - }, - { - "name": "LSA_LOCATE_PKG_BY_ID", - "pointerType": "PLSA_LOCATE_PKG_BY_ID" - }, - { - "name": "LSA_AP_PRE_LOGON_USER_SURROGATE", - "pointerType": "PLSA_AP_PRE_LOGON_USER_SURROGATE" - }, - { - "name": "LSA_AP_POST_LOGON_USER_SURROGATE", - "pointerType": "PLSA_AP_POST_LOGON_USER_SURROGATE" - }, { "name": "QUERYFORCONNECTION" }, @@ -630,56 +62,6 @@ "pointerType": "RTM_ENTITY_EXPORT_METHOD", "alreadyPointer": true }, - { - "name": "PTHREAD_START_ROUTINE", - "pointerType": "LPTHREAD_START_ROUTINE", - "alreadyPointer": true - }, - { - "name": "INTERNET_STATUS_CALLBACK", - "pointerType": "LPINTERNET_STATUS_CALLBACK", - "alreadyPointer": true - }, - { - "name": "GET_RUNTIME_FUNCTION_CALLBACK", - "pointerType": "PGET_RUNTIME_FUNCTION_CALLBACK" - }, - { - "name": "OUT_OF_PROCESS_FUNCTION_TABLE_CALLBACK", - "pointerType": "POUT_OF_PROCESS_FUNCTION_TABLE_CALLBACK" - }, - { - "name": "PATCH_PROGRESS_CALLBACK", - "pointerType": "PPATCH_PROGRESS_CALLBACK" - }, - { - "name": "PATCH_SYMLOAD_CALLBACK", - "pointerType": "PPATCH_SYMLOAD_CALLBACK" - }, - { - "name": "DISPATCHNOTIFICATIONS", - "pointerType": "LPDISPATCHNOTIFICATIONS" - }, - { - "name": "CREATECONVERSATIONINDEX", - "pointerType": "LPCREATECONVERSATIONINDEX" - }, - { - "name": "WABALLOCATEBUFFER", - "pointerType": "LPWABALLOCATEBUFFER" - }, - { - "name": "WABALLOCATEMORE", - "pointerType": "LPWABALLOCATEMORE" - }, - { - "name": "WABFREEBUFFER", - "pointerType": "LPWABFREEBUFFER" - }, - { - "name": "AudioStateMonitorCallback", - "pointerType": "PAudioStateMonitorCallback" - }, { "name": "_WHEA_ERROR_SOURCE_INITIALIZE_DEVICE_DRIVER", "pointerType": "WHEA_ERROR_SOURCE_INITIALIZE_DEVICE_DRIVER" @@ -693,39 +75,29 @@ "pointerType": "WHEA_ERROR_SOURCE_CORRECT_DEVICE_DRIVER" }, { - "name": "FNIDLE", - "pointerType": "PFNIDLE" - }, - { - "name": "DUMP_DEVICE_POWERON_ROUTINE", - "pointerType": "PDUMP_DEVICE_POWERON_ROUTINE" - }, - { - "name": "LSA_GET_SECPKG_FAILURE_REASON", - "pointerType": "PLSA_GET_SECPKG_FAILURE_REASON" - }, - { - "name": "LSA_SET_SECPKG_FAILURE_REASON", - "pointerType": "PLSA_SET_SECPKG_FAILURE_REASON" + "name": "PTHREAD_START_ROUTINE", + "pointerType": "LPTHREAD_START_ROUTINE", + "alreadyPointer": true }, { - "name": "TP_SIMPLE_CALLBACK", - "pointerType": "PTP_SIMPLE_CALLBACK" + "name": "INTERNET_STATUS_CALLBACK", + "pointerType": "LPINTERNET_STATUS_CALLBACK", + "alreadyPointer": true }, { - "name": "TP_CLEANUP_GROUP_CANCEL_CALLBACK", - "pointerType": "PTP_CLEANUP_GROUP_CANCEL_CALLBACK" + "name": "PBMCALLBACKFN", + "pointerType": "LPBMCALLBACKFN" }, { - "name": "TP_WORK_CALLBACK", - "pointerType": "PTP_WORK_CALLBACK" + "name": "PTOP_LEVEL_EXCEPTION_FILTER", + "pointerType": "LPTOP_LEVEL_EXCEPTION_FILTER" }, { - "name": "TP_TIMER_CALLBACK", - "pointerType": "PTP_TIMER_CALLBACK" + "name": "LPFNADDPROPSHEETPAGE", + "pointerType": "LPFNSVADDPROPSHEETPAGE" }, { - "name": "TP_WAIT_CALLBACK", - "pointerType": "PTP_WAIT_CALLBACK" + "name": "PFIBER_START_ROUTINE", + "pointerType": "LPFIBER_START_ROUTINE" } ] diff --git a/generation/WinSDK/scraper.settings.rsp b/generation/WinSDK/scraper.settings.rsp index f93fee3cd..cae95b12e 100644 --- a/generation/WinSDK/scraper.settings.rsp +++ b/generation/WinSDK/scraper.settings.rsp @@ -170,1646 +170,91 @@ DEVPKEY_Device_SupportsSearch DEVPKEY_Device_SupportsMute DEVPKEY_Device_MaxVolume DEVPKEY_Device_SupportsSetNextAVT +--exclude-auto-remap +# Temporary compatibility pins: keep the historical public names until we intentionally +# accept the corresponding breaking renames in the winmd surface. +DxcBuffer +_DnsRecordOptA +_ERROR_INFOW +D3D12_SERIALIZED_BLOCK_TYPE +_SPLCLIENT_INFO_2_V3 +DTC_STATUS_ +WHV_PROCESSOR_INTERCEPT_COUNTERS +WHV_PROCESSOR_EVENT_COUNTERS +CompilationRelaxationsEnum --remap ABI::Windows::Foundation::IActivatableClassRegistration=IActivatableClassRegistration -adpcmcoef_tag=ADPCMCOEFSET -adpcmewaveformat_tag=ADPCMEWAVEFORMAT -adpcmwaveformat_tag=ADPCMWAVEFORMAT -aptxwaveformat_tag=APTXWAVEFORMAT -audiofile_af10waveformat_tag=AUDIOFILE_AF10WAVEFORMAT -audiofile_af36waveformat_tag=AUDIOFILE_AF36WAVEFORMAT -CONFIG_CI_PROV_INFO_=CONFIG_CI_PROV_INFO -CONFIG_CI_PROV_INFO_RESULT_=CONFIG_CI_PROV_INFO_RESULT -contres_cr10waveformat_tag=CONTRESCR10WAVEFORMAT -contres_vqlpcwaveformat_tag=CONTRESVQLPCWAVEFORMAT -creative_adpcmwaveformat_tag=CREATIVEADPCMWAVEFORMAT -creative_fastspeech8format_tag=CREATIVEFASTSPEECH8WAVEFORMAT -creative_fastspeech10format_tag=CREATIVEFASTSPEECH10WAVEFORMAT -creative_fastspeechformat_tag=DIALOGICOKIADPCMWAVEFORMAT -csimaadpcmwaveformat_tag=CSIMAADPCMWAVEFORMAT D3D11_AUTHENTICATED_PROTECTION_FLAGS::__MIDL___MIDL_itf_d3d11_0000_0034_0001=_Flags_e__Struct DEVPROPGUID=Guid -digiadpcmmwaveformat_tag=DIGIADPCMWAVEFORMAT -digifixwaveformat_tag=DIGIFIXWAVEFORMAT -digirealwaveformat_tag=DIGIREALWAVEFORMAT -digistdwaveformat_tag=DIGISTDWAVEFORMAT -dolbyac2waveformat_tag=DOLBYAC2WAVEFORMAT -DRIVER_VER_INFO_=DRIVER_VER_INFO -DRIVER_VER_MAJORMINOR_=DRIVER_VER_MAJORMINOR -drmwaveformat_tag=DRMWAVEFORMAT -dvi_adpcmwaveformat_tag=DVIADPCMWAVEFORMAT DWORD_PTR=UIntPtr -echosc1waveformat_tag=ECHOSC1WAVEFORMAT -fmtowns_snd_waveformat_tag=FMTOWNS_SND_WAVEFORMAT -g721_adpcmwaveformat_tag=G721_ADPCMWAVEFORMAT -g723_adpcmwaveformat_tag=G723_ADPCMWAVEFORMAT -gsm610waveformat_tag=GSM610WAVEFORMAT PBOOL=BOOL* LPBOOL=BOOL* PBOOLEAN=BOOLEAN* LPBOOLEAN=BOOLEAN* HFILTER_INSTANCE1*=HFILTER_INSTANCE* __MIDL___MIDL_itf_uianimation_0000_0002_0003*=UI_ANIMATION_KEYFRAME -heaacwaveformat_tag=HEAACWAVEFORMAT -heaacwaveinfo_tag=HEAACWAVEINFO ID3D10Blob=ID3DBlob -ima_adpcmwaveformat_tag=IMAADPCMWAVEFORMAT INT_PTR=IntPtr LONG_PTR=IntPtr LPARAM=IntPtr LRESULT=IntPtr -mediaspace_adpcmwaveformat_tag=MEDIASPACEADPCMWAVEFORMAT -midievent_tag=MIDIEVENT -midihdr_tag=MIDIHDR -midiproptempo_tag=MIDIPROPTEMPO -midiproptimediv_tag=MIDIPROPTIMEDIV -midistrmbuffver_tag=MIDISTRMBUFFVER -mmtime_tag=MMTIME -mpeg1waveformat_tag=MPEG1WAVEFORMAT -mpeglayer3waveformat_tag=MPEGLAYER3WAVEFORMAT -msaudio1waveformat_tag=MSAUDIO1WAVEFORMAT -MS_ADDINFO_BLOB_=MS_ADDINFO_BLOB -MS_ADDINFO_CATALOGMEMBER_=MS_ADDINFO_CATALOGMEMBER -MS_ADDINFO_FLAT_=MS_ADDINFO_FLAT -nms_vbxadpcmmwaveformat_tag=NMS_VBXADPCMWAVEFORMAT -oliadpcmwaveformat_tag=OLIADPCMWAVEFORMAT -olicelpwaveformat_tag=OLICELPWAVEFORMAT -oligsmwaveformat_tag=OLIGSMWAVEFORMAT -olioprwaveformat_tag=OLIOPRWAVEFORMAT -olisbcwaveformat_tag=OLISBCWAVEFORMAT -pcmwaveformat_tag=PCMWAVEFORMAT SECURITY_STATUS=HRESULT SHANDLE_PTR=IntPtr -sierra_adpcmwaveformat_tag=SIERRAADPCMWAVEFORMAT -SIP_ADD_NEWPROVIDER_=SIP_ADD_NEWPROVIDER -SIP_DISPATCH_INFO_=SIP_DISPATCH_INFO -SIP_INDIRECT_DATA_=SIP_INDIRECT_DATA -SIP_SUBJECTINFO_=SIP_SUBJECTINFO SIZE_T=UIntPtr -sonarcwaveformat_tag=SONARCWAVEFORMAT -SPC_LINK_=SPC_LINK -SPC_SIGINFO_=SPC_SIGINFO SSIZE_T=IntPtr tagABORTPATH=ABORTPATH -tagACCEL=ACCEL -tagACCESSTIMEOUT=ACCESSTIMEOUT -tagACTCTXA=ACTCTXA -tagACTCTXW=ACTCTXW -tagACTCTX_SECTION_KEYED_DATA=ACTCTX_SECTION_KEYED_DATA -tagACTCTX_SECTION_KEYED_DATA_2600=ACTCTX_SECTION_KEYED_DATA_2600 -tagACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA=ACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA -tagACTIVATEFLAGS=ACTIVATEFLAGS -tagACTIVATIONTYPE=ACTIVATIONTYPE -tagADVF=ADVF -tagALTTABINFO=ALTTABINFO -tagANIMATIONINFO=ANIMATIONINFO -tagApplicationType=ApplicationType -tagARRAYDESC=ARRAYDESC -tagAR_STATE=AR_STATE -tagAspectInfo=DVASPECTINFO -tagAspectInfoFlag=DVASPECTINFOFLAG -tagAUDIODESCRIPTION=AUDIODESCRIPTION -tagAUXCAPS2A=AUXCAPS2A -tagAUXCAPS2W=AUXCAPS2W -tagAUXCAPSA=AUXCAPSA -tagAUXCAPSW=AUXCAPSW -tagAXESLISTA=AXESLISTA -tagAXESLISTW=AXESLISTW -tagAXISINFOA=AXISINFOA -tagAXISINFOW=AXISINFOW -tagBINDPTR=BINDPTR -tagBINDSPEED=BINDSPEED -tagBINDSTATUS=BINDSTATUS -tagBINDSTRING=BINDSTRING -tagBIND_FLAGS=BIND_FLAGS -tagBIND_OPTS2=BIND_OPTS2 -tagBIND_OPTS3=BIND_OPTS3 -tagBIND_OPTS=BIND_OPTS -tagBITMAP=BITMAP -tagBITMAPCOREHEADER=BITMAPCOREHEADER -tagBITMAPCOREINFO=BITMAPCOREINFO -tagBITMAPFILEHEADER=BITMAPFILEHEADER -tagBITMAPINFO=BITMAPINFO -tagBITMAPINFOHEADER=BITMAPINFOHEADER -tagBLOB=BLOB -tagBSTRBLOB=BSTRBLOB -tagCABOOL=CABOOL -tagCABSTR=CABSTR -tagCABSTRBLOB=CABSTRBLOB -tagCAC=CAC -tagCACLIPDATA=CACLIPDATA -tagCACLSID=CACLSID -tagCACY=CACY -tagCADATE=CADATE -tagCADBL=CADBL -tagCADWORD=CADWORD -tagCAFILETIME=CAFILETIME -tagCAFLT=CAFLT -tagCAH=CAH -tagCAI=CAI -tagCAL=CAL -tagCALLCONV=CALLCONV -tagCALLTYPE=CALLTYPE -tagCALPOLESTR=CALPOLESTR -tagCALPSTR=CALPSTR -tagCALPWSTR=CALPWSTR -tagCAPROPVARIANT=CAPROPVARIANT -tagCASCODE=CASCODE -tagCAUB=CAUB -tagCAUH=CAUH -tagCAUI=CAUI -tagCAUL=CAUL -tagCAUUID=CAUUID -tagCBTACTIVATESTRUCT=CBTACTIVATESTRUCT -tagCBT_CREATEWNDA=CBT_CREATEWNDA -tagCBT_CREATEWNDW=CBT_CREATEWNDW -tagCHANGEFILTERSTRUCT=CHANGEFILTERSTRUCT -tagCHANGEKIND=CHANGEKIND -tagCHARSETINFO=CHARSETINFO -tagCIEXYZ=CIEXYZ -tagCLEANLOCALSTORAGE=CLEANLOCALSTORAGE -tagCLIENTCREATESTRUCT=CLIENTCREATESTRUCT -tagCLIPDATA=CLIPDATA -tagCLSCTX=CLSCTX -tagCOINIT=COINIT -tagCOINITBASE=COINITBASE -tagCOLORADJUSTMENT=COLORADJUSTMENT -tagCOLORCORRECTPALETTE=EMRCOLORCORRECTPALETTE -tagCOLORMATCHTOTARGET=EMRCOLORMATCHTOTARGET -tagCOMBOBOXINFO=COMBOBOXINFO -tagCOMPAREITEMSTRUCT=COMPAREITEMSTRUCT -tagCONNECTDATA=CONNECTDATA -tagCONTROLINFO=CONTROLINFO -tagCOPYDATASTRUCT=COPYDATASTRUCT -tagCOWAIT_FLAGS=COWAIT_FLAGS -tagCREATESTRUCTA=CREATESTRUCTA -tagCREATESTRUCTW=CREATESTRUCTW -tagCSPLATFORM=CSPLATFORM -tagCTRLINFO=CTRLINFO -tagCURSORINFO=CURSORINFO -tagCURSORSHAPE=CURSORSHAPE -tagCUSTDATA=CUSTDATA -tagCUSTDATAITEM=CUSTDATAITEM -tagCWPRETSTRUCT=CWPRETSTRUCT -tagCWPSTRUCT=CWPSTRUCT -tagCY=CY -tagDATADIR=DATADIR -tagDCOM_CALL_STATE=DCOM_CALL_STATE -tagDEBUGHOOKINFO=DEBUGHOOKINFO -tagDEC=DECIMAL -tagDELETEITEMSTRUCT=DELETEITEMSTRUCT -tagDESCKIND=DESCKIND -tagDESIGNVECTOR=DESIGNVECTOR -tagDIBSECTION=DIBSECTION -tagDISCARDCACHE=DISCARDCACHE -tagDISPPARAMS=DISPPARAMS -tagDOMNodeType=DOMNodeType -tagDRAWITEMSTRUCT=DRAWITEMSTRUCT -tagDRAWTEXTPARAMS=DRAWTEXTPARAMS -tagDROPSTRUCT=DROPSTRUCT -tagDVTARGETDEVICE=DVTARGETDEVICE -tagELEMDESC=ELEMDESC -tagEMR=EMR -tagEMRALPHABLEND=EMRALPHABLEND -tagEMRANGLEARC=EMRANGLEARC -tagEMRARC=EMRARC -tagEMRBITBLT=EMRBITBLT -tagEMRCREATEBRUSHINDIRECT=EMRCREATEBRUSHINDIRECT -tagEMRCREATECOLORSPACE=EMRCREATECOLORSPACE -tagEMRCREATECOLORSPACEW=EMRCREATECOLORSPACEW -tagEMRCREATEDIBPATTERNBRUSHPT=EMRCREATEDIBPATTERNBRUSHPT -tagEMRCREATEMONOBRUSH=EMRCREATEMONOBRUSH -tagEMRCREATEPALETTE=EMRCREATEPALETTE -tagEMRCREATEPEN=EMRCREATEPEN -tagEMRELLIPSE=EMRELLIPSE -tagEMREOF=EMREOF -tagEMREXCLUDECLIPRECT=EMREXCLUDECLIPRECT -tagEMREXTCREATEFONTINDIRECTW=EMREXTCREATEFONTINDIRECTW -tagEMREXTCREATEPEN=EMREXTCREATEPEN -tagEMREXTESCAPE=EMREXTESCAPE -tagEMREXTFLOODFILL=EMREXTFLOODFILL -tagEMREXTSELECTCLIPRGN=EMREXTSELECTCLIPRGN -tagEMREXTTEXTOUTA=EMREXTTEXTOUTA -tagEMRFILLPATH=EMRFILLPATH -tagEMRFILLRGN=EMRFILLRGN -tagEMRFORMAT=EMRFORMAT -tagEMRFRAMERGN=EMRFRAMERGN -tagEMRGDICOMMENT=EMRGDICOMMENT -tagEMRGLSBOUNDEDRECORD=EMRGLSBOUNDEDRECORD -tagEMRGLSRECORD=EMRGLSRECORD -tagEMRGRADIENTFILL=EMRGRADIENTFILL -tagEMRINVERTRGN=EMRINVERTRGN -tagEMRLINETO=EMRLINETO -tagEMRMASKBLT=EMRMASKBLT -tagEMRMODIFYWORLDTRANSFORM=EMRMODIFYWORLDTRANSFORM -tagEMRNAMEDESCAPE=EMRNAMEDESCAPE -tagEMROFFSETCLIPRGN=EMROFFSETCLIPRGN -tagEMRPIXELFORMAT=EMRPIXELFORMAT -tagEMRPLGBLT=EMRPLGBLT -tagEMRPOLYDRAW16=EMRPOLYDRAW16 -tagEMRPOLYDRAW=EMRPOLYDRAW -tagEMRPOLYLINE16=EMRPOLYLINE16 -tagEMRPOLYLINE=EMRPOLYLINE -tagEMRPOLYPOLYLINE16=EMRPOLYPOLYLINE16 -tagEMRPOLYPOLYLINE=EMRPOLYPOLYLINE -tagEMRPOLYTEXTOUTA=EMRPOLYTEXTOUTA -tagEMRRESIZEPALETTE=EMRRESIZEPALETTE -tagEMRRESTOREDC=EMRRESTOREDC -tagEMRROUNDRECT=EMRROUNDRECT -tagEMRSCALEVIEWPORTEXTEX=EMRSCALEVIEWPORTEXTEX -tagEMRSELECTCLIPPATH=EMRSELECTCLIPPATH -tagEMRSELECTOBJECT=EMRSELECTOBJECT -tagEMRSELECTPALETTE=EMRSELECTPALETTE -tagEMRSETARCDIRECTION=EMRSETARCDIRECTION -tagEMRSETCOLORADJUSTMENT=EMRSETCOLORADJUSTMENT -tagEMRSETCOLORSPACE=EMRSETCOLORSPACE -tagEMRSETDIBITSTODEVICE=EMRSETDIBITSTODEVICE -tagEMRSETICMPROFILE=EMRSETICMPROFILE -tagEMRSETMAPPERFLAGS=EMRSETMAPPERFLAGS -tagEMRSETMITERLIMIT=EMRSETMITERLIMIT -tagEMRSETPALETTEENTRIES=EMRSETPALETTEENTRIES -tagEMRSETPIXELV=EMRSETPIXELV -tagEMRSETTEXTCOLOR=EMRSETTEXTCOLOR -tagEMRSETVIEWPORTEXTEX=EMRSETVIEWPORTEXTEX -tagEMRSETVIEWPORTORGEX=EMRSETVIEWPORTORGEX -tagEMRSETWORLDTRANSFORM=EMRSETWORLDTRANSFORM -tagEMRSTRETCHBLT=EMRSTRETCHBLT -tagEMRSTRETCHDIBITS=EMRSTRETCHDIBITS -tagEMRTEXT=EMRTEXT -tagEMRTRANSPARENTBLT=EMRTRANSPARENTBLT -tagENHMETAHEADER=ENHMETAHEADER -tagENHMETARECORD=ENHMETARECORD -tagENUMLOGFONTA=ENUMLOGFONTA -tagENUMLOGFONTEXA=ENUMLOGFONTEXA -tagENUMLOGFONTEXDVA=ENUMLOGFONTEXDVA -tagENUMLOGFONTEXDVW=ENUMLOGFONTEXDVW -tagENUMLOGFONTEXW=ENUMLOGFONTEXW -tagENUMLOGFONTW=ENUMLOGFONTW -tagENUMTEXTMETRICA=ENUMTEXTMETRICA -tagENUMTEXTMETRICW=ENUMTEXTMETRICW -tagENUMUILANG=ENUMUILANG -tagEOLE_AUTHENTICATION_CAPABILITIES=EOLE_AUTHENTICATION_CAPABILITIES -tagEVENTMSG=EVENTMSG -tagEXBMINFOHEADER=EXBMINFOHEADER -tagEXCEPINFO=EXCEPINFO -tagEXTCONN=EXTCONN -tagExtentInfo=DVEXTENTINFO -tagExtentMode=DVEXTENTMODE -tagEXTLOGFONTA=EXTLOGFONTA -tagEXTLOGFONTW=EXTLOGFONTW -tagEXTLOGPEN32=EXTLOGPEN32 -tagEXTLOGPEN=EXTLOGPEN -tagFEEDBACK_TYPE=FEEDBACK_TYPE -tagFILTERKEYS=FILTERKEYS -tagFONTSIGNATURE=FONTSIGNATURE -tagFORMATETC=FORMATETC -tagFUNCDESC=FUNCDESC -tagFUNCFLAGS=FUNCFLAGS -tagFUNCKIND=FUNCKIND -tagGCP_RESULTSA=GCP_RESULTSA -tagGCP_RESULTSW=GCP_RESULTSW -tagGESTURECONFIG=GESTURECONFIG -tagGESTUREINFO=GESTUREINFO -tagGESTURENOTIFYSTRUCT=GESTURENOTIFYSTRUCT -tagGLOBALOPT_EH_VALUES=GLOBALOPT_EH_VALUES -tagGLOBALOPT_PROPERTIES=GLOBALOPT_PROPERTIES -tagGLOBALOPT_RO_FLAGS=GLOBALOPT_RO_FLAGS -tagGLOBALOPT_RPCTP_VALUES=GLOBALOPT_RPCTP_VALUES -tagGLOBALOPT_UNMARSHALING_POLICY_VALUES=GLOBALOPT_UNMARSHALING_POLICY_VALUES -tagGLYPHSET=GLYPHSET -tagGUIDKIND=GUIDKIND -tagGUITHREADINFO=GUITHREADINFO -tagHANDEDNESS=HANDEDNESS -tagHANDLETABLE=HANDLETABLE -tagHARDWAREHOOKSTRUCT=HARDWAREHOOKSTRUCT -tagHARDWAREINPUT=HARDWAREINPUT -tagHELPINFO=HELPINFO -tagHELPWININFOA=HELPWININFOA -tagHELPWININFOW=HELPWININFOW -tagHIGHCONTRASTA=HIGHCONTRASTA -tagHIGHCONTRASTW=HIGHCONTRASTW -tagHITRESULT=HITRESULT -tagHW_PROFILE_INFOA=HW_PROFILE_INFOA -tagHW_PROFILE_INFOW=HW_PROFILE_INFOW -tagICEXYZTRIPLE=CIEXYZTRIPLE -tagICONMETRICSA=ICONMETRICSA -tagICONMETRICSW=ICONMETRICSW -tagIDLDESC=IDLDESC -tagINPUT=INPUT -tagINPUT_INJECTION_VALUE=INPUT_INJECTION_VALUE -tagINPUT_MESSAGE_DEVICE_TYPE=INPUT_MESSAGE_DEVICE_TYPE -tagINPUT_MESSAGE_ORIGIN_ID=INPUT_MESSAGE_ORIGIN_ID -tagINPUT_MESSAGE_SOURCE=INPUT_MESSAGE_SOURCE -tagINPUT_TRANSFORM=INPUT_TRANSFORM -tagINTERFACEINFO=INTERFACEINFO -tagINVOKEKIND=INVOKEKIND -tagJPEGINFOHEADER=JPEGINFOHEADER -tagKBDLLHOOKSTRUCT=KBDLLHOOKSTRUCT -tagKERNINGPAIR=KERNINGPAIR -tagKEYBDINPUT=KEYBDINPUT -tagLASTINPUTINFO=LASTINPUTINFO -tagLAYERPLANEDESCRIPTOR=LAYERPLANEDESCRIPTOR -tagLIBFLAGS=LIBFLAGS -tagLICINFO=LICINFO -tagLOCALESIGNATURE=LOCALESIGNATURE -tagLOCKTYPE=LOCKTYPE -tagLOGBRUSH32=LOGBRUSH32 -tagLOGBRUSH=LOGBRUSH -tagLOGCOLORSPACEA=LOGCOLORSPACEA -tagLOGCOLORSPACEW=LOGCOLORSPACEW -tagLOGFONTA=LOGFONTA -tagLOGFONTW=LOGFONTW -tagLOGPALETTE=LOGPALETTE -tagLOGPEN=LOGPEN -tagMDICREATESTRUCTA=MDICREATESTRUCTA -tagMDICREATESTRUCTW=MDICREATESTRUCTW -tagMDINEXTMENU=MDINEXTMENU -tagMEASUREITEMSTRUCT=MEASUREITEMSTRUCT -tagMEMCTX=MEMCTX -tagMENUBARINFO=MENUBARINFO -tagMENUGETOBJECTINFO=MENUGETOBJECTINFO -tagMENUINFO=MENUINFO -tagMENUITEMINFOA=MENUITEMINFOA -tagMENUITEMINFOW=MENUITEMINFOW -tagMETAFILEPICT=METAFILEPICT -tagMETAHEADER=METAHEADER -tagMETARECORD=METARECORD -tagMIDIINCAPS2A=MIDIINCAPS2A -tagMIDIINCAPS2W=MIDIINCAPS2W -tagMIDIINCAPSA=MIDIINCAPSA -tagMIDIINCAPSW=MIDIINCAPSW -tagMIDIOUTCAPS2A=MIDIOUTCAPS2A -tagMIDIOUTCAPS2W=MIDIOUTCAPS2W -tagMIDIOUTCAPSA=MIDIOUTCAPSA -tagMIDIOUTCAPSW=MIDIOUTCAPSW -tagMINIMIZEDMETRICS=MINIMIZEDMETRICS -tagMINMAXINFO=MINMAXINFO -tagMIXERCAPS2A=MIXERCAPS2A -tagMIXERCAPS2W=MIXERCAPS2W -tagMIXERCAPSA=MIXERCAPSA -tagMIXERCAPSW=MIXERCAPSW -tagMIXERCONTROLA=MIXERCONTROLA -tagMIXERCONTROLDETAILS_LISTTEXTA=MIXERCONTROLDETAILS_LISTTEXTA -tagMIXERCONTROLDETAILS_LISTTEXTW=MIXERCONTROLDETAILS_LISTTEXTW -tagMIXERCONTROLW=MIXERCONTROLW -tagMIXERLINEA=MIXERLINEA -tagMIXERLINECONTROLSA=MIXERLINECONTROLSA -tagMIXERLINECONTROLSW=MIXERLINECONTROLSW -tagMIXERLINEW=MIXERLINEW -tagMKREDUCE=MKRREDUCE -tagMKSYS=MKSYS -tagMONITORINFO=MONITORINFO -tagMONITORINFOEXA=MONITORINFOEXA -tagMONITORINFOEXW=MONITORINFOEXW -tagMOUSEHOOKSTRUCT=MOUSEHOOKSTRUCT -tagMOUSEHOOKSTRUCTEX=MOUSEHOOKSTRUCTEX -tagMOUSEINPUT=MOUSEINPUT -tagMOUSEKEYS=MOUSEKEYS -tagMOUSEMOVEPOINT=MOUSEMOVEPOINT -tagMSG=MSG -tagMSGBOXPARAMSA=MSGBOXPARAMSA -tagMSGBOXPARAMSW=MSGBOXPARAMSW -tagMSHCTX=MSHCTX -tagMSHLFLAGS=MSHLFLAGS -tagMSLLHOOKSTRUCT=MSLLHOOKSTRUCT -tagMULTIKEYHELPA=MULTIKEYHELPA -tagMULTIKEYHELPW=MULTIKEYHELPW -tagMULTI_QI=MULTI_QI -tagNCCALCSIZE_PARAMS=NCCALCSIZE_PARAMS -tagNEWTEXTMETRICA=NEWTEXTMETRICA -tagNEWTEXTMETRICEXA=NEWTEXTMETRICEXA -tagNEWTEXTMETRICEXW=NEWTEXTMETRICEXW -tagNEWTEXTMETRICW=NEWTEXTMETRICW -tagNMHDR=NMHDR -tagNONCLIENTMETRICSA=NONCLIENTMETRICSA -tagNONCLIENTMETRICSW=NONCLIENTMETRICSW -tagOBJECTDESCRIPTOR=OBJECTDESCRIPTOR tagOIFI*=OLEINPLACEFRAMEINFO* -tagOIFI=OLEINPLACEFRAMEINFO -tagOLECLOSE=OLECLOSE -tagOLECONTF=OLECONTF -tagOLEDCFLAGS=OLEDCFLAGS -tagOLEGETMONIKER=OLEGETMONIKER -tagOLELINKBIND=OLELINKBIND -tagOleMenuGroupWidths=OLEMENUGROUPWIDTHS -tagOLEMISC=OLEMISC -tagOLERENDER=OLERENDER -tagOLEUPDATE=OLEUPDATE -tagOLEVERB=OLEVERB -tagOLEVERBATTRIB=OLEVERBATTRIB -tagOLEWHICHMK=OLEWHICHMK -tagPAINTSTRUCT=PAINTSTRUCT -tagPALETTEENTRY=PALETTEENTRY -tagPANOSE=PANOSE -tagPARAMDESC=PARAMDESC -tagPARAMDESCEX=PARAMDESCEX -tagPELARRAY=PELARRAY -tagPENDINGMSG=PENDINGMSG -tagPENDINGTYPE=PENDINGTYPE -tagPictureAttributes=PICTUREATTRIBUTES -tagPIXELFORMATDESCRIPTOR=PIXELFORMATDESCRIPTOR -tagPOINT=POINT -tagPOINTERINACTIVE=POINTERINACTIVE -tagPOINTER_BUTTON_CHANGE_TYPE=POINTER_BUTTON_CHANGE_TYPE -tagPOINTER_DEVICE_CURSOR_INFO=POINTER_DEVICE_CURSOR_INFO -tagPOINTER_DEVICE_CURSOR_TYPE=POINTER_DEVICE_CURSOR_TYPE -tagPOINTER_DEVICE_INFO=POINTER_DEVICE_INFO -tagPOINTER_DEVICE_PROPERTY=POINTER_DEVICE_PROPERTY -tagPOINTER_DEVICE_TYPE=POINTER_DEVICE_TYPE -tagPOINTER_INFO=POINTER_INFO tagPOINTER_INPUT_TYPE=POINTER_INPUT_TYPE -tagPOINTER_PEN_INFO=POINTER_PEN_INFO -tagPOINTER_TOUCH_INFO=POINTER_TOUCH_INFO -tagPOINTER_TYPE_INFO=POINTER_TYPE_INFO -tagPOINTF=POINTF -tagPOINTFX=POINTFX -tagPOINTS=POINTS -tagPOLYTEXTA=POLYTEXTA -tagPOLYTEXTW=POLYTEXTW -tagPROPBAG2=PROPBAG2 -tagPROPBAG2_TYPE=PROPBAG2_TYPE -tagPROPPAGEINFO=PROPPAGEINFO -tagPROPPAGESTATUS=PROPPAGESTATUS -tagPROPSPEC=PROPSPEC tagPROPSPEC*=PROPSPEC* -tagPROPVARIANT=PROPVARIANT tagPROPVARIANT*=PROPVARIANT* tagProxyFileInfo=ProxyFileInfo -tagQACONTAINER=QACONTAINER -tagQACONTAINERFLAGS=QACONTAINERFLAGS -tagQACONTROL=QACONTROL -tagQUERYCONTEXT=QUERYCONTEXT -tagRAWHID=RAWHID -tagRAWINPUT=RAWINPUT -tagRAWINPUTDEVICE=RAWINPUTDEVICE -tagRAWINPUTDEVICELIST=RAWINPUTDEVICELIST -tagRAWINPUTHEADER=RAWINPUTHEADER -tagRAWKEYBOARD=RAWKEYBOARD -tagRAWMOUSE=RAWMOUSE -tagREADYSTATE=READYSTATE -tagRECT=RECT -tagREGCLS=REGCLS -tagRemBRUSH=RemHBRUSH -tagRemFORMATETC=RemFORMATETC -tagRemHBITMAP=RemHBITMAP -tagRemHENHMETAFILE=RemHENHMETAFILE -tagRemHGLOBAL=RemHGLOBAL -tagRemHMETAFILEPICT=RemHMETAFILEPICT -tagRemHPALETTE=RemHPALETTE -tagRemSNB=RemSNB -tagRemSTGMEDIUM=RemSTGMEDIUM -tagRGBQUAD=RGBQUAD -tagRGBTRIPLE=RGBTRIPLE -tagRID_DEVICE_INFO=RID_DEVICE_INFO -tagRID_DEVICE_INFO_HID=RID_DEVICE_INFO_HID -tagRID_DEVICE_INFO_KEYBOARD=RID_DEVICE_INFO_KEYBOARD -tagRID_DEVICE_INFO_MOUSE=RID_DEVICE_INFO_MOUSE -tagRPCOLEMESSAGE=RPCOLEMESSAGE -tagRPCOPT_PROPERTIES=RPCOPT_PROPERTIES -tagRPCOPT_SERVER_LOCALITY_VALUES=RPCOPT_SERVER_LOCALITY_VALUES -tagSAFEARRAY=SAFEARRAY -tagSAFEARRAYBOUND=SAFEARRAYBOUND -tagSCROLLBARINFO=SCROLLBARINFO -tagSCROLLINFO=SCROLLINFO -tagSERIALKEYSA=SERIALKEYSA -tagSERIALKEYSW=SERIALKEYSW -tagSERVERCALL=SERVERCALL -tagServerInformation=ServerInformation -tagSF_TYPE=SF_TYPE -tagShutdownType=ShutdownType -tagSIZE=SIZE -tagSOLE_AUTHENTICATION_INFO=SOLE_AUTHENTICATION_INFO -tagSOLE_AUTHENTICATION_LIST=SOLE_AUTHENTICATION_LIST -tagSOLE_AUTHENTICATION_SERVICE=SOLE_AUTHENTICATION_SERVICE -tagSOUNDSENTRYA=SOUNDSENTRYA -tagSOUNDSENTRYW=SOUNDSENTRYW -tagSTATDATA=STATDATA -tagSTATFLAG=STATFLAG -tagSTATPROPSETSTG=STATPROPSETSTG -tagSTATPROPSTG=STATPROPSTG -tagSTATSTG=STATSTG -tagSTDMSHLFLAGS=STDMSHLFLAGS -tagSTGC=STGC tagSTGMEDIUM=STGMEDIUM -tagSTGMOVE=STGMOVE -tagSTGTY=STGTY -tagSTICKYKEYS=STICKYKEYS -tagStorageLayout=StorageLayout -tagSTREAM_SEEK=STREAM_SEEK -tagSTYLESTRUCT=STYLESTRUCT -tagSYSKIND=SYSKIND -tagTEXTMETRICA=TEXTMETRICA -tagTEXTMETRICW=TEXTMETRICW -tagTITLEBARINFO=TITLEBARINFO -tagTITLEBARINFOEX=TITLEBARINFOEX -tagTLIBATTR=TLIBATTR -tagTOGGLEKEYS=TOGGLEKEYS -tagTOUCHINPUT=TOUCHINPUT -tagTouchPredictionParameters=TOUCHPREDICTIONPARAMETERS -tagTOUCH_HIT_TESTING_INPUT=TOUCH_HIT_TESTING_INPUT -tagTOUCH_HIT_TESTING_PROXIMITY_EVALUATION=TOUCH_HIT_TESTING_PROXIMITY_EVALUATION -tagTPMPARAMS=TPMPARAMS -tagTRACKMOUSEEVENT=TRACKMOUSEEVENT -tagTTPOLYCURVE=TTPOLYCURVE -tagTTPOLYGONHEADER=TTPOLYGONHEADER -tagTYMED=TYMED -tagTYPEATTR=TYPEATTR -tagTYPEDESC=TYPEDESC -tagTYPEFLAGS=TYPEFLAGS -tagTYPEKIND=TYPEKIND -tagTYSPEC=TYSPEC -tagUASFLAGS=UASFLAGS -tagUPDATELAYEREDWINDOWINFO=UPDATELAYEREDWINDOWINFO -tagURLTEMPLATE=URLTEMPLATE -tagURLZONE=URLZONE -tagUSAGE_PROPERTIES=USAGE_PROPERTIES -tagUSERCLASSTYPE=USERCLASSTYPE -tagUSEROBJECTFLAGS=USEROBJECTFLAGS -tagVARDESC=VARDESC -tagVARFLAGS=VARFLAGS -tagVARIANT=VARIANT -tagVARKIND=VARKIND -tagVersionedStream=VERSIONEDSTREAM -tagVIEWSTATUS=VIEWSTATUS -tagWAVEINCAPS2A=WAVEINCAPS2A -tagWAVEINCAPS2W=WAVEINCAPS2W -tagWAVEINCAPSA=WAVEINCAPSA -tagWAVEINCAPSW=WAVEINCAPSW -tagWAVEOUTCAPS2A=WAVEOUTCAPS2A -tagWAVEOUTCAPS2W=WAVEOUTCAPS2W -tagWAVEOUTCAPSA=WAVEOUTCAPSA -tagWAVEOUTCAPSW=WAVEOUTCAPSW -tagWCRANGE=WCRANGE -tagWINDOWINFO=WINDOWINFO -tagWINDOWPLACEMENT=WINDOWPLACEMENT -tagWINDOWPOS=WINDOWPOS -tagWNDCLASSA=WNDCLASSA -tagWNDCLASSEXA=WNDCLASSEXA -tagWNDCLASSEXW=WNDCLASSEXW -tagWNDCLASSW=WNDCLASSW -tagWTSSESSION_NOTIFICATION=WTSSESSION_NOTIFICATION -tagXFORM=XFORM -tagXFORMCOORDS=XFORMCOORDS -tagXMLEMEM_TYPE=XMLELEM_TYPE tag_s_RIFFWAVE_inst=s_RIFFWAVE_inst -tMIXERCONTROLDETAILS=MIXERCONTROLDETAILS -tMIXERCONTROLDETAILS_BOOLEAN=MIXERCONTROLDETAILS_BOOLEAN -tMIXERCONTROLDETAILS_SIGNED=MIXERCONTROLDETAILS_SIGNED -tMIXERCONTROLDETAILS_UNSIGNED=MIXERCONTROLDETAILS_UNSIGNED -truespeechwaveformat_tag=TRUESPEECHWAVEFORMAT -tWAVEFORMATEX=WAVEFORMATEX UHALF_PTR=UHALF_PTR UINT_PTR=UIntPtr ULONG_PTR=UIntPtr -wavefilter_echo_tag=ECHOWAVEFILTER -wavefilter_tag=WAVEFILTER -wavefilter_volume_tag=VOLUMEWAVEFILTER -waveformat_tag=WAVEFORMAT -wavehdr_tag=WAVEHDR -WINTRUST_BLOB_INFO_=WINTRUST_BLOB_INFO -WINTRUST_CATALOG_INFO_=WINTRUST_CATALOG_INFO -WINTRUST_CERT_INFO_=WINTRUST_CERT_INFO -WINTRUST_FILE_INFO_=WINTRUST_FILE_INFO -WINTRUST_SGNR_INFO_=WINTRUST_SGNR_INFO -WINTRUST_SIGNATURE_SETTINGS_=WINTRUST_SIGNATURE_SETTINGS -wmaudio2waveformat_tag=WMAUDIO2WAVEFORMAT -wmaudio3waveformat_tag=WMAUDIO3WAVEFORMAT WPARAM=UIntPtr X3DAUDIO_VECTOR=Vector3 -yamaha_adpmcwaveformat_tag=YAMAHA_ADPCMWAVEFORMAT -_ABC=ABC -_ABCFLOAT=ABCFLOAT -_ACCESS_ALLOWED_ACE=ACCESS_ALLOWED_ACE -_ACCESS_ALLOWED_CALLBACK_ACE=ACCESS_ALLOWED_CALLBACK_ACE -_ACCESS_ALLOWED_CALLBACK_OBJECT_ACE=ACCESS_ALLOWED_CALLBACK_OBJECT_ACE -_ACCESS_ALLOWED_OBJECT_ACE=ACCESS_ALLOWED_OBJECT_ACE -_ACCESS_DENIED_ACE=ACCESS_DENIED_ACE -_ACCESS_DENIED_CALLBACK_ACE=ACCESS_DENIED_CALLBACK_ACE -_ACCESS_DENIED_CALLBACK_OBJECT_ACE=ACCESS_DENIED_CALLBACK_OBJECT_ACE -_ACCESS_DENIED_OBJECT_ACE=ACCESS_DENIED_OBJECT_ACE -_ACCESS_REASONS=ACCESS_REASONS -_ACCESS_REASON_TYPE=ACCESS_REASON_TYPE -_ACE_HEADER=ACE_HEADER -_ACL=ACL -_ACL_INFORMATION_CLASS=ACL_INFORMATION_CLASS -_ACL_REVISION_INFORMATION=ACL_REVISION_INFORMATION -_ACL_SIZE_INFORMATION=ACL_SIZE_INFORMATION _ACTIVATION_CONTEXT*=IntPtr -_ACTIVATION_CONTEXT_ASSEMBLY_DETAILED_INFORMATION=ACTIVATION_CONTEXT_ASSEMBLY_DETAILED_INFORMATION -_ACTIVATION_CONTEXT_BASIC_INFORMATION=ACTIVATION_CONTEXT_BASIC_INFORMATION -_ACTIVATION_CONTEXT_COMPATIBILITY_INFORMATION=ACTIVATION_CONTEXT_COMPATIBILITY_INFORMATION -_ACTIVATION_CONTEXT_DETAILED_INFORMATION=ACTIVATION_CONTEXT_DETAILED_INFORMATION -_ACTIVATION_CONTEXT_INFO_CLASS=ACTIVATION_CONTEXT_INFO_CLASS -_ACTIVATION_CONTEXT_QUERY_INDEX=ACTIVATION_CONTEXT_QUERY_INDEX -_ACTIVATION_CONTEXT_RUN_LEVEL_INFORMATION=ACTIVATION_CONTEXT_RUN_LEVEL_INFORMATION -_ADMINISTRATOR_POWER_POLICY=ADMINISTRATOR_POWER_POLICY -_APPLICATIONLAUNCH_SETTING_VALUE=APPLICATIONLAUNCH_SETTING_VALUE -_APP_MEMORY_INFORMATION=APP_MEMORY_INFORMATION -_APTTYPE=APTTYPE -_APTTYPEQUALIFIER=APTTYPEQUALIFIER -_ASSEMBLY_FILE_DETAILED_INFORMATION=ASSEMBLY_FILE_DETAILED_INFORMATION -_AUDCLNT_SHAREMODE=AUDCLNT_SHAREMODE -_AudioSessionState=AudioSessionState -_AUDIO_STREAM_CATEGORY=AUDIO_STREAM_CATEGORY -_AUDIT_EVENT_TYPE=AUDIT_EVENT_TYPE -_AUTHENTICODE_EXTRA_CERT_CHAIN_POLICY_PARA=AUTHENTICODE_EXTRA_CERT_CHAIN_POLICY_PARA -_AUTHENTICODE_EXTRA_CERT_CHAIN_POLICY_STATUS=AUTHENTICODE_EXTRA_CERT_CHAIN_POLICY_STATUS -_AUTHENTICODE_TS_EXTRA_CERT_CHAIN_POLICY_PARA=AUTHENTICODE_TS_EXTRA_CERT_CHAIN_POLICY_PARA -_BLENDFUNCTION=BLENDFUNCTION -_BYTE_BLOB=BYTE_BLOB -_BYTE_SIZEDARR=BYTE_SIZEDARR -_BY_HANDLE_FILE_INFORMATION=BY_HANDLE_FILE_INFORMATION -_CABINET_INFO_A=CABINET_INFO_A -_CABINET_INFO_W=CABINET_INFO_W -_CACHE_DESCRIPTOR=CACHE_DESCRIPTOR -_CACHE_RELATIONSHIP=CACHE_RELATIONSHIP -_CAT_MEMBERINFO2=CAT_MEMBERINFO2 -_CAT_MEMBERINFO=CAT_MEMBERINFO -_CAT_NAMEVALUE=CAT_NAMEVALUE -_CERT_ACCESS_DESCRIPTION=CERT_ACCESS_DESCRIPTION -_CERT_ALT_NAME_ENTRY=CERT_ALT_NAME_ENTRY -_CERT_ALT_NAME_INFO=CERT_ALT_NAME_INFO -_CERT_AUTHORITY_INFO_ACCESS=CERT_AUTHORITY_INFO_ACCESS -_CERT_AUTHORITY_KEY_ID2_INFO=CERT_AUTHORITY_KEY_ID2_INFO -_CERT_AUTHORITY_KEY_ID_INFO=CERT_AUTHORITY_KEY_ID_INFO -_CERT_BASIC_CONSTRAINTS2_INFO=CERT_BASIC_CONSTRAINTS2_INFO -_CERT_BASIC_CONSTRAINTS_INFO=CERT_BASIC_CONSTRAINTS_INFO -_CERT_BIOMETRIC_DATA=CERT_BIOMETRIC_DATA -_CERT_BIOMETRIC_EXT_INFO=CERT_BIOMETRIC_EXT_INFO -_CERT_CHAIN=CERT_CHAIN -_CERT_CHAIN_CONTEXT=CERT_CHAIN_CONTEXT -_CERT_CHAIN_ELEMENT=CERT_CHAIN_ELEMENT -_CERT_CHAIN_ENGINE_CONFIG=CERT_CHAIN_ENGINE_CONFIG -_CERT_CHAIN_FIND_BY_ISSUER_PARA=CERT_CHAIN_FIND_BY_ISSUER_PARA -_CERT_CHAIN_PARA=CERT_CHAIN_PARA -_CERT_CHAIN_POLICY_PARA=CERT_CHAIN_POLICY_PARA -_CERT_CHAIN_POLICY_STATUS=CERT_CHAIN_POLICY_STATUS -_CERT_CONTEXT=CERT_CONTEXT -_CERT_CREATE_CONTEXT_PARA=CERT_CREATE_CONTEXT_PARA -_CERT_CRL_CONTEXT_PAIR=CERT_CRL_CONTEXT_PAIR -_CERT_DH_PARAMETERS=CERT_DH_PARAMETERS -_CERT_DSS_PARAMETERS=CERT_DSS_PARAMETERS -_CERT_ECC_SIGNATURE=CERT_ECC_SIGNATURE -_CERT_EXTENSION=CERT_EXTENSION -_CERT_EXTENSIONS=CERT_EXTENSIONS -_CERT_FORTEZZA_DATA_PROP=CERT_FORTEZZA_DATA_PROP -_CERT_GENERAL_SUBTREE=CERT_GENERAL_SUBTREE -_CERT_HASHED_URL=CERT_HASHED_URL -_CERT_ID=CERT_ID -_CERT_INFO=CERT_INFO -_CERT_ISSUER_SERIAL_NUMBER=CERT_ISSUER_SERIAL_NUMBER -_CERT_KEYGEN_REQUEST_INFO=CERT_KEYGEN_REQUEST_INFO -_CERT_KEY_ATTRIBUTES_INFO=CERT_KEY_ATTRIBUTES_INFO -_CERT_KEY_CONTEXT=CERT_KEY_CONTEXT -_CERT_KEY_USAGE_RESTRICTION_INFO=CERT_KEY_USAGE_RESTRICTION_INFO -_CERT_LDAP_STORE_OPENED_PARA=CERT_LDAP_STORE_OPENED_PARA -_CERT_LOGOTYPE_AUDIO=CERT_LOGOTYPE_AUDIO -_CERT_LOGOTYPE_AUDIO_INFO=CERT_LOGOTYPE_AUDIO_INFO -_CERT_LOGOTYPE_DATA=CERT_LOGOTYPE_DATA -_CERT_LOGOTYPE_DETAILS=CERT_LOGOTYPE_DETAILS -_CERT_LOGOTYPE_EXT_INFO=CERT_LOGOTYPE_EXT_INFO -_CERT_LOGOTYPE_IMAGE=CERT_LOGOTYPE_IMAGE -_CERT_LOGOTYPE_IMAGE_INFO=CERT_LOGOTYPE_IMAGE_INFO -_CERT_LOGOTYPE_INFO=CERT_LOGOTYPE_INFO -_CERT_LOGOTYPE_REFERENCE=CERT_LOGOTYPE_REFERENCE -_CERT_NAME_CONSTRAINTS_INFO=CERT_NAME_CONSTRAINTS_INFO -_CERT_NAME_INFO=CERT_NAME_INFO -_CERT_NAME_VALUE=CERT_NAME_VALUE -_CERT_OR_CRL_BLOB=CERT_OR_CRL_BLOB -_CERT_OR_CRL_BUNDLE=CERT_OR_CRL_BUNDLE -_CERT_OTHER_LOGOTYPE_INFO=CERT_OTHER_LOGOTYPE_INFO -_CERT_OTHER_NAME=CERT_OTHER_NAME -_CERT_PAIR=CERT_PAIR -_CERT_PHYSICAL_STORE_INFO=CERT_PHYSICAL_STORE_INFO -_CERT_POLICIES_INFO=CERT_POLICIES_INFO -_CERT_POLICY95_QUALIFIER1=CERT_POLICY95_QUALIFIER1 -_CERT_POLICY_CONSTRAINTS_INFO=CERT_POLICY_CONSTRAINTS_INFO -_CERT_POLICY_ID=CERT_POLICY_ID -_CERT_POLICY_INFO=CERT_POLICY_INFO -_CERT_POLICY_MAPPING=CERT_POLICY_MAPPING -_CERT_POLICY_MAPPINGS_INFO=CERT_POLICY_MAPPINGS_INFO -_CERT_POLICY_QUALIFIER_INFO=CERT_POLICY_QUALIFIER_INFO -_CERT_POLICY_QUALIFIER_NOTICE_REFERENCE=CERT_POLICY_QUALIFIER_NOTICE_REFERENCE -_CERT_POLICY_QUALIFIER_USER_NOTICE=CERT_POLICY_QUALIFIER_USER_NOTICE -_CERT_PRIVATE_KEY_VALIDITY=CERT_PRIVATE_KEY_VALIDITY -_CERT_PUBLIC_KEY_INFO=CERT_PUBLIC_KEY_INFO -_CERT_QC_STATEMENT=CERT_QC_STATEMENT -_CERT_QC_STATEMENTS_EXT_INFO=CERT_QC_STATEMENTS_EXT_INFO -_CERT_RDN=CERT_RDN -_CERT_RDN_ATTR=CERT_RDN_ATTR -_CERT_REGISTRY_STORE_CLIENT_GPT_PARA=CERT_REGISTRY_STORE_CLIENT_GPT_PARA -_CERT_REGISTRY_STORE_ROAMING_PARA=CERT_REGISTRY_STORE_ROAMING_PARA -_CERT_REQUEST_INFO=CERT_REQUEST_INFO -_CERT_REVOCATION_CHAIN_PARA=CERT_REVOCATION_CHAIN_PARA -_CERT_REVOCATION_CRL_INFO=CERT_REVOCATION_CRL_INFO -_CERT_REVOCATION_INFO=CERT_REVOCATION_INFO -_CERT_REVOCATION_PARA=CERT_REVOCATION_PARA -_CERT_REVOCATION_STATUS=CERT_REVOCATION_STATUS -_CERT_SELECT_CHAIN_PARA=CERT_SELECT_CHAIN_PARA -_CERT_SELECT_CRITERIA=CERT_SELECT_CRITERIA -_CERT_SERVER_OCSP_RESPONSE_CONTEXT=CERT_SERVER_OCSP_RESPONSE_CONTEXT -_CERT_SERVER_OCSP_RESPONSE_OPEN_PARA=CERT_SERVER_OCSP_RESPONSE_OPEN_PARA -_CERT_SIGNED_CONTENT_INFO=CERT_SIGNED_CONTENT_INFO -_CERT_SIMPLE_CHAIN=CERT_SIMPLE_CHAIN -_CERT_STORE_PROV_FIND_INFO=CERT_STORE_PROV_FIND_INFO -_CERT_STORE_PROV_INFO=CERT_STORE_PROV_INFO -_CERT_STRONG_SIGN_PARA=CERT_STRONG_SIGN_PARA -_CERT_STRONG_SIGN_SERIALIZED_INFO=CERT_STRONG_SIGN_SERIALIZED_INFO -_CERT_SUPPORTED_ALGORITHM_INFO=CERT_SUPPORTED_ALGORITHM_INFO -_CERT_SYSTEM_STORE_INFO=CERT_SYSTEM_STORE_INFO -_CERT_SYSTEM_STORE_RELOCATE_PARA=CERT_SYSTEM_STORE_RELOCATE_PARA -_CERT_TEMPLATE_EXT=CERT_TEMPLATE_EXT -_CERT_TPM_SPECIFICATION_INFO=CERT_TPM_SPECIFICATION_INFO -_CERT_TRUST_LIST_INFO=CERT_TRUST_LIST_INFO -_CERT_TRUST_STATUS=CERT_TRUST_STATUS -_CERT_USAGE_MATCH=CERT_USAGE_MATCH -_CERT_X942_DH_PARAMETERS=CERT_X942_DH_PARAMETERS -_CERT_X942_DH_VALIDATION_PARAMS=CERT_X942_DH_VALIDATION_PARAMS -_CFG_CALL_TARGET_INFO=CFG_CALL_TARGET_INFO -_CLAIM_SECURITY_ATTRIBUTES_INFORMATION=CLAIM_SECURITY_ATTRIBUTES_INFORMATION -_CLAIM_SECURITY_ATTRIBUTE_FQBN_VALUE=CLAIM_SECURITY_ATTRIBUTE_FQBN_VALUE -_CLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE=CLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE -_CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1=CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1 -_CLAIM_SECURITY_ATTRIBUTE_V1=CLAIM_SECURITY_ATTRIBUTE_V1 -_CMC_ADD_ATTRIBUTES_INFO=CMC_ADD_ATTRIBUTES_INFO -_CMC_ADD_EXTENSIONS_INFO=CMC_ADD_EXTENSIONS_INFO -_CMC_DATA_INFO=CMC_DATA_INFO -_CMC_PEND_INFO=CMC_PEND_INFO -_CMC_RESPONSE_INFO=CMC_RESPONSE_INFO -_CMC_STATUS_INFO=CMC_STATUS_INFO -_CMC_TAGGED_ATTRIBUTE=CMC_TAGGED_ATTRIBUTE -_CMC_TAGGED_CERT_REQUEST=CMC_TAGGED_CERT_REQUEST -_CMC_TAGGED_CONTENT_INFO=CMC_TAGGED_CONTENT_INFO -_CMC_TAGGED_OTHER_MSG=CMC_TAGGED_OTHER_MSG -_CMC_TAGGED_REQUEST=CMC_TAGGED_REQUEST -_CMSG_CMS_RECIPIENT_INFO=CMSG_CMS_RECIPIENT_INFO -_CMSG_CMS_SIGNER_INFO=CMSG_CMS_SIGNER_INFO -_CMSG_CNG_CONTENT_DECRYPT_INFO=CMSG_CNG_CONTENT_DECRYPT_INFO -_CMSG_CONTENT_ENCRYPT_INFO=CMSG_CONTENT_ENCRYPT_INFO -_CMSG_CTRL_ADD_SIGNER_UNAUTH_ATTR_PARA=CMSG_CTRL_ADD_SIGNER_UNAUTH_ATTR_PARA -_CMSG_CTRL_DECRYPT_PARA=CMSG_CTRL_DECRYPT_PARA -_CMSG_CTRL_DEL_SIGNER_UNAUTH_ATTR_PARA=CMSG_CTRL_DEL_SIGNER_UNAUTH_ATTR_PARA -_CMSG_CTRL_KEY_AGREE_DECRYPT_PARA=CMSG_CTRL_KEY_AGREE_DECRYPT_PARA -_CMSG_CTRL_KEY_TRANS_DECRYPT_PARA=CMSG_CTRL_KEY_TRANS_DECRYPT_PARA -_CMSG_CTRL_MAIL_LIST_DECRYPT_PARA=CMSG_CTRL_MAIL_LIST_DECRYPT_PARA -_CMSG_CTRL_VERIFY_SIGNATURE_EX_PARA=CMSG_CTRL_VERIFY_SIGNATURE_EX_PARA -_CMSG_ENCRYPTED_ENCODE_INFO=CMSG_ENCRYPTED_ENCODE_INFO -_CMSG_ENVELOPED_ENCODE_INFO=CMSG_ENVELOPED_ENCODE_INFO -_CMSG_HASHED_ENCODE_INFO=CMSG_HASHED_ENCODE_INFO -_CMSG_KEY_AGREE_ENCRYPT_INFO=CMSG_KEY_AGREE_ENCRYPT_INFO -_CMSG_KEY_AGREE_KEY_ENCRYPT_INFO=CMSG_KEY_AGREE_KEY_ENCRYPT_INFO -_CMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO=CMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO -_CMSG_KEY_AGREE_RECIPIENT_INFO=CMSG_KEY_AGREE_RECIPIENT_INFO -_CMSG_KEY_TRANS_ENCRYPT_INFO=CMSG_KEY_TRANS_ENCRYPT_INFO -_CMSG_KEY_TRANS_RECIPIENT_ENCODE_INFO=CMSG_KEY_TRANS_RECIPIENT_ENCODE_INFO -_CMSG_KEY_TRANS_RECIPIENT_INFO=CMSG_KEY_TRANS_RECIPIENT_INFO -_CMSG_MAIL_LIST_ENCRYPT_INFO=CMSG_MAIL_LIST_ENCRYPT_INFO -_CMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO=CMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO -_CMSG_MAIL_LIST_RECIPIENT_INFO=CMSG_MAIL_LIST_RECIPIENT_INFO -_CMSG_RC2_AUX_INFO=CMSG_RC2_AUX_INFO -_CMSG_RC4_AUX_INFO=CMSG_RC4_AUX_INFO -_CMSG_RECIPIENT_ENCODE_INFO=CMSG_RECIPIENT_ENCODE_INFO -_CMSG_RECIPIENT_ENCRYPTED_KEY_ENCODE_INFO=CMSG_RECIPIENT_ENCRYPTED_KEY_ENCODE_INFO -_CMSG_RECIPIENT_ENCRYPTED_KEY_INFO=CMSG_RECIPIENT_ENCRYPTED_KEY_INFO -_CMSG_SIGNED_AND_ENVELOPED_ENCODE_INFO=CMSG_SIGNED_AND_ENVELOPED_ENCODE_INFO -_CMSG_SIGNED_ENCODE_INFO=CMSG_SIGNED_ENCODE_INFO -_CMSG_SIGNER_ENCODE_INFO=CMSG_SIGNER_ENCODE_INFO -_CMSG_SIGNER_INFO=CMSG_SIGNER_INFO -_CMSG_SP3_COMPATIBLE_AUX_INFO=CMSG_SP3_COMPATIBLE_AUX_INFO -_CMSG_STREAM_INFO=CMSG_STREAM_INFO -_CMS_DH_KEY_INFO=CMS_DH_KEY_INFO -_CMS_KEY_INFO=CMS_KEY_INFO -_CM_ERROR_CONTROL_TYPE=SERVICE_ERROR_TYPE -_CM_SERVICE_LOAD_TYPE=SERVICE_LOAD_TYPE -_CM_SERVICE_NODE_TYPE=SERVICE_NODE_TYPE -_COAUTHIDENTITY=COAUTHIDENTITY -_COAUTHINFO=COAUTHINFO -_COINSTALLER_CONTEXT_DATA=COINSTALLER_CONTEXT_DATA -_COMMCONFIG=COMMCONFIG -_COMMPROP=COMMPROP -_COMMTIMEOUTS=COMMTIMEOUTS -_COMPATIBILITY_CONTEXT_ELEMENT=COMPATIBILITY_CONTEXT_ELEMENT -_COMPUTER_NAME_FORMAT=COMPUTER_NAME_FORMAT -_COMSTAT=COMSTAT _CONTEXT=CONTEXT -_COPYFILE2_COPY_PHASE=COPYFILE2_COPY_PHASE -_COPYFILE2_MESSAGE_ACTION=COPYFILE2_MESSAGE_ACTION -_COPYFILE2_MESSAGE_TYPE=COPYFILE2_MESSAGE_TYPE -_COSERVERINFO=COSERVERINFO -_CPS_URLS=CPS_URLS -_CPU_SET_INFORMATION_TYPE=CPU_SET_INFORMATION_TYPE -_CREATEFILE2_EXTENDED_PARAMETERS=CREATEFILE2_EXTENDED_PARAMETERS -_CREATE_PROCESS_DEBUG_INFO=CREATE_PROCESS_DEBUG_INFO -_CREATE_THREAD_DEBUG_INFO=CREATE_THREAD_DEBUG_INFO -_CRL_CONTEXT=CRL_CONTEXT -_CRL_DIST_POINT=CRL_DIST_POINT -_CRL_DIST_POINTS_INFO=CRL_DIST_POINTS_INFO -_CRL_DIST_POINT_NAME=CRL_DIST_POINT_NAME -_CRL_ENTRY=CRL_ENTRY -_CRL_FIND_ISSUED_FOR_PARA=CRL_FIND_ISSUED_FOR_PARA -_CRL_INFO=CRL_INFO -_CRL_ISSUING_DIST_POINT=CRL_ISSUING_DIST_POINT -_CRL_REVOCATION_INFO=CRL_REVOCATION_INFO -_CROSS_CERT_DIST_POINTS_INFO=CROSS_CERT_DIST_POINTS_INFO -_CRYPTNET_URL_CACHE_FLUSH_INFO=CRYPTNET_URL_CACHE_FLUSH_INFO -_CRYPTNET_URL_CACHE_PRE_FETCH_INFO=CRYPTNET_URL_CACHE_PRE_FETCH_INFO -_CRYPTNET_URL_CACHE_RESPONSE_INFO=CRYPTNET_URL_CACHE_RESPONSE_INFO _CRYPTOAPI_BLOB=CRYPT_INTEGER_BLOB -_CRYPT_3DES_KEY_STATE=CRYPT_3DES_KEY_STATE -_CRYPT_AES_128_KEY_STATE=CRYPT_AES_128_KEY_STATE -_CRYPT_AES_256_KEY_STATE=CRYPT_AES_256_KEY_STATE -_CRYPT_ALGORITHM_IDENTIFIER=CRYPT_ALGORITHM_IDENTIFIER -_CRYPT_ASYNC_RETRIEVAL_COMPLETION=CRYPT_ASYNC_RETRIEVAL_COMPLETION -_CRYPT_ATTRIBUTE=CRYPT_ATTRIBUTE -_CRYPT_ATTRIBUTES=CRYPT_ATTRIBUTES -_CRYPT_ATTRIBUTE_TYPE_VALUE=CRYPT_ATTRIBUTE_TYPE_VALUE -_CRYPT_BIT_BLOB=CRYPT_BIT_BLOB -_CRYPT_BLOB_ARRAY=CRYPT_BLOB_ARRAY -_CRYPT_CONTENT_INFO=CRYPT_CONTENT_INFO -_CRYPT_CONTENT_INFO_SEQUENCE_OF_ANY=CRYPT_CONTENT_INFO_SEQUENCE_OF_ANY -_CRYPT_CREDENTIALS=CRYPT_CREDENTIALS -_CRYPT_CSP_PROVIDER=CRYPT_CSP_PROVIDER -_CRYPT_DECODE_PARA=CRYPT_DECODE_PARA -_CRYPT_DECRYPT_MESSAGE_PARA=CRYPT_DECRYPT_MESSAGE_PARA -_CRYPT_DEFAULT_CONTEXT_MULTI_OID_PARA=CRYPT_DEFAULT_CONTEXT_MULTI_OID_PARA -_CRYPT_DES_KEY_STATE=CRYPT_DES_KEY_STATE -_CRYPT_ECC_CMS_SHARED_INFO=CRYPT_ECC_CMS_SHARED_INFO -_CRYPT_ECC_PRIVATE_KEY_INFO=CRYPT_ECC_PRIVATE_KEY_INFO -_CRYPT_ENCODE_PARA=CRYPT_ENCODE_PARA -_CRYPT_ENCRYPTED_PRIVATE_KEY_INFO=CRYPT_ENCRYPTED_PRIVATE_KEY_INFO -_CRYPT_ENCRYPT_MESSAGE_PARA=CRYPT_ENCRYPT_MESSAGE_PARA -_CRYPT_ENROLLMENT_NAME_VALUE_PAIR=CRYPT_ENROLLMENT_NAME_VALUE_PAIR -_CRYPT_GET_TIME_VALID_OBJECT_EXTRA_INFO=CRYPT_GET_TIME_VALID_OBJECT_EXTRA_INFO -_CRYPT_HASH_INFO=CRYPT_HASH_INFO -_CRYPT_HASH_MESSAGE_PARA=CRYPT_HASH_MESSAGE_PARA -_CRYPT_KEY_PROV_INFO=CRYPT_KEY_PROV_INFO -_CRYPT_KEY_PROV_PARAM=CRYPT_KEY_PROV_PARAM -_CRYPT_KEY_SIGN_MESSAGE_PARA=CRYPT_KEY_SIGN_MESSAGE_PARA -_CRYPT_KEY_VERIFY_MESSAGE_PARA=CRYPT_KEY_VERIFY_MESSAGE_PARA -_CRYPT_MASK_GEN_ALGORITHM=CRYPT_MASK_GEN_ALGORITHM -_CRYPT_OBJECT_LOCATOR_PROVIDER_TABLE=CRYPT_OBJECT_LOCATOR_PROVIDER_TABLE -_CRYPT_OBJID_TABLE=CRYPT_OBJID_TABLE -_CRYPT_OID_FUNC_ENTRY=CRYPT_OID_FUNC_ENTRY -_CRYPT_OID_INFO=CRYPT_OID_INFO -_CRYPT_PASSWORD_CREDENTIALSA=CRYPT_PASSWORD_CREDENTIALSA -_CRYPT_PASSWORD_CREDENTIALSW=CRYPT_PASSWORD_CREDENTIALSW -_CRYPT_PKCS8_EXPORT_PARAMS=CRYPT_PKCS8_EXPORT_PARAMS -_CRYPT_PKCS8_IMPORT_PARAMS=CRYPT_PKCS8_IMPORT_PARAMS -_CRYPT_PKCS12_PBE_PARAMS=CRYPT_PKCS12_PBE_PARAMS -_CRYPT_PRIVATE_KEY_INFO=CRYPT_PRIVATE_KEY_INFO -_CRYPT_PROVIDER_CERT=CRYPT_PROVIDER_CERT -_CRYPT_PROVIDER_DATA=CRYPT_PROVIDER_DATA -_CRYPT_PROVIDER_DEFUSAGE=CRYPT_PROVIDER_DEFUSAGE -_CRYPT_PROVIDER_FUNCTIONS=CRYPT_PROVIDER_FUNCTIONS -_CRYPT_PROVIDER_PRIVDATA=CRYPT_PROVIDER_PRIVDATA -_CRYPT_PROVIDER_REGDEFUSAGE=CRYPT_PROVIDER_REGDEFUSAGE -_CRYPT_PROVIDER_SGNR=CRYPT_PROVIDER_SGNR -_CRYPT_PROVIDER_SIGSTATE=CRYPT_PROVIDER_SIGSTATE -_CRYPT_PROVUI_DATA=CRYPT_PROVUI_DATA -_CRYPT_PROVUI_FUNCS=CRYPT_PROVUI_FUNCS -_CRYPT_PSOURCE_ALGORITHM=CRYPT_PSOURCE_ALGORITHM -_CRYPT_RC2_CBC_PARAMETERS=CRYPT_RC2_CBC_PARAMETERS -_CRYPT_RC4_KEY_STATE=CRYPT_RC4_KEY_STATE -_CRYPT_REGISTER_ACTIONID=CRYPT_REGISTER_ACTIONID -_CRYPT_RETRIEVE_AUX_INFO=CRYPT_RETRIEVE_AUX_INFO -_CRYPT_RSAES_OAEP_PARAMETERS=CRYPT_RSAES_OAEP_PARAMETERS -_CRYPT_RSA_SSA_PSS_PARAMETERS=CRYPT_RSA_SSA_PSS_PARAMETERS -_CRYPT_SEQUENCE_OF_ANY=CRYPT_SEQUENCE_OF_ANY -_CRYPT_SIGN_MESSAGE_PARA=CRYPT_SIGN_MESSAGE_PARA -_CRYPT_SMART_CARD_ROOT_INFO=CRYPT_SMART_CARD_ROOT_INFO -_CRYPT_SMIME_CAPABILITIES=CRYPT_SMIME_CAPABILITIES -_CRYPT_SMIME_CAPABILITY=CRYPT_SMIME_CAPABILITY -_CRYPT_TIMESTAMP_ACCURACY=CRYPT_TIMESTAMP_ACCURACY -_CRYPT_TIMESTAMP_CONTEXT=CRYPT_TIMESTAMP_CONTEXT -_CRYPT_TIMESTAMP_INFO=CRYPT_TIMESTAMP_INFO -_CRYPT_TIMESTAMP_PARA=CRYPT_TIMESTAMP_PARA -_CRYPT_TIMESTAMP_REQUEST=CRYPT_TIMESTAMP_REQUEST -_CRYPT_TIMESTAMP_RESPONSE=CRYPT_TIMESTAMP_RESPONSE -_CRYPT_TIME_STAMP_REQUEST_INFO=CRYPT_TIME_STAMP_REQUEST_INFO -_CRYPT_TRUST_REG_ENTRY=CRYPT_TRUST_REG_ENTRY -_CRYPT_URL_ARRAY=CRYPT_URL_ARRAY -_CRYPT_URL_INFO=CRYPT_URL_INFO -_CRYPT_VERIFY_CERT_SIGN_STRONG_PROPERTIES_INFO=CRYPT_VERIFY_CERT_SIGN_STRONG_PROPERTIES_INFO -_CRYPT_VERIFY_CERT_SIGN_WEAK_HASH_INFO=CRYPT_VERIFY_CERT_SIGN_WEAK_HASH_INFO -_CRYPT_VERIFY_MESSAGE_PARA=CRYPT_VERIFY_MESSAGE_PARA -_CRYPT_X942_OTHER_INFO=CRYPT_X942_OTHER_INFO -_CTL_ANY_SUBJECT_INFO=CTL_ANY_SUBJECT_INFO -_CTL_CONTEXT=CTL_CONTEXT -_CTL_ENTRY=CTL_ENTRY -_CTL_FIND_SUBJECT_PARA=CTL_FIND_SUBJECT_PARA -_CTL_FIND_USAGE_PARA=CTL_FIND_USAGE_PARA -_CTL_INFO=CTL_INFO -_CTL_USAGE=CTL_USAGE -_CTL_USAGE_MATCH=CTL_USAGE_MATCH -_CTL_VERIFY_USAGE_PARA=CTL_VERIFY_USAGE_PARA -_CTL_VERIFY_USAGE_STATUS=CTL_VERIFY_USAGE_STATUS -_CUSTOM_SYSTEM_EVENT_TRIGGER_CONFIG=CUSTOM_SYSTEM_EVENT_TRIGGER_CONFIG -_D3D11_AES_CTR_IV=D3D11_AES_CTR_IV -_D3D11_FUNCTION_DESC=D3D11_FUNCTION_DESC -_D3D11_LIBRARY_DESC=D3D11_LIBRARY_DESC -_D3D11_PARAMETER_DESC=D3D11_PARAMETER_DESC -_D3D11_SHADER_BUFFER_DESC=D3D11_SHADER_BUFFER_DESC -_D3D11_SHADER_DESC=D3D11_SHADER_DESC -_D3D11_SHADER_INPUT_BIND_DESC=D3D11_SHADER_INPUT_BIND_DESC -_D3D11_SHADER_TYPE_DESC=D3D11_SHADER_TYPE_DESC -_D3D11_SHADER_VARIABLE_DESC=D3D11_SHADER_VARIABLE_DESC -_D3D11_SIGNATURE_PARAMETER_DESC=D3D11_SIGNATURE_PARAMETER_DESC -_D3D12_FUNCTION_DESC=D3D12_FUNCTION_DESC -_D3D12_LIBRARY_DESC=D3D12_LIBRARY_DESC -_D3D12_PARAMETER_DESC=D3D12_PARAMETER_DESC -_D3D12_SHADER_BUFFER_DESC=D3D12_SHADER_BUFFER_DESC -_D3D12_SHADER_DESC=D3D12_SHADER_DESC -_D3D12_SHADER_INPUT_BIND_DESC=D3D12_SHADER_INPUT_BIND_DESC -_D3D12_SHADER_TYPE_DESC=D3D12_SHADER_TYPE_DESC -_D3D12_SHADER_VARIABLE_DESC=D3D12_SHADER_VARIABLE_DESC -_D3D12_SIGNATURE_PARAMETER_DESC=D3D12_SIGNATURE_PARAMETER_DESC -_D3DMATRIX=D3DMATRIX -_D3D_CBUFFER_TYPE=D3D_CBUFFER_TYPE -_D3D_INCLUDE_TYPE=D3D_INCLUDE_TYPE -_D3D_PARAMETER_FLAGS=D3D_PARAMETER_FLAGS -_D3D_SHADER_CBUFFER_FLAGS=D3D_SHADER_CBUFFER_FLAGS -_D3D_SHADER_DATA=D3D_SHADER_DATA -_D3D_SHADER_INPUT_FLAGS=D3D_SHADER_INPUT_FLAGS -_D3D_SHADER_INPUT_TYPE=D3D_SHADER_INPUT_TYPE -_D3D_SHADER_MACRO=D3D_SHADER_MACRO -_D3D_SHADER_VARIABLE_CLASS=D3D_SHADER_VARIABLE_CLASS -_D3D_SHADER_VARIABLE_FLAGS=D3D_SHADER_VARIABLE_FLAGS -_D3D_SHADER_VARIABLE_TYPE=D3D_SHADER_VARIABLE_TYPE -_DCB=DCB -_DEBUG_EVENT=DEBUG_EVENT -_DEP_SYSTEM_POLICY_TYPE=DEP_SYSTEM_POLICY_TYPE -_devicemodeA=DEVMODEA -_devicemodeW=DEVMODEW -_DEVICE_POWER_STATE=DEVICE_POWER_STATE -_DEVPROPCOMPKEY=DEVPROPCOMPKEY -_DEVPROPERTY=DEVPROPERTY -_DEVPROPKEY=DEVPROPKEY -_DEVPROPSTORE=DEVPROPSTORE -_DISPLAYCONFIG_COLOR_ENCODING=DISPLAYCONFIG_COLOR_ENCODING -_DISPLAYCONFIG_GET_ADVANCED_COLOR_INFO=DISPLAYCONFIG_GET_ADVANCED_COLOR_INFO -_DISPLAYCONFIG_SDR_WHITE_LEVEL=DISPLAYCONFIG_SDR_WHITE_LEVEL -_DISPLAYCONFIG_SET_ADVANCED_COLOR_STATE=DISPLAYCONFIG_SET_ADVANCED_COLOR_STATE -_DISPLAY_DEVICEA=DISPLAY_DEVICEA -_DISPLAY_DEVICEW=DISPLAY_DEVICEW -_DOCINFOA=DOCINFOA -_DOCINFOW=DOCINFOW -_DRAWPATRECT=DRAWPATRECT -_DSSSEED=DSSSEED -_DWORD_BLOB=DWORD_BLOB -_DXGI_OFFER_RESOURCE_FLAGS=DXGI_OFFER_RESOURCE_FLAGS -_DXGI_OFFER_RESOURCE_PRIORITY=DXGI_OFFER_RESOURCE_PRIORITY -_DXGI_RECLAIM_RESOURCE_RESULTS=DXGI_RECLAIM_RESOURCE_RESULTS -_ENLISTMENT_BASIC_INFORMATION=ENLISTMENT_BASIC_INFORMATION -_ENLISTMENT_CRM_INFORMATION=ENLISTMENT_CRM_INFORMATION -_ENLISTMENT_INFORMATION_CLASS=ENLISTMENT_INFORMATION_CLASS _ENUM_PAGE_FILE_INFORMATION_=ENUM_PAGE_FILE_INFORMATION -_EVENTLOGRECORD=EVENTLOGRECORD -_EVENT_PROPERTY_INFO=EVENT_PROPERTY_INFO -_EVENTLOG_FULL_INFORMATION=EVENTLOG_FULL_INFORMATION -_EVENTSFORLOGFILE=EVENTSFORLOGFILE -_EV_EXTRA_CERT_CHAIN_POLICY_PARA=EV_EXTRA_CERT_CHAIN_POLICY_PARA -_EV_EXTRA_CERT_CHAIN_POLICY_STATUS=EV_EXTRA_CERT_CHAIN_POLICY_STATUS -_EXCEPTION_DEBUG_INFO=EXCEPTION_DEBUG_INFO -_EXCEPTION_DISPOSITION=EXCEPTION_DISPOSITION -_EXCEPTION_POINTERS=EXCEPTION_POINTERS -_EXCEPTION_RECORD32=EXCEPTION_RECORD32 -_EXCEPTION_RECORD64=EXCEPTION_RECORD64 _EXCEPTION_RECORD=EXCEPTION_RECORD -_EXIT_PROCESS_DEBUG_INFO=EXIT_PROCESS_DEBUG_INFO -_EXIT_THREAD_DEBUG_INFO=EXIT_THREAD_DEBUG_INFO -_FILEPATHS_A=FILEPATHS_A -_FILEPATHS_SIGNERINFO_A=FILEPATHS_SIGNERINFO_A -_FILEPATHS_SIGNERINFO_W=FILEPATHS_SIGNERINFO_W -_FILEPATHS_W=FILEPATHS_W -_FILETIME=FILETIME -_FILE_ALIGNMENT_INFO=FILE_ALIGNMENT_INFO -_FILE_ALLOCATION_INFO=FILE_ALLOCATION_INFO -_FILE_ATTRIBUTE_TAG_INFO=FILE_ATTRIBUTE_TAG_INFO -_FILE_BASIC_INFO=FILE_BASIC_INFO -_FILE_CASE_SENSITIVE_INFO=FILE_CASE_SENSITIVE_INFO -_FILE_COMPRESSION_INFO=FILE_COMPRESSION_INFO -_FILE_DISPOSITION_INFO=FILE_DISPOSITION_INFO -_FILE_DISPOSITION_INFO_EX=FILE_DISPOSITION_INFO_EX -_FILE_END_OF_FILE_INFO=FILE_END_OF_FILE_INFO -_FILE_FULL_DIR_INFO=FILE_FULL_DIR_INFO -_FILE_ID_128=FILE_ID_128 -_FILE_ID_BOTH_DIR_INFO=FILE_ID_BOTH_DIR_INFO -_FILE_ID_EXTD_DIR_INFO=FILE_ID_EXTD_DIR_INFO -_FILE_ID_INFO=FILE_ID_INFO -_FILE_ID_TYPE=FILE_ID_TYPE -_FILE_INFO_BY_HANDLE_CLASS=FILE_INFO_BY_HANDLE_CLASS -_FILE_IN_CABINET_INFO_A=FILE_IN_CABINET_INFO_A -_FILE_IN_CABINET_INFO_W=FILE_IN_CABINET_INFO_W -_FILE_IO_PRIORITY_HINT_INFO=FILE_IO_PRIORITY_HINT_INFO -_FILE_NAME_INFO=FILE_NAME_INFO -_FILE_NOTIFY_EXTENDED_INFORMATION=FILE_NOTIFY_EXTENDED_INFORMATION -_FILE_NOTIFY_INFORMATION=FILE_NOTIFY_INFORMATION -_FILE_REMOTE_PROTOCOL_INFO=FILE_REMOTE_PROTOCOL_INFO -_FILE_RENAME_INFO=FILE_RENAME_INFO -_FILE_SEGMENT_ELEMENT=FILE_SEGMENT_ELEMENT -_FILE_STANDARD_INFO=FILE_STANDARD_INFO -_FILE_STORAGE_INFO=FILE_STORAGE_INFO -_FILE_STREAM_INFO=FILE_STREAM_INFO -_FINDEX_INFO_LEVELS=FINDEX_INFO_LEVELS -_FINDEX_SEARCH_OPS=FINDEX_SEARCH_OPS -_FIRMWARE_TYPE=FIRMWARE_TYPE -_FIXED=FIXED -_FLAGGED_BYTE_BLOB=FLAGGED_BYTE_BLOB -_FLAGGED_WORD_BLOB=FLAGGED_WORD_BLOB -_FLAG_STGMEDIUM=FLAG_STGMEDIUM -_FLOAT128=FLOAT128 -_FLOATING_SAVE_AREA=FLOATING_SAVE_AREA -_FPO_DATA=FPO_DATA _GDI_NONREMOTE::__MIDL_IWinTypes_0002=_u_e__Struct -_GDI_NONREMOTE=GDI_NONREMOTE _GDI_OBJECT::__MIDL_IAdviseSink_0002=_u_e__Struct -_GDI_OBJECT=GDI_OBJECT -_GENERIC_MAPPING=GENERIC_MAPPING -_GET_FILEEX_INFO_LEVELS=GET_FILEEX_INFO_LEVELS -_GLYPHMETRICS=GLYPHMETRICS -_GLYPHMETRICSFLOAT=GLYPHMETRICSFLOAT -_GRADIENT_RECT=GRADIENT_RECT -_GRADIENT_TRIANGLE=GRADIENT_TRIANGLE -_GROUP_AFFINITY=GROUP_AFFINITY -_GROUP_RELATIONSHIP=GROUP_RELATIONSHIP _GUID=Guid -_HARDWARE_COUNTER_DATA=HARDWARE_COUNTER_DATA -_HARDWARE_COUNTER_TYPE=HARDWARE_COUNTER_TYPE -_HEAP_INFORMATION_CLASS=HEAP_INFORMATION_CLASS -_HEAP_OPTIMIZE_RESOURCES_INFORMATION=HEAP_OPTIMIZE_RESOURCES_INFORMATION -_HEAP_SUMMARY=HEAP_SUMMARY -_HIBERFILE_BUCKET=HIBERFILE_BUCKET -_HIBERFILE_BUCKET_SIZE=HIBERFILE_BUCKET_SIZE -_HIDD_ATTRIBUTES=HIDD_ATTRIBUTES -_HIDD_CONFIGURATION=HIDD_CONFIGURATION -_HIDP_BUTTON_CAPS=HIDP_BUTTON_CAPS -_HIDP_CAPS=HIDP_CAPS -_HIDP_DATA=HIDP_DATA -_HIDP_EXTENDED_ATTRIBUTES=HIDP_EXTENDED_ATTRIBUTES -_HIDP_KEYBOARD_DIRECTION=HIDP_KEYBOARD_DIRECTION -_HIDP_KEYBOARD_MODIFIER_STATE=HIDP_KEYBOARD_MODIFIER_STATE -_HIDP_LINK_COLLECTION_NODE=HIDP_LINK_COLLECTION_NODE _HIDP_PREPARSED_DATA*=IntPtr -_HIDP_REPORT_TYPE=HIDP_REPORT_TYPE -_HIDP_UNKNOWN_TOKEN=HIDP_UNKNOWN_TOKEN -_HIDP_VALUE_CAPS=HIDP_VALUE_CAPS -_HID_COLLECTION_INFORMATION=HID_COLLECTION_INFORMATION -_HID_DRIVER_CONFIG=HID_DRIVER_CONFIG -_HID_XFER_PACKET=HID_XFER_PACKET -_HMAC_Info=HMAC_INFO -_HTTPSPolicyCallbackData=HTTPSPolicyCallbackData -_HYPER_SIZEDARR=HYPER_SIZEDARR -_ICONINFO=ICONINFO -_ICONINFOEXA=ICONINFOEXA -_ICONINFOEXW=ICONINFOEXW -_ImageArchitectureEntry=IMAGE_ARCHITECTURE_ENTRY -_ImageArchitectureHeader=IMAGE_ARCHITECTURE_HEADER -_IMAGE_ALPHA64_RUNTIME_FUNCTION_ENTRY=IMAGE_ALPHA64_RUNTIME_FUNCTION_ENTRY -_IMAGE_ALPHA_RUNTIME_FUNCTION_ENTRY=IMAGE_ALPHA_RUNTIME_FUNCTION_ENTRY -_IMAGE_ARCHIVE_MEMBER_HEADER=IMAGE_ARCHIVE_MEMBER_HEADER -_IMAGE_ARM64_RUNTIME_FUNCTION_ENTRY=IMAGE_ARM64_RUNTIME_FUNCTION_ENTRY -_IMAGE_ARM_RUNTIME_FUNCTION_ENTRY=IMAGE_ARM_RUNTIME_FUNCTION_ENTRY -_IMAGE_AUX_SYMBOL=IMAGE_AUX_SYMBOL -_IMAGE_AUX_SYMBOL_EX=IMAGE_AUX_SYMBOL_EX -_IMAGE_BASE_RELOCATION=IMAGE_BASE_RELOCATION -_IMAGE_BOUND_FORWARDER_REF=IMAGE_BOUND_FORWARDER_REF -_IMAGE_BOUND_IMPORT_DESCRIPTOR=IMAGE_BOUND_IMPORT_DESCRIPTOR -_IMAGE_CE_RUNTIME_FUNCTION_ENTRY=IMAGE_CE_RUNTIME_FUNCTION_ENTRY -_IMAGE_COFF_SYMBOLS_HEADER=IMAGE_COFF_SYMBOLS_HEADER -_IMAGE_DATA_DIRECTORY=IMAGE_DATA_DIRECTORY -_IMAGE_DEBUG_DIRECTORY=IMAGE_DEBUG_DIRECTORY -_IMAGE_DEBUG_MISC=IMAGE_DEBUG_MISC -_IMAGE_DELAYLOAD_DESCRIPTOR=IMAGE_DELAYLOAD_DESCRIPTOR -_IMAGE_DOS_HEADER=IMAGE_DOS_HEADER -_IMAGE_DYNAMIC_RELOCATION32=IMAGE_DYNAMIC_RELOCATION32 -_IMAGE_DYNAMIC_RELOCATION32_V2=IMAGE_DYNAMIC_RELOCATION32_V2 -_IMAGE_DYNAMIC_RELOCATION64=IMAGE_DYNAMIC_RELOCATION64 -_IMAGE_DYNAMIC_RELOCATION64_V2=IMAGE_DYNAMIC_RELOCATION64_V2 -_IMAGE_DYNAMIC_RELOCATION_TABLE=IMAGE_DYNAMIC_RELOCATION_TABLE -_IMAGE_EPILOGUE_DYNAMIC_RELOCATION_HEADER=IMAGE_EPILOGUE_DYNAMIC_RELOCATION_HEADER -_IMAGE_EXPORT_DIRECTORY=IMAGE_EXPORT_DIRECTORY -_IMAGE_FILE_HEADER=IMAGE_FILE_HEADER -_IMAGE_FUNCTION_ENTRY64=IMAGE_FUNCTION_ENTRY64 -_IMAGE_FUNCTION_ENTRY=IMAGE_FUNCTION_ENTRY -_IMAGE_HOT_PATCH_BASE=IMAGE_HOT_PATCH_BASE -_IMAGE_HOT_PATCH_HASHES=IMAGE_HOT_PATCH_HASHES -_IMAGE_HOT_PATCH_INFO=IMAGE_HOT_PATCH_INFO -_IMAGE_IMPORT_BY_NAME=IMAGE_IMPORT_BY_NAME -_IMAGE_IMPORT_CONTROL_TRANSFER_DYNAMIC_RELOCATION=IMAGE_IMPORT_CONTROL_TRANSFER_DYNAMIC_RELOCATION -_IMAGE_IMPORT_DESCRIPTOR=IMAGE_IMPORT_DESCRIPTOR -_IMAGE_INDIR_CONTROL_TRANSFER_DYNAMIC_RELOCATION=IMAGE_INDIR_CONTROL_TRANSFER_DYNAMIC_RELOCATION -_IMAGE_LINENUMBER=IMAGE_LINENUMBER -_IMAGE_LOAD_CONFIG_CODE_INTEGRITY=IMAGE_LOAD_CONFIG_CODE_INTEGRITY -_IMAGE_LOAD_CONFIG_DIRECTORY32=IMAGE_LOAD_CONFIG_DIRECTORY32 -_IMAGE_LOAD_CONFIG_DIRECTORY64=IMAGE_LOAD_CONFIG_DIRECTORY64 -_IMAGE_NT_HEADERS64=IMAGE_NT_HEADERS64 -_IMAGE_NT_HEADERS=IMAGE_NT_HEADERS32 -_IMAGE_OPTIONAL_HEADER64=IMAGE_OPTIONAL_HEADER64 -_IMAGE_OPTIONAL_HEADER=IMAGE_OPTIONAL_HEADER32 -_IMAGE_OS2_HEADER=IMAGE_OS2_HEADER -_IMAGE_POLICY_ENTRY=IMAGE_POLICY_ENTRY -_IMAGE_POLICY_ENTRY_TYPE=IMAGE_POLICY_ENTRY_TYPE -_IMAGE_POLICY_ID=IMAGE_POLICY_ID -_IMAGE_POLICY_METADATA=IMAGE_POLICY_METADATA -_IMAGE_PROLOGUE_DYNAMIC_RELOCATION_HEADER=IMAGE_PROLOGUE_DYNAMIC_RELOCATION_HEADER -_IMAGE_RELOCATION=IMAGE_RELOCATION -_IMAGE_RESOURCE_DATA_ENTRY=IMAGE_RESOURCE_DATA_ENTRY -_IMAGE_RESOURCE_DIRECTORY=IMAGE_RESOURCE_DIRECTORY -_IMAGE_RESOURCE_DIRECTORY_ENTRY=IMAGE_RESOURCE_DIRECTORY_ENTRY -_IMAGE_RESOURCE_DIRECTORY_STRING=IMAGE_RESOURCE_DIRECTORY_STRING -_IMAGE_RESOURCE_DIR_STRING_U=IMAGE_RESOURCE_DIR_STRING_U -_IMAGE_ROM_HEADERS=IMAGE_ROM_HEADERS -_IMAGE_ROM_OPTIONAL_HEADER=IMAGE_ROM_OPTIONAL_HEADER _IMAGE_RUNTIME_FUNCTION_ENTRY=IMAGE_RUNTIME_FUNCTION_ENTRY -_IMAGE_SECTION_HEADER=IMAGE_SECTION_HEADER -_IMAGE_SEPARATE_DEBUG_HEADER=IMAGE_SEPARATE_DEBUG_HEADER -_IMAGE_SWITCHTABLE_BRANCH_DYNAMIC_RELOCATION=IMAGE_SWITCHTABLE_BRANCH_DYNAMIC_RELOCATION -_IMAGE_SYMBOL=IMAGE_SYMBOL -_IMAGE_SYMBOL_EX=IMAGE_SYMBOL_EX -_IMAGE_THUNK_DATA32=IMAGE_THUNK_DATA32 -_IMAGE_THUNK_DATA64=IMAGE_THUNK_DATA64 -_IMAGE_TLS_DIRECTORY32=IMAGE_TLS_DIRECTORY32 -_IMAGE_TLS_DIRECTORY64=IMAGE_TLS_DIRECTORY64 -_IMAGE_VXD_HEADER=IMAGE_VXD_HEADER -_INFCONTEXT=INFCONTEXT -_INTENT_TO_SEAL_ATTRIBUTE=INTENT_TO_SEAL_ATTRIBUTE -_IO_COUNTERS=IO_COUNTERS -_JIT_DEBUG_INFO=JIT_DEBUG_INFO -_JOBOBJECTINFOCLASS=JOBOBJECTINFOCLASS -_JOBOBJECT_ASSOCIATE_COMPLETION_PORT=JOBOBJECT_ASSOCIATE_COMPLETION_PORT -_JOBOBJECT_BASIC_ACCOUNTING_INFORMATION=JOBOBJECT_BASIC_ACCOUNTING_INFORMATION -_JOBOBJECT_BASIC_AND_IO_ACCOUNTING_INFORMATION=JOBOBJECT_BASIC_AND_IO_ACCOUNTING_INFORMATION -_JOBOBJECT_BASIC_LIMIT_INFORMATION=JOBOBJECT_BASIC_LIMIT_INFORMATION -_JOBOBJECT_BASIC_PROCESS_ID_LIST=JOBOBJECT_BASIC_PROCESS_ID_LIST -_JOBOBJECT_BASIC_UI_RESTRICTIONS=JOBOBJECT_BASIC_UI_RESTRICTIONS -_JOBOBJECT_CPU_RATE_CONTROL_INFORMATION=JOBOBJECT_CPU_RATE_CONTROL_INFORMATION -_JOBOBJECT_END_OF_JOB_TIME_INFORMATION=JOBOBJECT_END_OF_JOB_TIME_INFORMATION -_JOBOBJECT_EXTENDED_LIMIT_INFORMATION=JOBOBJECT_EXTENDED_LIMIT_INFORMATION -_JOBOBJECT_IO_ATTRIBUTION_INFORMATION=JOBOBJECT_IO_ATTRIBUTION_INFORMATION -_JOBOBJECT_IO_ATTRIBUTION_STATS=JOBOBJECT_IO_ATTRIBUTION_STATS -_JOBOBJECT_JOBSET_INFORMATION=JOBOBJECT_JOBSET_INFORMATION -_JOBOBJECT_LIMIT_VIOLATION_INFORMATION=JOBOBJECT_LIMIT_VIOLATION_INFORMATION -_JOBOBJECT_NOTIFICATION_LIMIT_INFORMATION=JOBOBJECT_NOTIFICATION_LIMIT_INFORMATION -_JOBOBJECT_RATE_CONTROL_TOLERANCE=JOBOBJECT_RATE_CONTROL_TOLERANCE -_JOBOBJECT_RATE_CONTROL_TOLERANCE_INTERVAL=JOBOBJECT_RATE_CONTROL_TOLERANCE_INTERVAL -_JOBOBJECT_SECURITY_LIMIT_INFORMATION=JOBOBJECT_SECURITY_LIMIT_INFORMATION -_JOB_SET_ARRAY=JOB_SET_ARRAY -_KEY_TYPE_SUBTYPE=KEY_TYPE_SUBTYPE -_KNONVOLATILE_CONTEXT_POINTERS=KNONVOLATILE_CONTEXT_POINTERS -_KTMOBJECT_CURSOR=KTMOBJECT_CURSOR -_KTMOBJECT_TYPE=KTMOBJECT_TYPE _LARGE_INTEGER=long -_LDT_ENTRY=LDT_ENTRY -_LIST_ENTRY=LIST_ENTRY -_LOAD_DLL_DEBUG_INFO=LOAD_DLL_DEBUG_INFO -_LOGICAL_PROCESSOR_RELATIONSHIP=LOGICAL_PROCESSOR_RELATIONSHIP -_LONG_SIZEDARR=DWORD_SIZEDARR -_LUID=LUID -_LUID_AND_ATTRIBUTES=LUID_AND_ATTRIBUTES -_M128A=M128A -_MANDATORY_LEVEL=MANDATORY_LEVEL -_MAT2=MAT2 -_MAXVERSIONTESTED_INFO=MAXVERSIONTESTED_INFO -_MEMORYSTATUS=MEMORYSTATUS -_MEMORYSTATUSEX=MEMORYSTATUSEX -_MEMORY_BASIC_INFORMATION32=MEMORY_BASIC_INFORMATION32 -_MEMORY_BASIC_INFORMATION64=MEMORY_BASIC_INFORMATION64 -_MEMORY_BASIC_INFORMATION=MEMORY_BASIC_INFORMATION -_MEMORY_PRIORITY_INFORMATION=MEMORY_PRIORITY_INFORMATION -_MEM_ADDRESS_REQUIREMENTS=MEM_ADDRESS_REQUIREMENTS -_MESSAGE_RESOURCE_BLOCK=MESSAGE_RESOURCE_BLOCK -_MESSAGE_RESOURCE_DATA=MESSAGE_RESOURCE_DATA -_MESSAGE_RESOURCE_ENTRY=MESSAGE_RESOURCE_ENTRY -_MIDL_STUB_MESSAGE=MIDL_STUB_MESSAGE -_MONITOR_DISPLAY_STATE=MONITOR_DISPLAY_STATE -_NETWORK_APP_INSTANCE_EA=NETWORK_APP_INSTANCE_EA -_NON_PAGED_DEBUG_INFO=NON_PAGED_DEBUG_INFO -_NT_TIB32=NT_TIB32 -_NT_TIB64=NT_TIB64 -_NUMA_NODE_RELATIONSHIP=NUMA_NODE_RELATIONSHIP -_NV_MEMORY_RANGE=NV_MEMORY_RANGE -_OBJECTID=OBJECTID -_OBJECT_TYPE_LIST=OBJECT_TYPE_LIST -_OCSP_BASIC_RESPONSE_ENTRY=OCSP_BASIC_RESPONSE_ENTRY -_OCSP_BASIC_RESPONSE_INFO=OCSP_BASIC_RESPONSE_INFO -_OCSP_BASIC_REVOKED_INFO=OCSP_BASIC_REVOKED_INFO -_OCSP_BASIC_SIGNED_RESPONSE_INFO=OCSP_BASIC_SIGNED_RESPONSE_INFO -_OCSP_CERT_ID=OCSP_CERT_ID -_OCSP_REQUEST_ENTRY=OCSP_REQUEST_ENTRY -_OCSP_REQUEST_INFO=OCSP_REQUEST_INFO -_OCSP_RESPONSE_INFO=OCSP_RESPONSE_INFO -_OCSP_SIGNATURE_INFO=OCSP_SIGNATURE_INFO -_OCSP_SIGNED_REQUEST_INFO=OCSP_SIGNED_REQUEST_INFO -_OFSTRUCT=OFSTRUCT -_OPERATION_END_PARAMETERS=OPERATION_END_PARAMETERS -_OPERATION_START_PARAMETERS=OPERATION_START_PARAMETERS -_OSVERSIONINFOA=OSVERSIONINFOA -_OSVERSIONINFOEXA=OSVERSIONINFOEXA -_OSVERSIONINFOEXW=OSVERSIONINFOEXW -_OSVERSIONINFOW=OSVERSIONINFOW -_OS_DEPLOYEMENT_STATE_VALUES=OS_DEPLOYEMENT_STATE_VALUES -_OUTLINETEXTMETRICA=OUTLINETEXTMETRICA -_OUTLINETEXTMETRICW=OUTLINETEXTMETRICW -_OUTPUT_DEBUG_STRING_INFO=OUTPUT_DEBUG_STRING_INFO -_OVERLAPPED=OVERLAPPED -_OVERLAPPED_ENTRY=OVERLAPPED_ENTRY -_PACKEDEVENTINFO=PACKEDEVENTINFO -_PERFORMANCE_DATA=PERFORMANCE_DATA -_PKCS12_PBES2_EXPORT_PARAMS=PKCS12_PBES2_EXPORT_PARAMS -_POINTFLOAT=POINTFLOAT -_POINTL=POINTL -_POWER_IDLE_RESILIENCY=POWER_IDLE_RESILIENCY -_POWER_MONITOR_INVOCATION=POWER_MONITOR_INVOCATION -_POWER_MONITOR_REQUEST_TYPE=POWER_MONITOR_REQUEST_TYPE -_POWER_PLATFORM_INFORMATION=POWER_PLATFORM_INFORMATION -_POWER_PLATFORM_ROLE=POWER_PLATFORM_ROLE -_POWER_REQUEST_TYPE=POWER_REQUEST_TYPE -_POWER_SESSION_ALLOW_EXTERNAL_DMA_DEVICES=POWER_SESSION_ALLOW_EXTERNAL_DMA_DEVICES -_POWER_SESSION_CONNECT=POWER_SESSION_CONNECT -_POWER_SESSION_RIT_STATE=POWER_SESSION_RIT_STATE -_POWER_SESSION_TIMEOUTS=POWER_SESSION_TIMEOUTS -_POWER_SESSION_WINLOGON=POWER_SESSION_WINLOGON -_POWER_USER_PRESENCE=POWER_USER_PRESENCE -_PRIORITY_HINT=PRIORITY_HINT -_PRIVILEGE_SET=PRIVILEGE_SET _PRIVKEYVER3=PRIVKEYVER3 -_PROCESSOR_CACHE_TYPE=PROCESSOR_CACHE_TYPE -_PROCESSOR_GROUP_INFO=PROCESSOR_GROUP_INFO -_PROCESSOR_NUMBER=PROCESSOR_NUMBER -_PROCESSOR_POWER_POLICY=PROCESSOR_POWER_POLICY -_PROCESSOR_POWER_POLICY_INFO=PROCESSOR_POWER_POLICY_INFO -_PROCESSOR_RELATIONSHIP=PROCESSOR_RELATIONSHIP -_PROCESS_DYNAMIC_EH_CONTINUATION_TARGET=PROCESS_DYNAMIC_EH_CONTINUATION_TARGET -_PROCESS_DYNAMIC_EH_CONTINUATION_TARGETS_INFORMATION=PROCESS_DYNAMIC_EH_CONTINUATION_TARGETS_INFORMATION -_PROCESS_HEAP_ENTRY=PROCESS_HEAP_ENTRY -_PROCESS_INFORMATION=PROCESS_INFORMATION -_PROCESS_INFORMATION_CLASS=PROCESS_INFORMATION_CLASS -_PROCESS_LEAP_SECOND_INFO=PROCESS_LEAP_SECOND_INFO -_PROCESS_MEMORY_EXHAUSTION_INFO=PROCESS_MEMORY_EXHAUSTION_INFO -_PROCESS_MEMORY_EXHAUSTION_TYPE=PROCESS_MEMORY_EXHAUSTION_TYPE -_PROCESS_MITIGATION_ASLR_POLICY=PROCESS_MITIGATION_ASLR_POLICY -_PROCESS_MITIGATION_BINARY_SIGNATURE_POLICY=PROCESS_MITIGATION_BINARY_SIGNATURE_POLICY -_PROCESS_MITIGATION_CHILD_PROCESS_POLICY=PROCESS_MITIGATION_CHILD_PROCESS_POLICY -_PROCESS_MITIGATION_CONTROL_FLOW_GUARD_POLICY=PROCESS_MITIGATION_CONTROL_FLOW_GUARD_POLICY -_PROCESS_MITIGATION_DEP_POLICY=PROCESS_MITIGATION_DEP_POLICY -_PROCESS_MITIGATION_DYNAMIC_CODE_POLICY=PROCESS_MITIGATION_DYNAMIC_CODE_POLICY -_PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY=PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY -_PROCESS_MITIGATION_FONT_DISABLE_POLICY=PROCESS_MITIGATION_FONT_DISABLE_POLICY -_PROCESS_MITIGATION_IMAGE_LOAD_POLICY=PROCESS_MITIGATION_IMAGE_LOAD_POLICY -_PROCESS_MITIGATION_PAYLOAD_RESTRICTION_POLICY=PROCESS_MITIGATION_PAYLOAD_RESTRICTION_POLICY -_PROCESS_MITIGATION_POLICY=PROCESS_MITIGATION_POLICY -_PROCESS_MITIGATION_SIDE_CHANNEL_ISOLATION_POLICY=PROCESS_MITIGATION_SIDE_CHANNEL_ISOLATION_POLICY -_PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY=PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY -_PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY=PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY -_PROCESS_MITIGATION_SYSTEM_CALL_FILTER_POLICY=PROCESS_MITIGATION_SYSTEM_CALL_FILTER_POLICY -_PROCESS_MITIGATION_USER_SHADOW_STACK_POLICY=PROCESS_MITIGATION_USER_SHADOW_STACK_POLICY -_PROCESS_POWER_THROTTLING_STATE=PROCESS_POWER_THROTTLING_STATE _PROC_THREAD_ATTRIBUTE_LIST*=IntPtr -_PROC_THREAD_ATTRIBUTE_NUM=PROC_THREAD_ATTRIBUTE_NUM -_PROPSHEETHEADERA_V1=PROPSHEETHEADERA_V1 -_PROPSHEETHEADERA_V2=PROPSHEETHEADERA_V2 -_PROPSHEETHEADERW_V1=PROPSHEETHEADERW_V1 -_PROPSHEETHEADERW_V2=PROPSHEETHEADERW_V2 _PROPSHEETPAGEA=PROPSHEETPAGEA -_PROPSHEETPAGEA_V1=PROPSHEETPAGEA_V1 -_PROPSHEETPAGEA_V2=PROPSHEETPAGEA_V2 -_PROPSHEETPAGEA_V3=PROPSHEETPAGEA_V3 _PROPSHEETPAGEW=PROPSHEETPAGEW -_PROPSHEETPAGEW_V1=PROPSHEETPAGEW_V1 -_PROPSHEETPAGEW_V2=PROPSHEETPAGEW_V2 -_PROPSHEETPAGEW_V3=PROPSHEETPAGEW_V3 -_PROVDATA_SIP=PROVDATA_SIP -_PROV_ENUMALGS=PROV_ENUMALGS -_PROV_ENUMALGS_EX=PROV_ENUMALGS_EX -_PSAPI_WORKING_SET_BLOCK=PSAPI_WORKING_SET_BLOCK -_PSAPI_WORKING_SET_EX_BLOCK=PSAPI_WORKING_SET_EX_BLOCK -_PSAPI_WORKING_SET_INFORMATION=PSAPI_WORKING_SET_INFORMATION -_PSAPI_WORKING_SET_EX_INFORMATION=PSAPI_WORKING_SET_EX_INFORMATION -_PSAPI_WS_WATCH_INFORMATION=PSAPI_WS_WATCH_INFORMATION -_PSAPI_WS_WATCH_INFORMATION_EX=PSAPI_WS_WATCH_INFORMATION_EX -_PROCESS_MEMORY_COUNTERS=PROCESS_MEMORY_COUNTERS -_PROCESS_MEMORY_COUNTERS_EX=PROCESS_MEMORY_COUNTERS_EX -_PERFORMANCE_INFORMATION=PERFORMANCE_INFORMATION -_PSFEATURE_CUSTPAPER=PSFEATURE_CUSTPAPER -_PSFEATURE_OUTPUT=PSFEATURE_OUTPUT -_PSHNOTIFY=PSHNOTIFY -_PSINJECTDATA=PSINJECTDATA _PSP*=IntPtr _PUBKEY=PUBKEY _PUBKEYVER3=PUBKEYVER3 -_PUBLICKEYSTRUC=PUBLICKEYSTRUC -_QUOTA_LIMITS=QUOTA_LIMITS -_QUOTA_LIMITS_EX=QUOTA_LIMITS_EX -_RASTERIZER_STATUS=RASTERIZER_STATUS -_RATE_QUOTA_LIMIT=RATE_QUOTA_LIMIT -_READ_DIRECTORY_NOTIFY_INFORMATION_CLASS=READ_DIRECTORY_NOTIFY_INFORMATION_CLASS -_REARRANGE_FILE_DATA=REARRANGE_FILE_DATA -_REASON_CONTEXT=REASON_CONTEXT -_RECTL=RECTL -_REDIRECTION_DESCRIPTOR=REDIRECTION_DESCRIPTOR -_REDIRECTION_FUNCTION_DESCRIPTOR=REDIRECTION_FUNCTION_DESCRIPTOR _RemotableHandle::__MIDL_IWinTypes_0009=_u_e__Struct -_RemotableHandle=RemotableHandle -_remoteMETAFILEPICT=remoteMETAFILEPICT -_REMSECURITY_ATTRIBUTES=REMSECURITY_ATTRIBUTES -_REPARSE_GUID_DATA_BUFFER=REPARSE_GUID_DATA_BUFFER -_RESOURCEMANAGER_BASIC_INFORMATION=RESOURCEMANAGER_BASIC_INFORMATION -_RESOURCEMANAGER_COMPLETION_INFORMATION=RESOURCEMANAGER_COMPLETION_INFORMATION -_RESOURCEMANAGER_INFORMATION_CLASS=RESOURCEMANAGER_INFORMATION_CLASS -_RESUME_PERFORMANCE=RESUME_PERFORMANCE -_RGNDATA=RGNDATA -_RGNDATAHEADER=RGNDATAHEADER -_RIP_INFO=RIP_INFO -_ROOT_INFO_LUID=ROOT_INFO_LUID -_RSAPUBKEY=RSAPUBKEY _RTL_BARRIER=SYNCHRONIZATION_BARRIER _RTL_CONDITION_VARIABLE=CONDITION_VARIABLE _RTL_CRITICAL_SECTION=CRITICAL_SECTION _RTL_CRITICAL_SECTION_DEBUG=CRITICAL_SECTION_DEBUG _RTL_RUN_ONCE=INIT_ONCE _RTL_SRWLOCK=SRWLOCK -_RTL_UMS_SCHEDULER_REASON=RTL_UMS_SCHEDULER_REASON _RTL_UMS_THREAD_INFO_CLASS=UMS_THREAD_INFO_CLASS -_SCHANNEL_ALG=SCHANNEL_ALG -_SCOPE_TABLE_AMD64=SCOPE_TABLE_AMD64 -_SCOPE_TABLE_ARM64=SCOPE_TABLE_ARM64 -_SCOPE_TABLE_ARM=SCOPE_TABLE_ARM -_SCRUB_DATA_INPUT=SCRUB_DATA_INPUT -_SCRUB_DATA_OUTPUT=SCRUB_DATA_OUTPUT -_SCRUB_PARITY_EXTENT=SCRUB_PARITY_EXTENT -_SCRUB_PARITY_EXTENT_DATA=SCRUB_PARITY_EXTENT_DATA -_SEALING_SIGNATURE_ATTRIBUTE=SEALING_SIGNATURE_ATTRIBUTE -_SEALING_TIMESTAMP_ATTRIBUTE=SEALING_TIMESTAMP_ATTRIBUTE -_SECURITY_ATTRIBUTES=SECURITY_ATTRIBUTES -_SECURITY_CAPABILITIES=SECURITY_CAPABILITIES -_SECURITY_DESCRIPTOR=SECURITY_DESCRIPTOR -_SECURITY_DESCRIPTOR_RELATIVE=SECURITY_DESCRIPTOR_RELATIVE -_SECURITY_IMPERSONATION_LEVEL=SECURITY_IMPERSONATION_LEVEL -_SECURITY_OBJECT_AI_PARAMS=SECURITY_OBJECT_AI_PARAMS -_SECURITY_QUALITY_OF_SERVICE=SECURITY_QUALITY_OF_SERVICE -_SERVERSILO_BASIC_INFORMATION=SERVERSILO_BASIC_INFORMATION -_SERVERSILO_STATE=SERVERSILO_STATE -_SE_ACCESS_REPLY=SE_ACCESS_REPLY -_SE_ACCESS_REQUEST=SE_ACCESS_REQUEST -_SE_IMAGE_SIGNATURE_TYPE=SE_IMAGE_SIGNATURE_TYPE -_SE_IMPERSONATION_STATE=SE_IMPERSONATION_STATE _SE_LEARNING_MODE_DATA_TYPE=SE_LEARNING_MODE_DATA_TYPE -_SE_SECURITY_DESCRIPTOR=SE_SECURITY_DESCRIPTOR -_SE_SID=SE_SID -_SE_TOKEN_USER=SE_TOKEN_USER -_SharedVirtualDiskHandleState=SharedVirtualDiskHandleState -_SharedVirtualDiskSupportType=SharedVirtualDiskSupportType -_SHARED_VIRTUAL_DISK_SUPPORT=SHARED_VIRTUAL_DISK_SUPPORT -_SHORT_SIZEDARR=WORD_SIZEDARR -_SHUFFLE_FILE_DATA=SHUFFLE_FILE_DATA -_SID=SID -_SID_AND_ATTRIBUTES=SID_AND_ATTRIBUTES -_SID_AND_ATTRIBUTES_HASH=SID_AND_ATTRIBUTES_HASH -_SID_IDENTIFIER_AUTHORITY=SID_IDENTIFIER_AUTHORITY -_SID_NAME_USE=SID_NAME_USE -_SILOOBJECT_BASIC_INFORMATION=SILOOBJECT_BASIC_INFORMATION PSLIST_ENTRY=SLIST_ENTRY* -_SIP_CAP_SET_V2=SIP_CAP_SET_V2 -_SIP_CAP_SET_V3=SIP_CAP_SET_V3 -_SLIST_HEADER=SLIST_HEADER -_SOURCE_MEDIA_A=SOURCE_MEDIA_A -_SOURCE_MEDIA_W=SOURCE_MEDIA_W -_SPC_FINANCIAL_CRITERIA=SPC_FINANCIAL_CRITERIA -_SPC_IMAGE=SPC_IMAGE -_SPC_INDIRECT_DATA_CONTENT=SPC_INDIRECT_DATA_CONTENT -_SPC_PE_IMAGE_DATA=SPC_PE_IMAGE_DATA -_SPC_SERIALIZED_OBJECT=SPC_SERIALIZED_OBJECT -_SPC_SP_AGENCY_INFO=SPC_SP_AGENCY_INFO -_SPC_SP_OPUS_INFO=SPC_SP_OPUS_INFO -_SPC_STATEMENT_TYPE=SPC_STATEMENT_TYPE -_SP_ALTPLATFORM_INFO_V1=SP_ALTPLATFORM_INFO_V1 -_SP_ALTPLATFORM_INFO_V2=SP_ALTPLATFORM_INFO_V2 -_SP_ALTPLATFORM_INFO_V3=SP_ALTPLATFORM_INFO_V3 -_SP_BACKUP_QUEUE_PARAMS_V1_A=SP_BACKUP_QUEUE_PARAMS_V1_A -_SP_BACKUP_QUEUE_PARAMS_V1_W=SP_BACKUP_QUEUE_PARAMS_V1_W -_SP_BACKUP_QUEUE_PARAMS_V2_A=SP_BACKUP_QUEUE_PARAMS_V2_A -_SP_BACKUP_QUEUE_PARAMS_V2_W=SP_BACKUP_QUEUE_PARAMS_V2_W -_SP_CLASSIMAGELIST_DATA=SP_CLASSIMAGELIST_DATA -_SP_CLASSINSTALL_HEADER=SP_CLASSINSTALL_HEADER -_SP_DETECTDEVICE_PARAMS=SP_DETECTDEVICE_PARAMS -_SP_DEVICE_INTERFACE_DATA=SP_DEVICE_INTERFACE_DATA -_SP_DEVICE_INTERFACE_DETAIL_DATA_A=SP_DEVICE_INTERFACE_DETAIL_DATA_A -_SP_DEVICE_INTERFACE_DETAIL_DATA_W=SP_DEVICE_INTERFACE_DETAIL_DATA_W -_SP_DEVINFO_DATA=SP_DEVINFO_DATA -_SP_DEVINFO_LIST_DETAIL_DATA_A=SP_DEVINFO_LIST_DETAIL_DATA_A -_SP_DEVINFO_LIST_DETAIL_DATA_W=SP_DEVINFO_LIST_DETAIL_DATA_W -_SP_DEVINSTALL_PARAMS_A=SP_DEVINSTALL_PARAMS_A -_SP_DEVINSTALL_PARAMS_W=SP_DEVINSTALL_PARAMS_W -_SP_DRVINFO_DATA_V1_A=SP_DRVINFO_DATA_V1_A -_SP_DRVINFO_DATA_V1_W=SP_DRVINFO_DATA_V1_W -_SP_DRVINFO_DATA_V2_A=SP_DRVINFO_DATA_V2_A -_SP_DRVINFO_DATA_V2_W=SP_DRVINFO_DATA_V2_W -_SP_DRVINFO_DETAIL_DATA_A=SP_DRVINFO_DETAIL_DATA_A -_SP_DRVINFO_DETAIL_DATA_W=SP_DRVINFO_DETAIL_DATA_W -_SP_DRVINSTALL_PARAMS=SP_DRVINSTALL_PARAMS -_SP_ENABLECLASS_PARAMS=SP_ENABLECLASS_PARAMS -_SP_FILE_COPY_PARAMS_A=SP_FILE_COPY_PARAMS_A -_SP_FILE_COPY_PARAMS_W=SP_FILE_COPY_PARAMS_W -_SP_INF_INFORMATION=SP_INF_INFORMATION -_SP_INF_SIGNER_INFO_V1_A=SP_INF_SIGNER_INFO_V1_A -_SP_INF_SIGNER_INFO_V1_W=SP_INF_SIGNER_INFO_V1_W -_SP_INF_SIGNER_INFO_V2_A=SP_INF_SIGNER_INFO_V2_A -_SP_INF_SIGNER_INFO_V2_W=SP_INF_SIGNER_INFO_V2_W -_SP_INSTALLWIZARD_DATA=SP_INSTALLWIZARD_DATA -_SP_NEWDEVICEWIZARD_DATA=SP_NEWDEVICEWIZARD_DATA -_SP_ORIGINAL_FILE_INFO_A=SP_ORIGINAL_FILE_INFO_A -_SP_ORIGINAL_FILE_INFO_W=SP_ORIGINAL_FILE_INFO_W -_SP_POWERMESSAGEWAKE_PARAMS_A=SP_POWERMESSAGEWAKE_PARAMS_A -_SP_POWERMESSAGEWAKE_PARAMS_W=SP_POWERMESSAGEWAKE_PARAMS_W -_SP_PROPCHANGE_PARAMS=SP_PROPCHANGE_PARAMS -_SP_PROPSHEETPAGE_REQUEST=SP_PROPSHEETPAGE_REQUEST -_SP_REGISTER_CONTROL_STATUSA=SP_REGISTER_CONTROL_STATUSA -_SP_REGISTER_CONTROL_STATUSW=SP_REGISTER_CONTROL_STATUSW -_SP_REMOVEDEVICE_PARAMS=SP_REMOVEDEVICE_PARAMS -_SP_SELECTDEVICE_PARAMS_A=SP_SELECTDEVICE_PARAMS_A -_SP_SELECTDEVICE_PARAMS_W=SP_SELECTDEVICE_PARAMS_W -_SP_TROUBLESHOOTER_PARAMS_A=SP_TROUBLESHOOTER_PARAMS_A -_SP_TROUBLESHOOTER_PARAMS_W=SP_TROUBLESHOOTER_PARAMS_W -_SP_UNREMOVEDEVICE_PARAMS=SP_UNREMOVEDEVICE_PARAMS -_SSL_F12_EXTRA_CERT_CHAIN_POLICY_STATUS=SSL_F12_EXTRA_CERT_CHAIN_POLICY_STATUS -_SSL_HPKP_HEADER_EXTRA_CERT_CHAIN_POLICY_PARA=SSL_HPKP_HEADER_EXTRA_CERT_CHAIN_POLICY_PARA -_SSL_KEY_PIN_EXTRA_CERT_CHAIN_POLICY_PARA=SSL_KEY_PIN_EXTRA_CERT_CHAIN_POLICY_PARA -_SSL_KEY_PIN_EXTRA_CERT_CHAIN_POLICY_STATUS=SSL_KEY_PIN_EXTRA_CERT_CHAIN_POLICY_STATUS -_STARTUPINFOA=STARTUPINFOA -_STARTUPINFOEXA=STARTUPINFOEXA -_STARTUPINFOEXW=STARTUPINFOEXW -_STARTUPINFOW=STARTUPINFOW -_STREAM_INFO_LEVELS=STREAM_INFO_LEVELS -_SUPPORTED_OS_INFO=SUPPORTED_OS_INFO -_SYSTEMTIME=SYSTEMTIME -_SYSTEM_ACCESS_FILTER_ACE=SYSTEM_ACCESS_FILTER_ACE -_SYSTEM_ALARM_ACE=SYSTEM_ALARM_ACE -_SYSTEM_ALARM_CALLBACK_ACE=SYSTEM_ALARM_CALLBACK_ACE -_SYSTEM_ALARM_CALLBACK_OBJECT_ACE=SYSTEM_ALARM_CALLBACK_OBJECT_ACE -_SYSTEM_ALARM_OBJECT_ACE=SYSTEM_ALARM_OBJECT_ACE -_SYSTEM_AUDIT_ACE=SYSTEM_AUDIT_ACE -_SYSTEM_AUDIT_CALLBACK_ACE=SYSTEM_AUDIT_CALLBACK_ACE -_SYSTEM_AUDIT_CALLBACK_OBJECT_ACE=SYSTEM_AUDIT_CALLBACK_OBJECT_ACE -_SYSTEM_AUDIT_OBJECT_ACE=SYSTEM_AUDIT_OBJECT_ACE -_SYSTEM_CPU_SET_INFORMATION=SYSTEM_CPU_SET_INFORMATION -_SYSTEM_INFO=SYSTEM_INFO -_SYSTEM_LOGICAL_PROCESSOR_INFORMATION=SYSTEM_LOGICAL_PROCESSOR_INFORMATION -_SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX=SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX -_SYSTEM_MANDATORY_LABEL_ACE=SYSTEM_MANDATORY_LABEL_ACE -_SYSTEM_POWER_POLICY=SYSTEM_POWER_POLICY -_SYSTEM_POWER_STATE=SYSTEM_POWER_STATE -_SYSTEM_POWER_STATUS=SYSTEM_POWER_STATUS -_SYSTEM_PROCESSOR_CYCLE_TIME_INFORMATION=SYSTEM_PROCESSOR_CYCLE_TIME_INFORMATION -_SYSTEM_PROCESS_TRUST_LABEL_ACE=SYSTEM_PROCESS_TRUST_LABEL_ACE -_SYSTEM_RESOURCE_ATTRIBUTE_ACE=SYSTEM_RESOURCE_ATTRIBUTE_ACE -_SYSTEM_SCOPED_POLICY_ID_ACE=SYSTEM_SCOPED_POLICY_ID_ACE -_tagAUTHENTICATEINFO=AUTHENTICATEINFO -_tagBINDINFO=BINDINFO -_tagCODEBASEHOLD=CODEBASEHOLD -_tagDATAINFO=DATAINFO -_tagHIT_LOGGING_INFO=HIT_LOGGING_INFO -_tagINTERNETFEATURELIST=INTERNETFEATURELIST -_tagOIBDG_FLAGS=OIBDG_FLAGS -_tagPARSEACTION=PARSEACTION -_tagPI_FLAGS=PI_FLAGS -_tagpropertykey=PROPERTYKEY -_tagPROTOCOLDATA=PROTOCOLDATA -_tagPROTOCOLFILTERDATA=PROTOCOLFILTERDATA -_tagPROTOCOL_ARGUMENT=PROTOCOL_ARGUMENT -_tagPSUACTION=PSUACTION -_tagQUERYOPTION=QUERYOPTION -_tagRemBINDINFO=RemBINDINFO -_tagSOFTDISTINFO=SOFTDISTINFO -_tagStartParam=StartParam -_TAPE_CREATE_PARTITION=TAPE_CREATE_PARTITION -_TAPE_DRIVE_PROBLEM_TYPE=TAPE_DRIVE_PROBLEM_TYPE -_TAPE_ERASE=TAPE_ERASE -_TAPE_GET_DRIVE_PARAMETERS=TAPE_GET_DRIVE_PARAMETERS -_TAPE_GET_MEDIA_PARAMETERS=TAPE_GET_MEDIA_PARAMETERS -_TAPE_GET_POSITION=TAPE_GET_POSITION -_TAPE_PREPARE=TAPE_PREPARE -_TAPE_SET_DRIVE_PARAMETERS=TAPE_SET_DRIVE_PARAMETERS -_TAPE_SET_MEDIA_PARAMETERS=TAPE_SET_MEDIA_PARAMETERS -_TAPE_SET_POSITION=TAPE_SET_POSITION -_TAPE_WMI_OPERATIONS=TAPE_WMI_OPERATIONS -_TAPE_WRITE_MARKS=TAPE_WRITE_MARKS -_TEB=TEB -_THDTYPE=THDTYPE -_THREAD_INFORMATION_CLASS=THREAD_INFORMATION_CLASS -_THREAD_POWER_THROTTLING_STATE=THREAD_POWER_THROTTLING_STATE -_TOKEN_ACCESS_INFORMATION=TOKEN_ACCESS_INFORMATION -_TOKEN_APPCONTAINER_INFORMATION=TOKEN_APPCONTAINER_INFORMATION -_TOKEN_AUDIT_POLICY=TOKEN_AUDIT_POLICY -_TOKEN_BNO_ISOLATION_INFORMATION=TOKEN_BNO_ISOLATION_INFORMATION -_TOKEN_CONTROL=TOKEN_CONTROL -_TOKEN_DEFAULT_DACL=TOKEN_DEFAULT_DACL -_TOKEN_DEVICE_CLAIMS=TOKEN_DEVICE_CLAIMS -_TOKEN_ELEVATION=TOKEN_ELEVATION -_TOKEN_ELEVATION_TYPE=TOKEN_ELEVATION_TYPE -_TOKEN_GROUPS=TOKEN_GROUPS -_TOKEN_GROUPS_AND_PRIVILEGES=TOKEN_GROUPS_AND_PRIVILEGES -_TOKEN_INFORMATION_CLASS=TOKEN_INFORMATION_CLASS -_TOKEN_LINKED_TOKEN=TOKEN_LINKED_TOKEN -_TOKEN_MANDATORY_LABEL=TOKEN_MANDATORY_LABEL -_TOKEN_MANDATORY_POLICY=TOKEN_MANDATORY_POLICY -_TOKEN_ORIGIN=TOKEN_ORIGIN -_TOKEN_OWNER=TOKEN_OWNER -_TOKEN_PRIMARY_GROUP=TOKEN_PRIMARY_GROUP -_TOKEN_PRIVILEGES=TOKEN_PRIVILEGES -_TOKEN_SID_INFORMATION=TOKEN_SID_INFORMATION -_TOKEN_SOURCE=TOKEN_SOURCE -_TOKEN_STATISTICS=TOKEN_STATISTICS -_TOKEN_TYPE=TOKEN_TYPE -_TOKEN_USER=TOKEN_USER -_TOKEN_USER_CLAIMS=TOKEN_USER_CLAIMS -_TP_CALLBACK_ENVIRON_V3=TP_CALLBACK_ENVIRON_V3 -_TP_CALLBACK_PRIORITY=TP_CALLBACK_PRIORITY _TP_CLEANUP_GROUP*=IntPtr -_TP_POOL_STACK_INFORMATION=TP_POOL_STACK_INFORMATION -_TRACE_EVENT_INFO=TRACE_EVENT_INFO -_TRANSACTIONMANAGER_BASIC_INFORMATION=TRANSACTIONMANAGER_BASIC_INFORMATION -_TRANSACTIONMANAGER_INFORMATION_CLASS=TRANSACTIONMANAGER_INFORMATION_CLASS -_TRANSACTIONMANAGER_LOGPATH_INFORMATION=TRANSACTIONMANAGER_LOGPATH_INFORMATION -_TRANSACTIONMANAGER_LOG_INFORMATION=TRANSACTIONMANAGER_LOG_INFORMATION -_TRANSACTIONMANAGER_OLDEST_INFORMATION=TRANSACTIONMANAGER_OLDEST_INFORMATION -_TRANSACTIONMANAGER_RECOVERY_INFORMATION=TRANSACTIONMANAGER_RECOVERY_INFORMATION -_TRANSACTION_BASIC_INFORMATION=TRANSACTION_BASIC_INFORMATION -_TRANSACTION_BIND_INFORMATION=TRANSACTION_BIND_INFORMATION -_TRANSACTION_ENLISTMENTS_INFORMATION=TRANSACTION_ENLISTMENTS_INFORMATION -_TRANSACTION_ENLISTMENT_PAIR=TRANSACTION_ENLISTMENT_PAIR -_TRANSACTION_INFORMATION_CLASS=TRANSACTION_INFORMATION_CLASS -_TRANSACTION_LIST_ENTRY=TRANSACTION_LIST_ENTRY -_TRANSACTION_LIST_INFORMATION=TRANSACTION_LIST_INFORMATION -_TRANSACTION_OUTCOME=TRANSACTION_OUTCOME -_TRANSACTION_PROPERTIES_INFORMATION=TRANSACTION_PROPERTIES_INFORMATION -_TRANSACTION_STATE=TRANSACTION_STATE -_TRANSACTION_SUPERIOR_ENLISTMENT_INFORMATION=TRANSACTION_SUPERIOR_ENLISTMENT_INFORMATION -_TRIVERTEX=TRIVERTEX _ULARGE_INTEGER=ulong -_UMS_CREATE_THREAD_ATTRIBUTES=UMS_CREATE_THREAD_ATTRIBUTES -_UMS_SCHEDULER_STARTUP_INFO=UMS_SCHEDULER_STARTUP_INFO -_UMS_SYSTEM_THREAD_INFORMATION=UMS_SYSTEM_THREAD_INFORMATION -_UNLOAD_DLL_DEBUG_INFO=UNLOAD_DLL_DEBUG_INFO -_URLZONEREG=URLZONEREG -_USAGE_AND_PAGE=USAGE_AND_PAGE -_userBITMAP=userBITMAP _userCLIPFORMAT::__MIDL_IWinTypes_0001=_u_e__Struct -_userCLIPFORMAT=userCLIPFORMAT -_userFLAG_STGMEDIUM=userFLAG_STGMEDIUM _userHBITMAP::__MIDL_IWinTypes_0007=_u_e__Struct -_userHBITMAP=userHBITMAP _userHENHMETAFILE::__MIDL_IWinTypes_0006=_u_e__Struct -_userHENHMETAFILE=userHENHMETAFILE _userHGLOBAL::__MIDL_IWinTypes_0003=_u_e__Struct -_userHGLOBAL=userHGLOBAL _userHMETAFILE::__MIDL_IWinTypes_0004=_u_e__Struct -_userHMETAFILE=userHMETAFILE _userHMETAFILEPICT::__MIDL_IWinTypes_0005=_u_e__Struct -_userHMETAFILEPICT=userHMETAFILEPICT _userHPALETTE::__MIDL_IWinTypes_0008=_u_e__Struct -_userHPALETTE=userHPALETTE _userSTGMEDIUM::_STGMEDIUM_UNION::__MIDL_IAdviseSink_0003=_u_e__Struct -_userSTGMEDIUM=userSTGMEDIUM -_USER_ACTIVITY_PRESENCE=USER_ACTIVITY_PRESENCE -_VIDEOPARAMETERS=VIDEOPARAMETERS -_WGLSWAP=WGLSWAP -_WIN32_FILE_ATTRIBUTE_DATA=WIN32_FILE_ATTRIBUTE_DATA -_WIN32_FIND_DATAA=WIN32_FIND_DATAA -_WIN32_FIND_DATAW=WIN32_FIND_DATAW -_WIN32_FIND_STREAM_DATA=WIN32_FIND_STREAM_DATA -_WIN32_STREAM_ID=WIN32_STREAM_ID -_WINTRUST_DATA=WINTRUST_DATA -_WIN_CERTIFICATE=WIN_CERTIFICATE -_WIN_SPUB_TRUSTED_PUBLISHER_DATA=WIN_SPUB_TRUSTED_PUBLISHER_DATA -_WIN_TRUST_ACTDATA_CONTEXT_WITH_SUBJECT=WIN_TRUST_ACTDATA_CONTEXT_WITH_SUBJECT -_WIN_TRUST_ACTDATA_SUBJECT_ONLY=WIN_TRUST_ACTDATA_SUBJECT_ONLY -_WIN_TRUST_SUBJECT_FILE=WIN_TRUST_SUBJECT_FILE -_WIN_TRUST_SUBJECT_FILE_AND_DISPLAY=WIN_TRUST_SUBJECT_FILE_AND_DISPLAY _wireSAFEARRAY_UNION::__MIDL_IOleAutomationTypes_0001=_u_e__Struct -_WORD_BLOB=WORD_BLOB _WOW64_ARCHITECTURE_INFORMATION=WOW64_ARCHITECTURE_INFORMATION -_WOW64_CONTEXT=WOW64_CONTEXT -_WOW64_DESCRIPTOR_TABLE_ENTRY=WOW64_DESCRIPTOR_TABLE_ENTRY -_WOW64_FLOATING_SAVE_AREA=WOW64_FLOATING_SAVE_AREA -_WOW64_LDT_ENTRY=WOW64_LDT_ENTRY -_WTD_GENERIC_CHAIN_POLICY_CREATE_INFO=WTD_GENERIC_CHAIN_POLICY_CREATE_INFO -_WTD_GENERIC_CHAIN_POLICY_DATA=WTD_GENERIC_CHAIN_POLICY_DATA -_WTD_GENERIC_CHAIN_POLICY_SIGNER_INFO=WTD_GENERIC_CHAIN_POLICY_SIGNER_INFO -_XINPUT_BATTERY_INFORMATION=XINPUT_BATTERY_INFORMATION -_XINPUT_CAPABILITIES=XINPUT_CAPABILITIES -_XINPUT_GAMEPAD=XINPUT_GAMEPAD -_XINPUT_KEYSTROKE=XINPUT_KEYSTROKE -_XINPUT_STATE=XINPUT_STATE -_XINPUT_VIBRATION=XINPUT_VIBRATION -_xml_error=XML_ERROR -_XSAVE_AREA=XSAVE_AREA -_XSAVE_AREA_HEADER=XSAVE_AREA_HEADER -_XSAVE_CET_U_FORMAT=XSAVE_CET_U_FORMAT -_XSAVE_FORMAT=XSAVE_FORMAT -_XSTATE_CONFIGURATION=XSTATE_CONFIGURATION -_XSTATE_CONTEXT=XSTATE_CONTEXT -_XSTATE_FEATURE=XSTATE_FEATURE -_ZONEATTRIBUTES=ZONEATTRIBUTES __AnonymousBase_dwrite_1_L627_C38=Base __AnonymousBase_dwrite_2_L67_C31=Base __AnonymousBase_dwrite_3_L1623_C31=Base @@ -1822,24 +267,7 @@ __AnonymousBase_WinUser_L13558_C43=Base __AnonymousEnum_d2d1_L89_C1=D2D1_INTERPOLATION_MODE_DEFINITION __MIDL_IAdviseSink_0002=_u_e__Struct __MIDL_IAdviseSink_0003=_u_e__Struct -__MIDL_IAuthenticateEx_0001=AUTHENTICATEF -__MIDL_IBindStatusCallbackEx_0001=BINDF2 -__MIDL_IBindStatusCallback_0001=BINDVERB -__MIDL_IBindStatusCallback_0002=BINDINFOF -__MIDL_IBindStatusCallback_0003=BINDF -__MIDL_IBindStatusCallback_0004=URL_ENCODING -__MIDL_IBindStatusCallback_0005=BINDINFO_OPTIONS -__MIDL_IBindStatusCallback_0006=BSCF -__MIDL_ICodeInstall_0001=CIP_STATUS -__MIDL_IGetBindHandle_0001=BINDHANDLETYPES -__MIDL_IInternetSecurityManager_0001=PUAF -__MIDL_IInternetSecurityManager_0002=PUAFOUT -__MIDL_IInternetSecurityManager_0003=SZM_FLAGS -__MIDL_IInternetZoneManager_0002=ZAFLAGS -__MIDL_IMonikerProp_0001=MONIKERPROPERTY __MIDL_IOleAutomationTypes_0001=_u_e__Struct -__MIDL_IUri_0001=Uri_PROPERTY -__MIDL_IUri_0002=Uri_HOST_TYPE __MIDL_IWinTypes_0001=_u_e__Struct __MIDL_IWinTypes_0002=_u_e__Struct __MIDL_IWinTypes_0003=_u_e__Struct @@ -1852,7695 +280,33 @@ __MIDL_IWinTypes_0009=_u_e__Struct __MIDL___MIDL_itf_d3d11_0000_0034_0001=_Flags_e__Struct __MIDL___MIDL_itf_documenttarget_0000_0001_0001=PrintDocumentPackageStatus __MIDL___MIDL_itf_wtypes_0000_0001_0001::__MIDL___MIDL_itf_wtypes_0000_0001_0005=_tagged_union_e__Struct -__MIDL___MIDL_itf_wtypes_0000_0001_0001=uCLSSPEC __MIDL___MIDL_itf_wtypes_0000_0001_0005=_tagged_union_e__Struct -_EXCEPTION_REGISTRATION_RECORD=EXCEPTION_REGISTRATION_RECORD -_NT_TIB=NT_TIB -_TRANSACTION_NOTIFICATION=TRANSACTION_NOTIFICATION -_TRANSACTION_NOTIFICATION_RECOVERY_ARGUMENT=TRANSACTION_NOTIFICATION_RECOVERY_ARGUMENT -_TRANSACTION_NOTIFICATION_TM_ONLINE_ARGUMENT=TRANSACTION_NOTIFICATION_TM_ONLINE_ARGUMENT -_TRANSACTION_NOTIFICATION_SAVEPOINT_ARGUMENT=TRANSACTION_NOTIFICATION_SAVEPOINT_ARGUMENT -_TRANSACTION_NOTIFICATION_PROPAGATE_ARGUMENT=TRANSACTION_NOTIFICATION_PROPAGATE_ARGUMENT -_TRANSACTION_NOTIFICATION_MARSHAL_ARGUMENT=TRANSACTION_NOTIFICATION_MARSHAL_ARGUMENT -_KCRM_MARSHAL_HEADER=KCRM_MARSHAL_HEADER -_KCRM_TRANSACTION_BLOB=KCRM_TRANSACTION_BLOB -_KCRM_PROTOCOL_BLOB=KCRM_PROTOCOL_BLOB -_MEMORY_RESOURCE_NOTIFICATION_TYPE=MEMORY_RESOURCE_NOTIFICATION_TYPE -_WIN32_MEMORY_RANGE_ENTRY=WIN32_MEMORY_RANGE_ENTRY -_TIME_ZONE_INFORMATION=TIME_ZONE_INFORMATION -_NORM_FORM=NORM_FORM -_FILEMUIINFO=FILEMUIINFO -_COORD=COORD -_SMALL_RECT=SMALL_RECT -_KEY_EVENT_RECORD=KEY_EVENT_RECORD -_MOUSE_EVENT_RECORD=MOUSE_EVENT_RECORD -_WINDOW_BUFFER_SIZE_RECORD=WINDOW_BUFFER_SIZE_RECORD -_MENU_EVENT_RECORD=MENU_EVENT_RECORD -_FOCUS_EVENT_RECORD=FOCUS_EVENT_RECORD -_INPUT_RECORD=INPUT_RECORD -_CHAR_INFO=CHAR_INFO -_CONSOLE_FONT_INFO=CONSOLE_FONT_INFO -_CONSOLE_READCONSOLE_CONTROL=CONSOLE_READCONSOLE_CONTROL -_CONSOLE_CURSOR_INFO=CONSOLE_CURSOR_INFO -_CONSOLE_SCREEN_BUFFER_INFO=CONSOLE_SCREEN_BUFFER_INFO -_CONSOLE_SCREEN_BUFFER_INFOEX=CONSOLE_SCREEN_BUFFER_INFOEX -_CONSOLE_FONT_INFOEX=CONSOLE_FONT_INFOEX -_CONSOLE_SELECTION_INFO=CONSOLE_SELECTION_INFO -_CONSOLE_HISTORY_INFO=CONSOLE_HISTORY_INFO -_NETRESOURCEA=NETRESOURCEA -_NETRESOURCEW=NETRESOURCEW -_CONNECTDLGSTRUCTA=CONNECTDLGSTRUCTA -_CONNECTDLGSTRUCTW=CONNECTDLGSTRUCTW -_DISCDLGSTRUCTA=DISCDLGSTRUCTA -_DISCDLGSTRUCTW=DISCDLGSTRUCTW -_UNIVERSAL_NAME_INFOA=UNIVERSAL_NAME_INFOA -_UNIVERSAL_NAME_INFOW=UNIVERSAL_NAME_INFOW -_REMOTE_NAME_INFOA=REMOTE_NAME_INFOA -_REMOTE_NAME_INFOW=REMOTE_NAME_INFOW -_NETINFOSTRUCT=NETINFOSTRUCT -_NETCONNECTINFOSTRUCT=NETCONNECTINFOSTRUCT -_MMIOINFO=MMIOINFO -_MMCKINFO=MMCKINFO -_NCB=NCB -_ADAPTER_STATUS=ADAPTER_STATUS -_NAME_BUFFER=NAME_BUFFER -_SESSION_HEADER=SESSION_HEADER -_SESSION_BUFFER=SESSION_BUFFER -_LANA_ENUM=LANA_ENUM -_FIND_NAME_HEADER=FIND_NAME_HEADER -_FIND_NAME_BUFFER=FIND_NAME_BUFFER -_ACTION_HEADER=ACTION_HEADER -_RPC_BINDING_VECTOR=RPC_BINDING_VECTOR -_UUID_VECTOR=UUID_VECTOR -_RPC_IF_ID=RPC_IF_ID -_RPC_PROTSEQ_VECTORA=RPC_PROTSEQ_VECTORA -_RPC_PROTSEQ_VECTORW=RPC_PROTSEQ_VECTORW -_RPC_POLICY=RPC_POLICY -_RPC_SECURITY_QOS=RPC_SECURITY_QOS -_SEC_WINNT_AUTH_IDENTITY_W=SEC_WINNT_AUTH_IDENTITY_W -_SEC_WINNT_AUTH_IDENTITY_A=SEC_WINNT_AUTH_IDENTITY_A -_RPC_HTTP_TRANSPORT_CREDENTIALS_W=RPC_HTTP_TRANSPORT_CREDENTIALS_W -_RPC_HTTP_TRANSPORT_CREDENTIALS_A=RPC_HTTP_TRANSPORT_CREDENTIALS_A -_RPC_HTTP_TRANSPORT_CREDENTIALS_V2_W=RPC_HTTP_TRANSPORT_CREDENTIALS_V2_W -_RPC_HTTP_TRANSPORT_CREDENTIALS_V2_A=RPC_HTTP_TRANSPORT_CREDENTIALS_V2_A -_RPC_HTTP_TRANSPORT_CREDENTIALS_V3_W=RPC_HTTP_TRANSPORT_CREDENTIALS_V3_W -_RPC_HTTP_TRANSPORT_CREDENTIALS_V3_A=RPC_HTTP_TRANSPORT_CREDENTIALS_V3_A -_RPC_SECURITY_QOS_V2_W=RPC_SECURITY_QOS_V2_W -_RPC_SECURITY_QOS_V2_A=RPC_SECURITY_QOS_V2_A -_RPC_SECURITY_QOS_V3_W=RPC_SECURITY_QOS_V3_W -_RPC_SECURITY_QOS_V3_A=RPC_SECURITY_QOS_V3_A -_RPC_SECURITY_QOS_V4_W=RPC_SECURITY_QOS_V4_W -_RPC_SECURITY_QOS_V4_A=RPC_SECURITY_QOS_V4_A -_RPC_SECURITY_QOS_V5_W=RPC_SECURITY_QOS_V5_W -_RPC_SECURITY_QOS_V5_A=RPC_SECURITY_QOS_V5_A -_RPC_BINDING_HANDLE_TEMPLATE_V1_W=RPC_BINDING_HANDLE_TEMPLATE_V1_W -_RPC_BINDING_HANDLE_TEMPLATE_V1_A=RPC_BINDING_HANDLE_TEMPLATE_V1_A -_RPC_BINDING_HANDLE_SECURITY_V1_W=RPC_BINDING_HANDLE_SECURITY_V1_W -_RPC_BINDING_HANDLE_SECURITY_V1_A=RPC_BINDING_HANDLE_SECURITY_V1_A -_RPC_BINDING_HANDLE_OPTIONS_V1=RPC_BINDING_HANDLE_OPTIONS_V1 -_RPC_HTTP_REDIRECTOR_STAGE=RPC_HTTP_REDIRECTOR_STAGE -_RPC_VERSION=RPC_VERSION -_RPC_SYNTAX_IDENTIFIER=RPC_SYNTAX_IDENTIFIER -_RPC_MESSAGE=RPC_MESSAGE -_RPC_PROTSEQ_ENDPOINT=RPC_PROTSEQ_ENDPOINT -_RPC_SERVER_INTERFACE=RPC_SERVER_INTERFACE -_RPC_CLIENT_INTERFACE=RPC_CLIENT_INTERFACE -_LRPC_SYSTEM_HANDLE_MARSHAL_DIRECTION=LRPC_SYSTEM_HANDLE_MARSHAL_DIRECTION -_RPC_SEC_CONTEXT_KEY_INFO=RPC_SEC_CONTEXT_KEY_INFO -_RPC_TRANSFER_SYNTAX=RPC_TRANSFER_SYNTAX -_RPC_C_OPT_COOKIE_AUTH_DESCRIPTOR=RPC_C_OPT_COOKIE_AUTH_DESCRIPTOR -_RDR_CALLOUT_STATE=RDR_CALLOUT_STATE -_RPC_NOTIFICATION_TYPES=RPC_NOTIFICATION_TYPES -_RPC_ASYNC_EVENT=RPC_ASYNC_EVENT -_RPC_ASYNC_NOTIFICATION_INFO=RPC_ASYNC_NOTIFICATION_INFO -_RPC_ASYNC_STATE=RPC_ASYNC_STATE -_RPC_CALL_LOCAL_ADDRESS_V1=RPC_CALL_LOCAL_ADDRESS_V1 -_RPC_NOTIFICATIONS=RPC_NOTIFICATIONS -_DRAGINFOA=DRAGINFOA -_DRAGINFOW=DRAGINFOW -_SHFILEOPSTRUCTA=SHFILEOPSTRUCTA -_SHFILEOPSTRUCTW=SHFILEOPSTRUCTW -_SHNAMEMAPPINGA=SHNAMEMAPPINGA -_SHNAMEMAPPINGW=SHNAMEMAPPINGW -_SHELLEXECUTEINFOA=SHELLEXECUTEINFOA -_SHELLEXECUTEINFOW=SHELLEXECUTEINFOW -_SHCREATEPROCESSINFOW=SHCREATEPROCESSINFOW -_SHQUERYRBINFO=SHQUERYRBINFO -_NOTIFYICONDATAA=NOTIFYICONDATAA -_NOTIFYICONDATAW=NOTIFYICONDATAW -_NOTIFYICONIDENTIFIER=NOTIFYICONIDENTIFIER -_SHFILEINFOA=SHFILEINFOA -_SHFILEINFOW=SHFILEINFOW -_SHSTOCKICONINFO=SHSTOCKICONINFO -_OPEN_PRINTER_PROPS_INFOA=OPEN_PRINTER_PROPS_INFOA -_OPEN_PRINTER_PROPS_INFOW=OPEN_PRINTER_PROPS_INFOW -_PERF_DATA_BLOCK=PERF_DATA_BLOCK -_PERF_OBJECT_TYPE=PERF_OBJECT_TYPE -_PERF_COUNTER_DEFINITION=PERF_COUNTER_DEFINITION -_PERF_INSTANCE_DEFINITION=PERF_INSTANCE_DEFINITION -_PERF_COUNTER_BLOCK=PERF_COUNTER_BLOCK -_BCRYPT_OID=BCRYPT_OID -_BCRYPT_OID_LIST=BCRYPT_OID_LIST -_BCRYPT_PKCS1_PADDING_INFO=BCRYPT_PKCS1_PADDING_INFO -_BCRYPT_PSS_PADDING_INFO=BCRYPT_PSS_PADDING_INFO -_BCRYPT_OAEP_PADDING_INFO=BCRYPT_OAEP_PADDING_INFO -_BCRYPT_AUTHENTICATED_CIPHER_MODE_INFO=BCRYPT_AUTHENTICATED_CIPHER_MODE_INFO -_BCryptBuffer=BCryptBuffer -_BCryptBufferDesc=BCryptBufferDesc -_BCRYPT_KEY_BLOB=BCRYPT_KEY_BLOB -_BCRYPT_RSAKEY_BLOB=BCRYPT_RSAKEY_BLOB -_BCRYPT_ECCKEY_BLOB=BCRYPT_ECCKEY_BLOB -_SSL_ECCKEY_BLOB=SSL_ECCKEY_BLOB -_BCRYPT_ECCFULLKEY_BLOB=BCRYPT_ECCFULLKEY_BLOB -_BCRYPT_DH_KEY_BLOB=BCRYPT_DH_KEY_BLOB -_BCRYPT_DH_PARAMETER_HEADER=BCRYPT_DH_PARAMETER_HEADER -_BCRYPT_DSA_KEY_BLOB=BCRYPT_DSA_KEY_BLOB -_BCRYPT_DSA_KEY_BLOB_V2=BCRYPT_DSA_KEY_BLOB_V2 -_BCRYPT_KEY_DATA_BLOB_HEADER=BCRYPT_KEY_DATA_BLOB_HEADER -_BCRYPT_DSA_PARAMETER_HEADER=BCRYPT_DSA_PARAMETER_HEADER -_BCRYPT_DSA_PARAMETER_HEADER_V2=BCRYPT_DSA_PARAMETER_HEADER_V2 -_BCRYPT_ECC_CURVE_NAMES=BCRYPT_ECC_CURVE_NAMES -_BCRYPT_MULTI_HASH_OPERATION=BCRYPT_MULTI_HASH_OPERATION -_BCRYPT_MULTI_OBJECT_LENGTH_STRUCT=BCRYPT_MULTI_OBJECT_LENGTH_STRUCT -_BCRYPT_ALGORITHM_IDENTIFIER=BCRYPT_ALGORITHM_IDENTIFIER -_BCRYPT_PROVIDER_NAME=BCRYPT_PROVIDER_NAME -_BCRYPT_INTERFACE_VERSION=BCRYPT_INTERFACE_VERSION -_CRYPT_INTERFACE_REG=CRYPT_INTERFACE_REG -_CRYPT_IMAGE_REG=CRYPT_IMAGE_REG -_CRYPT_PROVIDER_REG=CRYPT_PROVIDER_REG -_CRYPT_PROVIDERS=CRYPT_PROVIDERS -_CRYPT_CONTEXT_CONFIG=CRYPT_CONTEXT_CONFIG -_CRYPT_CONTEXT_FUNCTION_CONFIG=CRYPT_CONTEXT_FUNCTION_CONFIG -_CRYPT_CONTEXTS=CRYPT_CONTEXTS -_CRYPT_CONTEXT_FUNCTIONS=CRYPT_CONTEXT_FUNCTIONS -_CRYPT_CONTEXT_FUNCTION_PROVIDERS=CRYPT_CONTEXT_FUNCTION_PROVIDERS -_CRYPT_PROPERTY_REF=CRYPT_PROPERTY_REF -_CRYPT_IMAGE_REF=CRYPT_IMAGE_REF -_CRYPT_PROVIDER_REF=CRYPT_PROVIDER_REF -_CRYPT_PROVIDER_REFS=CRYPT_PROVIDER_REFS -_NCRYPT_CIPHER_PADDING_INFO=NCRYPT_CIPHER_PADDING_INFO -_NCRYPT_PLATFORM_ATTEST_PADDING_INFO=NCRYPT_PLATFORM_ATTEST_PADDING_INFO -_NCRYPT_KEY_ATTEST_PADDING_INFO=NCRYPT_KEY_ATTEST_PADDING_INFO -_NCRYPT_ISOLATED_KEY_ATTESTED_ATTRIBUTES=NCRYPT_ISOLATED_KEY_ATTESTED_ATTRIBUTES _NCRYPT_VSM_KEY_ATTESTATION_STATEMENT=NCRYPT_VSM_KEY_ATTESTATION_STATEMENT _NCRYPT_VSM_KEY_ATTESTATION_CLAIM_RESTRICTIONS=NCRYPT_VSM_KEY_ATTESTATION_CLAIM_RESTRICTIONS -_NCRYPT_EXPORTED_ISOLATED_KEY_HEADER=NCRYPT_EXPORTED_ISOLATED_KEY_HEADER -_NCRYPT_EXPORTED_ISOLATED_KEY_ENVELOPE=NCRYPT_EXPORTED_ISOLATED_KEY_ENVELOPE -_NCRYPT_TPM_PLATFORM_ATTESTATION_STATEMENT=NCRYPT_TPM_PLATFORM_ATTESTATION_STATEMENT -_NCryptAlgorithmName=NCryptAlgorithmName -_NCRYPT_KEY_BLOB_HEADER=NCRYPT_KEY_BLOB_HEADER -_CRYPTPROTECT_PROMPTSTRUCT=CRYPTPROTECT_PROMPTSTRUCT -_EFS_HASH_BLOB=EFS_HASH_BLOB -_EFS_RPC_BLOB=EFS_RPC_BLOB -_EFS_PIN_BLOB=EFS_PIN_BLOB -_EFS_KEY_INFO=EFS_KEY_INFO -_EFS_COMPATIBILITY_INFO=EFS_COMPATIBILITY_INFO -_EFS_VERSION_INFO=EFS_VERSION_INFO -_EFS_DECRYPTION_STATUS_INFO=EFS_DECRYPTION_STATUS_INFO -_EFS_ENCRYPTION_STATUS_INFO=EFS_ENCRYPTION_STATUS_INFO -_ENCRYPTION_CERTIFICATE=ENCRYPTION_CERTIFICATE -_ENCRYPTION_CERTIFICATE_HASH=ENCRYPTION_CERTIFICATE_HASH -_ENCRYPTION_CERTIFICATE_HASH_LIST=ENCRYPTION_CERTIFICATE_HASH_LIST -_ENCRYPTION_CERTIFICATE_LIST=ENCRYPTION_CERTIFICATE_LIST -_ENCRYPTED_FILE_METADATA_SIGNATURE=ENCRYPTED_FILE_METADATA_SIGNATURE -_ENCRYPTION_PROTECTOR=ENCRYPTION_PROTECTOR -_ENCRYPTION_PROTECTOR_LIST=ENCRYPTION_PROTECTOR_LIST -_SCONTEXT_QUEUE=SCONTEXT_QUEUE -_MIDL_SYNTAX_INFO=MIDL_SYNTAX_INFO -_GENERIC_BINDING_ROUTINE_PAIR=GENERIC_BINDING_ROUTINE_PAIR -_XMIT_ROUTINE_QUINTUPLE=XMIT_ROUTINE_QUINTUPLE -_USER_MARSHAL_ROUTINE_QUADRUPLE=USER_MARSHAL_ROUTINE_QUADRUPLE -_USER_MARSHAL_CB_TYPE=USER_MARSHAL_CB_TYPE -_USER_MARSHAL_CB=USER_MARSHAL_CB -_MALLOC_FREE_STRUCT=MALLOC_FREE_STRUCT -_COMM_FAULT_OFFSETS=COMM_FAULT_OFFSETS -_IDL_CS_CONVERT=IDL_CS_CONVERT -_NDR_CS_SIZE_CONVERT_ROUTINES=NDR_CS_SIZE_CONVERT_ROUTINES -_NDR_CS_ROUTINES=NDR_CS_ROUTINES -_NDR_EXPR_DESC=NDR_EXPR_DESC -_MIDL_STUB_DESC=MIDL_STUB_DESC -_MIDL_FORMAT_STRING=MIDL_FORMAT_STRING -_MIDL_METHOD_PROPERTY=MIDL_METHOD_PROPERTY -_MIDL_METHOD_PROPERTY_MAP=MIDL_METHOD_PROPERTY_MAP -_MIDL_INTERFACE_METHOD_PROPERTIES=MIDL_INTERFACE_METHOD_PROPERTIES -_MIDL_STUBLESS_PROXY_INFO=MIDL_STUBLESS_PROXY_INFO -_CLIENT_CALL_RETURN=CLIENT_CALL_RETURN -_FULL_PTR_XLAT_TABLES=FULL_PTR_XLAT_TABLES -_system_handle_t=system_handle_t -_MIDL_INTERCEPTION_INFO=MIDL_INTERCEPTION_INFO -_MIDL_WINRT_TYPE_SERIALIZATION_INFO=MIDL_WINRT_TYPE_SERIALIZATION_INFO -_NDR_USER_MARSHAL_INFO_LEVEL1=NDR_USER_MARSHAL_INFO_LEVEL1 -_NDR_USER_MARSHAL_INFO=NDR_USER_MARSHAL_INFO -_STORAGE_HOTPLUG_INFO=STORAGE_HOTPLUG_INFO -_STORAGE_DEVICE_NUMBER=STORAGE_DEVICE_NUMBER -_STORAGE_DEVICE_NUMBERS=STORAGE_DEVICE_NUMBERS -_STORAGE_DEVICE_NUMBER_EX=STORAGE_DEVICE_NUMBER_EX -_STORAGE_BUS_RESET_REQUEST=STORAGE_BUS_RESET_REQUEST -_PREVENT_MEDIA_REMOVAL=PREVENT_MEDIA_REMOVAL -_CLASS_MEDIA_CHANGE_CONTEXT=CLASS_MEDIA_CHANGE_CONTEXT -_TAPE_STATISTICS=TAPE_STATISTICS -_TAPE_GET_STATISTICS=TAPE_GET_STATISTICS -_STORAGE_MEDIA_TYPE=STORAGE_MEDIA_TYPE -_STORAGE_BUS_TYPE=STORAGE_BUS_TYPE -_DEVICE_MEDIA_INFO=DEVICE_MEDIA_INFO -_GET_MEDIA_TYPES=GET_MEDIA_TYPES -_STORAGE_PREDICT_FAILURE=STORAGE_PREDICT_FAILURE -_STORAGE_FAILURE_PREDICTION_CONFIG=STORAGE_FAILURE_PREDICTION_CONFIG -_STORAGE_QUERY_TYPE=STORAGE_QUERY_TYPE -_STORAGE_SET_TYPE=STORAGE_SET_TYPE -_STORAGE_PROPERTY_ID=STORAGE_PROPERTY_ID -_STORAGE_PROPERTY_QUERY=STORAGE_PROPERTY_QUERY -_STORAGE_PROPERTY_SET=STORAGE_PROPERTY_SET -_STORAGE_DESCRIPTOR_HEADER=STORAGE_DESCRIPTOR_HEADER -_STORAGE_DEVICE_DESCRIPTOR=STORAGE_DEVICE_DESCRIPTOR -_STORAGE_ADAPTER_DESCRIPTOR=STORAGE_ADAPTER_DESCRIPTOR -_STORAGE_ACCESS_ALIGNMENT_DESCRIPTOR=STORAGE_ACCESS_ALIGNMENT_DESCRIPTOR -_STORAGE_MEDIUM_PRODUCT_TYPE_DESCRIPTOR=STORAGE_MEDIUM_PRODUCT_TYPE_DESCRIPTOR -_STORAGE_PORT_CODE_SET=STORAGE_PORT_CODE_SET -_STORAGE_MINIPORT_DESCRIPTOR=STORAGE_MINIPORT_DESCRIPTOR -_STORAGE_IDENTIFIER_CODE_SET=STORAGE_IDENTIFIER_CODE_SET -_STORAGE_IDENTIFIER_TYPE=STORAGE_IDENTIFIER_TYPE -_STORAGE_ID_NAA_FORMAT=STORAGE_ID_NAA_FORMAT -_STORAGE_ASSOCIATION_TYPE=STORAGE_ASSOCIATION_TYPE -_STORAGE_IDENTIFIER=STORAGE_IDENTIFIER -_STORAGE_DEVICE_ID_DESCRIPTOR=STORAGE_DEVICE_ID_DESCRIPTOR -_DEVICE_SEEK_PENALTY_DESCRIPTOR=DEVICE_SEEK_PENALTY_DESCRIPTOR -_DEVICE_WRITE_AGGREGATION_DESCRIPTOR=DEVICE_WRITE_AGGREGATION_DESCRIPTOR -_DEVICE_TRIM_DESCRIPTOR=DEVICE_TRIM_DESCRIPTOR -_DEVICE_LB_PROVISIONING_DESCRIPTOR=DEVICE_LB_PROVISIONING_DESCRIPTOR -_STORAGE_LB_PROVISIONING_MAP_RESOURCES=STORAGE_LB_PROVISIONING_MAP_RESOURCES -_DEVICE_POWER_DESCRIPTOR=DEVICE_POWER_DESCRIPTOR -_DEVICE_COPY_OFFLOAD_DESCRIPTOR=DEVICE_COPY_OFFLOAD_DESCRIPTOR -_STORAGE_DEVICE_RESILIENCY_DESCRIPTOR=STORAGE_DEVICE_RESILIENCY_DESCRIPTOR -_STORAGE_RPMB_FRAME_TYPE=STORAGE_RPMB_FRAME_TYPE -_STORAGE_RPMB_DESCRIPTOR=STORAGE_RPMB_DESCRIPTOR -_STORAGE_CRYPTO_ALGORITHM_ID=STORAGE_CRYPTO_ALGORITHM_ID -_STORAGE_CRYPTO_KEY_SIZE=STORAGE_CRYPTO_KEY_SIZE -_STORAGE_CRYPTO_CAPABILITY=STORAGE_CRYPTO_CAPABILITY -_STORAGE_CRYPTO_DESCRIPTOR=STORAGE_CRYPTO_DESCRIPTOR -_STORAGE_TIER_MEDIA_TYPE=STORAGE_TIER_MEDIA_TYPE -_STORAGE_TIER_CLASS=STORAGE_TIER_CLASS -_STORAGE_TIER=STORAGE_TIER -_STORAGE_DEVICE_TIERING_DESCRIPTOR=STORAGE_DEVICE_TIERING_DESCRIPTOR -_STORAGE_DEVICE_FAULT_DOMAIN_DESCRIPTOR=STORAGE_DEVICE_FAULT_DOMAIN_DESCRIPTOR -_STORAGE_PROTOCOL_TYPE=STORAGE_PROTOCOL_TYPE -_STORAGE_PROTOCOL_NVME_DATA_TYPE=STORAGE_PROTOCOL_NVME_DATA_TYPE -_STORAGE_PROTOCOL_ATA_DATA_TYPE=STORAGE_PROTOCOL_ATA_DATA_TYPE -_STORAGE_PROTOCOL_UFS_DATA_TYPE=STORAGE_PROTOCOL_UFS_DATA_TYPE -_STORAGE_PROTOCOL_SPECIFIC_DATA=STORAGE_PROTOCOL_SPECIFIC_DATA -_STORAGE_PROTOCOL_SPECIFIC_DATA_EXT=STORAGE_PROTOCOL_SPECIFIC_DATA_EXT -_STORAGE_PROTOCOL_DATA_DESCRIPTOR=STORAGE_PROTOCOL_DATA_DESCRIPTOR -_STORAGE_PROTOCOL_DATA_DESCRIPTOR_EXT=STORAGE_PROTOCOL_DATA_DESCRIPTOR_EXT -_STORAGE_TEMPERATURE_INFO=STORAGE_TEMPERATURE_INFO -_STORAGE_TEMPERATURE_DATA_DESCRIPTOR=STORAGE_TEMPERATURE_DATA_DESCRIPTOR -_STORAGE_TEMPERATURE_THRESHOLD=STORAGE_TEMPERATURE_THRESHOLD -_STORAGE_DEVICE_FORM_FACTOR=STORAGE_DEVICE_FORM_FACTOR -_STORAGE_COMPONENT_HEALTH_STATUS=STORAGE_COMPONENT_HEALTH_STATUS -_STORAGE_SPEC_VERSION=STORAGE_SPEC_VERSION -_STORAGE_PHYSICAL_DEVICE_DATA=STORAGE_PHYSICAL_DEVICE_DATA -_STORAGE_PHYSICAL_ADAPTER_DATA=STORAGE_PHYSICAL_ADAPTER_DATA -_STORAGE_PHYSICAL_NODE_DATA=STORAGE_PHYSICAL_NODE_DATA -_STORAGE_PHYSICAL_TOPOLOGY_DESCRIPTOR=STORAGE_PHYSICAL_TOPOLOGY_DESCRIPTOR -_STORAGE_DEVICE_IO_CAPABILITY_DESCRIPTOR=STORAGE_DEVICE_IO_CAPABILITY_DESCRIPTOR -_STORAGE_DEVICE_ATTRIBUTES_DESCRIPTOR=STORAGE_DEVICE_ATTRIBUTES_DESCRIPTOR -_STORAGE_DISK_HEALTH_STATUS=STORAGE_DISK_HEALTH_STATUS -_STORAGE_DISK_OPERATIONAL_STATUS=STORAGE_DISK_OPERATIONAL_STATUS -_STORAGE_OPERATIONAL_STATUS_REASON=STORAGE_OPERATIONAL_STATUS_REASON -_STORAGE_OPERATIONAL_REASON=STORAGE_OPERATIONAL_REASON -_STORAGE_DEVICE_MANAGEMENT_STATUS=STORAGE_DEVICE_MANAGEMENT_STATUS -_STORAGE_ADAPTER_SERIAL_NUMBER=STORAGE_ADAPTER_SERIAL_NUMBER -_STORAGE_ZONED_DEVICE_TYPES=STORAGE_ZONED_DEVICE_TYPES -_STORAGE_ZONE_TYPES=STORAGE_ZONE_TYPES -_STORAGE_ZONE_GROUP=STORAGE_ZONE_GROUP -_STORAGE_ZONED_DEVICE_DESCRIPTOR=STORAGE_ZONED_DEVICE_DESCRIPTOR -_DEVICE_LOCATION=DEVICE_LOCATION -_STORAGE_DEVICE_LOCATION_DESCRIPTOR=STORAGE_DEVICE_LOCATION_DESCRIPTOR -_STORAGE_DEVICE_NUMA_PROPERTY=STORAGE_DEVICE_NUMA_PROPERTY -_STORAGE_DEVICE_UNSAFE_SHUTDOWN_COUNT=STORAGE_DEVICE_UNSAFE_SHUTDOWN_COUNT -_STORAGE_HW_ENDURANCE_INFO=STORAGE_HW_ENDURANCE_INFO -_STORAGE_HW_ENDURANCE_DATA_DESCRIPTOR=STORAGE_HW_ENDURANCE_DATA_DESCRIPTOR -_DEVICE_DATA_SET_RANGE=DEVICE_DATA_SET_RANGE -_DEVICE_MANAGE_DATA_SET_ATTRIBUTES=DEVICE_MANAGE_DATA_SET_ATTRIBUTES -_DEVICE_MANAGE_DATA_SET_ATTRIBUTES_OUTPUT=DEVICE_MANAGE_DATA_SET_ATTRIBUTES_OUTPUT -_DEVICE_DSM_DEFINITION=DEVICE_DSM_DEFINITION -_DEVICE_DSM_NOTIFICATION_PARAMETERS=DEVICE_DSM_NOTIFICATION_PARAMETERS -_STORAGE_OFFLOAD_TOKEN=STORAGE_OFFLOAD_TOKEN -_DEVICE_DSM_OFFLOAD_READ_PARAMETERS=DEVICE_DSM_OFFLOAD_READ_PARAMETERS -_STORAGE_OFFLOAD_READ_OUTPUT=STORAGE_OFFLOAD_READ_OUTPUT -_DEVICE_DSM_OFFLOAD_WRITE_PARAMETERS=DEVICE_DSM_OFFLOAD_WRITE_PARAMETERS -_STORAGE_OFFLOAD_WRITE_OUTPUT=STORAGE_OFFLOAD_WRITE_OUTPUT -_DEVICE_DATA_SET_LBP_STATE_PARAMETERS=DEVICE_DATA_SET_LBP_STATE_PARAMETERS -_DEVICE_DATA_SET_LB_PROVISIONING_STATE=DEVICE_DATA_SET_LB_PROVISIONING_STATE -_DEVICE_DATA_SET_LB_PROVISIONING_STATE_V2=DEVICE_DATA_SET_LB_PROVISIONING_STATE_V2 -_DEVICE_DATA_SET_REPAIR_PARAMETERS=DEVICE_DATA_SET_REPAIR_PARAMETERS -_DEVICE_DATA_SET_REPAIR_OUTPUT=DEVICE_DATA_SET_REPAIR_OUTPUT -_DEVICE_DATA_SET_SCRUB_OUTPUT=DEVICE_DATA_SET_SCRUB_OUTPUT -_DEVICE_DATA_SET_SCRUB_EX_OUTPUT=DEVICE_DATA_SET_SCRUB_EX_OUTPUT -_DEVICE_DSM_TIERING_QUERY_INPUT=DEVICE_DSM_TIERING_QUERY_INPUT -_STORAGE_TIER_REGION=STORAGE_TIER_REGION -_DEVICE_DSM_TIERING_QUERY_OUTPUT=DEVICE_DSM_TIERING_QUERY_OUTPUT -_DEVICE_DSM_NVCACHE_CHANGE_PRIORITY_PARAMETERS=DEVICE_DSM_NVCACHE_CHANGE_PRIORITY_PARAMETERS -_DEVICE_DATA_SET_TOPOLOGY_ID_QUERY_OUTPUT=DEVICE_DATA_SET_TOPOLOGY_ID_QUERY_OUTPUT -_DEVICE_STORAGE_ADDRESS_RANGE=DEVICE_STORAGE_ADDRESS_RANGE -_DEVICE_DSM_PHYSICAL_ADDRESSES_OUTPUT=DEVICE_DSM_PHYSICAL_ADDRESSES_OUTPUT -_DEVICE_DSM_REPORT_ZONES_PARAMETERS=DEVICE_DSM_REPORT_ZONES_PARAMETERS -_STORAGE_ZONES_ATTRIBUTES=STORAGE_ZONES_ATTRIBUTES -_STORAGE_ZONE_CONDITION=STORAGE_ZONE_CONDITION -_STORAGE_ZONE_DESCRIPTOR=STORAGE_ZONE_DESCRIPTOR -_DEVICE_DSM_REPORT_ZONES_DATA=DEVICE_DSM_REPORT_ZONES_DATA -_DEVICE_STORAGE_RANGE_ATTRIBUTES=DEVICE_STORAGE_RANGE_ATTRIBUTES -_DEVICE_DSM_RANGE_ERROR_INFO=DEVICE_DSM_RANGE_ERROR_INFO -_DEVICE_DSM_LOST_QUERY_PARAMETERS=DEVICE_DSM_LOST_QUERY_PARAMETERS -_DEVICE_DSM_LOST_QUERY_OUTPUT=DEVICE_DSM_LOST_QUERY_OUTPUT -_DEVICE_DSM_FREE_SPACE_OUTPUT=DEVICE_DSM_FREE_SPACE_OUTPUT -_DEVICE_DSM_CONVERSION_OUTPUT=DEVICE_DSM_CONVERSION_OUTPUT -_STORAGE_GET_BC_PROPERTIES_OUTPUT=STORAGE_GET_BC_PROPERTIES_OUTPUT -_STORAGE_ALLOCATE_BC_STREAM_INPUT=STORAGE_ALLOCATE_BC_STREAM_INPUT -_STORAGE_ALLOCATE_BC_STREAM_OUTPUT=STORAGE_ALLOCATE_BC_STREAM_OUTPUT -_STORAGE_PRIORITY_HINT_SUPPORT=STORAGE_PRIORITY_HINT_SUPPORT -_STORAGE_DIAGNOSTIC_LEVEL=STORAGE_DIAGNOSTIC_LEVEL -_STORAGE_DIAGNOSTIC_TARGET_TYPE=STORAGE_DIAGNOSTIC_TARGET_TYPE -_STORAGE_DIAGNOSTIC_REQUEST=STORAGE_DIAGNOSTIC_REQUEST -_STORAGE_DIAGNOSTIC_DATA=STORAGE_DIAGNOSTIC_DATA -_PHYSICAL_ELEMENT_STATUS_REQUEST=PHYSICAL_ELEMENT_STATUS_REQUEST -_PHYSICAL_ELEMENT_STATUS_DESCRIPTOR=PHYSICAL_ELEMENT_STATUS_DESCRIPTOR -_PHYSICAL_ELEMENT_STATUS=PHYSICAL_ELEMENT_STATUS -_REMOVE_ELEMENT_AND_TRUNCATE_REQUEST=REMOVE_ELEMENT_AND_TRUNCATE_REQUEST -_STORAGE_MEDIA_SERIAL_NUMBER_DATA=STORAGE_MEDIA_SERIAL_NUMBER_DATA -_STORAGE_READ_CAPACITY=STORAGE_READ_CAPACITY -_WRITE_CACHE_TYPE=WRITE_CACHE_TYPE -_WRITE_CACHE_ENABLE=WRITE_CACHE_ENABLE -_WRITE_CACHE_CHANGE=WRITE_CACHE_CHANGE -_WRITE_THROUGH=WRITE_THROUGH -_STORAGE_WRITE_CACHE_PROPERTY=STORAGE_WRITE_CACHE_PROPERTY -_PERSISTENT_RESERVE_COMMAND=PERSISTENT_RESERVE_COMMAND -_DEVICEDUMP_SUBSECTION_POINTER=DEVICEDUMP_SUBSECTION_POINTER -_DEVICEDUMP_STRUCTURE_VERSION=DEVICEDUMP_STRUCTURE_VERSION -_DEVICEDUMP_SECTION_HEADER=DEVICEDUMP_SECTION_HEADER -_GP_LOG_PAGE_DESCRIPTOR=GP_LOG_PAGE_DESCRIPTOR -_DEVICEDUMP_PUBLIC_SUBSECTION=DEVICEDUMP_PUBLIC_SUBSECTION -_DEVICEDUMP_RESTRICTED_SUBSECTION=DEVICEDUMP_RESTRICTED_SUBSECTION -_DEVICEDUMP_PRIVATE_SUBSECTION=DEVICEDUMP_PRIVATE_SUBSECTION -_DEVICEDUMP_STORAGEDEVICE_DATA=DEVICEDUMP_STORAGEDEVICE_DATA -_DEVICEDUMP_STORAGESTACK_PUBLIC_STATE_RECORD=DEVICEDUMP_STORAGESTACK_PUBLIC_STATE_RECORD -_DEVICEDUMP_STORAGESTACK_PUBLIC_DUMP=DEVICEDUMP_STORAGESTACK_PUBLIC_DUMP -_STORAGE_IDLE_POWER=STORAGE_IDLE_POWER -_STORAGE_POWERUP_REASON_TYPE=STORAGE_POWERUP_REASON_TYPE -_STORAGE_IDLE_POWERUP_REASON=STORAGE_IDLE_POWERUP_REASON -_STORAGE_DEVICE_POWER_CAP_UNITS=STORAGE_DEVICE_POWER_CAP_UNITS -_STORAGE_DEVICE_POWER_CAP=STORAGE_DEVICE_POWER_CAP -_STORAGE_RPMB_DATA_FRAME=STORAGE_RPMB_DATA_FRAME -_STORAGE_RPMB_COMMAND_TYPE=STORAGE_RPMB_COMMAND_TYPE -_STORAGE_EVENT_NOTIFICATION=STORAGE_EVENT_NOTIFICATION -_STORAGE_COUNTER_TYPE=STORAGE_COUNTER_TYPE -_STORAGE_COUNTER=STORAGE_COUNTER -_STORAGE_COUNTERS=STORAGE_COUNTERS -_STORAGE_HW_FIRMWARE_INFO_QUERY=STORAGE_HW_FIRMWARE_INFO_QUERY -_STORAGE_HW_FIRMWARE_SLOT_INFO=STORAGE_HW_FIRMWARE_SLOT_INFO -_STORAGE_HW_FIRMWARE_INFO=STORAGE_HW_FIRMWARE_INFO -_STORAGE_HW_FIRMWARE_DOWNLOAD=STORAGE_HW_FIRMWARE_DOWNLOAD -_STORAGE_HW_FIRMWARE_DOWNLOAD_V2=STORAGE_HW_FIRMWARE_DOWNLOAD_V2 -_STORAGE_HW_FIRMWARE_ACTIVATE=STORAGE_HW_FIRMWARE_ACTIVATE -_STORAGE_PROTOCOL_COMMAND=STORAGE_PROTOCOL_COMMAND -_STORAGE_ATTRIBUTE_MGMT_ACTION=STORAGE_ATTRIBUTE_MGMT_ACTION -_STORAGE_ATTRIBUTE_MGMT=STORAGE_ATTRIBUTE_MGMT -_SCM_PD_HEALTH_NOTIFICATION_DATA=SCM_PD_HEALTH_NOTIFICATION_DATA -_SCM_LOGICAL_DEVICE_INSTANCE=SCM_LOGICAL_DEVICE_INSTANCE -_SCM_LOGICAL_DEVICES=SCM_LOGICAL_DEVICES -_SCM_PHYSICAL_DEVICE_INSTANCE=SCM_PHYSICAL_DEVICE_INSTANCE -_SCM_PHYSICAL_DEVICES=SCM_PHYSICAL_DEVICES -_SCM_REGION_FLAG=SCM_REGION_FLAG -_SCM_REGION=SCM_REGION -_SCM_REGIONS=SCM_REGIONS -_SCM_INTERLEAVED_PD_INFO=SCM_INTERLEAVED_PD_INFO -_SCM_LD_INTERLEAVE_SET_INFO=SCM_LD_INTERLEAVE_SET_INFO -_SCM_PD_QUERY_TYPE=SCM_PD_QUERY_TYPE -_SCM_PD_PROPERTY_ID=SCM_PD_PROPERTY_ID -_SCM_PD_PROPERTY_QUERY=SCM_PD_PROPERTY_QUERY -_SCM_PD_DESCRIPTOR_HEADER=SCM_PD_DESCRIPTOR_HEADER -_SCM_PD_DEVICE_HANDLE=SCM_PD_DEVICE_HANDLE -_SCM_PD_DEVICE_INFO=SCM_PD_DEVICE_INFO -_SCM_PD_DEVICE_SPECIFIC_PROPERTY=SCM_PD_DEVICE_SPECIFIC_PROPERTY -_SCM_PD_DEVICE_SPECIFIC_INFO=SCM_PD_DEVICE_SPECIFIC_INFO -_SCM_PD_FIRMWARE_SLOT_INFO=SCM_PD_FIRMWARE_SLOT_INFO -_SCM_PD_FIRMWARE_INFO=SCM_PD_FIRMWARE_INFO -_SCM_PD_HEALTH_STATUS=SCM_PD_HEALTH_STATUS -_SCM_PD_OPERATIONAL_STATUS=SCM_PD_OPERATIONAL_STATUS -_SCM_PD_OPERATIONAL_STATUS_REASON=SCM_PD_OPERATIONAL_STATUS_REASON -_SCM_PD_MANAGEMENT_STATUS=SCM_PD_MANAGEMENT_STATUS -_SCM_PD_LOCATION_STRING=SCM_PD_LOCATION_STRING -_SCM_PD_FIRMWARE_DOWNLOAD=SCM_PD_FIRMWARE_DOWNLOAD -_SCM_PD_FIRMWARE_ACTIVATE=SCM_PD_FIRMWARE_ACTIVATE -_SCM_PD_PASSTHROUGH_INPUT=SCM_PD_PASSTHROUGH_INPUT -_SCM_PD_PASSTHROUGH_OUTPUT=SCM_PD_PASSTHROUGH_OUTPUT -_SCM_PD_PASSTHROUGH_INVDIMM_INPUT=SCM_PD_PASSTHROUGH_INVDIMM_INPUT -_SCM_PD_PASSTHROUGH_INVDIMM_OUTPUT=SCM_PD_PASSTHROUGH_INVDIMM_OUTPUT -_SCM_PD_REINITIALIZE_MEDIA_INPUT=SCM_PD_REINITIALIZE_MEDIA_INPUT -_SCM_PD_MEDIA_REINITIALIZATION_STATUS=SCM_PD_MEDIA_REINITIALIZATION_STATUS -_SCM_PD_REINITIALIZE_MEDIA_OUTPUT=SCM_PD_REINITIALIZE_MEDIA_OUTPUT -_MEDIA_TYPE=MEDIA_TYPE -_FORMAT_PARAMETERS=FORMAT_PARAMETERS -_FORMAT_EX_PARAMETERS=FORMAT_EX_PARAMETERS -_DISK_GEOMETRY=DISK_GEOMETRY -_PARTITION_INFORMATION=PARTITION_INFORMATION -_SET_PARTITION_INFORMATION=SET_PARTITION_INFORMATION -_DRIVE_LAYOUT_INFORMATION=DRIVE_LAYOUT_INFORMATION -_VERIFY_INFORMATION=VERIFY_INFORMATION -_REASSIGN_BLOCKS=REASSIGN_BLOCKS -_REASSIGN_BLOCKS_EX=REASSIGN_BLOCKS_EX -_PARTITION_STYLE=PARTITION_STYLE -_PARTITION_INFORMATION_GPT=PARTITION_INFORMATION_GPT -_PARTITION_INFORMATION_MBR=PARTITION_INFORMATION_MBR -_SET_PARTITION_INFORMATION_EX=SET_PARTITION_INFORMATION_EX -_CREATE_DISK_GPT=CREATE_DISK_GPT -_CREATE_DISK_MBR=CREATE_DISK_MBR -_CREATE_DISK=CREATE_DISK -_GET_LENGTH_INFORMATION=GET_LENGTH_INFORMATION -_PARTITION_INFORMATION_EX=PARTITION_INFORMATION_EX -_DRIVE_LAYOUT_INFORMATION_GPT=DRIVE_LAYOUT_INFORMATION_GPT -_DRIVE_LAYOUT_INFORMATION_MBR=DRIVE_LAYOUT_INFORMATION_MBR -_DRIVE_LAYOUT_INFORMATION_EX=DRIVE_LAYOUT_INFORMATION_EX -_DETECTION_TYPE=DETECTION_TYPE -_DISK_INT13_INFO=DISK_INT13_INFO -_DISK_EX_INT13_INFO=DISK_EX_INT13_INFO -_DISK_DETECTION_INFO=DISK_DETECTION_INFO -_DISK_PARTITION_INFO=DISK_PARTITION_INFO -_DISK_GEOMETRY_EX=DISK_GEOMETRY_EX -_DISK_CONTROLLER_NUMBER=DISK_CONTROLLER_NUMBER -_DISK_CACHE_INFORMATION=DISK_CACHE_INFORMATION -_DISK_GROW_PARTITION=DISK_GROW_PARTITION -_HISTOGRAM_BUCKET=HISTOGRAM_BUCKET -_DISK_HISTOGRAM=DISK_HISTOGRAM -_DISK_PERFORMANCE=DISK_PERFORMANCE -_DISK_RECORD=DISK_RECORD -_DISK_LOGGING=DISK_LOGGING -_BIN_TYPES=BIN_TYPES -_BIN_RANGE=BIN_RANGE -_PERF_BIN=PERF_BIN -_BIN_COUNT=BIN_COUNT -_BIN_RESULTS=BIN_RESULTS -_GETVERSIONINPARAMS=GETVERSIONINPARAMS -_IDEREGS=IDEREGS -_SENDCMDINPARAMS=SENDCMDINPARAMS -_DRIVERSTATUS=DRIVERSTATUS -_SENDCMDOUTPARAMS=SENDCMDOUTPARAMS -_GET_DISK_ATTRIBUTES=GET_DISK_ATTRIBUTES -_SET_DISK_ATTRIBUTES=SET_DISK_ATTRIBUTES -_ELEMENT_TYPE=ELEMENT_TYPE -_CHANGER_ELEMENT=CHANGER_ELEMENT -_CHANGER_ELEMENT_LIST=CHANGER_ELEMENT_LIST -_GET_CHANGER_PARAMETERS=GET_CHANGER_PARAMETERS -_CHANGER_PRODUCT_DATA=CHANGER_PRODUCT_DATA -_CHANGER_SET_ACCESS=CHANGER_SET_ACCESS -_CHANGER_READ_ELEMENT_STATUS=CHANGER_READ_ELEMENT_STATUS -_CHANGER_ELEMENT_STATUS=CHANGER_ELEMENT_STATUS -_CHANGER_ELEMENT_STATUS_EX=CHANGER_ELEMENT_STATUS_EX -_CHANGER_INITIALIZE_ELEMENT_STATUS=CHANGER_INITIALIZE_ELEMENT_STATUS -_CHANGER_SET_POSITION=CHANGER_SET_POSITION -_CHANGER_EXCHANGE_MEDIUM=CHANGER_EXCHANGE_MEDIUM -_CHANGER_MOVE_MEDIUM=CHANGER_MOVE_MEDIUM -_CHANGER_SEND_VOLUME_TAG_INFORMATION=CHANGER_SEND_VOLUME_TAG_INFORMATION -_READ_ELEMENT_ADDRESS_INFO=READ_ELEMENT_ADDRESS_INFO -_CHANGER_DEVICE_PROBLEM_TYPE=CHANGER_DEVICE_PROBLEM_TYPE -_PATHNAME_BUFFER=PATHNAME_BUFFER -_FSCTL_QUERY_FAT_BPB_BUFFER=FSCTL_QUERY_FAT_BPB_BUFFER -_FILE_PREFETCH=FILE_PREFETCH -_FILE_PREFETCH_EX=FILE_PREFETCH_EX -_FILESYSTEM_STATISTICS=FILESYSTEM_STATISTICS -_FAT_STATISTICS=FAT_STATISTICS -_EXFAT_STATISTICS=EXFAT_STATISTICS -_NTFS_STATISTICS=NTFS_STATISTICS -_FILESYSTEM_STATISTICS_EX=FILESYSTEM_STATISTICS_EX -_NTFS_STATISTICS_EX=NTFS_STATISTICS_EX -_FILE_OBJECTID_BUFFER=FILE_OBJECTID_BUFFER -_FILE_SET_SPARSE_BUFFER=FILE_SET_SPARSE_BUFFER -_FILE_ZERO_DATA_INFORMATION=FILE_ZERO_DATA_INFORMATION -_FILE_ZERO_DATA_INFORMATION_EX=FILE_ZERO_DATA_INFORMATION_EX -_FILE_ALLOCATED_RANGE_BUFFER=FILE_ALLOCATED_RANGE_BUFFER -_ENCRYPTION_BUFFER=ENCRYPTION_BUFFER -_DECRYPTION_STATUS_BUFFER=DECRYPTION_STATUS_BUFFER -_REQUEST_RAW_ENCRYPTED_DATA=REQUEST_RAW_ENCRYPTED_DATA -_ENCRYPTED_DATA_INFO=ENCRYPTED_DATA_INFO -_EXTENDED_ENCRYPTED_DATA_INFO=EXTENDED_ENCRYPTED_DATA_INFO -_PLEX_READ_DATA_REQUEST=PLEX_READ_DATA_REQUEST -_SI_COPYFILE=SI_COPYFILE -_FILE_MAKE_COMPATIBLE_BUFFER=FILE_MAKE_COMPATIBLE_BUFFER -_FILE_SET_DEFECT_MGMT_BUFFER=FILE_SET_DEFECT_MGMT_BUFFER -_FILE_QUERY_SPARING_BUFFER=FILE_QUERY_SPARING_BUFFER -_FILE_QUERY_ON_DISK_VOL_INFO_BUFFER=FILE_QUERY_ON_DISK_VOL_INFO_BUFFER -_FILE_INITIATE_REPAIR_OUTPUT_BUFFER=FILE_INITIATE_REPAIR_OUTPUT_BUFFER -_SHRINK_VOLUME_REQUEST_TYPES=SHRINK_VOLUME_REQUEST_TYPES -_SHRINK_VOLUME_INFORMATION=SHRINK_VOLUME_INFORMATION -_TXFS_MODIFY_RM=TXFS_MODIFY_RM -_TXFS_QUERY_RM_INFORMATION=TXFS_QUERY_RM_INFORMATION -_TXFS_ROLLFORWARD_REDO_INFORMATION=TXFS_ROLLFORWARD_REDO_INFORMATION -_TXFS_START_RM_INFORMATION=TXFS_START_RM_INFORMATION -_TXFS_GET_METADATA_INFO_OUT=TXFS_GET_METADATA_INFO_OUT -_TXFS_LIST_TRANSACTION_LOCKED_FILES_ENTRY=TXFS_LIST_TRANSACTION_LOCKED_FILES_ENTRY -_TXFS_LIST_TRANSACTION_LOCKED_FILES=TXFS_LIST_TRANSACTION_LOCKED_FILES -_TXFS_LIST_TRANSACTIONS_ENTRY=TXFS_LIST_TRANSACTIONS_ENTRY -_TXFS_LIST_TRANSACTIONS=TXFS_LIST_TRANSACTIONS -_TXFS_READ_BACKUP_INFORMATION_OUT=TXFS_READ_BACKUP_INFORMATION_OUT -_TXFS_WRITE_BACKUP_INFORMATION=TXFS_WRITE_BACKUP_INFORMATION -_TXFS_GET_TRANSACTED_VERSION=TXFS_GET_TRANSACTED_VERSION -_TXFS_SAVEPOINT_INFORMATION=TXFS_SAVEPOINT_INFORMATION -_TXFS_CREATE_MINIVERSION_INFO=TXFS_CREATE_MINIVERSION_INFO -_TXFS_TRANSACTION_ACTIVE_INFO=TXFS_TRANSACTION_ACTIVE_INFO -_BOOT_AREA_INFO=BOOT_AREA_INFO -_RETRIEVAL_POINTER_BASE=RETRIEVAL_POINTER_BASE -_FILE_FS_PERSISTENT_VOLUME_INFORMATION=FILE_FS_PERSISTENT_VOLUME_INFORMATION -_FILE_SYSTEM_RECOGNITION_INFORMATION=FILE_SYSTEM_RECOGNITION_INFORMATION -_REQUEST_OPLOCK_INPUT_BUFFER=REQUEST_OPLOCK_INPUT_BUFFER -_REQUEST_OPLOCK_OUTPUT_BUFFER=REQUEST_OPLOCK_OUTPUT_BUFFER -_VIRTUAL_STORAGE_TYPE=VIRTUAL_STORAGE_TYPE -_STORAGE_QUERY_DEPENDENT_VOLUME_REQUEST=STORAGE_QUERY_DEPENDENT_VOLUME_REQUEST -_STORAGE_QUERY_DEPENDENT_VOLUME_LEV1_ENTRY=STORAGE_QUERY_DEPENDENT_VOLUME_LEV1_ENTRY -_STORAGE_QUERY_DEPENDENT_VOLUME_LEV2_ENTRY=STORAGE_QUERY_DEPENDENT_VOLUME_LEV2_ENTRY -_STORAGE_QUERY_DEPENDENT_VOLUME_RESPONSE=STORAGE_QUERY_DEPENDENT_VOLUME_RESPONSE -_SD_CHANGE_MACHINE_SID_INPUT=SD_CHANGE_MACHINE_SID_INPUT -_SD_CHANGE_MACHINE_SID_OUTPUT=SD_CHANGE_MACHINE_SID_OUTPUT -_SD_QUERY_STATS_INPUT=SD_QUERY_STATS_INPUT -_SD_QUERY_STATS_OUTPUT=SD_QUERY_STATS_OUTPUT -_SD_ENUM_SDS_INPUT=SD_ENUM_SDS_INPUT -_SD_ENUM_SDS_ENTRY=SD_ENUM_SDS_ENTRY -_SD_ENUM_SDS_OUTPUT=SD_ENUM_SDS_OUTPUT -_SD_GLOBAL_CHANGE_INPUT=SD_GLOBAL_CHANGE_INPUT -_SD_GLOBAL_CHANGE_OUTPUT=SD_GLOBAL_CHANGE_OUTPUT -_LOOKUP_STREAM_FROM_CLUSTER_INPUT=LOOKUP_STREAM_FROM_CLUSTER_INPUT -_LOOKUP_STREAM_FROM_CLUSTER_OUTPUT=LOOKUP_STREAM_FROM_CLUSTER_OUTPUT -_LOOKUP_STREAM_FROM_CLUSTER_ENTRY=LOOKUP_STREAM_FROM_CLUSTER_ENTRY -_FILE_TYPE_NOTIFICATION_INPUT=FILE_TYPE_NOTIFICATION_INPUT -_CSV_MGMT_LOCK=CSV_MGMT_LOCK -_CSV_NAMESPACE_INFO=CSV_NAMESPACE_INFO -_CSV_CONTROL_OP=CSV_CONTROL_OP -_CSV_CONTROL_PARAM=CSV_CONTROL_PARAM -_CSV_QUERY_REDIRECT_STATE=CSV_QUERY_REDIRECT_STATE -_CSV_QUERY_FILE_REVISION=CSV_QUERY_FILE_REVISION -_CSV_QUERY_FILE_REVISION_FILE_ID_128=CSV_QUERY_FILE_REVISION_FILE_ID_128 -_CSV_QUERY_MDS_PATH=CSV_QUERY_MDS_PATH -_CSVFS_DISK_CONNECTIVITY=CSVFS_DISK_CONNECTIVITY -_CSV_QUERY_VOLUME_REDIRECT_STATE=CSV_QUERY_VOLUME_REDIRECT_STATE -_CSV_QUERY_MDS_PATH_V2=CSV_QUERY_MDS_PATH_V2 -_CSV_QUERY_VETO_FILE_DIRECT_IO_OUTPUT=CSV_QUERY_VETO_FILE_DIRECT_IO_OUTPUT -_STORAGE_RESERVE_ID=STORAGE_RESERVE_ID -_CSV_IS_OWNED_BY_CSVFS=CSV_IS_OWNED_BY_CSVFS -_FILE_LEVEL_TRIM_RANGE=FILE_LEVEL_TRIM_RANGE -_FILE_LEVEL_TRIM=FILE_LEVEL_TRIM -_FILE_LEVEL_TRIM_OUTPUT=FILE_LEVEL_TRIM_OUTPUT -_QUERY_FILE_LAYOUT_FILTER_TYPE=QUERY_FILE_LAYOUT_FILTER_TYPE -_CLUSTER_RANGE=CLUSTER_RANGE -_FILE_REFERENCE_RANGE=FILE_REFERENCE_RANGE -_QUERY_FILE_LAYOUT_INPUT=QUERY_FILE_LAYOUT_INPUT -_QUERY_FILE_LAYOUT_OUTPUT=QUERY_FILE_LAYOUT_OUTPUT -_FILE_LAYOUT_ENTRY=FILE_LAYOUT_ENTRY -_FILE_LAYOUT_NAME_ENTRY=FILE_LAYOUT_NAME_ENTRY -_FILE_LAYOUT_INFO_ENTRY=FILE_LAYOUT_INFO_ENTRY -_STREAM_LAYOUT_ENTRY=STREAM_LAYOUT_ENTRY -_STREAM_EXTENT_ENTRY=STREAM_EXTENT_ENTRY -_FSCTL_GET_INTEGRITY_INFORMATION_BUFFER=FSCTL_GET_INTEGRITY_INFORMATION_BUFFER -_FSCTL_SET_INTEGRITY_INFORMATION_BUFFER=FSCTL_SET_INTEGRITY_INFORMATION_BUFFER -_FSCTL_SET_INTEGRITY_INFORMATION_BUFFER_EX=FSCTL_SET_INTEGRITY_INFORMATION_BUFFER_EX -_FSCTL_OFFLOAD_READ_INPUT=FSCTL_OFFLOAD_READ_INPUT -_FSCTL_OFFLOAD_READ_OUTPUT=FSCTL_OFFLOAD_READ_OUTPUT -_FSCTL_OFFLOAD_WRITE_INPUT=FSCTL_OFFLOAD_WRITE_INPUT -_FSCTL_OFFLOAD_WRITE_OUTPUT=FSCTL_OFFLOAD_WRITE_OUTPUT -_SET_PURGE_FAILURE_MODE_INPUT=SET_PURGE_FAILURE_MODE_INPUT -_REPAIR_COPIES_INPUT=REPAIR_COPIES_INPUT -_REPAIR_COPIES_OUTPUT=REPAIR_COPIES_OUTPUT -_FILE_REGION_INFO=FILE_REGION_INFO -_FILE_REGION_OUTPUT=FILE_REGION_OUTPUT -_FILE_REGION_INPUT=FILE_REGION_INPUT -_WRITE_USN_REASON_INPUT=WRITE_USN_REASON_INPUT -_FILE_STORAGE_TIER_MEDIA_TYPE=FILE_STORAGE_TIER_MEDIA_TYPE -_FILE_STORAGE_TIER_CLASS=FILE_STORAGE_TIER_CLASS -_FILE_STORAGE_TIER=FILE_STORAGE_TIER -_FSCTL_QUERY_STORAGE_CLASSES_OUTPUT=FSCTL_QUERY_STORAGE_CLASSES_OUTPUT -_STREAM_INFORMATION_ENTRY=STREAM_INFORMATION_ENTRY -_FSCTL_QUERY_REGION_INFO_INPUT=FSCTL_QUERY_REGION_INFO_INPUT -_FILE_STORAGE_TIER_REGION=FILE_STORAGE_TIER_REGION -_FSCTL_QUERY_REGION_INFO_OUTPUT=FSCTL_QUERY_REGION_INFO_OUTPUT -_FILE_DESIRED_STORAGE_CLASS_INFORMATION=FILE_DESIRED_STORAGE_CLASS_INFORMATION -_DUPLICATE_EXTENTS_DATA=DUPLICATE_EXTENTS_DATA -_DUPLICATE_EXTENTS_DATA_EX=DUPLICATE_EXTENTS_DATA_EX -_REFS_SMR_VOLUME_GC_STATE=REFS_SMR_VOLUME_GC_STATE -_REFS_SMR_VOLUME_INFO_OUTPUT=REFS_SMR_VOLUME_INFO_OUTPUT -_REFS_SMR_VOLUME_GC_ACTION=REFS_SMR_VOLUME_GC_ACTION -_REFS_SMR_VOLUME_GC_METHOD=REFS_SMR_VOLUME_GC_METHOD -_REFS_SMR_VOLUME_GC_PARAMETERS=REFS_SMR_VOLUME_GC_PARAMETERS -_STREAMS_QUERY_PARAMETERS_OUTPUT_BUFFER=STREAMS_QUERY_PARAMETERS_OUTPUT_BUFFER -_STREAMS_ASSOCIATE_ID_INPUT_BUFFER=STREAMS_ASSOCIATE_ID_INPUT_BUFFER -_STREAMS_QUERY_ID_OUTPUT_BUFFER=STREAMS_QUERY_ID_OUTPUT_BUFFER -_QUERY_BAD_RANGES_INPUT_RANGE=QUERY_BAD_RANGES_INPUT_RANGE -_QUERY_BAD_RANGES_INPUT=QUERY_BAD_RANGES_INPUT -_QUERY_BAD_RANGES_OUTPUT_RANGE=QUERY_BAD_RANGES_OUTPUT_RANGE -_QUERY_BAD_RANGES_OUTPUT=QUERY_BAD_RANGES_OUTPUT -_SET_DAX_ALLOC_ALIGNMENT_HINT_INPUT=SET_DAX_ALLOC_ALIGNMENT_HINT_INPUT -_VIRTUAL_STORAGE_BEHAVIOR_CODE=VIRTUAL_STORAGE_BEHAVIOR_CODE -_VIRTUAL_STORAGE_SET_BEHAVIOR_INPUT=VIRTUAL_STORAGE_SET_BEHAVIOR_INPUT -_ENCRYPTION_KEY_CTRL_INPUT=ENCRYPTION_KEY_CTRL_INPUT -_WOF_EXTERNAL_INFO=WOF_EXTERNAL_INFO -_WOF_EXTERNAL_FILE_ID=WOF_EXTERNAL_FILE_ID -_WOF_VERSION_INFO=WOF_VERSION_INFO -_WIM_PROVIDER_EXTERNAL_INFO=WIM_PROVIDER_EXTERNAL_INFO -_WIM_PROVIDER_ADD_OVERLAY_INPUT=WIM_PROVIDER_ADD_OVERLAY_INPUT -_WIM_PROVIDER_UPDATE_OVERLAY_INPUT=WIM_PROVIDER_UPDATE_OVERLAY_INPUT -_WIM_PROVIDER_REMOVE_OVERLAY_INPUT=WIM_PROVIDER_REMOVE_OVERLAY_INPUT -_WIM_PROVIDER_SUSPEND_OVERLAY_INPUT=WIM_PROVIDER_SUSPEND_OVERLAY_INPUT -_WIM_PROVIDER_OVERLAY_ENTRY=WIM_PROVIDER_OVERLAY_ENTRY -_FILE_PROVIDER_EXTERNAL_INFO_V0=FILE_PROVIDER_EXTERNAL_INFO_V0 -_FILE_PROVIDER_EXTERNAL_INFO_V1=FILE_PROVIDER_EXTERNAL_INFO_V1 -_CONTAINER_VOLUME_STATE=CONTAINER_VOLUME_STATE -_CONTAINER_ROOT_INFO_INPUT=CONTAINER_ROOT_INFO_INPUT -_CONTAINER_ROOT_INFO_OUTPUT=CONTAINER_ROOT_INFO_OUTPUT -_VIRTUALIZATION_INSTANCE_INFO_INPUT=VIRTUALIZATION_INSTANCE_INFO_INPUT -_VIRTUALIZATION_INSTANCE_INFO_INPUT_EX=VIRTUALIZATION_INSTANCE_INFO_INPUT_EX -_VIRTUALIZATION_INSTANCE_INFO_OUTPUT=VIRTUALIZATION_INSTANCE_INFO_OUTPUT -_GET_FILTER_FILE_IDENTIFIER_INPUT=GET_FILTER_FILE_IDENTIFIER_INPUT -_GET_FILTER_FILE_IDENTIFIER_OUTPUT=GET_FILTER_FILE_IDENTIFIER_OUTPUT -_DISK_EXTENT=DISK_EXTENT -_VOLUME_DISK_EXTENTS=VOLUME_DISK_EXTENTS -_VOLUME_GET_GPT_ATTRIBUTES_INFORMATION=VOLUME_GET_GPT_ATTRIBUTES_INFORMATION -_IO_IRP_EXT_TRACK_OFFSET_HEADER=IO_IRP_EXT_TRACK_OFFSET_HEADER -_SCARD_IO_REQUEST=SCARD_IO_REQUEST -_SCARD_T0_COMMAND=SCARD_T0_COMMAND -_SCARD_T0_REQUEST=SCARD_T0_REQUEST -_SCARD_T1_REQUEST=SCARD_T1_REQUEST -_SCARD_ATRMASK=SCARD_ATRMASK -_PRINTER_INFO_1A=PRINTER_INFO_1A -_PRINTER_INFO_1W=PRINTER_INFO_1W -_PRINTER_INFO_2A=PRINTER_INFO_2A -_PRINTER_INFO_2W=PRINTER_INFO_2W -_PRINTER_INFO_3=PRINTER_INFO_3 -_PRINTER_INFO_4A=PRINTER_INFO_4A -_PRINTER_INFO_4W=PRINTER_INFO_4W -_PRINTER_INFO_5A=PRINTER_INFO_5A -_PRINTER_INFO_5W=PRINTER_INFO_5W -_PRINTER_INFO_6=PRINTER_INFO_6 -_PRINTER_INFO_7A=PRINTER_INFO_7A -_PRINTER_INFO_7W=PRINTER_INFO_7W -_PRINTER_INFO_8A=PRINTER_INFO_8A -_PRINTER_INFO_8W=PRINTER_INFO_8W -_PRINTER_INFO_9A=PRINTER_INFO_9A -_PRINTER_INFO_9W=PRINTER_INFO_9W -_JOB_INFO_1A=JOB_INFO_1A -_JOB_INFO_1W=JOB_INFO_1W -_JOB_INFO_2A=JOB_INFO_2A -_JOB_INFO_2W=JOB_INFO_2W -_JOB_INFO_3=JOB_INFO_3 -_JOB_INFO_4A=JOB_INFO_4A -_JOB_INFO_4W=JOB_INFO_4W -_ADDJOB_INFO_1A=ADDJOB_INFO_1A -_ADDJOB_INFO_1W=ADDJOB_INFO_1W -_DRIVER_INFO_1A=DRIVER_INFO_1A -_DRIVER_INFO_1W=DRIVER_INFO_1W -_DRIVER_INFO_2A=DRIVER_INFO_2A -_DRIVER_INFO_2W=DRIVER_INFO_2W -_DRIVER_INFO_3A=DRIVER_INFO_3A -_DRIVER_INFO_3W=DRIVER_INFO_3W -_DRIVER_INFO_4A=DRIVER_INFO_4A -_DRIVER_INFO_4W=DRIVER_INFO_4W -_DRIVER_INFO_5A=DRIVER_INFO_5A -_DRIVER_INFO_5W=DRIVER_INFO_5W -_DRIVER_INFO_6A=DRIVER_INFO_6A -_DRIVER_INFO_6W=DRIVER_INFO_6W -_DRIVER_INFO_8A=DRIVER_INFO_8A -_DRIVER_INFO_8W=DRIVER_INFO_8W -_DOC_INFO_1A=DOC_INFO_1A -_DOC_INFO_1W=DOC_INFO_1W -_FORM_INFO_1A=FORM_INFO_1A -_FORM_INFO_1W=FORM_INFO_1W -_FORM_INFO_2A=FORM_INFO_2A -_FORM_INFO_2W=FORM_INFO_2W -_DOC_INFO_2A=DOC_INFO_2A -_DOC_INFO_2W=DOC_INFO_2W -_DOC_INFO_3A=DOC_INFO_3A -_DOC_INFO_3W=DOC_INFO_3W -_PRINTPROCESSOR_INFO_1A=PRINTPROCESSOR_INFO_1A -_PRINTPROCESSOR_INFO_1W=PRINTPROCESSOR_INFO_1W -_PRINTPROCESSOR_CAPS_1=PRINTPROCESSOR_CAPS_1 -_PRINTPROCESSOR_CAPS_2=PRINTPROCESSOR_CAPS_2 -_PORT_INFO_1A=PORT_INFO_1A -_PORT_INFO_1W=PORT_INFO_1W -_PORT_INFO_2A=PORT_INFO_2A -_PORT_INFO_2W=PORT_INFO_2W -_PORT_INFO_3A=PORT_INFO_3A -_PORT_INFO_3W=PORT_INFO_3W -_MONITOR_INFO_1A=MONITOR_INFO_1A -_MONITOR_INFO_1W=MONITOR_INFO_1W -_MONITOR_INFO_2A=MONITOR_INFO_2A -_MONITOR_INFO_2W=MONITOR_INFO_2W -_DATATYPES_INFO_1A=DATATYPES_INFO_1A -_DATATYPES_INFO_1W=DATATYPES_INFO_1W -_PRINTER_DEFAULTSA=PRINTER_DEFAULTSA -_PRINTER_DEFAULTSW=PRINTER_DEFAULTSW -_PRINTER_ENUM_VALUESA=PRINTER_ENUM_VALUESA -_PRINTER_ENUM_VALUESW=PRINTER_ENUM_VALUESW -_PRINTER_NOTIFY_OPTIONS_TYPE=PRINTER_NOTIFY_OPTIONS_TYPE -_PRINTER_NOTIFY_OPTIONS=PRINTER_NOTIFY_OPTIONS -_PRINTER_NOTIFY_INFO_DATA=PRINTER_NOTIFY_INFO_DATA -_PRINTER_NOTIFY_INFO=PRINTER_NOTIFY_INFO -_BINARY_CONTAINER=BINARY_CONTAINER -_BIDI_DATA=BIDI_DATA -_BIDI_REQUEST_DATA=BIDI_REQUEST_DATA -_BIDI_REQUEST_CONTAINER=BIDI_REQUEST_CONTAINER -_BIDI_RESPONSE_DATA=BIDI_RESPONSE_DATA -_BIDI_RESPONSE_CONTAINER=BIDI_RESPONSE_CONTAINER -_PROVIDOR_INFO_1A=PROVIDOR_INFO_1A -_PROVIDOR_INFO_1W=PROVIDOR_INFO_1W -_PROVIDOR_INFO_2A=PROVIDOR_INFO_2A -_PROVIDOR_INFO_2W=PROVIDOR_INFO_2W -_PRINTER_OPTION_FLAGS=PRINTER_OPTION_FLAGS -_PRINTER_OPTIONSA=PRINTER_OPTIONSA -_PRINTER_OPTIONSW=PRINTER_OPTIONSW -_PRINTER_CONNECTION_INFO_1A=PRINTER_CONNECTION_INFO_1A -_PRINTER_CONNECTION_INFO_1W=PRINTER_CONNECTION_INFO_1W -_CORE_PRINTER_DRIVERA=CORE_PRINTER_DRIVERA -_CORE_PRINTER_DRIVERW=CORE_PRINTER_DRIVERW -_OLESTREAMVTBL=OLESTREAMVTBL -_OLESTREAM=OLESTREAM -_OFNOTIFYA=OFNOTIFYA -_OFNOTIFYW=OFNOTIFYW -_OFNOTIFYEXA=OFNOTIFYEXA -_OFNOTIFYEXW=OFNOTIFYEXW -_SERVICE_CUSTOM_SYSTEM_STATE_CHANGE_DATA_ITEM=SERVICE_CUSTOM_SYSTEM_STATE_CHANGE_DATA_ITEM -_SERVICE_DESCRIPTIONA=SERVICE_DESCRIPTIONA -_SERVICE_DESCRIPTIONW=SERVICE_DESCRIPTIONW -_SC_ACTION_TYPE=SC_ACTION_TYPE -_SC_ACTION=SC_ACTION -_SERVICE_FAILURE_ACTIONSA=SERVICE_FAILURE_ACTIONSA -_SERVICE_FAILURE_ACTIONSW=SERVICE_FAILURE_ACTIONSW -_SERVICE_DELAYED_AUTO_START_INFO=SERVICE_DELAYED_AUTO_START_INFO -_SERVICE_FAILURE_ACTIONS_FLAG=SERVICE_FAILURE_ACTIONS_FLAG -_SERVICE_SID_INFO=SERVICE_SID_INFO -_SERVICE_REQUIRED_PRIVILEGES_INFOA=SERVICE_REQUIRED_PRIVILEGES_INFOA -_SERVICE_REQUIRED_PRIVILEGES_INFOW=SERVICE_REQUIRED_PRIVILEGES_INFOW -_SERVICE_PRESHUTDOWN_INFO=SERVICE_PRESHUTDOWN_INFO -_SERVICE_TRIGGER_SPECIFIC_DATA_ITEM=SERVICE_TRIGGER_SPECIFIC_DATA_ITEM -_SERVICE_TRIGGER=SERVICE_TRIGGER -_SERVICE_TRIGGER_INFO=SERVICE_TRIGGER_INFO -_SERVICE_PREFERRED_NODE_INFO=SERVICE_PREFERRED_NODE_INFO -_SERVICE_TIMECHANGE_INFO=SERVICE_TIMECHANGE_INFO -_SERVICE_LAUNCH_PROTECTED_INFO=SERVICE_LAUNCH_PROTECTED_INFO -_SC_STATUS_TYPE=SC_STATUS_TYPE -_SC_ENUM_TYPE=SC_ENUM_TYPE -_SERVICE_STATUS=SERVICE_STATUS -_SERVICE_STATUS_PROCESS=SERVICE_STATUS_PROCESS -_ENUM_SERVICE_STATUSA=ENUM_SERVICE_STATUSA -_ENUM_SERVICE_STATUSW=ENUM_SERVICE_STATUSW -_ENUM_SERVICE_STATUS_PROCESSA=ENUM_SERVICE_STATUS_PROCESSA -_ENUM_SERVICE_STATUS_PROCESSW=ENUM_SERVICE_STATUS_PROCESSW -_QUERY_SERVICE_LOCK_STATUSA=QUERY_SERVICE_LOCK_STATUSA -_QUERY_SERVICE_LOCK_STATUSW=QUERY_SERVICE_LOCK_STATUSW -_QUERY_SERVICE_CONFIGA=QUERY_SERVICE_CONFIGA -_QUERY_SERVICE_CONFIGW=QUERY_SERVICE_CONFIGW -_SERVICE_TABLE_ENTRYA=SERVICE_TABLE_ENTRYA -_SERVICE_TABLE_ENTRYW=SERVICE_TABLE_ENTRYW -_SERVICE_NOTIFY_1=SERVICE_NOTIFY_1 -_SERVICE_NOTIFY_2A=SERVICE_NOTIFY_2A -_SERVICE_NOTIFY_2W=SERVICE_NOTIFY_2W -_SERVICE_CONTROL_STATUS_REASON_PARAMSA=SERVICE_CONTROL_STATUS_REASON_PARAMSA -_SERVICE_CONTROL_STATUS_REASON_PARAMSW=SERVICE_CONTROL_STATUS_REASON_PARAMSW -_SERVICE_START_REASON=SERVICE_START_REASON -_SC_EVENT_TYPE=SC_EVENT_TYPE -_MODEMDEVCAPS=MODEMDEVCAPS -_MODEMSETTINGS=MODEMSETTINGS -_SOCKET_ADDRESS=SOCKET_ADDRESS -_SOCKET_ADDRESS_LIST=SOCKET_ADDRESS_LIST -_CSADDR_INFO=CSADDR_INFO -_SOCKET_PROCESSOR_AFFINITY=SOCKET_PROCESSOR_AFFINITY -_WSABUF=WSABUF -_WSAMSG=WSAMSG -_QOS_SD_MODE=QOS_SD_MODE -_QOS_SHAPING_RATE=QOS_SHAPING_RATE -_WSANETWORKEVENTS=WSANETWORKEVENTS -_WSAPROTOCOLCHAIN=WSAPROTOCOLCHAIN -_WSAPROTOCOL_INFOA=WSAPROTOCOL_INFOA -_WSAPROTOCOL_INFOW=WSAPROTOCOL_INFOW -_WSACOMPLETIONTYPE=WSACOMPLETIONTYPE -_WSACOMPLETION=WSACOMPLETION -_AFPROTOCOLS=AFPROTOCOLS -_WSAESETSERVICEOP=WSAESETSERVICEOP -_WSANAMESPACE_INFOA=WSANAMESPACE_INFOA -_WSANAMESPACE_INFOW=WSANAMESPACE_INFOW -_WSANAMESPACE_INFOEXA=WSANAMESPACE_INFOEXA -_WSANAMESPACE_INFOEXW=WSANAMESPACE_INFOEXW -_STRING=STRING -_UNICODE_STRING=UNICODE_STRING -_CLIENT_ID=CLIENT_ID -_PEB_LDR_DATA=PEB_LDR_DATA -_LDR_DATA_TABLE_ENTRY=LDR_DATA_TABLE_ENTRY -_RTL_USER_PROCESS_PARAMETERS=RTL_USER_PROCESS_PARAMETERS -_PEB=PEB -_OBJECT_ATTRIBUTES=OBJECT_ATTRIBUTES -_IO_STATUS_BLOCK=IO_STATUS_BLOCK -_PROCESS_BASIC_INFORMATION=PROCESS_BASIC_INFORMATION -_SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION=SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION -_SYSTEM_PROCESS_INFORMATION=SYSTEM_PROCESS_INFORMATION -_SYSTEM_THREAD_INFORMATION=SYSTEM_THREAD_INFORMATION -_SYSTEM_REGISTRY_QUOTA_INFORMATION=SYSTEM_REGISTRY_QUOTA_INFORMATION -_SYSTEM_BASIC_INFORMATION=SYSTEM_BASIC_INFORMATION -_SYSTEM_TIMEOFDAY_INFORMATION=SYSTEM_TIMEOFDAY_INFORMATION -_SYSTEM_PERFORMANCE_INFORMATION=SYSTEM_PERFORMANCE_INFORMATION -_SYSTEM_EXCEPTION_INFORMATION=SYSTEM_EXCEPTION_INFORMATION -_SYSTEM_LOOKASIDE_INFORMATION=SYSTEM_LOOKASIDE_INFORMATION -_SYSTEM_INTERRUPT_INFORMATION=SYSTEM_INTERRUPT_INFORMATION -_SYSTEM_POLICY_INFORMATION=SYSTEM_POLICY_INFORMATION -_FILE_INFORMATION_CLASS=FILE_INFORMATION_CLASS -_PROCESSINFOCLASS=PROCESSINFOCLASS -_THREADINFOCLASS=THREADINFOCLASS -_SYSTEM_CODEINTEGRITY_INFORMATION=SYSTEM_CODEINTEGRITY_INFORMATION -_SYSTEM_INFORMATION_CLASS=SYSTEM_INFORMATION_CLASS -_OBJECT_INFORMATION_CLASS=OBJECT_INFORMATION_CLASS -_PUBLIC_OBJECT_BASIC_INFORMATION=PUBLIC_OBJECT_BASIC_INFORMATION -_KEY_VALUE_ENTRY=KEY_VALUE_ENTRY -_KEY_SET_INFORMATION_CLASS=KEY_SET_INFORMATION_CLASS -_WINSTATIONINFOCLASS=WINSTATIONINFOCLASS -_WINSTATIONINFORMATIONW=WINSTATIONINFORMATIONW -_LSA_TRUST_INFORMATION=LSA_TRUST_INFORMATION -_LSA_REFERENCED_DOMAIN_LIST=LSA_REFERENCED_DOMAIN_LIST -_LSA_TRANSLATED_SID2=LSA_TRANSLATED_SID2 -_LSA_TRANSLATED_NAME=LSA_TRANSLATED_NAME -_POLICY_ACCOUNT_DOMAIN_INFO=POLICY_ACCOUNT_DOMAIN_INFO -_POLICY_DNS_DOMAIN_INFO=POLICY_DNS_DOMAIN_INFO -_LSA_LOOKUP_DOMAIN_INFO_CLASS=LSA_LOOKUP_DOMAIN_INFO_CLASS -_SECURITY_LOGON_TYPE=SECURITY_LOGON_TYPE -_SE_ADT_PARAMETER_TYPE=SE_ADT_PARAMETER_TYPE -_SE_ADT_OBJECT_TYPE=SE_ADT_OBJECT_TYPE -_SE_ADT_PARAMETER_ARRAY_ENTRY=SE_ADT_PARAMETER_ARRAY_ENTRY -_SE_ADT_ACCESS_REASON=SE_ADT_ACCESS_REASON -_SE_ADT_CLAIMS=SE_ADT_CLAIMS -_SE_ADT_PARAMETER_ARRAY=SE_ADT_PARAMETER_ARRAY -_SE_ADT_PARAMETER_ARRAY_EX=SE_ADT_PARAMETER_ARRAY_EX -_POLICY_AUDIT_EVENT_TYPE=POLICY_AUDIT_EVENT_TYPE -_LSA_TRANSLATED_SID=LSA_TRANSLATED_SID -_POLICY_LSA_SERVER_ROLE=POLICY_LSA_SERVER_ROLE -_POLICY_INFORMATION_CLASS=POLICY_INFORMATION_CLASS -_POLICY_AUDIT_LOG_INFO=POLICY_AUDIT_LOG_INFO -_POLICY_AUDIT_EVENTS_INFO=POLICY_AUDIT_EVENTS_INFO -_POLICY_AUDIT_SUBCATEGORIES_INFO=POLICY_AUDIT_SUBCATEGORIES_INFO -_POLICY_AUDIT_CATEGORIES_INFO=POLICY_AUDIT_CATEGORIES_INFO -_POLICY_PRIMARY_DOMAIN_INFO=POLICY_PRIMARY_DOMAIN_INFO -_POLICY_PD_ACCOUNT_INFO=POLICY_PD_ACCOUNT_INFO -_POLICY_LSA_SERVER_ROLE_INFO=POLICY_LSA_SERVER_ROLE_INFO -_POLICY_REPLICA_SOURCE_INFO=POLICY_REPLICA_SOURCE_INFO -_POLICY_DEFAULT_QUOTA_INFO=POLICY_DEFAULT_QUOTA_INFO -_POLICY_MODIFICATION_INFO=POLICY_MODIFICATION_INFO -_POLICY_AUDIT_FULL_SET_INFO=POLICY_AUDIT_FULL_SET_INFO -_POLICY_AUDIT_FULL_QUERY_INFO=POLICY_AUDIT_FULL_QUERY_INFO -_POLICY_DOMAIN_INFORMATION_CLASS=POLICY_DOMAIN_INFORMATION_CLASS -_POLICY_DOMAIN_EFS_INFO=POLICY_DOMAIN_EFS_INFO -_POLICY_DOMAIN_KERBEROS_TICKET_INFO=POLICY_DOMAIN_KERBEROS_TICKET_INFO -_POLICY_MACHINE_ACCT_INFO=POLICY_MACHINE_ACCT_INFO -_POLICY_NOTIFICATION_INFORMATION_CLASS=POLICY_NOTIFICATION_INFORMATION_CLASS -_TRUSTED_INFORMATION_CLASS=TRUSTED_INFORMATION_CLASS -_TRUSTED_DOMAIN_NAME_INFO=TRUSTED_DOMAIN_NAME_INFO -_TRUSTED_CONTROLLERS_INFO=TRUSTED_CONTROLLERS_INFO -_TRUSTED_POSIX_OFFSET_INFO=TRUSTED_POSIX_OFFSET_INFO -_TRUSTED_PASSWORD_INFO=TRUSTED_PASSWORD_INFO -_TRUSTED_DOMAIN_INFORMATION_EX=TRUSTED_DOMAIN_INFORMATION_EX -_TRUSTED_DOMAIN_INFORMATION_EX2=TRUSTED_DOMAIN_INFORMATION_EX2 -_LSA_AUTH_INFORMATION=LSA_AUTH_INFORMATION -_TRUSTED_DOMAIN_AUTH_INFORMATION=TRUSTED_DOMAIN_AUTH_INFORMATION -_TRUSTED_DOMAIN_FULL_INFORMATION=TRUSTED_DOMAIN_FULL_INFORMATION -_TRUSTED_DOMAIN_FULL_INFORMATION2=TRUSTED_DOMAIN_FULL_INFORMATION2 -_TRUSTED_DOMAIN_SUPPORTED_ENCRYPTION_TYPES=TRUSTED_DOMAIN_SUPPORTED_ENCRYPTION_TYPES -_LSA_FOREST_TRUST_DOMAIN_INFO=LSA_FOREST_TRUST_DOMAIN_INFO -_LSA_FOREST_TRUST_BINARY_DATA=LSA_FOREST_TRUST_BINARY_DATA -_LSA_FOREST_TRUST_RECORD=LSA_FOREST_TRUST_RECORD -_LSA_FOREST_TRUST_INFORMATION=LSA_FOREST_TRUST_INFORMATION -_LSA_FOREST_TRUST_COLLISION_RECORD=LSA_FOREST_TRUST_COLLISION_RECORD -_LSA_FOREST_TRUST_COLLISION_INFORMATION=LSA_FOREST_TRUST_COLLISION_INFORMATION -_LSA_ENUMERATION_INFORMATION=LSA_ENUMERATION_INFORMATION -_LSA_LAST_INTER_LOGON_INFO=LSA_LAST_INTER_LOGON_INFO -_SECURITY_LOGON_SESSION_DATA=SECURITY_LOGON_SESSION_DATA -_CENTRAL_ACCESS_POLICY_ENTRY=CENTRAL_ACCESS_POLICY_ENTRY -_CENTRAL_ACCESS_POLICY=CENTRAL_ACCESS_POLICY -_NEGOTIATE_PACKAGE_PREFIX=NEGOTIATE_PACKAGE_PREFIX -_NEGOTIATE_PACKAGE_PREFIXES=NEGOTIATE_PACKAGE_PREFIXES -_NEGOTIATE_CALLER_NAME_REQUEST=NEGOTIATE_CALLER_NAME_REQUEST -_NEGOTIATE_CALLER_NAME_RESPONSE=NEGOTIATE_CALLER_NAME_RESPONSE -_DOMAIN_PASSWORD_INFORMATION=DOMAIN_PASSWORD_INFORMATION -_MSV1_0_LOGON_SUBMIT_TYPE=MSV1_0_LOGON_SUBMIT_TYPE -_MSV1_0_PROFILE_BUFFER_TYPE=MSV1_0_PROFILE_BUFFER_TYPE -_MSV1_0_INTERACTIVE_LOGON=MSV1_0_INTERACTIVE_LOGON -_MSV1_0_INTERACTIVE_PROFILE=MSV1_0_INTERACTIVE_PROFILE -_MSV1_0_LM20_LOGON=MSV1_0_LM20_LOGON -_MSV1_0_SUBAUTH_LOGON=MSV1_0_SUBAUTH_LOGON -_MSV1_0_S4U_LOGON=MSV1_0_S4U_LOGON -_MSV1_0_LM20_LOGON_PROFILE=MSV1_0_LM20_LOGON_PROFILE -_MSV1_0_CREDENTIAL_KEY_TYPE=MSV1_0_CREDENTIAL_KEY_TYPE -_MSV1_0_CREDENTIAL_KEY=MSV1_0_CREDENTIAL_KEY -_MSV1_0_SUPPLEMENTAL_CREDENTIAL=MSV1_0_SUPPLEMENTAL_CREDENTIAL -_MSV1_0_SUPPLEMENTAL_CREDENTIAL_V2=MSV1_0_SUPPLEMENTAL_CREDENTIAL_V2 -_MSV1_0_SUPPLEMENTAL_CREDENTIAL_V3=MSV1_0_SUPPLEMENTAL_CREDENTIAL_V3 -_MSV1_0_IUM_SUPPLEMENTAL_CREDENTIAL=MSV1_0_IUM_SUPPLEMENTAL_CREDENTIAL -_MSV1_0_REMOTE_SUPPLEMENTAL_CREDENTIAL=MSV1_0_REMOTE_SUPPLEMENTAL_CREDENTIAL -_MSV1_0_NTLM3_RESPONSE=MSV1_0_NTLM3_RESPONSE -_MSV1_0_AV_PAIR=MSV1_0_AV_PAIR -_MSV1_0_PROTOCOL_MESSAGE_TYPE=MSV1_0_PROTOCOL_MESSAGE_TYPE -_MSV1_0_CHANGEPASSWORD_REQUEST=MSV1_0_CHANGEPASSWORD_REQUEST -_MSV1_0_CHANGEPASSWORD_RESPONSE=MSV1_0_CHANGEPASSWORD_RESPONSE -_MSV1_0_PASSTHROUGH_REQUEST=MSV1_0_PASSTHROUGH_REQUEST -_MSV1_0_PASSTHROUGH_RESPONSE=MSV1_0_PASSTHROUGH_RESPONSE -_MSV1_0_SUBAUTH_REQUEST=MSV1_0_SUBAUTH_REQUEST -_MSV1_0_SUBAUTH_RESPONSE=MSV1_0_SUBAUTH_RESPONSE -_KERB_LOGON_SUBMIT_TYPE=KERB_LOGON_SUBMIT_TYPE -_KERB_INTERACTIVE_LOGON=KERB_INTERACTIVE_LOGON -_KERB_INTERACTIVE_UNLOCK_LOGON=KERB_INTERACTIVE_UNLOCK_LOGON -_KERB_SMART_CARD_LOGON=KERB_SMART_CARD_LOGON -_KERB_SMART_CARD_UNLOCK_LOGON=KERB_SMART_CARD_UNLOCK_LOGON -_KERB_CERTIFICATE_LOGON=KERB_CERTIFICATE_LOGON -_KERB_CERTIFICATE_UNLOCK_LOGON=KERB_CERTIFICATE_UNLOCK_LOGON -_KERB_CERTIFICATE_S4U_LOGON=KERB_CERTIFICATE_S4U_LOGON -_KERB_TICKET_LOGON=KERB_TICKET_LOGON -_KERB_TICKET_UNLOCK_LOGON=KERB_TICKET_UNLOCK_LOGON -_KERB_S4U_LOGON=KERB_S4U_LOGON -_KERB_PROFILE_BUFFER_TYPE=KERB_PROFILE_BUFFER_TYPE -_KERB_INTERACTIVE_PROFILE=KERB_INTERACTIVE_PROFILE -_KERB_SMART_CARD_PROFILE=KERB_SMART_CARD_PROFILE -_KERB_TICKET_PROFILE=KERB_TICKET_PROFILE -_KERB_PROTOCOL_MESSAGE_TYPE=KERB_PROTOCOL_MESSAGE_TYPE -_KERB_QUERY_TKT_CACHE_REQUEST=KERB_QUERY_TKT_CACHE_REQUEST -_KERB_TICKET_CACHE_INFO=KERB_TICKET_CACHE_INFO -_KERB_TICKET_CACHE_INFO_EX=KERB_TICKET_CACHE_INFO_EX -_KERB_TICKET_CACHE_INFO_EX2=KERB_TICKET_CACHE_INFO_EX2 -_KERB_TICKET_CACHE_INFO_EX3=KERB_TICKET_CACHE_INFO_EX3 -_KERB_QUERY_TKT_CACHE_RESPONSE=KERB_QUERY_TKT_CACHE_RESPONSE -_KERB_QUERY_TKT_CACHE_EX_RESPONSE=KERB_QUERY_TKT_CACHE_EX_RESPONSE -_KERB_QUERY_TKT_CACHE_EX2_RESPONSE=KERB_QUERY_TKT_CACHE_EX2_RESPONSE -_KERB_QUERY_TKT_CACHE_EX3_RESPONSE=KERB_QUERY_TKT_CACHE_EX3_RESPONSE -_SecHandle=SecHandle -_KERB_AUTH_DATA=KERB_AUTH_DATA -_KERB_NET_ADDRESS=KERB_NET_ADDRESS -_KERB_NET_ADDRESSES=KERB_NET_ADDRESSES -_KERB_EXTERNAL_NAME=KERB_EXTERNAL_NAME -_KERB_EXTERNAL_TICKET=KERB_EXTERNAL_TICKET -_KERB_RETRIEVE_TKT_REQUEST=KERB_RETRIEVE_TKT_REQUEST -_KERB_RETRIEVE_TKT_RESPONSE=KERB_RETRIEVE_TKT_RESPONSE -_KERB_PURGE_TKT_CACHE_REQUEST=KERB_PURGE_TKT_CACHE_REQUEST -_KERB_PURGE_TKT_CACHE_EX_REQUEST=KERB_PURGE_TKT_CACHE_EX_REQUEST -_KERB_SUBMIT_TKT_REQUEST=KERB_SUBMIT_TKT_REQUEST -_KERB_QUERY_KDC_PROXY_CACHE_REQUEST=KERB_QUERY_KDC_PROXY_CACHE_REQUEST -_KDC_PROXY_CACHE_ENTRY_DATA=KDC_PROXY_CACHE_ENTRY_DATA -_KERB_QUERY_KDC_PROXY_CACHE_RESPONSE=KERB_QUERY_KDC_PROXY_CACHE_RESPONSE -_KERB_PURGE_KDC_PROXY_CACHE_REQUEST=KERB_PURGE_KDC_PROXY_CACHE_REQUEST -_KERB_PURGE_KDC_PROXY_CACHE_RESPONSE=KERB_PURGE_KDC_PROXY_CACHE_RESPONSE -_KERB_S4U2PROXY_CACHE_ENTRY_INFO=KERB_S4U2PROXY_CACHE_ENTRY_INFO -_KERB_S4U2PROXY_CRED=KERB_S4U2PROXY_CRED -_KERB_QUERY_S4U2PROXY_CACHE_REQUEST=KERB_QUERY_S4U2PROXY_CACHE_REQUEST -_KERB_QUERY_S4U2PROXY_CACHE_RESPONSE=KERB_QUERY_S4U2PROXY_CACHE_RESPONSE -_KERB_RETRIEVE_KEY_TAB_REQUEST=KERB_RETRIEVE_KEY_TAB_REQUEST -_KERB_RETRIEVE_KEY_TAB_RESPONSE=KERB_RETRIEVE_KEY_TAB_RESPONSE -_KERB_CHANGEPASSWORD_REQUEST=KERB_CHANGEPASSWORD_REQUEST -_KERB_SETPASSWORD_REQUEST=KERB_SETPASSWORD_REQUEST -_KERB_SETPASSWORD_EX_REQUEST=KERB_SETPASSWORD_EX_REQUEST -_KERB_DECRYPT_REQUEST=KERB_DECRYPT_REQUEST -_KERB_DECRYPT_RESPONSE=KERB_DECRYPT_RESPONSE -_KERB_ADD_BINDING_CACHE_ENTRY_REQUEST=KERB_ADD_BINDING_CACHE_ENTRY_REQUEST -_KERB_REFRESH_SCCRED_REQUEST=KERB_REFRESH_SCCRED_REQUEST -_KERB_ADD_CREDENTIALS_REQUEST=KERB_ADD_CREDENTIALS_REQUEST -_KERB_ADD_CREDENTIALS_REQUEST_EX=KERB_ADD_CREDENTIALS_REQUEST_EX -_KERB_TRANSFER_CRED_REQUEST=KERB_TRANSFER_CRED_REQUEST -_KERB_CLEANUP_MACHINE_PKINIT_CREDS_REQUEST=KERB_CLEANUP_MACHINE_PKINIT_CREDS_REQUEST -_KERB_BINDING_CACHE_ENTRY_DATA=KERB_BINDING_CACHE_ENTRY_DATA -_KERB_QUERY_BINDING_CACHE_RESPONSE=KERB_QUERY_BINDING_CACHE_RESPONSE -_KERB_ADD_BINDING_CACHE_ENTRY_EX_REQUEST=KERB_ADD_BINDING_CACHE_ENTRY_EX_REQUEST -_KERB_QUERY_BINDING_CACHE_REQUEST=KERB_QUERY_BINDING_CACHE_REQUEST -_KERB_PURGE_BINDING_CACHE_REQUEST=KERB_PURGE_BINDING_CACHE_REQUEST -_KERB_QUERY_DOMAIN_EXTENDED_POLICIES_REQUEST=KERB_QUERY_DOMAIN_EXTENDED_POLICIES_REQUEST -_KERB_QUERY_DOMAIN_EXTENDED_POLICIES_RESPONSE=KERB_QUERY_DOMAIN_EXTENDED_POLICIES_RESPONSE -_KERB_CERTIFICATE_INFO_TYPE=KERB_CERTIFICATE_INFO_TYPE -_KERB_CERTIFICATE_HASHINFO=KERB_CERTIFICATE_HASHINFO -_KERB_CERTIFICATE_INFO=KERB_CERTIFICATE_INFO -_POLICY_AUDIT_SID_ARRAY=POLICY_AUDIT_SID_ARRAY -_AUDIT_POLICY_INFORMATION=AUDIT_POLICY_INFORMATION -_PKU2U_CERT_BLOB=PKU2U_CERT_BLOB -_PKU2U_CREDUI_CONTEXT=PKU2U_CREDUI_CONTEXT -_PKU2U_LOGON_SUBMIT_TYPE=PKU2U_LOGON_SUBMIT_TYPE -_PKU2U_CERTIFICATE_S4U_LOGON=PKU2U_CERTIFICATE_S4U_LOGON -_SE_OBJECT_TYPE=SE_OBJECT_TYPE -_TRUSTEE_TYPE=TRUSTEE_TYPE -_TRUSTEE_FORM=TRUSTEE_FORM -_MULTIPLE_TRUSTEE_OPERATION=MULTIPLE_TRUSTEE_OPERATION -_OBJECTS_AND_SID=OBJECTS_AND_SID -_OBJECTS_AND_NAME_A=OBJECTS_AND_NAME_A -_OBJECTS_AND_NAME_W=OBJECTS_AND_NAME_W -_TRUSTEE_A=TRUSTEE_A -_TRUSTEE_W=TRUSTEE_W -_ACCESS_MODE=ACCESS_MODE -_EXPLICIT_ACCESS_A=EXPLICIT_ACCESS_A -_EXPLICIT_ACCESS_W=EXPLICIT_ACCESS_W -_ACTRL_ACCESS_ENTRYA=ACTRL_ACCESS_ENTRYA -_ACTRL_ACCESS_ENTRYW=ACTRL_ACCESS_ENTRYW -_ACTRL_ACCESS_ENTRY_LISTA=ACTRL_ACCESS_ENTRY_LISTA -_ACTRL_ACCESS_ENTRY_LISTW=ACTRL_ACCESS_ENTRY_LISTW -_ACTRL_PROPERTY_ENTRYA=ACTRL_PROPERTY_ENTRYA -_ACTRL_PROPERTY_ENTRYW=ACTRL_PROPERTY_ENTRYW -_TRUSTEE_ACCESSA=TRUSTEE_ACCESSA -_TRUSTEE_ACCESSW=TRUSTEE_ACCESSW -_ACTRL_OVERLAPPED=ACTRL_OVERLAPPED -_ACTRL_ACCESS_INFOA=ACTRL_ACCESS_INFOA -_ACTRL_ACCESS_INFOW=ACTRL_ACCESS_INFOW -_ACTRL_CONTROL_INFOA=ACTRL_CONTROL_INFOA -_ACTRL_CONTROL_INFOW=ACTRL_CONTROL_INFOW -_INHERITED_FROMA=INHERITED_FROMA -_INHERITED_FROMW=INHERITED_FROMW -_WCT_OBJECT_TYPE=WCT_OBJECT_TYPE -_WCT_OBJECT_STATUS=WCT_OBJECT_STATUS -_WAITCHAIN_NODE_INFO=WAITCHAIN_NODE_INFO -_WNODE_HEADER=WNODE_HEADER -_EVENT_TRACE_HEADER=EVENT_TRACE_HEADER -_EVENT_INSTANCE_HEADER=EVENT_INSTANCE_HEADER -_MOF_FIELD=MOF_FIELD -_TRACE_LOGFILE_HEADER=TRACE_LOGFILE_HEADER -_TRACE_LOGFILE_HEADER32=TRACE_LOGFILE_HEADER32 -_TRACE_LOGFILE_HEADER64=TRACE_LOGFILE_HEADER64 -_EVENT_FILTER_DESCRIPTOR=EVENT_FILTER_DESCRIPTOR -_EVENT_TRACE_PROPERTIES=EVENT_TRACE_PROPERTIES -_EVENT_TRACE_PROPERTIES_V2=EVENT_TRACE_PROPERTIES_V2 -_TRACE_GUID_REGISTRATION=TRACE_GUID_REGISTRATION -_TRACE_GUID_PROPERTIES=TRACE_GUID_PROPERTIES -_ETW_BUFFER_CONTEXT=ETW_BUFFER_CONTEXT -_TRACE_ENABLE_INFO=TRACE_ENABLE_INFO -_TRACE_PROVIDER_INSTANCE_INFO=TRACE_PROVIDER_INSTANCE_INFO -_TRACE_GUID_INFO=TRACE_GUID_INFO -_PROFILE_SOURCE_INFO=PROFILE_SOURCE_INFO -_EVENT_TRACE=EVENT_TRACE -_EVENT_RECORD=EVENT_RECORD -_EVENT_TRACE_LOGFILEW=EVENT_TRACE_LOGFILEW -_EVENT_TRACE_LOGFILEA=EVENT_TRACE_LOGFILEA -_ENABLE_TRACE_PARAMETERS_V1=ENABLE_TRACE_PARAMETERS_V1 -_ENABLE_TRACE_PARAMETERS=ENABLE_TRACE_PARAMETERS -_TRACE_QUERY_INFO_CLASS=TRACE_QUERY_INFO_CLASS -_CLASSIC_EVENT_ID=CLASSIC_EVENT_ID -_TRACE_PROFILE_INTERVAL=TRACE_PROFILE_INTERVAL -_TRACE_VERSION_INFO=TRACE_VERSION_INFO -_TRACE_PERIODIC_CAPTURE_STATE_INFO=TRACE_PERIODIC_CAPTURE_STATE_INFO -_ETW_PROCESS_HANDLE_INFO_TYPE=ETW_PROCESS_HANDLE_INFO_TYPE -_ETW_TRACE_PARTITION_INFORMATION=ETW_TRACE_PARTITION_INFORMATION -_ETW_TRACE_PARTITION_INFORMATION_V2=ETW_TRACE_PARTITION_INFORMATION_V2 -_INSTALLSPECTYPE=INSTALLSPECTYPE -_INSTALLSPEC=INSTALLSPEC -_INSTALLDATA=INSTALLDATA -_LOCALMANAGEDAPPLICATION=LOCALMANAGEDAPPLICATION -_MANAGEDAPPLICATION=MANAGEDAPPLICATION -_APPCATEGORYINFO=APPCATEGORYINFO -_APPCATEGORYINFOLIST=APPCATEGORYINFOLIST -_PERF_COUNTERSET_INFO=PERF_COUNTERSET_INFO -_PERF_COUNTER_INFO=PERF_COUNTER_INFO -_PERF_COUNTERSET_INSTANCE=PERF_COUNTERSET_INSTANCE -_PERF_COUNTER_IDENTITY=PERF_COUNTER_IDENTITY -_PERF_INSTANCE_HEADER=PERF_INSTANCE_HEADER -_PerfRegInfoType=PerfRegInfoType -_PERF_COUNTERSET_REG_INFO=PERF_COUNTERSET_REG_INFO -_PERF_COUNTER_REG_INFO=PERF_COUNTER_REG_INFO -_PERF_COUNTER_IDENTIFIER=PERF_COUNTER_IDENTIFIER -_PERF_DATA_HEADER=PERF_DATA_HEADER -_PerfCounterDataType=PerfCounterDataType -_PERF_COUNTER_HEADER=PERF_COUNTER_HEADER -_PERF_MULTI_INSTANCES=PERF_MULTI_INSTANCES -_PERF_MULTI_COUNTERS=PERF_MULTI_COUNTERS -_PERF_COUNTER_DATA=PERF_COUNTER_DATA -_SAFER_CODE_PROPERTIES_V1=SAFER_CODE_PROPERTIES_V1 -_SAFER_CODE_PROPERTIES_V2=SAFER_CODE_PROPERTIES_V2 -_SAFER_POLICY_INFO_CLASS=SAFER_POLICY_INFO_CLASS -_SAFER_OBJECT_INFO_CLASS=SAFER_OBJECT_INFO_CLASS -_SAFER_IDENTIFICATION_TYPES=SAFER_IDENTIFICATION_TYPES -_SAFER_IDENTIFICATION_HEADER=SAFER_IDENTIFICATION_HEADER -_SAFER_PATHNAME_IDENTIFICATION=SAFER_PATHNAME_IDENTIFICATION -_SAFER_HASH_IDENTIFICATION=SAFER_HASH_IDENTIFICATION -_SAFER_HASH_IDENTIFICATION2=SAFER_HASH_IDENTIFICATION2 -_SAFER_URLZONE_IDENTIFICATION=SAFER_URLZONE_IDENTIFICATION -_PNP_VETO_TYPE=PNP_VETO_TYPE -_CONFLICT_DETAILS_A=CONFLICT_DETAILS_A -_CONFLICT_DETAILS_W=CONFLICT_DETAILS_W -_CM_NOTIFY_FILTER_TYPE=CM_NOTIFY_FILTER_TYPE -_CM_NOTIFY_FILTER=CM_NOTIFY_FILTER -_CM_NOTIFY_ACTION=CM_NOTIFY_ACTION -_CM_NOTIFY_EVENT_DATA=CM_NOTIFY_EVENT_DATA -_SHITEMID=SHITEMID -_ITEMIDLIST=ITEMIDLIST -_STRRET=STRRET -_SHELLDETAILS=SHELLDETAILS -_COMDLG_FILTERSPEC=COMDLG_FILTERSPEC -_DLLVERSIONINFO=DLLVERSIONINFO -_DLLVERSIONINFO2=DLLVERSIONINFO2 -_IMAGELISTDRAWPARAMS=IMAGELISTDRAWPARAMS -_IMAGEINFO=IMAGEINFO -_HD_TEXTFILTERA=HD_TEXTFILTERA -_HD_TEXTFILTERW=HD_TEXTFILTERW -_TBBUTTON=TBBUTTON -_COLORMAP=COLORMAP -_NMTBCUSTOMDRAW=NMTBCUSTOMDRAW -_TTGETTITLE=TTGETTITLE -_UDACCEL=UDACCEL -_TVITEMPART=TVITEMPART -_TASKDIALOG_MESSAGES=TASKDIALOG_MESSAGES -_TASKDIALOG_NOTIFICATIONS=TASKDIALOG_NOTIFICATIONS -_TASKDIALOG_BUTTON=TASKDIALOG_BUTTON -_TASKDIALOG_ELEMENTS=TASKDIALOG_ELEMENTS -_TASKDIALOG_ICON_ELEMENTS=TASKDIALOG_ICON_ELEMENTS -_TASKDIALOGCONFIG=TASKDIALOGCONFIG -_DPASTREAMINFO=DPASTREAMINFO -_CMINVOKECOMMANDINFO=CMINVOKECOMMANDINFO -_CMINVOKECOMMANDINFOEX=CMINVOKECOMMANDINFOEX -_PERSIST_FOLDER_TARGET_INFO=PERSIST_FOLDER_TARGET_INFO -_SV2CVW2_PARAMS=SV2CVW2_PARAMS -_SIGDN=SIGDN -_SPACTION=SPACTION -_SPTEXT=SPTEXT -_NRESARRAY=NRESARRAY -_FILEDESCRIPTORA=FILEDESCRIPTORA -_FILEDESCRIPTORW=FILEDESCRIPTORW -_FILEGROUPDESCRIPTORA=FILEGROUPDESCRIPTORA -_FILEGROUPDESCRIPTORW=FILEGROUPDESCRIPTORW -_DROPFILES=DROPFILES -_SHChangeNotifyEntry=SHChangeNotifyEntry -_SHChangeDWORDAsIDList=SHChangeDWORDAsIDList -_SHChangeUpdateImageIDList=SHChangeUpdateImageIDList -_SHDESCRIPTIONID=SHDESCRIPTIONID -_QCMINFO_IDMAP_PLACEMENT=QCMINFO_IDMAP_PLACEMENT -_QCMINFO_IDMAP=QCMINFO_IDMAP -_QCMINFO=QCMINFO -_DETAILSINFO=DETAILSINFO -_SFVM_PROPPAGE_DATA=SFVM_PROPPAGE_DATA -_SFVM_HELPTOPIC_DATA=SFVM_HELPTOPIC_DATA -_ITEMSPACING=ITEMSPACING -_SFV_CREATE=SFV_CREATE -_CSFV=CSFV -_SHChangeProductKeyAsIDList=SHChangeProductKeyAsIDList -_TBINFO=TBINFO -_SFV_SETITEMPOS=SFV_SETITEMPOS -_AUDIT_PARAM_TYPE=AUDIT_PARAM_TYPE -_AUDIT_OBJECT_TYPE=AUDIT_OBJECT_TYPE -_AUDIT_OBJECT_TYPES=AUDIT_OBJECT_TYPES -_AUDIT_IP_ADDRESS=AUDIT_IP_ADDRESS -_AUDIT_PARAM=AUDIT_PARAM -_AUDIT_PARAMS=AUDIT_PARAMS -_AUTHZ_AUDIT_EVENT_TYPE_LEGACY=AUTHZ_AUDIT_EVENT_TYPE_LEGACY -_AUTHZ_AUDIT_EVENT_TYPE_UNION=AUTHZ_AUDIT_EVENT_TYPE_UNION -_AUTHZ_AUDIT_EVENT_TYPE_OLD=AUTHZ_AUDIT_EVENT_TYPE_OLD -_AUTHZ_ACCESS_REQUEST=AUTHZ_ACCESS_REQUEST -_AUTHZ_ACCESS_REPLY=AUTHZ_ACCESS_REPLY -_AUTHZ_SECURITY_ATTRIBUTE_FQBN_VALUE=AUTHZ_SECURITY_ATTRIBUTE_FQBN_VALUE -_AUTHZ_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE=AUTHZ_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE -_AUTHZ_SECURITY_ATTRIBUTE_V1=AUTHZ_SECURITY_ATTRIBUTE_V1 -_AUTHZ_SECURITY_ATTRIBUTES_INFORMATION=AUTHZ_SECURITY_ATTRIBUTES_INFORMATION -_AUTHZ_RPC_INIT_INFO_CLIENT=AUTHZ_RPC_INIT_INFO_CLIENT -_AUTHZ_INIT_INFO=AUTHZ_INIT_INFO -_AUTHZ_CONTEXT_INFORMATION_CLASS=AUTHZ_CONTEXT_INFORMATION_CLASS -_AUTHZ_AUDIT_EVENT_INFORMATION_CLASS=AUTHZ_AUDIT_EVENT_INFORMATION_CLASS -_AUTHZ_REGISTRATION_OBJECT_TYPE_NAME_OFFSET=AUTHZ_REGISTRATION_OBJECT_TYPE_NAME_OFFSET -_AUTHZ_SOURCE_SCHEMA_REGISTRATION=AUTHZ_SOURCE_SCHEMA_REGISTRATION -_DFS_TARGET_PRIORITY_CLASS=DFS_TARGET_PRIORITY_CLASS -_DFS_TARGET_PRIORITY=DFS_TARGET_PRIORITY -_DFS_INFO_1=DFS_INFO_1 -_DFS_INFO_2=DFS_INFO_2 -_DFS_STORAGE_INFO=DFS_STORAGE_INFO -_DFS_STORAGE_INFO_1=DFS_STORAGE_INFO_1 -_DFS_INFO_3=DFS_INFO_3 -_DFS_INFO_4=DFS_INFO_4 -_DFS_INFO_5=DFS_INFO_5 -_DFS_INFO_6=DFS_INFO_6 -_DFS_INFO_7=DFS_INFO_7 -_DFS_INFO_8=DFS_INFO_8 -_DFS_INFO_9=DFS_INFO_9 -_DFS_INFO_50=DFS_INFO_50 -_DFS_INFO_100=DFS_INFO_100 -_DFS_INFO_101=DFS_INFO_101 -_DFS_INFO_102=DFS_INFO_102 -_DFS_INFO_103=DFS_INFO_103 -_DFS_INFO_104=DFS_INFO_104 -_DFS_INFO_105=DFS_INFO_105 -_DFS_INFO_106=DFS_INFO_106 -_DFS_INFO_107=DFS_INFO_107 -_DFS_INFO_150=DFS_INFO_150 -_DFS_INFO_200=DFS_INFO_200 -_DFS_INFO_300=DFS_INFO_300 -_DFS_SUPPORTED_NAMESPACE_VERSION_INFO=DFS_SUPPORTED_NAMESPACE_VERSION_INFO -_USER_INFO_0=USER_INFO_0 -_USER_INFO_1=USER_INFO_1 -_USER_INFO_2=USER_INFO_2 -_USER_INFO_3=USER_INFO_3 -_USER_INFO_4=USER_INFO_4 -_USER_INFO_10=USER_INFO_10 -_USER_INFO_11=USER_INFO_11 -_USER_INFO_20=USER_INFO_20 -_USER_INFO_21=USER_INFO_21 -_USER_INFO_22=USER_INFO_22 -_USER_INFO_23=USER_INFO_23 -_USER_INFO_24=USER_INFO_24 -_USER_INFO_1003=USER_INFO_1003 -_USER_INFO_1005=USER_INFO_1005 -_USER_INFO_1006=USER_INFO_1006 -_USER_INFO_1007=USER_INFO_1007 -_USER_INFO_1008=USER_INFO_1008 -_USER_INFO_1009=USER_INFO_1009 -_USER_INFO_1010=USER_INFO_1010 -_USER_INFO_1011=USER_INFO_1011 -_USER_INFO_1012=USER_INFO_1012 -_USER_INFO_1013=USER_INFO_1013 -_USER_INFO_1014=USER_INFO_1014 -_USER_INFO_1017=USER_INFO_1017 -_USER_INFO_1018=USER_INFO_1018 -_USER_INFO_1020=USER_INFO_1020 -_USER_INFO_1023=USER_INFO_1023 -_USER_INFO_1024=USER_INFO_1024 -_USER_INFO_1025=USER_INFO_1025 -_USER_INFO_1051=USER_INFO_1051 -_USER_INFO_1052=USER_INFO_1052 -_USER_INFO_1053=USER_INFO_1053 -_USER_MODALS_INFO_0=USER_MODALS_INFO_0 -_USER_MODALS_INFO_1=USER_MODALS_INFO_1 -_USER_MODALS_INFO_2=USER_MODALS_INFO_2 -_USER_MODALS_INFO_3=USER_MODALS_INFO_3 -_USER_MODALS_INFO_1001=USER_MODALS_INFO_1001 -_USER_MODALS_INFO_1002=USER_MODALS_INFO_1002 -_USER_MODALS_INFO_1003=USER_MODALS_INFO_1003 -_USER_MODALS_INFO_1004=USER_MODALS_INFO_1004 -_USER_MODALS_INFO_1005=USER_MODALS_INFO_1005 -_USER_MODALS_INFO_1006=USER_MODALS_INFO_1006 -_USER_MODALS_INFO_1007=USER_MODALS_INFO_1007 -_GROUP_INFO_0=GROUP_INFO_0 -_GROUP_INFO_1=GROUP_INFO_1 -_GROUP_INFO_2=GROUP_INFO_2 -_GROUP_INFO_3=GROUP_INFO_3 -_GROUP_INFO_1002=GROUP_INFO_1002 -_GROUP_INFO_1005=GROUP_INFO_1005 -_GROUP_USERS_INFO_0=GROUP_USERS_INFO_0 -_GROUP_USERS_INFO_1=GROUP_USERS_INFO_1 -_LOCALGROUP_INFO_0=LOCALGROUP_INFO_0 -_LOCALGROUP_INFO_1=LOCALGROUP_INFO_1 -_LOCALGROUP_INFO_1002=LOCALGROUP_INFO_1002 -_LOCALGROUP_MEMBERS_INFO_0=LOCALGROUP_MEMBERS_INFO_0 -_LOCALGROUP_MEMBERS_INFO_1=LOCALGROUP_MEMBERS_INFO_1 -_LOCALGROUP_MEMBERS_INFO_2=LOCALGROUP_MEMBERS_INFO_2 -_LOCALGROUP_MEMBERS_INFO_3=LOCALGROUP_MEMBERS_INFO_3 -_LOCALGROUP_USERS_INFO_0=LOCALGROUP_USERS_INFO_0 -_NET_DISPLAY_USER=NET_DISPLAY_USER -_NET_DISPLAY_MACHINE=NET_DISPLAY_MACHINE -_NET_DISPLAY_GROUP=NET_DISPLAY_GROUP -_ACCESS_INFO_0=ACCESS_INFO_0 -_ACCESS_INFO_1=ACCESS_INFO_1 -_ACCESS_INFO_1002=ACCESS_INFO_1002 -_ACCESS_LIST=ACCESS_LIST -_NET_VALIDATE_PASSWORD_TYPE=NET_VALIDATE_PASSWORD_TYPE -_NET_VALIDATE_PASSWORD_HASH=NET_VALIDATE_PASSWORD_HASH -_NET_VALIDATE_PERSISTED_FIELDS=NET_VALIDATE_PERSISTED_FIELDS -_NET_VALIDATE_OUTPUT_ARG=NET_VALIDATE_OUTPUT_ARG -_NET_VALIDATE_AUTHENTICATION_INPUT_ARG=NET_VALIDATE_AUTHENTICATION_INPUT_ARG -_NET_VALIDATE_PASSWORD_CHANGE_INPUT_ARG=NET_VALIDATE_PASSWORD_CHANGE_INPUT_ARG -_NET_VALIDATE_PASSWORD_RESET_INPUT_ARG=NET_VALIDATE_PASSWORD_RESET_INPUT_ARG -_NETLOGON_INFO_1=NETLOGON_INFO_1 -_NETLOGON_INFO_2=NETLOGON_INFO_2 -_NETLOGON_INFO_3=NETLOGON_INFO_3 -_NETLOGON_INFO_4=NETLOGON_INFO_4 -_MSA_INFO_LEVEL=MSA_INFO_LEVEL -_MSA_INFO_STATE=MSA_INFO_STATE -_MSA_INFO_0=MSA_INFO_0 -_STD_ALERT=STD_ALERT -_ADMIN_OTHER_INFO=ADMIN_OTHER_INFO -_ERRLOG_OTHER_INFO=ERRLOG_OTHER_INFO -_PRINT_OTHER_INFO=PRINT_OTHER_INFO -_USER_OTHER_INFO=USER_OTHER_INFO -_SHARE_INFO_0=SHARE_INFO_0 -_SHARE_INFO_1=SHARE_INFO_1 -_SHARE_INFO_2=SHARE_INFO_2 -_SHARE_INFO_501=SHARE_INFO_501 -_SHARE_INFO_502=SHARE_INFO_502 -_SHARE_INFO_503=SHARE_INFO_503 -_SHARE_INFO_1004=SHARE_INFO_1004 -_SHARE_INFO_1005=SHARE_INFO_1005 -_SHARE_INFO_1006=SHARE_INFO_1006 -_SHARE_INFO_1501=SHARE_INFO_1501 -_SHARE_INFO_1503=SHARE_INFO_1503 -_SERVER_ALIAS_INFO_0=SERVER_ALIAS_INFO_0 -_SESSION_INFO_0=SESSION_INFO_0 -_SESSION_INFO_1=SESSION_INFO_1 -_SESSION_INFO_2=SESSION_INFO_2 -_SESSION_INFO_10=SESSION_INFO_10 -_SESSION_INFO_502=SESSION_INFO_502 -_CONNECTION_INFO_0=CONNECTION_INFO_0 -_CONNECTION_INFO_1=CONNECTION_INFO_1 -_FILE_INFO_2=FILE_INFO_2 -_FILE_INFO_3=FILE_INFO_3 -_MSG_INFO_0=MSG_INFO_0 -_MSG_INFO_1=MSG_INFO_1 -_TIME_OF_DAY_INFO=TIME_OF_DAY_INFO -_REPL_INFO_0=REPL_INFO_0 -_REPL_INFO_1000=REPL_INFO_1000 -_REPL_INFO_1001=REPL_INFO_1001 -_REPL_INFO_1002=REPL_INFO_1002 -_REPL_INFO_1003=REPL_INFO_1003 -_REPL_EDIR_INFO_0=REPL_EDIR_INFO_0 -_REPL_EDIR_INFO_1=REPL_EDIR_INFO_1 -_REPL_EDIR_INFO_2=REPL_EDIR_INFO_2 -_REPL_EDIR_INFO_1000=REPL_EDIR_INFO_1000 -_REPL_EDIR_INFO_1001=REPL_EDIR_INFO_1001 -_REPL_IDIR_INFO_0=REPL_IDIR_INFO_0 -_REPL_IDIR_INFO_1=REPL_IDIR_INFO_1 -_SERVER_INFO_100=SERVER_INFO_100 -_SERVER_INFO_101=SERVER_INFO_101 -_SERVER_INFO_102=SERVER_INFO_102 -_SERVER_INFO_103=SERVER_INFO_103 -_SERVER_INFO_402=SERVER_INFO_402 -_SERVER_INFO_403=SERVER_INFO_403 -_SERVER_INFO_502=SERVER_INFO_502 -_SERVER_INFO_503=SERVER_INFO_503 -_SERVER_INFO_599=SERVER_INFO_599 -_SERVER_INFO_598=SERVER_INFO_598 -_SERVER_INFO_1005=SERVER_INFO_1005 -_SERVER_INFO_1107=SERVER_INFO_1107 -_SERVER_INFO_1010=SERVER_INFO_1010 -_SERVER_INFO_1016=SERVER_INFO_1016 -_SERVER_INFO_1017=SERVER_INFO_1017 -_SERVER_INFO_1018=SERVER_INFO_1018 -_SERVER_INFO_1501=SERVER_INFO_1501 -_SERVER_INFO_1502=SERVER_INFO_1502 -_SERVER_INFO_1503=SERVER_INFO_1503 -_SERVER_INFO_1506=SERVER_INFO_1506 -_SERVER_INFO_1509=SERVER_INFO_1509 -_SERVER_INFO_1510=SERVER_INFO_1510 -_SERVER_INFO_1511=SERVER_INFO_1511 -_SERVER_INFO_1512=SERVER_INFO_1512 -_SERVER_INFO_1513=SERVER_INFO_1513 -_SERVER_INFO_1514=SERVER_INFO_1514 -_SERVER_INFO_1515=SERVER_INFO_1515 -_SERVER_INFO_1516=SERVER_INFO_1516 -_SERVER_INFO_1518=SERVER_INFO_1518 -_SERVER_INFO_1520=SERVER_INFO_1520 -_SERVER_INFO_1521=SERVER_INFO_1521 -_SERVER_INFO_1522=SERVER_INFO_1522 -_SERVER_INFO_1523=SERVER_INFO_1523 -_SERVER_INFO_1524=SERVER_INFO_1524 -_SERVER_INFO_1525=SERVER_INFO_1525 -_SERVER_INFO_1528=SERVER_INFO_1528 -_SERVER_INFO_1529=SERVER_INFO_1529 -_SERVER_INFO_1530=SERVER_INFO_1530 -_SERVER_INFO_1533=SERVER_INFO_1533 -_SERVER_INFO_1534=SERVER_INFO_1534 -_SERVER_INFO_1535=SERVER_INFO_1535 -_SERVER_INFO_1536=SERVER_INFO_1536 -_SERVER_INFO_1537=SERVER_INFO_1537 -_SERVER_INFO_1538=SERVER_INFO_1538 -_SERVER_INFO_1539=SERVER_INFO_1539 -_SERVER_INFO_1540=SERVER_INFO_1540 -_SERVER_INFO_1541=SERVER_INFO_1541 -_SERVER_INFO_1542=SERVER_INFO_1542 -_SERVER_INFO_1543=SERVER_INFO_1543 -_SERVER_INFO_1544=SERVER_INFO_1544 -_SERVER_INFO_1545=SERVER_INFO_1545 -_SERVER_INFO_1546=SERVER_INFO_1546 -_SERVER_INFO_1547=SERVER_INFO_1547 -_SERVER_INFO_1548=SERVER_INFO_1548 -_SERVER_INFO_1549=SERVER_INFO_1549 -_SERVER_INFO_1550=SERVER_INFO_1550 -_SERVER_INFO_1552=SERVER_INFO_1552 -_SERVER_INFO_1553=SERVER_INFO_1553 -_SERVER_INFO_1554=SERVER_INFO_1554 -_SERVER_INFO_1555=SERVER_INFO_1555 -_SERVER_INFO_1556=SERVER_INFO_1556 -_SERVER_INFO_1557=SERVER_INFO_1557 -_SERVER_INFO_1560=SERVER_INFO_1560 -_SERVER_INFO_1561=SERVER_INFO_1561 -_SERVER_INFO_1562=SERVER_INFO_1562 -_SERVER_INFO_1563=SERVER_INFO_1563 -_SERVER_INFO_1564=SERVER_INFO_1564 -_SERVER_INFO_1565=SERVER_INFO_1565 -_SERVER_INFO_1566=SERVER_INFO_1566 -_SERVER_INFO_1567=SERVER_INFO_1567 -_SERVER_INFO_1568=SERVER_INFO_1568 -_SERVER_INFO_1569=SERVER_INFO_1569 -_SERVER_INFO_1570=SERVER_INFO_1570 -_SERVER_INFO_1571=SERVER_INFO_1571 -_SERVER_INFO_1572=SERVER_INFO_1572 -_SERVER_INFO_1573=SERVER_INFO_1573 -_SERVER_INFO_1574=SERVER_INFO_1574 -_SERVER_INFO_1575=SERVER_INFO_1575 -_SERVER_INFO_1576=SERVER_INFO_1576 -_SERVER_INFO_1577=SERVER_INFO_1577 -_SERVER_INFO_1578=SERVER_INFO_1578 -_SERVER_INFO_1579=SERVER_INFO_1579 -_SERVER_INFO_1580=SERVER_INFO_1580 -_SERVER_INFO_1581=SERVER_INFO_1581 -_SERVER_INFO_1582=SERVER_INFO_1582 -_SERVER_INFO_1583=SERVER_INFO_1583 -_SERVER_INFO_1584=SERVER_INFO_1584 -_SERVER_INFO_1585=SERVER_INFO_1585 -_SERVER_INFO_1586=SERVER_INFO_1586 -_SERVER_INFO_1587=SERVER_INFO_1587 -_SERVER_INFO_1588=SERVER_INFO_1588 -_SERVER_INFO_1590=SERVER_INFO_1590 -_SERVER_INFO_1591=SERVER_INFO_1591 -_SERVER_INFO_1592=SERVER_INFO_1592 -_SERVER_INFO_1593=SERVER_INFO_1593 -_SERVER_INFO_1594=SERVER_INFO_1594 -_SERVER_INFO_1595=SERVER_INFO_1595 -_SERVER_INFO_1596=SERVER_INFO_1596 -_SERVER_INFO_1597=SERVER_INFO_1597 -_SERVER_INFO_1598=SERVER_INFO_1598 -_SERVER_INFO_1599=SERVER_INFO_1599 -_SERVER_INFO_1600=SERVER_INFO_1600 -_SERVER_INFO_1601=SERVER_INFO_1601 -_SERVER_INFO_1602=SERVER_INFO_1602 -_SERVER_TRANSPORT_INFO_0=SERVER_TRANSPORT_INFO_0 -_SERVER_TRANSPORT_INFO_1=SERVER_TRANSPORT_INFO_1 -_SERVER_TRANSPORT_INFO_2=SERVER_TRANSPORT_INFO_2 -_SERVER_TRANSPORT_INFO_3=SERVER_TRANSPORT_INFO_3 -_SERVICE_INFO_0=SERVICE_INFO_0 -_SERVICE_INFO_1=SERVICE_INFO_1 -_SERVICE_INFO_2=SERVICE_INFO_2 -_USE_INFO_0=USE_INFO_0 -_USE_INFO_1=USE_INFO_1 -_USE_INFO_2=USE_INFO_2 -_USE_INFO_3=USE_INFO_3 -_USE_INFO_4=USE_INFO_4 -_USE_INFO_5=USE_INFO_5 -_USE_OPTION_GENERIC=USE_OPTION_GENERIC _USE_OPTION_DEFFERED_CONNECTION_PARAMETERS=USE_OPTION_DEFFERED_CONNECTION_PARAMETERS -_WKSTA_INFO_100=WKSTA_INFO_100 -_WKSTA_INFO_101=WKSTA_INFO_101 -_WKSTA_INFO_102=WKSTA_INFO_102 -_WKSTA_INFO_302=WKSTA_INFO_302 -_WKSTA_INFO_402=WKSTA_INFO_402 -_WKSTA_INFO_502=WKSTA_INFO_502 -_WKSTA_INFO_1010=WKSTA_INFO_1010 -_WKSTA_INFO_1011=WKSTA_INFO_1011 -_WKSTA_INFO_1012=WKSTA_INFO_1012 -_WKSTA_INFO_1027=WKSTA_INFO_1027 -_WKSTA_INFO_1028=WKSTA_INFO_1028 -_WKSTA_INFO_1032=WKSTA_INFO_1032 -_WKSTA_INFO_1013=WKSTA_INFO_1013 -_WKSTA_INFO_1018=WKSTA_INFO_1018 -_WKSTA_INFO_1023=WKSTA_INFO_1023 -_WKSTA_INFO_1033=WKSTA_INFO_1033 -_WKSTA_INFO_1041=WKSTA_INFO_1041 -_WKSTA_INFO_1042=WKSTA_INFO_1042 -_WKSTA_INFO_1043=WKSTA_INFO_1043 -_WKSTA_INFO_1044=WKSTA_INFO_1044 -_WKSTA_INFO_1045=WKSTA_INFO_1045 -_WKSTA_INFO_1046=WKSTA_INFO_1046 -_WKSTA_INFO_1047=WKSTA_INFO_1047 -_WKSTA_INFO_1048=WKSTA_INFO_1048 -_WKSTA_INFO_1049=WKSTA_INFO_1049 -_WKSTA_INFO_1050=WKSTA_INFO_1050 -_WKSTA_INFO_1051=WKSTA_INFO_1051 -_WKSTA_INFO_1052=WKSTA_INFO_1052 -_WKSTA_INFO_1053=WKSTA_INFO_1053 -_WKSTA_INFO_1054=WKSTA_INFO_1054 -_WKSTA_INFO_1055=WKSTA_INFO_1055 -_WKSTA_INFO_1056=WKSTA_INFO_1056 -_WKSTA_INFO_1057=WKSTA_INFO_1057 -_WKSTA_INFO_1058=WKSTA_INFO_1058 -_WKSTA_INFO_1059=WKSTA_INFO_1059 -_WKSTA_INFO_1060=WKSTA_INFO_1060 -_WKSTA_INFO_1061=WKSTA_INFO_1061 -_WKSTA_INFO_1062=WKSTA_INFO_1062 -_WKSTA_USER_INFO_0=WKSTA_USER_INFO_0 -_WKSTA_USER_INFO_1=WKSTA_USER_INFO_1 -_WKSTA_USER_INFO_1101=WKSTA_USER_INFO_1101 -_WKSTA_TRANSPORT_INFO_0=WKSTA_TRANSPORT_INFO_0 -_ERROR_LOG=ERROR_LOG -_HLOG=HLOG -_CONFIG_INFO_0=CONFIG_INFO_0 -_STAT_WORKSTATION_0=STAT_WORKSTATION_0 -_STAT_SERVER_0=STAT_SERVER_0 -_AUDIT_ENTRY=AUDIT_ENTRY -_AE_SRVSTATUS=AE_SRVSTATUS -_AE_SESSLOGON=AE_SESSLOGON -_AE_SESSLOGOFF=AE_SESSLOGOFF -_AE_SESSPWERR=AE_SESSPWERR -_AE_CONNSTART=AE_CONNSTART -_AE_CONNSTOP=AE_CONNSTOP -_AE_CONNREJ=AE_CONNREJ -_AE_RESACCESS=AE_RESACCESS -_AE_RESACCESSREJ=AE_RESACCESSREJ -_AE_CLOSEFILE=AE_CLOSEFILE -_AE_SERVICESTAT=AE_SERVICESTAT -_AE_ACLMOD=AE_ACLMOD -_AE_UASMOD=AE_UASMOD -_AE_NETLOGON=AE_NETLOGON -_AE_NETLOGOFF=AE_NETLOGOFF -_AE_ACCLIM=AE_ACCLIM -_AE_LOCKOUT=AE_LOCKOUT -_AE_GENERIC=AE_GENERIC -_NETSETUP_NAME_TYPE=NETSETUP_NAME_TYPE -_DSREG_JOIN_TYPE=DSREG_JOIN_TYPE -_DSREG_USER_INFO=DSREG_USER_INFO -_DSREG_JOIN_INFO=DSREG_JOIN_INFO -_NET_COMPUTER_NAME_TYPE=NET_COMPUTER_NAME_TYPE -_NETSETUP_PROVISIONING_PARAMS=NETSETUP_PROVISIONING_PARAMS -_NETSETUP_JOIN_STATUS=NETSETUP_JOIN_STATUS -_IP4_ARRAY=IP4_ARRAY -_DNS_HEADER=DNS_HEADER -_DNS_HEADER_EXT=DNS_HEADER_EXT -_DNS_WIRE_QUESTION=DNS_WIRE_QUESTION -_DNS_WIRE_RECORD=DNS_WIRE_RECORD -_DNS_CHARSET=DNS_CHARSET -_DNS_QUERY_RESULT=DNS_QUERY_RESULT -_DNS_QUERY_REQUEST=DNS_QUERY_REQUEST -_DNS_QUERY_CANCEL=DNS_QUERY_CANCEL -_DNS_NAME_FORMAT=DNS_NAME_FORMAT -_DNS_MESSAGE_BUFFER=DNS_MESSAGE_BUFFER -_DNS_CONNECTION_PROXY_TYPE=DNS_CONNECTION_PROXY_TYPE -_DNS_CONNECTION_PROXY_INFO_SWITCH=DNS_CONNECTION_PROXY_INFO_SWITCH -_DNS_CONNECTION_PROXY_INFO=DNS_CONNECTION_PROXY_INFO -_DNS_CONNECTION_PROXY_INFO_EX=DNS_CONNECTION_PROXY_INFO_EX -_DNS_CONNECTION_PROXY_ELEMENT=DNS_CONNECTION_PROXY_ELEMENT -_DNS_CONNECTION_PROXY_LIST=DNS_CONNECTION_PROXY_LIST -_DNS_CONNECTION_NAME=DNS_CONNECTION_NAME -_DNS_CONNECTION_NAME_LIST=DNS_CONNECTION_NAME_LIST -_DNS_CONNECTION_IFINDEX_ENTRY=DNS_CONNECTION_IFINDEX_ENTRY -_DNS_CONNECTION_IFINDEX_LIST=DNS_CONNECTION_IFINDEX_LIST -_DNS_CONNECTION_POLICY_ENTRY=DNS_CONNECTION_POLICY_ENTRY -_DNS_CONNECTION_POLICY_ENTRY_LIST=DNS_CONNECTION_POLICY_ENTRY_LIST -_DNS_SERVICE_INSTANCE=DNS_SERVICE_INSTANCE -_DNS_SERVICE_CANCEL=DNS_SERVICE_CANCEL -_DNS_SERVICE_BROWSE_REQUEST=DNS_SERVICE_BROWSE_REQUEST -_DNS_SERVICE_RESOLVE_REQUEST=DNS_SERVICE_RESOLVE_REQUEST -_DNS_SERVICE_REGISTER_REQUEST=DNS_SERVICE_REGISTER_REQUEST -_MDNS_QUERY_HANDLE=MDNS_QUERY_HANDLE -_MDNS_QUERY_REQUEST=MDNS_QUERY_REQUEST -_SCHEDULE_HEADER=SCHEDULE_HEADER -_SCHEDULE=SCHEDULE -_DS_MANGLE_FOR=DS_MANGLE_FOR -_DS_REPL_INFO_TYPE=DS_REPL_INFO_TYPE -_DS_REPL_NEIGHBORW=DS_REPL_NEIGHBORW -_DS_REPL_NEIGHBORW_BLOB=DS_REPL_NEIGHBORW_BLOB -_DS_REPL_NEIGHBORSW=DS_REPL_NEIGHBORSW -_DS_REPL_CURSOR=DS_REPL_CURSOR -_DS_REPL_CURSOR_2=DS_REPL_CURSOR_2 -_DS_REPL_CURSOR_3W=DS_REPL_CURSOR_3W -_DS_REPL_CURSOR_BLOB=DS_REPL_CURSOR_BLOB -_DS_REPL_CURSORS=DS_REPL_CURSORS -_DS_REPL_CURSORS_2=DS_REPL_CURSORS_2 -_DS_REPL_CURSORS_3W=DS_REPL_CURSORS_3W -_DS_REPL_ATTR_META_DATA=DS_REPL_ATTR_META_DATA -_DS_REPL_ATTR_META_DATA_2=DS_REPL_ATTR_META_DATA_2 -_DS_REPL_ATTR_META_DATA_BLOB=DS_REPL_ATTR_META_DATA_BLOB -_DS_REPL_OBJ_META_DATA=DS_REPL_OBJ_META_DATA -_DS_REPL_OBJ_META_DATA_2=DS_REPL_OBJ_META_DATA_2 -_DS_REPL_KCC_DSA_FAILUREW=DS_REPL_KCC_DSA_FAILUREW -_DS_REPL_KCC_DSA_FAILUREW_BLOB=DS_REPL_KCC_DSA_FAILUREW_BLOB -_DS_REPL_KCC_DSA_FAILURESW=DS_REPL_KCC_DSA_FAILURESW -_DS_REPL_OP_TYPE=DS_REPL_OP_TYPE -_DS_REPL_OPW=DS_REPL_OPW -_DS_REPL_OPW_BLOB=DS_REPL_OPW_BLOB -_DS_REPL_PENDING_OPSW=DS_REPL_PENDING_OPSW -_DS_REPL_VALUE_META_DATA=DS_REPL_VALUE_META_DATA -_DS_REPL_VALUE_META_DATA_2=DS_REPL_VALUE_META_DATA_2 -_DS_REPL_VALUE_META_DATA_EXT=DS_REPL_VALUE_META_DATA_EXT -_DS_REPL_VALUE_META_DATA_BLOB=DS_REPL_VALUE_META_DATA_BLOB -_DS_REPL_VALUE_META_DATA_BLOB_EXT=DS_REPL_VALUE_META_DATA_BLOB_EXT -_DS_REPL_ATTR_VALUE_META_DATA=DS_REPL_ATTR_VALUE_META_DATA -_DS_REPL_ATTR_VALUE_META_DATA_2=DS_REPL_ATTR_VALUE_META_DATA_2 -_DS_REPL_ATTR_VALUE_META_DATA_EXT=DS_REPL_ATTR_VALUE_META_DATA_EXT -_DS_REPL_QUEUE_STATISTICSW=DS_REPL_QUEUE_STATISTICSW -_FLT_FILESYSTEM_TYPE=FLT_FILESYSTEM_TYPE -_FILTER_INFORMATION_CLASS=FILTER_INFORMATION_CLASS -_FILTER_FULL_INFORMATION=FILTER_FULL_INFORMATION -_FILTER_AGGREGATE_BASIC_INFORMATION=FILTER_AGGREGATE_BASIC_INFORMATION -_FILTER_AGGREGATE_STANDARD_INFORMATION=FILTER_AGGREGATE_STANDARD_INFORMATION -_FILTER_VOLUME_INFORMATION_CLASS=FILTER_VOLUME_INFORMATION_CLASS -_FILTER_VOLUME_BASIC_INFORMATION=FILTER_VOLUME_BASIC_INFORMATION -_FILTER_VOLUME_STANDARD_INFORMATION=FILTER_VOLUME_STANDARD_INFORMATION -_INSTANCE_INFORMATION_CLASS=INSTANCE_INFORMATION_CLASS -_INSTANCE_BASIC_INFORMATION=INSTANCE_BASIC_INFORMATION -_INSTANCE_PARTIAL_INFORMATION=INSTANCE_PARTIAL_INFORMATION -_INSTANCE_FULL_INFORMATION=INSTANCE_FULL_INFORMATION -_INSTANCE_AGGREGATE_STANDARD_INFORMATION=INSTANCE_AGGREGATE_STANDARD_INFORMATION -_FILTER_MESSAGE_HEADER=FILTER_MESSAGE_HEADER -_FILTER_REPLY_HEADER=FILTER_REPLY_HEADER -_MODULEINFO=MODULEINFO -_ENUM_PAGE_FILE_INFORMATION=ENUM_PAGE_FILE_INFORMATION -_WER_REPORT_UI=WER_REPORT_UI -_WER_REGISTER_FILE_TYPE=WER_REGISTER_FILE_TYPE -_WER_FILE_TYPE=WER_FILE_TYPE -_WER_SUBMIT_RESULT=WER_SUBMIT_RESULT -_WER_REPORT_TYPE=WER_REPORT_TYPE -_WER_REPORT_INFORMATION=WER_REPORT_INFORMATION -_WER_REPORT_INFORMATION_V3=WER_REPORT_INFORMATION_V3 -_WER_DUMP_CUSTOM_OPTIONS=WER_DUMP_CUSTOM_OPTIONS -_WER_DUMP_CUSTOM_OPTIONS_V2=WER_DUMP_CUSTOM_OPTIONS_V2 -_WER_REPORT_INFORMATION_V4=WER_REPORT_INFORMATION_V4 -_WER_REPORT_INFORMATION_V5=WER_REPORT_INFORMATION_V5 -_WER_DUMP_CUSTOM_OPTIONS_V3=WER_DUMP_CUSTOM_OPTIONS_V3 -_WER_EXCEPTION_INFORMATION=WER_EXCEPTION_INFORMATION -_WER_CONSENT=WER_CONSENT -_WER_DUMP_TYPE=WER_DUMP_TYPE -_WER_RUNTIME_EXCEPTION_INFORMATION=WER_RUNTIME_EXCEPTION_INFORMATION -_REPORT_STORE_TYPES=REPORT_STORE_TYPES -_WER_REPORT_PARAMETER=WER_REPORT_PARAMETER -_WER_REPORT_SIGNATURE=WER_REPORT_SIGNATURE -_WER_REPORT_METADATA_V2=WER_REPORT_METADATA_V2 -_WER_REPORT_METADATA_V3=WER_REPORT_METADATA_V3 -_WER_REPORT_METADATA_V1=WER_REPORT_METADATA_V1 -_NS_INFOA=NS_INFOA -_NS_INFOW=NS_INFOW -_SERVICE_TYPE_VALUE=SERVICE_TYPE_VALUE -_SERVICE_TYPE_VALUE_ABSA=SERVICE_TYPE_VALUE_ABSA -_SERVICE_TYPE_VALUE_ABSW=SERVICE_TYPE_VALUE_ABSW -_SERVICE_TYPE_INFO=SERVICE_TYPE_INFO -_SERVICE_TYPE_INFO_ABSA=SERVICE_TYPE_INFO_ABSA -_SERVICE_TYPE_INFO_ABSW=SERVICE_TYPE_INFO_ABSW -_SERVICE_ADDRESS=SERVICE_ADDRESS -_SERVICE_ADDRESSES=SERVICE_ADDRESSES -_SERVICE_INFOA=SERVICE_INFOA -_SERVICE_INFOW=SERVICE_INFOW -_NS_SERVICE_INFOA=NS_SERVICE_INFOA -_NS_SERVICE_INFOW=NS_SERVICE_INFOW -_PROTOCOL_INFOA=PROTOCOL_INFOA -_PROTOCOL_INFOW=PROTOCOL_INFOW -_NETRESOURCE2A=NETRESOURCE2A -_NETRESOURCE2W=NETRESOURCE2W -_SERVICE_ASYNC_INFO=SERVICE_ASYNC_INFO -_DL_EUI48=DL_EUI48 -_PROFILEINFOA=PROFILEINFOA -_PROFILEINFOW=PROFILEINFOW -_GPO_LINK=GPO_LINK -_GROUP_POLICY_OBJECTA=GROUP_POLICY_OBJECTA -_GROUP_POLICY_OBJECTW=GROUP_POLICY_OBJECTW -_RSOP_TARGET=RSOP_TARGET -_SETTINGSTATUS=SETTINGSTATUS -_POLICYSETTINGSTATUSINFO=POLICYSETTINGSTATUSINFO -_WEB_SOCKET_CLOSE_STATUS=WEB_SOCKET_CLOSE_STATUS -_WEB_SOCKET_PROPERTY_TYPE=WEB_SOCKET_PROPERTY_TYPE -_WEB_SOCKET_ACTION_QUEUE=WEB_SOCKET_ACTION_QUEUE -_WEB_SOCKET_BUFFER_TYPE=WEB_SOCKET_BUFFER_TYPE -_WEB_SOCKET_ACTION=WEB_SOCKET_ACTION -_WEB_SOCKET_PROPERTY=WEB_SOCKET_PROPERTY -_WEB_SOCKET_HTTP_HEADER=WEB_SOCKET_HTTP_HEADER -_WEB_SOCKET_BUFFER=WEB_SOCKET_BUFFER -_WINHTTP_PROXY_RESULT_ENTRY=WINHTTP_PROXY_RESULT_ENTRY -_WINHTTP_PROXY_RESULT=WINHTTP_PROXY_RESULT -_WINHTTP_PROXY_RESULT_EX=WINHTTP_PROXY_RESULT_EX -_WINHTTP_PROXY_SETTINGS=WINHTTP_PROXY_SETTINGS -_WINHTTP_CONNECTION_INFO=WINHTTP_CONNECTION_INFO -_WINHTTP_REQUEST_TIME_ENTRY=WINHTTP_REQUEST_TIME_ENTRY -_WINHTTP_REQUEST_TIMES=WINHTTP_REQUEST_TIMES -_WINHTTP_REQUEST_STAT_ENTRY=WINHTTP_REQUEST_STAT_ENTRY -_WINHTTP_REQUEST_STATS=WINHTTP_REQUEST_STATS -_WINHTTP_WEB_SOCKET_OPERATION=WINHTTP_WEB_SOCKET_OPERATION -_WINHTTP_WEB_SOCKET_BUFFER_TYPE=WINHTTP_WEB_SOCKET_BUFFER_TYPE -_WINHTTP_WEB_SOCKET_CLOSE_STATUS=WINHTTP_WEB_SOCKET_CLOSE_STATUS -_WINHTTP_WEB_SOCKET_ASYNC_RESULT=WINHTTP_WEB_SOCKET_ASYNC_RESULT -_WINHTTP_WEB_SOCKET_STATUS=WINHTTP_WEB_SOCKET_STATUS -_SecPkgCred_SupportedAlgs=SecPkgCred_SupportedAlgs -_SecPkgCred_CipherStrengths=SecPkgCred_CipherStrengths -_SecPkgCred_SupportedProtocols=SecPkgCred_SupportedProtocols -_SecPkgCred_ClientCertPolicy=SecPkgCred_ClientCertPolicy -_eTlsSignatureAlgorithm=eTlsSignatureAlgorithm -_eTlsHashAlgorithm=eTlsHashAlgorithm -_SecPkgContext_RemoteCredentialInfo=SecPkgContext_RemoteCredentialInfo -_SecPkgContext_LocalCredentialInfo=SecPkgContext_LocalCredentialInfo -_SecPkgContext_ClientCertPolicyResult=SecPkgContext_ClientCertPolicyResult -_SecPkgContext_IssuerListInfoEx=SecPkgContext_IssuerListInfoEx -_SecPkgContext_ConnectionInfo=SecPkgContext_ConnectionInfo -_SecPkgContext_ConnectionInfoEx=SecPkgContext_ConnectionInfoEx -_SecPkgContext_CipherInfo=SecPkgContext_CipherInfo -_SecPkgContext_EapKeyBlock=SecPkgContext_EapKeyBlock -_SecPkgContext_MappedCredAttr=SecPkgContext_MappedCredAttr -_SecPkgContext_SessionInfo=SecPkgContext_SessionInfo -_SecPkgContext_SessionAppData=SecPkgContext_SessionAppData -_SecPkgContext_EapPrfInfo=SecPkgContext_EapPrfInfo -_SecPkgContext_SupportedSignatures=SecPkgContext_SupportedSignatures -_SecPkgContext_Certificates=SecPkgContext_Certificates -_SecPkgContext_CertInfo=SecPkgContext_CertInfo -_SecPkgContext_UiInfo=SecPkgContext_UiInfo -_SecPkgContext_EarlyStart=SecPkgContext_EarlyStart -_SecPkgContext_KeyingMaterialInfo=SecPkgContext_KeyingMaterialInfo -_SecPkgContext_KeyingMaterial=SecPkgContext_KeyingMaterial -_SecPkgContext_KeyingMaterial_Inproc=SecPkgContext_KeyingMaterial_Inproc -_SecPkgContext_SrtpParameters=SecPkgContext_SrtpParameters -_SecPkgContext_TokenBinding=SecPkgContext_TokenBinding -_SCHANNEL_CRED=SCHANNEL_CRED -_SEND_GENERIC_TLS_EXTENSION=SEND_GENERIC_TLS_EXTENSION -_TLS_EXTENSION_SUBSCRIPTION=TLS_EXTENSION_SUBSCRIPTION -_SUBSCRIBE_GENERIC_TLS_EXTENSION=SUBSCRIBE_GENERIC_TLS_EXTENSION -_SCHANNEL_CERT_HASH=SCHANNEL_CERT_HASH -_SCHANNEL_CERT_HASH_STORE=SCHANNEL_CERT_HASH_STORE -_SCHANNEL_ALERT_TOKEN=SCHANNEL_ALERT_TOKEN -_SCHANNEL_SESSION_TOKEN=SCHANNEL_SESSION_TOKEN -_SCHANNEL_CLIENT_SIGNATURE=SCHANNEL_CLIENT_SIGNATURE -_SSL_CREDENTIAL_CERTIFICATE=SSL_CREDENTIAL_CERTIFICATE -_SCH_CRED=SCH_CRED -_SCH_CRED_SECRET_CAPI=SCH_CRED_SECRET_CAPI -_SCH_CRED_SECRET_PRIVKEY=SCH_CRED_SECRET_PRIVKEY -_SCH_CRED_PUBLIC_CERTCHAIN=SCH_CRED_PUBLIC_CERTCHAIN -_PctPublicKey=PctPublicKey -_X509Certificate=X509Certificate -_SCH_EXTENSION_DATA=SCH_EXTENSION_DATA -_SchGetExtensionsOptions=SchGetExtensionsOptions -_WSATHREADID=WSATHREADID -_WSPPROC_TABLE=WSPPROC_TABLE -_WSPUPCALLTABLE=WSPUPCALLTABLE -_WSC_PROVIDER_INFO_TYPE=WSC_PROVIDER_INFO_TYPE -_WSC_PROVIDER_AUDIT_INFO=WSC_PROVIDER_AUDIT_INFO -_NSP_ROUTINE=NSP_ROUTINE -_NSPV2_ROUTINE=NSPV2_ROUTINE -_WTS_CONNECTSTATE_CLASS=WTS_CONNECTSTATE_CLASS -_WTS_SERVER_INFOW=WTS_SERVER_INFOW -_WTS_SERVER_INFOA=WTS_SERVER_INFOA -_WTS_SESSION_INFOW=WTS_SESSION_INFOW -_WTS_SESSION_INFOA=WTS_SESSION_INFOA -_WTS_SESSION_INFO_1W=WTS_SESSION_INFO_1W -_WTS_SESSION_INFO_1A=WTS_SESSION_INFO_1A -_WTS_PROCESS_INFOW=WTS_PROCESS_INFOW -_WTS_PROCESS_INFOA=WTS_PROCESS_INFOA -_WTS_INFO_CLASS=WTS_INFO_CLASS -_WTSCONFIGINFOW=WTSCONFIGINFOW -_WTSCONFIGINFOA=WTSCONFIGINFOA -_WTSINFOW=WTSINFOW -_WTSINFOA=WTSINFOA -_WTSINFOEX_LEVEL1_W=WTSINFOEX_LEVEL1_W -_WTSINFOEX_LEVEL1_A=WTSINFOEX_LEVEL1_A -_WTSINFOEX_LEVEL_W=WTSINFOEX_LEVEL_W -_WTSINFOEX_LEVEL_A=WTSINFOEX_LEVEL_A -_WTSINFOEXW=WTSINFOEXW -_WTSINFOEXA=WTSINFOEXA -_WTSCLIENTW=WTSCLIENTW -_WTSCLIENTA=WTSCLIENTA -_WTS_VALIDATION_INFORMATIONA=WTS_VALIDATION_INFORMATIONA -_WTS_VALIDATION_INFORMATIONW=WTS_VALIDATION_INFORMATIONW -_WTS_CLIENT_ADDRESS=WTS_CLIENT_ADDRESS -_WTS_CLIENT_DISPLAY=WTS_CLIENT_DISPLAY -_WTS_CONFIG_CLASS=WTS_CONFIG_CLASS -_WTS_CONFIG_SOURCE=WTS_CONFIG_SOURCE -_WTSUSERCONFIGA=WTSUSERCONFIGA -_WTSUSERCONFIGW=WTSUSERCONFIGW -_WTS_VIRTUAL_CLASS=WTS_VIRTUAL_CLASS -_WTS_SESSION_ADDRESS=WTS_SESSION_ADDRESS -_WTS_PROCESS_INFO_EXW=WTS_PROCESS_INFO_EXW -_WTS_PROCESS_INFO_EXA=WTS_PROCESS_INFO_EXA -_WTS_TYPE_CLASS=WTS_TYPE_CLASS -_WTSLISTENERCONFIGW=WTSLISTENERCONFIGW -_WTSLISTENERCONFIGA=WTSLISTENERCONFIGA -_CREDENTIAL_ATTRIBUTEA=CREDENTIAL_ATTRIBUTEA -_CREDENTIAL_ATTRIBUTEW=CREDENTIAL_ATTRIBUTEW -_CREDENTIALA=CREDENTIALA -_CREDENTIALW=CREDENTIALW -_CREDENTIAL_TARGET_INFORMATIONA=CREDENTIAL_TARGET_INFORMATIONA -_CREDENTIAL_TARGET_INFORMATIONW=CREDENTIAL_TARGET_INFORMATIONW -_CERT_CREDENTIAL_INFO=CERT_CREDENTIAL_INFO -_USERNAME_TARGET_CREDENTIAL_INFO=USERNAME_TARGET_CREDENTIAL_INFO -_BINARY_BLOB_CREDENTIAL_INFO=BINARY_BLOB_CREDENTIAL_INFO -_CRED_MARSHAL_TYPE=CRED_MARSHAL_TYPE -_CRED_PROTECTION_TYPE=CRED_PROTECTION_TYPE -_CREDUI_INFOA=CREDUI_INFOA -_CREDUI_INFOW=CREDUI_INFOW -_EVENT_DATA_DESCRIPTOR=EVENT_DATA_DESCRIPTOR -_EVENT_DESCRIPTOR=EVENT_DESCRIPTOR -_EVENT_FILTER_HEADER=EVENT_FILTER_HEADER -_EVENT_FILTER_EVENT_ID=EVENT_FILTER_EVENT_ID -_EVENT_FILTER_EVENT_NAME=EVENT_FILTER_EVENT_NAME -_EVENT_FILTER_LEVEL_KW=EVENT_FILTER_LEVEL_KW -_EVENT_INFO_CLASS=EVENT_INFO_CLASS -_EVENT_HEADER_EXTENDED_DATA_ITEM=EVENT_HEADER_EXTENDED_DATA_ITEM -_EVENT_EXTENDED_ITEM_INSTANCE=EVENT_EXTENDED_ITEM_INSTANCE -_EVENT_EXTENDED_ITEM_RELATED_ACTIVITYID=EVENT_EXTENDED_ITEM_RELATED_ACTIVITYID -_EVENT_EXTENDED_ITEM_TS_ID=EVENT_EXTENDED_ITEM_TS_ID -_EVENT_EXTENDED_ITEM_STACK_TRACE32=EVENT_EXTENDED_ITEM_STACK_TRACE32 -_EVENT_EXTENDED_ITEM_STACK_TRACE64=EVENT_EXTENDED_ITEM_STACK_TRACE64 -_EVENT_EXTENDED_ITEM_PEBS_INDEX=EVENT_EXTENDED_ITEM_PEBS_INDEX -_EVENT_EXTENDED_ITEM_PMC_COUNTERS=EVENT_EXTENDED_ITEM_PMC_COUNTERS -_EVENT_EXTENDED_ITEM_PROCESS_START_KEY=EVENT_EXTENDED_ITEM_PROCESS_START_KEY -_EVENT_EXTENDED_ITEM_EVENT_KEY=EVENT_EXTENDED_ITEM_EVENT_KEY -_EVENT_HEADER=EVENT_HEADER -_COMPRESS_ALLOCATION_ROUTINES=COMPRESS_ALLOCATION_ROUTINES -_DEVPROP_OPERATOR=DEVPROP_OPERATOR -_DEVPROP_FILTER_EXPRESSION=DEVPROP_FILTER_EXPRESSION -_DEV_OBJECT_TYPE=DEV_OBJECT_TYPE -_DEV_QUERY_FLAGS=DEV_QUERY_FLAGS -_DEV_QUERY_STATE=DEV_QUERY_STATE -_DEV_QUERY_RESULT_ACTION=DEV_QUERY_RESULT_ACTION -_DEV_OBJECT=DEV_OBJECT -_DEV_QUERY_RESULT_ACTION_DATA=DEV_QUERY_RESULT_ACTION_DATA -_DEV_QUERY_PARAMETER=DEV_QUERY_PARAMETER -_SW_DEVICE_CAPABILITIES=SW_DEVICE_CAPABILITIES -_SW_DEVICE_CREATE_INFO=SW_DEVICE_CREATE_INFO -_SW_DEVICE_LIFETIME=SW_DEVICE_LIFETIME -_IsolatedAppLauncherTelemetryParameters=IsolatedAppLauncherTelemetryParameters -_PF_FILTER_DESCRIPTOR=PF_FILTER_DESCRIPTOR -_PF_FILTER_STATS=PF_FILTER_STATS -_PF_INTERFACE_STATS=PF_INTERFACE_STATS -_PF_LATEBIND_INFO=PF_LATEBIND_INFO -_DOMAIN_CONTROLLER_INFOA=DOMAIN_CONTROLLER_INFOA -_DOMAIN_CONTROLLER_INFOW=DOMAIN_CONTROLLER_INFOW -_DS_DOMAIN_TRUSTSW=DS_DOMAIN_TRUSTSW -_DS_DOMAIN_TRUSTSA=DS_DOMAIN_TRUSTSA -_WSA_COMPATIBILITY_BEHAVIOR_ID=WSA_COMPATIBILITY_BEHAVIOR_ID -_WSA_COMPATIBILITY_MODE=WSA_COMPATIBILITY_MODE -_RIORESULT=RIORESULT -_RIO_BUF=RIO_BUF -_RIO_CMSG_BUFFER=RIO_CMSG_BUFFER -_TRANSMIT_FILE_BUFFERS=TRANSMIT_FILE_BUFFERS -_TRANSMIT_PACKETS_ELEMENT=TRANSMIT_PACKETS_ELEMENT -_NLA_BLOB_DATA_TYPE=NLA_BLOB_DATA_TYPE -_NLA_CONNECTIVITY_TYPE=NLA_CONNECTIVITY_TYPE -_NLA_INTERNET=NLA_INTERNET -_NLA_BLOB=NLA_BLOB -_RIO_NOTIFICATION_COMPLETION_TYPE=RIO_NOTIFICATION_COMPLETION_TYPE -_RIO_NOTIFICATION_COMPLETION=RIO_NOTIFICATION_COMPLETION -_RIO_EXTENSION_FUNCTION_TABLE=RIO_EXTENSION_FUNCTION_TABLE -_INTERFACE_INFO=INTERFACE_INFO -_INTERFACE_INFO_EX=INTERFACE_INFO_EX -_PMTUD_STATE=PMTUD_STATE -_SOCKADDR_INET=SOCKADDR_INET -_IF_ACCESS_TYPE=IF_ACCESS_TYPE -_INTERNAL_IF_OPER_STATUS=INTERNAL_IF_OPER_STATUS -_MIB_OPAQUE_QUERY=MIB_OPAQUE_QUERY -_NET_IF_OPER_STATUS=NET_IF_OPER_STATUS -_NET_IF_ADMIN_STATUS=NET_IF_ADMIN_STATUS -_NET_IF_RCV_ADDRESS_TYPE=NET_IF_RCV_ADDRESS_TYPE -_NET_IF_RCV_ADDRESS_LH=NET_IF_RCV_ADDRESS_LH -_NET_IF_ALIAS_LH=NET_IF_ALIAS_LH -_NET_LUID_LH=NET_LUID_LH -_NET_IF_CONNECTION_TYPE=NET_IF_CONNECTION_TYPE -_NET_IF_ACCESS_TYPE=NET_IF_ACCESS_TYPE -_NET_IF_DIRECTION_TYPE=NET_IF_DIRECTION_TYPE -_NET_IF_MEDIA_CONNECT_STATE=NET_IF_MEDIA_CONNECT_STATE -_NET_IF_MEDIA_DUPLEX_STATE=NET_IF_MEDIA_DUPLEX_STATE -_NET_PHYSICAL_LOCATION_LH=NET_PHYSICAL_LOCATION_LH -_IF_COUNTED_STRING_LH=IF_COUNTED_STRING_LH -_IF_PHYSICAL_ADDRESS_LH=IF_PHYSICAL_ADDRESS_LH -_IF_ADMINISTRATIVE_STATE=IF_ADMINISTRATIVE_STATE -_NDIS_INTERFACE_INFORMATION=NDIS_INTERFACE_INFORMATION -_MIB_IFNUMBER=MIB_IFNUMBER -_MIB_IFROW=MIB_IFROW -_MIB_IFTABLE=MIB_IFTABLE -_NL_ROUTE_ORIGIN=NL_ROUTE_ORIGIN -_NL_NEIGHBOR_STATE=NL_NEIGHBOR_STATE -_NL_LINK_LOCAL_ADDRESS_BEHAVIOR=NL_LINK_LOCAL_ADDRESS_BEHAVIOR -_NL_INTERFACE_OFFLOAD_ROD=NL_INTERFACE_OFFLOAD_ROD -_NL_ROUTER_DISCOVERY_BEHAVIOR=NL_ROUTER_DISCOVERY_BEHAVIOR -_NL_BANDWIDTH_FLAG=NL_BANDWIDTH_FLAG -_NL_PATH_BANDWIDTH_ROD=NL_PATH_BANDWIDTH_ROD -_NL_NETWORK_CATEGORY=NL_NETWORK_CATEGORY -_NL_INTERFACE_NETWORK_CATEGORY_STATE=NL_INTERFACE_NETWORK_CATEGORY_STATE -_NL_BANDWIDTH_INFORMATION=NL_BANDWIDTH_INFORMATION -_MIB_IPADDRROW_XP=MIB_IPADDRROW_XP -_MIB_IPADDRROW_W2K=MIB_IPADDRROW_W2K -_MIB_IPADDRTABLE=MIB_IPADDRTABLE -_MIB_IPFORWARDNUMBER=MIB_IPFORWARDNUMBER -_MIB_IPFORWARDROW=MIB_IPFORWARDROW -_MIB_IPFORWARDTABLE=MIB_IPFORWARDTABLE -_MIB_IPNETROW_LH=MIB_IPNETROW_LH -_MIB_IPNETROW_W2K=MIB_IPNETROW_W2K -_MIB_IPNETTABLE=MIB_IPNETTABLE -_MIB_IPSTATS_LH=MIB_IPSTATS_LH -_MIB_IPSTATS_W2K=MIB_IPSTATS_W2K -_MIBICMPSTATS=MIBICMPSTATS -_MIBICMPINFO=MIBICMPINFO -_MIB_ICMP=MIB_ICMP -_MIBICMPSTATS_EX_XPSP1=MIBICMPSTATS_EX_XPSP1 -_MIB_ICMP_EX_XPSP1=MIB_ICMP_EX_XPSP1 -_MIB_IPMCAST_OIF_XP=MIB_IPMCAST_OIF_XP -_MIB_IPMCAST_OIF_W2K=MIB_IPMCAST_OIF_W2K -_MIB_IPMCAST_MFE=MIB_IPMCAST_MFE -_MIB_MFE_TABLE=MIB_MFE_TABLE -_MIB_IPMCAST_OIF_STATS_LH=MIB_IPMCAST_OIF_STATS_LH -_MIB_IPMCAST_OIF_STATS_W2K=MIB_IPMCAST_OIF_STATS_W2K -_MIB_IPMCAST_MFE_STATS=MIB_IPMCAST_MFE_STATS -_MIB_MFE_STATS_TABLE=MIB_MFE_STATS_TABLE -_MIB_IPMCAST_MFE_STATS_EX_XP=MIB_IPMCAST_MFE_STATS_EX_XP -_MIB_MFE_STATS_TABLE_EX_XP=MIB_MFE_STATS_TABLE_EX_XP -_MIB_IPMCAST_GLOBAL=MIB_IPMCAST_GLOBAL -_MIB_IPMCAST_IF_ENTRY=MIB_IPMCAST_IF_ENTRY -_MIB_IPMCAST_IF_TABLE=MIB_IPMCAST_IF_TABLE -_MIB_TCPROW_LH=MIB_TCPROW_LH -_MIB_TCPROW_W2K=MIB_TCPROW_W2K -_MIB_TCPTABLE=MIB_TCPTABLE -_MIB_TCPROW2=MIB_TCPROW2 -_MIB_TCPTABLE2=MIB_TCPTABLE2 -_MIB_TCPROW_OWNER_PID=MIB_TCPROW_OWNER_PID -_MIB_TCPTABLE_OWNER_PID=MIB_TCPTABLE_OWNER_PID -_MIB_TCPROW_OWNER_MODULE=MIB_TCPROW_OWNER_MODULE -_MIB_TCPTABLE_OWNER_MODULE=MIB_TCPTABLE_OWNER_MODULE -_MIB_TCP6ROW=MIB_TCP6ROW -_MIB_TCP6TABLE=MIB_TCP6TABLE -_MIB_TCP6ROW2=MIB_TCP6ROW2 -_MIB_TCP6TABLE2=MIB_TCP6TABLE2 -_MIB_TCP6ROW_OWNER_PID=MIB_TCP6ROW_OWNER_PID -_MIB_TCP6TABLE_OWNER_PID=MIB_TCP6TABLE_OWNER_PID -_MIB_TCP6ROW_OWNER_MODULE=MIB_TCP6ROW_OWNER_MODULE -_MIB_TCP6TABLE_OWNER_MODULE=MIB_TCP6TABLE_OWNER_MODULE -_MIB_TCPSTATS_LH=MIB_TCPSTATS_LH -_MIB_TCPSTATS_W2K=MIB_TCPSTATS_W2K -_MIB_TCPSTATS2=MIB_TCPSTATS2 -_MIB_UDPROW=MIB_UDPROW -_MIB_UDPTABLE=MIB_UDPTABLE -_MIB_UDPROW_OWNER_PID=MIB_UDPROW_OWNER_PID -_MIB_UDPTABLE_OWNER_PID=MIB_UDPTABLE_OWNER_PID -_MIB_UDPROW_OWNER_MODULE=MIB_UDPROW_OWNER_MODULE -_MIB_UDPTABLE_OWNER_MODULE=MIB_UDPTABLE_OWNER_MODULE -_MIB_UDP6ROW=MIB_UDP6ROW -_MIB_UDP6TABLE=MIB_UDP6TABLE -_MIB_UDP6ROW_OWNER_PID=MIB_UDP6ROW_OWNER_PID -_MIB_UDP6TABLE_OWNER_PID=MIB_UDP6TABLE_OWNER_PID -_MIB_UDP6ROW_OWNER_MODULE=MIB_UDP6ROW_OWNER_MODULE -_MIB_UDP6TABLE_OWNER_MODULE=MIB_UDP6TABLE_OWNER_MODULE -_MIB_UDPSTATS=MIB_UDPSTATS -_MIB_UDPSTATS2=MIB_UDPSTATS2 -_TCP_TABLE_CLASS=TCP_TABLE_CLASS -_UDP_TABLE_CLASS=UDP_TABLE_CLASS -_TCPIP_OWNER_MODULE_INFO_CLASS=TCPIP_OWNER_MODULE_INFO_CLASS -_TCPIP_OWNER_MODULE_BASIC_INFO=TCPIP_OWNER_MODULE_BASIC_INFO -_MIB_IPMCAST_BOUNDARY=MIB_IPMCAST_BOUNDARY -_MIB_IPMCAST_BOUNDARY_TABLE=MIB_IPMCAST_BOUNDARY_TABLE -_MIB_IPMCAST_SCOPE=MIB_IPMCAST_SCOPE -_MIB_IPDESTROW=MIB_IPDESTROW -_MIB_IPDESTTABLE=MIB_IPDESTTABLE -_MIB_BEST_IF=MIB_BEST_IF -_MIB_PROXYARP=MIB_PROXYARP -_MIB_IFSTATUS=MIB_IFSTATUS -_MIB_ROUTESTATE=MIB_ROUTESTATE -_MIB_OPAQUE_INFO=MIB_OPAQUE_INFO -_IPV6_ADDRESS_EX=IPV6_ADDRESS_EX -_IP_ADAPTER_INDEX_MAP=IP_ADAPTER_INDEX_MAP -_IP_INTERFACE_INFO=IP_INTERFACE_INFO -_IP_UNIDIRECTIONAL_ADAPTER_ADDRESS=IP_UNIDIRECTIONAL_ADAPTER_ADDRESS -_IP_ADAPTER_ORDER_MAP=IP_ADAPTER_ORDER_MAP -_IP_MCAST_COUNTER_INFO=IP_MCAST_COUNTER_INFO -_IP_ADDR_STRING=IP_ADDR_STRING -_IP_ADAPTER_INFO=IP_ADAPTER_INFO -_IP_ADAPTER_UNICAST_ADDRESS_LH=IP_ADAPTER_UNICAST_ADDRESS_LH -_IP_ADAPTER_UNICAST_ADDRESS_XP=IP_ADAPTER_UNICAST_ADDRESS_XP -_IP_ADAPTER_ANYCAST_ADDRESS_XP=IP_ADAPTER_ANYCAST_ADDRESS_XP -_IP_ADAPTER_MULTICAST_ADDRESS_XP=IP_ADAPTER_MULTICAST_ADDRESS_XP -_IP_ADAPTER_DNS_SERVER_ADDRESS_XP=IP_ADAPTER_DNS_SERVER_ADDRESS_XP -_IP_ADAPTER_WINS_SERVER_ADDRESS_LH=IP_ADAPTER_WINS_SERVER_ADDRESS_LH -_IP_ADAPTER_GATEWAY_ADDRESS_LH=IP_ADAPTER_GATEWAY_ADDRESS_LH -_IP_ADAPTER_PREFIX_XP=IP_ADAPTER_PREFIX_XP -_IP_ADAPTER_DNS_SUFFIX=IP_ADAPTER_DNS_SUFFIX -_IP_ADAPTER_ADDRESSES_LH=IP_ADAPTER_ADDRESSES_LH -_IP_ADAPTER_ADDRESSES_XP=IP_ADAPTER_ADDRESSES_XP -_IP_PER_ADAPTER_INFO_W2KSP1=IP_PER_ADAPTER_INFO_W2KSP1 -_TCP_BOOLEAN_OPTIONAL=TCP_BOOLEAN_OPTIONAL -_TCP_ESTATS_SYN_OPTS_ROS_v0=TCP_ESTATS_SYN_OPTS_ROS_v0 -_TCP_ESTATS_DATA_ROD_v0=TCP_ESTATS_DATA_ROD_v0 -_TCP_ESTATS_DATA_RW_v0=TCP_ESTATS_DATA_RW_v0 -_TCP_ESTATS_SND_CONG_ROD_v0=TCP_ESTATS_SND_CONG_ROD_v0 -_TCP_ESTATS_SND_CONG_ROS_v0=TCP_ESTATS_SND_CONG_ROS_v0 -_TCP_ESTATS_SND_CONG_RW_v0=TCP_ESTATS_SND_CONG_RW_v0 -_TCP_ESTATS_PATH_ROD_v0=TCP_ESTATS_PATH_ROD_v0 -_TCP_ESTATS_PATH_RW_v0=TCP_ESTATS_PATH_RW_v0 -_TCP_ESTATS_SEND_BUFF_ROD_v0=TCP_ESTATS_SEND_BUFF_ROD_v0 -_TCP_ESTATS_SEND_BUFF_RW_v0=TCP_ESTATS_SEND_BUFF_RW_v0 -_TCP_ESTATS_REC_ROD_v0=TCP_ESTATS_REC_ROD_v0 -_TCP_ESTATS_REC_RW_v0=TCP_ESTATS_REC_RW_v0 -_TCP_ESTATS_OBS_REC_ROD_v0=TCP_ESTATS_OBS_REC_ROD_v0 -_TCP_ESTATS_OBS_REC_RW_v0=TCP_ESTATS_OBS_REC_RW_v0 -_TCP_ESTATS_BANDWIDTH_RW_v0=TCP_ESTATS_BANDWIDTH_RW_v0 -_TCP_ESTATS_BANDWIDTH_ROD_v0=TCP_ESTATS_BANDWIDTH_ROD_v0 -_TCP_ESTATS_FINE_RTT_RW_v0=TCP_ESTATS_FINE_RTT_RW_v0 -_TCP_ESTATS_FINE_RTT_ROD_v0=TCP_ESTATS_FINE_RTT_ROD_v0 _INTERFACE_TIMESTAMP_CAPABILITY_FLAGS=INTERFACE_TIMESTAMP_CAPABILITY_FLAGS -_INTERFACE_TIMESTAMP_CAPABILITIES=INTERFACE_TIMESTAMP_CAPABILITIES -_INTERFACE_HARDWARE_CROSSTIMESTAMP=INTERFACE_HARDWARE_CROSSTIMESTAMP -_MIB_NOTIFICATION_TYPE=MIB_NOTIFICATION_TYPE -_NDIS_STATISTICS_VALUE=NDIS_STATISTICS_VALUE -_NDIS_STATISTICS_VALUE_EX=NDIS_STATISTICS_VALUE_EX -_NDIS_VAR_DATA_DESC=NDIS_VAR_DATA_DESC -_NDIS_OBJECT_HEADER=NDIS_OBJECT_HEADER -_NDIS_REQUEST_TYPE=NDIS_REQUEST_TYPE -_NDIS_STATISTICS_INFO=NDIS_STATISTICS_INFO -_NDIS_INTERRUPT_MODERATION=NDIS_INTERRUPT_MODERATION -_NDIS_INTERRUPT_MODERATION_PARAMETERS=NDIS_INTERRUPT_MODERATION_PARAMETERS -_NDIS_TIMEOUT_DPC_REQUEST_CAPABILITIES=NDIS_TIMEOUT_DPC_REQUEST_CAPABILITIES -_NDIS_PCI_DEVICE_CUSTOM_PROPERTIES=NDIS_PCI_DEVICE_CUSTOM_PROPERTIES -_NDIS_802_11_STATUS_TYPE=NDIS_802_11_STATUS_TYPE -_NDIS_802_11_STATUS_INDICATION=NDIS_802_11_STATUS_INDICATION -_NDIS_802_11_AUTHENTICATION_REQUEST=NDIS_802_11_AUTHENTICATION_REQUEST -_PMKID_CANDIDATE=PMKID_CANDIDATE -_NDIS_802_11_PMKID_CANDIDATE_LIST=NDIS_802_11_PMKID_CANDIDATE_LIST -_NDIS_802_11_NETWORK_TYPE=NDIS_802_11_NETWORK_TYPE -_NDIS_802_11_NETWORK_TYPE_LIST=NDIS_802_11_NETWORK_TYPE_LIST -_NDIS_802_11_POWER_MODE=NDIS_802_11_POWER_MODE -_NDIS_802_11_CONFIGURATION_FH=NDIS_802_11_CONFIGURATION_FH -_NDIS_802_11_CONFIGURATION=NDIS_802_11_CONFIGURATION -_NDIS_802_11_STATISTICS=NDIS_802_11_STATISTICS -_NDIS_802_11_KEY=NDIS_802_11_KEY -_NDIS_802_11_REMOVE_KEY=NDIS_802_11_REMOVE_KEY -_NDIS_802_11_WEP=NDIS_802_11_WEP -_NDIS_802_11_NETWORK_INFRASTRUCTURE=NDIS_802_11_NETWORK_INFRASTRUCTURE -_NDIS_802_11_AUTHENTICATION_MODE=NDIS_802_11_AUTHENTICATION_MODE -_NDIS_802_11_SSID=NDIS_802_11_SSID -_NDIS_WLAN_BSSID=NDIS_WLAN_BSSID -_NDIS_802_11_BSSID_LIST=NDIS_802_11_BSSID_LIST -_NDIS_WLAN_BSSID_EX=NDIS_WLAN_BSSID_EX -_NDIS_802_11_BSSID_LIST_EX=NDIS_802_11_BSSID_LIST_EX -_NDIS_802_11_FIXED_IEs=NDIS_802_11_FIXED_IEs -_NDIS_802_11_VARIABLE_IEs=NDIS_802_11_VARIABLE_IEs -_NDIS_802_11_PRIVACY_FILTER=NDIS_802_11_PRIVACY_FILTER -_NDIS_802_11_WEP_STATUS=NDIS_802_11_WEP_STATUS -_NDIS_802_11_RELOAD_DEFAULTS=NDIS_802_11_RELOAD_DEFAULTS -_NDIS_802_11_AI_REQFI=NDIS_802_11_AI_REQFI -_NDIS_802_11_AI_RESFI=NDIS_802_11_AI_RESFI -_NDIS_802_11_ASSOCIATION_INFORMATION=NDIS_802_11_ASSOCIATION_INFORMATION -_NDIS_802_11_AUTHENTICATION_EVENT=NDIS_802_11_AUTHENTICATION_EVENT -_NDIS_802_11_TEST=NDIS_802_11_TEST -_NDIS_802_11_MEDIA_STREAM_MODE=NDIS_802_11_MEDIA_STREAM_MODE -_BSSID_INFO=BSSID_INFO -_NDIS_802_11_PMKID=NDIS_802_11_PMKID -_NDIS_802_11_AUTHENTICATION_ENCRYPTION=NDIS_802_11_AUTHENTICATION_ENCRYPTION -_NDIS_802_11_CAPABILITY=NDIS_802_11_CAPABILITY -_NDIS_802_11_NON_BCAST_SSID_LIST=NDIS_802_11_NON_BCAST_SSID_LIST -_NDIS_802_11_RADIO_STATUS=NDIS_802_11_RADIO_STATUS -_OFFLOAD_OPERATION_E=OFFLOAD_OPERATION_E -_OFFLOAD_ALGO_INFO=OFFLOAD_ALGO_INFO -_OFFLOAD_CONF_ALGO=OFFLOAD_CONF_ALGO -_OFFLOAD_INTEGRITY_ALGO=OFFLOAD_INTEGRITY_ALGO -_OFFLOAD_SECURITY_ASSOCIATION=OFFLOAD_SECURITY_ASSOCIATION -_OFFLOAD_IPSEC_ADD_SA=OFFLOAD_IPSEC_ADD_SA -_OFFLOAD_IPSEC_DELETE_SA=OFFLOAD_IPSEC_DELETE_SA -_UDP_ENCAP_TYPE=UDP_ENCAP_TYPE -_OFFLOAD_IPSEC_UDPESP_ENCAPTYPE_ENTRY=OFFLOAD_IPSEC_UDPESP_ENCAPTYPE_ENTRY -_OFFLOAD_IPSEC_ADD_UDPESP_SA=OFFLOAD_IPSEC_ADD_UDPESP_SA -_OFFLOAD_IPSEC_DELETE_UDPESP_SA=OFFLOAD_IPSEC_DELETE_UDPESP_SA -_NDIS_MEDIUM=NDIS_MEDIUM -_NDIS_PHYSICAL_MEDIUM=NDIS_PHYSICAL_MEDIUM -_TRANSPORT_HEADER_OFFSET=TRANSPORT_HEADER_OFFSET -_NETWORK_ADDRESS=NETWORK_ADDRESS -_NETWORK_ADDRESS_LIST=NETWORK_ADDRESS_LIST -_NETWORK_ADDRESS_IP=NETWORK_ADDRESS_IP -_NETWORK_ADDRESS_IP6=NETWORK_ADDRESS_IP6 -_NETWORK_ADDRESS_IPX=NETWORK_ADDRESS_IPX -_NDIS_HARDWARE_STATUS=NDIS_HARDWARE_STATUS -_GEN_GET_TIME_CAPS=GEN_GET_TIME_CAPS -_GEN_GET_NETCARD_TIME=GEN_GET_NETCARD_TIME -_NDIS_PM_PACKET_PATTERN=NDIS_PM_PACKET_PATTERN -_NDIS_DEVICE_POWER_STATE=NDIS_DEVICE_POWER_STATE -_NDIS_PM_WAKE_UP_CAPABILITIES=NDIS_PM_WAKE_UP_CAPABILITIES -_NDIS_PNP_CAPABILITIES=NDIS_PNP_CAPABILITIES -_NDIS_FDDI_ATTACHMENT_TYPE=NDIS_FDDI_ATTACHMENT_TYPE -_NDIS_FDDI_RING_MGT_STATE=NDIS_FDDI_RING_MGT_STATE -_NDIS_FDDI_LCONNECTION_STATE=NDIS_FDDI_LCONNECTION_STATE -_NDIS_WAN_MEDIUM_SUBTYPE=NDIS_WAN_MEDIUM_SUBTYPE -_NDIS_WAN_HEADER_FORMAT=NDIS_WAN_HEADER_FORMAT -_NDIS_WAN_QUALITY=NDIS_WAN_QUALITY -_NDIS_WAN_PROTOCOL_CAPS=NDIS_WAN_PROTOCOL_CAPS -_NDIS_802_5_RING_STATE=NDIS_802_5_RING_STATE -_NDIS_MEDIA_STATE=NDIS_MEDIA_STATE -_NDIS_CO_LINK_SPEED=NDIS_CO_LINK_SPEED -_NDIS_LINK_SPEED=NDIS_LINK_SPEED -_DOT11_BSS_TYPE=DOT11_BSS_TYPE -_DOT11_SSID=DOT11_SSID -_DOT11_AUTH_ALGORITHM=DOT11_AUTH_ALGORITHM -_DOT11_CIPHER_ALGORITHM=DOT11_CIPHER_ALGORITHM -_DOT11_OI=DOT11_OI -_DOT11_PHY_TYPE=DOT11_PHY_TYPE -_DOT11_RATE_SET=DOT11_RATE_SET -_DOT11_WFD_SESSION_INFO=DOT11_WFD_SESSION_INFO -_DOT11_OFFLOAD_CAPABILITY=DOT11_OFFLOAD_CAPABILITY -_DOT11_CURRENT_OFFLOAD_CAPABILITY=DOT11_CURRENT_OFFLOAD_CAPABILITY -_DOT11_OFFLOAD_TYPE=DOT11_OFFLOAD_TYPE -_DOT11_IV48_COUNTER=DOT11_IV48_COUNTER -_DOT11_WEP_OFFLOAD=DOT11_WEP_OFFLOAD -_DOT11_WEP_UPLOAD=DOT11_WEP_UPLOAD -_DOT11_KEY_DIRECTION=DOT11_KEY_DIRECTION -_DOT11_DEFAULT_WEP_OFFLOAD=DOT11_DEFAULT_WEP_OFFLOAD -_DOT11_DEFAULT_WEP_UPLOAD=DOT11_DEFAULT_WEP_UPLOAD -_DOT11_OPERATION_MODE_CAPABILITY=DOT11_OPERATION_MODE_CAPABILITY -_DOT11_CURRENT_OPERATION_MODE=DOT11_CURRENT_OPERATION_MODE -_DOT11_SCAN_TYPE=DOT11_SCAN_TYPE -_DOT11_SCAN_REQUEST=DOT11_SCAN_REQUEST -_CH_DESCRIPTION_TYPE=CH_DESCRIPTION_TYPE -_DOT11_PHY_TYPE_INFO=DOT11_PHY_TYPE_INFO -_DOT11_SCAN_REQUEST_V2=DOT11_SCAN_REQUEST_V2 -_DOT11_BSS_DESCRIPTION=DOT11_BSS_DESCRIPTION -_DOT11_JOIN_REQUEST=DOT11_JOIN_REQUEST -_DOT11_START_REQUEST=DOT11_START_REQUEST -_DOT11_UPDATE_IE_OP=DOT11_UPDATE_IE_OP -_DOT11_UPDATE_IE=DOT11_UPDATE_IE -_DOT11_RESET_TYPE=DOT11_RESET_TYPE -_DOT11_RESET_REQUEST=DOT11_RESET_REQUEST -_DOT11_OPTIONAL_CAPABILITY=DOT11_OPTIONAL_CAPABILITY -_DOT11_CURRENT_OPTIONAL_CAPABILITY=DOT11_CURRENT_OPTIONAL_CAPABILITY -_DOT11_POWER_MODE=DOT11_POWER_MODE -_DOT11_POWER_MGMT_MODE=DOT11_POWER_MGMT_MODE -_DOT11_COUNTERS_ENTRY=DOT11_COUNTERS_ENTRY -_DOT11_SUPPORTED_PHY_TYPES=DOT11_SUPPORTED_PHY_TYPES -_DOT11_TEMP_TYPE=DOT11_TEMP_TYPE -_DOT11_DIVERSITY_SUPPORT=DOT11_DIVERSITY_SUPPORT -_DOT11_SUPPORTED_POWER_LEVELS=DOT11_SUPPORTED_POWER_LEVELS -_DOT11_REG_DOMAIN_VALUE=DOT11_REG_DOMAIN_VALUE -_DOT11_REG_DOMAINS_SUPPORT_VALUE=DOT11_REG_DOMAINS_SUPPORT_VALUE -_DOT11_SUPPORTED_ANTENNA=DOT11_SUPPORTED_ANTENNA -_DOT11_SUPPORTED_ANTENNA_LIST=DOT11_SUPPORTED_ANTENNA_LIST -_DOT11_DIVERSITY_SELECTION_RX=DOT11_DIVERSITY_SELECTION_RX -_DOT11_DIVERSITY_SELECTION_RX_LIST=DOT11_DIVERSITY_SELECTION_RX_LIST -_DOT11_SUPPORTED_DATA_RATES_VALUE=DOT11_SUPPORTED_DATA_RATES_VALUE -_DOT11_SUPPORTED_DATA_RATES_VALUE_V2=DOT11_SUPPORTED_DATA_RATES_VALUE_V2 -_DOT11_MULTI_DOMAIN_CAPABILITY_ENTRY=DOT11_MULTI_DOMAIN_CAPABILITY_ENTRY -_DOT11_MD_CAPABILITY_ENTRY_LIST=DOT11_MD_CAPABILITY_ENTRY_LIST -_DOT11_HOP_ALGO_ADOPTED=DOT11_HOP_ALGO_ADOPTED -_DOT11_HOPPING_PATTERN_ENTRY=DOT11_HOPPING_PATTERN_ENTRY -_DOT11_HOPPING_PATTERN_ENTRY_LIST=DOT11_HOPPING_PATTERN_ENTRY_LIST -_DOT11_WPA_TSC=DOT11_WPA_TSC -_DOT11_RSSI_RANGE=DOT11_RSSI_RANGE -_DOT11_NIC_SPECIFIC_EXTENSION=DOT11_NIC_SPECIFIC_EXTENSION -_DOT11_AP_JOIN_REQUEST=DOT11_AP_JOIN_REQUEST -_DOT11_RECV_SENSITIVITY=DOT11_RECV_SENSITIVITY -_DOT11_RECV_SENSITIVITY_LIST=DOT11_RECV_SENSITIVITY_LIST -_DOT11_AC_PARAM=DOT11_AC_PARAM -_DOT11_WME_AC_PARAMETERS=DOT11_WME_AC_PARAMETERS -_DOT11_WME_UPDATE_IE=DOT11_WME_UPDATE_IE -_DOT11_QOS_TX_DURATION=DOT11_QOS_TX_DURATION -_DOT11_QOS_TX_MEDIUM_TIME=DOT11_QOS_TX_MEDIUM_TIME -_DOT11_SUPPORTED_OFDM_FREQUENCY=DOT11_SUPPORTED_OFDM_FREQUENCY -_DOT11_SUPPORTED_OFDM_FREQUENCY_LIST=DOT11_SUPPORTED_OFDM_FREQUENCY_LIST -_DOT11_SUPPORTED_DSSS_CHANNEL=DOT11_SUPPORTED_DSSS_CHANNEL -_DOT11_SUPPORTED_DSSS_CHANNEL_LIST=DOT11_SUPPORTED_DSSS_CHANNEL_LIST -_DOT11_ASSOCIATION_STATE=DOT11_ASSOCIATION_STATE -_DOT11_ASSOCIATION_INFO_EX=DOT11_ASSOCIATION_INFO_EX -_DOT11_DATA_RATE_MAPPING_TABLE=DOT11_DATA_RATE_MAPPING_TABLE -_DOT11_FRAGMENT_DESCRIPTOR=DOT11_FRAGMENT_DESCRIPTOR -_DOT11_PER_MSDU_COUNTERS=DOT11_PER_MSDU_COUNTERS -_DOT11_RECV_EXTENSION_INFO=DOT11_RECV_EXTENSION_INFO -_DOT11_RECV_EXTENSION_INFO_V2=DOT11_RECV_EXTENSION_INFO_V2 -_DOT11_STATUS_INDICATION=DOT11_STATUS_INDICATION -_DOT11_EXTAP_ATTRIBUTES=DOT11_EXTAP_ATTRIBUTES -_DOT11_INCOMING_ASSOC_STARTED_PARAMETERS=DOT11_INCOMING_ASSOC_STARTED_PARAMETERS -_DOT11_INCOMING_ASSOC_REQUEST_RECEIVED_PARAMETERS=DOT11_INCOMING_ASSOC_REQUEST_RECEIVED_PARAMETERS -_DOT11_INCOMING_ASSOC_COMPLETION_PARAMETERS=DOT11_INCOMING_ASSOC_COMPLETION_PARAMETERS -_DOT11_STOP_AP_PARAMETERS=DOT11_STOP_AP_PARAMETERS -_DOT11_PHY_FREQUENCY_ADOPTED_PARAMETERS=DOT11_PHY_FREQUENCY_ADOPTED_PARAMETERS -_DOT11_CAN_SUSTAIN_AP_PARAMETERS=DOT11_CAN_SUSTAIN_AP_PARAMETERS -_DOT11_AVAILABLE_CHANNEL_LIST=DOT11_AVAILABLE_CHANNEL_LIST -_DOT11_AVAILABLE_FREQUENCY_LIST=DOT11_AVAILABLE_FREQUENCY_LIST -_DOT11_DISASSOCIATE_PEER_REQUEST=DOT11_DISASSOCIATE_PEER_REQUEST -_DOT11_INCOMING_ASSOC_DECISION=DOT11_INCOMING_ASSOC_DECISION -_DOT11_INCOMING_ASSOC_DECISION_V2=DOT11_INCOMING_ASSOC_DECISION_V2 -_DOT11_ADDITIONAL_IE=DOT11_ADDITIONAL_IE -_DOT11_PEER_STATISTICS=DOT11_PEER_STATISTICS -_DOT11_PEER_INFO=DOT11_PEER_INFO -_DOT11_PEER_INFO_LIST=DOT11_PEER_INFO_LIST -_DOT11_VWIFI_COMBINATION=DOT11_VWIFI_COMBINATION -_DOT11_VWIFI_COMBINATION_V2=DOT11_VWIFI_COMBINATION_V2 -_DOT11_VWIFI_COMBINATION_V3=DOT11_VWIFI_COMBINATION_V3 -_DOT11_MAC_PARAMETERS=DOT11_MAC_PARAMETERS -_DOT11_WFD_ATTRIBUTES=DOT11_WFD_ATTRIBUTES -_DOT11_WFD_DEVICE_TYPE=DOT11_WFD_DEVICE_TYPE -_DOT11_WPS_DEVICE_NAME=DOT11_WPS_DEVICE_NAME -_DOT11_WFD_CONFIGURATION_TIMEOUT=DOT11_WFD_CONFIGURATION_TIMEOUT -_DOT11_WFD_GROUP_ID=DOT11_WFD_GROUP_ID -_DOT11_WFD_GO_INTENT=DOT11_WFD_GO_INTENT -_DOT11_WFD_CHANNEL=DOT11_WFD_CHANNEL -_DOT11_WPS_CONFIG_METHOD=DOT11_WPS_CONFIG_METHOD -_DOT11_WPS_DEVICE_PASSWORD_ID=DOT11_WPS_DEVICE_PASSWORD_ID -_WFDSVC_CONNECTION_CAPABILITY=WFDSVC_CONNECTION_CAPABILITY -_DOT11_WFD_SERVICE_HASH_LIST=DOT11_WFD_SERVICE_HASH_LIST -_DOT11_WFD_ADVERTISEMENT_ID=DOT11_WFD_ADVERTISEMENT_ID -_DOT11_WFD_SESSION_ID=DOT11_WFD_SESSION_ID -_DOT11_WFD_ADVERTISED_SERVICE_DESCRIPTOR=DOT11_WFD_ADVERTISED_SERVICE_DESCRIPTOR -_DOT11_WFD_ADVERTISED_SERVICE_LIST=DOT11_WFD_ADVERTISED_SERVICE_LIST -_DOT11_WFD_DISCOVER_COMPLETE_PARAMETERS=DOT11_WFD_DISCOVER_COMPLETE_PARAMETERS -_DOT11_GO_NEGOTIATION_REQUEST_SEND_COMPLETE_PARAMETERS=DOT11_GO_NEGOTIATION_REQUEST_SEND_COMPLETE_PARAMETERS -_DOT11_RECEIVED_GO_NEGOTIATION_REQUEST_PARAMETERS=DOT11_RECEIVED_GO_NEGOTIATION_REQUEST_PARAMETERS -_DOT11_GO_NEGOTIATION_RESPONSE_SEND_COMPLETE_PARAMETERS=DOT11_GO_NEGOTIATION_RESPONSE_SEND_COMPLETE_PARAMETERS -_DOT11_RECEIVED_GO_NEGOTIATION_RESPONSE_PARAMETERS=DOT11_RECEIVED_GO_NEGOTIATION_RESPONSE_PARAMETERS -_DOT11_GO_NEGOTIATION_CONFIRMATION_SEND_COMPLETE_PARAMETERS=DOT11_GO_NEGOTIATION_CONFIRMATION_SEND_COMPLETE_PARAMETERS -_DOT11_RECEIVED_GO_NEGOTIATION_CONFIRMATION_PARAMETERS=DOT11_RECEIVED_GO_NEGOTIATION_CONFIRMATION_PARAMETERS -_DOT11_INVITATION_REQUEST_SEND_COMPLETE_PARAMETERS=DOT11_INVITATION_REQUEST_SEND_COMPLETE_PARAMETERS -_DOT11_RECEIVED_INVITATION_REQUEST_PARAMETERS=DOT11_RECEIVED_INVITATION_REQUEST_PARAMETERS -_DOT11_INVITATION_RESPONSE_SEND_COMPLETE_PARAMETERS=DOT11_INVITATION_RESPONSE_SEND_COMPLETE_PARAMETERS -_DOT11_RECEIVED_INVITATION_RESPONSE_PARAMETERS=DOT11_RECEIVED_INVITATION_RESPONSE_PARAMETERS -_DOT11_PROVISION_DISCOVERY_REQUEST_SEND_COMPLETE_PARAMETERS=DOT11_PROVISION_DISCOVERY_REQUEST_SEND_COMPLETE_PARAMETERS -_DOT11_RECEIVED_PROVISION_DISCOVERY_REQUEST_PARAMETERS=DOT11_RECEIVED_PROVISION_DISCOVERY_REQUEST_PARAMETERS -_DOT11_PROVISION_DISCOVERY_RESPONSE_SEND_COMPLETE_PARAMETERS=DOT11_PROVISION_DISCOVERY_RESPONSE_SEND_COMPLETE_PARAMETERS -_DOT11_RECEIVED_PROVISION_DISCOVERY_RESPONSE_PARAMETERS=DOT11_RECEIVED_PROVISION_DISCOVERY_RESPONSE_PARAMETERS -_DOT11_ANQP_QUERY_RESULT=DOT11_ANQP_QUERY_RESULT -_DOT11_ANQP_QUERY_COMPLETE_PARAMETERS=DOT11_ANQP_QUERY_COMPLETE_PARAMETERS -_DOT11_WFD_DEVICE_CAPABILITY_CONFIG=DOT11_WFD_DEVICE_CAPABILITY_CONFIG -_DOT11_WFD_GROUP_OWNER_CAPABILITY_CONFIG=DOT11_WFD_GROUP_OWNER_CAPABILITY_CONFIG -_DOT11_WFD_GROUP_OWNER_CAPABILITY_CONFIG_V2=DOT11_WFD_GROUP_OWNER_CAPABILITY_CONFIG_V2 -_DOT11_WFD_DEVICE_INFO=DOT11_WFD_DEVICE_INFO -_DOT11_WFD_SECONDARY_DEVICE_TYPE_LIST=DOT11_WFD_SECONDARY_DEVICE_TYPE_LIST -_DOT11_WFD_DISCOVER_TYPE=DOT11_WFD_DISCOVER_TYPE -_DOT11_WFD_SCAN_TYPE=DOT11_WFD_SCAN_TYPE -_DOT11_WFD_DISCOVER_DEVICE_FILTER=DOT11_WFD_DISCOVER_DEVICE_FILTER -_DOT11_WFD_DISCOVER_REQUEST=DOT11_WFD_DISCOVER_REQUEST -_DOT11_WFD_DEVICE_ENTRY=DOT11_WFD_DEVICE_ENTRY -_DOT11_WFD_ADDITIONAL_IE=DOT11_WFD_ADDITIONAL_IE -_DOT11_SEND_GO_NEGOTIATION_REQUEST_PARAMETERS=DOT11_SEND_GO_NEGOTIATION_REQUEST_PARAMETERS -_DOT11_SEND_GO_NEGOTIATION_RESPONSE_PARAMETERS=DOT11_SEND_GO_NEGOTIATION_RESPONSE_PARAMETERS -_DOT11_SEND_GO_NEGOTIATION_CONFIRMATION_PARAMETERS=DOT11_SEND_GO_NEGOTIATION_CONFIRMATION_PARAMETERS -_DOT11_WFD_INVITATION_FLAGS=DOT11_WFD_INVITATION_FLAGS -_DOT11_SEND_INVITATION_REQUEST_PARAMETERS=DOT11_SEND_INVITATION_REQUEST_PARAMETERS -_DOT11_SEND_INVITATION_RESPONSE_PARAMETERS=DOT11_SEND_INVITATION_RESPONSE_PARAMETERS -_DOT11_SEND_PROVISION_DISCOVERY_REQUEST_PARAMETERS=DOT11_SEND_PROVISION_DISCOVERY_REQUEST_PARAMETERS -_DOT11_SEND_PROVISION_DISCOVERY_RESPONSE_PARAMETERS=DOT11_SEND_PROVISION_DISCOVERY_RESPONSE_PARAMETERS -_DOT11_WFD_DEVICE_LISTEN_CHANNEL=DOT11_WFD_DEVICE_LISTEN_CHANNEL -_DOT11_WFD_GROUP_START_PARAMETERS=DOT11_WFD_GROUP_START_PARAMETERS -_DOT11_WFD_GROUP_JOIN_PARAMETERS=DOT11_WFD_GROUP_JOIN_PARAMETERS -_DOT11_POWER_MGMT_AUTO_MODE_ENABLED_INFO=DOT11_POWER_MGMT_AUTO_MODE_ENABLED_INFO -_DOT11_POWER_MODE_REASON=DOT11_POWER_MODE_REASON -_DOT11_POWER_MGMT_MODE_STATUS_INFO=DOT11_POWER_MGMT_MODE_STATUS_INFO -_DOT11_OFFLOAD_NETWORK_LIST_INFO=DOT11_OFFLOAD_NETWORK_LIST_INFO -_DOT11_OFFLOAD_NETWORK_STATUS_PARAMETERS=DOT11_OFFLOAD_NETWORK_STATUS_PARAMETERS -_DOT11_MANUFACTURING_TEST_TYPE=DOT11_MANUFACTURING_TEST_TYPE -_DOT11_MANUFACTURING_TEST=DOT11_MANUFACTURING_TEST -_DOT11_MANUFACTURING_SELF_TEST_SET_PARAMS=DOT11_MANUFACTURING_SELF_TEST_SET_PARAMS -_DOT11_MANUFACTURING_SELF_TEST_QUERY_RESULTS=DOT11_MANUFACTURING_SELF_TEST_QUERY_RESULTS -_DOT11_MANUFACTURING_FUNCTIONAL_TEST_RX=DOT11_MANUFACTURING_FUNCTIONAL_TEST_RX -_DOT11_MANUFACTURING_FUNCTIONAL_TEST_TX=DOT11_MANUFACTURING_FUNCTIONAL_TEST_TX -_DOT11_MANUFACTURING_FUNCTIONAL_TEST_QUERY_ADC=DOT11_MANUFACTURING_FUNCTIONAL_TEST_QUERY_ADC -_DOT11_MANUFACTURING_TEST_SET_DATA=DOT11_MANUFACTURING_TEST_SET_DATA -_DOT11_MANUFACTURING_TEST_QUERY_DATA=DOT11_MANUFACTURING_TEST_QUERY_DATA -_DOT11_MANUFACTURING_TEST_SLEEP=DOT11_MANUFACTURING_TEST_SLEEP -_DOT11_MANUFACTURING_CALLBACK_TYPE=DOT11_MANUFACTURING_CALLBACK_TYPE -_NDIS_GUID=NDIS_GUID -_NDIS_IRDA_PACKET_INFO=NDIS_IRDA_PACKET_INFO -_NDIS_SUPPORTED_PAUSE_FUNCTIONS=NDIS_SUPPORTED_PAUSE_FUNCTIONS -_NDIS_LINK_STATE=NDIS_LINK_STATE -_NDIS_LINK_PARAMETERS=NDIS_LINK_PARAMETERS -_NDIS_OPER_STATE=NDIS_OPER_STATE -_NDIS_IP_OPER_STATUS=NDIS_IP_OPER_STATUS -_NDIS_IP_OPER_STATUS_INFO=NDIS_IP_OPER_STATUS_INFO -_NDIS_IP_OPER_STATE=NDIS_IP_OPER_STATE -_NDIS_OFFLOAD_PARAMETERS=NDIS_OFFLOAD_PARAMETERS -_NDIS_TCP_LARGE_SEND_OFFLOAD_V1=NDIS_TCP_LARGE_SEND_OFFLOAD_V1 -_NDIS_TCP_IP_CHECKSUM_OFFLOAD=NDIS_TCP_IP_CHECKSUM_OFFLOAD -_NDIS_IPSEC_OFFLOAD_V1=NDIS_IPSEC_OFFLOAD_V1 -_NDIS_TCP_LARGE_SEND_OFFLOAD_V2=NDIS_TCP_LARGE_SEND_OFFLOAD_V2 -_NDIS_OFFLOAD=NDIS_OFFLOAD -_NDIS_WMI_TCP_LARGE_SEND_OFFLOAD_V1=NDIS_WMI_TCP_LARGE_SEND_OFFLOAD_V1 -_NDIS_WMI_TCP_IP_CHECKSUM_OFFLOAD=NDIS_WMI_TCP_IP_CHECKSUM_OFFLOAD -_NDIS_WMI_IPSEC_OFFLOAD_V1=NDIS_WMI_IPSEC_OFFLOAD_V1 -_NDIS_WMI_TCP_LARGE_SEND_OFFLOAD_V2=NDIS_WMI_TCP_LARGE_SEND_OFFLOAD_V2 -_NDIS_WMI_OFFLOAD=NDIS_WMI_OFFLOAD -_NDIS_TCP_CONNECTION_OFFLOAD=NDIS_TCP_CONNECTION_OFFLOAD -_NDIS_WMI_TCP_CONNECTION_OFFLOAD=NDIS_WMI_TCP_CONNECTION_OFFLOAD -_NDIS_PORT_TYPE=NDIS_PORT_TYPE -_NDIS_PORT_AUTHORIZATION_STATE=NDIS_PORT_AUTHORIZATION_STATE -_NDIS_PORT_CONTROL_STATE=NDIS_PORT_CONTROL_STATE -_NDIS_PORT_AUTHENTICATION_PARAMETERS=NDIS_PORT_AUTHENTICATION_PARAMETERS -_NDIS_NETWORK_CHANGE_TYPE=NDIS_NETWORK_CHANGE_TYPE -_NDIS_WMI_METHOD_HEADER=NDIS_WMI_METHOD_HEADER -_NDIS_WMI_SET_HEADER=NDIS_WMI_SET_HEADER -_NDIS_WMI_EVENT_HEADER=NDIS_WMI_EVENT_HEADER -_NDIS_WMI_ENUM_ADAPTER=NDIS_WMI_ENUM_ADAPTER -_NDIS_RECEIVE_SCALE_CAPABILITIES=NDIS_RECEIVE_SCALE_CAPABILITIES -_NDIS_RECEIVE_SCALE_PARAMETERS=NDIS_RECEIVE_SCALE_PARAMETERS -_NDIS_RECEIVE_HASH_PARAMETERS=NDIS_RECEIVE_HASH_PARAMETERS -_NDIS_PROCESSOR_VENDOR=NDIS_PROCESSOR_VENDOR -_NDIS_PORT_STATE=NDIS_PORT_STATE -_NDIS_PORT_CHARACTERISTICS=NDIS_PORT_CHARACTERISTICS -_NDIS_PORT=NDIS_PORT -_NDIS_PORT_ARRAY=NDIS_PORT_ARRAY -_NDIS_TIMESTAMP_CAPABILITY_FLAGS=NDIS_TIMESTAMP_CAPABILITY_FLAGS -_NDIS_TIMESTAMP_CAPABILITIES=NDIS_TIMESTAMP_CAPABILITIES -_NDIS_HARDWARE_CROSSTIMESTAMP=NDIS_HARDWARE_CROSSTIMESTAMP -_MIB_IF_ROW2=MIB_IF_ROW2 -_MIB_IF_TABLE2=MIB_IF_TABLE2 -_MIB_IF_ENTRY_LEVEL=MIB_IF_ENTRY_LEVEL -_MIB_IF_TABLE_LEVEL=MIB_IF_TABLE_LEVEL -_MIB_IPINTERFACE_ROW=MIB_IPINTERFACE_ROW -_MIB_IPINTERFACE_TABLE=MIB_IPINTERFACE_TABLE -_MIB_IFSTACK_ROW=MIB_IFSTACK_ROW -_MIB_INVERTEDIFSTACK_ROW=MIB_INVERTEDIFSTACK_ROW -_MIB_IFSTACK_TABLE=MIB_IFSTACK_TABLE -_MIB_INVERTEDIFSTACK_TABLE=MIB_INVERTEDIFSTACK_TABLE -_MIB_IP_NETWORK_CONNECTION_BANDWIDTH_ESTIMATES=MIB_IP_NETWORK_CONNECTION_BANDWIDTH_ESTIMATES -_MIB_UNICASTIPADDRESS_ROW=MIB_UNICASTIPADDRESS_ROW -_MIB_UNICASTIPADDRESS_TABLE=MIB_UNICASTIPADDRESS_TABLE -_MIB_ANYCASTIPADDRESS_ROW=MIB_ANYCASTIPADDRESS_ROW -_MIB_ANYCASTIPADDRESS_TABLE=MIB_ANYCASTIPADDRESS_TABLE -_MIB_MULTICASTIPADDRESS_ROW=MIB_MULTICASTIPADDRESS_ROW -_MIB_MULTICASTIPADDRESS_TABLE=MIB_MULTICASTIPADDRESS_TABLE -_IP_ADDRESS_PREFIX=IP_ADDRESS_PREFIX -_MIB_IPFORWARD_ROW2=MIB_IPFORWARD_ROW2 -_MIB_IPFORWARD_TABLE2=MIB_IPFORWARD_TABLE2 -_MIB_IPPATH_ROW=MIB_IPPATH_ROW -_MIB_IPPATH_TABLE=MIB_IPPATH_TABLE -_MIB_IPNET_ROW2=MIB_IPNET_ROW2 -_MIB_IPNET_TABLE2=MIB_IPNET_TABLE2 -_DNS_SETTINGS=DNS_SETTINGS -_DNS_INTERFACE_SETTINGS=DNS_INTERFACE_SETTINGS -_EVENT_MAP_ENTRY=EVENT_MAP_ENTRY -_MAP_FLAGS=MAP_FLAGS -_MAP_VALUETYPE=MAP_VALUETYPE -_EVENT_MAP_INFO=EVENT_MAP_INFO -_PROPERTY_FLAGS=PROPERTY_FLAGS -_DECODING_SOURCE=DECODING_SOURCE -_TEMPLATE_FLAGS=TEMPLATE_FLAGS -_PROPERTY_DATA_DESCRIPTOR=PROPERTY_DATA_DESCRIPTOR -_PAYLOAD_OPERATOR=PAYLOAD_OPERATOR -_PAYLOAD_FILTER_PREDICATE=PAYLOAD_FILTER_PREDICATE -_PROVIDER_FILTER_INFO=PROVIDER_FILTER_INFO -_EVENT_FIELD_TYPE=EVENT_FIELD_TYPE -_PROVIDER_FIELD_INFO=PROVIDER_FIELD_INFO -_PROVIDER_FIELD_INFOARRAY=PROVIDER_FIELD_INFOARRAY -_TRACE_PROVIDER_INFO=TRACE_PROVIDER_INFO -_PROVIDER_ENUMERATION_INFO=PROVIDER_ENUMERATION_INFO -_PROVIDER_EVENT_INFO=PROVIDER_EVENT_INFO -_TDH_CONTEXT_TYPE=TDH_CONTEXT_TYPE -_TDH_CONTEXT=TDH_CONTEXT -_SecPkgInfoW=SecPkgInfoW -_SecPkgInfoA=SecPkgInfoA -_SecBuffer=SecBuffer -_SecBufferDesc=SecBufferDesc -_SEC_NEGOTIATION_INFO=SEC_NEGOTIATION_INFO -_SEC_CHANNEL_BINDINGS=SEC_CHANNEL_BINDINGS -_SEC_APPLICATION_PROTOCOL_NEGOTIATION_EXT=SEC_APPLICATION_PROTOCOL_NEGOTIATION_EXT -_SEC_APPLICATION_PROTOCOL_LIST=SEC_APPLICATION_PROTOCOL_LIST -_SEC_APPLICATION_PROTOCOLS=SEC_APPLICATION_PROTOCOLS -_SEC_SRTP_PROTECTION_PROFILES=SEC_SRTP_PROTECTION_PROFILES -_SEC_SRTP_MASTER_KEY_IDENTIFIER=SEC_SRTP_MASTER_KEY_IDENTIFIER -_SEC_TOKEN_BINDING=SEC_TOKEN_BINDING -_SEC_PRESHAREDKEY=SEC_PRESHAREDKEY -_SEC_PRESHAREDKEY_IDENTITY=SEC_PRESHAREDKEY_IDENTITY -_SEC_DTLS_MTU=SEC_DTLS_MTU -_SEC_FLAGS=SEC_FLAGS -_SEC_TRAFFIC_SECRET_TYPE=SEC_TRAFFIC_SECRET_TYPE -_SEC_TRAFFIC_SECRETS=SEC_TRAFFIC_SECRETS -_SecPkgCredentials_NamesW=SecPkgCredentials_NamesW -_SecPkgCredentials_NamesA=SecPkgCredentials_NamesA -_SecPkgCredentials_SSIProviderW=SecPkgCredentials_SSIProviderW -_SecPkgCredentials_SSIProviderA=SecPkgCredentials_SSIProviderA -_SecPkgCredentials_KdcProxySettingsW=SecPkgCredentials_KdcProxySettingsW -_SecPkgCredentials_Cert=SecPkgCredentials_Cert -_SecPkgContext_SubjectAttributes=SecPkgContext_SubjectAttributes -_SECPKG_CRED_CLASS=SECPKG_CRED_CLASS -_SecPkgContext_CredInfo=SecPkgContext_CredInfo -_SecPkgContext_NegoPackageInfo=SecPkgContext_NegoPackageInfo -_SecPkgContext_NegoStatus=SecPkgContext_NegoStatus -_SecPkgContext_Sizes=SecPkgContext_Sizes -_SecPkgContext_StreamSizes=SecPkgContext_StreamSizes -_SecPkgContext_NamesW=SecPkgContext_NamesW -_SECPKG_ATTR_LCT_STATUS=SECPKG_ATTR_LCT_STATUS -_SecPkgContext_LastClientTokenStatus=SecPkgContext_LastClientTokenStatus -_SecPkgContext_NamesA=SecPkgContext_NamesA -_SecPkgContext_Lifespan=SecPkgContext_Lifespan -_SecPkgContext_DceInfo=SecPkgContext_DceInfo -_SecPkgContext_KeyInfoA=SecPkgContext_KeyInfoA -_SecPkgContext_KeyInfoW=SecPkgContext_KeyInfoW -_SecPkgContext_AuthorityA=SecPkgContext_AuthorityA -_SecPkgContext_AuthorityW=SecPkgContext_AuthorityW -_SecPkgContext_ProtoInfoA=SecPkgContext_ProtoInfoA -_SecPkgContext_ProtoInfoW=SecPkgContext_ProtoInfoW -_SecPkgContext_PasswordExpiry=SecPkgContext_PasswordExpiry -_SecPkgContext_LogoffTime=SecPkgContext_LogoffTime -_SecPkgContext_SessionKey=SecPkgContext_SessionKey -_SecPkgContext_NegoKeys=SecPkgContext_NegoKeys -_SecPkgContext_PackageInfoW=SecPkgContext_PackageInfoW -_SecPkgContext_PackageInfoA=SecPkgContext_PackageInfoA -_SecPkgContext_UserFlags=SecPkgContext_UserFlags -_SecPkgContext_Flags=SecPkgContext_Flags -_SecPkgContext_NegotiationInfoA=SecPkgContext_NegotiationInfoA -_SecPkgContext_NegotiationInfoW=SecPkgContext_NegotiationInfoW -_SecPkgContext_NativeNamesW=SecPkgContext_NativeNamesW -_SecPkgContext_NativeNamesA=SecPkgContext_NativeNamesA -_SecPkgContext_CredentialNameW=SecPkgContext_CredentialNameW -_SecPkgContext_CredentialNameA=SecPkgContext_CredentialNameA -_SecPkgContext_AccessToken=SecPkgContext_AccessToken -_SecPkgContext_TargetInformation=SecPkgContext_TargetInformation -_SecPkgContext_AuthzID=SecPkgContext_AuthzID -_SecPkgContext_Target=SecPkgContext_Target -_SecPkgContext_ClientSpecifiedTarget=SecPkgContext_ClientSpecifiedTarget -_SecPkgContext_Bindings=SecPkgContext_Bindings -_SEC_APPLICATION_PROTOCOL_NEGOTIATION_STATUS=SEC_APPLICATION_PROTOCOL_NEGOTIATION_STATUS -_SecPkgContext_ApplicationProtocol=SecPkgContext_ApplicationProtocol -_SecPkgContext_NegotiatedTlsExtensions=SecPkgContext_NegotiatedTlsExtensions -_SECPKG_APP_MODE_INFO=SECPKG_APP_MODE_INFO -_SecDelegationType=SecDelegationType -_SASL_AUTHZID_STATE=SASL_AUTHZID_STATE -_SEC_WINNT_AUTH_IDENTITY_EX2=SEC_WINNT_AUTH_IDENTITY_EX2 -_SEC_WINNT_AUTH_IDENTITY_EXW=SEC_WINNT_AUTH_IDENTITY_EXW -_SEC_WINNT_AUTH_IDENTITY_EXA=SEC_WINNT_AUTH_IDENTITY_EXA -_SEC_WINNT_AUTH_IDENTITY_INFO=SEC_WINNT_AUTH_IDENTITY_INFO -_SECURITY_PACKAGE_OPTIONS=SECURITY_PACKAGE_OPTIONS -_LSA_TOKEN_INFORMATION_TYPE=LSA_TOKEN_INFORMATION_TYPE -_LSA_TOKEN_INFORMATION_NULL=LSA_TOKEN_INFORMATION_NULL -_LSA_TOKEN_INFORMATION_V1=LSA_TOKEN_INFORMATION_V1 -_LSA_TOKEN_INFORMATION_V3=LSA_TOKEN_INFORMATION_V3 -_LSA_DISPATCH_TABLE=LSA_DISPATCH_TABLE -_SECPKG_CLIENT_INFO=SECPKG_CLIENT_INFO -_SECPKG_CALL_INFO=SECPKG_CALL_INFO -_SECPKG_SUPPLEMENTAL_CRED=SECPKG_SUPPLEMENTAL_CRED -_SECPKG_BYTE_VECTOR=SECPKG_BYTE_VECTOR -_SECPKG_SHORT_VECTOR=SECPKG_SHORT_VECTOR -_SECPKG_SUPPLIED_CREDENTIAL=SECPKG_SUPPLIED_CREDENTIAL -_SECPKG_CREDENTIAL=SECPKG_CREDENTIAL -_SECPKG_SUPPLEMENTAL_CRED_ARRAY=SECPKG_SUPPLEMENTAL_CRED_ARRAY -_SECPKG_PRIMARY_CRED=SECPKG_PRIMARY_CRED -_SECPKG_PRIMARY_CRED_EX=SECPKG_PRIMARY_CRED_EX -_SECPKG_PARAMETERS=SECPKG_PARAMETERS -_SECPKG_EXTENDED_INFORMATION_CLASS=SECPKG_EXTENDED_INFORMATION_CLASS -_SECPKG_GSS_INFO=SECPKG_GSS_INFO -_SECPKG_CONTEXT_THUNKS=SECPKG_CONTEXT_THUNKS -_SECPKG_MUTUAL_AUTH_LEVEL=SECPKG_MUTUAL_AUTH_LEVEL -_SECPKG_WOW_CLIENT_DLL=SECPKG_WOW_CLIENT_DLL -_SECPKG_SERIALIZED_OID=SECPKG_SERIALIZED_OID -_SECPKG_EXTRA_OIDS=SECPKG_EXTRA_OIDS -_SECPKG_NEGO2_INFO=SECPKG_NEGO2_INFO -_SECPKG_EXTENDED_INFORMATION=SECPKG_EXTENDED_INFORMATION -_SECPKG_TARGETINFO=SECPKG_TARGETINFO -_SecPkgContext_SaslContext=SecPkgContext_SaslContext -_SECURITY_USER_DATA=SECURITY_USER_DATA -_SECPKG_CALL_PACKAGE_MESSAGE_TYPE=SECPKG_CALL_PACKAGE_MESSAGE_TYPE -_SECPKG_CALL_PACKAGE_PIN_DC_REQUEST=SECPKG_CALL_PACKAGE_PIN_DC_REQUEST -_SECPKG_CALL_PACKAGE_UNPIN_ALL_DCS_REQUEST=SECPKG_CALL_PACKAGE_UNPIN_ALL_DCS_REQUEST -_SECPKG_CALL_PACKAGE_TRANSFER_CRED_REQUEST=SECPKG_CALL_PACKAGE_TRANSFER_CRED_REQUEST -_SECPKG_REDIRECTED_LOGON_BUFFER=SECPKG_REDIRECTED_LOGON_BUFFER -_SECPKG_POST_LOGON_USER_INFO=SECPKG_POST_LOGON_USER_INFO -_SECPKG_SESSIONINFO_TYPE=SECPKG_SESSIONINFO_TYPE -_SECPKG_NAME_TYPE=SECPKG_NAME_TYPE -_SECPKG_EVENT_PACKAGE_CHANGE=SECPKG_EVENT_PACKAGE_CHANGE -_SECPKG_EVENT_ROLE_CHANGE=SECPKG_EVENT_ROLE_CHANGE -_SECPKG_EVENT_NOTIFY=SECPKG_EVENT_NOTIFY -_CRED_FETCH=CRED_FETCH -_ENCRYPTED_CREDENTIALW=ENCRYPTED_CREDENTIALW -_SEC_WINNT_AUTH_IDENTITY32=SEC_WINNT_AUTH_IDENTITY32 -_SEC_WINNT_AUTH_IDENTITY_EX32=SEC_WINNT_AUTH_IDENTITY_EX32 -_LSA_SECPKG_FUNCTION_TABLE=LSA_SECPKG_FUNCTION_TABLE -_SECPKG_DLL_FUNCTIONS=SECPKG_DLL_FUNCTIONS -_SECPKG_FUNCTION_TABLE=SECPKG_FUNCTION_TABLE -_SECPKG_USER_FUNCTION_TABLE=SECPKG_USER_FUNCTION_TABLE -_KSEC_CONTEXT_TYPE=KSEC_CONTEXT_TYPE -_KSEC_LIST_ENTRY=KSEC_LIST_ENTRY -_SECPKG_KERNEL_FUNCTIONS=SECPKG_KERNEL_FUNCTIONS -_SECPKG_KERNEL_FUNCTION_TABLE=SECPKG_KERNEL_FUNCTION_TABLE -_MIDL_TYPE_PICKLING_INFO=MIDL_TYPE_PICKLING_INFO -_AT_INFO=AT_INFO -_AT_ENUM=AT_ENUM -_NOTIFYINFO=NOTIFYINFO -_NOTIFYADD=NOTIFYADD -_NOTIFYCANCEL=NOTIFYCANCEL -_GLOBAL_MACHINE_POWER_POLICY=GLOBAL_MACHINE_POWER_POLICY -_GLOBAL_USER_POWER_POLICY=GLOBAL_USER_POWER_POLICY -_GLOBAL_POWER_POLICY=GLOBAL_POWER_POLICY -_MACHINE_POWER_POLICY=MACHINE_POWER_POLICY -_MACHINE_PROCESSOR_POWER_POLICY=MACHINE_PROCESSOR_POWER_POLICY -_USER_POWER_POLICY=USER_POWER_POLICY -_POWER_POLICY=POWER_POLICY -_POWER_DATA_ACCESSOR=POWER_DATA_ACCESSOR -_DEVICE_NOTIFY_SUBSCRIBE_PARAMETERS=DEVICE_NOTIFY_SUBSCRIBE_PARAMETERS -_THERMAL_EVENT=THERMAL_EVENT -_WS_XML_DICTIONARY=WS_XML_DICTIONARY -_WS_XML_STRING=WS_XML_STRING -_WS_XML_QNAME=WS_XML_QNAME -_WS_XML_NODE_POSITION=WS_XML_NODE_POSITION -_WS_XML_READER_PROPERTY=WS_XML_READER_PROPERTY -_WS_XML_CANONICALIZATION_INCLUSIVE_PREFIXES=WS_XML_CANONICALIZATION_INCLUSIVE_PREFIXES -_WS_XML_CANONICALIZATION_PROPERTY=WS_XML_CANONICALIZATION_PROPERTY -_WS_XML_WRITER_PROPERTY=WS_XML_WRITER_PROPERTY -_WS_XML_BUFFER_PROPERTY=WS_XML_BUFFER_PROPERTY -_WS_XML_TEXT=WS_XML_TEXT -_WS_XML_UTF8_TEXT=WS_XML_UTF8_TEXT -_WS_XML_UTF16_TEXT=WS_XML_UTF16_TEXT -_WS_XML_BASE64_TEXT=WS_XML_BASE64_TEXT -_WS_XML_BOOL_TEXT=WS_XML_BOOL_TEXT -_WS_XML_INT32_TEXT=WS_XML_INT32_TEXT -_WS_XML_INT64_TEXT=WS_XML_INT64_TEXT -_WS_XML_UINT64_TEXT=WS_XML_UINT64_TEXT -_WS_XML_FLOAT_TEXT=WS_XML_FLOAT_TEXT -_WS_XML_DOUBLE_TEXT=WS_XML_DOUBLE_TEXT -_WS_XML_DECIMAL_TEXT=WS_XML_DECIMAL_TEXT -_WS_XML_GUID_TEXT=WS_XML_GUID_TEXT -_WS_XML_UNIQUE_ID_TEXT=WS_XML_UNIQUE_ID_TEXT -_WS_DATETIME=WS_DATETIME -_WS_XML_DATETIME_TEXT=WS_XML_DATETIME_TEXT -_WS_TIMESPAN=WS_TIMESPAN -_WS_XML_TIMESPAN_TEXT=WS_XML_TIMESPAN_TEXT -_WS_XML_QNAME_TEXT=WS_XML_QNAME_TEXT -_WS_XML_LIST_TEXT=WS_XML_LIST_TEXT -_WS_XML_NODE=WS_XML_NODE -_WS_XML_ATTRIBUTE=WS_XML_ATTRIBUTE -_WS_XML_ELEMENT_NODE=WS_XML_ELEMENT_NODE -_WS_XML_TEXT_NODE=WS_XML_TEXT_NODE -_WS_XML_COMMENT_NODE=WS_XML_COMMENT_NODE -_WS_XML_READER_INPUT=WS_XML_READER_INPUT -_WS_XML_READER_BUFFER_INPUT=WS_XML_READER_BUFFER_INPUT -_WS_XML_READER_STREAM_INPUT=WS_XML_READER_STREAM_INPUT -_WS_XML_READER_ENCODING=WS_XML_READER_ENCODING -_WS_XML_READER_TEXT_ENCODING=WS_XML_READER_TEXT_ENCODING -_WS_XML_READER_BINARY_ENCODING=WS_XML_READER_BINARY_ENCODING -_WS_STRING=WS_STRING -_WS_XML_READER_MTOM_ENCODING=WS_XML_READER_MTOM_ENCODING -_WS_XML_READER_RAW_ENCODING=WS_XML_READER_RAW_ENCODING -_WS_XML_WRITER_ENCODING=WS_XML_WRITER_ENCODING -_WS_XML_WRITER_TEXT_ENCODING=WS_XML_WRITER_TEXT_ENCODING -_WS_XML_WRITER_BINARY_ENCODING=WS_XML_WRITER_BINARY_ENCODING -_WS_XML_WRITER_MTOM_ENCODING=WS_XML_WRITER_MTOM_ENCODING -_WS_XML_WRITER_RAW_ENCODING=WS_XML_WRITER_RAW_ENCODING -_WS_XML_WRITER_OUTPUT=WS_XML_WRITER_OUTPUT -_WS_XML_WRITER_BUFFER_OUTPUT=WS_XML_WRITER_BUFFER_OUTPUT -_WS_XML_WRITER_STREAM_OUTPUT=WS_XML_WRITER_STREAM_OUTPUT -_WS_XML_WRITER_PROPERTIES=WS_XML_WRITER_PROPERTIES -_WS_XML_READER_PROPERTIES=WS_XML_READER_PROPERTIES -_WS_ASYNC_CONTEXT=WS_ASYNC_CONTEXT -_WS_ASYNC_STATE=WS_ASYNC_STATE -_WS_ASYNC_OPERATION=WS_ASYNC_OPERATION -_WS_CHANNEL_PROPERTY=WS_CHANNEL_PROPERTY -_WS_CUSTOM_HTTP_PROXY=WS_CUSTOM_HTTP_PROXY -_WS_CHANNEL_PROPERTIES=WS_CHANNEL_PROPERTIES -_WS_CUSTOM_CHANNEL_CALLBACKS=WS_CUSTOM_CHANNEL_CALLBACKS -_WS_HTTP_HEADER_MAPPING=WS_HTTP_HEADER_MAPPING -_WS_HTTP_MESSAGE_MAPPING=WS_HTTP_MESSAGE_MAPPING -_WS_ELEMENT_DESCRIPTION=WS_ELEMENT_DESCRIPTION -_WS_MESSAGE_DESCRIPTION=WS_MESSAGE_DESCRIPTION -_WS_CHANNEL_ENCODER=WS_CHANNEL_ENCODER -_WS_CHANNEL_DECODER=WS_CHANNEL_DECODER -_WS_HTTP_REDIRECT_CALLBACK_CONTEXT=WS_HTTP_REDIRECT_CALLBACK_CONTEXT -_WS_ENDPOINT_IDENTITY=WS_ENDPOINT_IDENTITY -_WS_ENDPOINT_ADDRESS=WS_ENDPOINT_ADDRESS -_WS_DNS_ENDPOINT_IDENTITY=WS_DNS_ENDPOINT_IDENTITY -_WS_UPN_ENDPOINT_IDENTITY=WS_UPN_ENDPOINT_IDENTITY -_WS_SPN_ENDPOINT_IDENTITY=WS_SPN_ENDPOINT_IDENTITY -_WS_BYTES=WS_BYTES -_WS_RSA_ENDPOINT_IDENTITY=WS_RSA_ENDPOINT_IDENTITY -_WS_CERT_ENDPOINT_IDENTITY=WS_CERT_ENDPOINT_IDENTITY -_WS_UNKNOWN_ENDPOINT_IDENTITY=WS_UNKNOWN_ENDPOINT_IDENTITY -_WS_ERROR_PROPERTY=WS_ERROR_PROPERTY -_WS_FAULT_REASON=WS_FAULT_REASON -_WS_FAULT_CODE=WS_FAULT_CODE -_WS_FAULT=WS_FAULT -_WS_FAULT_DETAIL_DESCRIPTION=WS_FAULT_DETAIL_DESCRIPTION -_WS_HEAP_PROPERTY=WS_HEAP_PROPERTY -_WS_HEAP_PROPERTIES=WS_HEAP_PROPERTIES -_WS_LISTENER_PROPERTY=WS_LISTENER_PROPERTY -_WS_DISALLOWED_USER_AGENT_SUBSTRINGS=WS_DISALLOWED_USER_AGENT_SUBSTRINGS -_WS_LISTENER_PROPERTIES=WS_LISTENER_PROPERTIES -_WS_HOST_NAMES=WS_HOST_NAMES -_WS_CUSTOM_LISTENER_CALLBACKS=WS_CUSTOM_LISTENER_CALLBACKS -_WS_MESSAGE_PROPERTY=WS_MESSAGE_PROPERTY -_WS_MESSAGE_PROPERTIES=WS_MESSAGE_PROPERTIES -_WS_SECURITY_ALGORITHM_PROPERTY=WS_SECURITY_ALGORITHM_PROPERTY -_WS_SECURITY_ALGORITHM_SUITE=WS_SECURITY_ALGORITHM_SUITE -_WS_SECURITY_PROPERTY=WS_SECURITY_PROPERTY -_WS_SECURITY_PROPERTIES=WS_SECURITY_PROPERTIES -_WS_SECURITY_BINDING_PROPERTY=WS_SECURITY_BINDING_PROPERTY -_WS_SECURITY_BINDING_PROPERTIES=WS_SECURITY_BINDING_PROPERTIES -_WS_SERVICE_SECURITY_IDENTITIES=WS_SERVICE_SECURITY_IDENTITIES -_WS_CERTIFICATE_VALIDATION_CALLBACK_CONTEXT=WS_CERTIFICATE_VALIDATION_CALLBACK_CONTEXT -_WS_CERT_CREDENTIAL=WS_CERT_CREDENTIAL -_WS_SUBJECT_NAME_CERT_CREDENTIAL=WS_SUBJECT_NAME_CERT_CREDENTIAL -_WS_THUMBPRINT_CERT_CREDENTIAL=WS_THUMBPRINT_CERT_CREDENTIAL -_WS_CUSTOM_CERT_CREDENTIAL=WS_CUSTOM_CERT_CREDENTIAL -_WS_WINDOWS_INTEGRATED_AUTH_CREDENTIAL=WS_WINDOWS_INTEGRATED_AUTH_CREDENTIAL -_WS_STRING_WINDOWS_INTEGRATED_AUTH_CREDENTIAL=WS_STRING_WINDOWS_INTEGRATED_AUTH_CREDENTIAL -_WS_DEFAULT_WINDOWS_INTEGRATED_AUTH_CREDENTIAL=WS_DEFAULT_WINDOWS_INTEGRATED_AUTH_CREDENTIAL -_WS_OPAQUE_WINDOWS_INTEGRATED_AUTH_CREDENTIAL=WS_OPAQUE_WINDOWS_INTEGRATED_AUTH_CREDENTIAL -_WS_USERNAME_CREDENTIAL=WS_USERNAME_CREDENTIAL -_WS_STRING_USERNAME_CREDENTIAL=WS_STRING_USERNAME_CREDENTIAL -_WS_SECURITY_KEY_HANDLE=WS_SECURITY_KEY_HANDLE -_WS_RAW_SYMMETRIC_SECURITY_KEY_HANDLE=WS_RAW_SYMMETRIC_SECURITY_KEY_HANDLE -_WS_NCRYPT_ASYMMETRIC_SECURITY_KEY_HANDLE=WS_NCRYPT_ASYMMETRIC_SECURITY_KEY_HANDLE -_WS_CAPI_ASYMMETRIC_SECURITY_KEY_HANDLE=WS_CAPI_ASYMMETRIC_SECURITY_KEY_HANDLE -_WS_SECURITY_BINDING=WS_SECURITY_BINDING -_WS_SSL_TRANSPORT_SECURITY_BINDING=WS_SSL_TRANSPORT_SECURITY_BINDING -_WS_TCP_SSPI_TRANSPORT_SECURITY_BINDING=WS_TCP_SSPI_TRANSPORT_SECURITY_BINDING -_WS_NAMEDPIPE_SSPI_TRANSPORT_SECURITY_BINDING=WS_NAMEDPIPE_SSPI_TRANSPORT_SECURITY_BINDING -_WS_HTTP_HEADER_AUTH_SECURITY_BINDING=WS_HTTP_HEADER_AUTH_SECURITY_BINDING -_WS_KERBEROS_APREQ_MESSAGE_SECURITY_BINDING=WS_KERBEROS_APREQ_MESSAGE_SECURITY_BINDING -_WS_USERNAME_MESSAGE_SECURITY_BINDING=WS_USERNAME_MESSAGE_SECURITY_BINDING -_WS_SECURITY_DESCRIPTION=WS_SECURITY_DESCRIPTION -_WS_SECURITY_CONTEXT_MESSAGE_SECURITY_BINDING=WS_SECURITY_CONTEXT_MESSAGE_SECURITY_BINDING -_WS_SECURITY_CONTEXT_PROPERTY=WS_SECURITY_CONTEXT_PROPERTY -_WS_XML_SECURITY_TOKEN_PROPERTY=WS_XML_SECURITY_TOKEN_PROPERTY -_WS_XML_TOKEN_MESSAGE_SECURITY_BINDING=WS_XML_TOKEN_MESSAGE_SECURITY_BINDING -_WS_SAML_AUTHENTICATOR=WS_SAML_AUTHENTICATOR -_WS_CERT_SIGNED_SAML_AUTHENTICATOR=WS_CERT_SIGNED_SAML_AUTHENTICATOR -_WS_SAML_MESSAGE_SECURITY_BINDING=WS_SAML_MESSAGE_SECURITY_BINDING -_WS_REQUEST_SECURITY_TOKEN_PROPERTY=WS_REQUEST_SECURITY_TOKEN_PROPERTY -_WS_ANY_ATTRIBUTE=WS_ANY_ATTRIBUTE -_WS_ANY_ATTRIBUTES=WS_ANY_ATTRIBUTES -_WS_BOOL_DESCRIPTION=WS_BOOL_DESCRIPTION -_WS_GUID_DESCRIPTION=WS_GUID_DESCRIPTION -_WS_DATETIME_DESCRIPTION=WS_DATETIME_DESCRIPTION -_WS_DURATION=WS_DURATION -_WS_DURATION_DESCRIPTION=WS_DURATION_DESCRIPTION -_WS_TIMESPAN_DESCRIPTION=WS_TIMESPAN_DESCRIPTION -_WS_UNIQUE_ID_DESCRIPTION=WS_UNIQUE_ID_DESCRIPTION -_WS_STRING_DESCRIPTION=WS_STRING_DESCRIPTION -_WS_XML_STRING_DESCRIPTION=WS_XML_STRING_DESCRIPTION -_WS_XML_QNAME_DESCRIPTION=WS_XML_QNAME_DESCRIPTION -_WS_CHAR_ARRAY_DESCRIPTION=WS_CHAR_ARRAY_DESCRIPTION -_WS_BYTE_ARRAY_DESCRIPTION=WS_BYTE_ARRAY_DESCRIPTION -_WS_UTF8_ARRAY_DESCRIPTION=WS_UTF8_ARRAY_DESCRIPTION -_WS_WSZ_DESCRIPTION=WS_WSZ_DESCRIPTION -_WS_INT8_DESCRIPTION=WS_INT8_DESCRIPTION -_WS_UINT8_DESCRIPTION=WS_UINT8_DESCRIPTION -_WS_INT16_DESCRIPTION=WS_INT16_DESCRIPTION -_WS_UINT16_DESCRIPTION=WS_UINT16_DESCRIPTION -_WS_INT32_DESCRIPTION=WS_INT32_DESCRIPTION -_WS_UINT32_DESCRIPTION=WS_UINT32_DESCRIPTION -_WS_INT64_DESCRIPTION=WS_INT64_DESCRIPTION -_WS_UINT64_DESCRIPTION=WS_UINT64_DESCRIPTION -_WS_FLOAT_DESCRIPTION=WS_FLOAT_DESCRIPTION -_WS_DOUBLE_DESCRIPTION=WS_DOUBLE_DESCRIPTION -_WS_DECIMAL_DESCRIPTION=WS_DECIMAL_DESCRIPTION -_WS_BYTES_DESCRIPTION=WS_BYTES_DESCRIPTION -_WS_ENUM_VALUE=WS_ENUM_VALUE -_WS_ENUM_DESCRIPTION=WS_ENUM_DESCRIPTION -_WS_ITEM_RANGE=WS_ITEM_RANGE -_WS_DEFAULT_VALUE=WS_DEFAULT_VALUE -_WS_FIELD_DESCRIPTION=WS_FIELD_DESCRIPTION -_WS_UNION_FIELD_DESCRIPTION=WS_UNION_FIELD_DESCRIPTION -_WS_STRUCT_DESCRIPTION=WS_STRUCT_DESCRIPTION -_WS_UNION_DESCRIPTION=WS_UNION_DESCRIPTION -_WS_ENDPOINT_ADDRESS_DESCRIPTION=WS_ENDPOINT_ADDRESS_DESCRIPTION -_WS_FAULT_DESCRIPTION=WS_FAULT_DESCRIPTION -_WS_VOID_DESCRIPTION=WS_VOID_DESCRIPTION -_WS_CUSTOM_TYPE_DESCRIPTION=WS_CUSTOM_TYPE_DESCRIPTION -_WS_ATTRIBUTE_DESCRIPTION=WS_ATTRIBUTE_DESCRIPTION -_WS_PARAMETER_DESCRIPTION=WS_PARAMETER_DESCRIPTION -_WS_OPERATION_DESCRIPTION=WS_OPERATION_DESCRIPTION -_WS_CONTRACT_DESCRIPTION=WS_CONTRACT_DESCRIPTION -_WS_SERVICE_CONTRACT=WS_SERVICE_CONTRACT -_WS_SERVICE_PROPERTY=WS_SERVICE_PROPERTY -_WS_SERVICE_ENDPOINT_PROPERTY=WS_SERVICE_ENDPOINT_PROPERTY -_WS_SERVICE_PROPERTY_ACCEPT_CALLBACK=WS_SERVICE_PROPERTY_ACCEPT_CALLBACK -_WS_SERVICE_METADATA_DOCUMENT=WS_SERVICE_METADATA_DOCUMENT -_WS_SERVICE_METADATA=WS_SERVICE_METADATA -_WS_SERVICE_PROPERTY_CLOSE_CALLBACK=WS_SERVICE_PROPERTY_CLOSE_CALLBACK -_WS_SERVICE_ENDPOINT_METADATA=WS_SERVICE_ENDPOINT_METADATA -_WS_SERVICE_ENDPOINT=WS_SERVICE_ENDPOINT -_WS_PROXY_PROPERTY=WS_PROXY_PROPERTY -_WS_PROXY_MESSAGE_CALLBACK_CONTEXT=WS_PROXY_MESSAGE_CALLBACK_CONTEXT -_WS_CALL_PROPERTY=WS_CALL_PROPERTY -_WS_URL=WS_URL -_WS_HTTP_URL=WS_HTTP_URL -_WS_HTTPS_URL=WS_HTTPS_URL -_WS_NETTCP_URL=WS_NETTCP_URL -_WS_SOAPUDP_URL=WS_SOAPUDP_URL -_WS_NETPIPE_URL=WS_NETPIPE_URL -_WS_UNIQUE_ID=WS_UNIQUE_ID -_WS_BUFFERS=WS_BUFFERS -_WS_METADATA_ENDPOINT=WS_METADATA_ENDPOINT -_WS_METADATA_ENDPOINTS=WS_METADATA_ENDPOINTS -_WS_METADATA_PROPERTY=WS_METADATA_PROPERTY -_WS_POLICY_PROPERTY=WS_POLICY_PROPERTY -_WS_POLICY_PROPERTIES=WS_POLICY_PROPERTIES -_WS_SECURITY_BINDING_PROPERTY_CONSTRAINT=WS_SECURITY_BINDING_PROPERTY_CONSTRAINT -_WS_SECURITY_BINDING_CONSTRAINT=WS_SECURITY_BINDING_CONSTRAINT -_WS_SSL_TRANSPORT_SECURITY_BINDING_CONSTRAINT=WS_SSL_TRANSPORT_SECURITY_BINDING_CONSTRAINT -_WS_USERNAME_MESSAGE_SECURITY_BINDING_CONSTRAINT=WS_USERNAME_MESSAGE_SECURITY_BINDING_CONSTRAINT -_WS_HTTP_HEADER_AUTH_SECURITY_BINDING_CONSTRAINT=WS_HTTP_HEADER_AUTH_SECURITY_BINDING_CONSTRAINT -_WS_TCP_SSPI_TRANSPORT_SECURITY_BINDING_CONSTRAINT=WS_TCP_SSPI_TRANSPORT_SECURITY_BINDING_CONSTRAINT -_WS_CERT_MESSAGE_SECURITY_BINDING_CONSTRAINT=WS_CERT_MESSAGE_SECURITY_BINDING_CONSTRAINT -_WS_KERBEROS_APREQ_MESSAGE_SECURITY_BINDING_CONSTRAINT=WS_KERBEROS_APREQ_MESSAGE_SECURITY_BINDING_CONSTRAINT -_WS_REQUEST_SECURITY_TOKEN_PROPERTY_CONSTRAINT=WS_REQUEST_SECURITY_TOKEN_PROPERTY_CONSTRAINT -_WS_ISSUED_TOKEN_MESSAGE_SECURITY_BINDING_CONSTRAINT=WS_ISSUED_TOKEN_MESSAGE_SECURITY_BINDING_CONSTRAINT -_WS_SECURITY_PROPERTY_CONSTRAINT=WS_SECURITY_PROPERTY_CONSTRAINT -_WS_SECURITY_CONSTRAINTS=WS_SECURITY_CONSTRAINTS -_WS_SECURITY_CONTEXT_MESSAGE_SECURITY_BINDING_CONSTRAINT=WS_SECURITY_CONTEXT_MESSAGE_SECURITY_BINDING_CONSTRAINT -_WS_CHANNEL_PROPERTY_CONSTRAINT=WS_CHANNEL_PROPERTY_CONSTRAINT -_WS_POLICY_EXTENSION=WS_POLICY_EXTENSION -_WS_ENDPOINT_POLICY_EXTENSION=WS_ENDPOINT_POLICY_EXTENSION -_WS_POLICY_CONSTRAINTS=WS_POLICY_CONSTRAINTS -_WS_HTTP_POLICY_DESCRIPTION=WS_HTTP_POLICY_DESCRIPTION -_WS_SSL_TRANSPORT_SECURITY_BINDING_POLICY_DESCRIPTION=WS_SSL_TRANSPORT_SECURITY_BINDING_POLICY_DESCRIPTION -_WS_HTTP_SSL_POLICY_DESCRIPTION=WS_HTTP_SSL_POLICY_DESCRIPTION -_WS_HTTP_HEADER_AUTH_SECURITY_BINDING_POLICY_DESCRIPTION=WS_HTTP_HEADER_AUTH_SECURITY_BINDING_POLICY_DESCRIPTION -_WS_HTTP_HEADER_AUTH_POLICY_DESCRIPTION=WS_HTTP_HEADER_AUTH_POLICY_DESCRIPTION -_WS_HTTP_SSL_HEADER_AUTH_POLICY_DESCRIPTION=WS_HTTP_SSL_HEADER_AUTH_POLICY_DESCRIPTION -_WS_USERNAME_MESSAGE_SECURITY_BINDING_POLICY_DESCRIPTION=WS_USERNAME_MESSAGE_SECURITY_BINDING_POLICY_DESCRIPTION -_WS_HTTP_SSL_USERNAME_POLICY_DESCRIPTION=WS_HTTP_SSL_USERNAME_POLICY_DESCRIPTION -_WS_KERBEROS_APREQ_MESSAGE_SECURITY_BINDING_POLICY_DESCRIPTION=WS_KERBEROS_APREQ_MESSAGE_SECURITY_BINDING_POLICY_DESCRIPTION -_WS_HTTP_SSL_KERBEROS_APREQ_POLICY_DESCRIPTION=WS_HTTP_SSL_KERBEROS_APREQ_POLICY_DESCRIPTION -_WS_TCP_POLICY_DESCRIPTION=WS_TCP_POLICY_DESCRIPTION -_WS_SSPI_TRANSPORT_SECURITY_BINDING_POLICY_DESCRIPTION=WS_SSPI_TRANSPORT_SECURITY_BINDING_POLICY_DESCRIPTION -_WS_TCP_SSPI_POLICY_DESCRIPTION=WS_TCP_SSPI_POLICY_DESCRIPTION -_WS_TCP_SSPI_USERNAME_POLICY_DESCRIPTION=WS_TCP_SSPI_USERNAME_POLICY_DESCRIPTION -_WS_TCP_SSPI_KERBEROS_APREQ_POLICY_DESCRIPTION=WS_TCP_SSPI_KERBEROS_APREQ_POLICY_DESCRIPTION -_WS_SECURITY_CONTEXT_MESSAGE_SECURITY_BINDING_POLICY_DESCRIPTION=WS_SECURITY_CONTEXT_MESSAGE_SECURITY_BINDING_POLICY_DESCRIPTION -_WS_SECURITY_CONTEXT_SECURITY_BINDING_POLICY_DESCRIPTION=WS_SECURITY_CONTEXT_SECURITY_BINDING_POLICY_DESCRIPTION -_WS_TCP_SSPI_KERBEROS_APREQ_SECURITY_CONTEXT_POLICY_DESCRIPTION=WS_TCP_SSPI_KERBEROS_APREQ_SECURITY_CONTEXT_POLICY_DESCRIPTION -_WS_TCP_SSPI_USERNAME_SECURITY_CONTEXT_POLICY_DESCRIPTION=WS_TCP_SSPI_USERNAME_SECURITY_CONTEXT_POLICY_DESCRIPTION -_WS_HTTP_SSL_USERNAME_SECURITY_CONTEXT_POLICY_DESCRIPTION=WS_HTTP_SSL_USERNAME_SECURITY_CONTEXT_POLICY_DESCRIPTION -_WS_HTTP_SSL_KERBEROS_APREQ_SECURITY_CONTEXT_POLICY_DESCRIPTION=WS_HTTP_SSL_KERBEROS_APREQ_SECURITY_CONTEXT_POLICY_DESCRIPTION -_WS_HTTP_BINDING_TEMPLATE=WS_HTTP_BINDING_TEMPLATE -_WS_TCP_BINDING_TEMPLATE=WS_TCP_BINDING_TEMPLATE -_WS_SSL_TRANSPORT_SECURITY_BINDING_TEMPLATE=WS_SSL_TRANSPORT_SECURITY_BINDING_TEMPLATE -_WS_HTTP_SSL_BINDING_TEMPLATE=WS_HTTP_SSL_BINDING_TEMPLATE -_WS_HTTP_HEADER_AUTH_SECURITY_BINDING_TEMPLATE=WS_HTTP_HEADER_AUTH_SECURITY_BINDING_TEMPLATE -_WS_HTTP_HEADER_AUTH_BINDING_TEMPLATE=WS_HTTP_HEADER_AUTH_BINDING_TEMPLATE -_WS_TCP_SSPI_TRANSPORT_SECURITY_BINDING_TEMPLATE=WS_TCP_SSPI_TRANSPORT_SECURITY_BINDING_TEMPLATE -_WS_TCP_SSPI_BINDING_TEMPLATE=WS_TCP_SSPI_BINDING_TEMPLATE -_WS_HTTP_SSL_HEADER_AUTH_BINDING_TEMPLATE=WS_HTTP_SSL_HEADER_AUTH_BINDING_TEMPLATE -_WS_USERNAME_MESSAGE_SECURITY_BINDING_TEMPLATE=WS_USERNAME_MESSAGE_SECURITY_BINDING_TEMPLATE -_WS_HTTP_SSL_USERNAME_BINDING_TEMPLATE=WS_HTTP_SSL_USERNAME_BINDING_TEMPLATE -_WS_KERBEROS_APREQ_MESSAGE_SECURITY_BINDING_TEMPLATE=WS_KERBEROS_APREQ_MESSAGE_SECURITY_BINDING_TEMPLATE -_WS_HTTP_SSL_KERBEROS_APREQ_BINDING_TEMPLATE=WS_HTTP_SSL_KERBEROS_APREQ_BINDING_TEMPLATE -_WS_TCP_SSPI_USERNAME_BINDING_TEMPLATE=WS_TCP_SSPI_USERNAME_BINDING_TEMPLATE -_WS_TCP_SSPI_KERBEROS_APREQ_BINDING_TEMPLATE=WS_TCP_SSPI_KERBEROS_APREQ_BINDING_TEMPLATE -_WS_SECURITY_CONTEXT_MESSAGE_SECURITY_BINDING_TEMPLATE=WS_SECURITY_CONTEXT_MESSAGE_SECURITY_BINDING_TEMPLATE -_WS_SECURITY_CONTEXT_SECURITY_BINDING_TEMPLATE=WS_SECURITY_CONTEXT_SECURITY_BINDING_TEMPLATE -_WS_HTTP_SSL_USERNAME_SECURITY_CONTEXT_BINDING_TEMPLATE=WS_HTTP_SSL_USERNAME_SECURITY_CONTEXT_BINDING_TEMPLATE -_WS_HTTP_SSL_KERBEROS_APREQ_SECURITY_CONTEXT_BINDING_TEMPLATE=WS_HTTP_SSL_KERBEROS_APREQ_SECURITY_CONTEXT_BINDING_TEMPLATE -_WS_TCP_SSPI_USERNAME_SECURITY_CONTEXT_BINDING_TEMPLATE=WS_TCP_SSPI_USERNAME_SECURITY_CONTEXT_BINDING_TEMPLATE -_WS_TCP_SSPI_KERBEROS_APREQ_SECURITY_CONTEXT_BINDING_TEMPLATE=WS_TCP_SSPI_KERBEROS_APREQ_SECURITY_CONTEXT_BINDING_TEMPLATE -_PROFILER_HEAP_OBJECT_SCOPE_LIST=PROFILER_HEAP_OBJECT_SCOPE_LIST -_PROFILER_PROPERTY_TYPE_SUBSTRING_INFO=PROFILER_PROPERTY_TYPE_SUBSTRING_INFO -_PROFILER_HEAP_OBJECT_RELATIONSHIP=PROFILER_HEAP_OBJECT_RELATIONSHIP -_PROFILER_HEAP_OBJECT_RELATIONSHIP_LIST=PROFILER_HEAP_OBJECT_RELATIONSHIP_LIST -_PROFILER_HEAP_OBJECT_OPTIONAL_INFO=PROFILER_HEAP_OBJECT_OPTIONAL_INFO -_PROFILER_HEAP_OBJECT=PROFILER_HEAP_OBJECT -_PROFILER_HEAP_SUMMARY=PROFILER_HEAP_SUMMARY -_DHCPAPI_PARAMS=DHCPAPI_PARAMS -_DHCPCAPI_CLASSID=DHCPCAPI_CLASSID -_DATE_TIME=DATE_TIME -_DHCP_IP_RANGE=DHCP_IP_RANGE -_DHCP_BINARY_DATA=DHCP_BINARY_DATA -_DHCP_HOST_INFO=DHCP_HOST_INFO -_DHCP_FORCE_FLAG=DHCP_FORCE_FLAG -_DWORD_DWORD=DWORD_DWORD -_DHCP_SUBNET_STATE=DHCP_SUBNET_STATE -_DHCP_SUBNET_INFO=DHCP_SUBNET_INFO -_DHCP_SUBNET_INFO_VQ=DHCP_SUBNET_INFO_VQ -_DHCP_IP_ARRAY=DHCP_IP_ARRAY -_DHCP_IP_CLUSTER=DHCP_IP_CLUSTER -_DHCP_IP_RESERVATION=DHCP_IP_RESERVATION -_DHCP_SUBNET_ELEMENT_DATA=DHCP_SUBNET_ELEMENT_DATA -_DHCP_SUBNET_ELEMENT_UNION=DHCP_SUBNET_ELEMENT_UNION -_DHCP_SUBNET_ELEMENT_INFO_ARRAY=DHCP_SUBNET_ELEMENT_INFO_ARRAY -_DHCP_IPV6_ADDRESS=DHCP_IPV6_ADDRESS -_DHCP_FILTER_LIST_TYPE=DHCP_FILTER_LIST_TYPE -_DHCP_ADDR_PATTERN=DHCP_ADDR_PATTERN -_DHCP_FILTER_GLOBAL_INFO=DHCP_FILTER_GLOBAL_INFO -_DHCP_FILTER_RECORD=DHCP_FILTER_RECORD -_DHCP_FILTER_ENUM_INFO=DHCP_FILTER_ENUM_INFO -_DHCP_OPTION_DATA_TYPE=DHCP_OPTION_DATA_TYPE -_DHCP_OPTION_DATA_ELEMENT=DHCP_OPTION_DATA_ELEMENT -_DHCP_OPTION_ELEMENT_UNION=DHCP_OPTION_ELEMENT_UNION -_DHCP_OPTION_DATA=DHCP_OPTION_DATA -_DHCP_OPTION_TYPE=DHCP_OPTION_TYPE -_DHCP_OPTION=DHCP_OPTION -_DHCP_OPTION_ARRAY=DHCP_OPTION_ARRAY -_DHCP_OPTION_VALUE=DHCP_OPTION_VALUE -_DHCP_OPTION_VALUE_ARRAY=DHCP_OPTION_VALUE_ARRAY -_DHCP_OPTION_SCOPE_TYPE=DHCP_OPTION_SCOPE_TYPE -_DHCP_RESERVED_SCOPE=DHCP_RESERVED_SCOPE -_DHCP_OPTION_SCOPE_INFO=DHCP_OPTION_SCOPE_INFO -_DHCP_OPTION_SCOPE_TYPE6=DHCP_OPTION_SCOPE_TYPE6 -_DHCP_RESERVED_SCOPE6=DHCP_RESERVED_SCOPE6 -_DHCP_OPTION_SCOPE_INFO6=DHCP_OPTION_SCOPE_INFO6 -_DHCP_OPTION_SCOPE_UNION6=DHCP_OPTION_SCOPE_UNION6 -_DHCP_OPTION_LIST=DHCP_OPTION_LIST -_DHCP_CLIENT_INFO=DHCP_CLIENT_INFO -_DHCP_CLIENT_INFO_ARRAY=DHCP_CLIENT_INFO_ARRAY -_QuarantineStatus=QuarantineStatus -_DHCP_CLIENT_INFO_VQ=DHCP_CLIENT_INFO_VQ -_DHCP_CLIENT_INFO_ARRAY_VQ=DHCP_CLIENT_INFO_ARRAY_VQ -_DHCP_CLIENT_FILTER_STATUS_INFO=DHCP_CLIENT_FILTER_STATUS_INFO -_DHCP_CLIENT_FILTER_STATUS_INFO_ARRAY=DHCP_CLIENT_FILTER_STATUS_INFO_ARRAY -_DHCP_CLIENT_INFO_PB=DHCP_CLIENT_INFO_PB -_DHCP_CLIENT_INFO_PB_ARRAY=DHCP_CLIENT_INFO_PB_ARRAY -_DHCP_CLIENT_SEARCH_UNION=DHCP_CLIENT_SEARCH_UNION -_DHCP_PROPERTY=DHCP_PROPERTY -_DHCP_PROPERTY_ARRAY=DHCP_PROPERTY_ARRAY -_DHCP_CLIENT_INFO_EX=DHCP_CLIENT_INFO_EX -_DHCP_CLIENT_INFO_EX_ARRAY=DHCP_CLIENT_INFO_EX_ARRAY -_SCOPE_MIB_INFO=SCOPE_MIB_INFO -_DHCP_MIB_INFO=DHCP_MIB_INFO -_SCOPE_MIB_INFO_VQ=SCOPE_MIB_INFO_VQ -_DHCP_MIB_INFO_VQ=DHCP_MIB_INFO_VQ -_SCOPE_MIB_INFO_V5=SCOPE_MIB_INFO_V5 -_DHCP_MIB_INFO_V5=DHCP_MIB_INFO_V5 -_DHCP_SERVER_CONFIG_INFO=DHCP_SERVER_CONFIG_INFO -_DHCP_SCAN_FLAG=DHCP_SCAN_FLAG -_DHCP_SCAN_ITEM=DHCP_SCAN_ITEM -_DHCP_SCAN_LIST=DHCP_SCAN_LIST -_DHCP_CLASS_INFO=DHCP_CLASS_INFO -_DHCP_CLASS_INFO_ARRAY=DHCP_CLASS_INFO_ARRAY -_DHCP_CLASS_INFO_V6=DHCP_CLASS_INFO_V6 -_DHCP_CLASS_INFO_ARRAY_V6=DHCP_CLASS_INFO_ARRAY_V6 -_DHCP_SERVER_SPECIFIC_STRINGS=DHCP_SERVER_SPECIFIC_STRINGS -_DHCP_IP_RESERVATION_V4=DHCP_IP_RESERVATION_V4 -_DHCP_IP_RESERVATION_INFO=DHCP_IP_RESERVATION_INFO -_DHCP_RESERVATION_INFO_ARRAY=DHCP_RESERVATION_INFO_ARRAY -_DHCP_SUBNET_ELEMENT_DATA_V4=DHCP_SUBNET_ELEMENT_DATA_V4 -_DHCP_SUBNET_ELEMENT_UNION_V4=DHCP_SUBNET_ELEMENT_UNION_V4 -_DHCP_SUBNET_ELEMENT_INFO_ARRAY_V4=DHCP_SUBNET_ELEMENT_INFO_ARRAY_V4 -_DHCP_CLIENT_INFO_V4=DHCP_CLIENT_INFO_V4 -_DHCP_CLIENT_INFO_ARRAY_V4=DHCP_CLIENT_INFO_ARRAY_V4 -_DHCP_SERVER_CONFIG_INFO_V4=DHCP_SERVER_CONFIG_INFO_V4 -_DHCP_SERVER_CONFIG_INFO_VQ=DHCP_SERVER_CONFIG_INFO_VQ -_DHCP_SERVER_CONFIG_INFO_V6=DHCP_SERVER_CONFIG_INFO_V6 -_DHCP_SUPER_SCOPE_TABLE_ENTRY=DHCP_SUPER_SCOPE_TABLE_ENTRY -_DHCP_SUPER_SCOPE_TABLE=DHCP_SUPER_SCOPE_TABLE -_DHCP_CLIENT_INFO_V5=DHCP_CLIENT_INFO_V5 -_DHCP_CLIENT_INFO_ARRAY_V5=DHCP_CLIENT_INFO_ARRAY_V5 -_DHCP_ALL_OPTIONS=DHCP_ALL_OPTIONS -_DHCP_ALL_OPTION_VALUES=DHCP_ALL_OPTION_VALUES -_DHCP_ALL_OPTION_VALUES_PB=DHCP_ALL_OPTION_VALUES_PB -_DHCPDS_SERVER=DHCPDS_SERVER -_DHCPDS_SERVERS=DHCPDS_SERVERS -_DHCP_ATTRIB=DHCP_ATTRIB -_DHCP_ATTRIB_ARRAY=DHCP_ATTRIB_ARRAY -_DHCP_BOOTP_IP_RANGE=DHCP_BOOTP_IP_RANGE -_DHCP_SUBNET_ELEMENT_DATA_V5=DHCP_SUBNET_ELEMENT_DATA_V5 -_DHCP_SUBNET_ELEMENT_INFO_ARRAY_V5=DHCP_SUBNET_ELEMENT_INFO_ARRAY_V5 -_DHCP_PERF_STATS=DHCP_PERF_STATS -_DHCP_BIND_ELEMENT=DHCP_BIND_ELEMENT -_DHCP_BIND_ELEMENT_ARRAY=DHCP_BIND_ELEMENT_ARRAY -_DHCPV6_BIND_ELEMENT=DHCPV6_BIND_ELEMENT -_DHCPV6_BIND_ELEMENT_ARRAY=DHCPV6_BIND_ELEMENT_ARRAY -_DHCP_IP_RANGE_V6=DHCP_IP_RANGE_V6 -_DHCP_HOST_INFO_V6=DHCP_HOST_INFO_V6 -_DHCP_SUBNET_INFO_V6=DHCP_SUBNET_INFO_V6 -_SCOPE_MIB_INFO_V6=SCOPE_MIB_INFO_V6 -_DHCP_MIB_INFO_V6=DHCP_MIB_INFO_V6 -_DHCP_IP_RESERVATION_V6=DHCP_IP_RESERVATION_V6 -_DHCP_SUBNET_ELEMENT_TYPE_V6=DHCP_SUBNET_ELEMENT_TYPE_V6 -_DHCP_SUBNET_ELEMENT_DATA_V6=DHCP_SUBNET_ELEMENT_DATA_V6 -_DHCP_SUBNET_ELEMENT_UNION_V6=DHCP_SUBNET_ELEMENT_UNION_V6 -_DHCP_SUBNET_ELEMENT_INFO_ARRAY_V6=DHCP_SUBNET_ELEMENT_INFO_ARRAY_V6 -_DHCP_CLIENT_INFO_V6=DHCP_CLIENT_INFO_V6 -_DHCPV6_IP_ARRAY=DHCPV6_IP_ARRAY -_DHCP_CLIENT_INFO_ARRAY_V6=DHCP_CLIENT_INFO_ARRAY_V6 -_DHCP_POL_COND=DHCP_POL_COND -_DHCP_POL_COND_ARRAY=DHCP_POL_COND_ARRAY -_DHCP_POL_EXPR=DHCP_POL_EXPR -_DHCP_POL_EXPR_ARRAY=DHCP_POL_EXPR_ARRAY -_DHCP_IP_RANGE_ARRAY=DHCP_IP_RANGE_ARRAY -_DHCP_POLICY=DHCP_POLICY -_DHCP_POLICY_ARRAY=DHCP_POLICY_ARRAY -_DHCP_POLICY_EX=DHCP_POLICY_EX -_DHCP_POLICY_EX_ARRAY=DHCP_POLICY_EX_ARRAY -_DHCP_FAILOVER_MODE=DHCP_FAILOVER_MODE -_DHCP_FAILOVER_SERVER=DHCP_FAILOVER_SERVER -_FSM_STATE=FSM_STATE -_DHCP_FAILOVER_RELATIONSHIP=DHCP_FAILOVER_RELATIONSHIP -_DHCP_FAILOVER_RELATIONSHIP_ARRAY=DHCP_FAILOVER_RELATIONSHIP_ARRAY -_DHCPV4_FAILOVER_CLIENT_INFO=DHCPV4_FAILOVER_CLIENT_INFO -_DHCPV4_FAILOVER_CLIENT_INFO_ARRAY=DHCPV4_FAILOVER_CLIENT_INFO_ARRAY -_DHCPV4_FAILOVER_CLIENT_INFO_EX=DHCPV4_FAILOVER_CLIENT_INFO_EX -_DHCP_FAILOVER_STATISTICS=DHCP_FAILOVER_STATISTICS -_IPNG_ADDRESS=IPNG_ADDRESS -_MCAST_CLIENT_UID=MCAST_CLIENT_UID -_MCAST_SCOPE_CTX=MCAST_SCOPE_CTX -_MCAST_SCOPE_ENTRY=MCAST_SCOPE_ENTRY -_MCAST_LEASE_REQUEST=MCAST_LEASE_REQUEST -_MCAST_LEASE_RESPONSE=MCAST_LEASE_RESPONSE -_DHCPV6CAPI_PARAMS=DHCPV6CAPI_PARAMS -_DHCPV6CAPI_PARAMS_ARRAY=DHCPV6CAPI_PARAMS_ARRAY -_DHCPV6CAPI_CLASSID=DHCPV6CAPI_CLASSID -_DHCPV6Prefix=DHCPV6Prefix -_DHCPV6PrefixLeaseInformation=DHCPV6PrefixLeaseInformation -_DSROLE_MACHINE_ROLE=DSROLE_MACHINE_ROLE -_DSROLE_SERVER_STATE=DSROLE_SERVER_STATE -_DSROLE_PRIMARY_DOMAIN_INFO_LEVEL=DSROLE_PRIMARY_DOMAIN_INFO_LEVEL -_DSROLE_PRIMARY_DOMAIN_INFO_BASIC=DSROLE_PRIMARY_DOMAIN_INFO_BASIC -_DSROLE_UPGRADE_STATUS_INFO=DSROLE_UPGRADE_STATUS_INFO -_DSROLE_OPERATION_STATE=DSROLE_OPERATION_STATE -_DSROLE_OPERATION_STATE_INFO=DSROLE_OPERATION_STATE_INFO -_JET_INSTANCE_INFO_A=JET_INSTANCE_INFO_A -_JET_INSTANCE_INFO_W=JET_INSTANCE_INFO_W -_L2_NOTIFICATION_DATA=L2_NOTIFICATION_DATA -_EAP_TYPE=EAP_TYPE -_EAP_METHOD_TYPE=EAP_METHOD_TYPE -_EAP_METHOD_INFO=EAP_METHOD_INFO -_EAP_METHOD_INFO_EX=EAP_METHOD_INFO_EX -_EAP_METHOD_INFO_ARRAY=EAP_METHOD_INFO_ARRAY -_EAP_METHOD_INFO_ARRAY_EX=EAP_METHOD_INFO_ARRAY_EX -_EAP_ERROR=EAP_ERROR -_EAP_ATTRIBUTE_TYPE=EAP_ATTRIBUTE_TYPE -_EAP_ATTRIBUTE=EAP_ATTRIBUTE -_EAP_ATTRIBUTES=EAP_ATTRIBUTES -_EAP_CONFIG_INPUT_FIELD_TYPE=EAP_CONFIG_INPUT_FIELD_TYPE -_EAP_CONFIG_INPUT_FIELD_DATA=EAP_CONFIG_INPUT_FIELD_DATA -_EAP_CONFIG_INPUT_FIELD_ARRAY=EAP_CONFIG_INPUT_FIELD_ARRAY -_EAP_INTERACTIVE_UI_DATA_TYPE=EAP_INTERACTIVE_UI_DATA_TYPE -_EAP_CRED_EXPIRY_REQ=EAP_CRED_EXPIRY_REQ -_EAP_INTERACTIVE_UI_DATA=EAP_INTERACTIVE_UI_DATA -_EAP_METHOD_PROPERTY_TYPE=EAP_METHOD_PROPERTY_TYPE -_EAP_METHOD_PROPERTY_VALUE_TYPE=EAP_METHOD_PROPERTY_VALUE_TYPE -_EAP_METHOD_PROPERTY_VALUE_BOOL=EAP_METHOD_PROPERTY_VALUE_BOOL -_EAP_METHOD_PROPERTY_VALUE_DWORD=EAP_METHOD_PROPERTY_VALUE_DWORD -_EAP_METHOD_PROPERTY_VALUE_STRING=EAP_METHOD_PROPERTY_VALUE_STRING -_EAP_METHOD_PROPERTY_VALUE=EAP_METHOD_PROPERTY_VALUE -_EAP_METHOD_PROPERTY=EAP_METHOD_PROPERTY -_EAP_METHOD_PROPERTY_ARRAY=EAP_METHOD_PROPERTY_ARRAY -_EAPHOST_IDENTITY_UI_PARAMS=EAPHOST_IDENTITY_UI_PARAMS -_EAPHOST_INTERACTIVE_UI_PARAMS=EAPHOST_INTERACTIVE_UI_PARAMS -_EapCredentialType=EapCredentialType -_EapUsernamePasswordCredential=EapUsernamePasswordCredential -_EapCertificateCredential=EapCertificateCredential -_EapSimCredential=EapSimCredential -_EapCredential=EapCredential -_WLAN_PROFILE_INFO=WLAN_PROFILE_INFO -_DOT11_NETWORK=DOT11_NETWORK -_WLAN_RAW_DATA=WLAN_RAW_DATA -_WLAN_RAW_DATA_LIST=WLAN_RAW_DATA_LIST -_WLAN_CONNECTION_MODE=WLAN_CONNECTION_MODE -_WLAN_RATE_SET=WLAN_RATE_SET -_WLAN_AVAILABLE_NETWORK=WLAN_AVAILABLE_NETWORK -_WLAN_AVAILABLE_NETWORK_V2=WLAN_AVAILABLE_NETWORK_V2 -_WLAN_BSS_ENTRY=WLAN_BSS_ENTRY -_WLAN_BSS_LIST=WLAN_BSS_LIST -_WLAN_INTERFACE_STATE=WLAN_INTERFACE_STATE -_WLAN_ADHOC_NETWORK_STATE=WLAN_ADHOC_NETWORK_STATE -_WLAN_INTERFACE_INFO=WLAN_INTERFACE_INFO -_WLAN_ASSOCIATION_ATTRIBUTES=WLAN_ASSOCIATION_ATTRIBUTES -_WLAN_SECURITY_ATTRIBUTES=WLAN_SECURITY_ATTRIBUTES -_WLAN_CONNECTION_ATTRIBUTES=WLAN_CONNECTION_ATTRIBUTES -_DOT11_RADIO_STATE=DOT11_RADIO_STATE -_WLAN_PHY_RADIO_STATE=WLAN_PHY_RADIO_STATE -_WLAN_RADIO_STATE=WLAN_RADIO_STATE -_WLAN_OPERATIONAL_STATE=WLAN_OPERATIONAL_STATE -_WLAN_INTERFACE_TYPE=WLAN_INTERFACE_TYPE -_WLAN_INTERFACE_CAPABILITY=WLAN_INTERFACE_CAPABILITY -_WLAN_AUTH_CIPHER_PAIR_LIST=WLAN_AUTH_CIPHER_PAIR_LIST -_WLAN_COUNTRY_OR_REGION_STRING_LIST=WLAN_COUNTRY_OR_REGION_STRING_LIST -_WLAN_PROFILE_INFO_LIST=WLAN_PROFILE_INFO_LIST -_WLAN_AVAILABLE_NETWORK_LIST=WLAN_AVAILABLE_NETWORK_LIST -_WLAN_AVAILABLE_NETWORK_LIST_V2=WLAN_AVAILABLE_NETWORK_LIST_V2 -_WLAN_INTERFACE_INFO_LIST=WLAN_INTERFACE_INFO_LIST -_DOT11_NETWORK_LIST=DOT11_NETWORK_LIST -_WLAN_POWER_SETTING=WLAN_POWER_SETTING -_WLAN_CONNECTION_PARAMETERS=WLAN_CONNECTION_PARAMETERS -_WLAN_CONNECTION_PARAMETERS_V2=WLAN_CONNECTION_PARAMETERS_V2 -_WLAN_MSM_NOTIFICATION_DATA=WLAN_MSM_NOTIFICATION_DATA -_WLAN_CONNECTION_NOTIFICATION_DATA=WLAN_CONNECTION_NOTIFICATION_DATA -_WLAN_DEVICE_SERVICE_NOTIFICATION_DATA=WLAN_DEVICE_SERVICE_NOTIFICATION_DATA -_WLAN_NOTIFICATION_ACM=WLAN_NOTIFICATION_ACM -_WLAN_NOTIFICATION_MSM=WLAN_NOTIFICATION_MSM -_WLAN_NOTIFICATION_SECURITY=WLAN_NOTIFICATION_SECURITY -_WLAN_OPCODE_VALUE_TYPE=WLAN_OPCODE_VALUE_TYPE -_WLAN_INTF_OPCODE=WLAN_INTF_OPCODE -_WLAN_AUTOCONF_OPCODE=WLAN_AUTOCONF_OPCODE -_WLAN_IHV_CONTROL_TYPE=WLAN_IHV_CONTROL_TYPE -_WLAN_FILTER_LIST_TYPE=WLAN_FILTER_LIST_TYPE -_WLAN_SECURABLE_OBJECT=WLAN_SECURABLE_OBJECT -_WLAN_DEVICE_SERVICE_GUID_LIST=WLAN_DEVICE_SERVICE_GUID_LIST -_WFD_ROLE_TYPE=WFD_ROLE_TYPE -_WFD_GROUP_ID=WFD_GROUP_ID -_WL_DISPLAY_PAGES=WL_DISPLAY_PAGES -_WLAN_HOSTED_NETWORK_STATE=WLAN_HOSTED_NETWORK_STATE -_WLAN_HOSTED_NETWORK_REASON=WLAN_HOSTED_NETWORK_REASON -_WLAN_HOSTED_NETWORK_PEER_AUTH_STATE=WLAN_HOSTED_NETWORK_PEER_AUTH_STATE -_WLAN_HOSTED_NETWORK_PEER_STATE=WLAN_HOSTED_NETWORK_PEER_STATE -_WLAN_HOSTED_NETWORK_RADIO_STATE=WLAN_HOSTED_NETWORK_RADIO_STATE -_WLAN_HOSTED_NETWORK_NOTIFICATION_CODE=WLAN_HOSTED_NETWORK_NOTIFICATION_CODE -_WLAN_HOSTED_NETWORK_STATE_CHANGE=WLAN_HOSTED_NETWORK_STATE_CHANGE -_WLAN_HOSTED_NETWORK_DATA_PEER_STATE_CHANGE=WLAN_HOSTED_NETWORK_DATA_PEER_STATE_CHANGE -_WLAN_HOSTED_NETWORK_OPCODE=WLAN_HOSTED_NETWORK_OPCODE -_WLAN_HOSTED_NETWORK_CONNECTION_SETTINGS=WLAN_HOSTED_NETWORK_CONNECTION_SETTINGS -_WLAN_HOSTED_NETWORK_SECURITY_SETTINGS=WLAN_HOSTED_NETWORK_SECURITY_SETTINGS -_WLAN_HOSTED_NETWORK_STATUS=WLAN_HOSTED_NETWORK_STATUS -_PROPERTY_UNITS=PROPERTY_UNITS -_PROPERTY_METRICS=PROPERTY_METRICS -_PACKET_PROPERTY=PACKET_PROPERTY -_PACKET_DESCRIPTION=PACKET_DESCRIPTION -_DMO_OUTPUT_DATA_BUFFER=DMO_OUTPUT_DATA_BUFFER -_MF_ATTRIBUTE_TYPE=MF_ATTRIBUTE_TYPE -_MF_ATTRIBUTES_MATCH_TYPE=MF_ATTRIBUTES_MATCH_TYPE -_MF2DBuffer_LockFlags=MF2DBuffer_LockFlags -_MFVideoInterlaceMode=MFVideoInterlaceMode -_MFVideoTransferFunction=MFVideoTransferFunction -_MFVideoPrimaries=MFVideoPrimaries -_MFVideoLighting=MFVideoLighting -_MFVideoTransferMatrix=MFVideoTransferMatrix -_MFVideoChromaSubsampling=MFVideoChromaSubsampling -_MFNominalRange=MFNominalRange -_MFVideoFlags=MFVideoFlags -_MFRatio=MFRatio -_MFOffset=MFOffset -_MFVideoArea=MFVideoArea -_MFVideoInfo=MFVideoInfo -_MFARGB=MFARGB -_MFPaletteEntry=MFPaletteEntry -_MFVideoSurfaceInfo=MFVideoSurfaceInfo -_MFVideoCompressedInfo=MFVideoCompressedInfo -_MFVIDEOFORMAT=MFVIDEOFORMAT -_MFStandardVideoFormat=MFStandardVideoFormat -_MFBYTESTREAM_SEEK_ORIGIN=MFBYTESTREAM_SEEK_ORIGIN -_MF_Plugin_Type=MF_Plugin_Type -_MF_STREAM_STATE=MF_STREAM_STATE -_MFT_MESSAGE_TYPE=MFT_MESSAGE_TYPE -_MFT_INPUT_STREAM_INFO=MFT_INPUT_STREAM_INFO -_MFT_OUTPUT_STREAM_INFO=MFT_OUTPUT_STREAM_INFO -_MFT_OUTPUT_DATA_BUFFER=MFT_OUTPUT_DATA_BUFFER -_DeviceStreamState=DeviceStreamState -_STREAM_MEDIUM=STREAM_MEDIUM -_MF3DVideoOutputType=MF3DVideoOutputType -_MFT_STREAM_STATE_PARAM=MFT_STREAM_STATE_PARAM -_MF_CONNECT_METHOD=MF_CONNECT_METHOD -_MF_TOPOLOGY_RESOLUTION_STATUS_FLAGS=MF_TOPOLOGY_RESOLUTION_STATUS_FLAGS -_MFMEDIASOURCE_CHARACTERISTICS=MFMEDIASOURCE_CHARACTERISTICS -_MFSTREAMSINK_MARKER_TYPE=MFSTREAMSINK_MARKER_TYPE -_MF_VIDEO_PROCESSOR_ROTATION=MF_VIDEO_PROCESSOR_ROTATION -_MF_VIDEO_PROCESSOR_MIRROR=MF_VIDEO_PROCESSOR_MIRROR -_MFVideoSphericalFormat=MFVideoSphericalFormat -_MF_TOPONODE_FLUSH_MODE=MF_TOPONODE_FLUSH_MODE -_MF_TOPONODE_DRAIN_MODE=MF_TOPONODE_DRAIN_MODE -_MFCLOCK_CHARACTERISTICS_FLAGS=MFCLOCK_CHARACTERISTICS_FLAGS -_MFCLOCK_STATE=MFCLOCK_STATE -_MFCLOCK_RELATIONAL_FLAGS=MFCLOCK_RELATIONAL_FLAGS -_MFCLOCK_PROPERTIES=MFCLOCK_PROPERTIES -_MFSHUTDOWN_STATUS=MFSHUTDOWN_STATUS -_MFRR_COMPONENT_HASH_INFO=MFRR_COMPONENT_HASH_INFO -_MFRR_COMPONENTS=MFRR_COMPONENTS -_MFRATE_DIRECTION=MFRATE_DIRECTION -_MF_QUALITY_DROP_MODE=MF_QUALITY_DROP_MODE -_MF_QUALITY_LEVEL=MF_QUALITY_LEVEL -_MF_QUALITY_ADVISE_FLAGS=MF_QUALITY_ADVISE_FLAGS -_MFSequencerTopologyFlags=MFSequencerTopologyFlags -_MFTOPONODE_ATTRIBUTE_UPDATE=MFTOPONODE_ATTRIBUTE_UPDATE -_MF_LEAKY_BUCKET_PAIR=MF_LEAKY_BUCKET_PAIR -_MFBYTESTREAM_BUFFERING_PARAMS=MFBYTESTREAM_BUFFERING_PARAMS -_MFNetCredentialManagerGetParam=MFNetCredentialManagerGetParam -_MFNetCredentialRequirements=MFNetCredentialRequirements -_MFNetCredentialOptions=MFNetCredentialOptions -_MFNetAuthenticationFlags=MFNetAuthenticationFlags -_MFNETSOURCE_PROTOCOL_TYPE=MFNETSOURCE_PROTOCOL_TYPE -_MFNETSOURCE_TRANSPORT_TYPE=MFNETSOURCE_TRANSPORT_TYPE -_MFNETSOURCE_CACHE_STATE=MFNETSOURCE_CACHE_STATE -_MFNETSOURCE_STATISTICS_IDS=MFNETSOURCE_STATISTICS_IDS -_MFNET_PROXYSETTINGS=MFNET_PROXYSETTINGS -_MFPOLICYMANAGER_ACTION=MFPOLICYMANAGER_ACTION -_MFINPUTTRUSTAUTHORITY_ACCESS_PARAMS=MFINPUTTRUSTAUTHORITY_ACCESS_PARAMS -_MF_OPM_CGMSA_PROTECTION_LEVEL=MF_OPM_CGMSA_PROTECTION_LEVEL -_MF_OPM_ACP_PROTECTION_LEVEL=MF_OPM_ACP_PROTECTION_LEVEL -_MFAudioConstriction=MFAudioConstriction -_MF_TRANSCODE_TOPOLOGYMODE_FLAGS=MF_TRANSCODE_TOPOLOGYMODE_FLAGS -_MF_TRANSCODE_ADJUST_PROFILE_FLAGS=MF_TRANSCODE_ADJUST_PROFILE_FLAGS -_MF_VIDEO_PROCESSOR_ALGORITHM_TYPE=MF_VIDEO_PROCESSOR_ALGORITHM_TYPE -_MF_TRANSCODE_SINK_INFO=MF_TRANSCODE_SINK_INFO -_MFT_REGISTRATION_INFO=MFT_REGISTRATION_INFO -_MFCONTENTPROTECTIONDEVICE_INPUT_DATA=MFCONTENTPROTECTIONDEVICE_INPUT_DATA -_MFCONTENTPROTECTIONDEVICE_OUTPUT_DATA=MFCONTENTPROTECTIONDEVICE_OUTPUT_DATA -_MFCONTENTPROTECTIONDEVICE_REALTIMECLIENT_DATA=MFCONTENTPROTECTIONDEVICE_REALTIMECLIENT_DATA -_MF_CROSS_ORIGIN_POLICY=MF_CROSS_ORIGIN_POLICY -_MF_VIDEO_SPHERICAL_VIEWDIRECTION=MF_VIDEO_SPHERICAL_VIEWDIRECTION -_MFCameraIntrinsic_CameraModel=MFCameraIntrinsic_CameraModel -_MFCameraIntrinsic_DistortionModel6KT=MFCameraIntrinsic_DistortionModel6KT -_MFCameraIntrinsic_DistortionModelArcTan=MFCameraIntrinsic_DistortionModelArcTan -_MFCameraIntrinsic_DistortionModelType=MFCameraIntrinsic_DistortionModelType -_MFExtendedCameraIntrinsic_IntrinsicModel=MFExtendedCameraIntrinsic_IntrinsicModel -_ASF_INDEX_IDENTIFIER=ASF_INDEX_IDENTIFIER -_ASF_INDEX_DESCRIPTOR=ASF_INDEX_DESCRIPTOR -_MFSINK_WMDRMACTION=MFSINK_WMDRMACTION -_AVRT_PRIORITY=AVRT_PRIORITY -_MFSampleEncryptionProtectionScheme=MFSampleEncryptionProtectionScheme -_MOVE_RECT=MOVE_RECT -_DIRTYRECT_INFO=DIRTYRECT_INFO -_MOVEREGION_INFO=MOVEREGION_INFO -_ROI_AREA=ROI_AREA -_MACROBLOCK_DATA=MACROBLOCK_DATA -_MFFrameSourceTypes=MFFrameSourceTypes -_MFVideo3DFormat=MFVideo3DFormat -_MFVideo3DSampleFormat=MFVideo3DSampleFormat -_MFVideoRotationFormat=MFVideoRotationFormat -_MFDepthMeasurement=MFDepthMeasurement -_MF_CUSTOM_DECODE_UNIT_TYPE=MF_CUSTOM_DECODE_UNIT_TYPE -_MFFOLDDOWN_MATRIX=MFFOLDDOWN_MATRIX -_MFVideoDRMFlags=MFVideoDRMFlags -_MFVideoPadFlags=MFVideoPadFlags -_MFVideoSrcContentHintFlags=MFVideoSrcContentHintFlags -_MT_CUSTOM_VIDEO_PRIMARIES=MT_CUSTOM_VIDEO_PRIMARIES -_MT_ARBITRARY_HEADER=MT_ARBITRARY_HEADER -_MF_FLOAT2=MF_FLOAT2 -_MF_FLOAT3=MF_FLOAT3 -_MF_QUATERNION=MF_QUATERNION -_MFCameraExtrinsic_CalibratedTransform=MFCameraExtrinsic_CalibratedTransform -_MFCameraExtrinsics=MFCameraExtrinsics -_MFCameraIntrinsic_PinholeCameraModel=MFCameraIntrinsic_PinholeCameraModel -_MFCameraIntrinsic_DistortionModel=MFCameraIntrinsic_DistortionModel -_MFPinholeCameraIntrinsic_IntrinsicModel=MFPinholeCameraIntrinsic_IntrinsicModel -_MFPinholeCameraIntrinsics=MFPinholeCameraIntrinsics -_MFWaveFormatExConvertFlags=MFWaveFormatExConvertFlags -_EAllocationType=EAllocationType -_MF_SINK_WRITER_STATISTICS=MF_SINK_WRITER_STATISTICS -_OPTPARAM=OPTPARAM -_OPTCOMBO=OPTCOMBO -_OPTTYPE=OPTTYPE -_EXTPUSH=EXTPUSH -_EXTCHKBOX=EXTCHKBOX -_OIEXT=OIEXT -_OPTITEM=OPTITEM -_CPSUICBPARAM=CPSUICBPARAM -_DLGPAGE=DLGPAGE -_COMPROPSHEETUI=COMPROPSHEETUI -_SETRESULT_INFO=SETRESULT_INFO -_INSERTPSUIPAGE_INFO=INSERTPSUIPAGE_INFO -_PSPINFO=PSPINFO -_CPSUIDATABLOCK=CPSUIDATABLOCK -_PROPSHEETUI_INFO=PROPSHEETUI_INFO -_PROPSHEETUI_GETICON_INFO=PROPSHEETUI_GETICON_INFO -_PROPSHEETUI_INFO_HEADER=PROPSHEETUI_INFO_HEADER -_DEVICEPROPERTYHEADER=DEVICEPROPERTYHEADER -_DOCUMENTPROPERTYHEADER=DOCUMENTPROPERTYHEADER -_DEVQUERYPRINT_INFO=DEVQUERYPRINT_INFO -_DRIVER_UPGRADE_INFO_1=DRIVER_UPGRADE_INFO_1 -_DRIVER_UPGRADE_INFO_2=DRIVER_UPGRADE_INFO_2 -_DOCEVENT_FILTER=DOCEVENT_FILTER -_DOCEVENT_CREATEDCPRE=DOCEVENT_CREATEDCPRE -_DOCEVENT_ESCAPE=DOCEVENT_ESCAPE -_PRINTER_EVENT_ATTRIBUTES_INFO=PRINTER_EVENT_ATTRIBUTES_INFO -_ATTRIBUTE_INFO_1=ATTRIBUTE_INFO_1 -_ATTRIBUTE_INFO_2=ATTRIBUTE_INFO_2 -_ATTRIBUTE_INFO_3=ATTRIBUTE_INFO_3 -_ATTRIBUTE_INFO_4=ATTRIBUTE_INFO_4 -_PSCRIPT5_PRIVATE_DEVMODE=PSCRIPT5_PRIVATE_DEVMODE -_UNIDRV_PRIVATE_DEVMODE=UNIDRV_PRIVATE_DEVMODE -_PUBLISHERINFO=PUBLISHERINFO -_OEMDMPARAM=OEMDMPARAM -_OEM_DMEXTRAHEADER=OEM_DMEXTRAHEADER -_USERDATA=USERDATA -_SIMULATE_CAPS_1=SIMULATE_CAPS_1 -_OEMUIPROCS=OEMUIPROCS -_OEMUIOBJ=OEMUIOBJ -_OEMCUIPPARAM=OEMCUIPPARAM -_OEMUIPSPARAM=OEMUIPSPARAM -_EATTRIBUTE_DATATYPE=EATTRIBUTE_DATATYPE -_CUSTOMSIZEPARAM=CUSTOMSIZEPARAM -_LOADED_IMAGE=LOADED_IMAGE -_IMAGE_DEBUG_INFORMATION=IMAGE_DEBUG_INFORMATION -_MODLOAD_DATA=MODLOAD_DATA -_MODLOAD_CVMISC=MODLOAD_CVMISC -_MODLOAD_PDBGUID_PDBAGE=MODLOAD_PDBGUID_PDBAGE -_KDHELP64=KDHELP64 -_KDHELP=KDHELP -_IMAGEHLP_SYMBOL64=IMAGEHLP_SYMBOL64 -_IMAGEHLP_SYMBOL64_PACKAGE=IMAGEHLP_SYMBOL64_PACKAGE -_IMAGEHLP_SYMBOLW64=IMAGEHLP_SYMBOLW64 -_IMAGEHLP_SYMBOLW64_PACKAGE=IMAGEHLP_SYMBOLW64_PACKAGE -_IMAGEHLP_SYMBOL=IMAGEHLP_SYMBOL -_IMAGEHLP_SYMBOL_PACKAGE=IMAGEHLP_SYMBOL_PACKAGE -_IMAGEHLP_SYMBOLW=IMAGEHLP_SYMBOLW -_IMAGEHLP_SYMBOLW_PACKAGE=IMAGEHLP_SYMBOLW_PACKAGE -_IMAGEHLP_MODULE64=IMAGEHLP_MODULE64 -_IMAGEHLP_MODULEW64=IMAGEHLP_MODULEW64 -_IMAGEHLP_MODULE=IMAGEHLP_MODULE -_IMAGEHLP_MODULEW=IMAGEHLP_MODULEW -_IMAGEHLP_LINE64=IMAGEHLP_LINE64 -_IMAGEHLP_LINEW64=IMAGEHLP_LINEW64 -_IMAGEHLP_LINE=IMAGEHLP_LINE -_IMAGEHLP_LINEW=IMAGEHLP_LINEW -_SOURCEFILE=SOURCEFILE -_SOURCEFILEW=SOURCEFILEW -_IMAGEHLP_CBA_READ_MEMORY=IMAGEHLP_CBA_READ_MEMORY -_IMAGEHLP_CBA_EVENT=IMAGEHLP_CBA_EVENT -_IMAGEHLP_CBA_EVENTW=IMAGEHLP_CBA_EVENTW -_IMAGEHLP_DEFERRED_SYMBOL_LOAD64=IMAGEHLP_DEFERRED_SYMBOL_LOAD64 -_IMAGEHLP_DEFERRED_SYMBOL_LOADW64=IMAGEHLP_DEFERRED_SYMBOL_LOADW64 -_IMAGEHLP_DEFERRED_SYMBOL_LOAD=IMAGEHLP_DEFERRED_SYMBOL_LOAD -_IMAGEHLP_DUPLICATE_SYMBOL64=IMAGEHLP_DUPLICATE_SYMBOL64 -_IMAGEHLP_DUPLICATE_SYMBOL=IMAGEHLP_DUPLICATE_SYMBOL -_OMAP=OMAP -_SRCCODEINFO=SRCCODEINFO -_SRCCODEINFOW=SRCCODEINFOW -_IMAGEHLP_SYMBOL_SRC=IMAGEHLP_SYMBOL_SRC -_MODULE_TYPE_INFO=MODULE_TYPE_INFO -_SYMBOL_INFO=SYMBOL_INFO -_SYMBOL_INFO_PACKAGE=SYMBOL_INFO_PACKAGE -_SYMBOL_INFOW=SYMBOL_INFOW -_SYMBOL_INFO_PACKAGEW=SYMBOL_INFO_PACKAGEW -_IMAGEHLP_STACK_FRAME=IMAGEHLP_STACK_FRAME -_IMAGEHLP_SYMBOL_TYPE_INFO=IMAGEHLP_SYMBOL_TYPE_INFO -_TI_FINDCHILDREN_PARAMS=TI_FINDCHILDREN_PARAMS -_IMAGEHLP_GET_TYPE_INFO_PARAMS=IMAGEHLP_GET_TYPE_INFO_PARAMS -_MINIDUMP_LOCATION_DESCRIPTOR=MINIDUMP_LOCATION_DESCRIPTOR -_MINIDUMP_LOCATION_DESCRIPTOR64=MINIDUMP_LOCATION_DESCRIPTOR64 -_MINIDUMP_MEMORY_DESCRIPTOR=MINIDUMP_MEMORY_DESCRIPTOR -_MINIDUMP_MEMORY_DESCRIPTOR64=MINIDUMP_MEMORY_DESCRIPTOR64 -_MINIDUMP_HEADER=MINIDUMP_HEADER -_MINIDUMP_DIRECTORY=MINIDUMP_DIRECTORY -_MINIDUMP_STRING=MINIDUMP_STRING -_MINIDUMP_STREAM_TYPE=MINIDUMP_STREAM_TYPE -_CPU_INFORMATION=CPU_INFORMATION -_MINIDUMP_SYSTEM_INFO=MINIDUMP_SYSTEM_INFO -_MINIDUMP_THREAD=MINIDUMP_THREAD -_MINIDUMP_THREAD_LIST=MINIDUMP_THREAD_LIST -_MINIDUMP_THREAD_EX=MINIDUMP_THREAD_EX -_MINIDUMP_THREAD_EX_LIST=MINIDUMP_THREAD_EX_LIST -_MINIDUMP_EXCEPTION=MINIDUMP_EXCEPTION -_MINIDUMP_MODULE=MINIDUMP_MODULE -_MINIDUMP_MODULE_LIST=MINIDUMP_MODULE_LIST -_MINIDUMP_MEMORY_LIST=MINIDUMP_MEMORY_LIST -_MINIDUMP_MEMORY64_LIST=MINIDUMP_MEMORY64_LIST -_MINIDUMP_EXCEPTION_INFORMATION=MINIDUMP_EXCEPTION_INFORMATION -_MINIDUMP_EXCEPTION_INFORMATION64=MINIDUMP_EXCEPTION_INFORMATION64 -_MINIDUMP_HANDLE_OBJECT_INFORMATION_TYPE=MINIDUMP_HANDLE_OBJECT_INFORMATION_TYPE -_MINIDUMP_HANDLE_OBJECT_INFORMATION=MINIDUMP_HANDLE_OBJECT_INFORMATION -_MINIDUMP_HANDLE_DESCRIPTOR=MINIDUMP_HANDLE_DESCRIPTOR -_MINIDUMP_HANDLE_DESCRIPTOR_2=MINIDUMP_HANDLE_DESCRIPTOR_2 -_MINIDUMP_HANDLE_DATA_STREAM=MINIDUMP_HANDLE_DATA_STREAM -_MINIDUMP_HANDLE_OPERATION_LIST=MINIDUMP_HANDLE_OPERATION_LIST -_MINIDUMP_FUNCTION_TABLE_DESCRIPTOR=MINIDUMP_FUNCTION_TABLE_DESCRIPTOR -_MINIDUMP_FUNCTION_TABLE_STREAM=MINIDUMP_FUNCTION_TABLE_STREAM -_MINIDUMP_UNLOADED_MODULE=MINIDUMP_UNLOADED_MODULE -_MINIDUMP_UNLOADED_MODULE_LIST=MINIDUMP_UNLOADED_MODULE_LIST -_XSTATE_CONFIG_FEATURE_MSC_INFO=XSTATE_CONFIG_FEATURE_MSC_INFO -_MINIDUMP_MISC_INFO=MINIDUMP_MISC_INFO -_MINIDUMP_MISC_INFO_2=MINIDUMP_MISC_INFO_2 -_MINIDUMP_MISC_INFO_3=MINIDUMP_MISC_INFO_3 -_MINIDUMP_MISC_INFO_4=MINIDUMP_MISC_INFO_4 -_MINIDUMP_MISC_INFO_5=MINIDUMP_MISC_INFO_5 -_MINIDUMP_MEMORY_INFO=MINIDUMP_MEMORY_INFO -_MINIDUMP_MEMORY_INFO_LIST=MINIDUMP_MEMORY_INFO_LIST -_MINIDUMP_THREAD_NAME=MINIDUMP_THREAD_NAME -_MINIDUMP_THREAD_NAME_LIST=MINIDUMP_THREAD_NAME_LIST -_MINIDUMP_THREAD_INFO=MINIDUMP_THREAD_INFO -_MINIDUMP_THREAD_INFO_LIST=MINIDUMP_THREAD_INFO_LIST -_MINIDUMP_TOKEN_INFO_HEADER=MINIDUMP_TOKEN_INFO_HEADER -_MINIDUMP_TOKEN_INFO_LIST=MINIDUMP_TOKEN_INFO_LIST -_MINIDUMP_SYSTEM_BASIC_INFORMATION=MINIDUMP_SYSTEM_BASIC_INFORMATION -_MINIDUMP_SYSTEM_FILECACHE_INFORMATION=MINIDUMP_SYSTEM_FILECACHE_INFORMATION -_MINIDUMP_SYSTEM_BASIC_PERFORMANCE_INFORMATION=MINIDUMP_SYSTEM_BASIC_PERFORMANCE_INFORMATION -_MINIDUMP_SYSTEM_PERFORMANCE_INFORMATION=MINIDUMP_SYSTEM_PERFORMANCE_INFORMATION -_MINIDUMP_SYSTEM_MEMORY_INFO_1=MINIDUMP_SYSTEM_MEMORY_INFO_1 -_MINIDUMP_PROCESS_VM_COUNTERS_1=MINIDUMP_PROCESS_VM_COUNTERS_1 -_MINIDUMP_PROCESS_VM_COUNTERS_2=MINIDUMP_PROCESS_VM_COUNTERS_2 -_MINIDUMP_USER_RECORD=MINIDUMP_USER_RECORD -_MINIDUMP_USER_STREAM=MINIDUMP_USER_STREAM -_MINIDUMP_USER_STREAM_INFORMATION=MINIDUMP_USER_STREAM_INFORMATION -_MINIDUMP_CALLBACK_TYPE=MINIDUMP_CALLBACK_TYPE -_MINIDUMP_THREAD_CALLBACK=MINIDUMP_THREAD_CALLBACK -_MINIDUMP_THREAD_EX_CALLBACK=MINIDUMP_THREAD_EX_CALLBACK -_MINIDUMP_INCLUDE_THREAD_CALLBACK=MINIDUMP_INCLUDE_THREAD_CALLBACK -_THREAD_WRITE_FLAGS=THREAD_WRITE_FLAGS -_MINIDUMP_MODULE_CALLBACK=MINIDUMP_MODULE_CALLBACK -_MINIDUMP_INCLUDE_MODULE_CALLBACK=MINIDUMP_INCLUDE_MODULE_CALLBACK -_MODULE_WRITE_FLAGS=MODULE_WRITE_FLAGS -_MINIDUMP_IO_CALLBACK=MINIDUMP_IO_CALLBACK -_MINIDUMP_READ_MEMORY_FAILURE_CALLBACK=MINIDUMP_READ_MEMORY_FAILURE_CALLBACK -_MINIDUMP_VM_QUERY_CALLBACK=MINIDUMP_VM_QUERY_CALLBACK -_MINIDUMP_VM_PRE_READ_CALLBACK=MINIDUMP_VM_PRE_READ_CALLBACK -_MINIDUMP_VM_POST_READ_CALLBACK=MINIDUMP_VM_POST_READ_CALLBACK -_MINIDUMP_CALLBACK_INPUT=MINIDUMP_CALLBACK_INPUT -_MINIDUMP_CALLBACK_OUTPUT=MINIDUMP_CALLBACK_OUTPUT -_MINIDUMP_TYPE=MINIDUMP_TYPE -_MINIDUMP_SECONDARY_FLAGS=MINIDUMP_SECONDARY_FLAGS -_MINIDUMP_CALLBACK_INFORMATION=MINIDUMP_CALLBACK_INFORMATION -_WEBAUTHN_RP_ENTITY_INFORMATION=WEBAUTHN_RP_ENTITY_INFORMATION -_WEBAUTHN_USER_ENTITY_INFORMATION=WEBAUTHN_USER_ENTITY_INFORMATION -_WEBAUTHN_CLIENT_DATA=WEBAUTHN_CLIENT_DATA -_WEBAUTHN_COSE_CREDENTIAL_PARAMETER=WEBAUTHN_COSE_CREDENTIAL_PARAMETER -_WEBAUTHN_COSE_CREDENTIAL_PARAMETERS=WEBAUTHN_COSE_CREDENTIAL_PARAMETERS -_WEBAUTHN_CREDENTIAL=WEBAUTHN_CREDENTIAL -_WEBAUTHN_CREDENTIALS=WEBAUTHN_CREDENTIALS -_WEBAUTHN_CREDENTIAL_EX=WEBAUTHN_CREDENTIAL_EX -_WEBAUTHN_CREDENTIAL_LIST=WEBAUTHN_CREDENTIAL_LIST -_WEBAUTHN_EXTENSION=WEBAUTHN_EXTENSION -_WEBAUTHN_EXTENSIONS=WEBAUTHN_EXTENSIONS -_WEBAUTHN_AUTHENTICATOR_MAKE_CREDENTIAL_OPTIONS=WEBAUTHN_AUTHENTICATOR_MAKE_CREDENTIAL_OPTIONS -_WEBAUTHN_AUTHENTICATOR_GET_ASSERTION_OPTIONS=WEBAUTHN_AUTHENTICATOR_GET_ASSERTION_OPTIONS -_WEBAUTHN_X5C=WEBAUTHN_X5C -_WEBAUTHN_COMMON_ATTESTATION=WEBAUTHN_COMMON_ATTESTATION -_WEBAUTHN_CREDENTIAL_ATTESTATION=WEBAUTHN_CREDENTIAL_ATTESTATION -_WEBAUTHN_ASSERTION=WEBAUTHN_ASSERTION -_KERNEL_CET_CONTEXT=KERNEL_CET_CONTEXT -_ARM64_NT_NEON128=ARM64_NT_NEON128 -_ARM64_NT_CONTEXT=ARM64_NT_CONTEXT _ARM64_FPCR_REG=ARM64_FPCR_REG _ARM64_FPSR_REG=ARM64_FPSR_REG _AMD64_MXCSR_REG=AMD64_MXCSR_REG -_ARM64EC_NT_CONTEXT=ARM64EC_NT_CONTEXT _DISPATCHER_CONTEXT_NONVOLREG_ARM64=DISPATCHER_CONTEXT_NONVOLREG_ARM64 _DISPATCHER_CONTEXT_ARM64=DISPATCHER_CONTEXT_ARM64 -_COMPONENT_FILTER=COMPONENT_FILTER -_PROCESS_DYNAMIC_ENFORCED_ADDRESS_RANGE=PROCESS_DYNAMIC_ENFORCED_ADDRESS_RANGE -_PROCESS_DYNAMIC_ENFORCED_ADDRESS_RANGES_INFORMATION=PROCESS_DYNAMIC_ENFORCED_ADDRESS_RANGES_INFORMATION -_PROCESS_MITIGATION_REDIRECTION_TRUST_POLICY=PROCESS_MITIGATION_REDIRECTION_TRUST_POLICY -_SYSTEM_POOL_ZEROING_INFORMATION=SYSTEM_POOL_ZEROING_INFORMATION -_MEM_DEDICATED_ATTRIBUTE_TYPE=MEM_DEDICATED_ATTRIBUTE_TYPE -_QUEUE_USER_APC_FLAGS=QUEUE_USER_APC_FLAGS -_STORAGE_PROTOCOL_DATA_SUBVALUE_GET_LOG_PAGE=STORAGE_PROTOCOL_DATA_SUBVALUE_GET_LOG_PAGE -_STORAGE_DEVICE_LED_STATE_DESCRIPTOR=STORAGE_DEVICE_LED_STATE_DESCRIPTOR -_STORAGE_DEVICE_SELF_ENCRYPTION_PROPERTY=STORAGE_DEVICE_SELF_ENCRYPTION_PROPERTY -_STORAGE_FRU_ID_DESCRIPTOR=STORAGE_FRU_ID_DESCRIPTOR -_DEVICE_INTERNAL_STATUS_DATA_REQUEST_TYPE=DEVICE_INTERNAL_STATUS_DATA_REQUEST_TYPE -_DEVICE_INTERNAL_STATUS_DATA_SET=DEVICE_INTERNAL_STATUS_DATA_SET -_GET_DEVICE_INTERNAL_STATUS_DATA_REQUEST=GET_DEVICE_INTERNAL_STATUS_DATA_REQUEST -_DEVICE_INTERNAL_STATUS_DATA=DEVICE_INTERNAL_STATUS_DATA -_STORAGE_SANITIZE_METHOD=STORAGE_SANITIZE_METHOD -_STORAGE_REINITIALIZE_MEDIA=STORAGE_REINITIALIZE_MEDIA -_SCM_BUS_QUERY_TYPE=SCM_BUS_QUERY_TYPE -_SCM_BUS_SET_TYPE=SCM_BUS_SET_TYPE -_SCM_BUS_PROPERTY_ID=SCM_BUS_PROPERTY_ID -_SCM_BUS_PROPERTY_QUERY=SCM_BUS_PROPERTY_QUERY -_SCM_BUS_FIRMWARE_ACTIVATION_STATE=SCM_BUS_FIRMWARE_ACTIVATION_STATE -_SCM_BUS_RUNTIME_FW_ACTIVATION_INFO=SCM_BUS_RUNTIME_FW_ACTIVATION_INFO _SCM_BUS_SPECIAL_PURPOSE_DEVICE_INFO=SCM_BUS_SPECIAL_PURPOSE_DEVICE_INFO _SCM_BUS_SPECIAL_PURPOSE_DEVICES_INFO=SCM_BUS_SPECIAL_PURPOSE_DEVICES_INFO -_SCM_BUS_PROPERTY_SET=SCM_BUS_PROPERTY_SET _SCM_BUS_SPECIAL_PURPOSE_MEMORY_STATE=SCM_BUS_SPECIAL_PURPOSE_MEMORY_STATE -_SCM_PD_SET_TYPE=SCM_PD_SET_TYPE -_SCM_PD_PROPERTY_SET=SCM_PD_PROPERTY_SET -_SCM_PD_RUNTIME_FW_ACTIVATION_ARM_STATE=SCM_PD_RUNTIME_FW_ACTIVATION_ARM_STATE -_SCM_PD_FRU_ID_STRING=SCM_PD_FRU_ID_STRING -_SCM_PD_LAST_FW_ACTIVATION_STATUS=SCM_PD_LAST_FW_ACTIVATION_STATUS -_SCM_PD_FIRMWARE_ACTIVATION_STATE=SCM_PD_FIRMWARE_ACTIVATION_STATE -_SCM_PD_RUNTIME_FW_ACTIVATION_INFO=SCM_PD_RUNTIME_FW_ACTIVATION_INFO -_MARK_HANDLE_INFO=MARK_HANDLE_INFO -_DUPLICATE_EXTENTS_STATE=DUPLICATE_EXTENTS_STATE -_ASYNC_DUPLICATE_EXTENTS_STATUS=ASYNC_DUPLICATE_EXTENTS_STATUS -_SMB_SHARE_FLUSH_AND_PURGE_INPUT=SMB_SHARE_FLUSH_AND_PURGE_INPUT -_SMB_SHARE_FLUSH_AND_PURGE_OUTPUT=SMB_SHARE_FLUSH_AND_PURGE_OUTPUT -_THREAD_NAME_INFORMATION=THREAD_NAME_INFORMATION -_KERB_REFRESH_POLICY_REQUEST=KERB_REFRESH_POLICY_REQUEST -_KERB_REFRESH_POLICY_RESPONSE=KERB_REFRESH_POLICY_RESPONSE -_ETW_PMC_COUNTER_OWNER_TYPE=ETW_PMC_COUNTER_OWNER_TYPE -_ETW_PMC_COUNTER_OWNER=ETW_PMC_COUNTER_OWNER -_ETW_PMC_COUNTER_OWNERSHIP_STATUS=ETW_PMC_COUNTER_OWNERSHIP_STATUS -_TRACE_STACK_CACHING_INFO=TRACE_STACK_CACHING_INFO _SERVER_CERTIFICATE_TYPE=SERVER_CERTIFICATE_TYPE _SERVER_CERTIFICATE_INFO_0=SERVER_CERTIFICATE_INFO_0 -_USE_OPTION_DEFERRED_CONNECTION_PARAMETERS=USE_OPTION_DEFERRED_CONNECTION_PARAMETERS -_TRANSPORT_TYPE=TRANSPORT_TYPE -_TRANSPORT_INFO=TRANSPORT_INFO -_USE_OPTION_TRANSPORT_PARAMETERS=USE_OPTION_TRANSPORT_PARAMETERS -_WINHTTP_ASYNC_RESULT=WINHTTP_ASYNC_RESULT -_HTTP_VERSION_INFO=HTTP_VERSION_INFO -_WINHTTP_PROXY_INFO=WINHTTP_PROXY_INFO -_WINHTTP_AUTOPROXY_OPTIONS=WINHTTP_AUTOPROXY_OPTIONS -_WINHTTP_CERTIFICATE_INFO=WINHTTP_CERTIFICATE_INFO -_WINHTTP_EXTENDED_HEADER=WINHTTP_EXTENDED_HEADER -_WINHTTP_SECURE_DNS_SETTING=WINHTTP_SECURE_DNS_SETTING -_WINHTTP_RESOLVER_CACHE_CONFIG=WINHTTP_RESOLVER_CACHE_CONFIG -_WINHTTP_FAILED_CONNECTION_RETRIES=WINHTTP_FAILED_CONNECTION_RETRIES -_WINHTTP_CURRENT_USER_IE_PROXY_CONFIG=WINHTTP_CURRENT_USER_IE_PROXY_CONFIG -_SecPkgContext_CertificateValidationResult=SecPkgContext_CertificateValidationResult -_EVENT_EXTENDED_ITEM_STACK_KEY32=EVENT_EXTENDED_ITEM_STACK_KEY32 -_EVENT_EXTENDED_ITEM_STACK_KEY64=EVENT_EXTENDED_ITEM_STACK_KEY64 -_NL_NETWORK_CONNECTIVITY_LEVEL_HINT=NL_NETWORK_CONNECTIVITY_LEVEL_HINT -_NL_NETWORK_CONNECTIVITY_COST_HINT=NL_NETWORK_CONNECTIVITY_COST_HINT -_NL_NETWORK_CONNECTIVITY_HINT=NL_NETWORK_CONNECTIVITY_HINT -_MIB_UDPROW2=MIB_UDPROW2 -_MIB_UDPTABLE2=MIB_UDPTABLE2 -_MIB_UDP6ROW2=MIB_UDP6ROW2 -_MIB_UDP6TABLE2=MIB_UDP6TABLE2 -_DNS_SETTINGS2=DNS_SETTINGS2 -_DNS_DOH_SERVER_SETTINGS=DNS_DOH_SERVER_SETTINGS -_DNS_SERVER_PROPERTY_TYPE=DNS_SERVER_PROPERTY_TYPE -_DNS_SERVER_PROPERTY_TYPES=DNS_SERVER_PROPERTY_TYPES -_DNS_SERVER_PROPERTY=DNS_SERVER_PROPERTY -_DNS_INTERFACE_SETTINGS_EX=DNS_INTERFACE_SETTINGS_EX -_DNS_INTERFACE_SETTINGS3=DNS_INTERFACE_SETTINGS3 -_SECPKG_SURROGATE_LOGON_ENTRY=SECPKG_SURROGATE_LOGON_ENTRY -_SECPKG_SURROGATE_LOGON=SECPKG_SURROGATE_LOGON -_WEBAUTHN_CRED_PROTECT_EXTENSION_IN=WEBAUTHN_CRED_PROTECT_EXTENSION_IN -_MF_MEDIA_ENGINE_KEYERR=MF_MEDIA_ENGINE_KEYERR -_MF_HDCP_STATUS=MF_HDCP_STATUS -_D3DVECTOR=D3DVECTOR -_D3DRECT=D3DRECT -_D3DVIEWPORT9=D3DVIEWPORT9 -_D3DCLIPSTATUS9=D3DCLIPSTATUS9 -_D3DMATERIAL9=D3DMATERIAL9 -_D3DLIGHTTYPE=D3DLIGHTTYPE -_D3DLIGHT9=D3DLIGHT9 -_D3DSHADEMODE=D3DSHADEMODE -_D3DFILLMODE=D3DFILLMODE -_D3DBLEND=D3DBLEND -_D3DBLENDOP=D3DBLENDOP -_D3DTEXTUREADDRESS=D3DTEXTUREADDRESS -_D3DCULL=D3DCULL -_D3DCMPFUNC=D3DCMPFUNC -_D3DSTENCILOP=D3DSTENCILOP -_D3DFOGMODE=D3DFOGMODE -_D3DZBUFFERTYPE=D3DZBUFFERTYPE -_D3DPRIMITIVETYPE=D3DPRIMITIVETYPE -_D3DTRANSFORMSTATETYPE=D3DTRANSFORMSTATETYPE -_D3DRENDERSTATETYPE=D3DRENDERSTATETYPE -_D3DMATERIALCOLORSOURCE=D3DMATERIALCOLORSOURCE -_D3DTEXTURESTAGESTATETYPE=D3DTEXTURESTAGESTATETYPE -_D3DSAMPLERSTATETYPE=D3DSAMPLERSTATETYPE -_D3DTEXTUREOP=D3DTEXTUREOP -_D3DTEXTUREFILTERTYPE=D3DTEXTUREFILTERTYPE -_D3DDECLUSAGE=D3DDECLUSAGE -_D3DDECLMETHOD=D3DDECLMETHOD -_D3DDECLTYPE=D3DDECLTYPE -_D3DVERTEXELEMENT9=D3DVERTEXELEMENT9 -_D3DSHADER_INSTRUCTION_OPCODE_TYPE=D3DSHADER_INSTRUCTION_OPCODE_TYPE -_D3DSHADER_COMPARISON=D3DSHADER_COMPARISON -_D3DSAMPLER_TEXTURE_TYPE=D3DSAMPLER_TEXTURE_TYPE -_D3DSHADER_PARAM_REGISTER_TYPE=D3DSHADER_PARAM_REGISTER_TYPE -_D3DSHADER_MISCTYPE_OFFSETS=D3DSHADER_MISCTYPE_OFFSETS -_D3DVS_RASTOUT_OFFSETS=D3DVS_RASTOUT_OFFSETS -_D3DVS_ADDRESSMODE_TYPE=D3DVS_ADDRESSMODE_TYPE -_D3DSHADER_ADDRESSMODE_TYPE=D3DSHADER_ADDRESSMODE_TYPE -_D3DSHADER_PARAM_SRCMOD_TYPE=D3DSHADER_PARAM_SRCMOD_TYPE -_D3DSHADER_MIN_PRECISION=D3DSHADER_MIN_PRECISION -_D3DBASISTYPE=D3DBASISTYPE -_D3DDEGREETYPE=D3DDEGREETYPE -_D3DPATCHEDGESTYLE=D3DPATCHEDGESTYLE -_D3DSTATEBLOCKTYPE=D3DSTATEBLOCKTYPE -_D3DVERTEXBLENDFLAGS=D3DVERTEXBLENDFLAGS -_D3DTEXTURETRANSFORMFLAGS=D3DTEXTURETRANSFORMFLAGS -_D3DDEVTYPE=D3DDEVTYPE -_D3DMULTISAMPLE_TYPE=D3DMULTISAMPLE_TYPE -_D3DFORMAT=D3DFORMAT -_D3DDISPLAYMODE=D3DDISPLAYMODE -_D3DDEVICE_CREATION_PARAMETERS=D3DDEVICE_CREATION_PARAMETERS -_D3DSWAPEFFECT=D3DSWAPEFFECT -_D3DPOOL=D3DPOOL -_D3DGAMMARAMP=D3DGAMMARAMP -_D3DBACKBUFFER_TYPE=D3DBACKBUFFER_TYPE -_D3DRESOURCETYPE=D3DRESOURCETYPE -_D3DCUBEMAP_FACES=D3DCUBEMAP_FACES -_D3DVERTEXBUFFER_DESC=D3DVERTEXBUFFER_DESC -_D3DINDEXBUFFER_DESC=D3DINDEXBUFFER_DESC -_D3DSURFACE_DESC=D3DSURFACE_DESC -_D3DVOLUME_DESC=D3DVOLUME_DESC -_D3DLOCKED_RECT=D3DLOCKED_RECT -_D3DBOX=D3DBOX -_D3DLOCKED_BOX=D3DLOCKED_BOX -_D3DRANGE=D3DRANGE -_D3DRECTPATCH_INFO=D3DRECTPATCH_INFO -_D3DTRIPATCH_INFO=D3DTRIPATCH_INFO -_D3DADAPTER_IDENTIFIER9=D3DADAPTER_IDENTIFIER9 -_D3DRASTER_STATUS=D3DRASTER_STATUS -_D3DDEBUGMONITORTOKENS=D3DDEBUGMONITORTOKENS -_D3DQUERYTYPE=D3DQUERYTYPE -_D3DRESOURCESTATS=D3DRESOURCESTATS -_D3DDEVINFO_RESOURCEMANAGER=D3DDEVINFO_RESOURCEMANAGER -_D3DDEVINFO_D3DVERTEXSTATS=D3DDEVINFO_D3DVERTEXSTATS -_D3DDEVINFO_VCACHE=D3DDEVINFO_VCACHE -_D3DDEVINFO_D3D9PIPELINETIMINGS=D3DDEVINFO_D3D9PIPELINETIMINGS -_D3DDEVINFO_D3D9INTERFACETIMINGS=D3DDEVINFO_D3D9INTERFACETIMINGS -_D3DDEVINFO_D3D9STAGETIMINGS=D3DDEVINFO_D3D9STAGETIMINGS -_D3DDEVINFO_D3D9BANDWIDTHTIMINGS=D3DDEVINFO_D3D9BANDWIDTHTIMINGS -_D3DDEVINFO_D3D9CACHEUTILIZATION=D3DDEVINFO_D3D9CACHEUTILIZATION -_D3DMEMORYPRESSURE=D3DMEMORYPRESSURE -_D3DCOMPOSERECTSOP=D3DCOMPOSERECTSOP -_D3DCOMPOSERECTDESC=D3DCOMPOSERECTDESC -_D3DCOMPOSERECTDESTINATION=D3DCOMPOSERECTDESTINATION -_D3DPRESENTSTATS=D3DPRESENTSTATS -_D3D_OMAC=D3D_OMAC -_D3DAUTHENTICATEDCHANNELTYPE=D3DAUTHENTICATEDCHANNELTYPE -_D3DAUTHENTICATEDCHANNEL_QUERY_INPUT=D3DAUTHENTICATEDCHANNEL_QUERY_INPUT -_D3DAUTHENTICATEDCHANNEL_QUERY_OUTPUT=D3DAUTHENTICATEDCHANNEL_QUERY_OUTPUT -_D3DAUTHENTICATEDCHANNEL_PROTECTION_FLAGS=D3DAUTHENTICATEDCHANNEL_PROTECTION_FLAGS -_D3DAUTHENTICATEDCHANNEL_QUERYPROTECTION_OUTPUT=D3DAUTHENTICATEDCHANNEL_QUERYPROTECTION_OUTPUT -_D3DAUTHENTICATEDCHANNEL_QUERYCHANNELTYPE_OUTPUT=D3DAUTHENTICATEDCHANNEL_QUERYCHANNELTYPE_OUTPUT -_D3DAUTHENTICATEDCHANNEL_QUERYDEVICEHANDLE_OUTPUT=D3DAUTHENTICATEDCHANNEL_QUERYDEVICEHANDLE_OUTPUT -_D3DAUTHENTICATEDCHANNEL_QUERYCRYPTOSESSION_INPUT=D3DAUTHENTICATEDCHANNEL_QUERYCRYPTOSESSION_INPUT -_D3DAUTHENTICATEDCHANNEL_QUERYCRYPTOSESSION_OUTPUT=D3DAUTHENTICATEDCHANNEL_QUERYCRYPTOSESSION_OUTPUT -_D3DAUTHENTICATEDCHANNEL_QUERYRESTRICTEDSHAREDRESOURCEPROCESSCOUNT_OUTPUT=D3DAUTHENTICATEDCHANNEL_QUERYRESTRICTEDSHAREDRESOURCEPROCESSCOUNT_OUTPUT -_D3DAUTHENTICATEDCHANNEL_QUERYRESTRICTEDSHAREDRESOURCEPROCESS_INPUT=D3DAUTHENTICATEDCHANNEL_QUERYRESTRICTEDSHAREDRESOURCEPROCESS_INPUT -_D3DAUTHENTICATEDCHANNEL_PROCESSIDENTIFIERTYPE=D3DAUTHENTICATEDCHANNEL_PROCESSIDENTIFIERTYPE -_D3DAUTHENTICATEDCHANNEL_QUERYRESTRICTEDSHAREDRESOURCEPROCESS_OUTPUT=D3DAUTHENTICATEDCHANNEL_QUERYRESTRICTEDSHAREDRESOURCEPROCESS_OUTPUT -_D3DAUTHENTICATEDCHANNEL_QUERYUNRESTRICTEDPROTECTEDSHAREDRESOURCECOUNT_OUTPUT=D3DAUTHENTICATEDCHANNEL_QUERYUNRESTRICTEDPROTECTEDSHAREDRESOURCECOUNT_OUTPUT -_D3DAUTHENTICATEDCHANNEL_QUERYOUTPUTIDCOUNT_INPUT=D3DAUTHENTICATEDCHANNEL_QUERYOUTPUTIDCOUNT_INPUT -_D3DAUTHENTICATEDCHANNEL_QUERYOUTPUTIDCOUNT_OUTPUT=D3DAUTHENTICATEDCHANNEL_QUERYOUTPUTIDCOUNT_OUTPUT -_D3DAUTHENTICATEDCHANNEL_QUERYOUTPUTID_INPUT=D3DAUTHENTICATEDCHANNEL_QUERYOUTPUTID_INPUT -_D3DAUTHENTICATEDCHANNEL_QUERYOUTPUTID_OUTPUT=D3DAUTHENTICATEDCHANNEL_QUERYOUTPUTID_OUTPUT -_D3DBUSTYPE=D3DBUSTYPE -_D3DAUTHENTICATEDCHANNEL_QUERYINFOBUSTYPE_OUTPUT=D3DAUTHENTICATEDCHANNEL_QUERYINFOBUSTYPE_OUTPUT -_D3DAUTHENTICATEDCHANNEL_QUERYEVICTIONENCRYPTIONGUIDCOUNT_OUTPUT=D3DAUTHENTICATEDCHANNEL_QUERYEVICTIONENCRYPTIONGUIDCOUNT_OUTPUT -_D3DAUTHENTICATEDCHANNEL_QUERYEVICTIONENCRYPTIONGUID_INPUT=D3DAUTHENTICATEDCHANNEL_QUERYEVICTIONENCRYPTIONGUID_INPUT -_D3DAUTHENTICATEDCHANNEL_QUERYEVICTIONENCRYPTIONGUID_OUTPUT=D3DAUTHENTICATEDCHANNEL_QUERYEVICTIONENCRYPTIONGUID_OUTPUT -_D3DAUTHENTICATEDCHANNEL_QUERYUNCOMPRESSEDENCRYPTIONLEVEL_OUTPUT=D3DAUTHENTICATEDCHANNEL_QUERYUNCOMPRESSEDENCRYPTIONLEVEL_OUTPUT -_D3DAUTHENTICATEDCHANNEL_CONFIGURE_INPUT=D3DAUTHENTICATEDCHANNEL_CONFIGURE_INPUT -_D3DAUTHENTICATEDCHANNEL_CONFIGURE_OUTPUT=D3DAUTHENTICATEDCHANNEL_CONFIGURE_OUTPUT -_D3DAUTHENTICATEDCHANNEL_CONFIGUREINITIALIZE=D3DAUTHENTICATEDCHANNEL_CONFIGUREINITIALIZE -_D3DAUTHENTICATEDCHANNEL_CONFIGUREPROTECTION=D3DAUTHENTICATEDCHANNEL_CONFIGUREPROTECTION -_D3DAUTHENTICATEDCHANNEL_CONFIGURECRYPTOSESSION=D3DAUTHENTICATEDCHANNEL_CONFIGURECRYPTOSESSION -_D3DAUTHENTICATEDCHANNEL_CONFIGURESHAREDRESOURCE=D3DAUTHENTICATEDCHANNEL_CONFIGURESHAREDRESOURCE -_D3DAUTHENTICATEDCHANNEL_CONFIGUREUNCOMPRESSEDENCRYPTION=D3DAUTHENTICATEDCHANNEL_CONFIGUREUNCOMPRESSEDENCRYPTION -_D3DENCRYPTED_BLOCK_INFO=D3DENCRYPTED_BLOCK_INFO -_D3DAES_CTR_IV=D3DAES_CTR_IV -_D3D10_SHADER_DESC=D3D10_SHADER_DESC -_D3D10_SHADER_BUFFER_DESC=D3D10_SHADER_BUFFER_DESC -_D3D10_SHADER_VARIABLE_DESC=D3D10_SHADER_VARIABLE_DESC -_D3D10_SHADER_TYPE_DESC=D3D10_SHADER_TYPE_DESC -_D3D10_SHADER_INPUT_BIND_DESC=D3D10_SHADER_INPUT_BIND_DESC -_D3D10_SIGNATURE_PARAMETER_DESC=D3D10_SIGNATURE_PARAMETER_DESC -_D3D10_DEVICE_STATE_TYPES=D3D10_DEVICE_STATE_TYPES -_D3D10_STATE_BLOCK_MASK=D3D10_STATE_BLOCK_MASK -_D3D10_EFFECT_TYPE_DESC=D3D10_EFFECT_TYPE_DESC -_D3D10_EFFECT_VARIABLE_DESC=D3D10_EFFECT_VARIABLE_DESC -_D3D10_EFFECT_SHADER_DESC=D3D10_EFFECT_SHADER_DESC -_D3D10_PASS_DESC=D3D10_PASS_DESC -_D3D10_PASS_SHADER_DESC=D3D10_PASS_SHADER_DESC -_D3D10_TECHNIQUE_DESC=D3D10_TECHNIQUE_DESC -_D3D10_EFFECT_DESC=D3D10_EFFECT_DESC -_D3D10_SHADER_DEBUG_REGTYPE=D3D10_SHADER_DEBUG_REGTYPE -_D3D10_SHADER_DEBUG_SCOPETYPE=D3D10_SHADER_DEBUG_SCOPETYPE -_D3D10_SHADER_DEBUG_VARTYPE=D3D10_SHADER_DEBUG_VARTYPE -_D3D10_SHADER_DEBUG_TOKEN_INFO=D3D10_SHADER_DEBUG_TOKEN_INFO -_D3D10_SHADER_DEBUG_VAR_INFO=D3D10_SHADER_DEBUG_VAR_INFO -_D3D10_SHADER_DEBUG_INPUT_INFO=D3D10_SHADER_DEBUG_INPUT_INFO -_D3D10_SHADER_DEBUG_SCOPEVAR_INFO=D3D10_SHADER_DEBUG_SCOPEVAR_INFO -_D3D10_SHADER_DEBUG_SCOPE_INFO=D3D10_SHADER_DEBUG_SCOPE_INFO -_D3D10_SHADER_DEBUG_OUTPUTVAR=D3D10_SHADER_DEBUG_OUTPUTVAR -_D3D10_SHADER_DEBUG_OUTPUTREG_INFO=D3D10_SHADER_DEBUG_OUTPUTREG_INFO -_D3D10_SHADER_DEBUG_INST_INFO=D3D10_SHADER_DEBUG_INST_INFO -_D3D10_SHADER_DEBUG_FILE_INFO=D3D10_SHADER_DEBUG_FILE_INFO -_D3D10_SHADER_DEBUG_INFO=D3D10_SHADER_DEBUG_INFO -tagVS_FIXEDFILEINFO=VS_FIXEDFILEINFO -tagHSZPAIR=HSZPAIR -tagCONVCONTEXT=CONVCONTEXT -tagCONVINFO=CONVINFO -tagDDEML_MSG_HOOK_DATA=DDEML_MSG_HOOK_DATA -tagMONMSGSTRUCT=MONMSGSTRUCT -tagMONCBSTRUCT=MONCBSTRUCT -tagMONHSZSTRUCTA=MONHSZSTRUCTA -tagMONHSZSTRUCTW=MONHSZSTRUCTW -tagMONERRSTRUCT=MONERRSTRUCT -tagMONLINKSTRUCT=MONLINKSTRUCT -tagMONCONVSTRUCT=MONCONVSTRUCT -tagCRGB=CRGB -tagMCI_GENERIC_PARMS=MCI_GENERIC_PARMS -tagMCI_OPEN_PARMSA=MCI_OPEN_PARMSA -tagMCI_OPEN_PARMSW=MCI_OPEN_PARMSW -tagMCI_PLAY_PARMS=MCI_PLAY_PARMS -tagMCI_SEEK_PARMS=MCI_SEEK_PARMS -tagMCI_STATUS_PARMS=MCI_STATUS_PARMS -tagMCI_INFO_PARMSA=MCI_INFO_PARMSA -tagMCI_INFO_PARMSW=MCI_INFO_PARMSW -tagMCI_GETDEVCAPS_PARMS=MCI_GETDEVCAPS_PARMS -tagMCI_SYSINFO_PARMSA=MCI_SYSINFO_PARMSA -tagMCI_SYSINFO_PARMSW=MCI_SYSINFO_PARMSW -tagMCI_SET_PARMS=MCI_SET_PARMS -tagMCI_BREAK_PARMS=MCI_BREAK_PARMS -tagMCI_SAVE_PARMSA=MCI_SAVE_PARMSA -tagMCI_SAVE_PARMSW=MCI_SAVE_PARMSW -tagMCI_LOAD_PARMSA=MCI_LOAD_PARMSA -tagMCI_LOAD_PARMSW=MCI_LOAD_PARMSW -tagMCI_RECORD_PARMS=MCI_RECORD_PARMS -tagMCI_VD_PLAY_PARMS=MCI_VD_PLAY_PARMS -tagMCI_VD_STEP_PARMS=MCI_VD_STEP_PARMS -tagMCI_VD_ESCAPE_PARMSA=MCI_VD_ESCAPE_PARMSA -tagMCI_VD_ESCAPE_PARMSW=MCI_VD_ESCAPE_PARMSW -tagMCI_WAVE_OPEN_PARMSA=MCI_WAVE_OPEN_PARMSA -tagMCI_WAVE_OPEN_PARMSW=MCI_WAVE_OPEN_PARMSW -tagMCI_WAVE_DELETE_PARMS=MCI_WAVE_DELETE_PARMS -tagMCI_WAVE_SET_PARMS=MCI_WAVE_SET_PARMS -tagMCI_SEQ_SET_PARMS=MCI_SEQ_SET_PARMS -tagMCI_ANIM_OPEN_PARMSA=MCI_ANIM_OPEN_PARMSA -tagMCI_ANIM_OPEN_PARMSW=MCI_ANIM_OPEN_PARMSW -tagMCI_ANIM_PLAY_PARMS=MCI_ANIM_PLAY_PARMS -tagMCI_ANIM_STEP_PARMS=MCI_ANIM_STEP_PARMS -tagMCI_ANIM_WINDOW_PARMSA=MCI_ANIM_WINDOW_PARMSA -tagMCI_ANIM_WINDOW_PARMSW=MCI_ANIM_WINDOW_PARMSW -tagMCI_ANIM_RECT_PARMS=MCI_ANIM_RECT_PARMS -tagMCI_ANIM_UPDATE_PARMS=MCI_ANIM_UPDATE_PARMS -tagMCI_OVLY_OPEN_PARMSA=MCI_OVLY_OPEN_PARMSA -tagMCI_OVLY_OPEN_PARMSW=MCI_OVLY_OPEN_PARMSW -tagMCI_OVLY_WINDOW_PARMSA=MCI_OVLY_WINDOW_PARMSA -tagMCI_OVLY_WINDOW_PARMSW=MCI_OVLY_WINDOW_PARMSW -tagMCI_OVLY_RECT_PARMS=MCI_OVLY_RECT_PARMS -tagMCI_OVLY_SAVE_PARMSA=MCI_OVLY_SAVE_PARMSA -tagMCI_OVLY_SAVE_PARMSW=MCI_OVLY_SAVE_PARMSW -tagMCI_OVLY_LOAD_PARMSA=MCI_OVLY_LOAD_PARMSA -tagMCI_OVLY_LOAD_PARMSW=MCI_OVLY_LOAD_PARMSW -tagDRVCONFIGINFO=DRVCONFIGINFO -tagJOYCAPSA=JOYCAPSA -tagJOYCAPSW=JOYCAPSW -tagJOYCAPS2A=JOYCAPS2A -tagJOYCAPS2W=JOYCAPS2W -tagI_RpcProxyCallbackInterface=I_RpcProxyCallbackInterface -tagExtendedErrorParamTypes=ExtendedErrorParamTypes -tagBinaryParam=BinaryParam -tagRPC_EE_INFO_PARAM=RPC_EE_INFO_PARAM -tagRPC_EXTENDED_ERROR_INFO=RPC_EXTENDED_ERROR_INFO -tagRPC_ERROR_ENUM_HANDLE=RPC_ERROR_ENUM_HANDLE -tagRpcLocalAddressFormat=RpcLocalAddressFormat -tagRPC_CALL_ATTRIBUTES_V1_W=RPC_CALL_ATTRIBUTES_V1_W -tagRPC_CALL_ATTRIBUTES_V1_A=RPC_CALL_ATTRIBUTES_V1_A -tagRpcCallType=RpcCallType -tagRpcCallClientLocality=RpcCallClientLocality -tagRPC_CALL_ATTRIBUTES_V2_W=RPC_CALL_ATTRIBUTES_V2_W -tagRPC_CALL_ATTRIBUTES_V2_A=RPC_CALL_ATTRIBUTES_V2_A -tagRPC_CALL_ATTRIBUTES_V3_W=RPC_CALL_ATTRIBUTES_V3_W -tagRPC_CALL_ATTRIBUTES_V3_A=RPC_CALL_ATTRIBUTES_V3_A -tagNC_ADDRESS=NC_ADDRESS -tagSTGOPTIONS=STGOPTIONS -tagCOMSD=COMSD -tagSERIALIZEDPROPERTYVALUE=SERIALIZEDPROPERTYVALUE -tagREGKIND=REGKIND -tagPARAMDATA=PARAMDATA -tagMETHODDATA=METHODDATA -tagINTERFACEDATA=INTERFACEDATA -tagCHOOSECOLORA=CHOOSECOLORA -tagCHOOSECOLORW=CHOOSECOLORW -tagFINDREPLACEA=FINDREPLACEA -tagFINDREPLACEW=FINDREPLACEW -tagCHOOSEFONTA=CHOOSEFONTA -tagCHOOSEFONTW=CHOOSEFONTW -tagPRINTPAGERANGE=PRINTPAGERANGE -tagDEVNAMES=DEVNAMES -tagCOMPOSITIONFORM=COMPOSITIONFORM -tagCANDIDATEFORM=CANDIDATEFORM -tagCANDIDATELIST=CANDIDATELIST -tagREGISTERWORDA=REGISTERWORDA -tagREGISTERWORDW=REGISTERWORDW -tagRECONVERTSTRING=RECONVERTSTRING -tagSTYLEBUFA=STYLEBUFA -tagSTYLEBUFW=STYLEBUFW -tagIMEMENUITEMINFOA=IMEMENUITEMINFOA -tagIMEMENUITEMINFOW=IMEMENUITEMINFOW -tagIMECHARPOSITION=IMECHARPOSITION -tagWNODE_ALL_DATA=WNODE_ALL_DATA -tagWNODE_SINGLE_INSTANCE=WNODE_SINGLE_INSTANCE -tagWNODE_SINGLE_ITEM=WNODE_SINGLE_ITEM -tagWNODE_METHOD_ITEM=WNODE_METHOD_ITEM -tagWNODE_EVENT_ITEM=WNODE_EVENT_ITEM -tagWNODE_EVENT_REFERENCE=WNODE_EVENT_REFERENCE -tagWNODE_TOO_SMALL=WNODE_TOO_SMALL -tagSTRRET_TYPE=STRRET_TYPE -tagPERCEIVED=PERCEIVED -tagSHCOLSTATE=SHCOLSTATE -tagPARSEDURLA=PARSEDURLA -tagPARSEDURLW=PARSEDURLW -tagINITCOMMONCONTROLSEX=INITCOMMONCONTROLSEX -tagCOLORSCHEME=COLORSCHEME -tagNMTOOLTIPSCREATED=NMTOOLTIPSCREATED -tagNMMOUSE=NMMOUSE -tagNMOBJECTNOTIFY=NMOBJECTNOTIFY -tagNMKEY=NMKEY -tagNMCHAR=NMCHAR -tagNMCUSTOMTEXT=NMCUSTOMTEXT -tagNMTTCUSTOMDRAW=NMTTCUSTOMDRAW -tagNMCUSTOMSPLITRECTINFO=NMCUSTOMSPLITRECTINFO -tagNMHEADERA=NMHEADERA -tagNMHEADERW=NMHEADERW -tagNMHDDISPINFOW=NMHDDISPINFOW -tagNMHDDISPINFOA=NMHDDISPINFOA -tagNMHDFILTERBTNCLICK=NMHDFILTERBTNCLICK -tagTBADDBITMAP=TBADDBITMAP -tagTBSAVEPARAMSA=TBSAVEPARAMSA -tagTBSAVEPARAMSW=TBSAVEPARAMSW -tagNMTBHOTITEM=NMTBHOTITEM -tagNMTBSAVE=NMTBSAVE -tagNMTBRESTORE=NMTBRESTORE -tagNMTBGETINFOTIPA=NMTBGETINFOTIPA -tagNMTBGETINFOTIPW=NMTBGETINFOTIPW -tagNMTOOLBARA=NMTOOLBARA -tagNMTOOLBARW=NMTOOLBARW -tagREBARINFO=REBARINFO -tagREBARBANDINFOA=REBARBANDINFOA -tagREBARBANDINFOW=REBARBANDINFOW -tagNMREBARCHILDSIZE=NMREBARCHILDSIZE -tagNMREBAR=NMREBAR -tagNMRBAUTOSIZE=NMRBAUTOSIZE -tagNMREBARCHEVRON=NMREBARCHEVRON -tagNMREBARSPLITTER=NMREBARSPLITTER -tagNMREBARAUTOBREAK=NMREBARAUTOBREAK -tagNMTTDISPINFOA=NMTTDISPINFOA -tagNMTTDISPINFOW=NMTTDISPINFOW -tagDRAGLISTINFO=DRAGLISTINFO -tagLITEM=LITEM -tagLHITTESTINFO=LHITTESTINFO -tagNMLINK=NMLINK -tagLVITEMA=LVITEMA -tagLVITEMW=LVITEMW -tagLVFINDINFOA=LVFINDINFOA -tagLVFINDINFOW=LVFINDINFOW -tagLVHITTESTINFO=LVHITTESTINFO -tagLVCOLUMNA=LVCOLUMNA -tagLVCOLUMNW=LVCOLUMNW -tagLVBKIMAGEA=LVBKIMAGEA -tagLVBKIMAGEW=LVBKIMAGEW -tagLVGROUP=LVGROUP -tagLVGROUPMETRICS=LVGROUPMETRICS -tagLVINSERTGROUPSORTED=LVINSERTGROUPSORTED -tagLVTILEVIEWINFO=LVTILEVIEWINFO -tagLVTILEINFO=LVTILEINFO -tagLVSETINFOTIP=LVSETINFOTIP -tagLVFOOTERINFO=LVFOOTERINFO -tagLVFOOTERITEM=LVFOOTERITEM -tagLVITEMINDEX=LVITEMINDEX -tagNMLISTVIEW=NMLISTVIEW -tagNMITEMACTIVATE=NMITEMACTIVATE -tagNMLVCUSTOMDRAW=NMLVCUSTOMDRAW -tagNMLVCACHEHINT=NMLVCACHEHINT -tagNMLVFINDITEMA=NMLVFINDITEMA -tagNMLVFINDITEMW=NMLVFINDITEMW -tagNMLVODSTATECHANGE=NMLVODSTATECHANGE -tagNMLVLINK=NMLVLINK -tagNMLVGETINFOTIPA=NMLVGETINFOTIPA -tagNMLVGETINFOTIPW=NMLVGETINFOTIPW -tagNMLVSCROLL=NMLVSCROLL -tagNMLVEMPTYMARKUP=NMLVEMPTYMARKUP -tagNMTVSTATEIMAGECHANGING=NMTVSTATEIMAGECHANGING -tagTVITEMA=TVITEMA -tagTVITEMW=TVITEMW -tagTVITEMEXA=TVITEMEXA -tagTVITEMEXW=TVITEMEXW -tagTVINSERTSTRUCTA=TVINSERTSTRUCTA -tagTVINSERTSTRUCTW=TVINSERTSTRUCTW -tagTVHITTESTINFO=TVHITTESTINFO -tagTVGETITEMPARTRECTINFO=TVGETITEMPARTRECTINFO -tagTVSORTCB=TVSORTCB -tagNMTREEVIEWA=NMTREEVIEWA -tagNMTREEVIEWW=NMTREEVIEWW -tagNMTVCUSTOMDRAW=NMTVCUSTOMDRAW -tagNMTVGETINFOTIPA=NMTVGETINFOTIPA -tagNMTVGETINFOTIPW=NMTVGETINFOTIPW -tagNMTVASYNCDRAW=NMTVASYNCDRAW -tagCOMBOBOXEXITEMA=COMBOBOXEXITEMA -tagCOMBOBOXEXITEMW=COMBOBOXEXITEMW -tagTCITEMHEADERA=TCITEMHEADERA -tagTCITEMHEADERW=TCITEMHEADERW -tagTCITEMA=TCITEMA -tagTCITEMW=TCITEMW -tagTCHITTESTINFO=TCHITTESTINFO -tagMCGRIDINFO=MCGRIDINFO -tagNMSELCHANGE=NMSELCHANGE -tagNMDAYSTATE=NMDAYSTATE -tagNMVIEWCHANGE=NMVIEWCHANGE -tagDATETIMEPICKERINFO=DATETIMEPICKERINFO -tagNMDATETIMECHANGE=NMDATETIMECHANGE -tagNMDATETIMESTRINGA=NMDATETIMESTRINGA -tagNMDATETIMESTRINGW=NMDATETIMESTRINGW -tagNMDATETIMEWMKEYDOWNA=NMDATETIMEWMKEYDOWNA -tagNMDATETIMEWMKEYDOWNW=NMDATETIMEWMKEYDOWNW -tagNMDATETIMEFORMATA=NMDATETIMEFORMATA -tagNMDATETIMEFORMATW=NMDATETIMEFORMATW -tagNMDATETIMEFORMATQUERYA=NMDATETIMEFORMATQUERYA -tagNMDATETIMEFORMATQUERYW=NMDATETIMEFORMATQUERYW -tagNMIPADDRESS=NMIPADDRESS -tagNMPGHOTITEM=NMPGHOTITEM -tagNMBCHOTITEM=NMBCHOTITEM -tagBUTTON_SPLITINFO=BUTTON_SPLITINFO -tagNMBCDROPDOWN=NMBCDROPDOWN -_tagEDITBALLOONTIP=EDITBALLOONTIP -tagPAGERANGE=PAGERANGE -tagPAGESET=PAGESET -_tagOLECMD=OLECMD -_tagOLECMDTEXT=OLECMDTEXT -tagCATEGORYINFO=CATEGORYINFO -tagCONDITION_TYPE=CONDITION_TYPE -tagCONDITION_OPERATION=CONDITION_OPERATION -tagBANDSITEINFO=BANDSITEINFO -tagSMDATA=SMDATA -tagSMINFO=SMINFO -_tagAUTOCOMPLETEOPTIONS=AUTOCOMPLETEOPTIONS -_tagACENUMOPTION=ACENUMOPTION -_tagAUTOCOMPLETELISTOPTIONS=AUTOCOMPLETELISTOPTIONS -tagIESHORTCUTFLAGS=IESHORTCUTFLAGS -tagAASHELLMENUITEM=AASHELLMENUITEM -tagHEAPLIST32=HEAPLIST32 -tagHEAPENTRY32=HEAPENTRY32 -tagPROCESSENTRY32W=PROCESSENTRY32W -tagPROCESSENTRY32=PROCESSENTRY32 -tagTHREADENTRY32=THREADENTRY32 -tagMODULEENTRY32W=MODULEENTRY32W -tagMODULEENTRY32=MODULEENTRY32 -tagWINHTTP_CREDS=WINHTTP_CREDS -tagWINHTTP_CREDS_EX=WINHTTP_CREDS_EX -tagOCPFIPARAMS=OCPFIPARAMS -tagFONTDESC=FONTDESC -tagPICTDESC=PICTDESC -tagSCRIPTLANGUAGEVERSION=SCRIPTLANGUAGEVERSION -tagSCRIPTSTATE=SCRIPTSTATE -tagSCRIPTTRACEINFO=SCRIPTTRACEINFO -tagSCRIPTTHREADSTATE=SCRIPTTHREADSTATE -tagSCRIPTGCTYPE=SCRIPTGCTYPE -tagSCRIPTUICITEM=SCRIPTUICITEM -tagSCRIPTUICHANDLING=SCRIPTUICHANDLING -tagPROP_INFO_FLAGS=PROP_INFO_FLAGS -tagDebugPropertyInfo=DebugPropertyInfo -tagEX_PROP_INFO_FLAGS=EX_PROP_INFO_FLAGS -tagExtendedDebugPropertyInfo=ExtendedDebugPropertyInfo -tagBREAKPOINT_STATE=BREAKPOINT_STATE -tagBREAKREASON=BREAKREASON -tagERRORRESUMEACTION=ERRORRESUMEACTION -tagDOCUMENTNAMETYPE=DOCUMENTNAMETYPE -tagDebugStackFrameDescriptor=DebugStackFrameDescriptor -tagDebugStackFrameDescriptor64=DebugStackFrameDescriptor64 -tagJET_INDEXID=JET_INDEXID -tagJET_CONDITIONALCOLUMN_A=JET_CONDITIONALCOLUMN_A -tagJET_CONDITIONALCOLUMN_W=JET_CONDITIONALCOLUMN_W -tagJET_UNICODEINDEX=JET_UNICODEINDEX -tagJET_UNICODEINDEX2=JET_UNICODEINDEX2 -tagJET_TUPLELIMITS=JET_TUPLELIMITS -tagJET_SPACEHINTS=JET_SPACEHINTS -tagJET_INDEXCREATE_A=JET_INDEXCREATE_A -tagJET_INDEXCREATE_W=JET_INDEXCREATE_W -tagJET_INDEXCREATE2_A=JET_INDEXCREATE2_A -tagJET_INDEXCREATE2_W=JET_INDEXCREATE2_W -tagJET_INDEXCREATE3_A=JET_INDEXCREATE3_A -tagJET_INDEXCREATE3_W=JET_INDEXCREATE3_W -tagJET_TABLECREATE_A=JET_TABLECREATE_A -tagJET_TABLECREATE_W=JET_TABLECREATE_W -tagJET_TABLECREATE2_A=JET_TABLECREATE2_A -tagJET_TABLECREATE2_W=JET_TABLECREATE2_W -tagJET_TABLECREATE3_A=JET_TABLECREATE3_A -tagJET_TABLECREATE3_W=JET_TABLECREATE3_W -tagJET_TABLECREATE4_A=JET_TABLECREATE4_A -tagJET_TABLECREATE4_W=JET_TABLECREATE4_W -tagJET_OPENTEMPORARYTABLE=JET_OPENTEMPORARYTABLE -tagJET_OPENTEMPORARYTABLE2=JET_OPENTEMPORARYTABLE2 -tagMSAAMENUINFO=MSAAMENUINFO -tagSYSTEM_EVENT_DATA=SYSTEM_EVENT_DATA -tagSTROKE_RANGE=STROKE_RANGE -tagRECO_GUIDE=RECO_GUIDE -tagRECO_ATTRS=RECO_ATTRS -tagRECO_RANGE=RECO_RANGE -tagLINE_SEGMENT=LINE_SEGMENT -tagLATTICE_METRICS=LATTICE_METRICS -tagRECO_LATTICE_PROPERTY=RECO_LATTICE_PROPERTY -tagRECO_LATTICE_PROPERTIES=RECO_LATTICE_PROPERTIES -tagRECO_LATTICE_ELEMENT=RECO_LATTICE_ELEMENT -tagRECO_LATTICE_COLUMN=RECO_LATTICE_COLUMN -tagRECO_LATTICE=RECO_LATTICE -tagCHARACTER_RANGE=CHARACTER_RANGE -tagPropertyConstraint=PropertyConstraint -tagSystemVisibilityFlags=SystemVisibilityFlags -tagQueryUpdateAction=QueryUpdateAction -tagQueryCategoryType=QueryCategoryType -tagMFASYNCRESULT=MFASYNCRESULT -tagFaceRectInfoBlobHeader=FaceRectInfoBlobHeader -tagFaceRectInfo=FaceRectInfo -tagFaceCharacterizationBlobHeader=FaceCharacterizationBlobHeader -tagFaceCharacterization=FaceCharacterization -tagCapturedMetadataExposureCompensation=CapturedMetadataExposureCompensation -tagCapturedMetadataISOGains=CapturedMetadataISOGains -tagCapturedMetadataWhiteBalanceGains=CapturedMetadataWhiteBalanceGains -tagMetadataTimeStamps=MetadataTimeStamps -tagHistogramGrid=HistogramGrid -tagHistogramBlobHeader=HistogramBlobHeader -tagHistogramHeader=HistogramHeader -tagHistogramDataHeader=HistogramDataHeader -tagVIDEOINFOHEADER=VIDEOINFOHEADER -tagVIDEOINFOHEADER2=VIDEOINFOHEADER2 -tagMPEG1VIDEOINFO=MPEG1VIDEOINFO -tagMPEG2VIDEOINFO=MPEG2VIDEOINFO -tagDIRECTX_AUDIO_ACTIVATION_PARAMS=DIRECTX_AUDIO_ACTIVATION_PARAMS -tagNAMED_PROFILE_INFO=NAMED_PROFILE_INFO -tagCOLOR=COLOR -tagPROFILEHEADER=PROFILEHEADER -tagPROFILE=PROFILE -tagENUMTYPEA=ENUMTYPEA -tagENUMTYPEW=ENUMTYPEW -_tagCOLORMATCHSETUPW=COLORMATCHSETUPW -_tagCOLORMATCHSETUPA=COLORMATCHSETUPA -_tagADDRESS64=ADDRESS64 -_tagADDRESS=ADDRESS -_tagSTACKFRAME64=STACKFRAME64 -_tagSTACKFRAME_EX=STACKFRAME_EX -_tagSTACKFRAME=STACKFRAME -sockaddr=SOCKADDR -_WINHTTP_HEADER_NAME=WINHTTP_HEADER_NAME -_INTERFACE_HARDWARE_TIMESTAMP_CAPABILITIES=INTERFACE_HARDWARE_TIMESTAMP_CAPABILITIES -_INTERFACE_SOFTWARE_TIMESTAMP_CAPABILITIES=INTERFACE_SOFTWARE_TIMESTAMP_CAPABILITIES -tagDigitalWindowSetting=DigitalWindowSetting -_IMAGEHLP_MODULE64_EX=IMAGEHLP_MODULE64_EX -_IMAGEHLP_MODULEW64_EX=IMAGEHLP_MODULEW64_EX -_ADS_CASEIGNORE_LIST=ADS_CASEIGNORE_LIST -_ADS_OCTET_LIST=ADS_OCTET_LIST -_ADSPROPINITPARAMS=ADSPROPINITPARAMS -_ADSPROPERROR=ADSPROPERROR -_DSDISPLAYSPECOPTIONS=DSDISPLAYSPECOPTIONS -_DOMAINDESC=DOMAINDESC -_DSOP_UPLEVEL_FILTER_FLAGS=DSOP_UPLEVEL_FILTER_FLAGS -_DSOP_FILTER_FLAGS=DSOP_FILTER_FLAGS -_DSOP_SCOPE_INIT_INFO=DSOP_SCOPE_INIT_INFO -_DSOP_INIT_INFO=DSOP_INIT_INFO -_DS_SELECTION=DS_SELECTION -_DS_SELECTION_LIST=DS_SELECTION_LIST -_SI_OBJECT_INFO=SI_OBJECT_INFO -_SI_ACCESS=SI_ACCESS -_SI_INHERIT_TYPE=SI_INHERIT_TYPE -_SI_PAGE_TYPE=SI_PAGE_TYPE -_SI_PAGE_ACTIVATED=SI_PAGE_ACTIVATED -_SID_INFO=SID_INFO -_SID_INFO_LIST=SID_INFO_LIST -_SECURITY_OBJECT=SECURITY_OBJECT -_EFFPERM_RESULT_LIST=EFFPERM_RESULT_LIST -tagDOT11_ADHOC_CIPHER_ALGORITHM=DOT11_ADHOC_CIPHER_ALGORITHM -tagDOT11_ADHOC_AUTH_ALGORITHM=DOT11_ADHOC_AUTH_ALGORITHM -tagDOT11_ADHOC_NETWORK_CONNECTION_STATUS=DOT11_ADHOC_NETWORK_CONNECTION_STATUS -tagDOT11_ADHOC_CONNECT_FAIL_REASON=DOT11_ADHOC_CONNECT_FAIL_REASON -_UNCOMPRESSEDAUDIOFORMAT=UNCOMPRESSEDAUDIOFORMAT -_DMUS_VOICE_STATE=DMUS_VOICE_STATE -_WIA_DITHER_PATTERN_DATA=WIA_DITHER_PATTERN_DATA -_WIA_PROPID_TO_NAME=WIA_PROPID_TO_NAME -_WIA_FORMAT_INFO=WIA_FORMAT_INFO -_WIA_DATA_CALLBACK_HEADER=WIA_DATA_CALLBACK_HEADER -_WIA_DATA_TRANSFER_INFO=WIA_DATA_TRANSFER_INFO -_WIA_EXTENDED_TRANSFER_INFO=WIA_EXTENDED_TRANSFER_INFO -_WIA_DEV_CAP=WIA_DEV_CAP -tagAZ_PROP_CONSTANTS=AZ_PROP_CONSTANTS -tagCSEDB_RSTMAPW=CSEDB_RSTMAPW -tagUpdateImpactLevel=UpdateImpactLevel -tagUpdateAssessmentStatus=UpdateAssessmentStatus -tagUpdateAssessment=UpdateAssessment -tagOSUpdateAssessment=OSUpdateAssessment -tagRTWQASYNCRESULT=RTWQASYNCRESULT -_VDS_STORAGE_IDENTIFIER_CODE_SET=VDS_STORAGE_IDENTIFIER_CODE_SET -_VDS_STORAGE_IDENTIFIER_TYPE=VDS_STORAGE_IDENTIFIER_TYPE -_VDS_STORAGE_BUS_TYPE=VDS_STORAGE_BUS_TYPE -_VDS_STORAGE_IDENTIFIER=VDS_STORAGE_IDENTIFIER -_VDS_STORAGE_DEVICE_ID_DESCRIPTOR=VDS_STORAGE_DEVICE_ID_DESCRIPTOR -_VDS_INTERCONNECT_ADDRESS_TYPE=VDS_INTERCONNECT_ADDRESS_TYPE -_VDS_INTERCONNECT=VDS_INTERCONNECT -_VDS_LUN_INFORMATION=VDS_LUN_INFORMATION -_VDS_OBJECT_TYPE=VDS_OBJECT_TYPE -_VDS_PROVIDER_TYPE=VDS_PROVIDER_TYPE -_VDS_PROVIDER_FLAG=VDS_PROVIDER_FLAG -_VDS_RECOVER_ACTION=VDS_RECOVER_ACTION -_VDS_NOTIFICATION_TARGET_TYPE=VDS_NOTIFICATION_TARGET_TYPE -_VDS_PACK_NOTIFICATION=VDS_PACK_NOTIFICATION -_VDS_DISK_NOTIFICATION=VDS_DISK_NOTIFICATION -_VDS_VOLUME_NOTIFICATION=VDS_VOLUME_NOTIFICATION -_VDS_PARTITION_NOTIFICATION=VDS_PARTITION_NOTIFICATION -_VDS_SERVICE_NOTIFICATION=VDS_SERVICE_NOTIFICATION -_VDS_DRIVE_LETTER_NOTIFICATION=VDS_DRIVE_LETTER_NOTIFICATION -_VDS_FILE_SYSTEM_NOTIFICATION=VDS_FILE_SYSTEM_NOTIFICATION -_VDS_MOUNT_POINT_NOTIFICATION=VDS_MOUNT_POINT_NOTIFICATION -_VDS_SUB_SYSTEM_NOTIFICATION=VDS_SUB_SYSTEM_NOTIFICATION -_VDS_CONTROLLER_NOTIFICATION=VDS_CONTROLLER_NOTIFICATION -_VDS_DRIVE_NOTIFICATION=VDS_DRIVE_NOTIFICATION -_VDS_LUN_NOTIFICATION=VDS_LUN_NOTIFICATION -_VDS_PORT_NOTIFICATION=VDS_PORT_NOTIFICATION -_VDS_PORTAL_NOTIFICATION=VDS_PORTAL_NOTIFICATION -_VDS_TARGET_NOTIFICATION=VDS_TARGET_NOTIFICATION -_VDS_PORTAL_GROUP_NOTIFICATION=VDS_PORTAL_GROUP_NOTIFICATION -_VDS_NOTIFICATION=VDS_NOTIFICATION -_VDS_ASYNC_OUTPUT_TYPE=VDS_ASYNC_OUTPUT_TYPE -_VDS_ASYNC_OUTPUT=VDS_ASYNC_OUTPUT -_VDS_HEALTH=VDS_HEALTH -_VDS_TRANSITION_STATE=VDS_TRANSITION_STATE -_VDS_FILE_SYSTEM_TYPE=VDS_FILE_SYSTEM_TYPE -_VDS_HBAPORT_TYPE=VDS_HBAPORT_TYPE -_VDS_HBAPORT_STATUS=VDS_HBAPORT_STATUS -_VDS_HBAPORT_SPEED_FLAG=VDS_HBAPORT_SPEED_FLAG -_VDS_PATH_STATUS=VDS_PATH_STATUS -_VDS_LOADBALANCE_POLICY_ENUM=VDS_LOADBALANCE_POLICY_ENUM -_VDS_PROVIDER_LBSUPPORT_FLAG=VDS_PROVIDER_LBSUPPORT_FLAG -_VDS_VERSION_SUPPORT_FLAG=VDS_VERSION_SUPPORT_FLAG -_VDS_HWPROVIDER_TYPE=VDS_HWPROVIDER_TYPE -_VDS_ISCSI_LOGIN_TYPE=VDS_ISCSI_LOGIN_TYPE -_VDS_ISCSI_AUTH_TYPE=VDS_ISCSI_AUTH_TYPE -_VDS_ISCSI_IPSEC_FLAG=VDS_ISCSI_IPSEC_FLAG -_VDS_ISCSI_LOGIN_FLAG=VDS_ISCSI_LOGIN_FLAG -_VDS_PATH_ID=VDS_PATH_ID -_VDS_WWN=VDS_WWN -_VDS_IPADDRESS=VDS_IPADDRESS -_VDS_ISCSI_IPSEC_KEY=VDS_ISCSI_IPSEC_KEY -_VDS_ISCSI_SHARED_SECRET=VDS_ISCSI_SHARED_SECRET -_VDS_HBAPORT_PROP=VDS_HBAPORT_PROP -_VDS_ISCSI_INITIATOR_ADAPTER_PROP=VDS_ISCSI_INITIATOR_ADAPTER_PROP -_VDS_ISCSI_INITIATOR_PORTAL_PROP=VDS_ISCSI_INITIATOR_PORTAL_PROP -_VDS_PROVIDER_PROP=VDS_PROVIDER_PROP -_VDS_PATH_INFO=VDS_PATH_INFO -_VDS_PATH_POLICY=VDS_PATH_POLICY -_VDS_SUB_SYSTEM_STATUS=VDS_SUB_SYSTEM_STATUS -_VDS_SUB_SYSTEM_FLAG=VDS_SUB_SYSTEM_FLAG -_VDS_SUB_SYSTEM_SUPPORTED_RAID_TYPE_FLAG=VDS_SUB_SYSTEM_SUPPORTED_RAID_TYPE_FLAG -_VDS_INTERCONNECT_FLAG=VDS_INTERCONNECT_FLAG -_VDS_CONTROLLER_STATUS=VDS_CONTROLLER_STATUS -_VDS_PORT_STATUS=VDS_PORT_STATUS -_VDS_DRIVE_STATUS=VDS_DRIVE_STATUS -_VDS_DRIVE_FLAG=VDS_DRIVE_FLAG -_VDS_LUN_TYPE=VDS_LUN_TYPE -_VDS_LUN_STATUS=VDS_LUN_STATUS -_VDS_LUN_FLAG=VDS_LUN_FLAG -_VDS_LUN_PLEX_TYPE=VDS_LUN_PLEX_TYPE -_VDS_LUN_PLEX_STATUS=VDS_LUN_PLEX_STATUS -_VDS_LUN_PLEX_FLAG=VDS_LUN_PLEX_FLAG -_VDS_ISCSI_PORTAL_STATUS=VDS_ISCSI_PORTAL_STATUS -_VDS_STORAGE_POOL_STATUS=VDS_STORAGE_POOL_STATUS -_VDS_STORAGE_POOL_TYPE=VDS_STORAGE_POOL_TYPE -_VDS_MAINTENANCE_OPERATION=VDS_MAINTENANCE_OPERATION -_VDS_HINTS=VDS_HINTS -_VDS_HINTS2=VDS_HINTS2 -_VDS_SUB_SYSTEM_PROP=VDS_SUB_SYSTEM_PROP -_VDS_SUB_SYSTEM_PROP2=VDS_SUB_SYSTEM_PROP2 -_VDS_CONTROLLER_PROP=VDS_CONTROLLER_PROP -_VDS_DRIVE_PROP=VDS_DRIVE_PROP -_VDS_DRIVE_PROP2=VDS_DRIVE_PROP2 -_VDS_DRIVE_EXTENT=VDS_DRIVE_EXTENT -_VDS_LUN_PROP=VDS_LUN_PROP -_VDS_LUN_PLEX_PROP=VDS_LUN_PLEX_PROP -_VDS_PORT_PROP=VDS_PORT_PROP -_VDS_ISCSI_PORTAL_PROP=VDS_ISCSI_PORTAL_PROP -_VDS_ISCSI_TARGET_PROP=VDS_ISCSI_TARGET_PROP -_VDS_ISCSI_PORTALGROUP_PROP=VDS_ISCSI_PORTALGROUP_PROP -_VDS_RAID_TYPE=VDS_RAID_TYPE -_VDS_POOL_CUSTOM_ATTRIBUTES=VDS_POOL_CUSTOM_ATTRIBUTES -_VDS_POOL_ATTRIBUTES=VDS_POOL_ATTRIBUTES -_VDS_STORAGE_POOL_PROP=VDS_STORAGE_POOL_PROP -_VDS_STORAGE_POOL_DRIVE_EXTENT=VDS_STORAGE_POOL_DRIVE_EXTENT -_VSS_OBJECT_TYPE=VSS_OBJECT_TYPE -_VSS_SNAPSHOT_STATE=VSS_SNAPSHOT_STATE -_VSS_VOLUME_SNAPSHOT_ATTRIBUTES=VSS_VOLUME_SNAPSHOT_ATTRIBUTES -_VSS_SNAPSHOT_CONTEXT=VSS_SNAPSHOT_CONTEXT -_VSS_PROVIDER_CAPABILITIES=VSS_PROVIDER_CAPABILITIES -_VSS_HARDWARE_OPTIONS=VSS_HARDWARE_OPTIONS -_VSS_RECOVERY_OPTIONS=VSS_RECOVERY_OPTIONS -_VSS_WRITER_STATE=VSS_WRITER_STATE -_VSS_BACKUP_TYPE=VSS_BACKUP_TYPE -_VSS_RESTORE_TYPE=VSS_RESTORE_TYPE -_VSS_ROLLFORWARD_TYPE=VSS_ROLLFORWARD_TYPE -_VSS_PROVIDER_TYPE=VSS_PROVIDER_TYPE -_VSS_APPLICATION_LEVEL=VSS_APPLICATION_LEVEL -_VSS_SNAPSHOT_COMPATIBILITY=VSS_SNAPSHOT_COMPATIBILITY -_VSS_SNAPSHOT_PROPERTY_ID=VSS_SNAPSHOT_PROPERTY_ID -_VSS_FILE_SPEC_BACKUP_TYPE=VSS_FILE_SPEC_BACKUP_TYPE -_VSS_BACKUP_SCHEMA=VSS_BACKUP_SCHEMA -_VSS_SNAPSHOT_PROP=VSS_SNAPSHOT_PROP -_VSS_PROVIDER_PROP=VSS_PROVIDER_PROP -_VSS_OBJECT_PROP=VSS_OBJECT_PROP -_VSS_MGMT_OBJECT_TYPE=VSS_MGMT_OBJECT_TYPE -_VSS_VOLUME_PROP=VSS_VOLUME_PROP -_VSS_DIFF_VOLUME_PROP=VSS_DIFF_VOLUME_PROP -_VSS_DIFF_AREA_PROP=VSS_DIFF_AREA_PROP -_VSS_MGMT_OBJECT_PROP=VSS_MGMT_OBJECT_PROP -_VSS_PROTECTION_LEVEL=VSS_PROTECTION_LEVEL -_VSS_PROTECTION_FAULT=VSS_PROTECTION_FAULT -_VSS_VOLUME_PROTECTION_INFO=VSS_VOLUME_PROTECTION_INFO _VSS_COMPONENTINFO=VSS_COMPONENTINFO -_POINTE=POINTE -_FLOAT_LONG=FLOAT_LONG -_POINTFIX=POINTFIX -_RECTFX=RECTFX -_FD_XFORM=FD_XFORM -_FD_DEVICEMETRICS=FD_DEVICEMETRICS -_LIGATURE=LIGATURE -_FD_LIGATURE=FD_LIGATURE -_POINTQF=POINTQF -_WCRUN=WCRUN -_FD_GLYPHSET=FD_GLYPHSET -_FD_GLYPHATTR=FD_GLYPHATTR -_FD_KERNINGPAIR=FD_KERNINGPAIR -_FONTDIFF=FONTDIFF -_FONTSIM=FONTSIM -_IFIMETRICS=IFIMETRICS -_IFIEXTRA=IFIEXTRA -_DRVFN=DRVFN -tagDRVENABLEDATA=DRVENABLEDATA -tagDEVINFO=DEVINFO -_LINEATTRS=LINEATTRS -_XFORML=XFORML -_CIECHROMA=CIECHROMA -_COLORINFO=COLORINFO -tagCDDDXGK_REDIRBITMAPPRESENTINFO=CDDDXGK_REDIRBITMAPPRESENTINFO -_GDIINFO=GDIINFO -_BRUSHOBJ=BRUSHOBJ -_CLIPOBJ=CLIPOBJ -_DRIVEROBJ=DRIVEROBJ -_FONTOBJ=FONTOBJ -_BLENDOBJ=BLENDOBJ -_PALOBJ=PALOBJ -_PATHOBJ=PATHOBJ -_SURFOBJ=SURFOBJ -_WNDOBJ=WNDOBJ -_XFORMOBJ=XFORMOBJ -_XLATEOBJ=XLATEOBJ -_ENUMRECTS=ENUMRECTS -_GLYPHBITS=GLYPHBITS -_GLYPHDEF=GLYPHDEF -_GLYPHPOS=GLYPHPOS -_GLYPHDATA=GLYPHDATA -_STROBJ=STROBJ -_FONTINFO=FONTINFO -_PATHDATA=PATHDATA -_RUN=RUN -_CLIPLINE=CLIPLINE -_PERBANDINFO=PERBANDINFO -_GAMMARAMP=GAMMARAMP -_DEVHTINFO=DEVHTINFO -_DEVHTADJDATA=DEVHTADJDATA -_TYPE1_FONT=TYPE1_FONT -_ENGSAFESEMAPHORE=ENGSAFESEMAPHORE -_FLOATOBJ=FLOATOBJ -tagFLOATOBJ_XFORM=FLOATOBJ_XFORM -_ENG_TIME_FIELDS=ENG_TIME_FIELDS -_ENG_SYSTEM_ATTRIBUTE=ENG_SYSTEM_ATTRIBUTE -_ENG_DEVICE_ATTRIBUTE=ENG_DEVICE_ATTRIBUTE -_DRH_APIBITMAPDATA=DRH_APIBITMAPDATA -_DEVICE_EVENT_MOUNT=DEVICE_EVENT_MOUNT -_DEVICE_EVENT_BECOMING_READY=DEVICE_EVENT_BECOMING_READY -_DEVICE_EVENT_EXTERNAL_REQUEST=DEVICE_EVENT_EXTERNAL_REQUEST -_DEVICE_EVENT_GENERIC_DATA=DEVICE_EVENT_GENERIC_DATA -_DEVICE_EVENT_RBC_DATA=DEVICE_EVENT_RBC_DATA -_GUID_IO_DISK_CLONE_ARRIVAL_INFORMATION=GUID_IO_DISK_CLONE_ARRIVAL_INFORMATION -_DISK_HEALTH_NOTIFICATION_DATA=DISK_HEALTH_NOTIFICATION_DATA -_REDBOOK_DIGITAL_AUDIO_EXTRACTION_INFO=REDBOOK_DIGITAL_AUDIO_EXTRACTION_INFO -_DEV_BROADCAST_HDR=DEV_BROADCAST_HDR -_DEV_BROADCAST_OEM=DEV_BROADCAST_OEM -_DEV_BROADCAST_DEVNODE=DEV_BROADCAST_DEVNODE -_DEV_BROADCAST_VOLUME=DEV_BROADCAST_VOLUME -_DEV_BROADCAST_PORT_A=DEV_BROADCAST_PORT_A -_DEV_BROADCAST_PORT_W=DEV_BROADCAST_PORT_W -_DEV_BROADCAST_NET=DEV_BROADCAST_NET -_DEV_BROADCAST_DEVICEINTERFACE_A=DEV_BROADCAST_DEVICEINTERFACE_A -_DEV_BROADCAST_DEVICEINTERFACE_W=DEV_BROADCAST_DEVICEINTERFACE_W -_DEV_BROADCAST_HANDLE=DEV_BROADCAST_HANDLE -_DEV_BROADCAST_HANDLE32=DEV_BROADCAST_HANDLE32 -_DEV_BROADCAST_HANDLE64=DEV_BROADCAST_HANDLE64 -_PWM_CONTROLLER_INFO=PWM_CONTROLLER_INFO -_PWM_CONTROLLER_GET_ACTUAL_PERIOD_OUTPUT=PWM_CONTROLLER_GET_ACTUAL_PERIOD_OUTPUT -_PWM_CONTROLLER_SET_DESIRED_PERIOD_INPUT=PWM_CONTROLLER_SET_DESIRED_PERIOD_INPUT -_PWM_CONTROLLER_SET_DESIRED_PERIOD_OUTPUT=PWM_CONTROLLER_SET_DESIRED_PERIOD_OUTPUT -_PWM_PIN_GET_ACTIVE_DUTY_CYCLE_PERCENTAGE_OUTPUT=PWM_PIN_GET_ACTIVE_DUTY_CYCLE_PERCENTAGE_OUTPUT -_PWM_PIN_SET_ACTIVE_DUTY_CYCLE_PERCENTAGE_INPUT=PWM_PIN_SET_ACTIVE_DUTY_CYCLE_PERCENTAGE_INPUT -_PWM_POLARITY=PWM_POLARITY -_PWM_PIN_GET_POLARITY_OUTPUT=PWM_PIN_GET_POLARITY_OUTPUT -_PWM_PIN_SET_POLARITY_INPUT=PWM_PIN_SET_POLARITY_INPUT -_PWM_PIN_IS_STARTED_OUTPUT=PWM_PIN_IS_STARTED_OUTPUT -_BATTERY_QUERY_INFORMATION=BATTERY_QUERY_INFORMATION -_BATTERY_INFORMATION=BATTERY_INFORMATION -_BATTERY_CHARGING_SOURCE_TYPE=BATTERY_CHARGING_SOURCE_TYPE -_BATTERY_CHARGING_SOURCE=BATTERY_CHARGING_SOURCE -_BATTERY_CHARGING_SOURCE_INFORMATION=BATTERY_CHARGING_SOURCE_INFORMATION -_USB_CHARGER_PORT=USB_CHARGER_PORT -_BATTERY_SET_INFORMATION=BATTERY_SET_INFORMATION -_BATTERY_CHARGER_STATUS=BATTERY_CHARGER_STATUS -_BATTERY_USB_CHARGER_STATUS=BATTERY_USB_CHARGER_STATUS -_BATTERY_WAIT_STATUS=BATTERY_WAIT_STATUS -_BATTERY_STATUS=BATTERY_STATUS -_BATTERY_MANUFACTURE_DATE=BATTERY_MANUFACTURE_DATE -_THERMAL_INFORMATION=THERMAL_INFORMATION -_THERMAL_WAIT_READ=THERMAL_WAIT_READ -_THERMAL_POLICY=THERMAL_POLICY -_WAKE_ALARM_INFORMATION=WAKE_ALARM_INFORMATION -_ACPI_REAL_TIME=ACPI_REAL_TIME -_VIDEO_VDM=VIDEO_VDM -_VIDEO_REGISTER_VDM=VIDEO_REGISTER_VDM -tagVIDEO_MONITOR_DESCRIPTOR=VIDEO_MONITOR_DESCRIPTOR -_VIDEO_WIN32K_CALLBACKS_PARAMS_TYPE=VIDEO_WIN32K_CALLBACKS_PARAMS_TYPE -_DXGK_WIN32K_PARAM_DATA=DXGK_WIN32K_PARAM_DATA -_VIDEO_WIN32K_CALLBACKS_PARAMS=VIDEO_WIN32K_CALLBACKS_PARAMS -_VIDEO_WIN32K_CALLBACKS=VIDEO_WIN32K_CALLBACKS -_VIDEO_DEVICE_SESSION_STATUS=VIDEO_DEVICE_SESSION_STATUS -_VIDEO_HARDWARE_STATE_HEADER=VIDEO_HARDWARE_STATE_HEADER -_VIDEO_HARDWARE_STATE=VIDEO_HARDWARE_STATE -_VIDEO_NUM_MODES=VIDEO_NUM_MODES -_VIDEO_MODE=VIDEO_MODE -_VIDEO_MODE_INFORMATION=VIDEO_MODE_INFORMATION -_VIDEO_LOAD_FONT_INFORMATION=VIDEO_LOAD_FONT_INFORMATION -_VIDEO_PALETTE_DATA=VIDEO_PALETTE_DATA -_VIDEO_CLUTDATA=VIDEO_CLUTDATA -_VIDEO_CURSOR_POSITION=VIDEO_CURSOR_POSITION -_VIDEO_CURSOR_ATTRIBUTES=VIDEO_CURSOR_ATTRIBUTES -_VIDEO_POINTER_POSITION=VIDEO_POINTER_POSITION -_VIDEO_POINTER_ATTRIBUTES=VIDEO_POINTER_ATTRIBUTES -_VIDEO_POINTER_CAPABILITIES=VIDEO_POINTER_CAPABILITIES -_VIDEO_BANK_SELECT=VIDEO_BANK_SELECT -_VIDEO_BANK_TYPE=VIDEO_BANK_TYPE -_VIDEO_MEMORY=VIDEO_MEMORY -_VIDEO_SHARE_MEMORY=VIDEO_SHARE_MEMORY -_VIDEO_SHARE_MEMORY_INFORMATION=VIDEO_SHARE_MEMORY_INFORMATION -_VIDEO_MEMORY_INFORMATION=VIDEO_MEMORY_INFORMATION -_VIDEO_PUBLIC_ACCESS_RANGES=VIDEO_PUBLIC_ACCESS_RANGES -_VIDEO_COLOR_CAPABILITIES=VIDEO_COLOR_CAPABILITIES -_VIDEO_POWER_STATE=VIDEO_POWER_STATE -_VIDEO_POWER_MANAGEMENT=VIDEO_POWER_MANAGEMENT -_VIDEO_COLOR_LUT_DATA=VIDEO_COLOR_LUT_DATA -_VIDEO_LUT_RGB256WORDS=VIDEO_LUT_RGB256WORDS -_BANK_POSITION=BANK_POSITION -_DISPLAY_BRIGHTNESS=DISPLAY_BRIGHTNESS -_FSCNTL_SCREEN_INFO=FSCNTL_SCREEN_INFO -_FONT_IMAGE_INFO=FONT_IMAGE_INFO -_CHAR_IMAGE_INFO=CHAR_IMAGE_INFO -_VGA_CHAR=VGA_CHAR -_FSVIDEO_COPY_FRAME_BUFFER=FSVIDEO_COPY_FRAME_BUFFER -_FSVIDEO_WRITE_TO_FRAME_BUFFER=FSVIDEO_WRITE_TO_FRAME_BUFFER -_FSVIDEO_REVERSE_MOUSE_POINTER=FSVIDEO_REVERSE_MOUSE_POINTER -_FSVIDEO_MODE_INFORMATION=FSVIDEO_MODE_INFORMATION -_FSVIDEO_SCREEN_INFORMATION=FSVIDEO_SCREEN_INFORMATION -_FSVIDEO_CURSOR_POSITION=FSVIDEO_CURSOR_POSITION -_ENG_EVENT=ENG_EVENT -_VIDEO_PERFORMANCE_COUNTER=VIDEO_PERFORMANCE_COUNTER -_VIDEO_QUERY_PERFORMANCE_COUNTER=VIDEO_QUERY_PERFORMANCE_COUNTER -_BRIGHTNESS_INTERFACE_VERSION=BRIGHTNESS_INTERFACE_VERSION -_PANEL_QUERY_BRIGHTNESS_CAPS=PANEL_QUERY_BRIGHTNESS_CAPS -_BRIGHTNESS_LEVEL=BRIGHTNESS_LEVEL -_BRIGHTNESS_NIT_RANGE=BRIGHTNESS_NIT_RANGE -_PANEL_QUERY_BRIGHTNESS_RANGES=PANEL_QUERY_BRIGHTNESS_RANGES -_PANEL_GET_BRIGHTNESS=PANEL_GET_BRIGHTNESS -_CHROMATICITY_COORDINATE=CHROMATICITY_COORDINATE -_PANEL_BRIGHTNESS_SENSOR_DATA=PANEL_BRIGHTNESS_SENSOR_DATA -_PANEL_SET_BRIGHTNESS=PANEL_SET_BRIGHTNESS -_PANEL_SET_BRIGHTNESS_STATE=PANEL_SET_BRIGHTNESS_STATE -_BACKLIGHT_OPTIMIZATION_LEVEL=BACKLIGHT_OPTIMIZATION_LEVEL -_PANEL_SET_BACKLIGHT_OPTIMIZATION=PANEL_SET_BACKLIGHT_OPTIMIZATION -_BACKLIGHT_REDUCTION_GAMMA_RAMP=BACKLIGHT_REDUCTION_GAMMA_RAMP -_PANEL_GET_BACKLIGHT_REDUCTION=PANEL_GET_BACKLIGHT_REDUCTION -_COLORSPACE_TRANSFORM_DATA_TYPE=COLORSPACE_TRANSFORM_DATA_TYPE -_COLORSPACE_TRANSFORM_DATA_CAP=COLORSPACE_TRANSFORM_DATA_CAP -_COLORSPACE_TRANSFORM_1DLUT_CAP=COLORSPACE_TRANSFORM_1DLUT_CAP -_COLORSPACE_TRANSFORM_MATRIX_CAP=COLORSPACE_TRANSFORM_MATRIX_CAP -_COLORSPACE_TRANSFORM_TARGET_CAPS_VERSION=COLORSPACE_TRANSFORM_TARGET_CAPS_VERSION -_COLORSPACE_TRANSFORM_TARGET_CAPS=COLORSPACE_TRANSFORM_TARGET_CAPS -_COLORSPACE_TRANSFORM_TYPE=COLORSPACE_TRANSFORM_TYPE -_GAMMA_RAMP_RGB256x3x16=GAMMA_RAMP_RGB256x3x16 -_GAMMA_RAMP_RGB=GAMMA_RAMP_RGB -_GAMMA_RAMP_DXGI_1=GAMMA_RAMP_DXGI_1 -_COLORSPACE_TRANSFORM_3x4=COLORSPACE_TRANSFORM_3x4 -_OUTPUT_WIRE_COLOR_SPACE_TYPE=OUTPUT_WIRE_COLOR_SPACE_TYPE -_OUTPUT_COLOR_ENCODING=OUTPUT_COLOR_ENCODING -_OUTPUT_WIRE_FORMAT=OUTPUT_WIRE_FORMAT -_COLORSPACE_TRANSFORM_STAGE_CONTROL=COLORSPACE_TRANSFORM_STAGE_CONTROL -_COLORSPACE_TRANSFORM_MATRIX_V2=COLORSPACE_TRANSFORM_MATRIX_V2 -_COLORSPACE_TRANSFORM=COLORSPACE_TRANSFORM -_COLORSPACE_TRANSFORM_SET_INPUT=COLORSPACE_TRANSFORM_SET_INPUT -_SET_ACTIVE_COLOR_PROFILE_NAME=SET_ACTIVE_COLOR_PROFILE_NAME -_MIPI_DSI_CAPS=MIPI_DSI_CAPS -_DSI_CONTROL_TRANSMISSION_MODE=DSI_CONTROL_TRANSMISSION_MODE -_MIPI_DSI_PACKET=MIPI_DSI_PACKET -_MIPI_DSI_TRANSMISSION=MIPI_DSI_TRANSMISSION -_MIPI_DSI_RESET=MIPI_DSI_RESET -_DDARGB=DDARGB -_DDRGBA=DDRGBA -_DDCOLORKEY=DDCOLORKEY -_DDBLTFX=DDBLTFX -_DDSCAPS=DDSCAPS -_DDOSCAPS=DDOSCAPS -_DDSCAPSEX=DDSCAPSEX -_DDSCAPS2=DDSCAPS2 -_DDCAPS_DX1=DDCAPS_DX1 -_DDCAPS_DX3=DDCAPS_DX3 -_DDCAPS_DX5=DDCAPS_DX5 -_DDCAPS_DX6=DDCAPS_DX6 -_DDCAPS_DX7=DDCAPS_DX7 -_DDPIXELFORMAT=DDPIXELFORMAT -_DDOVERLAYFX=DDOVERLAYFX -_DDBLTBATCH=DDBLTBATCH -_DDGAMMARAMP=DDGAMMARAMP -tagDDDEVICEIDENTIFIER=DDDEVICEIDENTIFIER -tagDDDEVICEIDENTIFIER2=DDDEVICEIDENTIFIER2 -_DDSURFACEDESC=DDSURFACEDESC -_DDSURFACEDESC2=DDSURFACEDESC2 -_DDOPTSURFACEDESC=DDOPTSURFACEDESC -_DDCOLORCONTROL=DDCOLORCONTROL -_AM_LINE21_CCLEVEL=AM_LINE21_CCLEVEL -_AM_LINE21_CCSERVICE=AM_LINE21_CCSERVICE -_AM_LINE21_CCSTATE=AM_LINE21_CCSTATE -_AM_LINE21_CCSTYLE=AM_LINE21_CCSTYLE -_AM_LINE21_DRAWBGMODE=AM_LINE21_DRAWBGMODE -_AM_WST_PAGE=AM_WST_PAGE -_AM_WST_LEVEL=AM_WST_LEVEL -_AM_WST_SERVICE=AM_WST_SERVICE -_AM_WST_STATE=AM_WST_STATE -_AM_WST_STYLE=AM_WST_STYLE -_AM_WST_DRAWBGMODE=AM_WST_DRAWBGMODE -tagVIDEOINFO=VIDEOINFO -_AM_FRAMESTEP_STEP=AM_FRAMESTEP_STEP -_AM_ASPECT_RATIO_MODE=AM_ASPECT_RATIO_MODE -tagAM_MPEGSTREAMTYPE=AM_MPEGSTREAMTYPE -tagAM_MPEGSYSTEMTYPE=AM_MPEGSYSTEMTYPE -_VMR9PresentationInfo=VMR9PresentationInfo -_VMR9AllocationInfo=VMR9AllocationInfo -_VMR9NormalizedRect=VMR9NormalizedRect -_VMR9ProcAmpControl=VMR9ProcAmpControl -_VMR9ProcAmpControlRange=VMR9ProcAmpControlRange -_VMR9AlphaBitmap=VMR9AlphaBitmap -_VMR9MonitorInfo=VMR9MonitorInfo -_VMR9Frequency=VMR9Frequency -_VMR9_SampleFormat=VMR9_SampleFormat -_VMR9VideoDesc=VMR9VideoDesc -_VMR9DeinterlaceCaps=VMR9DeinterlaceCaps -_VMR9VideoStreamInfo=VMR9VideoStreamInfo -_MP_CURVE_TYPE=MP_CURVE_TYPE -_MP_PARAMINFO=MP_PARAMINFO -_MP_ENVELOPE_SEGMENT=MP_ENVELOPE_SEGMENT -_DMO_PARTIAL_MEDIATYPE=DMO_PARTIAL_MEDIATYPE -_DWM_BLURBEHIND=DWM_BLURBEHIND -_DWM_THUMBNAIL_PROPERTIES=DWM_THUMBNAIL_PROPERTIES -_UNSIGNED_RATIO=UNSIGNED_RATIO -_DWM_TIMING_INFO=DWM_TIMING_INFO -_DWM_PRESENT_PARAMETERS=DWM_PRESENT_PARAMETERS -_MilMatrix3x2D=MilMatrix3x2D -_NgcTicketContext=NgcTicketContext -_RAS_AUTH_ATTRIBUTE=RAS_AUTH_ATTRIBUTE -_PPP_EAP_PACKET=PPP_EAP_PACKET -_PPP_EAP_INPUT=PPP_EAP_INPUT -_PPP_EAP_ACTION=PPP_EAP_ACTION -_PPP_EAP_OUTPUT=PPP_EAP_OUTPUT -_PPP_EAP_INFO=PPP_EAP_INFO -_LEGACY_IDENTITY_UI_PARAMS=LEGACY_IDENTITY_UI_PARAMS -_LEGACY_INTERACTIVE_UI_PARAMS=LEGACY_INTERACTIVE_UI_PARAMS -tagEapPeerMethodResult=EapPeerMethodResult -_EAP_PEER_METHOD_ROUTINES=EAP_PEER_METHOD_ROUTINES -_EAP_AUTHENTICATOR_METHOD_ROUTINES=EAP_AUTHENTICATOR_METHOD_ROUTINES -_ACT_AUTHORIZATION_STATE=ACT_AUTHORIZATION_STATE -_SILO_INFO=SILO_INFO -_ACT_AUTHORIZATION_STATE_VALUE=ACT_AUTHORIZATION_STATE_VALUE -tagNETCON_CHARACTERISTIC_FLAGS=NETCON_CHARACTERISTIC_FLAGS -tagNETCON_STATUS=NETCON_STATUS -tagNETCON_TYPE=NETCON_TYPE -tagNETCON_MEDIATYPE=NETCON_MEDIATYPE -tagNETCON_PROPERTIES=NETCON_PROPERTIES -tagNETCONMGR_ENUM_FLAGS=NETCONMGR_ENUM_FLAGS -tagNETCONUI_CONNECT_FLAGS=NETCONUI_CONNECT_FLAGS -tagSHARINGCONNECTIONTYPE=SHARINGCONNECTIONTYPE -tagSHARINGCONNECTION_ENUM_FLAGS=SHARINGCONNECTION_ENUM_FLAGS -tagICS_TARGETTYPE=ICS_TARGETTYPE -_INET_FIREWALL_AC_CREATION_TYPE=INET_FIREWALL_AC_CREATION_TYPE -_INET_FIREWALL_AC_CHANGE_TYPE=INET_FIREWALL_AC_CHANGE_TYPE -_INET_FIREWALL_AC_CAPABILITIES=INET_FIREWALL_AC_CAPABILITIES -_INET_FIREWALL_AC_BINARIES=INET_FIREWALL_AC_BINARIES -_INET_FIREWALL_AC_CHANGE=INET_FIREWALL_AC_CHANGE -_INET_FIREWALL_APP_CONTAINER=INET_FIREWALL_APP_CONTAINER -_NETISO_ERROR_TYPE=NETISO_ERROR_TYPE -_IMAPI_MEDIA_PHYSICAL_TYPE=IMAPI_MEDIA_PHYSICAL_TYPE -_IMAPI_MEDIA_WRITE_PROTECT_STATE=IMAPI_MEDIA_WRITE_PROTECT_STATE -_IMAPI_READ_TRACK_ADDRESS_TYPE=IMAPI_READ_TRACK_ADDRESS_TYPE -_IMAPI_MODE_PAGE_REQUEST_TYPE=IMAPI_MODE_PAGE_REQUEST_TYPE -_IMAPI_MODE_PAGE_TYPE=IMAPI_MODE_PAGE_TYPE -_IMAPI_FEATURE_PAGE_TYPE=IMAPI_FEATURE_PAGE_TYPE -_IMAPI_PROFILE_TYPE=IMAPI_PROFILE_TYPE -_IMAPI_FORMAT2_DATA_WRITE_ACTION=IMAPI_FORMAT2_DATA_WRITE_ACTION -_IMAPI_FORMAT2_DATA_MEDIA_STATE=IMAPI_FORMAT2_DATA_MEDIA_STATE -_IMAPI_FORMAT2_TAO_WRITE_ACTION=IMAPI_FORMAT2_TAO_WRITE_ACTION -_IMAPI_FORMAT2_RAW_CD_DATA_SECTOR_TYPE=IMAPI_FORMAT2_RAW_CD_DATA_SECTOR_TYPE -_IMAPI_FORMAT2_RAW_CD_WRITE_ACTION=IMAPI_FORMAT2_RAW_CD_WRITE_ACTION -_IMAPI_CD_SECTOR_TYPE=IMAPI_CD_SECTOR_TYPE -_IMAPI_CD_TRACK_DIGITAL_COPY_SETTING=IMAPI_CD_TRACK_DIGITAL_COPY_SETTING -_IMAPI_BURN_VERIFICATION_LEVEL=IMAPI_BURN_VERIFICATION_LEVEL -_CI_STATE=CI_STATE -tagFULLPROPSPEC=FULLPROPSPEC -tagIFILTER_INIT=IFILTER_INIT -tagIFILTER_FLAGS=IFILTER_FLAGS -tagCHUNKSTATE=CHUNKSTATE -tagCHUNK_BREAKTYPE=CHUNK_BREAKTYPE -tagFILTERREGION=FILTERREGION -tagSTAT_CHUNK=STAT_CHUNK -_MAPPING_SERVICE_INFO=MAPPING_SERVICE_INFO -_MAPPING_ENUM_OPTIONS=MAPPING_ENUM_OPTIONS -_MAPPING_OPTIONS=MAPPING_OPTIONS -_MAPPING_DATA_RANGE=MAPPING_DATA_RANGE -_MAPPING_PROPERTY_BAG=MAPPING_PROPERTY_BAG -_IMEDLG=IMEDLG -tagWDD=WDD -tagMORRSLT=MORRSLT -_IMEWRD=IMEWRD -_IMESHF=IMESHF -_POSTBL=POSTBL -_IMEDP=IMEDP -tagIMEKMSINIT=IMEKMSINIT -tagIMEKMSKEY=IMEKMSKEY -tagIMEKMS=IMEKMS -tagIMEKMSNTFY=IMEKMSNTFY -tagIMEKMSKMP=IMEKMSKMP -tagIMEKMSINVK=IMEKMSINVK -tagIMEKMSFUNCDESC=IMEKMSFUNCDESC -tagCOMPOSITIONSTRING=COMPOSITIONSTRING -tagGUIDELINE=GUIDELINE -tagTRANSMSG=TRANSMSG -tagTRANSMSGLIST=TRANSMSGLIST -tagCANDIDATEINFO=CANDIDATEINFO -tagINPUTCONTEXT=INPUTCONTEXT -tagIMEINFO=IMEINFO -tagSOFTKBDDATA=SOFTKBDDATA -tagAPPLETIDLIST=APPLETIDLIST -tagIMESTRINGCANDIDATE=IMESTRINGCANDIDATE -tagIMEITEM=IMEITEM -tagIMEITEMCANDIDATE=IMEITEMCANDIDATE -tagIMESTRINGCANDIDATEINFO=IMESTRINGCANDIDATEINFO -tagIMECOMPOSITIONSTRINGINFO=IMECOMPOSITIONSTRINGINFO -tagIMECHARINFO=IMECHARINFO -tagIMEAPPLETUI=IMEAPPLETUI -tagAPPLYCANDEXPARAM=APPLYCANDEXPARAM -tagGOFFSET=GOFFSET -_SERVERXMLHTTP_OPTION=SERVERXMLHTTP_OPTION -_SXH_SERVER_CERT_OPTION=SXH_SERVER_CERT_OPTION -_SXH_PROXY_SETTING=SXH_PROXY_SETTING -_SOMITEMTYPE=SOMITEMTYPE -_SCHEMAUSE=SCHEMAUSE -_SCHEMADERIVATIONMETHOD=SCHEMADERIVATIONMETHOD -_SCHEMACONTENTTYPE=SCHEMACONTENTTYPE -_SCHEMAPROCESSCONTENTS=SCHEMAPROCESSCONTENTS -_SCHEMAWHITESPACE=SCHEMAWHITESPACE -_SCHEMATYPEVARIETY=SCHEMATYPEVARIETY -_XHR_COOKIE_STATE=XHR_COOKIE_STATE -_XHR_COOKIE_FLAG=XHR_COOKIE_FLAG -_XHR_CRED_PROMPT=XHR_CRED_PROMPT -_XHR_AUTH=XHR_AUTH -_XHR_PROPERTY=XHR_PROPERTY -_XHR_CERT_IGNORE_FLAG=XHR_CERT_IGNORE_FLAG -_XHR_CERT_ERROR_FLAG=XHR_CERT_ERROR_FLAG -tagXHR_COOKIE=XHR_COOKIE -tagXHR_CERT=XHR_CERT -_QUAD=QUAD -_EVENT_TYPE=EVENT_TYPE -_TIMER_TYPE=TIMER_TYPE -_WAIT_TYPE=WAIT_TYPE -_CSTRING=CSTRING -_RTL_BALANCED_NODE=RTL_BALANCED_NODE -_SINGLE_LIST_ENTRY=SINGLE_LIST_ENTRY -_SINGLE_LIST_ENTRY32=SINGLE_LIST_ENTRY32 -_WNF_STATE_NAME=WNF_STATE_NAME -_STRING32=STRING32 -_STRING64=STRING64 -_OBJECT_ATTRIBUTES64=OBJECT_ATTRIBUTES64 -_OBJECT_ATTRIBUTES32=OBJECT_ATTRIBUTES32 -_NT_PRODUCT_TYPE=NT_PRODUCT_TYPE -_SUITE_TYPE=SUITE_TYPE -tagMAGTRANSFORM=MAGTRANSFORM -tagMAGIMAGEHEADER=MAGIMAGEHEADER -tagMAGCOLOREFFECT=MAGCOLOREFFECT -_MANAGEMENT_SERVICE_INFO=MANAGEMENT_SERVICE_INFO -_MANAGEMENT_REGISTRATION_INFO=MANAGEMENT_REGISTRATION_INFO -_REGISTRATION_INFORMATION_CLASS=REGISTRATION_INFORMATION_CLASS -tagAecQualityMetrics_Struct=AecQualityMetrics_Struct -_MFVideoDSPMode=MFVideoDSPMode -_TOC_DESCRIPTOR=TOC_DESCRIPTOR -_TOC_ENTRY_DESCRIPTOR=TOC_ENTRY_DESCRIPTOR -_DXVAHD_FRAME_FORMAT=DXVAHD_FRAME_FORMAT -_DXVAHD_DEVICE_USAGE=DXVAHD_DEVICE_USAGE -_DXVAHD_SURFACE_TYPE=DXVAHD_SURFACE_TYPE -_DXVAHD_DEVICE_TYPE=DXVAHD_DEVICE_TYPE -_DXVAHD_DEVICE_CAPS=DXVAHD_DEVICE_CAPS -_DXVAHD_FEATURE_CAPS=DXVAHD_FEATURE_CAPS -_DXVAHD_FILTER_CAPS=DXVAHD_FILTER_CAPS -_DXVAHD_INPUT_FORMAT_CAPS=DXVAHD_INPUT_FORMAT_CAPS -_DXVAHD_PROCESSOR_CAPS=DXVAHD_PROCESSOR_CAPS -_DXVAHD_ITELECINE_CAPS=DXVAHD_ITELECINE_CAPS -_DXVAHD_FILTER=DXVAHD_FILTER -_DXVAHD_BLT_STATE=DXVAHD_BLT_STATE -_DXVAHD_ALPHA_FILL_MODE=DXVAHD_ALPHA_FILL_MODE -_DXVAHD_STREAM_STATE=DXVAHD_STREAM_STATE -_DXVAHD_OUTPUT_RATE=DXVAHD_OUTPUT_RATE -_DXVAHD_RATIONAL=DXVAHD_RATIONAL -_DXVAHD_COLOR_RGBA=DXVAHD_COLOR_RGBA -_DXVAHD_COLOR_YCbCrA=DXVAHD_COLOR_YCbCrA -_DXVAHD_COLOR=DXVAHD_COLOR -_DXVAHD_CONTENT_DESC=DXVAHD_CONTENT_DESC -_DXVAHD_VPDEVCAPS=DXVAHD_VPDEVCAPS -_DXVAHD_VPCAPS=DXVAHD_VPCAPS -_DXVAHD_CUSTOM_RATE_DATA=DXVAHD_CUSTOM_RATE_DATA -_DXVAHD_FILTER_RANGE_DATA=DXVAHD_FILTER_RANGE_DATA -_DXVAHD_BLT_STATE_TARGET_RECT_DATA=DXVAHD_BLT_STATE_TARGET_RECT_DATA -_DXVAHD_BLT_STATE_BACKGROUND_COLOR_DATA=DXVAHD_BLT_STATE_BACKGROUND_COLOR_DATA -_DXVAHD_BLT_STATE_OUTPUT_COLOR_SPACE_DATA=DXVAHD_BLT_STATE_OUTPUT_COLOR_SPACE_DATA -_DXVAHD_BLT_STATE_ALPHA_FILL_DATA=DXVAHD_BLT_STATE_ALPHA_FILL_DATA -_DXVAHD_BLT_STATE_CONSTRICTION_DATA=DXVAHD_BLT_STATE_CONSTRICTION_DATA -_DXVAHD_BLT_STATE_PRIVATE_DATA=DXVAHD_BLT_STATE_PRIVATE_DATA -_DXVAHD_STREAM_STATE_D3DFORMAT_DATA=DXVAHD_STREAM_STATE_D3DFORMAT_DATA -_DXVAHD_STREAM_STATE_FRAME_FORMAT_DATA=DXVAHD_STREAM_STATE_FRAME_FORMAT_DATA -_DXVAHD_STREAM_STATE_INPUT_COLOR_SPACE_DATA=DXVAHD_STREAM_STATE_INPUT_COLOR_SPACE_DATA -_DXVAHD_STREAM_STATE_OUTPUT_RATE_DATA=DXVAHD_STREAM_STATE_OUTPUT_RATE_DATA -_DXVAHD_STREAM_STATE_SOURCE_RECT_DATA=DXVAHD_STREAM_STATE_SOURCE_RECT_DATA -_DXVAHD_STREAM_STATE_DESTINATION_RECT_DATA=DXVAHD_STREAM_STATE_DESTINATION_RECT_DATA -_DXVAHD_STREAM_STATE_ALPHA_DATA=DXVAHD_STREAM_STATE_ALPHA_DATA -_DXVAHD_STREAM_STATE_PALETTE_DATA=DXVAHD_STREAM_STATE_PALETTE_DATA -_DXVAHD_STREAM_STATE_LUMA_KEY_DATA=DXVAHD_STREAM_STATE_LUMA_KEY_DATA -_DXVAHD_STREAM_STATE_ASPECT_RATIO_DATA=DXVAHD_STREAM_STATE_ASPECT_RATIO_DATA -_DXVAHD_STREAM_STATE_FILTER_DATA=DXVAHD_STREAM_STATE_FILTER_DATA -_DXVAHD_STREAM_STATE_PRIVATE_DATA=DXVAHD_STREAM_STATE_PRIVATE_DATA -_DXVAHD_STREAM_DATA=DXVAHD_STREAM_DATA -_DXVAHD_STREAM_STATE_PRIVATE_IVTC_DATA=DXVAHD_STREAM_STATE_PRIVATE_IVTC_DATA -_DXVAHDSW_CALLBACKS=DXVAHDSW_CALLBACKS -_DXVAHDETW_CREATEVIDEOPROCESSOR=DXVAHDETW_CREATEVIDEOPROCESSOR -_DXVAHDETW_VIDEOPROCESSBLTSTATE=DXVAHDETW_VIDEOPROCESSBLTSTATE -_DXVAHDETW_VIDEOPROCESSSTREAMSTATE=DXVAHDETW_VIDEOPROCESSSTREAMSTATE -_DXVAHDETW_VIDEOPROCESSBLTHD=DXVAHDETW_VIDEOPROCESSBLTHD -_DXVAHDETW_VIDEOPROCESSBLTHD_STREAM=DXVAHDETW_VIDEOPROCESSBLTHD_STREAM -_DXVAHDETW_DESTROYVIDEOPROCESSOR=DXVAHDETW_DESTROYVIDEOPROCESSOR -_DXVA2_ExtendedFormat=DXVA2_ExtendedFormat -_DXVA2_SampleFormat=DXVA2_SampleFormat -_DXVA2_VideoChromaSubSampling=DXVA2_VideoChromaSubSampling -_DXVA2_NominalRange=DXVA2_NominalRange -_DXVA2_VideoTransferMatrix=DXVA2_VideoTransferMatrix -_DXVA2_VideoLighting=DXVA2_VideoLighting -_DXVA2_VideoPrimaries=DXVA2_VideoPrimaries -_DXVA2_VideoTransferFunction=DXVA2_VideoTransferFunction -_DXVA2_Frequency=DXVA2_Frequency -_DXVA2_VideoDesc=DXVA2_VideoDesc -_DXVA2_VideoProcessorCaps=DXVA2_VideoProcessorCaps -_DXVA2_Fixed32=DXVA2_Fixed32 -_DXVA2_AYUVSample8=DXVA2_AYUVSample8 -_DXVA2_AYUVSample16=DXVA2_AYUVSample16 -_DXVA2_VideoSample=DXVA2_VideoSample -_DXVA2_ValueRange=DXVA2_ValueRange -_DXVA2_ProcAmpValues=DXVA2_ProcAmpValues -_DXVA2_FilterValues=DXVA2_FilterValues -_DXVA2_VideoProcessBltParams=DXVA2_VideoProcessBltParams -_DXVA2_ConfigPictureDecode=DXVA2_ConfigPictureDecode -_DXVA2_DecodeBufferDesc=DXVA2_DecodeBufferDesc -_DXVA2_AES_CTR_IV=DXVA2_AES_CTR_IV -_DXVA2_DecodeExtensionData=DXVA2_DecodeExtensionData -_DXVA2_DecodeExecuteParams=DXVA2_DecodeExecuteParams -_OPM_VIDEO_OUTPUT_SEMANTICS=OPM_VIDEO_OUTPUT_SEMANTICS -_OPM_OUTPUT_HARDWARE_PROTECTION=OPM_OUTPUT_HARDWARE_PROTECTION -_OPM_DPCP_PROTECTION_LEVEL=OPM_DPCP_PROTECTION_LEVEL -_OPM_HDCP_PROTECTION_LEVEL=OPM_HDCP_PROTECTION_LEVEL -_OPM_TYPE_ENFORCEMENT_HDCP_PROTECTION_LEVEL=OPM_TYPE_ENFORCEMENT_HDCP_PROTECTION_LEVEL -_OPM_ACP_PROTECTION_LEVEL=OPM_ACP_PROTECTION_LEVEL -_OPM_IMAGE_ASPECT_RATIO_EN300294=OPM_IMAGE_ASPECT_RATIO_EN300294 -_OPM_RANDOM_NUMBER=OPM_RANDOM_NUMBER -_OPM_OMAC=OPM_OMAC -_OPM_ENCRYPTED_INITIALIZATION_PARAMETERS=OPM_ENCRYPTED_INITIALIZATION_PARAMETERS -_OPM_GET_INFO_PARAMETERS=OPM_GET_INFO_PARAMETERS -_OPM_COPP_COMPATIBLE_GET_INFO_PARAMETERS=OPM_COPP_COMPATIBLE_GET_INFO_PARAMETERS -_OPM_HDCP_KEY_SELECTION_VECTOR=OPM_HDCP_KEY_SELECTION_VECTOR -_OPM_CONNECTED_HDCP_DEVICE_INFORMATION=OPM_CONNECTED_HDCP_DEVICE_INFORMATION -_OPM_REQUESTED_INFORMATION=OPM_REQUESTED_INFORMATION -_OPM_STANDARD_INFORMATION=OPM_STANDARD_INFORMATION -_OPM_ACTUAL_OUTPUT_FORMAT=OPM_ACTUAL_OUTPUT_FORMAT -_OPM_ACP_AND_CGMSA_SIGNALING=OPM_ACP_AND_CGMSA_SIGNALING -_OPM_OUTPUT_ID_DATA=OPM_OUTPUT_ID_DATA -_OPM_CONFIGURE_PARAMETERS=OPM_CONFIGURE_PARAMETERS -_OPM_SET_PROTECTION_LEVEL_PARAMETERS=OPM_SET_PROTECTION_LEVEL_PARAMETERS -_OPM_SET_ACP_AND_CGMSA_SIGNALING_PARAMETERS=OPM_SET_ACP_AND_CGMSA_SIGNALING_PARAMETERS -_OPM_SET_HDCP_SRM_PARAMETERS=OPM_SET_HDCP_SRM_PARAMETERS -_OPM_GET_CODEC_INFO_PARAMETERS=OPM_GET_CODEC_INFO_PARAMETERS -_OPM_GET_CODEC_INFO_INFORMATION=OPM_GET_CODEC_INFO_INFORMATION -_MFMPEG2DLNASINKSTATS=MFMPEG2DLNASINKSTATS -_MFVideoMixPrefs=MFVideoMixPrefs -_MF_SERVICE_LOOKUP_TYPE=MF_SERVICE_LOOKUP_TYPE -_MMC_PROPERTY_ACTION=MMC_PROPERTY_ACTION -_MMC_SNAPIN_PROPERTY=MMC_SNAPIN_PROPERTY -_MMC_RESULT_VIEW_STYLE=MMC_RESULT_VIEW_STYLE -_MMC_CONTROL_TYPE=MMC_CONTROL_TYPE -_MMC_CONSOLE_VERB=MMC_CONSOLE_VERB -_MMC_BUTTON_STATE=MMC_BUTTON_STATE -_RESULTDATAITEM=RESULTDATAITEM -_RESULTFINDINFO=RESULTFINDINFO -_SCOPEDATAITEM=SCOPEDATAITEM -_MMC_SCOPE_ITEM_STATE=MMC_SCOPE_ITEM_STATE -_CONTEXTMENUITEM=CONTEXTMENUITEM -_MMC_MENU_COMMAND_IDS=MMC_MENU_COMMAND_IDS -_MENUBUTTONDATA=MENUBUTTONDATA -_MMC_FILTER_TYPE=MMC_FILTER_TYPE -_MMC_FILTERDATA=MMC_FILTERDATA -_MMC_FILTER_CHANGE_CODE=MMC_FILTER_CHANGE_CODE -_MMC_RESTORE_VIEW=MMC_RESTORE_VIEW -_MMC_EXPANDSYNC_STRUCT=MMC_EXPANDSYNC_STRUCT -_MMC_VISIBLE_COLUMNS=MMC_VISIBLE_COLUMNS -_MMC_NOTIFY_TYPE=MMC_NOTIFY_TYPE -_DATA_OBJECT_TYPES=DATA_OBJECT_TYPES -_SMMCDataObjects=SMMCDataObjects -_SMMCObjectTypes=SMMCObjectTypes -_SNodeID=SNodeID -_SNodeID2=SNodeID2 -_SColumnSetID=SColumnSetID -_MMC_TASK_DISPLAY_TYPE=MMC_TASK_DISPLAY_TYPE -_MMC_TASK_DISPLAY_SYMBOL=MMC_TASK_DISPLAY_SYMBOL -_MMC_TASK_DISPLAY_BITMAP=MMC_TASK_DISPLAY_BITMAP -_MMC_TASK_DISPLAY_OBJECT=MMC_TASK_DISPLAY_OBJECT -_MMC_ACTION_TYPE=MMC_ACTION_TYPE -_MMC_TASK=MMC_TASK -_MMC_LISTPAD_INFO=MMC_LISTPAD_INFO -_MMC_COLUMN_DATA=MMC_COLUMN_DATA -_MMC_COLUMN_SET_DATA=MMC_COLUMN_SET_DATA -_MMC_SORT_DATA=MMC_SORT_DATA -_MMC_SORT_SET_DATA=MMC_SORT_SET_DATA -tagIconIdentifier=IconIdentifier -_RDCOMPARE=RDCOMPARE -_MMC_VIEW_TYPE=MMC_VIEW_TYPE -_RESULT_VIEW_TYPE_INFO=RESULT_VIEW_TYPE_INFO -_CONTEXTMENUITEM2=CONTEXTMENUITEM2 -_MMC_EXT_VIEW_DATA=MMC_EXT_VIEW_DATA -_PHYSICAL_MONITOR=PHYSICAL_MONITOR -_MC_TIMING_REPORT=MC_TIMING_REPORT -_MC_VCP_CODE_TYPE=MC_VCP_CODE_TYPE -_MC_DISPLAY_TECHNOLOGY_TYPE=MC_DISPLAY_TECHNOLOGY_TYPE -_MC_DRIVE_TYPE=MC_DRIVE_TYPE -_MC_GAIN_TYPE=MC_GAIN_TYPE -_MC_POSITION_TYPE=MC_POSITION_TYPE -_MC_SIZE_TYPE=MC_SIZE_TYPE -_MC_COLOR_TEMPERATURE=MC_COLOR_TEMPERATURE -_CYPHER_BLOCK=CYPHER_BLOCK -_LM_OWF_PASSWORD=LM_OWF_PASSWORD -_SAMPR_ENCRYPTED_USER_PASSWORD=SAMPR_ENCRYPTED_USER_PASSWORD -_ENCRYPTED_LM_OWF_PASSWORD=ENCRYPTED_LM_OWF_PASSWORD -_CLUSTER_REG_COMMAND=CLUSTER_REG_COMMAND -_CLUSCTL_RESOURCE_STATE_CHANGE_REASON_STRUCT=CLUSCTL_RESOURCE_STATE_CHANGE_REASON_STRUCT -_CLUSTER_BATCH_COMMAND=CLUSTER_BATCH_COMMAND -_CLUSTER_READ_BATCH_COMMAND=CLUSTER_READ_BATCH_COMMAND -_CLUSTER_ENUM_ITEM=CLUSTER_ENUM_ITEM -_CLUSTER_CREATE_GROUP_INFO=CLUSTER_CREATE_GROUP_INFO -_CLUSTER_VALIDATE_PATH=CLUSTER_VALIDATE_PATH -_CLUSTER_VALIDATE_DIRECTORY=CLUSTER_VALIDATE_DIRECTORY -_CLUSTER_VALIDATE_NETNAME=CLUSTER_VALIDATE_NETNAME -_CLUSTER_VALIDATE_CSV_FILENAME=CLUSTER_VALIDATE_CSV_FILENAME -_CLUSTER_IP_ENTRY=CLUSTER_IP_ENTRY -_CREATE_CLUSTER_CONFIG=CREATE_CLUSTER_CONFIG -_CREATE_CLUSTER_NAME_ACCOUNT=CREATE_CLUSTER_NAME_ACCOUNT -_CLUSTER_UPGRADE_PHASE=CLUSTER_UPGRADE_PHASE -_NOTIFY_FILTER_AND_TYPE=NOTIFY_FILTER_AND_TYPE -_CLUSTER_MEMBERSHIP_INFO=CLUSTER_MEMBERSHIP_INFO -_CLUSTER_GROUP_ENUM_ITEM=CLUSTER_GROUP_ENUM_ITEM -_CLUSTER_RESOURCE_ENUM_ITEM=CLUSTER_RESOURCE_ENUM_ITEM -_CLUSTER_CSV_VOLUME_FAULT_STATE=CLUSTER_CSV_VOLUME_FAULT_STATE -_CLUSTER_SHARED_VOLUME_BACKUP_STATE=CLUSTER_SHARED_VOLUME_BACKUP_STATE -_CLUS_CSV_VOLUME_INFO=CLUS_CSV_VOLUME_INFO -_CLUS_CSV_VOLUME_NAME=CLUS_CSV_VOLUME_NAME -_CLUSTER_SHARED_VOLUME_STATE=CLUSTER_SHARED_VOLUME_STATE -_CLUSTER_SHARED_VOLUME_STATE_INFO=CLUSTER_SHARED_VOLUME_STATE_INFO -_CLUSTER_SHARED_VOLUME_STATE_INFO_EX=CLUSTER_SHARED_VOLUME_STATE_INFO_EX -_CLUSTER_SHARED_VOLUME_RENAME_INPUT_TYPE=CLUSTER_SHARED_VOLUME_RENAME_INPUT_TYPE -_CLUSTER_SHARED_VOLUME_RENAME_INPUT_VOLUME=CLUSTER_SHARED_VOLUME_RENAME_INPUT_VOLUME -_CLUSTER_SHARED_VOLUME_RENAME_INPUT_NAME=CLUSTER_SHARED_VOLUME_RENAME_INPUT_NAME -_CLUSTER_SHARED_VOLUME_RENAME_INPUT_GUID_NAME=CLUSTER_SHARED_VOLUME_RENAME_INPUT_GUID_NAME -_CLUSTER_SHARED_VOLUME_RENAME_INPUT=CLUSTER_SHARED_VOLUME_RENAME_INPUT -_CLUSTER_SHARED_VOLUME_RENAME_GUID_INPUT=CLUSTER_SHARED_VOLUME_RENAME_GUID_INPUT -_CLUS_CHKDSK_INFO=CLUS_CHKDSK_INFO -_CLUS_DISK_NUMBER_INFO=CLUS_DISK_NUMBER_INFO -_CLUS_SHARED_VOLUME_BACKUP_MODE=CLUS_SHARED_VOLUME_BACKUP_MODE -_MAINTENANCE_MODE_TYPE_ENUM=MAINTENANCE_MODE_TYPE_ENUM -_CLUS_MAINTENANCE_MODE_INFOEX=CLUS_MAINTENANCE_MODE_INFOEX -_CLUS_SET_MAINTENANCE_MODE_INPUT=CLUS_SET_MAINTENANCE_MODE_INPUT -_CLUS_STORAGE_SET_DRIVELETTER=CLUS_STORAGE_SET_DRIVELETTER -_CLUS_STORAGE_GET_AVAILABLE_DRIVELETTERS=CLUS_STORAGE_GET_AVAILABLE_DRIVELETTERS -_CLUS_STORAGE_REMAP_DRIVELETTER=CLUS_STORAGE_REMAP_DRIVELETTER -_CLUS_PROVIDER_STATE_CHANGE_INFO=CLUS_PROVIDER_STATE_CHANGE_INFO -_CLUS_CREATE_INFRASTRUCTURE_FILESERVER_INPUT=CLUS_CREATE_INFRASTRUCTURE_FILESERVER_INPUT -_CLUS_CREATE_INFRASTRUCTURE_FILESERVER_OUTPUT=CLUS_CREATE_INFRASTRUCTURE_FILESERVER_OUTPUT -_FILESHARE_CHANGE_ENUM=FILESHARE_CHANGE_ENUM -_FILESHARE_CHANGE=FILESHARE_CHANGE -_FILESHARE_CHANGE_LIST=FILESHARE_CHANGE_LIST -_CLUSCTL_GROUP_GET_LAST_MOVE_TIME_OUTPUT=CLUSCTL_GROUP_GET_LAST_MOVE_TIME_OUTPUT -_CLUSTER_SETUP_PHASE=CLUSTER_SETUP_PHASE -_CLUSTER_SETUP_PHASE_TYPE=CLUSTER_SETUP_PHASE_TYPE -_CLUSTER_SETUP_PHASE_SEVERITY=CLUSTER_SETUP_PHASE_SEVERITY -_SR_RESOURCE_TYPE_REPLICATED_PARTITION_INFO=SR_RESOURCE_TYPE_REPLICATED_PARTITION_INFO -_SR_RESOURCE_TYPE_REPLICATED_PARTITION_ARRAY=SR_RESOURCE_TYPE_REPLICATED_PARTITION_ARRAY -_SR_REPLICATED_DISK_TYPE=SR_REPLICATED_DISK_TYPE -_SR_DISK_REPLICATION_ELIGIBLE=SR_DISK_REPLICATION_ELIGIBLE -_SR_RESOURCE_TYPE_QUERY_ELIGIBLE_LOGDISKS=SR_RESOURCE_TYPE_QUERY_ELIGIBLE_LOGDISKS -_SR_RESOURCE_TYPE_DISK_INFO=SR_RESOURCE_TYPE_DISK_INFO -_SR_RESOURCE_TYPE_ELIGIBLE_DISKS_RESULT=SR_RESOURCE_TYPE_ELIGIBLE_DISKS_RESULT -_SR_RESOURCE_TYPE_REPLICATED_DISK=SR_RESOURCE_TYPE_REPLICATED_DISK -_SR_RESOURCE_TYPE_REPLICATED_DISKS_RESULT=SR_RESOURCE_TYPE_REPLICATED_DISKS_RESULT -_CLUSCTL_RESOURCE_TYPE_STORAGE_GET_AVAILABLE_DISKS_EX2_INPUT=CLUSCTL_RESOURCE_TYPE_STORAGE_GET_AVAILABLE_DISKS_EX2_INPUT -_RESOURCE_EXIT_STATE=RESOURCE_EXIT_STATE -_FAILURE_TYPE=FAILURE_TYPE -_CLUSTER_HEALTH_FAULT=CLUSTER_HEALTH_FAULT -_CLUSTER_HEALTH_FAULT_ARRAY=CLUSTER_HEALTH_FAULT_ARRAY -_CLUSTER_ROLE=CLUSTER_ROLE -_CLUSTER_ROLE_STATE=CLUSTER_ROLE_STATE -_PaxosTagCStruct=PaxosTagCStruct -_WitnessTagUpdateHelper=WitnessTagUpdateHelper -_WitnessTagHelper=WitnessTagHelper -_CLUADMEX_OBJECT_TYPE=CLUADMEX_OBJECT_TYPE -_UDCR_TAG=UDCR_TAG -_PIC_SEQ_SAMPLE=PIC_SEQ_SAMPLE -_SAMPLE_SEQ_OFFSET=SAMPLE_SEQ_OFFSET -_TRANSPORT_PROPERTIES=TRANSPORT_PROPERTIES -_PBDA_TAG_ATTRIBUTE=PBDA_TAG_ATTRIBUTE -_CAPTURE_STREAMTIME=CAPTURE_STREAMTIME -_DSHOW_STREAM_DESC=DSHOW_STREAM_DESC -_SAMPLE_LIVE_STREAM_TIME=SAMPLE_LIVE_STREAM_TIME -_AVISTREAMINFOW=AVISTREAMINFOW -_AVISTREAMINFOA=AVISTREAMINFOA -_AVIFILEINFOW=AVIFILEINFOW -_AVIFILEINFOA=AVIFILEINFOA -_WSDXML_NAMESPACE=WSDXML_NAMESPACE -_WSDXML_NAME=WSDXML_NAME -_WSDXML_TYPE=WSDXML_TYPE -_WSDXML_PREFIX_MAPPING=WSDXML_PREFIX_MAPPING -_WSDXML_ATTRIBUTE=WSDXML_ATTRIBUTE -_WSDXML_NODE=WSDXML_NODE -_WSDXML_ELEMENT=WSDXML_ELEMENT -_WSDXML_TEXT=WSDXML_TEXT -_WSDXML_ELEMENT_LIST=WSDXML_ELEMENT_LIST -_WSD_DATETIME=WSD_DATETIME -_WSD_DURATION=WSD_DURATION -_WSD_CONFIG_PARAM=WSD_CONFIG_PARAM -_WSD_SECURITY_CERT_VALIDATION_V1=WSD_SECURITY_CERT_VALIDATION_V1 -_WSD_SECURITY_CERT_VALIDATION=WSD_SECURITY_CERT_VALIDATION -_WSD_SECURITY_SIGNATURE_VALIDATION=WSD_SECURITY_SIGNATURE_VALIDATION -_WSD_CONFIG_ADDRESSES=WSD_CONFIG_ADDRESSES -_WSDUdpRetransmitParams=WSDUdpRetransmitParams -_WSDUdpMessageType=WSDUdpMessageType -tagDIAGNOSIS_STATUS=DIAGNOSIS_STATUS -tagREPAIR_STATUS=REPAIR_STATUS -tagPROBLEM_TYPE=PROBLEM_TYPE -tagHYPOTHESIS=HYPOTHESIS -tagHelperAttributeInfo=HelperAttributeInfo -tagDiagnosticsInfo=DiagnosticsInfo -tagHypothesisResult=HypothesisResult -_NS_REQS=NS_REQS -_TOKEN_VALUE=TOKEN_VALUE -_NS_CONTEXT_ATTRIBUTES=NS_CONTEXT_ATTRIBUTES -_NS_HELPER_ATTRIBUTES=NS_HELPER_ATTRIBUTES -_CMD_ENTRY=CMD_ENTRY -_CMD_GROUP_ENTRY=CMD_GROUP_ENTRY -_TAG_TYPE=TAG_TYPE -_NET_INTERFACE_CONTEXT=NET_INTERFACE_CONTEXT -_NET_INTERFACE_CONTEXT_TABLE=NET_INTERFACE_CONTEXT_TABLE -_ATTRIBUTEID=ATTRIBUTEID -_NEW_LOG_FILE_FREQUENCY=NEW_LOG_FILE_FREQUENCY -_AUTHENTICATION_TYPE=AUTHENTICATION_TYPE -_IDENTITY_TYPE=IDENTITY_TYPE -_ATTRIBUTESYNTAX=ATTRIBUTESYNTAX -_ATTRIBUTERESTRICTIONS=ATTRIBUTERESTRICTIONS -_ATTRIBUTEFILTER=ATTRIBUTEFILTER -_ATTRIBUTEINFO=ATTRIBUTEINFO -_IASCOMMONPROPERTIES=IASCOMMONPROPERTIES -_USERPROPERTIES=USERPROPERTIES -_DICTIONARYPROPERTIES=DICTIONARYPROPERTIES -_ATTRIBUTEPROPERTIES=ATTRIBUTEPROPERTIES -_IASPROPERTIES=IASPROPERTIES -_TEMPLATESPROPERTIES=TEMPLATESPROPERTIES -_CLIENTPROPERTIES=CLIENTPROPERTIES -_VENDORPROPERTIES=VENDORPROPERTIES -_PROFILEPROPERTIES=PROFILEPROPERTIES -_POLICYPROPERTIES=POLICYPROPERTIES -_CONDITIONPROPERTIES=CONDITIONPROPERTIES -_RADIUSSERVERGROUPPROPERTIES=RADIUSSERVERGROUPPROPERTIES -_RADIUSSERVERPROPERTIES=RADIUSSERVERPROPERTIES -_REMEDIATIONSERVERGROUPPROPERTIES=REMEDIATIONSERVERGROUPPROPERTIES -_REMEDIATIONSERVERPROPERTIES=REMEDIATIONSERVERPROPERTIES -_SHVTEMPLATEPROPERTIES=SHVTEMPLATEPROPERTIES -_IPFILTERPROPERTIES=IPFILTERPROPERTIES -_SHAREDSECRETPROPERTIES=SHAREDSECRETPROPERTIES -_IASCOMPONENTPROPERTIES=IASCOMPONENTPROPERTIES -_PROTOCOLPROPERTIES=PROTOCOLPROPERTIES -_RADIUSPROPERTIES=RADIUSPROPERTIES -_NTEVENTLOGPROPERTIES=NTEVENTLOGPROPERTIES -_NAMESPROPERTIES=NAMESPROPERTIES -_NTSAMPROPERTIES=NTSAMPROPERTIES -_ACCOUNTINGPROPERTIES=ACCOUNTINGPROPERTIES -_NAPPROPERTIES=NAPPROPERTIES -_RADIUSPROXYPROPERTIES=RADIUSPROXYPROPERTIES -_REMEDIATIONSERVERSPROPERTIES=REMEDIATIONSERVERSPROPERTIES -_SHV_COMBINATION_TYPE=SHV_COMBINATION_TYPE -_SERVICE_TYPE=SERVICE_TYPE -_IASOSTYPE=IASOSTYPE -_IASDATASTORE=IASDATASTORE -tagOFFLINEFILES_ITEM_TYPE=OFFLINEFILES_ITEM_TYPE -tagOFFLINEFILES_ITEM_COPY=OFFLINEFILES_ITEM_COPY -tagOFFLINEFILES_CONNECT_STATE=OFFLINEFILES_CONNECT_STATE -tagOFFLINEFILES_OFFLINE_REASON=OFFLINEFILES_OFFLINE_REASON -tagOFFLINEFILES_CACHING_MODE=OFFLINEFILES_CACHING_MODE -tagOFFLINEFILES_OP_RESPONSE=OFFLINEFILES_OP_RESPONSE -tagOFFLINEFILES_EVENTS=OFFLINEFILES_EVENTS -tagOFFLINEFILES_PATHFILTER_MATCH=OFFLINEFILES_PATHFILTER_MATCH -tagOFFLINEFILES_SYNC_CONFLICT_RESOLVE=OFFLINEFILES_SYNC_CONFLICT_RESOLVE -tagOFFLINEFILES_ITEM_TIME=OFFLINEFILES_ITEM_TIME -tagOFFLINEFILES_COMPARE=OFFLINEFILES_COMPARE -tagOFFLINEFILES_SETTING_VALUE_TYPE=OFFLINEFILES_SETTING_VALUE_TYPE -tagOFFLINEFILES_SYNC_OPERATION=OFFLINEFILES_SYNC_OPERATION -tagOFFLINEFILES_SYNC_STATE=OFFLINEFILES_SYNC_STATE -_DRT_REGISTRATION_STATE=DRT_REGISTRATION_STATE -_DRT_ADDRESS_FLAGS=DRT_ADDRESS_FLAGS -_DRT_ADDRESS=DRT_ADDRESS -_DRT_ADDRESS_LIST=DRT_ADDRESS_LIST -_PEERDIST_CLIENT_INFO_BY_HANDLE_CLASS=PEERDIST_CLIENT_INFO_BY_HANDLE_CLASS -_PEERDIST_CLIENT_BASIC_INFO=PEERDIST_CLIENT_BASIC_INFO -tagWPCFLAG_OVERRIDE=WPCFLAG_OVERRIDE -tagWPCFLAG_RESTRICTION=WPCFLAG_RESTRICTION -tagWPCFLAG_WEB_SETTING=WPCFLAG_WEB_SETTING -tagWPCFLAG_VISIBILITY=WPCFLAG_VISIBILITY -_PDH_RAW_COUNTER=PDH_RAW_COUNTER -_PDH_RAW_COUNTER_ITEM_A=PDH_RAW_COUNTER_ITEM_A -_PDH_RAW_COUNTER_ITEM_W=PDH_RAW_COUNTER_ITEM_W -_PDH_FMT_COUNTERVALUE=PDH_FMT_COUNTERVALUE -_PDH_FMT_COUNTERVALUE_ITEM_A=PDH_FMT_COUNTERVALUE_ITEM_A -_PDH_FMT_COUNTERVALUE_ITEM_W=PDH_FMT_COUNTERVALUE_ITEM_W -_PDH_STATISTICS=PDH_STATISTICS -_PDH_COUNTER_PATH_ELEMENTS_A=PDH_COUNTER_PATH_ELEMENTS_A -_PDH_COUNTER_PATH_ELEMENTS_W=PDH_COUNTER_PATH_ELEMENTS_W -_PDH_DATA_ITEM_PATH_ELEMENTS_A=PDH_DATA_ITEM_PATH_ELEMENTS_A -_PDH_DATA_ITEM_PATH_ELEMENTS_W=PDH_DATA_ITEM_PATH_ELEMENTS_W -_PDH_COUNTER_INFO_A=PDH_COUNTER_INFO_A -_PDH_COUNTER_INFO_W=PDH_COUNTER_INFO_W -_PDH_TIME_INFO=PDH_TIME_INFO -_PDH_RAW_LOG_RECORD=PDH_RAW_LOG_RECORD -_PDH_LOG_SERVICE_QUERY_INFO_A=PDH_LOG_SERVICE_QUERY_INFO_A -_PDH_LOG_SERVICE_QUERY_INFO_W=PDH_LOG_SERVICE_QUERY_INFO_W -tagUSER_INPUT_STRING_TYPE=USER_INPUT_STRING_TYPE -tagERROR_ADVISE_MESSAGE_TYPE=ERROR_ADVISE_MESSAGE_TYPE -tagERROR_ADVISE_RESULT=ERROR_ADVISE_RESULT -tagPROGRESS_DIALOG_IMAGE_TYPE=PROGRESS_DIALOG_IMAGE_TYPE -tagPROGRESS_DIALOG_CHECKBOX_ID=PROGRESS_DIALOG_CHECKBOX_ID -tagDEVICE_SELECTION_DEVICE_TYPE=DEVICE_SELECTION_DEVICE_TYPE -_GROUP_POLICY_OBJECT_TYPE=GROUP_POLICY_OBJECT_TYPE -_GROUP_POLICY_HINT_TYPE=GROUP_POLICY_HINT_TYPE -_QOS_TRAFFIC_TYPE=QOS_TRAFFIC_TYPE -_QOS_SET_FLOW=QOS_SET_FLOW -_QOS_PACKET_PRIORITY=QOS_PACKET_PRIORITY -_QOS_FLOW_FUNDAMENTALS=QOS_FLOW_FUNDAMENTALS -_QOS_FLOWRATE_REASON=QOS_FLOWRATE_REASON -_QOS_SHAPING=QOS_SHAPING -_QOS_FLOWRATE_OUTGOING=QOS_FLOWRATE_OUTGOING -_QOS_QUERY_FLOW=QOS_QUERY_FLOW -_QOS_NOTIFY_FLOW=QOS_NOTIFY_FLOW -_QOS_VERSION=QOS_VERSION -_TCI_CLIENT_FUNC_LIST=TCI_CLIENT_FUNC_LIST -_ADDRESS_LIST_DESCRIPTOR=ADDRESS_LIST_DESCRIPTOR -_TC_IFC_DESCRIPTOR=TC_IFC_DESCRIPTOR -_TC_SUPPORTED_INFO_BUFFER=TC_SUPPORTED_INFO_BUFFER -_TC_GEN_FILTER=TC_GEN_FILTER -_TC_GEN_FLOW=TC_GEN_FLOW -_IP_PATTERN=IP_PATTERN -_IPX_PATTERN=IPX_PATTERN -_ENUMERATION_BUFFER=ENUMERATION_BUFFER -tagRASDEVSPECIFICINFO=RASDEVSPECIFICINFO -_RASPPP_PROJECTION_INFO=RASPPP_PROJECTION_INFO -_RASIKEV2_PROJECTION_INFO=RASIKEV2_PROJECTION_INFO -_RASPROJECTION_INFO_TYPE=RASPROJECTION_INFO_TYPE -_IKEV2_ID_PAYLOAD_TYPE=IKEV2_ID_PAYLOAD_TYPE -_RAS_PROJECTION_INFO=RAS_PROJECTION_INFO -_RAS_STATS=RAS_STATS -_ROUTER_INTERFACE_TYPE=ROUTER_INTERFACE_TYPE -_ROUTER_CONNECTION_STATE=ROUTER_CONNECTION_STATE -_MPR_INTERFACE_0=MPR_INTERFACE_0 -_MPR_IPINIP_INTERFACE_0=MPR_IPINIP_INTERFACE_0 -_MPR_INTERFACE_1=MPR_INTERFACE_1 -_MPR_INTERFACE_2=MPR_INTERFACE_2 -_MPR_INTERFACE_3=MPR_INTERFACE_3 -_MPR_DEVICE_0=MPR_DEVICE_0 -_MPR_DEVICE_1=MPR_DEVICE_1 -_MPR_CREDENTIALSEX_0=MPR_CREDENTIALSEX_0 -_MPR_CREDENTIALSEX_1=MPR_CREDENTIALSEX_1 -_MPR_TRANSPORT_0=MPR_TRANSPORT_0 -_MPR_IFTRANSPORT_0=MPR_IFTRANSPORT_0 -_MPR_SERVER_0=MPR_SERVER_0 -_MPR_SERVER_1=MPR_SERVER_1 -_MPR_SERVER_2=MPR_SERVER_2 -_RAS_PORT_CONDITION=RAS_PORT_CONDITION -_RAS_HARDWARE_CONDITION=RAS_HARDWARE_CONDITION -_RAS_PORT_0=RAS_PORT_0 -_RAS_PORT_1=RAS_PORT_1 -_RAS_PORT_2=RAS_PORT_2 -_PPP_NBFCP_INFO=PPP_NBFCP_INFO -_PPP_IPCP_INFO=PPP_IPCP_INFO -_PPP_IPCP_INFO2=PPP_IPCP_INFO2 -_PPP_IPXCP_INFO=PPP_IPXCP_INFO -_PPP_ATCP_INFO=PPP_ATCP_INFO -_PPP_IPV6_CP_INFO=PPP_IPV6_CP_INFO -_PPP_INFO=PPP_INFO -_PPP_CCP_INFO=PPP_CCP_INFO -_PPP_LCP_INFO=PPP_LCP_INFO -_PPP_INFO_2=PPP_INFO_2 -_PPP_INFO_3=PPP_INFO_3 -_RAS_CONNECTION_0=RAS_CONNECTION_0 -_RAS_CONNECTION_1=RAS_CONNECTION_1 -_RAS_CONNECTION_2=RAS_CONNECTION_2 -_RAS_QUARANTINE_STATE=RAS_QUARANTINE_STATE -_RAS_CONNECTION_3=RAS_CONNECTION_3 -_RAS_USER_0=RAS_USER_0 -_RAS_USER_1=RAS_USER_1 -_MPR_FILTER_0=MPR_FILTER_0 -_MPRAPI_OBJECT_HEADER=MPRAPI_OBJECT_HEADER -_MPRAPI_OBJECT_TYPE=MPRAPI_OBJECT_TYPE -_PPP_PROJECTION_INFO=PPP_PROJECTION_INFO -_PPP_PROJECTION_INFO2=PPP_PROJECTION_INFO2 -_IKEV2_PROJECTION_INFO=IKEV2_PROJECTION_INFO -_IKEV2_PROJECTION_INFO2=IKEV2_PROJECTION_INFO2 -_PROJECTION_INFO=PROJECTION_INFO -_PROJECTION_INFO2=PROJECTION_INFO2 -_RAS_CONNECTION_EX=RAS_CONNECTION_EX -_RAS_CONNECTION_4=RAS_CONNECTION_4 -_ROUTER_CUSTOM_IKEv2_POLICY0=ROUTER_CUSTOM_IKEv2_POLICY0 -_ROUTER_IKEv2_IF_CUSTOM_CONFIG0=ROUTER_IKEv2_IF_CUSTOM_CONFIG0 -_MPR_IF_CUSTOMINFOEX0=MPR_IF_CUSTOMINFOEX0 -_MPR_CERT_EKU=MPR_CERT_EKU -_VPN_TS_IP_ADDRESS=VPN_TS_IP_ADDRESS -_MPR_VPN_TS_TYPE=MPR_VPN_TS_TYPE -_MPR_VPN_TRAFFIC_SELECTORS=MPR_VPN_TRAFFIC_SELECTORS -_ROUTER_IKEv2_IF_CUSTOM_CONFIG2=ROUTER_IKEv2_IF_CUSTOM_CONFIG2 -_MPR_IF_CUSTOMINFOEX2=MPR_IF_CUSTOMINFOEX2 -_IKEV2_TUNNEL_CONFIG_PARAMS4=IKEV2_TUNNEL_CONFIG_PARAMS4 -_ROUTER_IKEv2_IF_CUSTOM_CONFIG1=ROUTER_IKEv2_IF_CUSTOM_CONFIG1 -_MPR_IF_CUSTOMINFOEX1=MPR_IF_CUSTOMINFOEX1 -_IKEV2_TUNNEL_CONFIG_PARAMS3=IKEV2_TUNNEL_CONFIG_PARAMS3 -_IKEV2_TUNNEL_CONFIG_PARAMS2=IKEV2_TUNNEL_CONFIG_PARAMS2 -_L2TP_TUNNEL_CONFIG_PARAMS2=L2TP_TUNNEL_CONFIG_PARAMS2 -_L2TP_TUNNEL_CONFIG_PARAMS1=L2TP_TUNNEL_CONFIG_PARAMS1 -_IKEV2_CONFIG_PARAMS=IKEV2_CONFIG_PARAMS -_PPTP_CONFIG_PARAMS=PPTP_CONFIG_PARAMS -_L2TP_CONFIG_PARAMS1=L2TP_CONFIG_PARAMS1 -_GRE_CONFIG_PARAMS0=GRE_CONFIG_PARAMS0 -_L2TP_CONFIG_PARAMS0=L2TP_CONFIG_PARAMS0 -_SSTP_CERT_INFO=SSTP_CERT_INFO -_SSTP_CONFIG_PARAMS=SSTP_CONFIG_PARAMS -_MPRAPI_TUNNEL_CONFIG_PARAMS0=MPRAPI_TUNNEL_CONFIG_PARAMS0 -_MPRAPI_TUNNEL_CONFIG_PARAMS1=MPRAPI_TUNNEL_CONFIG_PARAMS1 -_MPR_SERVER_EX0=MPR_SERVER_EX0 -_MPR_SERVER_EX1=MPR_SERVER_EX1 -_MPR_SERVER_SET_CONFIG_EX0=MPR_SERVER_SET_CONFIG_EX0 -_MPR_SERVER_SET_CONFIG_EX1=MPR_SERVER_SET_CONFIG_EX1 -_AUTH_VALIDATION_EX=AUTH_VALIDATION_EX -_MPRAPI_ADMIN_DLL_CALLBACKS=MPRAPI_ADMIN_DLL_CALLBACKS -_SECURITY_MESSAGE=SECURITY_MESSAGE -_RAS_SECURITY_INFO=RAS_SECURITY_INFO -_MGM_IF_ENTRY=MGM_IF_ENTRY -_ROUTING_PROTOCOL_CONFIG=ROUTING_PROTOCOL_CONFIG -_MGM_ENUM_TYPES=MGM_ENUM_TYPES -_SOURCE_GROUP_ENTRY=SOURCE_GROUP_ENTRY -_RTM_REGN_PROFILE=RTM_REGN_PROFILE -_RTM_NET_ADDRESS=RTM_NET_ADDRESS -_RTM_PREF_INFO=RTM_PREF_INFO -_RTM_NEXTHOP_LIST=RTM_NEXTHOP_LIST -_RTM_DEST_INFO=RTM_DEST_INFO -_RTM_ROUTE_INFO=RTM_ROUTE_INFO -_RTM_NEXTHOP_INFO=RTM_NEXTHOP_INFO -_RTM_ENTITY_ID=RTM_ENTITY_ID -_RTM_ENTITY_INFO=RTM_ENTITY_INFO -_RTM_EVENT_TYPE=RTM_EVENT_TYPE -_RTM_ENTITY_METHOD_INPUT=RTM_ENTITY_METHOD_INPUT -_RTM_ENTITY_METHOD_OUTPUT=RTM_ENTITY_METHOD_OUTPUT -_RTM_ENTITY_EXPORT_METHODS=RTM_ENTITY_EXPORT_METHODS -_RM_APP_TYPE=RM_APP_TYPE -_RM_SHUTDOWN_TYPE=RM_SHUTDOWN_TYPE -_RM_APP_STATUS=RM_APP_STATUS -_RM_REBOOT_REASON=RM_REBOOT_REASON -_RM_UNIQUE_PROCESS=RM_UNIQUE_PROCESS -_RM_PROCESS_INFO=RM_PROCESS_INFO -_RM_FILTER_TRIGGER=RM_FILTER_TRIGGER -_RM_FILTER_ACTION=RM_FILTER_ACTION -_RM_FILTER_INFO=RM_FILTER_INFO -tagWORDREP_BREAK_TYPE=WORDREP_BREAK_TYPE -tagTEXT_SOURCE=TEXT_SOURCE -tagDBID=DBID -_FILTERED_DATA_SOURCES=FILTERED_DATA_SOURCES -tagSTRUCTURED_QUERY_SYNTAX=STRUCTURED_QUERY_SYNTAX -tagSTRUCTURED_QUERY_SINGLE_OPTION=STRUCTURED_QUERY_SINGLE_OPTION -tagSTRUCTURED_QUERY_MULTIOPTION=STRUCTURED_QUERY_MULTIOPTION -tagSTRUCTURED_QUERY_PARSE_ERROR=STRUCTURED_QUERY_PARSE_ERROR -tagINTERVAL_LIMIT_KIND=INTERVAL_LIMIT_KIND -tagQUERY_PARSER_MANAGER_OPTION=QUERY_PARSER_MANAGER_OPTION -tagHITRANGE=HITRANGE -_TIMEOUT_INFO=TIMEOUT_INFO -_PROXY_ACCESS=PROXY_ACCESS -_PROXY_INFO=PROXY_INFO -_AUTH_TYPE=AUTH_TYPE -_AUTHENTICATION_INFO=AUTHENTICATION_INFO -_INCREMENTAL_ACCESS_INFO=INCREMENTAL_ACCESS_INFO -_ITEM_INFO=ITEM_INFO -_FOLLOW_FLAGS=FOLLOW_FLAGS -_SEARCH_KIND_OF_CHANGE=SEARCH_KIND_OF_CHANGE -_SEARCH_NOTIFICATION_PRIORITY=SEARCH_NOTIFICATION_PRIORITY -_SEARCH_ITEM_CHANGE=SEARCH_ITEM_CHANGE -_SEARCH_ITEM_PERSISTENT_CHANGE=SEARCH_ITEM_PERSISTENT_CHANGE -_SEARCH_INDEXING_PHASE=SEARCH_INDEXING_PHASE -_SEARCH_ITEM_INDEXING_STATUS=SEARCH_ITEM_INDEXING_STATUS -_CatalogStatus=CatalogStatus -_CatalogPausedReason=CatalogPausedReason -_SEARCH_TERM_EXPANSION=SEARCH_TERM_EXPANSION -_SEARCH_QUERY_SYNTAX=SEARCH_QUERY_SYNTAX -_SEARCH_COLUMN_PROPERTIES=SEARCH_COLUMN_PROPERTIES -_WINBIO_ASYNC_NOTIFICATION_METHOD=WINBIO_ASYNC_NOTIFICATION_METHOD -_WINBIO_ASYNC_RESULT=WINBIO_ASYNC_RESULT -_WINBIO_STORAGE_RECORD=WINBIO_STORAGE_RECORD -_WINBIO_PIPELINE=WINBIO_PIPELINE -_WINBIO_ADAPTER_INTERFACE_VERSION=WINBIO_ADAPTER_INTERFACE_VERSION -_WINBIO_SENSOR_INTERFACE=WINBIO_SENSOR_INTERFACE -_WINBIO_ENGINE_INTERFACE=WINBIO_ENGINE_INTERFACE -_WINBIO_STORAGE_INTERFACE=WINBIO_STORAGE_INTERFACE -_WINBIO_FRAMEWORK_INTERFACE=WINBIO_FRAMEWORK_INTERFACE -_WLX_SC_NOTIFICATION_INFO=WLX_SC_NOTIFICATION_INFO -_WLX_PROFILE_V1_0=WLX_PROFILE_V1_0 -_WLX_PROFILE_V2_0=WLX_PROFILE_V2_0 -_WLX_MPR_NOTIFY_INFO=WLX_MPR_NOTIFY_INFO -_WLX_TERMINAL_SERVICES_DATA=WLX_TERMINAL_SERVICES_DATA -_WLX_DESKTOP=WLX_DESKTOP -_WLX_DISPATCH_VERSION_1_0=WLX_DISPATCH_VERSION_1_0 -_WLX_DISPATCH_VERSION_1_1=WLX_DISPATCH_VERSION_1_1 -_WLX_DISPATCH_VERSION_1_2=WLX_DISPATCH_VERSION_1_2 -_WLX_DISPATCH_VERSION_1_3=WLX_DISPATCH_VERSION_1_3 -_WLX_DISPATCH_VERSION_1_4=WLX_DISPATCH_VERSION_1_4 -_WLX_NOTIFICATION_INFO=WLX_NOTIFICATION_INFO -_LOGON_HOURS=LOGON_HOURS -_SR_SECURITY_DESCRIPTOR=SR_SECURITY_DESCRIPTOR -_USER_ALL_INFORMATION=USER_ALL_INFORMATION -_CLEAR_BLOCK=CLEAR_BLOCK -_USER_SESSION_KEY=USER_SESSION_KEY -_NETLOGON_LOGON_INFO_CLASS=NETLOGON_LOGON_INFO_CLASS -_NETLOGON_LOGON_IDENTITY_INFO=NETLOGON_LOGON_IDENTITY_INFO -_NETLOGON_INTERACTIVE_INFO=NETLOGON_INTERACTIVE_INFO -_NETLOGON_SERVICE_INFO=NETLOGON_SERVICE_INFO -_NETLOGON_NETWORK_INFO=NETLOGON_NETWORK_INFO -_NETLOGON_GENERIC_INFO=NETLOGON_GENERIC_INFO -_MSV1_0_VALIDATION_INFO=MSV1_0_VALIDATION_INFO -_CRYPT_XML_BLOB=CRYPT_XML_BLOB -_CRYPT_XML_DATA_BLOB=CRYPT_XML_DATA_BLOB -_CRYPT_XML_STATUS=CRYPT_XML_STATUS -_CRYPT_XML_TRANSFORM_INFO=CRYPT_XML_TRANSFORM_INFO -_CRYPT_XML_TRANSFORM_CHAIN_CONFIG=CRYPT_XML_TRANSFORM_CHAIN_CONFIG -_CRYPT_XML_KEY_INFO=CRYPT_XML_KEY_INFO -_CRYPT_XML_ALGORITHM=CRYPT_XML_ALGORITHM -_CRYPT_XML_REFERENCE=CRYPT_XML_REFERENCE -_CRYPT_XML_REFERENCES=CRYPT_XML_REFERENCES -_CRYPT_XML_SIGNED_INFO=CRYPT_XML_SIGNED_INFO -_CRYPT_XML_OBJECT=CRYPT_XML_OBJECT -_CRYPT_XML_SIGNATURE=CRYPT_XML_SIGNATURE -_CRYPT_XML_ALGORITHM_INFO=CRYPT_XML_ALGORITHM_INFO -_CRYPT_XML_CRYPTOGRAPHIC_INTERFACE=CRYPT_XML_CRYPTOGRAPHIC_INTERFACE -_CRYPT_XML_PROPERTY=CRYPT_XML_PROPERTY -_CRYPT_XML_DATA_PROVIDER=CRYPT_XML_DATA_PROVIDER -_CRYPT_XML_KEY_DSA_KEY_VALUE=CRYPT_XML_KEY_DSA_KEY_VALUE -_CRYPT_XML_KEY_ECDSA_KEY_VALUE=CRYPT_XML_KEY_ECDSA_KEY_VALUE -_CRYPT_XML_KEY_RSA_KEY_VALUE=CRYPT_XML_KEY_RSA_KEY_VALUE -_CRYPT_XML_KEY_VALUE=CRYPT_XML_KEY_VALUE -_CRYPT_XML_ISSUER_SERIAL=CRYPT_XML_ISSUER_SERIAL -_CRYPT_XML_X509DATA_ITEM=CRYPT_XML_X509DATA_ITEM -_CRYPT_XML_X509DATA=CRYPT_XML_X509DATA -_CRYPT_XML_KEY_INFO_ITEM=CRYPT_XML_KEY_INFO_ITEM -_CRYPT_XML_DOC_CTXT=CRYPT_XML_DOC_CTXT -_CRYPT_XML_KEYINFO_PARAM=CRYPT_XML_KEYINFO_PARAM -tagCERT_VIEWPROPERTIES_STRUCT_A=CERT_VIEWPROPERTIES_STRUCT_A -tagCERT_VIEWPROPERTIES_STRUCT_W=CERT_VIEWPROPERTIES_STRUCT_W -_CERT_VERIFY_CERTIFICATE_TRUST=CERT_VERIFY_CERTIFICATE_TRUST -_CTL_MODIFY_REQUEST=CTL_MODIFY_REQUEST -_CRYPTUI_CERT_MGR_STRUCT=CRYPTUI_CERT_MGR_STRUCT -_CRYPTUI_WIZ_DIGITAL_SIGN_BLOB_INFO=CRYPTUI_WIZ_DIGITAL_SIGN_BLOB_INFO -_CRYPTUI_WIZ_DIGITAL_SIGN_STORE_INFO=CRYPTUI_WIZ_DIGITAL_SIGN_STORE_INFO -_CRYPTUI_WIZ_DIGITAL_SIGN_PVK_FILE_INFO=CRYPTUI_WIZ_DIGITAL_SIGN_PVK_FILE_INFO -_CRYPTUI_WIZ_DIGITAL_SIGN_CERT_PVK_INFO=CRYPTUI_WIZ_DIGITAL_SIGN_CERT_PVK_INFO -_CRYPTUI_WIZ_DIGITAL_SIGN_EXTENDED_INFO=CRYPTUI_WIZ_DIGITAL_SIGN_EXTENDED_INFO -_CRYPTUI_WIZ_DIGITAL_SIGN_INFO=CRYPTUI_WIZ_DIGITAL_SIGN_INFO -_CRYPTUI_WIZ_DIGITAL_SIGN_CONTEXT=CRYPTUI_WIZ_DIGITAL_SIGN_CONTEXT -tagCRYPTUI_INITDIALOG_STRUCT=CRYPTUI_INITDIALOG_STRUCT -tagCRYPTUI_VIEWCERTIFICATE_STRUCTW=CRYPTUI_VIEWCERTIFICATE_STRUCTW -tagCRYPTUI_VIEWCERTIFICATE_STRUCTA=CRYPTUI_VIEWCERTIFICATE_STRUCTA -_CRYPTUI_WIZ_EXPORT_INFO=CRYPTUI_WIZ_EXPORT_INFO -_CRYPTUI_WIZ_EXPORT_CERTCONTEXT_INFO=CRYPTUI_WIZ_EXPORT_CERTCONTEXT_INFO -_SCESVC_INFO_TYPE=SCESVC_INFO_TYPE -_tagSLDATATYPE=SLDATATYPE -_tagSLIDTYPE=SLIDTYPE -_tagSLLICENSINGSTATUS=SLLICENSINGSTATUS -_tagSL_LICENSING_STATUS=SL_LICENSING_STATUS -_tagSL_ACTIVATION_TYPE=SL_ACTIVATION_TYPE -_tagSL_ACTIVATION_INFO_HEADER=SL_ACTIVATION_INFO_HEADER -_tagSL_AD_ACTIVATION_INFO=SL_AD_ACTIVATION_INFO -_SL_GENUINE_STATE=SL_GENUINE_STATE -_tagSL_NONGENUINE_UI_OPTIONS=SL_NONGENUINE_UI_OPTIONS -_SL_SYSTEM_POLICY_INFORMATION=SL_SYSTEM_POLICY_INFORMATION _OLD_LARGE_INTEGER=long -tagQOCINFO=QOCINFO -tagINSTALLMESSAGE=INSTALLMESSAGE -tagINSTALLUILEVEL=INSTALLUILEVEL -tagINSTALLSTATE=INSTALLSTATE -tagUSERINFOSTATE=USERINFOSTATE -tagINSTALLLEVEL=INSTALLLEVEL -tagREINSTALLMODE=REINSTALLMODE -tagINSTALLLOGATTRIBUTES=INSTALLLOGATTRIBUTES -tagINSTALLFEATUREATTRIBUTE=INSTALLFEATUREATTRIBUTE -tagINSTALLMODE=INSTALLMODE -tagMSIPATCHSTATE=MSIPATCHSTATE -tagMSIINSTALLCONTEXT=MSIINSTALLCONTEXT -tagMSIPATCHDATATYPE=MSIPATCHDATATYPE -tagMSIPATCHSEQUENCEINFOA=MSIPATCHSEQUENCEINFOA -tagMSIPATCHSEQUENCEINFOW=MSIPATCHSEQUENCEINFOW -tagSCRIPTFLAGS=SCRIPTFLAGS -tagADVERTISEFLAGS=ADVERTISEFLAGS -tagINSTALLTYPE=INSTALLTYPE -_MSIFILEHASHINFO=MSIFILEHASHINFO -tagMSIARCHITECTUREFLAGS=MSIARCHITECTUREFLAGS -tagMSIOPENPACKAGEFLAGS=MSIOPENPACKAGEFLAGS -tagMSIADVERTISEOPTIONFLAGS=MSIADVERTISEOPTIONFLAGS -tagMSISOURCETYPE=MSISOURCETYPE -tagMSICODE=MSICODE -tagMSITRANSACTION=MSITRANSACTION -tagMSITRANSACTIONSTATE=MSITRANSACTIONSTATE -tagMSIDBSTATE=MSIDBSTATE -tagMSIMODIFY=MSIMODIFY -tagMSICOLINFO=MSICOLINFO -tagMSICONDITION=MSICONDITION -tagMSICOSTTREE=MSICOSTTREE -tagMSIDBERROR=MSIDBERROR -tagMSIRUNMODE=MSIRUNMODE -tagMSITRANSFORM_ERROR=MSITRANSFORM_ERROR -tagMSITRANSFORM_VALIDATE=MSITRANSFORM_VALIDATE -_ASSEMBLY_INFO=ASSEMBLY_INFO -_PROTECTED_FILE_DATA=PROTECTED_FILE_DATA -_CREDENTIAL_PROVIDER_USAGE_SCENARIO=CREDENTIAL_PROVIDER_USAGE_SCENARIO -_CREDENTIAL_PROVIDER_FIELD_TYPE=CREDENTIAL_PROVIDER_FIELD_TYPE -_CREDENTIAL_PROVIDER_FIELD_STATE=CREDENTIAL_PROVIDER_FIELD_STATE -_CREDENTIAL_PROVIDER_FIELD_INTERACTIVE_STATE=CREDENTIAL_PROVIDER_FIELD_INTERACTIVE_STATE -_CREDENTIAL_PROVIDER_FIELD_DESCRIPTOR=CREDENTIAL_PROVIDER_FIELD_DESCRIPTOR -_CREDENTIAL_PROVIDER_GET_SERIALIZATION_RESPONSE=CREDENTIAL_PROVIDER_GET_SERIALIZATION_RESPONSE -_CREDENTIAL_PROVIDER_STATUS_ICON=CREDENTIAL_PROVIDER_STATUS_ICON -_CREDENTIAL_PROVIDER_CREDENTIAL_SERIALIZATION=CREDENTIAL_PROVIDER_CREDENTIAL_SERIALIZATION -_tagSYNCMGRSTATUS=SYNCMGRSTATUS -_tagSYNCMGRPROGRESSITEM=SYNCMGRPROGRESSITEM -_tagSYNCMGRLOGLEVEL=SYNCMGRLOGLEVEL -_tagSYNCMGRERRORFLAGS=SYNCMGRERRORFLAGS -_tagSYNCMGRLOGERRORINFO=SYNCMGRLOGERRORINFO -_tagSYNCMGRITEMFLAGS=SYNCMGRITEMFLAGS -_tagSYNCMGRITEM=SYNCMGRITEM -_tagSYNCMGRFLAG=SYNCMGRFLAG -_tagSYNCMGRHANDLERFLAGS=SYNCMGRHANDLERFLAGS -_tagSYNCMGRHANDLERINFO=SYNCMGRHANDLERINFO -_tagSYNCMGRITEMSTATE=SYNCMGRITEMSTATE -_tagSYNCMGRINVOKEFLAGS=SYNCMGRINVOKEFLAGS -_tagSYNCMGRREGISTERFLAGS=SYNCMGRREGISTERFLAGS -tagBNSTATE=BNSTATE -tagTI_FLAGS=TI_FLAGS -tagINKMETRIC=INKMETRIC -_InkRecoGuide=InkRecoGuide -_TASK_TRIGGER_TYPE=TASK_TRIGGER_TYPE -_DAILY=DAILY -_WEEKLY=WEEKLY -_MONTHLYDATE=MONTHLYDATE -_MONTHLYDOW=MONTHLYDOW -_TRIGGER_TYPE_UNION=TRIGGER_TYPE_UNION -_TASK_TRIGGER=TASK_TRIGGER -_TASKPAGE=TASKPAGE -_TASK_RUN_FLAGS=TASK_RUN_FLAGS -_TASK_ENUM_FLAGS=TASK_ENUM_FLAGS -_TASK_LOGON_TYPE=TASK_LOGON_TYPE -_TASK_STATE=TASK_STATE -_TASK_CREATION=TASK_CREATION -_TASK_TRIGGER_TYPE2=TASK_TRIGGER_TYPE2 -_TASK_SESSION_STATE_CHANGE_TYPE=TASK_SESSION_STATE_CHANGE_TYPE -_TASK_ACTION_TYPE=TASK_ACTION_TYPE -_TASK_INSTANCES_POLICY=TASK_INSTANCES_POLICY -_TASK_COMPATIBILITY=TASK_COMPATIBILITY -_TPM_DEVICE_INFO=TPM_DEVICE_INFO -_TS_SB_SORT_BY=TS_SB_SORT_BY -_TSPUB_PLUGIN_PD_RESOLUTION_TYPE=TSPUB_PLUGIN_PD_RESOLUTION_TYPE -_TSPUB_PLUGIN_PD_ASSIGNMENT_TYPE=TSPUB_PLUGIN_PD_ASSIGNMENT_TYPE -tagRFX_GFX_RECT=RFX_GFX_RECT -tagRFX_GFX_MSG_HEADER=RFX_GFX_MSG_HEADER -tagRFX_GFX_MONITOR_INFO=RFX_GFX_MONITOR_INFO -tagRFX_GFX_MSG_CLIENT_DESKTOP_INFO_REQUEST=RFX_GFX_MSG_CLIENT_DESKTOP_INFO_REQUEST -tagRFX_GFX_MSG_CLIENT_DESKTOP_INFO_RESPONSE=RFX_GFX_MSG_CLIENT_DESKTOP_INFO_RESPONSE -tagRFX_GFX_MSG_DESKTOP_CONFIG_CHANGE_NOTIFY=RFX_GFX_MSG_DESKTOP_CONFIG_CHANGE_NOTIFY -tagRFX_GFX_MSG_DESKTOP_CONFIG_CHANGE_CONFIRM=RFX_GFX_MSG_DESKTOP_CONFIG_CHANGE_CONFIRM -tagRFX_GFX_MSG_DESKTOP_INPUT_RESET=RFX_GFX_MSG_DESKTOP_INPUT_RESET -tagRFX_GFX_MSG_DISCONNECT_NOTIFY=RFX_GFX_MSG_DISCONNECT_NOTIFY -tagRFX_GFX_MSG_DESKTOP_RESEND_REQUEST=RFX_GFX_MSG_DESKTOP_RESEND_REQUEST -tagRFX_GFX_MSG_RDP_DATA=RFX_GFX_MSG_RDP_DATA -tagUAL_DATA_BLOB=UAL_DATA_BLOB -_OPEN_VIRTUAL_DISK_VERSION=OPEN_VIRTUAL_DISK_VERSION -_OPEN_VIRTUAL_DISK_PARAMETERS=OPEN_VIRTUAL_DISK_PARAMETERS -_VIRTUAL_DISK_ACCESS_MASK=VIRTUAL_DISK_ACCESS_MASK -_OPEN_VIRTUAL_DISK_FLAG=OPEN_VIRTUAL_DISK_FLAG -_CREATE_VIRTUAL_DISK_VERSION=CREATE_VIRTUAL_DISK_VERSION -_CREATE_VIRTUAL_DISK_PARAMETERS=CREATE_VIRTUAL_DISK_PARAMETERS -_CREATE_VIRTUAL_DISK_FLAG=CREATE_VIRTUAL_DISK_FLAG -_ATTACH_VIRTUAL_DISK_VERSION=ATTACH_VIRTUAL_DISK_VERSION -_ATTACH_VIRTUAL_DISK_PARAMETERS=ATTACH_VIRTUAL_DISK_PARAMETERS -_ATTACH_VIRTUAL_DISK_FLAG=ATTACH_VIRTUAL_DISK_FLAG -_DETACH_VIRTUAL_DISK_FLAG=DETACH_VIRTUAL_DISK_FLAG -_DEPENDENT_DISK_FLAG=DEPENDENT_DISK_FLAG -_STORAGE_DEPENDENCY_INFO_VERSION=STORAGE_DEPENDENCY_INFO_VERSION -_STORAGE_DEPENDENCY_INFO_TYPE_1=STORAGE_DEPENDENCY_INFO_TYPE_1 -_STORAGE_DEPENDENCY_INFO_TYPE_2=STORAGE_DEPENDENCY_INFO_TYPE_2 -_STORAGE_DEPENDENCY_INFO=STORAGE_DEPENDENCY_INFO -_GET_STORAGE_DEPENDENCY_FLAG=GET_STORAGE_DEPENDENCY_FLAG -_GET_VIRTUAL_DISK_INFO_VERSION=GET_VIRTUAL_DISK_INFO_VERSION -_GET_VIRTUAL_DISK_INFO=GET_VIRTUAL_DISK_INFO -_SET_VIRTUAL_DISK_INFO_VERSION=SET_VIRTUAL_DISK_INFO_VERSION -_SET_VIRTUAL_DISK_INFO=SET_VIRTUAL_DISK_INFO -_VIRTUAL_DISK_PROGRESS=VIRTUAL_DISK_PROGRESS -_COMPACT_VIRTUAL_DISK_VERSION=COMPACT_VIRTUAL_DISK_VERSION -_COMPACT_VIRTUAL_DISK_PARAMETERS=COMPACT_VIRTUAL_DISK_PARAMETERS -_COMPACT_VIRTUAL_DISK_FLAG=COMPACT_VIRTUAL_DISK_FLAG -_MERGE_VIRTUAL_DISK_VERSION=MERGE_VIRTUAL_DISK_VERSION -_MERGE_VIRTUAL_DISK_PARAMETERS=MERGE_VIRTUAL_DISK_PARAMETERS -_MERGE_VIRTUAL_DISK_FLAG=MERGE_VIRTUAL_DISK_FLAG -_EXPAND_VIRTUAL_DISK_VERSION=EXPAND_VIRTUAL_DISK_VERSION -_EXPAND_VIRTUAL_DISK_PARAMETERS=EXPAND_VIRTUAL_DISK_PARAMETERS -_EXPAND_VIRTUAL_DISK_FLAG=EXPAND_VIRTUAL_DISK_FLAG -_RESIZE_VIRTUAL_DISK_VERSION=RESIZE_VIRTUAL_DISK_VERSION -_RESIZE_VIRTUAL_DISK_PARAMETERS=RESIZE_VIRTUAL_DISK_PARAMETERS -_RESIZE_VIRTUAL_DISK_FLAG=RESIZE_VIRTUAL_DISK_FLAG -_MIRROR_VIRTUAL_DISK_VERSION=MIRROR_VIRTUAL_DISK_VERSION -_MIRROR_VIRTUAL_DISK_PARAMETERS=MIRROR_VIRTUAL_DISK_PARAMETERS -_MIRROR_VIRTUAL_DISK_FLAG=MIRROR_VIRTUAL_DISK_FLAG -_QUERY_CHANGES_VIRTUAL_DISK_RANGE=QUERY_CHANGES_VIRTUAL_DISK_RANGE -_QUERY_CHANGES_VIRTUAL_DISK_FLAG=QUERY_CHANGES_VIRTUAL_DISK_FLAG -_TAKE_SNAPSHOT_VHDSET_FLAG=TAKE_SNAPSHOT_VHDSET_FLAG -_TAKE_SNAPSHOT_VHDSET_VERSION=TAKE_SNAPSHOT_VHDSET_VERSION -_TAKE_SNAPSHOT_VHDSET_PARAMETERS=TAKE_SNAPSHOT_VHDSET_PARAMETERS -_DELETE_SNAPSHOT_VHDSET_FLAG=DELETE_SNAPSHOT_VHDSET_FLAG -_DELETE_SNAPSHOT_VHDSET_VERSION=DELETE_SNAPSHOT_VHDSET_VERSION -_DELETE_SNAPSHOT_VHDSET_PARAMETERS=DELETE_SNAPSHOT_VHDSET_PARAMETERS -_MODIFY_VHDSET_VERSION=MODIFY_VHDSET_VERSION -_MODIFY_VHDSET_FLAG=MODIFY_VHDSET_FLAG -_MODIFY_VHDSET_PARAMETERS=MODIFY_VHDSET_PARAMETERS -_APPLY_SNAPSHOT_VHDSET_FLAG=APPLY_SNAPSHOT_VHDSET_FLAG -_APPLY_SNAPSHOT_VHDSET_VERSION=APPLY_SNAPSHOT_VHDSET_VERSION -_APPLY_SNAPSHOT_VHDSET_PARAMETERS=APPLY_SNAPSHOT_VHDSET_PARAMETERS -_RAW_SCSI_VIRTUAL_DISK_FLAG=RAW_SCSI_VIRTUAL_DISK_FLAG -_RAW_SCSI_VIRTUAL_DISK_VERSION=RAW_SCSI_VIRTUAL_DISK_VERSION -_RAW_SCSI_VIRTUAL_DISK_PARAMETERS=RAW_SCSI_VIRTUAL_DISK_PARAMETERS -_RAW_SCSI_VIRTUAL_DISK_RESPONSE=RAW_SCSI_VIRTUAL_DISK_RESPONSE -_FORK_VIRTUAL_DISK_VERSION=FORK_VIRTUAL_DISK_VERSION -_FORK_VIRTUAL_DISK_PARAMETERS=FORK_VIRTUAL_DISK_PARAMETERS -_FORK_VIRTUAL_DISK_FLAG=FORK_VIRTUAL_DISK_FLAG -_tagWAB_PARAM=WAB_PARAM -_WABIMPORTPARAM=WABIMPORTPARAM -_WABEXTDISPLAY=WABEXTDISPLAY -_WCM_PROPERTY=WCM_PROPERTY -_WCM_MEDIA_TYPE=WCM_MEDIA_TYPE -_WCM_POLICY_VALUE=WCM_POLICY_VALUE -_WCM_PROFILE_INFO=WCM_PROFILE_INFO -_WCM_PROFILE_INFO_LIST=WCM_PROFILE_INFO_LIST -_WCM_CONNECTION_COST=WCM_CONNECTION_COST -_WCM_CONNECTION_COST_SOURCE=WCM_CONNECTION_COST_SOURCE -_WCM_CONNECTION_COST_DATA=WCM_CONNECTION_COST_DATA -_WCM_TIME_INTERVAL=WCM_TIME_INTERVAL -_WCM_USAGE_DATA=WCM_USAGE_DATA -_WCM_DATAPLAN_STATUS=WCM_DATAPLAN_STATUS -tagWCN_PASSWORD_TYPE=WCN_PASSWORD_TYPE -tagWCN_SESSION_STATUS=WCN_SESSION_STATUS -tagWCN_VENDOR_EXTENSION_SPEC=WCN_VENDOR_EXTENSION_SPEC -tagWDS_CLI_CRED=WDS_CLI_CRED -_WDS_CLI_IMAGE_TYPE=WDS_CLI_IMAGE_TYPE -_WDS_CLI_FIRMWARE_TYPE=WDS_CLI_FIRMWARE_TYPE -_WDS_CLI_IMAGE_PARAM_TYPE=WDS_CLI_IMAGE_PARAM_TYPE -tagPXE_DHCP_OPTION=PXE_DHCP_OPTION -tagPXE_DHCP_MESSAGE=PXE_DHCP_MESSAGE -tagPXE_DHCPV6_OPTION=PXE_DHCPV6_OPTION -tagPXE_DHCPV6_MESSAGE_HEADER=PXE_DHCPV6_MESSAGE_HEADER -tagPXE_DHCPV6_MESSAGE=PXE_DHCPV6_MESSAGE -tagPXE_DHCPV6_RELAY_MESSAGE=PXE_DHCPV6_RELAY_MESSAGE -tagPXE_PROVIDER=PXE_PROVIDER -tagPXE_ADDRESS=PXE_ADDRESS -tagPXE_DHCPV6_NESTED_RELAY_MESSAGE=PXE_DHCPV6_NESTED_RELAY_MESSAGE -_TRANSPORTPROVIDER_CALLBACK_ID=TRANSPORTPROVIDER_CALLBACK_ID -_WDS_TRANSPORTPROVIDER_INIT_PARAMS=WDS_TRANSPORTPROVIDER_INIT_PARAMS -_WDS_TRANSPORTPROVIDER_SETTINGS=WDS_TRANSPORTPROVIDER_SETTINGS -_TRANSPORTCLIENT_CALLBACK_ID=TRANSPORTCLIENT_CALLBACK_ID -_TRANSPORTCLIENT_SESSION_INFO=TRANSPORTCLIENT_SESSION_INFO -_WDS_TRANSPORTCLIENT_REQUEST=WDS_TRANSPORTCLIENT_REQUEST -_WDS_TRANSPORTCLIENT_CALLBACKS=WDS_TRANSPORTCLIENT_CALLBACKS -_DAV_CALLBACK_AUTH_BLOB=DAV_CALLBACK_AUTH_BLOB -_DAV_CALLBACK_AUTH_UNP=DAV_CALLBACK_AUTH_UNP -_DAV_CALLBACK_CRED=DAV_CALLBACK_CRED -_EC_SUBSCRIPTION_PROPERTY_ID=EC_SUBSCRIPTION_PROPERTY_ID -_EC_SUBSCRIPTION_CREDENTIALS_TYPE=EC_SUBSCRIPTION_CREDENTIALS_TYPE -_EC_SUBSCRIPTION_TYPE=EC_SUBSCRIPTION_TYPE -_EC_SUBSCRIPTION_RUNTIME_STATUS_INFO_ID=EC_SUBSCRIPTION_RUNTIME_STATUS_INFO_ID -_EC_VARIANT_TYPE=EC_VARIANT_TYPE -_EC_VARIANT=EC_VARIANT -_EC_SUBSCRIPTION_CONFIGURATION_MODE=EC_SUBSCRIPTION_CONFIGURATION_MODE -_EC_SUBSCRIPTION_DELIVERY_MODE=EC_SUBSCRIPTION_DELIVERY_MODE -_EC_SUBSCRIPTION_CONTENT_FORMAT=EC_SUBSCRIPTION_CONTENT_FORMAT -_EC_SUBSCRIPTION_RUNTIME_STATUS_ACTIVE_STATUS=EC_SUBSCRIPTION_RUNTIME_STATUS_ACTIVE_STATUS -_UI_EVENTPARAMS_COMMAND=UI_EVENTPARAMS_COMMAND -_UI_EVENTPARAMS=UI_EVENTPARAMS -_INTERNET_BUFFERSA=INTERNET_BUFFERSA -_INTERNET_BUFFERSW=INTERNET_BUFFERSW -_INTERNET_CACHE_ENTRY_INFOA=INTERNET_CACHE_ENTRY_INFOA -_INTERNET_CACHE_ENTRY_INFOW=INTERNET_CACHE_ENTRY_INFOW -_INTERNET_CACHE_TIMESTAMPS=INTERNET_CACHE_TIMESTAMPS -_INTERNET_CACHE_GROUP_INFOA=INTERNET_CACHE_GROUP_INFOA -_INTERNET_CACHE_GROUP_INFOW=INTERNET_CACHE_GROUP_INFOW -_INTERNET_DOWNLOAD_MODE_HANDLE=INTERNET_DOWNLOAD_MODE_HANDLE -_REQUEST_TIMES=REQUEST_TIMES -_HTTP_REQUEST_TIMES=HTTP_REQUEST_TIMES -_INTERNET_SERVER_CONNECTION_STATE=INTERNET_SERVER_CONNECTION_STATE -_INTERNET_END_BROWSER_SESSION_DATA=INTERNET_END_BROWSER_SESSION_DATA -_INTERNET_CALLBACK_COOKIE=INTERNET_CALLBACK_COOKIE -_INTERNET_CREDENTIALS=INTERNET_CREDENTIALS -_HTTP_PUSH_TRANSPORT_SETTING=HTTP_PUSH_TRANSPORT_SETTING -_HTTP_PUSH_NOTIFICATION_STATUS=HTTP_PUSH_NOTIFICATION_STATUS -_HTTP_PUSH_WAIT_TYPE=HTTP_PUSH_WAIT_TYPE -_INTERNET_COOKIE=INTERNET_COOKIE -_COOKIE_DLG_INFO=COOKIE_DLG_INFO -_INTERNET_CACHE_CONFIG_PATH_ENTRYA=INTERNET_CACHE_CONFIG_PATH_ENTRYA -_INTERNET_CACHE_CONFIG_PATH_ENTRYW=INTERNET_CACHE_CONFIG_PATH_ENTRYW -_INTERNET_CACHE_CONFIG_INFOA=INTERNET_CACHE_CONFIG_INFOA -_INTERNET_CACHE_CONFIG_INFOW=INTERNET_CACHE_CONFIG_INFOW -_INTERNET_CACHE_CONTAINER_INFOA=INTERNET_CACHE_CONTAINER_INFOA -_INTERNET_CACHE_CONTAINER_INFOW=INTERNET_CACHE_CONTAINER_INFOW -_APP_CACHE_STATE=APP_CACHE_STATE -_APP_CACHE_DOWNLOAD_ENTRY=APP_CACHE_DOWNLOAD_ENTRY -_APP_CACHE_DOWNLOAD_LIST=APP_CACHE_DOWNLOAD_LIST -_APP_CACHE_FINALIZE_STATE=APP_CACHE_FINALIZE_STATE -_APP_CACHE_GROUP_INFO=APP_CACHE_GROUP_INFO -_APP_CACHE_GROUP_LIST=APP_CACHE_GROUP_LIST -_URLCACHE_ENTRY_INFO=URLCACHE_ENTRY_INFO -_URL_CACHE_LIMIT_TYPE=URL_CACHE_LIMIT_TYPE -_WININET_PROXY_INFO=WININET_PROXY_INFO -_WININET_PROXY_INFO_LIST=WININET_PROXY_INFO_LIST -_HTTP_WEB_SOCKET_OPERATION=HTTP_WEB_SOCKET_OPERATION -_HTTP_WEB_SOCKET_BUFFER_TYPE=HTTP_WEB_SOCKET_BUFFER_TYPE -_HTTP_WEB_SOCKET_CLOSE_STATUS=HTTP_WEB_SOCKET_CLOSE_STATUS -_HTTP_WEB_SOCKET_ASYNC_RESULT=HTTP_WEB_SOCKET_ASYNC_RESULT -_AVRF_BACKTRACE_INFORMATION=AVRF_BACKTRACE_INFORMATION -_AVRF_HEAP_ALLOCATION=AVRF_HEAP_ALLOCATION -_AVRF_HANDLE_OPERATION=AVRF_HANDLE_OPERATION -_SEGMENT_NOTE=SEGMENT_NOTE -_IMAGE_NOTE=IMAGE_NOTE -_TEMP_BP_NOTE=TEMP_BP_NOTE -_VDM_SEGINFO=VDM_SEGINFO -_FH_TARGET_PROPERTY_TYPE=FH_TARGET_PROPERTY_TYPE -_FH_TARGET_DRIVE_TYPES=FH_TARGET_DRIVE_TYPES -_FH_PROTECTED_ITEM_CATEGORY=FH_PROTECTED_ITEM_CATEGORY -_FH_LOCAL_POLICY_TYPE=FH_LOCAL_POLICY_TYPE -_FH_RETENTION_TYPES=FH_RETENTION_TYPES -_FH_BACKUP_STATUS=FH_BACKUP_STATUS -_FH_DEVICE_VALIDATION_RESULT=FH_DEVICE_VALIDATION_RESULT -_PERUSERSECTIONA=PERUSERSECTIONA -_PERUSERSECTIONW=PERUSERSECTIONW -tagIMESTRUCT=IMESTRUCT -tagUNDETERMINESTRUCT=UNDETERMINESTRUCT -tagSTRINGEXSTRUCT=STRINGEXSTRUCT -_tagDATETIME=DATETIME -_tagIMEPROA=IMEPROA -_tagIMEPROW=IMEPROW -_SECURITY_PRODUCT_TYPE=SECURITY_PRODUCT_TYPE -_WSC_SECURITY_SIGNATURE_STATUS=WSC_SECURITY_SIGNATURE_STATUS -_WSC_SECURITY_PROVIDER=WSC_SECURITY_PROVIDER -_WSC_SECURITY_PROVIDER_HEALTH=WSC_SECURITY_PROVIDER_HEALTH -_WSMAN_DATA_TEXT=WSMAN_DATA_TEXT -_WSMAN_DATA_BINARY=WSMAN_DATA_BINARY -_WSMAN_DATA=WSMAN_DATA -_WSMAN_ERROR=WSMAN_ERROR -_WSMAN_USERNAME_PASSWORD_CREDS=WSMAN_USERNAME_PASSWORD_CREDS -_WSMAN_AUTHENTICATION_CREDENTIALS=WSMAN_AUTHENTICATION_CREDENTIALS -_WSMAN_OPTION=WSMAN_OPTION -_WSMAN_OPTION_SET=WSMAN_OPTION_SET -_WSMAN_OPTION_SETEX=WSMAN_OPTION_SETEX -_WSMAN_KEY=WSMAN_KEY -_WSMAN_SELECTOR_SET=WSMAN_SELECTOR_SET -_WSMAN_FRAGMENT=WSMAN_FRAGMENT -_WSMAN_FILTER=WSMAN_FILTER -_WSMAN_OPERATION_INFO=WSMAN_OPERATION_INFO -_WSMAN_OPERATION_INFOEX=WSMAN_OPERATION_INFOEX -_WSMAN_PROXY_INFO=WSMAN_PROXY_INFO -_WSMAN_STREAM_ID_SET=WSMAN_STREAM_ID_SET -_WSMAN_ENVIRONMENT_VARIABLE=WSMAN_ENVIRONMENT_VARIABLE -_WSMAN_ENVIRONMENT_VARIABLE_SET=WSMAN_ENVIRONMENT_VARIABLE_SET -_WSMAN_SHELL_STARTUP_INFO_V10=WSMAN_SHELL_STARTUP_INFO_V10 -_WSMAN_SHELL_STARTUP_INFO_V11=WSMAN_SHELL_STARTUP_INFO_V11 -_WSMAN_SHELL_DISCONNECT_INFO=WSMAN_SHELL_DISCONNECT_INFO -_WSMAN_RECEIVE_DATA_RESULT=WSMAN_RECEIVE_DATA_RESULT -_WSMAN_CONNECT_DATA=WSMAN_CONNECT_DATA -_WSMAN_CREATE_SHELL_DATA=WSMAN_CREATE_SHELL_DATA -_WSMAN_RESPONSE_DATA=WSMAN_RESPONSE_DATA -_WSMAN_SHELL_ASYNC=WSMAN_SHELL_ASYNC -_WSMAN_COMMAND_ARG_SET=WSMAN_COMMAND_ARG_SET -_WSMAN_CERTIFICATE_DETAILS=WSMAN_CERTIFICATE_DETAILS -_WSMAN_SENDER_DETAILS=WSMAN_SENDER_DETAILS -_WSMAN_PLUGIN_REQUEST=WSMAN_PLUGIN_REQUEST -_WSMAN_AUTHZ_QUOTA=WSMAN_AUTHZ_QUOTA -_WSManSessionFlags=WSManSessionFlags -_WSManEnumFlags=WSManEnumFlags -_WSManProxyAccessTypeFlags=WSManProxyAccessTypeFlags -_WSManProxyAuthenticationFlags=WSManProxyAuthenticationFlags -_ID_PARAMETER_PAIR=ID_PARAMETER_PAIR -_ID_PARAMETERS=ID_PARAMETERS -_SYNC_SESSION_STATISTICS=SYNC_SESSION_STATISTICS -_SYNC_VERSION=SYNC_VERSION -_SYNC_RANGE=SYNC_RANGE -_SYNC_TIME=SYNC_TIME -_SYNC_FILTER_CHANGE=SYNC_FILTER_CHANGE -_SyncProviderConfiguration=SyncProviderConfiguration -_SyncProviderConfigUIConfiguration=SyncProviderConfigUIConfiguration -tagWMDM_TAG_DATATYPE=WMDM_TAG_DATATYPE -tagWMDM_SESSION_TYPE=WMDM_SESSION_TYPE -_tagWMFILECAPABILITIES=WMFILECAPABILITIES -_WMDMDATETIME=WMDMDATETIME -tagWMDM_STORAGE_ENUM_MODE=WMDM_STORAGE_ENUM_MODE -tagWMDM_FORMATCODE=WMDM_FORMATCODE -_WMDM_ENUM_PROP_VALID_VALUES_FORM=WMDM_ENUM_PROP_VALID_VALUES_FORM -_WMDM_PROP_VALUES_RANGE=WMDM_PROP_VALUES_RANGE -_WMDM_PROP_VALUES_ENUM=WMDM_PROP_VALUES_ENUM -_WMDM_PROP_DESC=WMDM_PROP_DESC -_WMDM_PROP_CONFIG=WMDM_PROP_CONFIG -_WMDM_FORMAT_CAPABILITY=WMDM_FORMAT_CAPABILITY -tagWMDM_FIND_SCOPE=WMDM_FIND_SCOPE -tagWMT_STORAGE_FORMAT=WMT_STORAGE_FORMAT -tagWMT_DRMLA_TRUST=WMT_DRMLA_TRUST -tagWMT_TRANSPORT_TYPE=WMT_TRANSPORT_TYPE -tagWMT_OFFSET_FORMAT=WMT_OFFSET_FORMAT -tagWMT_INDEXER_TYPE=WMT_INDEXER_TYPE -tagWMT_INDEX_TYPE=WMT_INDEX_TYPE -tagWMT_FILESINK_MODE=WMT_FILESINK_MODE -tagWMT_MUSICSPEECH_CLASS_MODE=WMT_MUSICSPEECH_CLASS_MODE -tagWMT_WATERMARK_ENTRY_TYPE=WMT_WATERMARK_ENTRY_TYPE -_WMT_BUFFER_SEGMENT=WMT_BUFFER_SEGMENT -_WMT_PAYLOAD_FRAGMENT=WMT_PAYLOAD_FRAGMENT -_WMT_FILESINK_DATA_UNIT=WMT_FILESINK_DATA_UNIT -_WMT_WEBSTREAM_FORMAT=WMT_WEBSTREAM_FORMAT -_WMT_WEBSTREAM_SAMPLE_HEADER=WMT_WEBSTREAM_SAMPLE_HEADER -tagWMVIDEOINFOHEADER=WMVIDEOINFOHEADER -tagWMVIDEOINFOHEADER2=WMVIDEOINFOHEADER2 -tagWMMPEG2VIDEOINFO=WMMPEG2VIDEOINFO -tagWMSCRIPTFORMAT=WMSCRIPTFORMAT -_WMT_COLORSPACEINFO_EXTENSION_DATA=WMT_COLORSPACEINFO_EXTENSION_DATA -_WMT_TIMECODE_EXTENSION_DATA=WMT_TIMECODE_EXTENSION_DATA -_DRM_VAL16=DRM_VAL16 -tagTimedLevel=TimedLevel -_WMP_WMDM_METADATA_ROUND_TRIP_PC2DEVICE=WMP_WMDM_METADATA_ROUND_TRIP_PC2DEVICE -_WMP_WMDM_METADATA_ROUND_TRIP_DEVICE2PC=WMP_WMDM_METADATA_ROUND_TRIP_DEVICE2PC -_WNV_NOTIFICATION_TYPE=WNV_NOTIFICATION_TYPE -_WNV_OBJECT_TYPE=WNV_OBJECT_TYPE -_WNV_CA_NOTIFICATION_TYPE=WNV_CA_NOTIFICATION_TYPE -_WNV_OBJECT_HEADER=WNV_OBJECT_HEADER -_WNV_NOTIFICATION_PARAM=WNV_NOTIFICATION_PARAM -_WNV_IP_ADDRESS=WNV_IP_ADDRESS -_WNV_POLICY_MISMATCH_PARAM=WNV_POLICY_MISMATCH_PARAM -_WNV_PROVIDER_ADDRESS_CHANGE_PARAM=WNV_PROVIDER_ADDRESS_CHANGE_PARAM -_WNV_CUSTOMER_ADDRESS_CHANGE_PARAM=WNV_CUSTOMER_ADDRESS_CHANGE_PARAM -_WNV_OBJECT_CHANGE_PARAM=WNV_OBJECT_CHANGE_PARAM -_WNV_REDIRECT_PARAM=WNV_REDIRECT_PARAM -tagDELETE_OBJECT_OPTIONS=DELETE_OBJECT_OPTIONS -tagWPD_DEVICE_TYPES=WPD_DEVICE_TYPES -tagWpdAttributeForm=WpdAttributeForm -tagWpdParameterAttributeForm=WpdParameterAttributeForm -tagWPD_DEVICE_TRANSPORTS=WPD_DEVICE_TRANSPORTS -tagWPD_STORAGE_TYPE_VALUES=WPD_STORAGE_TYPE_VALUES -tagWPD_STORAGE_ACCESS_CAPABILITY_VALUES=WPD_STORAGE_ACCESS_CAPABILITY_VALUES -tagWPD_SMS_ENCODING_TYPES=WPD_SMS_ENCODING_TYPES -tagSMS_MESSAGE_TYPES=SMS_MESSAGE_TYPES -tagWPD_POWER_SOURCES=WPD_POWER_SOURCES -tagWPD_WHITE_BALANCE_SETTINGS=WPD_WHITE_BALANCE_SETTINGS -tagWPD_FOCUS_MODES=WPD_FOCUS_MODES -tagWPD_EXPOSURE_METERING_MODES=WPD_EXPOSURE_METERING_MODES -tagWPD_FLASH_MODES=WPD_FLASH_MODES -tagWPD_EXPOSURE_PROGRAM_MODES=WPD_EXPOSURE_PROGRAM_MODES -tagWPD_CAPTURE_MODES=WPD_CAPTURE_MODES -tagWPD_EFFECT_MODES=WPD_EFFECT_MODES -tagWPD_FOCUS_METERING_MODES=WPD_FOCUS_METERING_MODES -tagWPD_BITRATE_TYPES=WPD_BITRATE_TYPES -tagWPD_META_GENRES=WPD_META_GENRES -tagWPD_CROPPED_STATUS_VALUES=WPD_CROPPED_STATUS_VALUES -tagWPD_COLOR_CORRECTED_STATUS_VALUES=WPD_COLOR_CORRECTED_STATUS_VALUES -tagWPD_VIDEO_SCAN_TYPES=WPD_VIDEO_SCAN_TYPES -tagWPD_OPERATION_STATES=WPD_OPERATION_STATES -tagWPD_SECTION_DATA_UNITS_VALUES=WPD_SECTION_DATA_UNITS_VALUES -tagWPD_RENDERING_INFORMATION_PROFILE_ENTRY_TYPES=WPD_RENDERING_INFORMATION_PROFILE_ENTRY_TYPES -tagWPD_COMMAND_ACCESS_TYPES=WPD_COMMAND_ACCESS_TYPES -tagWPD_SERVICE_INHERITANCE_TYPES=WPD_SERVICE_INHERITANCE_TYPES -tagWPD_PARAMETER_USAGE_TYPES=WPD_PARAMETER_USAGE_TYPES -tagWPD_COMMAND_ACCESS_LOOKUP_ENTRY=WPD_COMMAND_ACCESS_LOOKUP_ENTRY -tagWPD_STREAM_UNITS=WPD_STREAM_UNITS -_WSB_OB_STATUS_ENTRY_PAIR_TYPE=WSB_OB_STATUS_ENTRY_PAIR_TYPE -_WSB_OB_STATUS_ENTRY_VALUE_TYPE_PAIR=WSB_OB_STATUS_ENTRY_VALUE_TYPE_PAIR -_WSB_OB_STATUS_ENTRY=WSB_OB_STATUS_ENTRY -_WSB_OB_STATUS_INFO=WSB_OB_STATUS_INFO -_WSB_OB_REGISTRATION_INFO=WSB_OB_REGISTRATION_INFO -tagAutomaticUpdatesNotificationLevel=AutomaticUpdatesNotificationLevel -tagAutomaticUpdatesScheduledInstallationDay=AutomaticUpdatesScheduledInstallationDay -tagDownloadPhase=DownloadPhase -tagDownloadPriority=DownloadPriority -tagAutoSelectionMode=AutoSelectionMode -tagAutoDownloadMode=AutoDownloadMode -tagInstallationImpact=InstallationImpact -tagInstallationRebootBehavior=InstallationRebootBehavior -tagOperationResultCode=OperationResultCode -tagServerSelection=ServerSelection -tagUpdateType=UpdateType -tagUpdateOperation=UpdateOperation -tagDeploymentAction=DeploymentAction -tagUpdateExceptionContext=UpdateExceptionContext -tagAutomaticUpdatesUserType=AutomaticUpdatesUserType -tagAutomaticUpdatesPermissionType=AutomaticUpdatesPermissionType -tagUpdateServiceRegistrationState=UpdateServiceRegistrationState -tagSearchScope=SearchScope -tagUpdateLockdownOption=UpdateLockdownOption -tagAddServiceFlag=AddServiceFlag -tagUpdateServiceOption=UpdateServiceOption -_XBL_IDP_AUTH_TOKEN_STATUS=XBL_IDP_AUTH_TOKEN_STATUS -tagEDefaultDevmodeType=EDefaultDevmodeType -_UNWIND_HISTORY_TABLE_ENTRY=UNWIND_HISTORY_TABLE_ENTRY -_UNWIND_HISTORY_TABLE=UNWIND_HISTORY_TABLE _DISPATCHER_CONTEXT=DISPATCHER_CONTEXT -_XYZColorF=XYZColorF -_JChColorF=JChColorF -_JabColorF=JabColorF -_GamutShellTriangle=GamutShellTriangle -_GamutShell=GamutShell -_PrimaryJabColors=PrimaryJabColors -_PrimaryXYZColors=PrimaryXYZColors -_GamutBoundaryDescription=GamutBoundaryDescription -_BlackInformation=BlackInformation -tagEFaultRepRetVal=EFaultRepRetVal -_EVT_VARIANT_TYPE=EVT_VARIANT_TYPE -_EVT_VARIANT=EVT_VARIANT -_EVT_LOGIN_CLASS=EVT_LOGIN_CLASS -_EVT_RPC_LOGIN_FLAGS=EVT_RPC_LOGIN_FLAGS -_EVT_RPC_LOGIN=EVT_RPC_LOGIN -_EVT_QUERY_FLAGS=EVT_QUERY_FLAGS -_EVT_SEEK_FLAGS=EVT_SEEK_FLAGS -_EVT_SUBSCRIBE_FLAGS=EVT_SUBSCRIBE_FLAGS -_EVT_SUBSCRIBE_NOTIFY_ACTION=EVT_SUBSCRIBE_NOTIFY_ACTION -_EVT_SYSTEM_PROPERTY_ID=EVT_SYSTEM_PROPERTY_ID -_EVT_RENDER_CONTEXT_FLAGS=EVT_RENDER_CONTEXT_FLAGS -_EVT_RENDER_FLAGS=EVT_RENDER_FLAGS -_EVT_FORMAT_MESSAGE_FLAGS=EVT_FORMAT_MESSAGE_FLAGS -_EVT_OPEN_LOG_FLAGS=EVT_OPEN_LOG_FLAGS -_EVT_LOG_PROPERTY_ID=EVT_LOG_PROPERTY_ID -_EVT_EXPORTLOG_FLAGS=EVT_EXPORTLOG_FLAGS -_EVT_CHANNEL_CONFIG_PROPERTY_ID=EVT_CHANNEL_CONFIG_PROPERTY_ID -_EVT_CHANNEL_TYPE=EVT_CHANNEL_TYPE -_EVT_CHANNEL_ISOLATION_TYPE=EVT_CHANNEL_ISOLATION_TYPE -_EVT_CHANNEL_CLOCK_TYPE=EVT_CHANNEL_CLOCK_TYPE -_EVT_CHANNEL_SID_TYPE=EVT_CHANNEL_SID_TYPE -_EVT_CHANNEL_REFERENCE_FLAGS=EVT_CHANNEL_REFERENCE_FLAGS -_EVT_PUBLISHER_METADATA_PROPERTY_ID=EVT_PUBLISHER_METADATA_PROPERTY_ID -_EVT_EVENT_METADATA_PROPERTY_ID=EVT_EVENT_METADATA_PROPERTY_ID -_EVT_QUERY_PROPERTY_ID=EVT_QUERY_PROPERTY_ID -_EVT_EVENT_PROPERTY_ID=EVT_EVENT_PROPERTY_ID -_DLSID=DLSID -_DLSVERSION=DLSVERSION -_CONNECTION=CONNECTION -_CONNECTIONLIST=CONNECTIONLIST -_RGNRANGE=RGNRANGE -_MIDILOCALE=MIDILOCALE -_RGNHEADER=RGNHEADER -_INSTHEADER=INSTHEADER -_DLSHEADER=DLSHEADER -_WAVELINK=WAVELINK -_POOLCUE=POOLCUE -_POOLTABLE=POOLTABLE -_DMUS_DOWNLOADINFO=DMUS_DOWNLOADINFO -_DMUS_OFFSETTABLE=DMUS_OFFSETTABLE -_DMUS_INSTRUMENT=DMUS_INSTRUMENT -_DMUS_REGION=DMUS_REGION -_DMUS_LFOPARAMS=DMUS_LFOPARAMS -_DMUS_VEGPARAMS=DMUS_VEGPARAMS -_DMUS_PEGPARAMS=DMUS_PEGPARAMS -_DMUS_MSCPARAMS=DMUS_MSCPARAMS -_DMUS_ARTICPARAMS=DMUS_ARTICPARAMS -_DMUS_ARTICULATION=DMUS_ARTICULATION -_DMUS_ARTICULATION2=DMUS_ARTICULATION2 -_DMUS_EXTENSIONCHUNK=DMUS_EXTENSIONCHUNK -_DMUS_COPYRIGHT=DMUS_COPYRIGHT -_DMUS_WAVEDATA=DMUS_WAVEDATA -_DMUS_WAVE=DMUS_WAVE -_DMUS_NOTERANGE=DMUS_NOTERANGE -_DMUS_WAVEARTDL=DMUS_WAVEARTDL -_DMUS_WAVEDL=DMUS_WAVEDL -_DSCAPS=DSCAPS -_DSBCAPS=DSBCAPS -_DSEFFECTDESC=DSEFFECTDESC -_DSCEFFECTDESC=DSCEFFECTDESC -_DSBUFFERDESC=DSBUFFERDESC -_DSBUFFERDESC1=DSBUFFERDESC1 -_DS3DBUFFER=DS3DBUFFER -_DS3DLISTENER=DS3DLISTENER -_DSCCAPS=DSCCAPS -_DSCBUFFERDESC1=DSCBUFFERDESC1 -_DSCBUFFERDESC=DSCBUFFERDESC -_DSCBCAPS=DSCBCAPS -_DSBPOSITIONNOTIFY=DSBPOSITIONNOTIFY -_DSFXGargle=DSFXGargle -_DSFXChorus=DSFXChorus -_DSFXFlanger=DSFXFlanger -_DSFXEcho=DSFXEcho -_DSFXDistortion=DSFXDistortion -_DSFXCompressor=DSFXCompressor -_DSFXParamEq=DSFXParamEq -_DSFXI3DL2Reverb=DSFXI3DL2Reverb -_DSFXWavesReverb=DSFXWavesReverb -_DSCFXAec=DSCFXAec -_DSCFXNoiseSuppress=DSCFXNoiseSuppress -_DMUS_EVENTHEADER=DMUS_EVENTHEADER -_DMUS_BUFFERDESC=DMUS_BUFFERDESC -_DMUS_PORTCAPS=DMUS_PORTCAPS -_DMUS_PORTPARAMS8=DMUS_PORTPARAMS8 -_DMUS_SYNTHSTATS=DMUS_SYNTHSTATS -_DMUS_SYNTHSTATS8=DMUS_SYNTHSTATS8 -_DMUS_WAVES_REVERB_PARAMS=DMUS_WAVES_REVERB_PARAMS -_DMUS_CLOCKINFO7=DMUS_CLOCKINFO7 -_DMUS_CLOCKINFO8=DMUS_CLOCKINFO8 tagKSP_PINMODE=KSP_PINMODE -_WIA_RAW_HEADER=WIA_RAW_HEADER -_WIA_BARCODE_INFO=WIA_BARCODE_INFO -_WIA_BARCODES=WIA_BARCODES -_WIA_PATCH_CODE_INFO=WIA_PATCH_CODE_INFO -_WIA_PATCH_CODES=WIA_PATCH_CODES -_WIA_MICR_INFO=WIA_MICR_INFO -_WIA_MICR=WIA_MICR -_DDVIDEOPORTCONNECT=DDVIDEOPORTCONNECT -_DDVIDEOPORTCAPS=DDVIDEOPORTCAPS -_DDVIDEOPORTDESC=DDVIDEOPORTDESC -_DDVIDEOPORTINFO=DDVIDEOPORTINFO -_DDVIDEOPORTBANDWIDTH=DDVIDEOPORTBANDWIDTH -_DDVIDEOPORTSTATUS=DDVIDEOPORTSTATUS -_DDVIDEOPORTNOTIFY=DDVIDEOPORTNOTIFY -_VIDEOMEMORY=VIDEOMEMORY -_VIDEOMEMORYINFO=VIDEOMEMORYINFO -_DD_MISCELLANEOUSCALLBACKS=DD_MISCELLANEOUSCALLBACKS -_DD_MISCELLANEOUS2CALLBACKS=DD_MISCELLANEOUS2CALLBACKS -_DD_NTCALLBACKS=DD_NTCALLBACKS -_DD_COLORCONTROLCALLBACKS=DD_COLORCONTROLCALLBACKS -_DD_NONLOCALVIDMEMCAPS=DD_NONLOCALVIDMEMCAPS -_DD_PALETTE_GLOBAL=DD_PALETTE_GLOBAL -_DD_PALETTE_LOCAL=DD_PALETTE_LOCAL -_DD_CLIPPER_GLOBAL=DD_CLIPPER_GLOBAL -_DD_CLIPPER_LOCAL=DD_CLIPPER_LOCAL -_DD_ATTACHLIST=DD_ATTACHLIST -_DD_SURFACE_INT=DD_SURFACE_INT -_DD_SURFACE_GLOBAL=DD_SURFACE_GLOBAL -_DD_SURFACE_MORE=DD_SURFACE_MORE -_DD_SURFACE_LOCAL=DD_SURFACE_LOCAL -_DD_MORECAPS=DD_MORECAPS -_DDNTCORECAPS=DDNTCORECAPS -_DD_D3DBUFCALLBACKS=DD_D3DBUFCALLBACKS -_DD_HALINFO_V4=DD_HALINFO_V4 -_DD_HALINFO=DD_HALINFO -_DD_DIRECTDRAW_GLOBAL=DD_DIRECTDRAW_GLOBAL -_DD_DIRECTDRAW_LOCAL=DD_DIRECTDRAW_LOCAL -_DD_VIDEOPORT_LOCAL=DD_VIDEOPORT_LOCAL -_DD_MOTIONCOMP_LOCAL=DD_MOTIONCOMP_LOCAL -_DD_MORESURFACECAPS=DD_MORESURFACECAPS -_DD_STEREOMODE=DD_STEREOMODE -_DD_UPDATENONLOCALHEAPDATA=DD_UPDATENONLOCALHEAPDATA -_DD_BLTDATA=DD_BLTDATA -_DD_LOCKDATA=DD_LOCKDATA -_DD_UNLOCKDATA=DD_UNLOCKDATA -_DD_UPDATEOVERLAYDATA=DD_UPDATEOVERLAYDATA -_DD_SETOVERLAYPOSITIONDATA=DD_SETOVERLAYPOSITIONDATA -_DD_SETPALETTEDATA=DD_SETPALETTEDATA -_DD_FLIPDATA=DD_FLIPDATA -_DD_DESTROYSURFACEDATA=DD_DESTROYSURFACEDATA -_DD_SETCLIPLISTDATA=DD_SETCLIPLISTDATA -_DD_ADDATTACHEDSURFACEDATA=DD_ADDATTACHEDSURFACEDATA -_DD_SETCOLORKEYDATA=DD_SETCOLORKEYDATA -_DD_GETBLTSTATUSDATA=DD_GETBLTSTATUSDATA -_DD_GETFLIPSTATUSDATA=DD_GETFLIPSTATUSDATA -_DD_DESTROYPALETTEDATA=DD_DESTROYPALETTEDATA -_DD_SETENTRIESDATA=DD_SETENTRIESDATA -_DD_CREATESURFACEDATA=DD_CREATESURFACEDATA -_DD_CANCREATESURFACEDATA=DD_CANCREATESURFACEDATA -_DD_CREATEPALETTEDATA=DD_CREATEPALETTEDATA -_DD_WAITFORVERTICALBLANKDATA=DD_WAITFORVERTICALBLANKDATA -_DD_DRVSETCOLORKEYDATA=DD_DRVSETCOLORKEYDATA -_DD_GETSCANLINEDATA=DD_GETSCANLINEDATA -_DD_MAPMEMORYDATA=DD_MAPMEMORYDATA -_DD_CANCREATEVPORTDATA=DD_CANCREATEVPORTDATA -_DD_CREATEVPORTDATA=DD_CREATEVPORTDATA -_DD_FLIPVPORTDATA=DD_FLIPVPORTDATA -_DD_GETVPORTBANDWIDTHDATA=DD_GETVPORTBANDWIDTHDATA -_DD_GETVPORTINPUTFORMATDATA=DD_GETVPORTINPUTFORMATDATA -_DD_GETVPORTOUTPUTFORMATDATA=DD_GETVPORTOUTPUTFORMATDATA -_DD_GETVPORTFIELDDATA=DD_GETVPORTFIELDDATA -_DD_GETVPORTLINEDATA=DD_GETVPORTLINEDATA -_DD_GETVPORTCONNECTDATA=DD_GETVPORTCONNECTDATA -_DD_DESTROYVPORTDATA=DD_DESTROYVPORTDATA -_DD_GETVPORTFLIPSTATUSDATA=DD_GETVPORTFLIPSTATUSDATA -_DD_UPDATEVPORTDATA=DD_UPDATEVPORTDATA -_DD_WAITFORVPORTSYNCDATA=DD_WAITFORVPORTSYNCDATA -_DD_GETVPORTSIGNALDATA=DD_GETVPORTSIGNALDATA -_DD_VPORTCOLORDATA=DD_VPORTCOLORDATA -_DD_COLORCONTROLDATA=DD_COLORCONTROLDATA -_DD_GETDRIVERINFODATA=DD_GETDRIVERINFODATA -_DD_GETAVAILDRIVERMEMORYDATA=DD_GETAVAILDRIVERMEMORYDATA -_DD_FREEDRIVERMEMORYDATA=DD_FREEDRIVERMEMORYDATA -_DD_SETEXCLUSIVEMODEDATA=DD_SETEXCLUSIVEMODEDATA -_DD_FLIPTOGDISURFACEDATA=DD_FLIPTOGDISURFACEDATA -_DD_SYNCSURFACEDATA=DD_SYNCSURFACEDATA -_DD_SYNCVIDEOPORTDATA=DD_SYNCVIDEOPORTDATA -_DD_GETMOCOMPGUIDSDATA=DD_GETMOCOMPGUIDSDATA -_DD_GETMOCOMPFORMATSDATA=DD_GETMOCOMPFORMATSDATA -_DD_CREATEMOCOMPDATA=DD_CREATEMOCOMPDATA -_DDCOMPBUFFERINFO=DDCOMPBUFFERINFO -_DD_GETMOCOMPCOMPBUFFDATA=DD_GETMOCOMPCOMPBUFFDATA -_DD_GETINTERNALMOCOMPDATA=DD_GETINTERNALMOCOMPDATA -_DD_BEGINMOCOMPFRAMEDATA=DD_BEGINMOCOMPFRAMEDATA -_DD_ENDMOCOMPFRAMEDATA=DD_ENDMOCOMPFRAMEDATA -_DDMOCOMPBUFFERINFO=DDMOCOMPBUFFERINFO -_DD_RENDERMOCOMPDATA=DD_RENDERMOCOMPDATA -_DD_QUERYMOCOMPSTATUSDATA=DD_QUERYMOCOMPSTATUSDATA -_DD_DESTROYMOCOMPDATA=DD_DESTROYMOCOMPDATA -_DD_CREATESURFACEEXDATA=DD_CREATESURFACEEXDATA -_DD_GETDRIVERSTATEDATA=DD_GETDRIVERSTATEDATA -_DD_DESTROYDDLOCALDATA=DD_DESTROYDDLOCALDATA -_D3DHVERTEX=D3DHVERTEX -_D3DTLVERTEX=D3DTLVERTEX -_D3DLVERTEX=D3DLVERTEX -_D3DVERTEX=D3DVERTEX -_D3DVIEWPORT=D3DVIEWPORT -_D3DVIEWPORT2=D3DVIEWPORT2 -_D3DVIEWPORT7=D3DVIEWPORT7 -_D3DTRANSFORMDATA=D3DTRANSFORMDATA -_D3DLIGHTINGELEMENT=D3DLIGHTINGELEMENT -_D3DMATERIAL=D3DMATERIAL -_D3DMATERIAL7=D3DMATERIAL7 -_D3DLIGHT=D3DLIGHT -_D3DLIGHT7=D3DLIGHT7 -_D3DLIGHT2=D3DLIGHT2 -_D3DLIGHTDATA=D3DLIGHTDATA -_D3DOPCODE=D3DOPCODE -_D3DINSTRUCTION=D3DINSTRUCTION -_D3DTEXTURELOAD=D3DTEXTURELOAD -_D3DPICKRECORD=D3DPICKRECORD -_D3DLINEPATTERN=D3DLINEPATTERN -_D3DTEXTUREFILTER=D3DTEXTUREFILTER -_D3DTEXTUREBLEND=D3DTEXTUREBLEND -_D3DANTIALIASMODE=D3DANTIALIASMODE -_D3DVERTEXTYPE=D3DVERTEXTYPE -_D3DLIGHTSTATETYPE=D3DLIGHTSTATETYPE -_D3DSTATE=D3DSTATE -_D3DMATRIXLOAD=D3DMATRIXLOAD -_D3DMATRIXMULTIPLY=D3DMATRIXMULTIPLY -_D3DPROCESSVERTICES=D3DPROCESSVERTICES -_D3DTEXTUREMAGFILTER=D3DTEXTUREMAGFILTER -_D3DTEXTUREMINFILTER=D3DTEXTUREMINFILTER -_D3DTEXTUREMIPFILTER=D3DTEXTUREMIPFILTER -_D3DTRIANGLE=D3DTRIANGLE -_D3DLINE=D3DLINE -_D3DSPAN=D3DSPAN -_D3DPOINT=D3DPOINT -_D3DBRANCH=D3DBRANCH -_D3DSTATUS=D3DSTATUS -_D3DCLIPSTATUS=D3DCLIPSTATUS -_D3DSTATS=D3DSTATS -_D3DEXECUTEDATA=D3DEXECUTEDATA -_D3DVERTEXBUFFERDESC=D3DVERTEXBUFFERDESC -_D3DDP_PTRSTRIDE=D3DDP_PTRSTRIDE -_D3DDRAWPRIMITIVESTRIDEDDATA=D3DDRAWPRIMITIVESTRIDEDDATA -_D3DTRANSFORMCAPS=D3DTRANSFORMCAPS -_D3DLIGHTINGCAPS=D3DLIGHTINGCAPS -_D3DFINDDEVICESEARCH=D3DFINDDEVICESEARCH -_D3DFINDDEVICERESULT=D3DFINDDEVICERESULT -_D3DDEVINFO_TEXTUREMANAGER=D3DDEVINFO_TEXTUREMANAGER -_D3DDEVINFO_TEXTURING=D3DDEVINFO_TEXTURING -_D3DNTHAL_GLOBALDRIVERDATA=D3DNTHAL_GLOBALDRIVERDATA -_D3DNTHAL_D3DDX6EXTENDEDCAPS=D3DNTHAL_D3DDX6EXTENDEDCAPS -_D3DNTHAL_D3DEXTENDEDCAPS=D3DNTHAL_D3DEXTENDEDCAPS -_D3DNTHAL_CONTEXTCREATEDATA=D3DNTHAL_CONTEXTCREATEDATA -_D3DNTHAL_CONTEXTDESTROYDATA=D3DNTHAL_CONTEXTDESTROYDATA -_D3DNTHAL_CONTEXTDESTROYALLDATA=D3DNTHAL_CONTEXTDESTROYALLDATA -_D3DNTHAL_SCENECAPTUREDATA=D3DNTHAL_SCENECAPTUREDATA -_D3DNTHAL_TEXTURECREATEDATA=D3DNTHAL_TEXTURECREATEDATA -_D3DNTHAL_TEXTUREDESTROYDATA=D3DNTHAL_TEXTUREDESTROYDATA -_D3DNTHAL_TEXTURESWAPDATA=D3DNTHAL_TEXTURESWAPDATA -_D3DNTHAL_TEXTUREGETSURFDATA=D3DNTHAL_TEXTUREGETSURFDATA -_D3DNTHAL_CALLBACKS=D3DNTHAL_CALLBACKS -_D3DNTHAL_SETRENDERTARGETDATA=D3DNTHAL_SETRENDERTARGETDATA -_D3DNTHAL_CALLBACKS2=D3DNTHAL_CALLBACKS2 -_D3DNTHAL_CLEAR2DATA=D3DNTHAL_CLEAR2DATA -_D3DNTHAL_VALIDATETEXTURESTAGESTATEDATA=D3DNTHAL_VALIDATETEXTURESTAGESTATEDATA -_D3DNTHAL_DP2COMMAND=D3DNTHAL_DP2COMMAND -_D3DNTHAL_DP2OPERATION=D3DNTHAL_DP2OPERATION -_D3DNTHAL_DP2POINTS=D3DNTHAL_DP2POINTS -_D3DNTHAL_DP2STARTVERTEX=D3DNTHAL_DP2STARTVERTEX -_D3DNTHAL_DP2LINELIST=D3DNTHAL_DP2LINELIST -_D3DNTHAL_DP2INDEXEDLINELIST=D3DNTHAL_DP2INDEXEDLINELIST -_D3DNTHAL_DP2LINESTRIP=D3DNTHAL_DP2LINESTRIP -_D3DNTHAL_DP2INDEXEDLINESTRIP=D3DNTHAL_DP2INDEXEDLINESTRIP -_D3DNTHAL_DP2TRIANGLELIST=D3DNTHAL_DP2TRIANGLELIST -_D3DNTHAL_DP2INDEXEDTRIANGLELIST=D3DNTHAL_DP2INDEXEDTRIANGLELIST -_D3DNTHAL_DP2INDEXEDTRIANGLELIST2=D3DNTHAL_DP2INDEXEDTRIANGLELIST2 -_D3DNTHAL_DP2TRIANGLESTRIP=D3DNTHAL_DP2TRIANGLESTRIP -_D3DNTHAL_DP2INDEXEDTRIANGLESTRIP=D3DNTHAL_DP2INDEXEDTRIANGLESTRIP -_D3DNTHAL_DP2TRIANGLEFAN=D3DNTHAL_DP2TRIANGLEFAN -_D3DNTHAL_DP2INDEXEDTRIANGLEFAN=D3DNTHAL_DP2INDEXEDTRIANGLEFAN -_D3DNTHAL_DP2TRIANGLEFAN_IMM=D3DNTHAL_DP2TRIANGLEFAN_IMM -_D3DNTHAL_DP2RENDERSTATE=D3DNTHAL_DP2RENDERSTATE -_D3DNTHAL_DP2TEXTURESTAGESTATE=D3DNTHAL_DP2TEXTURESTAGESTATE -_D3DNTHAL_DP2VIEWPORTINFO=D3DNTHAL_DP2VIEWPORTINFO -_D3DNTHAL_DP2WINFO=D3DNTHAL_DP2WINFO -_D3DNTHAL_DP2SETPALETTE=D3DNTHAL_DP2SETPALETTE -_D3DNTHAL_DP2UPDATEPALETTE=D3DNTHAL_DP2UPDATEPALETTE -_D3DNTHAL_DP2SETRENDERTARGET=D3DNTHAL_DP2SETRENDERTARGET -_D3DNTHAL_DP2STATESET=D3DNTHAL_DP2STATESET -_D3DNTHAL_DP2ZRANGE=D3DNTHAL_DP2ZRANGE -_D3DNTHAL_DP2SETLIGHT=D3DNTHAL_DP2SETLIGHT -_D3DNTHAL_DP2SETCLIPPLANE=D3DNTHAL_DP2SETCLIPPLANE -_D3DNTHAL_DP2CREATELIGHT=D3DNTHAL_DP2CREATELIGHT -_D3DNTHAL_DP2SETTRANSFORM=D3DNTHAL_DP2SETTRANSFORM -_D3DNTHAL_DP2EXT=D3DNTHAL_DP2EXT -_D3DNTHAL_DP2TEXBLT=D3DNTHAL_DP2TEXBLT -_D3DNTHAL_DP2SETPRIORITY=D3DNTHAL_DP2SETPRIORITY -_D3DNTHAL_DP2CLEAR=D3DNTHAL_DP2CLEAR -_D3DNTHAL_DP2SETTEXLOD=D3DNTHAL_DP2SETTEXLOD -_D3DNTHAL_DRAWPRIMITIVES2DATA=D3DNTHAL_DRAWPRIMITIVES2DATA -_D3DNTHAL_CALLBACKS3=D3DNTHAL_CALLBACKS3 -_BG_FILE_PROGRESS=BG_FILE_PROGRESS -_BG_FILE_INFO=BG_FILE_INFO -_BG_JOB_PROGRESS=BG_JOB_PROGRESS -_BG_JOB_TIMES=BG_JOB_TIMES -_BG_JOB_REPLY_PROGRESS=BG_JOB_REPLY_PROGRESS -_BG_FILE_RANGE=BG_FILE_RANGE -_FILESETINFO=FILESETINFO _SdpAttributeRange=SdpAttributeRange -_SdpQueryUuid=SdpQueryUuid -_BTH_DEVICE_INFO=BTH_DEVICE_INFO -_BTH_RADIO_IN_RANGE=BTH_RADIO_IN_RANGE -_BTH_L2CAP_EVENT_INFO=BTH_L2CAP_EVENT_INFO -_BTH_HCI_EVENT_INFO=BTH_HCI_EVENT_INFO -_IO_CAPABILITY=IO_CAPABILITY -_AUTHENTICATION_REQUIREMENTS=AUTHENTICATION_REQUIREMENTS -_BTH_LE_UUID=BTH_LE_UUID -_BTH_LE_GATT_SERVICE=BTH_LE_GATT_SERVICE -_BTH_LE_GATT_DESCRIPTOR_TYPE=BTH_LE_GATT_DESCRIPTOR_TYPE -_BTH_LE_GATT_CHARACTERISTIC=BTH_LE_GATT_CHARACTERISTIC -_BTH_LE_GATT_CHARACTERISTIC_VALUE=BTH_LE_GATT_CHARACTERISTIC_VALUE -_BTH_LE_GATT_DESCRIPTOR=BTH_LE_GATT_DESCRIPTOR -_BTH_LE_GATT_DESCRIPTOR_VALUE=BTH_LE_GATT_DESCRIPTOR_VALUE -_BTH_LE_GATT_EVENT_TYPE=BTH_LE_GATT_EVENT_TYPE -_BLUETOOTH_GATT_VALUE_CHANGED_EVENT_REGISTRATION=BLUETOOTH_GATT_VALUE_CHANGED_EVENT_REGISTRATION -_BLUETOOTH_GATT_VALUE_CHANGED_EVENT=BLUETOOTH_GATT_VALUE_CHANGED_EVENT -_BLUETOOTH_FIND_RADIO_PARAMS=BLUETOOTH_FIND_RADIO_PARAMS -_BLUETOOTH_RADIO_INFO=BLUETOOTH_RADIO_INFO -_BLUETOOTH_AUTHENTICATION_METHOD=BLUETOOTH_AUTHENTICATION_METHOD -_BLUETOOTH_IO_CAPABILITY=BLUETOOTH_IO_CAPABILITY -_BLUETOOTH_AUTHENTICATION_REQUIREMENTS=BLUETOOTH_AUTHENTICATION_REQUIREMENTS -_BLUETOOTH_AUTHENTICATION_CALLBACK_PARAMS=BLUETOOTH_AUTHENTICATION_CALLBACK_PARAMS -_BLUETOOTH_DEVICE_SEARCH_PARAMS=BLUETOOTH_DEVICE_SEARCH_PARAMS -_BLUETOOTH_COD_PAIRS=BLUETOOTH_COD_PAIRS -_BLUETOOTH_SELECT_DEVICE_PARAMS=BLUETOOTH_SELECT_DEVICE_PARAMS -_BLUETOOTH_PIN_INFO=BLUETOOTH_PIN_INFO -_BLUETOOTH_OOB_DATA_INFO=BLUETOOTH_OOB_DATA_INFO -_BLUETOOTH_NUMERIC_COMPARISON_INFO=BLUETOOTH_NUMERIC_COMPARISON_INFO -_BLUETOOTH_PASSKEY_INFO=BLUETOOTH_PASSKEY_INFO -_BLUETOOTH_AUTHENTICATE_RESPONSE=BLUETOOTH_AUTHENTICATE_RESPONSE -_SDP_ELEMENT_DATA=SDP_ELEMENT_DATA -_SDP_STRING_TYPE_DATA=SDP_STRING_TYPE_DATA -_SOCKADDR_BTH=SOCKADDR_BTH -_BTH_SET_SERVICE=BTH_SET_SERVICE -_BTH_QUERY_DEVICE=BTH_QUERY_DEVICE -_BTH_QUERY_SERVICE=BTH_QUERY_SERVICE -_RFCOMM_MSC_DATA=RFCOMM_MSC_DATA -_RFCOMM_RLS_DATA=RFCOMM_RLS_DATA -_RFCOMM_RPN_DATA=RFCOMM_RPN_DATA -_RFCOMM_COMMAND=RFCOMM_COMMAND -_BTH_PING_REQ=BTH_PING_REQ -_BTH_PING_RSP=BTH_PING_RSP -_BTH_INFO_REQ=BTH_INFO_REQ -_BTH_INFO_RSP=BTH_INFO_RSP -_USB_DEVICE_SPEED=USB_DEVICE_SPEED -_USB_DEVICE_TYPE=USB_DEVICE_TYPE -_BM_REQUEST_TYPE=BM_REQUEST_TYPE -_USB_DEFAULT_PIPE_SETUP_PACKET=USB_DEFAULT_PIPE_SETUP_PACKET -_USB_DEVICE_STATUS=USB_DEVICE_STATUS -_USB_INTERFACE_STATUS=USB_INTERFACE_STATUS -_USB_ENDPOINT_STATUS=USB_ENDPOINT_STATUS -_USB_COMMON_DESCRIPTOR=USB_COMMON_DESCRIPTOR -_USB_DEVICE_DESCRIPTOR=USB_DEVICE_DESCRIPTOR -_USB_DEVICE_QUALIFIER_DESCRIPTOR=USB_DEVICE_QUALIFIER_DESCRIPTOR -_USB_BOS_DESCRIPTOR=USB_BOS_DESCRIPTOR -_USB_DEVICE_CAPABILITY_USB20_EXTENSION_DESCRIPTOR=USB_DEVICE_CAPABILITY_USB20_EXTENSION_DESCRIPTOR -_USB_DEVICE_CAPABILITY_POWER_DELIVERY_DESCRIPTOR=USB_DEVICE_CAPABILITY_POWER_DELIVERY_DESCRIPTOR -_USB_DEVICE_CAPABILITY_PD_CONSUMER_PORT_DESCRIPTOR=USB_DEVICE_CAPABILITY_PD_CONSUMER_PORT_DESCRIPTOR -_USB_DEVICE_CAPABILITY_SUPERSPEED_USB_DESCRIPTOR=USB_DEVICE_CAPABILITY_SUPERSPEED_USB_DESCRIPTOR -_USB_DEVICE_CAPABILITY_SUPERSPEEDPLUS_SPEED=USB_DEVICE_CAPABILITY_SUPERSPEEDPLUS_SPEED -_USB_DEVICE_CAPABILITY_SUPERSPEEDPLUS_USB_DESCRIPTOR=USB_DEVICE_CAPABILITY_SUPERSPEEDPLUS_USB_DESCRIPTOR -_USB_DEVICE_CAPABILITY_CONTAINER_ID_DESCRIPTOR=USB_DEVICE_CAPABILITY_CONTAINER_ID_DESCRIPTOR -_USB_DEVICE_CAPABILITY_PLATFORM_DESCRIPTOR=USB_DEVICE_CAPABILITY_PLATFORM_DESCRIPTOR -_USB_DEVICE_CAPABILITY_BILLBOARD_DESCRIPTOR=USB_DEVICE_CAPABILITY_BILLBOARD_DESCRIPTOR -_USB_DEVICE_CAPABILITY_FIRMWARE_STATUS_DESCRIPTOR=USB_DEVICE_CAPABILITY_FIRMWARE_STATUS_DESCRIPTOR -_USB_DEVICE_CAPABILITY_DESCRIPTOR=USB_DEVICE_CAPABILITY_DESCRIPTOR -_USB_CONFIGURATION_DESCRIPTOR=USB_CONFIGURATION_DESCRIPTOR -_USB_INTERFACE_ASSOCIATION_DESCRIPTOR=USB_INTERFACE_ASSOCIATION_DESCRIPTOR -_USB_INTERFACE_DESCRIPTOR=USB_INTERFACE_DESCRIPTOR -_USB_ENDPOINT_DESCRIPTOR=USB_ENDPOINT_DESCRIPTOR -_USB_HIGH_SPEED_MAXPACKET=USB_HIGH_SPEED_MAXPACKET -_USB_STRING_DESCRIPTOR=USB_STRING_DESCRIPTOR -_USB_SUPERSPEED_ENDPOINT_COMPANION_DESCRIPTOR=USB_SUPERSPEED_ENDPOINT_COMPANION_DESCRIPTOR -_USB_SUPERSPEEDPLUS_ISOCH_ENDPOINT_COMPANION_DESCRIPTOR=USB_SUPERSPEEDPLUS_ISOCH_ENDPOINT_COMPANION_DESCRIPTOR -_USB_HUB_DESCRIPTOR=USB_HUB_DESCRIPTOR -_USB_30_HUB_DESCRIPTOR=USB_30_HUB_DESCRIPTOR -_USB_HUB_STATUS=USB_HUB_STATUS -_USB_HUB_CHANGE=USB_HUB_CHANGE -_USB_HUB_STATUS_AND_CHANGE=USB_HUB_STATUS_AND_CHANGE -_USB_20_PORT_STATUS=USB_20_PORT_STATUS -_USB_20_PORT_CHANGE=USB_20_PORT_CHANGE -_USB_30_PORT_STATUS=USB_30_PORT_STATUS -_USB_30_PORT_CHANGE=USB_30_PORT_CHANGE -_USB_PORT_STATUS=USB_PORT_STATUS -_USB_PORT_CHANGE=USB_PORT_CHANGE -_USB_PORT_EXT_STATUS=USB_PORT_EXT_STATUS -_USB_PORT_STATUS_AND_CHANGE=USB_PORT_STATUS_AND_CHANGE -_USB_PORT_EXT_STATUS_AND_CHANGE=USB_PORT_EXT_STATUS_AND_CHANGE -_USB_HUB_30_PORT_REMOTE_WAKE_MASK=USB_HUB_30_PORT_REMOTE_WAKE_MASK -_USB_FUNCTION_SUSPEND_OPTIONS=USB_FUNCTION_SUSPEND_OPTIONS -_USB_CONFIGURATION_POWER_DESCRIPTOR=USB_CONFIGURATION_POWER_DESCRIPTOR -_USB_INTERFACE_POWER_DESCRIPTOR=USB_INTERFACE_POWER_DESCRIPTOR -_USB_CONTROLLER_FLAVOR=USB_CONTROLLER_FLAVOR -_USBD_VERSION_INFORMATION=USBD_VERSION_INFORMATION -_USBD_PIPE_TYPE=USBD_PIPE_TYPE -_USBD_DEVICE_INFORMATION=USBD_DEVICE_INFORMATION -_USBD_PIPE_INFORMATION=USBD_PIPE_INFORMATION -_USBD_ENDPOINT_OFFLOAD_MODE=USBD_ENDPOINT_OFFLOAD_MODE -_USBD_ENDPOINT_OFFLOAD_INFORMATION=USBD_ENDPOINT_OFFLOAD_INFORMATION -_USBD_INTERFACE_INFORMATION=USBD_INTERFACE_INFORMATION -_OS_STRING=OS_STRING -_USBD_ISO_PACKET_DESCRIPTOR=USBD_ISO_PACKET_DESCRIPTOR -_USBD_STREAM_INFORMATION=USBD_STREAM_INFORMATION -_URB=URB -_USB_IDLE_CALLBACK_INFO=USB_IDLE_CALLBACK_INFO -_USB_USER_ERROR_CODE=USB_USER_ERROR_CODE -_USBUSER_REQUEST_HEADER=USBUSER_REQUEST_HEADER -_PACKET_PARAMETERS=PACKET_PARAMETERS -_USBUSER_SEND_ONE_PACKET=USBUSER_SEND_ONE_PACKET -_RAW_RESET_PORT_PARAMETERS=RAW_RESET_PORT_PARAMETERS -_USBUSER_RAW_RESET_ROOT_PORT=USBUSER_RAW_RESET_ROOT_PORT -_RAW_ROOTPORT_FEATURE=RAW_ROOTPORT_FEATURE -_USBUSER_ROOTPORT_FEATURE_REQUEST=USBUSER_ROOTPORT_FEATURE_REQUEST -_RAW_ROOTPORT_PARAMETERS=RAW_ROOTPORT_PARAMETERS -_USBUSER_ROOTPORT_PARAMETERS=USBUSER_ROOTPORT_PARAMETERS -_USB_CONTROLLER_INFO_0=USB_CONTROLLER_INFO_0 -_USBUSER_CONTROLLER_INFO_0=USBUSER_CONTROLLER_INFO_0 -_USB_UNICODE_NAME=USB_UNICODE_NAME -_USBUSER_CONTROLLER_UNICODE_NAME=USBUSER_CONTROLLER_UNICODE_NAME -_USB_PASS_THRU_PARAMETERS=USB_PASS_THRU_PARAMETERS -_USBUSER_PASS_THRU_REQUEST=USBUSER_PASS_THRU_REQUEST -_WDMUSB_POWER_STATE=WDMUSB_POWER_STATE -_USB_POWER_INFO=USB_POWER_INFO -_USBUSER_POWER_INFO_REQUEST=USBUSER_POWER_INFO_REQUEST -_USB_OPEN_RAW_DEVICE_PARAMETERS=USB_OPEN_RAW_DEVICE_PARAMETERS -_USBUSER_OPEN_RAW_DEVICE=USBUSER_OPEN_RAW_DEVICE -_USB_CLOSE_RAW_DEVICE_PARAMETERS=USB_CLOSE_RAW_DEVICE_PARAMETERS -_USBUSER_CLOSE_RAW_DEVICE=USBUSER_CLOSE_RAW_DEVICE -_USB_SEND_RAW_COMMAND_PARAMETERS=USB_SEND_RAW_COMMAND_PARAMETERS -_USBUSER_SEND_RAW_COMMAND=USBUSER_SEND_RAW_COMMAND -_USB_BANDWIDTH_INFO=USB_BANDWIDTH_INFO -_USBUSER_BANDWIDTH_INFO_REQUEST=USBUSER_BANDWIDTH_INFO_REQUEST -_USB_BUS_STATISTICS_0=USB_BUS_STATISTICS_0 -_USBUSER_BUS_STATISTICS_0_REQUEST=USBUSER_BUS_STATISTICS_0_REQUEST -_USB_DRIVER_VERSION_PARAMETERS=USB_DRIVER_VERSION_PARAMETERS -_USBUSER_GET_DRIVER_VERSION=USBUSER_GET_DRIVER_VERSION -_USB_USB2HW_VERSION_PARAMETERS=USB_USB2HW_VERSION_PARAMETERS -_USBUSER_GET_USB2HW_VERSION=USBUSER_GET_USB2HW_VERSION -_USBUSER_REFRESH_HCT_REG=USBUSER_REFRESH_HCT_REG -_WINUSB_PIPE_INFORMATION=WINUSB_PIPE_INFORMATION -_WINUSB_PIPE_INFORMATION_EX=WINUSB_PIPE_INFORMATION_EX -_WINUSB_SETUP_PACKET=WINUSB_SETUP_PACKET -_USB_START_TRACKING_FOR_TIME_SYNC_INFORMATION=USB_START_TRACKING_FOR_TIME_SYNC_INFORMATION -_USB_STOP_TRACKING_FOR_TIME_SYNC_INFORMATION=USB_STOP_TRACKING_FOR_TIME_SYNC_INFORMATION -_USB_FRAME_NUMBER_AND_QPC_FOR_TIME_SYNC_INFORMATION=USB_FRAME_NUMBER_AND_QPC_FOR_TIME_SYNC_INFORMATION -tagOLEUIINSERTOBJECTW=OLEUIINSERTOBJECTW -tagOLEUIINSERTOBJECTA=OLEUIINSERTOBJECTA -tagOLEUIPASTEFLAG=OLEUIPASTEFLAG -tagOLEUIPASTEENTRYW=OLEUIPASTEENTRYW -tagOLEUIPASTEENTRYA=OLEUIPASTEENTRYA -tagOLEUIPASTESPECIALW=OLEUIPASTESPECIALW -tagOLEUIPASTESPECIALA=OLEUIPASTESPECIALA -tagOLEUIEDITLINKSW=OLEUIEDITLINKSW -tagOLEUIEDITLINKSA=OLEUIEDITLINKSA -tagOLEUICHANGEICONW=OLEUICHANGEICONW -tagOLEUICHANGEICONA=OLEUICHANGEICONA -tagOLEUICONVERTW=OLEUICONVERTW -tagOLEUICONVERTA=OLEUICONVERTA -tagOLEUIBUSYW=OLEUIBUSYW -tagOLEUIBUSYA=OLEUIBUSYA -tagOLEUICHANGESOURCEW=OLEUICHANGESOURCEW -tagOLEUICHANGESOURCEA=OLEUICHANGESOURCEA -tagOLEUIGNRLPROPSW=OLEUIGNRLPROPSW -tagOLEUIGNRLPROPSA=OLEUIGNRLPROPSA -tagOLEUIVIEWPROPSW=OLEUIVIEWPROPSW -tagOLEUIVIEWPROPSA=OLEUIVIEWPROPSA -tagOLEUILINKPROPSW=OLEUILINKPROPSW -tagOLEUILINKPROPSA=OLEUILINKPROPSA -tagOLEUIOBJECTPROPSW=OLEUIOBJECTPROPSW -tagOLEUIOBJECTPROPSA=OLEUIOBJECTPROPSA -tagComCallData=ComCallData -tagIMAGELISTSTATS=IMAGELISTSTATS -tagRICHEDIT_IMAGE_PARAMETERS=RICHEDIT_IMAGE_PARAMETERS -tagKHYPH=KHYPH -_DTBGOPTS=DTBGOPTS -_MARGINS=MARGINS -_INTLIST=INTLIST -_WTA_OPTIONS=WTA_OPTIONS -_DTTOPTS=DTTOPTS -_BP_BUFFERFORMAT=BP_BUFFERFORMAT -_BP_ANIMATIONSTYLE=BP_ANIMATIONSTYLE -_BP_ANIMATIONPARAMS=BP_ANIMATIONPARAMS -_BP_PAINTPARAMS=BP_PAINTPARAMS -_MF_MDL_SHARED_PAYLOAD_KEY=MF_MDL_SHARED_PAYLOAD_KEY -_KSAUDIO_PACKETSIZE_CONSTRAINTS=KSAUDIO_PACKETSIZE_CONSTRAINTS -_KSAUDIO_PACKETSIZE_CONSTRAINTS2=KSAUDIO_PACKETSIZE_CONSTRAINTS2 -_DS3DVECTOR=DS3DVECTOR -_tagKSTELEPHONY_CALLCONTROL=KSTELEPHONY_CALLCONTROL -_tagKSTELEPHONY_PROVIDERCHANGE=KSTELEPHONY_PROVIDERCHANGE -_tagKSTELEPHONY_CALLINFO=KSTELEPHONY_CALLINFO -_tagKSTOPOLOGY_ENDPOINTID=KSTOPOLOGY_ENDPOINTID -_tagKSTOPOLOGY_ENDPOINTIDPAIR=KSTOPOLOGY_ENDPOINTIDPAIR -_KSMPEGVID_RECT=KSMPEGVID_RECT -_KS_DVD_YCrCb=KS_DVD_YCrCb -_KS_DVD_YUV=KS_DVD_YUV -_KSPROPERTY_SPPAL=KSPROPERTY_SPPAL -_KS_COLCON=KS_COLCON -_KSPROPERTY_SPHLI=KSPROPERTY_SPHLI -_KS_DVDCOPY_CHLGKEY=KS_DVDCOPY_CHLGKEY -_KS_DVDCOPY_BUSKEY=KS_DVDCOPY_BUSKEY -_KS_DVDCOPY_DISCKEY=KS_DVDCOPY_DISCKEY -_KS_DVDCOPY_REGION=KS_DVDCOPY_REGION -_KS_DVDCOPY_TITLEKEY=KS_DVDCOPY_TITLEKEY -_KS_COPY_MACROVISION=KS_COPY_MACROVISION -_KS_DVDCOPY_SET_COPY_STATE=KS_DVDCOPY_SET_COPY_STATE -tagKS_RGBQUAD=KS_RGBQUAD -tagKS_BITMAPINFOHEADER=KS_BITMAPINFOHEADER -tagKS_VIDEOINFOHEADER=KS_VIDEOINFOHEADER -tagKS_VIDEOINFO=KS_VIDEOINFO -tagKS_VBIINFOHEADER=KS_VBIINFOHEADER -tagKS_TVTUNER_CHANGE_INFO=KS_TVTUNER_CHANGE_INFO -tagKS_VIDEOINFOHEADER2=KS_VIDEOINFOHEADER2 -tagKS_MPEG1VIDEOINFO=KS_MPEG1VIDEOINFO -tagKS_MPEGVIDEOINFO2=KS_MPEGVIDEOINFO2 -tagKS_H264VIDEOINFO=KS_H264VIDEOINFO -tagKS_DATAFORMAT_VIDEOINFOHEADER=KS_DATAFORMAT_VIDEOINFOHEADER -tagKS_DATAFORMAT_VIDEOINFOHEADER2=KS_DATAFORMAT_VIDEOINFOHEADER2 -tagKS_DATAFORMAT_MPEGVIDEOINFO2=KS_DATAFORMAT_MPEGVIDEOINFO2 -tagKS_DATAFORMAT_H264VIDEOINFO=KS_DATAFORMAT_H264VIDEOINFO -tagKS_DATAFORMAT_IMAGEINFO=KS_DATAFORMAT_IMAGEINFO -tagKS_DATAFORMAT_VIDEOINFO_PALETTE=KS_DATAFORMAT_VIDEOINFO_PALETTE -tagKS_DATAFORMAT_VBIINFOHEADER=KS_DATAFORMAT_VBIINFOHEADER -_KS_VIDEO_STREAM_CONFIG_CAPS=KS_VIDEO_STREAM_CONFIG_CAPS -tagKS_DATARANGE_VIDEO=KS_DATARANGE_VIDEO -tagKS_DATARANGE_VIDEO2=KS_DATARANGE_VIDEO2 -tagKS_DATARANGE_MPEG1_VIDEO=KS_DATARANGE_MPEG1_VIDEO -tagKS_DATARANGE_MPEG2_VIDEO=KS_DATARANGE_MPEG2_VIDEO -tagKS_DATARANGE_H264_VIDEO=KS_DATARANGE_H264_VIDEO -tagKS_DATARANGE_IMAGE=KS_DATARANGE_IMAGE -tagKS_DATARANGE_VIDEO_PALETTE=KS_DATARANGE_VIDEO_PALETTE -tagKS_DATARANGE_VIDEO_VBI=KS_DATARANGE_VIDEO_VBI -tagKS_DATARANGE_ANALOGVIDEO=KS_DATARANGE_ANALOGVIDEO -_VBICAP_PROPERTIES_PROTECTION_S=VBICAP_PROPERTIES_PROTECTION_S -_NABTSFEC_BUFFER=NABTSFEC_BUFFER -_VBICODECFILTERING_SCANLINES=VBICODECFILTERING_SCANLINES -_VBICODECFILTERING_NABTS_SUBSTREAMS=VBICODECFILTERING_NABTS_SUBSTREAMS -_VBICODECFILTERING_CC_SUBSTREAMS=VBICODECFILTERING_CC_SUBSTREAMS -_CC_BYTE_PAIR=CC_BYTE_PAIR -_CC_HW_FIELD=CC_HW_FIELD -_NABTS_BUFFER_LINE=NABTS_BUFFER_LINE -_NABTS_BUFFER=NABTS_BUFFER -_WST_BUFFER_LINE=WST_BUFFER_LINE -_WST_BUFFER=WST_BUFFER -_VBICODECFILTERING_STATISTICS_COMMON=VBICODECFILTERING_STATISTICS_COMMON -_VBICODECFILTERING_STATISTICS_COMMON_PIN=VBICODECFILTERING_STATISTICS_COMMON_PIN -_VBICODECFILTERING_STATISTICS_NABTS=VBICODECFILTERING_STATISTICS_NABTS -_VBICODECFILTERING_STATISTICS_NABTS_PIN=VBICODECFILTERING_STATISTICS_NABTS_PIN -_VBICODECFILTERING_STATISTICS_CC=VBICODECFILTERING_STATISTICS_CC -_VBICODECFILTERING_STATISTICS_CC_PIN=VBICODECFILTERING_STATISTICS_CC_PIN -_VBICODECFILTERING_STATISTICS_TELETEXT=VBICODECFILTERING_STATISTICS_TELETEXT -_VBICODECFILTERING_STATISTICS_TELETEXT_PIN=VBICODECFILTERING_STATISTICS_TELETEXT_PIN -tagKS_FRAME_INFO=KS_FRAME_INFO -tagKS_VBI_FRAME_INFO=KS_VBI_FRAME_INFO -tagKSCAMERA_EXTENDEDPROP_HEADER=KSCAMERA_EXTENDEDPROP_HEADER -tagKSCAMERA_EXTENDEDPROP_VALUE=KSCAMERA_EXTENDEDPROP_VALUE -tagKSCAMERA_MAXVIDEOFPS_FORPHOTORES=KSCAMERA_MAXVIDEOFPS_FORPHOTORES -tagKSCAMERA_EXTENDEDPROP_PHOTOMODE=KSCAMERA_EXTENDEDPROP_PHOTOMODE -tagKSCAMERA_EXTENDEDPROP_VIDEOPROCSETTING=KSCAMERA_EXTENDEDPROP_VIDEOPROCSETTING -tagKSCAMERA_EXTENDEDPROP_EVCOMPENSATION=KSCAMERA_EXTENDEDPROP_EVCOMPENSATION -tagKSCAMERA_EXTENDEDPROP_FIELDOFVIEW=KSCAMERA_EXTENDEDPROP_FIELDOFVIEW -tagKSCAMERA_EXTENDEDPROP_CAMERAOFFSET=KSCAMERA_EXTENDEDPROP_CAMERAOFFSET -tagKSCAMERA_EXTENDEDPROP_METADATAINFO=KSCAMERA_EXTENDEDPROP_METADATAINFO -tagKSCAMERA_METADATA_ITEMHEADER=KSCAMERA_METADATA_ITEMHEADER -tagKSCAMERA_METADATA_PHOTOCONFIRMATION=KSCAMERA_METADATA_PHOTOCONFIRMATION -tagKSCAMERA_METADATA_FRAMEILLUMINATION=KSCAMERA_METADATA_FRAMEILLUMINATION -tagKSCAMERA_METADATA_CAPTURESTATS=KSCAMERA_METADATA_CAPTURESTATS -tagKSCAMERA_EXTENDEDPROP_ROI_CONFIGCAPSHEADER=KSCAMERA_EXTENDEDPROP_ROI_CONFIGCAPSHEADER -tagKSCAMERA_EXTENDEDPROP_ROI_CONFIGCAPS=KSCAMERA_EXTENDEDPROP_ROI_CONFIGCAPS -tagKSCAMERA_EXTENDEDPROP_ROI_ISPCONTROLHEADER=KSCAMERA_EXTENDEDPROP_ROI_ISPCONTROLHEADER -tagKSCAMERA_EXTENDEDPROP_ROI_ISPCONTROL=KSCAMERA_EXTENDEDPROP_ROI_ISPCONTROL -tagKSCAMERA_EXTENDEDPROP_ROI_INFO=KSCAMERA_EXTENDEDPROP_ROI_INFO -tagKSCAMERA_EXTENDEDPROP_ROI_WHITEBALANCE=KSCAMERA_EXTENDEDPROP_ROI_WHITEBALANCE -tagKSCAMERA_EXTENDEDPROP_ROI_EXPOSURE=KSCAMERA_EXTENDEDPROP_ROI_EXPOSURE -tagKSCAMERA_EXTENDEDPROP_ROI_FOCUS=KSCAMERA_EXTENDEDPROP_ROI_FOCUS -_KSCAMERA_EXTENDEDPROP_PROFILE=KSCAMERA_EXTENDEDPROP_PROFILE -_KSCAMERA_PROFILE_MEDIAINFO=KSCAMERA_PROFILE_MEDIAINFO -_KSCAMERA_PROFILE_PININFO=KSCAMERA_PROFILE_PININFO -_KSCAMERA_PROFILE_INFO=KSCAMERA_PROFILE_INFO -_KSCAMERA_PROFILE_CONCURRENCYINFO=KSCAMERA_PROFILE_CONCURRENCYINFO -_KSDEVICE_PROFILE_INFO=KSDEVICE_PROFILE_INFO -_WNF_KSCAMERA_STREAMSTATE_INFO=WNF_KSCAMERA_STREAMSTATE_INFO -tagDEVCAPS=DEVCAPS -tagTRANSPORTSTATUS=TRANSPORTSTATUS -tagTRANSPORTBASICPARMS=TRANSPORTBASICPARMS -tagTRANSPORTVIDEOPARMS=TRANSPORTVIDEOPARMS -tagTRANSPORTAUDIOPARMS=TRANSPORTAUDIOPARMS -tagTIMECODE_SAMPLE=TIMECODE_SAMPLE -tagKS_AMVPDIMINFO=KS_AMVPDIMINFO -tagKS_AMVPDATAINFO=KS_AMVPDATAINFO -tagKS_AMVPSIZE=KS_AMVPSIZE -_KSGOP_USERDATA=KSGOP_USERDATA -_tagKSJACK_SINK_INFORMATION=KSJACK_SINK_INFORMATION -_tagKSJACK_DESCRIPTION2=KSJACK_DESCRIPTION2 -_tagKSAUDIOENGINE_DESCRIPTOR=KSAUDIOENGINE_DESCRIPTOR -_tagKSAUDIOENGINE_BUFFER_SIZE_RANGE=KSAUDIOENGINE_BUFFER_SIZE_RANGE -_tagKSAUDIOENGINE_VOLUMELEVEL=KSAUDIOENGINE_VOLUMELEVEL -tagKSATTRIBUTE_AUDIOSIGNALPROCESSING_MODE=KSATTRIBUTE_AUDIOSIGNALPROCESSING_MODE -_KSAUDIOMODULE_DESCRIPTOR=KSAUDIOMODULE_DESCRIPTOR -_KSAUDIOMODULE_PROPERTY=KSAUDIOMODULE_PROPERTY -_KSAUDIOMODULE_NOTIFICATION=KSAUDIOMODULE_NOTIFICATION -_RECYCLE_INFO=RECYCLE_INFO -tagDUMPTYPE=DUMPTYPE -_HANG_INFO=HANG_INFO -tagCOMPLUS_APPTYPE=COMPLUS_APPTYPE -_GetAppTrackerDataFlags=GetAppTrackerDataFlags -_ApplicationProcessSummary=ApplicationProcessSummary -_ApplicationProcessStatistics=ApplicationProcessStatistics -_ApplicationProcessRecycleInfo=ApplicationProcessRecycleInfo -_ApplicationSummary=ApplicationSummary -_ComponentSummary=ComponentSummary -_ComponentStatistics=ComponentStatistics -_ComponentHangMonitorInfo=ComponentHangMonitorInfo -tagTransactionVote=TransactionVote -tagCrmLogRecordRead=CrmLogRecordRead -tagCrmTransactionState=CrmTransactionState -tagCSC_InheritanceConfig=CSC_InheritanceConfig -tagCSC_ThreadPool=CSC_ThreadPool -tagCSC_Binding=CSC_Binding -tagCSC_TransactionConfig=CSC_TransactionConfig -tagCSC_SynchronizationConfig=CSC_SynchronizationConfig -tagCSC_TrackerConfig=CSC_TrackerConfig -tagCSC_PartitionConfig=CSC_PartitionConfig -tagCSC_IISIntrinsicsConfig=CSC_IISIntrinsicsConfig -tagCSC_COMTIIntrinsicsConfig=CSC_COMTIIntrinsicsConfig -tagCSC_SxsConfig=CSC_SxsConfig -tagCRMFLAGS=CRMFLAGS -tagCRMREGFLAGS=CRMREGFLAGS -_htmlDesignMode=htmlDesignMode -_htmlZOrder=htmlZOrder -_htmlClear=htmlClear -_htmlControlAlign=htmlControlAlign -_htmlBlockAlign=htmlBlockAlign -_htmlReadyState=htmlReadyState -_htmlLoop=htmlLoop -_mediaType=mediaType -_DomConstructor=DomConstructor -_styleTextTransform=styleTextTransform -_styleDataRepeat=styleDataRepeat -_styleOverflow=styleOverflow -_styleMsOverflowStyle=styleMsOverflowStyle -_styleTableLayout=styleTableLayout -_styleBorderCollapse=styleBorderCollapse -_styleCaptionSide=styleCaptionSide -_styleEmptyCells=styleEmptyCells -_styleFontStyle=styleFontStyle -_styleFontVariant=styleFontVariant -_styleBackgroundRepeat=styleBackgroundRepeat -_styleBackgroundAttachment=styleBackgroundAttachment -_styleBackgroundAttachment3=styleBackgroundAttachment3 -_styleBackgroundClip=styleBackgroundClip -_styleBackgroundOrigin=styleBackgroundOrigin -_styleVerticalAlign=styleVerticalAlign -_styleFontWeight=styleFontWeight -_styleFontSize=styleFontSize -_styleZIndex=styleZIndex -_styleWidowsOrphans=styleWidowsOrphans -_styleAuto=styleAuto -_styleNone=styleNone -_styleNormal=styleNormal -_styleBorderWidth=styleBorderWidth -_stylePosition=stylePosition -_styleBorderStyle=styleBorderStyle -_styleOutlineStyle=styleOutlineStyle -_styleStyleFloat=styleStyleFloat -_styleDisplay=styleDisplay -_styleVisibility=styleVisibility -_styleListStyleType=styleListStyleType -_styleListStylePosition=styleListStylePosition -_styleWhiteSpace=styleWhiteSpace -_stylePageBreak=stylePageBreak -_stylePageBreakInside=stylePageBreakInside -_styleCursor=styleCursor -_styleDir=styleDir -_styleBidi=styleBidi -_styleImeMode=styleImeMode -_styleRubyAlign=styleRubyAlign -_styleRubyPosition=styleRubyPosition -_styleRubyOverhang=styleRubyOverhang -_styleLayoutGridChar=styleLayoutGridChar -_styleLayoutGridLine=styleLayoutGridLine -_styleLayoutGridMode=styleLayoutGridMode -_styleLayoutGridType=styleLayoutGridType -_styleLineBreak=styleLineBreak -_styleWordBreak=styleWordBreak -_styleWordWrap=styleWordWrap -_styleTextJustify=styleTextJustify -_styleTextAlignLast=styleTextAlignLast -_styleTextJustifyTrim=styleTextJustifyTrim -_styleAccelerator=styleAccelerator -_styleLayoutFlow=styleLayoutFlow -_styleBlockProgression=styleBlockProgression -_styleWritingMode=styleWritingMode -_styleBool=styleBool -_styleTextUnderlinePosition=styleTextUnderlinePosition -_styleTextOverflow=styleTextOverflow -_styleInterpolation=styleInterpolation -_styleBoxSizing=styleBoxSizing -_styleFlex=styleFlex -_styleFlexBasis=styleFlexBasis -_styleFlexDirection=styleFlexDirection -_styleWebkitBoxOrient=styleWebkitBoxOrient -_styleWebkitBoxDirection=styleWebkitBoxDirection -_styleFlexWrap=styleFlexWrap -_styleAlignItems=styleAlignItems -_styleMsFlexAlign=styleMsFlexAlign -_styleMsFlexItemAlign=styleMsFlexItemAlign -_styleAlignSelf=styleAlignSelf -_styleJustifyContent=styleJustifyContent -_styleMsFlexPack=styleMsFlexPack -_styleWebkitBoxPack=styleWebkitBoxPack -_styleMsFlexLinePack=styleMsFlexLinePack -_styleAlignContent=styleAlignContent -_styleColumnFill=styleColumnFill -_styleColumnSpan=styleColumnSpan -_styleBreak=styleBreak -_styleBreakInside=styleBreakInside -_styleMsScrollChaining=styleMsScrollChaining -_styleMsContentZooming=styleMsContentZooming -_styleMsContentZoomSnapType=styleMsContentZoomSnapType -_styleMsScrollRails=styleMsScrollRails -_styleMsContentZoomChaining=styleMsContentZoomChaining -_styleMsScrollSnapType=styleMsScrollSnapType -_styleGridColumn=styleGridColumn -_styleGridColumnAlign=styleGridColumnAlign -_styleGridColumnSpan=styleGridColumnSpan -_styleGridRow=styleGridRow -_styleGridRowAlign=styleGridRowAlign -_styleGridRowSpan=styleGridRowSpan -_styleWrapThrough=styleWrapThrough -_styleWrapFlow=styleWrapFlow -_styleAlignmentBaseline=styleAlignmentBaseline -_styleBaselineShift=styleBaselineShift -_styleClipRule=styleClipRule -_styleDominantBaseline=styleDominantBaseline -_styleFillRule=styleFillRule -_styleFontStretch=styleFontStretch -_stylePointerEvents=stylePointerEvents -_styleEnableBackground=styleEnableBackground -_styleStrokeLinecap=styleStrokeLinecap -_styleStrokeLinejoin=styleStrokeLinejoin -_styleTextAnchor=styleTextAnchor -_styleAttrType=styleAttrType -_styleInitialColor=styleInitialColor -_styleInitialString=styleInitialString -_styleTransformOriginX=styleTransformOriginX -_styleTransformOriginY=styleTransformOriginY -_stylePerspectiveOriginX=stylePerspectiveOriginX -_stylePerspectiveOriginY=stylePerspectiveOriginY -_styleTransformStyle=styleTransformStyle -_styleBackfaceVisibility=styleBackfaceVisibility -_styleTextSizeAdjust=styleTextSizeAdjust -_styleColorInterpolationFilters=styleColorInterpolationFilters -_styleHyphens=styleHyphens -_styleHyphenateLimitLines=styleHyphenateLimitLines -_styleMsAnimationPlayState=styleMsAnimationPlayState -_styleMsAnimationDirection=styleMsAnimationDirection -_styleMsAnimationFillMode=styleMsAnimationFillMode -_styleMsHighContrastAdjust=styleMsHighContrastAdjust -_styleMsUserSelect=styleMsUserSelect -_styleMsTouchAction=styleMsTouchAction -_styleMsTouchSelect=styleMsTouchSelect -_styleMsScrollTranslation=styleMsScrollTranslation -_styleBorderImageRepeat=styleBorderImageRepeat -_styleBorderImageSliceFill=styleBorderImageSliceFill -_styleMsImeAlign=styleMsImeAlign -_styleMsTextCombineHorizontal=styleMsTextCombineHorizontal -_styleWebkitAppearance=styleWebkitAppearance -_styleViewportSize=styleViewportSize -_styleUserZoom=styleUserZoom -_styleTextLineThroughStyle=styleTextLineThroughStyle -_styleTextUnderlineStyle=styleTextUnderlineStyle -_styleTextEffect=styleTextEffect -_styleDefaultTextSelection=styleDefaultTextSelection -_styleTextDecoration=styleTextDecoration -_textDecoration=textDecoration -_htmlListType=htmlListType -_htmlMethod=htmlMethod -_htmlWrap=htmlWrap -_htmlDir=htmlDir -_htmlEditable=htmlEditable -_htmlInput=htmlInput -_htmlSpellCheck=htmlSpellCheck -_htmlEncoding=htmlEncoding -_htmlAdjacency=htmlAdjacency -_htmlTabIndex=htmlTabIndex -_htmlComponent=htmlComponent -_htmlApplyLocation=htmlApplyLocation -_htmlGlyphMode=htmlGlyphMode -_htmlDraggable=htmlDraggable -_htmlUnit=htmlUnit -_htmlEndPoints=htmlEndPoints -_htmlDirection=htmlDirection -_htmlStart=htmlStart -_bodyScroll=bodyScroll -_htmlSelectType=htmlSelectType -_htmlSelectExFlag=htmlSelectExFlag -_htmlSelection=htmlSelection -_htmlMarqueeBehavior=htmlMarqueeBehavior -_htmlMarqueeDirection=htmlMarqueeDirection -_htmlPersistState=htmlPersistState -_htmlDropEffect=htmlDropEffect -_htmlEffectAllowed=htmlEffectAllowed -_htmlCompatMode=htmlCompatMode -_BoolValue=BoolValue -_htmlCaptionAlign=htmlCaptionAlign -_htmlCaptionVAlign=htmlCaptionVAlign -_htmlFrame=htmlFrame -_htmlRules=htmlRules -_htmlCellAlign=htmlCellAlign -_htmlCellVAlign=htmlCellVAlign -_frameScrolling=frameScrolling -_sandboxAllow=sandboxAllow -_svgAngleType=svgAngleType -_svgExternalResourcesRequired=svgExternalResourcesRequired -_svgFocusable=svgFocusable -_svgLengthType=svgLengthType -_svgPathSegType=svgPathSegType -_svgTransformType=svgTransformType -_svgPreserveAspectRatioAlignType=svgPreserveAspectRatioAlignType -_svgPreserveAspectMeetOrSliceType=svgPreserveAspectMeetOrSliceType -_svgUnitTypes=svgUnitTypes -_svgSpreadMethod=svgSpreadMethod -_svgFeblendMode=svgFeblendMode -_svgFecolormatrixType=svgFecolormatrixType -_svgFecomponenttransferType=svgFecomponenttransferType -_svgFecompositeOperator=svgFecompositeOperator -_svgEdgemode=svgEdgemode -_svgPreserveAlpha=svgPreserveAlpha -_svgChannel=svgChannel -_svgMorphologyOperator=svgMorphologyOperator -_svgTurbulenceType=svgTurbulenceType -_svgStitchtype=svgStitchtype -_svgMarkerUnits=svgMarkerUnits -_svgMarkerOrient=svgMarkerOrient -_svgMarkerOrientAttribute=svgMarkerOrientAttribute -_htmlMediaNetworkState=htmlMediaNetworkState -_htmlMediaReadyState=htmlMediaReadyState -_htmlMediaErr=htmlMediaErr -_lengthAdjust=lengthAdjust -_textpathMethodtype=textpathMethodtype -_textpathSpacingtype=textpathSpacingtype -_ELEMENT_CORNER=ELEMENT_CORNER -_SECUREURLHOSTVALIDATE_FLAGS=SECUREURLHOSTVALIDATE_FLAGS -_POINTER_GRAVITY=POINTER_GRAVITY -_ELEMENT_ADJACENCY=ELEMENT_ADJACENCY -_MARKUP_CONTEXT_TYPE=MARKUP_CONTEXT_TYPE -_FINDTEXT_FLAGS=FINDTEXT_FLAGS -_MOVEUNIT_ACTION=MOVEUNIT_ACTION -_PARSE_FLAGS=PARSE_FLAGS -_ELEMENT_TAG_ID=ELEMENT_TAG_ID -_SELECTION_TYPE=SELECTION_TYPE -_SAVE_SEGMENTS_FLAGS=SAVE_SEGMENTS_FLAGS -_CARET_DIRECTION=CARET_DIRECTION -_LINE_DIRECTION=LINE_DIRECTION -_HT_OPTIONS=HT_OPTIONS -_HT_RESULTS=HT_RESULTS -_DISPLAY_MOVEUNIT=DISPLAY_MOVEUNIT -_DISPLAY_GRAVITY=DISPLAY_GRAVITY -_DISPLAY_BREAK=DISPLAY_BREAK -_COORD_SYSTEM=COORD_SYSTEM -_DEV_CONSOLE_MESSAGE_LEVEL=DEV_CONSOLE_MESSAGE_LEVEL -_DOM_EVENT_PHASE=DOM_EVENT_PHASE -_SCRIPT_TIMER_TYPE=SCRIPT_TIMER_TYPE -_HTML_PAINTER=HTML_PAINTER -_HTML_PAINT_ZORDER=HTML_PAINT_ZORDER -_HTML_PAINT_DRAW_FLAGS=HTML_PAINT_DRAW_FLAGS -_HTML_PAINT_EVENT_FLAGS=HTML_PAINT_EVENT_FLAGS -_HTML_PAINT_DRAW_INFO_FLAGS=HTML_PAINT_DRAW_INFO_FLAGS -_HTML_PAINTER_INFO=HTML_PAINTER_INFO -_HTML_PAINT_XFORM=HTML_PAINT_XFORM -_HTML_PAINT_DRAW_INFO=HTML_PAINT_DRAW_INFO -_HTMLDlgFlag=HTMLDlgFlag -_HTMLDlgBorder=HTMLDlgBorder -_HTMLDlgEdge=HTMLDlgEdge -_HTMLDlgCenter=HTMLDlgCenter -_HTMLAppFlag=HTMLAppFlag -_HTMLMinimizeFlag=HTMLMinimizeFlag -_HTMLMaximizeFlag=HTMLMaximizeFlag -_HTMLCaptionFlag=HTMLCaptionFlag -_HTMLSysMenuFlag=HTMLSysMenuFlag -_HTMLBorder=HTMLBorder -_HTMLBorderStyle=HTMLBorderStyle -_HTMLWindowState=HTMLWindowState -_BEHAVIOR_EVENT=BEHAVIOR_EVENT -_BEHAVIOR_EVENT_FLAGS=BEHAVIOR_EVENT_FLAGS -_BEHAVIOR_RENDER_INFO=BEHAVIOR_RENDER_INFO -_BEHAVIOR_RELATION=BEHAVIOR_RELATION -_BEHAVIOR_LAYOUT_INFO=BEHAVIOR_LAYOUT_INFO -_BEHAVIOR_LAYOUT_MODE=BEHAVIOR_LAYOUT_MODE -_ELEMENTDESCRIPTOR_FLAGS=ELEMENTDESCRIPTOR_FLAGS -_ELEMENTNAMESPACE_FLAGS=ELEMENTNAMESPACE_FLAGS -_VIEW_OBJECT_ALPHA_MODE=VIEW_OBJECT_ALPHA_MODE -_VIEW_OBJECT_COMPOSITION_MODE=VIEW_OBJECT_COMPOSITION_MODE -_DEDUP_CONTAINER_EXTENT=DEDUP_CONTAINER_EXTENT -_DDP_FILE_EXTENT=DDP_FILE_EXTENT -_DEDUP_BACKUP_SUPPORT_PARAM_TYPE=DEDUP_BACKUP_SUPPORT_PARAM_TYPE -_DHCP_SERVER_OPTIONS=DHCP_SERVER_OPTIONS -_DHCP_CALLOUT_TABLE=DHCP_CALLOUT_TABLE -_D3DVSHADERCAPS2_0=D3DVSHADERCAPS2_0 -_D3DPSHADERCAPS2_0=D3DPSHADERCAPS2_0 -_D3DOVERLAYCAPS=D3DOVERLAYCAPS -_D3DCONTENTPROTECTIONCAPS=D3DCONTENTPROTECTIONCAPS -_D3DCAPS9=D3DCAPS9 -_AMVP_SELECT_FORMAT_BY=AMVP_SELECT_FORMAT_BY -_AMVP_MODE=AMVP_MODE -_AMVPSIZE=AMVPSIZE -_AMVPDIMINFO=AMVPDIMINFO -_AMVPDATAINFO=AMVPDATAINFO -tagAM_SAMPLE2_PROPERTIES=AM_SAMPLE2_PROPERTIES -tagQualityMessageType=QualityMessageType -tagQuality=Quality -tagCOLORKEY=COLORKEY -_VIDEO_STREAM_CONFIG_CAPS=VIDEO_STREAM_CONFIG_CAPS -_AUDIO_STREAM_CONFIG_CAPS=AUDIO_STREAM_CONFIG_CAPS -tagAnalogVideoStandard=AnalogVideoStandard -tagTunerInputType=TunerInputType -tagPhysicalConnectorType=PhysicalConnectorType -tagVideoProcAmpProperty=VideoProcAmpProperty -tagVideoProcAmpFlags=VideoProcAmpFlags -tagCameraControlProperty=CameraControlProperty -tagCameraControlFlags=CameraControlFlags -tagVideoControlFlags=VideoControlFlags -tagAMTunerSubChannel=AMTunerSubChannel -tagAMTunerSignalStrength=AMTunerSignalStrength -tagAMTunerModeType=AMTunerModeType -tagAMTunerEventType=AMTunerEventType -tagTVAudioMode=TVAudioMode -tagAMTVAudioEventType=AMTVAudioEventType -_DECIMATION_USAGE=DECIMATION_USAGE -_AMCOPPSignature=AMCOPPSignature -_AMCOPPCommand=AMCOPPCommand -_AMCOPPStatusInput=AMCOPPStatusInput -_AMCOPPStatusOutput=AMCOPPStatusOutput -_AM_GRAPH_CONFIG_RECONNECT_FLAGS=AM_GRAPH_CONFIG_RECONNECT_FLAGS -_AM_FILTER_FLAGS=AM_FILTER_FLAGS -tagVMRPRESENTATIONINFO=VMRPRESENTATIONINFO -tagVMRALLOCATIONINFO=VMRALLOCATIONINFO -_NORMALIZEDRECT=NORMALIZEDRECT -tagVMRGUID=VMRGUID -tagVMRMONITORINFO=VMRMONITORINFO -_VMRFrequency=VMRFrequency -_VMRVideoDesc=VMRVideoDesc -_VMRDeinterlaceCaps=VMRDeinterlaceCaps -_VMRALPHABITMAP=VMRALPHABITMAP -_VMRVIDEOSTREAMINFO=VMRVIDEOSTREAMINFO -tagDVD_DOMAIN=DVD_DOMAIN -tagDVD_MENU_ID=DVD_MENU_ID -tagDVD_DISC_SIDE=DVD_DISC_SIDE -tagDVD_PREFERRED_DISPLAY_MODE=DVD_PREFERRED_DISPLAY_MODE -tagDVD_ATR=DVD_ATR -tagDVD_FRAMERATE=DVD_FRAMERATE -tagDVD_TIMECODE=DVD_TIMECODE -tagDVD_NavCmdType=DVD_NavCmdType -tagDVD_TIMECODE_FLAGS=DVD_TIMECODE_FLAGS -tagDVD_HMSF_TIMECODE=DVD_HMSF_TIMECODE -tagDVD_PLAYBACK_LOCATION2=DVD_PLAYBACK_LOCATION2 -tagDVD_PLAYBACK_LOCATION=DVD_PLAYBACK_LOCATION -tagDVD_PARENTAL_LEVEL=DVD_PARENTAL_LEVEL -tagDVD_AUDIO_LANG_EXT=DVD_AUDIO_LANG_EXT -tagDVD_SUBPICTURE_LANG_EXT=DVD_SUBPICTURE_LANG_EXT -tagDVD_AUDIO_APPMODE=DVD_AUDIO_APPMODE -tagDVD_AUDIO_FORMAT=DVD_AUDIO_FORMAT -tagDVD_KARAOKE_DOWNMIX=DVD_KARAOKE_DOWNMIX -tagDVD_AudioAttributes=DVD_AudioAttributes -tagDVD_MUA_MixingInfo=DVD_MUA_MixingInfo -tagDVD_MUA_Coeff=DVD_MUA_Coeff -tagDVD_MultichannelAudioAttributes=DVD_MultichannelAudioAttributes -tagDVD_KARAOKE_CONTENTS=DVD_KARAOKE_CONTENTS -tagDVD_KARAOKE_ASSIGNMENT=DVD_KARAOKE_ASSIGNMENT -tagDVD_KaraokeAttributes=DVD_KaraokeAttributes -tagDVD_VIDEO_COMPRESSION=DVD_VIDEO_COMPRESSION -tagDVD_VideoAttributes=DVD_VideoAttributes -tagDVD_SUBPICTURE_TYPE=DVD_SUBPICTURE_TYPE -tagDVD_SUBPICTURE_CODING=DVD_SUBPICTURE_CODING -tagDVD_SubpictureAttributes=DVD_SubpictureAttributes -tagDVD_TITLE_APPMODE=DVD_TITLE_APPMODE -tagDVD_MenuAttributes=DVD_MenuAttributes -tagDVD_DECODER_CAPS=DVD_DECODER_CAPS -_AM_DVD_GRAPH_FLAGS=AM_DVD_GRAPH_FLAGS -_AM_DVD_STREAM_FLAGS=AM_DVD_STREAM_FLAGS -_BDA_TEMPLATE_CONNECTION=BDA_TEMPLATE_CONNECTION -_BDA_TEMPLATE_PIN_JOINT=BDA_TEMPLATE_PIN_JOINT -tagKS_BDA_FRAME_INFO=KS_BDA_FRAME_INFO -_BDA_ETHERNET_ADDRESS=BDA_ETHERNET_ADDRESS -_BDA_ETHERNET_ADDRESS_LIST=BDA_ETHERNET_ADDRESS_LIST -_BDA_IPv4_ADDRESS=BDA_IPv4_ADDRESS -_BDA_IPv4_ADDRESS_LIST=BDA_IPv4_ADDRESS_LIST -_BDA_IPv6_ADDRESS=BDA_IPv6_ADDRESS -_BDA_IPv6_ADDRESS_LIST=BDA_IPv6_ADDRESS_LIST -_BDANODE_DESCRIPTOR=BDANODE_DESCRIPTOR -_BDA_TABLE_SECTION=BDA_TABLE_SECTION -_BDA_DISEQC_SEND=BDA_DISEQC_SEND -_BDA_DISEQC_RESPONSE=BDA_DISEQC_RESPONSE -_BDA_PID_MAP=BDA_PID_MAP -_BDA_PID_UNMAP=BDA_PID_UNMAP -_BDA_CA_MODULE_UI=BDA_CA_MODULE_UI -_BDA_PROGRAM_PID_LIST=BDA_PROGRAM_PID_LIST -_BDA_DRM_DRMSTATUS=BDA_DRM_DRMSTATUS -_BDA_WMDRM_STATUS=BDA_WMDRM_STATUS -_BDA_WMDRM_KEYINFOLIST=BDA_WMDRM_KEYINFOLIST -_BDA_BUFFER=BDA_BUFFER -_BDA_WMDRM_RENEWLICENSE=BDA_WMDRM_RENEWLICENSE -_BDA_WMDRMTUNER_PIDPROTECTION=BDA_WMDRMTUNER_PIDPROTECTION -_BDA_WMDRMTUNER_PURCHASEENTITLEMENT=BDA_WMDRMTUNER_PURCHASEENTITLEMENT -_BDA_TUNER_TUNERSTATE=BDA_TUNER_TUNERSTATE -_BDA_TUNER_DIAGNOSTICS=BDA_TUNER_DIAGNOSTICS -_BDA_STRING=BDA_STRING -_BDA_SCAN_CAPABILTIES=BDA_SCAN_CAPABILTIES -_BDA_SCAN_STATE=BDA_SCAN_STATE -_BDA_SCAN_START=BDA_SCAN_START -_BDA_GDDS_DATATYPE=BDA_GDDS_DATATYPE -_BDA_GDDS_DATA=BDA_GDDS_DATA -_BDA_USERACTIVITY_INTERVAL=BDA_USERACTIVITY_INTERVAL -_BDA_CAS_CHECK_ENTITLEMENTTOKEN=BDA_CAS_CHECK_ENTITLEMENTTOKEN -_BDA_CAS_CLOSE_MMIDIALOG=BDA_CAS_CLOSE_MMIDIALOG -_BDA_CAS_REQUESTTUNERDATA=BDA_CAS_REQUESTTUNERDATA -_BDA_CAS_OPENMMIDATA=BDA_CAS_OPENMMIDATA -_BDA_CAS_CLOSEMMIDATA=BDA_CAS_CLOSEMMIDATA -_BDA_ISDBCAS_REQUESTHEADER=BDA_ISDBCAS_REQUESTHEADER -_BDA_ISDBCAS_RESPONSEDATA=BDA_ISDBCAS_RESPONSEDATA -_BDA_ISDBCAS_EMG_REQ=BDA_ISDBCAS_EMG_REQ -_BDA_MUX_PIDLISTITEM=BDA_MUX_PIDLISTITEM -_BDA_TS_SELECTORINFO=BDA_TS_SELECTORINFO -_BDA_TS_SELECTORINFO_ISDBS_EXT=BDA_TS_SELECTORINFO_ISDBS_EXT -_BDA_DVBT2_L1_SIGNALLING_DATA=BDA_DVBT2_L1_SIGNALLING_DATA -_BDA_RATING_PINRESET=BDA_RATING_PINRESET -_MPEG2_TRANSPORT_STRIDE=MPEG2_TRANSPORT_STRIDE -tagScanModulationTypes=ScanModulationTypes -_BDA_SIGNAL_TIMEOUTS=BDA_SIGNAL_TIMEOUTS -_PIPE_DIMENSIONS=PIPE_DIMENSIONS -_PIPE_TERMINATION=PIPE_TERMINATION -_ALLOCATOR_PROPERTIES_EX=ALLOCATOR_PROPERTIES_EX -_AM_DVD_YUV=AM_DVD_YUV -_AM_PROPERTY_SPPAL=AM_PROPERTY_SPPAL -_AM_COLCON=AM_COLCON -_AM_PROPERTY_SPHLI=AM_PROPERTY_SPHLI -_AM_DIGITAL_CP=AM_DIGITAL_CP -_AM_DVDCOPY_CHLGKEY=AM_DVDCOPY_CHLGKEY -_AM_DVDCOPY_BUSKEY=AM_DVDCOPY_BUSKEY -_AM_DVDCOPY_DISCKEY=AM_DVDCOPY_DISCKEY -_AM_COPY_MACROVISION=AM_COPY_MACROVISION -_DVD_REGION=DVD_REGION -tagAM_DvdKaraokeData=AM_DvdKaraokeData -_tagDVD_ERROR=DVD_ERROR -_tagDVD_WARNING=DVD_WARNING -_tagDVD_PB_STOPPED=DVD_PB_STOPPED -tagEapHostPeerMethodResultReason=EapHostPeerMethodResultReason -tagEapHostPeerResponseAction=EapHostPeerResponseAction -tagEapHostPeerAuthParams=EapHostPeerAuthParams -_EAPHOST_AUTH_STATUS=EAPHOST_AUTH_STATUS -_EAPHOST_AUTH_INFO=EAPHOST_AUTH_INFO -_ISOLATION_STATE=ISOLATION_STATE -tagEapHostPeerMethodResult=EapHostPeerMethodResult -tagEapPacket=EapPacket -tagEapCode=EapCode -_EAP_METHOD_AUTHENTICATOR_RESPONSE_ACTION=EAP_METHOD_AUTHENTICATOR_RESPONSE_ACTION -_EAP_METHOD_AUTHENTICATOR_RESULT=EAP_METHOD_AUTHENTICATOR_RESULT -tagEapPeerMethodResponseAction=EapPeerMethodResponseAction -tagEapPeerMethodResultReason=EapPeerMethodResultReason -_EAP_AUTHENTICATOR_SEND_TIMEOUT=EAP_AUTHENTICATOR_SEND_TIMEOUT -_ENHANCED_STORAGE_PASSWORD_SILO_INFORMATION=ENHANCED_STORAGE_PASSWORD_SILO_INFORMATION -_FAX_LOG_CATEGORYA=FAX_LOG_CATEGORYA -_FAX_LOG_CATEGORYW=FAX_LOG_CATEGORYW -_FAX_TIME=FAX_TIME -_FAX_CONFIGURATIONA=FAX_CONFIGURATIONA -_FAX_CONFIGURATIONW=FAX_CONFIGURATIONW -_FAX_DEVICE_STATUSA=FAX_DEVICE_STATUSA -_FAX_DEVICE_STATUSW=FAX_DEVICE_STATUSW -_FAX_JOB_ENTRYA=FAX_JOB_ENTRYA -_FAX_JOB_ENTRYW=FAX_JOB_ENTRYW -_FAX_PORT_INFOA=FAX_PORT_INFOA -_FAX_PORT_INFOW=FAX_PORT_INFOW -_FAX_ROUTING_METHODA=FAX_ROUTING_METHODA -_FAX_ROUTING_METHODW=FAX_ROUTING_METHODW -_FAX_GLOBAL_ROUTING_INFOA=FAX_GLOBAL_ROUTING_INFOA -_FAX_GLOBAL_ROUTING_INFOW=FAX_GLOBAL_ROUTING_INFOW -_FAX_COVERPAGE_INFOA=FAX_COVERPAGE_INFOA -_FAX_COVERPAGE_INFOW=FAX_COVERPAGE_INFOW -_FAX_JOB_PARAMA=FAX_JOB_PARAMA -_FAX_JOB_PARAMW=FAX_JOB_PARAMW -_FAX_EVENTA=FAX_EVENTA -_FAX_EVENTW=FAX_EVENTW -_FAX_PRINT_INFOA=FAX_PRINT_INFOA -_FAX_PRINT_INFOW=FAX_PRINT_INFOW -_FAX_CONTEXT_INFOA=FAX_CONTEXT_INFOA -_FAX_CONTEXT_INFOW=FAX_CONTEXT_INFOW -_FAX_SEND=FAX_SEND -_FAX_RECEIVE=FAX_RECEIVE -_FAX_DEV_STATUS=FAX_DEV_STATUS -_FAX_ROUTE_CALLBACKROUTINES=FAX_ROUTE_CALLBACKROUTINES -_FAX_ROUTE=FAX_ROUTE -_NTMS_ASYNC_IO=NTMS_ASYNC_IO -_NTMS_MOUNT_INFORMATION=NTMS_MOUNT_INFORMATION -_NTMS_ALLOCATION_INFORMATION=NTMS_ALLOCATION_INFORMATION -_NTMS_DRIVEINFORMATIONA=NTMS_DRIVEINFORMATIONA -_NTMS_DRIVEINFORMATIONW=NTMS_DRIVEINFORMATIONW -_NTMS_LIBRARYINFORMATION=NTMS_LIBRARYINFORMATION -_NTMS_CHANGERINFORMATIONA=NTMS_CHANGERINFORMATIONA -_NTMS_CHANGERINFORMATIONW=NTMS_CHANGERINFORMATIONW -_NTMS_STORAGESLOTINFORMATION=NTMS_STORAGESLOTINFORMATION -_NTMS_IEDOORINFORMATION=NTMS_IEDOORINFORMATION -_NTMS_IEPORTINFORMATION=NTMS_IEPORTINFORMATION -_NTMS_PMIDINFORMATIONA=NTMS_PMIDINFORMATIONA -_NTMS_PMIDINFORMATIONW=NTMS_PMIDINFORMATIONW -_NTMS_LMIDINFORMATION=NTMS_LMIDINFORMATION -_NTMS_PARTITIONINFORMATIONA=NTMS_PARTITIONINFORMATIONA -_NTMS_PARTITIONINFORMATIONW=NTMS_PARTITIONINFORMATIONW -_NTMS_MEDIAPOOLINFORMATION=NTMS_MEDIAPOOLINFORMATION -_NTMS_MEDIATYPEINFORMATION=NTMS_MEDIATYPEINFORMATION -_NTMS_DRIVETYPEINFORMATIONA=NTMS_DRIVETYPEINFORMATIONA -_NTMS_DRIVETYPEINFORMATIONW=NTMS_DRIVETYPEINFORMATIONW -_NTMS_CHANGERTYPEINFORMATIONA=NTMS_CHANGERTYPEINFORMATIONA -_NTMS_CHANGERTYPEINFORMATIONW=NTMS_CHANGERTYPEINFORMATIONW -_NTMS_LIBREQUESTINFORMATIONA=NTMS_LIBREQUESTINFORMATIONA -_NTMS_LIBREQUESTINFORMATIONW=NTMS_LIBREQUESTINFORMATIONW -_NTMS_OPREQUESTINFORMATIONA=NTMS_OPREQUESTINFORMATIONA -_NTMS_OPREQUESTINFORMATIONW=NTMS_OPREQUESTINFORMATIONW -_NTMS_COMPUTERINFORMATION=NTMS_COMPUTERINFORMATION -_NTMS_OBJECTINFORMATIONA=NTMS_OBJECTINFORMATIONA -_NTMS_OBJECTINFORMATIONW=NTMS_OBJECTINFORMATIONW -_NTMS_I1_LIBRARYINFORMATION=NTMS_I1_LIBRARYINFORMATION -_NTMS_I1_LIBREQUESTINFORMATIONA=NTMS_I1_LIBREQUESTINFORMATIONA -_NTMS_I1_LIBREQUESTINFORMATIONW=NTMS_I1_LIBREQUESTINFORMATIONW -_NTMS_I1_PMIDINFORMATIONA=NTMS_I1_PMIDINFORMATIONA -_NTMS_I1_PMIDINFORMATIONW=NTMS_I1_PMIDINFORMATIONW -_NTMS_I1_PARTITIONINFORMATIONA=NTMS_I1_PARTITIONINFORMATIONA -_NTMS_I1_PARTITIONINFORMATIONW=NTMS_I1_PARTITIONINFORMATIONW -_NTMS_I1_OPREQUESTINFORMATIONA=NTMS_I1_OPREQUESTINFORMATIONA -_NTMS_I1_OPREQUESTINFORMATIONW=NTMS_I1_OPREQUESTINFORMATIONW -_NTMS_I1_OBJECTINFORMATIONA=NTMS_I1_OBJECTINFORMATIONA -_NTMS_I1_OBJECTINFORMATIONW=NTMS_I1_OBJECTINFORMATIONW -_NTMS_NOTIFICATIONINFORMATION=NTMS_NOTIFICATIONINFORMATION -_CLS_LSN=CLS_LSN -_CLS_CONTEXT_MODE=CLS_CONTEXT_MODE -_CLFS_CONTEXT_MODE=CLFS_CONTEXT_MODE -_CLFS_NODE_ID=CLFS_NODE_ID -_CLS_WRITE_ENTRY=CLS_WRITE_ENTRY -_CLS_INFORMATION=CLS_INFORMATION -_CLFS_LOG_NAME_INFORMATION=CLFS_LOG_NAME_INFORMATION -_CLFS_STREAM_ID_INFORMATION=CLFS_STREAM_ID_INFORMATION -_CLFS_PHYSICAL_LSN_INFORMATION=CLFS_PHYSICAL_LSN_INFORMATION -_CLS_CONTAINER_INFORMATION=CLS_CONTAINER_INFORMATION -_CLS_LOG_INFORMATION_CLASS=CLS_LOG_INFORMATION_CLASS -_CLS_IOSTATS_CLASS=CLS_IOSTATS_CLASS -_CLFS_IOSTATS_CLASS=CLFS_IOSTATS_CLASS -_CLS_IO_STATISTICS_HEADER=CLS_IO_STATISTICS_HEADER -_CLS_IO_STATISTICS=CLS_IO_STATISTICS -_CLS_SCAN_CONTEXT=CLS_SCAN_CONTEXT -_CLS_ARCHIVE_DESCRIPTOR=CLS_ARCHIVE_DESCRIPTOR -_CLFS_LOG_ARCHIVE_MODE=CLFS_LOG_ARCHIVE_MODE -_CLFS_MGMT_POLICY_TYPE=CLFS_MGMT_POLICY_TYPE -_CLFS_MGMT_POLICY=CLFS_MGMT_POLICY -_CLFS_MGMT_NOTIFICATION_TYPE=CLFS_MGMT_NOTIFICATION_TYPE -_CLFS_MGMT_NOTIFICATION=CLFS_MGMT_NOTIFICATION -_LOG_MANAGEMENT_CALLBACKS=LOG_MANAGEMENT_CALLBACKS -_WIM_ENTRY_INFO=WIM_ENTRY_INFO -_WIM_EXTERNAL_FILE_INFO=WIM_EXTERNAL_FILE_INFO -_WOF_FILE_COMPRESSION_INFO_V0=WOF_FILE_COMPRESSION_INFO_V0 -_WOF_FILE_COMPRESSION_INFO_V1=WOF_FILE_COMPRESSION_INFO_V1 -_TXF_ID=TXF_ID -_TXF_LOG_RECORD_BASE=TXF_LOG_RECORD_BASE -_TXF_LOG_RECORD_WRITE=TXF_LOG_RECORD_WRITE -_TXF_LOG_RECORD_TRUNCATE=TXF_LOG_RECORD_TRUNCATE -_TXF_LOG_RECORD_AFFECTED_FILE=TXF_LOG_RECORD_AFFECTED_FILE -_VOLUME_FAILOVER_SET=VOLUME_FAILOVER_SET -_VOLUME_NUMBER=VOLUME_NUMBER -_VOLUME_LOGICAL_OFFSET=VOLUME_LOGICAL_OFFSET -_VOLUME_PHYSICAL_OFFSET=VOLUME_PHYSICAL_OFFSET -_VOLUME_PHYSICAL_OFFSETS=VOLUME_PHYSICAL_OFFSETS -_VOLUME_READ_PLEX_INPUT=VOLUME_READ_PLEX_INPUT -_VOLUME_SET_GPT_ATTRIBUTES_INFORMATION=VOLUME_SET_GPT_ATTRIBUTES_INFORMATION -_VOLUME_GET_BC_PROPERTIES_INPUT=VOLUME_GET_BC_PROPERTIES_INPUT -_VOLUME_GET_BC_PROPERTIES_OUTPUT=VOLUME_GET_BC_PROPERTIES_OUTPUT -_VOLUME_ALLOCATE_BC_STREAM_INPUT=VOLUME_ALLOCATE_BC_STREAM_INPUT -_VOLUME_ALLOCATE_BC_STREAM_OUTPUT=VOLUME_ALLOCATE_BC_STREAM_OUTPUT -_FILE_EXTENT=FILE_EXTENT -_VOLUME_CRITICAL_IO=VOLUME_CRITICAL_IO -_VOLUME_ALLOCATION_HINT_INPUT=VOLUME_ALLOCATION_HINT_INPUT -_VOLUME_ALLOCATION_HINT_OUTPUT=VOLUME_ALLOCATION_HINT_OUTPUT -_VOLUME_SHRINK_INFO=VOLUME_SHRINK_INFO -_FsrmQuotaFlags=FsrmQuotaFlags -_FsrmFileScreenFlags=FsrmFileScreenFlags -_FsrmCollectionState=FsrmCollectionState -_FsrmEnumOptions=FsrmEnumOptions -_FsrmCommitOptions=FsrmCommitOptions -_FsrmTemplateApplyOptions=FsrmTemplateApplyOptions -_FsrmActionType=FsrmActionType -_FsrmEventType=FsrmEventType -_FsrmAccountType=FsrmAccountType -_FsrmReportType=FsrmReportType -_FsrmReportFormat=FsrmReportFormat -_FsrmReportRunningStatus=FsrmReportRunningStatus -_FsrmReportGenerationContext=FsrmReportGenerationContext -_FsrmReportFilter=FsrmReportFilter -_FsrmReportLimit=FsrmReportLimit -_FsrmPropertyDefinitionType=FsrmPropertyDefinitionType -_FsrmPropertyDefinitionFlags=FsrmPropertyDefinitionFlags -_FsrmPropertyDefinitionAppliesTo=FsrmPropertyDefinitionAppliesTo -_FsrmRuleType=FsrmRuleType -_FsrmRuleFlags=FsrmRuleFlags -_FsrmClassificationLoggingFlags=FsrmClassificationLoggingFlags -_FsrmExecutionOption=FsrmExecutionOption -_FsrmStorageModuleCaps=FsrmStorageModuleCaps -_FsrmStorageModuleType=FsrmStorageModuleType -_FsrmPropertyBagFlags=FsrmPropertyBagFlags -_FsrmPropertyBagField=FsrmPropertyBagField -_FsrmPropertyFlags=FsrmPropertyFlags -_FsrmPipelineModuleType=FsrmPipelineModuleType -_FsrmGetFilePropertyOptions=FsrmGetFilePropertyOptions -_FsrmFileManagementType=FsrmFileManagementType -_FsrmFileManagementLoggingFlags=FsrmFileManagementLoggingFlags -_FsrmPropertyConditionType=FsrmPropertyConditionType -_FsrmFileStreamingMode=FsrmFileStreamingMode -_FsrmFileStreamingInterfaceType=FsrmFileStreamingInterfaceType -_FsrmFileConditionType=FsrmFileConditionType -_FsrmFileSystemPropertyId=FsrmFileSystemPropertyId -_FsrmPropertyValueType=FsrmPropertyValueType -_AdrClientDisplayFlags=AdrClientDisplayFlags -_AdrEmailFlags=AdrEmailFlags -_AdrClientErrorType=AdrClientErrorType -_AdrClientFlags=AdrClientFlags -_IPSEC_KEY_MANAGER0=IPSEC_KEY_MANAGER0 -_IPSEC_KEY_MANAGER_CALLBACKS0=IPSEC_KEY_MANAGER_CALLBACKS0 -_DIOBJECTDATAFORMAT=DIOBJECTDATAFORMAT -_DIDATAFORMAT=DIDATAFORMAT -_DIACTIONA=DIACTIONA -_DIACTIONW=DIACTIONW -_DIACTIONFORMATA=DIACTIONFORMATA -_DIACTIONFORMATW=DIACTIONFORMATW -_DICOLORSET=DICOLORSET -_DICONFIGUREDEVICESPARAMSA=DICONFIGUREDEVICESPARAMSA -_DICONFIGUREDEVICESPARAMSW=DICONFIGUREDEVICESPARAMSW -_DIDEVICEIMAGEINFOA=DIDEVICEIMAGEINFOA -_DIDEVICEIMAGEINFOW=DIDEVICEIMAGEINFOW -_DIDEVICEIMAGEINFOHEADERA=DIDEVICEIMAGEINFOHEADERA -_DIDEVICEIMAGEINFOHEADERW=DIDEVICEIMAGEINFOHEADERW -_CPOINT=CPOINT -_DIMOUSESTATE=DIMOUSESTATE -_DIMOUSESTATE2=DIMOUSESTATE2 -_KEYBOARD_INPUT_DATA=KEYBOARD_INPUT_DATA -_KEYBOARD_TYPEMATIC_PARAMETERS=KEYBOARD_TYPEMATIC_PARAMETERS -_KEYBOARD_ID=KEYBOARD_ID -_KEYBOARD_ATTRIBUTES=KEYBOARD_ATTRIBUTES -_KEYBOARD_EXTENDED_ATTRIBUTES=KEYBOARD_EXTENDED_ATTRIBUTES -_KEYBOARD_INDICATOR_PARAMETERS=KEYBOARD_INDICATOR_PARAMETERS -_INDICATOR_LIST=INDICATOR_LIST -_KEYBOARD_INDICATOR_TRANSLATION=KEYBOARD_INDICATOR_TRANSLATION -_KEYBOARD_UNIT_ID_PARAMETER=KEYBOARD_UNIT_ID_PARAMETER -_KEYBOARD_IME_STATUS=KEYBOARD_IME_STATUS -_MOUSE_INPUT_DATA=MOUSE_INPUT_DATA -_MOUSE_ATTRIBUTES=MOUSE_ATTRIBUTES -_MOUSE_UNIT_ID_PARAMETER=MOUSE_UNIT_ID_PARAMETER -tagHHN_NOTIFY=HHN_NOTIFY -tagHH_POPUP=HH_POPUP -tagHH_AKLINK=HH_AKLINK -tagHH_ENUM_IT=HH_ENUM_IT -tagHH_ENUM_CAT=HH_ENUM_CAT -tagHH_SET_INFOTYPE=HH_SET_INFOTYPE -tagHH_FTS_QUERY=HH_FTS_QUERY -tagHH_WINTYPE=HH_WINTYPE -tagHHNTRACK=HHNTRACK -tagHH_GPROPID=HH_GPROPID -tagHH_GLOBAL_PROPERTY=HH_GLOBAL_PROPERTY -tagROWSTATUS=ROWSTATUS -tagCOLUMNSTATUS=COLUMNSTATUS -_HTTP_SERVER_PROPERTY=HTTP_SERVER_PROPERTY -_HTTP_PROPERTY_FLAGS=HTTP_PROPERTY_FLAGS -_HTTP_ENABLED_STATE=HTTP_ENABLED_STATE -_HTTP_STATE_INFO=HTTP_STATE_INFO -_HTTP_503_RESPONSE_VERBOSITY=HTTP_503_RESPONSE_VERBOSITY -_HTTP_QOS_SETTING_TYPE=HTTP_QOS_SETTING_TYPE -_HTTP_QOS_SETTING_INFO=HTTP_QOS_SETTING_INFO -_HTTP_CONNECTION_LIMIT_INFO=HTTP_CONNECTION_LIMIT_INFO -_HTTP_BANDWIDTH_LIMIT_INFO=HTTP_BANDWIDTH_LIMIT_INFO -_HTTP_FLOWRATE_INFO=HTTP_FLOWRATE_INFO -_HTTP_SERVICE_CONFIG_TIMEOUT_KEY=HTTP_SERVICE_CONFIG_TIMEOUT_KEY -_HTTP_SERVICE_CONFIG_TIMEOUT_SET=HTTP_SERVICE_CONFIG_TIMEOUT_SET -_HTTP_TIMEOUT_LIMIT_INFO=HTTP_TIMEOUT_LIMIT_INFO -_HTTP_SERVICE_CONFIG_SETTING_KEY=HTTP_SERVICE_CONFIG_SETTING_KEY -_HTTP_SERVICE_CONFIG_SETTING_SET=HTTP_SERVICE_CONFIG_SETTING_SET -_HTTP_LISTEN_ENDPOINT_INFO=HTTP_LISTEN_ENDPOINT_INFO -_HTTP_SERVER_AUTHENTICATION_DIGEST_PARAMS=HTTP_SERVER_AUTHENTICATION_DIGEST_PARAMS -_HTTP_SERVER_AUTHENTICATION_BASIC_PARAMS=HTTP_SERVER_AUTHENTICATION_BASIC_PARAMS -_HTTP_SERVER_AUTHENTICATION_INFO=HTTP_SERVER_AUTHENTICATION_INFO -_HTTP_SERVICE_BINDING_TYPE=HTTP_SERVICE_BINDING_TYPE -_HTTP_SERVICE_BINDING_BASE=HTTP_SERVICE_BINDING_BASE -_HTTP_SERVICE_BINDING_A=HTTP_SERVICE_BINDING_A -_HTTP_SERVICE_BINDING_W=HTTP_SERVICE_BINDING_W -_HTTP_AUTHENTICATION_HARDENING_LEVELS=HTTP_AUTHENTICATION_HARDENING_LEVELS -_HTTP_CHANNEL_BIND_INFO=HTTP_CHANNEL_BIND_INFO -_HTTP_REQUEST_CHANNEL_BIND_STATUS=HTTP_REQUEST_CHANNEL_BIND_STATUS -_HTTP_REQUEST_TOKEN_BINDING_INFO=HTTP_REQUEST_TOKEN_BINDING_INFO -_HTTP_LOGGING_TYPE=HTTP_LOGGING_TYPE -_HTTP_LOGGING_ROLLOVER_TYPE=HTTP_LOGGING_ROLLOVER_TYPE -_HTTP_LOGGING_INFO=HTTP_LOGGING_INFO -_HTTP_BINDING_INFO=HTTP_BINDING_INFO -_HTTP_PROTECTION_LEVEL_TYPE=HTTP_PROTECTION_LEVEL_TYPE -_HTTP_PROTECTION_LEVEL_INFO=HTTP_PROTECTION_LEVEL_INFO -_HTTP_BYTE_RANGE=HTTP_BYTE_RANGE -_HTTP_VERSION=HTTP_VERSION -_HTTP_VERB=HTTP_VERB -_HTTP_HEADER_ID=HTTP_HEADER_ID -_HTTP_KNOWN_HEADER=HTTP_KNOWN_HEADER -_HTTP_UNKNOWN_HEADER=HTTP_UNKNOWN_HEADER -_HTTP_LOG_DATA_TYPE=HTTP_LOG_DATA_TYPE -_HTTP_LOG_DATA=HTTP_LOG_DATA -_HTTP_LOG_FIELDS_DATA=HTTP_LOG_FIELDS_DATA -_HTTP_DATA_CHUNK_TYPE=HTTP_DATA_CHUNK_TYPE -_HTTP_DATA_CHUNK=HTTP_DATA_CHUNK -_HTTP_REQUEST_HEADERS=HTTP_REQUEST_HEADERS -_HTTP_RESPONSE_HEADERS=HTTP_RESPONSE_HEADERS -_HTTP_DELEGATE_REQUEST_PROPERTY_ID=HTTP_DELEGATE_REQUEST_PROPERTY_ID -_HTTP_DELEGATE_REQUEST_PROPERTY_INFO=HTTP_DELEGATE_REQUEST_PROPERTY_INFO -_HTTP_TRANSPORT_ADDRESS=HTTP_TRANSPORT_ADDRESS -_HTTP_COOKED_URL=HTTP_COOKED_URL -_HTTP_AUTH_STATUS=HTTP_AUTH_STATUS -_HTTP_REQUEST_AUTH_TYPE=HTTP_REQUEST_AUTH_TYPE -_HTTP_SSL_CLIENT_CERT_INFO=HTTP_SSL_CLIENT_CERT_INFO -_HTTP_SSL_INFO=HTTP_SSL_INFO -_HTTP_SSL_PROTOCOL_INFO=HTTP_SSL_PROTOCOL_INFO -_HTTP_REQUEST_SIZING_TYPE=HTTP_REQUEST_SIZING_TYPE -_HTTP_REQUEST_SIZING_INFO=HTTP_REQUEST_SIZING_INFO -_HTTP_REQUEST_TIMING_TYPE=HTTP_REQUEST_TIMING_TYPE -_HTTP_REQUEST_TIMING_INFO=HTTP_REQUEST_TIMING_INFO -_HTTP_REQUEST_INFO_TYPE=HTTP_REQUEST_INFO_TYPE -_HTTP_REQUEST_INFO=HTTP_REQUEST_INFO -_HTTP_REQUEST_AUTH_INFO=HTTP_REQUEST_AUTH_INFO -_HTTP_REQUEST_V1=HTTP_REQUEST_V1 -_HTTP_REQUEST_V2=HTTP_REQUEST_V2 -_HTTP_RESPONSE_V1=HTTP_RESPONSE_V1 -_HTTP_RESPONSE_INFO_TYPE=HTTP_RESPONSE_INFO_TYPE -_HTTP_RESPONSE_INFO=HTTP_RESPONSE_INFO -_HTTP_MULTIPLE_KNOWN_HEADERS=HTTP_MULTIPLE_KNOWN_HEADERS -_HTTP_RESPONSE_V2=HTTP_RESPONSE_V2 -_HTTPAPI_VERSION=HTTPAPI_VERSION -_HTTP_CACHE_POLICY_TYPE=HTTP_CACHE_POLICY_TYPE -_HTTP_CACHE_POLICY=HTTP_CACHE_POLICY -_HTTP_SERVICE_CONFIG_ID=HTTP_SERVICE_CONFIG_ID -_HTTP_SERVICE_CONFIG_QUERY_TYPE=HTTP_SERVICE_CONFIG_QUERY_TYPE -_HTTP_SERVICE_CONFIG_SSL_KEY=HTTP_SERVICE_CONFIG_SSL_KEY -_HTTP_SERVICE_CONFIG_SSL_KEY_EX=HTTP_SERVICE_CONFIG_SSL_KEY_EX -_HTTP_SERVICE_CONFIG_SSL_SNI_KEY=HTTP_SERVICE_CONFIG_SSL_SNI_KEY -_HTTP_SERVICE_CONFIG_SSL_CCS_KEY=HTTP_SERVICE_CONFIG_SSL_CCS_KEY -_HTTP_SERVICE_CONFIG_SSL_PARAM=HTTP_SERVICE_CONFIG_SSL_PARAM -_HTTP_SSL_SERVICE_CONFIG_EX_PARAM_TYPE=HTTP_SSL_SERVICE_CONFIG_EX_PARAM_TYPE -_HTTP2_WINDOW_SIZE_PARAM=HTTP2_WINDOW_SIZE_PARAM -_HTTP2_SETTINGS_LIMITS_PARAM=HTTP2_SETTINGS_LIMITS_PARAM -_HTTP_PERFORMANCE_PARAM=HTTP_PERFORMANCE_PARAM -_HTTP_SERVICE_CONFIG_SSL_PARAM_EX=HTTP_SERVICE_CONFIG_SSL_PARAM_EX -_HTTP_SERVICE_CONFIG_SSL_SET=HTTP_SERVICE_CONFIG_SSL_SET -_HTTP_SERVICE_CONFIG_SSL_SNI_SET=HTTP_SERVICE_CONFIG_SSL_SNI_SET -_HTTP_SERVICE_CONFIG_SSL_CCS_SET=HTTP_SERVICE_CONFIG_SSL_CCS_SET -_HTTP_SERVICE_CONFIG_SSL_SET_EX=HTTP_SERVICE_CONFIG_SSL_SET_EX -_HTTP_SERVICE_CONFIG_SSL_SNI_SET_EX=HTTP_SERVICE_CONFIG_SSL_SNI_SET_EX -_HTTP_SERVICE_CONFIG_SSL_CCS_SET_EX=HTTP_SERVICE_CONFIG_SSL_CCS_SET_EX -_HTTP_SERVICE_CONFIG_SSL_QUERY=HTTP_SERVICE_CONFIG_SSL_QUERY -_HTTP_SERVICE_CONFIG_SSL_SNI_QUERY=HTTP_SERVICE_CONFIG_SSL_SNI_QUERY -_HTTP_SERVICE_CONFIG_SSL_CCS_QUERY=HTTP_SERVICE_CONFIG_SSL_CCS_QUERY -_HTTP_SERVICE_CONFIG_SSL_QUERY_EX=HTTP_SERVICE_CONFIG_SSL_QUERY_EX -_HTTP_SERVICE_CONFIG_SSL_SNI_QUERY_EX=HTTP_SERVICE_CONFIG_SSL_SNI_QUERY_EX -_HTTP_SERVICE_CONFIG_SSL_CCS_QUERY_EX=HTTP_SERVICE_CONFIG_SSL_CCS_QUERY_EX -_HTTP_SERVICE_CONFIG_IP_LISTEN_PARAM=HTTP_SERVICE_CONFIG_IP_LISTEN_PARAM -_HTTP_SERVICE_CONFIG_IP_LISTEN_QUERY=HTTP_SERVICE_CONFIG_IP_LISTEN_QUERY -_HTTP_SERVICE_CONFIG_URLACL_KEY=HTTP_SERVICE_CONFIG_URLACL_KEY -_HTTP_SERVICE_CONFIG_URLACL_PARAM=HTTP_SERVICE_CONFIG_URLACL_PARAM -_HTTP_SERVICE_CONFIG_URLACL_SET=HTTP_SERVICE_CONFIG_URLACL_SET -_HTTP_SERVICE_CONFIG_URLACL_QUERY=HTTP_SERVICE_CONFIG_URLACL_QUERY -_HTTP_SERVICE_CONFIG_CACHE_KEY=HTTP_SERVICE_CONFIG_CACHE_KEY -_HTTP_REQUEST_PROPERTY=HTTP_REQUEST_PROPERTY -_HTTP_QUERY_REQUEST_QUALIFIER_TCP=HTTP_QUERY_REQUEST_QUALIFIER_TCP -_HTTP_QUERY_REQUEST_QUALIFIER_QUIC=HTTP_QUERY_REQUEST_QUALIFIER_QUIC -_HTTP_REQUEST_PROPERTY_SNI=HTTP_REQUEST_PROPERTY_SNI -_HTTP_URI_SCHEME=HTTP_SCHEME -_SCSI_PASS_THROUGH=SCSI_PASS_THROUGH -_SCSI_PASS_THROUGH_DIRECT=SCSI_PASS_THROUGH_DIRECT -_SCSI_PASS_THROUGH_EX=SCSI_PASS_THROUGH_EX -_SCSI_PASS_THROUGH_DIRECT_EX=SCSI_PASS_THROUGH_DIRECT_EX -_ATA_PASS_THROUGH_EX=ATA_PASS_THROUGH_EX -_ATA_PASS_THROUGH_DIRECT=ATA_PASS_THROUGH_DIRECT -_IDE_IO_CONTROL=IDE_IO_CONTROL -_MPIO_PASS_THROUGH_PATH=MPIO_PASS_THROUGH_PATH -_MPIO_PASS_THROUGH_PATH_DIRECT=MPIO_PASS_THROUGH_PATH_DIRECT -_MPIO_PASS_THROUGH_PATH_EX=MPIO_PASS_THROUGH_PATH_EX -_MPIO_PASS_THROUGH_PATH_DIRECT_EX=MPIO_PASS_THROUGH_PATH_DIRECT_EX -_SCSI_BUS_DATA=SCSI_BUS_DATA -_SCSI_ADAPTER_BUS_INFO=SCSI_ADAPTER_BUS_INFO -_SCSI_INQUIRY_DATA=SCSI_INQUIRY_DATA -_SRB_IO_CONTROL=SRB_IO_CONTROL -_NVCACHE_REQUEST_BLOCK=NVCACHE_REQUEST_BLOCK -_NV_FEATURE_PARAMETER=NV_FEATURE_PARAMETER -_NVCACHE_HINT_PAYLOAD=NVCACHE_HINT_PAYLOAD -_NV_SEP_CACHE_PARAMETER=NV_SEP_CACHE_PARAMETER -_NV_SEP_WRITE_CACHE_TYPE=NV_SEP_WRITE_CACHE_TYPE -_MP_STORAGE_DIAGNOSTIC_LEVEL=MP_STORAGE_DIAGNOSTIC_LEVEL -_MP_STORAGE_DIAGNOSTIC_TARGET_TYPE=MP_STORAGE_DIAGNOSTIC_TARGET_TYPE -_STORAGE_DIAGNOSTIC_MP_REQUEST=STORAGE_DIAGNOSTIC_MP_REQUEST -_MP_DEVICE_DATA_SET_RANGE=MP_DEVICE_DATA_SET_RANGE -_DSM_NOTIFICATION_REQUEST_BLOCK=DSM_NOTIFICATION_REQUEST_BLOCK -_HYBRID_REQUEST_BLOCK=HYBRID_REQUEST_BLOCK -_NVCACHE_TYPE=NVCACHE_TYPE -_NVCACHE_STATUS=NVCACHE_STATUS -_NVCACHE_PRIORITY_LEVEL_DESCRIPTOR=NVCACHE_PRIORITY_LEVEL_DESCRIPTOR -_HYBRID_INFORMATION=HYBRID_INFORMATION -_HYBRID_DIRTY_THRESHOLDS=HYBRID_DIRTY_THRESHOLDS -_HYBRID_DEMOTE_BY_SIZE=HYBRID_DEMOTE_BY_SIZE -_FIRMWARE_REQUEST_BLOCK=FIRMWARE_REQUEST_BLOCK -_STORAGE_FIRMWARE_SLOT_INFO=STORAGE_FIRMWARE_SLOT_INFO -_STORAGE_FIRMWARE_SLOT_INFO_V2=STORAGE_FIRMWARE_SLOT_INFO_V2 -_STORAGE_FIRMWARE_INFO=STORAGE_FIRMWARE_INFO -_STORAGE_FIRMWARE_INFO_V2=STORAGE_FIRMWARE_INFO_V2 -_STORAGE_FIRMWARE_DOWNLOAD=STORAGE_FIRMWARE_DOWNLOAD -_STORAGE_FIRMWARE_DOWNLOAD_V2=STORAGE_FIRMWARE_DOWNLOAD_V2 -_STORAGE_FIRMWARE_ACTIVATE=STORAGE_FIRMWARE_ACTIVATE -_IO_SCSI_CAPABILITIES=IO_SCSI_CAPABILITIES -_SCSI_ADDRESS=SCSI_ADDRESS -_DUMP_POINTERS_VERSION=DUMP_POINTERS_VERSION -_DUMP_POINTERS=DUMP_POINTERS -_DUMP_POINTERS_EX=DUMP_POINTERS_EX -_DUMP_DRIVER=DUMP_DRIVER -_NTSCSI_UNICODE_STRING=NTSCSI_UNICODE_STRING -_DUMP_DRIVER_EX=DUMP_DRIVER_EX -_STORAGE_ENDURANCE_INFO=STORAGE_ENDURANCE_INFO -_STORAGE_ENDURANCE_DATA_DESCRIPTOR=STORAGE_ENDURANCE_DATA_DESCRIPTOR -_ISCSI_UNIQUE_SESSION_ID=ISCSI_UNIQUE_SESSION_ID -_DXVA_AYUVsample2=DXVA_AYUVsample2 -_DXVA_BufferDescription=DXVA_BufferDescription -_DXVA_ConfigPictureDecode=DXVA_ConfigPictureDecode -_DXVA_PictureParameters=DXVA_PictureParameters -_DXVAUncompDataInfo=DXVAUncompDataInfo -_DXVACompBufferInfo=DXVACompBufferInfo -_DXVABufferInfo=DXVABufferInfo -_DXVA_SampleFormat=DXVA_SampleFormat -_DXVA_VideoTransferFunction=DXVA_VideoTransferFunction -_DXVA_VideoPrimaries=DXVA_VideoPrimaries -_DXVA_VideoLighting=DXVA_VideoLighting -_DXVA_VideoTransferMatrix=DXVA_VideoTransferMatrix -_DXVA_NominalRange=DXVA_NominalRange -_DXVA_VideoChromaSubsampling=DXVA_VideoChromaSubsampling -_DXVA_ExtendedFormat=DXVA_ExtendedFormat -_DXVA_Frequency=DXVA_Frequency -_DXVA_VideoDesc=DXVA_VideoDesc -_DXVA_VideoProcessCaps=DXVA_VideoProcessCaps -_DXVA_DeinterlaceTech=DXVA_DeinterlaceTech -_DXVA_VideoSample=DXVA_VideoSample -_DXVA_SampleFlags=DXVA_SampleFlags -_DXVA_DestinationFlags=DXVA_DestinationFlags -_DXVA_VideoSample2=DXVA_VideoSample2 -_DXVA_DeinterlaceCaps=DXVA_DeinterlaceCaps -_DXVA_DeinterlaceBlt=DXVA_DeinterlaceBlt -_DXVA_DeinterlaceBltEx=DXVA_DeinterlaceBltEx -_DXVA_DeinterlaceQueryAvailableModes=DXVA_DeinterlaceQueryAvailableModes -_DXVA_DeinterlaceQueryModeCaps=DXVA_DeinterlaceQueryModeCaps -_DXVA_ProcAmpControlProp=DXVA_ProcAmpControlProp -_DXVA_ProcAmpControlCaps=DXVA_ProcAmpControlCaps -_DXVA_ProcAmpControlQueryRange=DXVA_ProcAmpControlQueryRange -_DXVA_VideoPropertyRange=DXVA_VideoPropertyRange -_DXVA_ProcAmpControlBlt=DXVA_ProcAmpControlBlt -_DXVA_COPPSignature=DXVA_COPPSignature -_DXVA_COPPCommand=DXVA_COPPCommand -_DXVA_COPPSetProtectionLevelCmdData=DXVA_COPPSetProtectionLevelCmdData -_COPP_HDCP_Protection_Level=COPP_HDCP_Protection_Level -_COPP_CGMSA_Protection_Level=COPP_CGMSA_Protection_Level -_COPP_ACP_Protection_Level=COPP_ACP_Protection_Level -_DXVA_COPPSetSignalingCmdData=DXVA_COPPSetSignalingCmdData -_COPP_TVProtectionStandard=COPP_TVProtectionStandard -_COPP_ImageAspectRatio_EN300294=COPP_ImageAspectRatio_EN300294 -_DXVA_COPPStatusInput=DXVA_COPPStatusInput -_DXVA_COPPStatusOutput=DXVA_COPPStatusOutput -_COPP_StatusFlags=COPP_StatusFlags -_DXVA_COPPStatusData=DXVA_COPPStatusData -_DXVA_COPPStatusDisplayData=DXVA_COPPStatusDisplayData -_COPP_StatusHDCPFlags=COPP_StatusHDCPFlags -_DXVA_COPPStatusHDCPKeyData=DXVA_COPPStatusHDCPKeyData -_COPP_ConnectorType=COPP_ConnectorType -_COPP_BusType=COPP_BusType -_DXVA_COPPStatusSignalingCmdData=DXVA_COPPStatusSignalingCmdData -_DSMCC_ELEMENT=DSMCC_ELEMENT -_MPE_ELEMENT=MPE_ELEMENT -_MPEG_STREAM_FILTER=MPEG_STREAM_FILTER -_KSP_BDA_NODE_PIN=KSP_BDA_NODE_PIN -_KSM_BDA_PIN=KSM_BDA_PIN -_KSM_BDA_PIN_PAIR=KSM_BDA_PIN_PAIR -_KSM_BDA_DEBUG_LEVEL=KSM_BDA_DEBUG_LEVEL -_BDA_DEBUG_DATA=BDA_DEBUG_DATA -_BDA_EVENT_DATA=BDA_EVENT_DATA -_KSM_BDA_EVENT_COMPLETE=KSM_BDA_EVENT_COMPLETE -_KSM_BDA_DRM_SETDRM=KSM_BDA_DRM_SETDRM -_KSM_BDA_BUFFER=KSM_BDA_BUFFER -_KSM_BDA_WMDRM_RENEWLICENSE=KSM_BDA_WMDRM_RENEWLICENSE -_KSM_BDA_WMDRMTUNER_PURCHASEENTITLEMENT=KSM_BDA_WMDRMTUNER_PURCHASEENTITLEMENT -_KSM_BDA_WMDRMTUNER_SETPIDPROTECTION=KSM_BDA_WMDRMTUNER_SETPIDPROTECTION -_KSM_BDA_WMDRMTUNER_GETPIDPROTECTION=KSM_BDA_WMDRMTUNER_GETPIDPROTECTION -_KSM_BDA_WMDRMTUNER_SYNCVALUE=KSM_BDA_WMDRMTUNER_SYNCVALUE -_KSM_BDA_TUNER_TUNEREQUEST=KSM_BDA_TUNER_TUNEREQUEST -_KSM_BDA_GPNV_GETVALUE=KSM_BDA_GPNV_GETVALUE -_KSM_BDA_GPNV_SETVALUE=KSM_BDA_GPNV_SETVALUE -_KSM_BDA_GPNV_NAMEINDEX=KSM_BDA_GPNV_NAMEINDEX -_KSM_BDA_SCAN_CAPABILTIES=KSM_BDA_SCAN_CAPABILTIES -_KSM_BDA_SCAN_FILTER=KSM_BDA_SCAN_FILTER -_KSM_BDA_SCAN_START=KSM_BDA_SCAN_START -_KSM_BDA_GDDS_TUNEXMLFROMIDX=KSM_BDA_GDDS_TUNEXMLFROMIDX -_KSM_BDA_GDDS_SERVICEFROMTUNEXML=KSM_BDA_GDDS_SERVICEFROMTUNEXML -_KSM_BDA_USERACTIVITY_USEREASON=KSM_BDA_USERACTIVITY_USEREASON -_KSM_BDA_CAS_ENTITLEMENTTOKEN=KSM_BDA_CAS_ENTITLEMENTTOKEN -_KSM_BDA_CAS_CAPTURETOKEN=KSM_BDA_CAS_CAPTURETOKEN -_KSM_BDA_CAS_OPENBROADCASTMMI=KSM_BDA_CAS_OPENBROADCASTMMI -_KSM_BDA_CAS_CLOSEMMIDIALOG=KSM_BDA_CAS_CLOSEMMIDIALOG -_KSM_BDA_ISDBCAS_REQUEST=KSM_BDA_ISDBCAS_REQUEST -_KSM_BDA_TS_SELECTOR_SETTSID=KSM_BDA_TS_SELECTOR_SETTSID -tagKS_DATARANGE_BDA_ANTENNA=KS_DATARANGE_BDA_ANTENNA -tagBDA_TRANSPORT_INFO=BDA_TRANSPORT_INFO -tagKS_DATARANGE_BDA_TRANSPORT=KS_DATARANGE_BDA_TRANSPORT -_ChannelChangeInfo=ChannelChangeInfo -_ChannelTypeInfo=ChannelTypeInfo -_ChannelInfo=ChannelInfo -_SpanningEventDescriptor=SpanningEventDescriptor -_DVBScramblingControlSpanningEvent=DVBScramblingControlSpanningEvent -_SpanningEventEmmMessage=SpanningEventEmmMessage -_LanguageInfo=LanguageInfo -_DualMonoInfo=DualMonoInfo -_PIDListSpanningEvent=PIDListSpanningEvent -_PBDAParentalControl=PBDAParentalControl -_WSD_HANDLER_CONTEXT=WSD_HANDLER_CONTEXT -_WSD_EVENT=WSD_EVENT -_DeviceDiscoveryMechanism=DeviceDiscoveryMechanism -_WSD_PROTOCOL_TYPE=WSD_PROTOCOL_TYPE -_WSD_OPERATION=WSD_OPERATION -_WSDEventType=WSDEventType -_WSD_SYNCHRONOUS_RESPONSE_CONTEXT=WSD_SYNCHRONOUS_RESPONSE_CONTEXT -_WSD_PORT_TYPE=WSD_PORT_TYPE -_WSD_RELATIONSHIP_METADATA=WSD_RELATIONSHIP_METADATA -_WSD_SERVICE_METADATA_LIST=WSD_SERVICE_METADATA_LIST -_WSD_HOST_METADATA=WSD_HOST_METADATA -_WSD_ENDPOINT_REFERENCE_LIST=WSD_ENDPOINT_REFERENCE_LIST -_WSD_SERVICE_METADATA=WSD_SERVICE_METADATA -_WSD_THIS_DEVICE_METADATA=WSD_THIS_DEVICE_METADATA -_WSD_THIS_MODEL_METADATA=WSD_THIS_MODEL_METADATA -_WSD_LOCALIZED_STRING_LIST=WSD_LOCALIZED_STRING_LIST -_WSD_SOAP_FAULT_REASON=WSD_SOAP_FAULT_REASON -_WSD_SOAP_FAULT_SUBCODE=WSD_SOAP_FAULT_SUBCODE -_WSD_SOAP_FAULT_CODE=WSD_SOAP_FAULT_CODE -_WSD_SOAP_FAULT=WSD_SOAP_FAULT -_WSD_APP_SEQUENCE=WSD_APP_SEQUENCE -_WSD_HEADER_RELATESTO=WSD_HEADER_RELATESTO -_WSD_SOAP_HEADER=WSD_SOAP_HEADER -_WSD_SOAP_MESSAGE=WSD_SOAP_MESSAGE -_WSD_RESOLVE_MATCHES=WSD_RESOLVE_MATCHES -_WSD_RESOLVE_MATCH=WSD_RESOLVE_MATCH -_WSD_RESOLVE=WSD_RESOLVE -_WSD_PROBE_MATCH=WSD_PROBE_MATCH -_WSD_PROBE_MATCH_LIST=WSD_PROBE_MATCH_LIST -_WSD_PROBE_MATCHES=WSD_PROBE_MATCHES -_WSD_PROBE=WSD_PROBE -_WSD_BYE=WSD_BYE -_WSD_SCOPES=WSD_SCOPES -_WSD_NAME_LIST=WSD_NAME_LIST -_WSD_HELLO=WSD_HELLO -_WSD_REFERENCE_PARAMETERS=WSD_REFERENCE_PARAMETERS -_WSD_REFERENCE_PROPERTIES=WSD_REFERENCE_PROPERTIES -_WSD_ENDPOINT_REFERENCE=WSD_ENDPOINT_REFERENCE -_WSD_METADATA_SECTION=WSD_METADATA_SECTION -_WSD_METADATA_SECTION_LIST=WSD_METADATA_SECTION_LIST -_WSD_URI_LIST=WSD_URI_LIST -_WSD_EVENTING_FILTER_ACTION=WSD_EVENTING_FILTER_ACTION -_WSD_EVENTING_FILTER=WSD_EVENTING_FILTER -_WSD_EVENTING_EXPIRES=WSD_EVENTING_EXPIRES -_WSD_EVENTING_DELIVERY_MODE_PUSH=WSD_EVENTING_DELIVERY_MODE_PUSH -_WSD_EVENTING_DELIVERY_MODE=WSD_EVENTING_DELIVERY_MODE -_WSD_LOCALIZED_STRING=WSD_LOCALIZED_STRING -_WSD_UNKNOWN_LOOKUP=WSD_UNKNOWN_LOOKUP -tagATTRIBUTE_TYPE=ATTRIBUTE_TYPE -tagOCTET_STRING=OCTET_STRING -tagLIFE_TIME=LIFE_TIME -tagHELPER_ATTRIBUTE=HELPER_ATTRIBUTE -tagREPAIR_SCOPE=REPAIR_SCOPE -tagShellCommandInfo=ShellCommandInfo -tagUiInfo=UiInfo -tagRepairInfo=RepairInfo -tagRepairInfoEx=RepairInfoEx -tagRootCauseInfo=RootCauseInfo -_RADIUS_ATTRIBUTE_TYPE=RADIUS_ATTRIBUTE_TYPE -_RADIUS_CODE=RADIUS_CODE -_RADIUS_AUTHENTICATION_PROVIDER=RADIUS_AUTHENTICATION_PROVIDER -_RADIUS_REJECT_REASON_CODE=RADIUS_REJECT_REASON_CODE -_RADIUS_DATA_TYPE=RADIUS_DATA_TYPE -_RADIUS_ATTRIBUTE=RADIUS_ATTRIBUTE -_RADIUS_VSA_FORMAT=RADIUS_VSA_FORMAT -_RADIUS_ACTION=RADIUS_ACTION -_RADIUS_EXTENSION_POINT=RADIUS_EXTENSION_POINT -_RADIUS_ATTRIBUTE_ARRAY=RADIUS_ATTRIBUTE_ARRAY -_RADIUS_EXTENSION_CONTROL_BLOCK=RADIUS_EXTENSION_CONTROL_BLOCK -_ONEX_AUTH_IDENTITY=ONEX_AUTH_IDENTITY -_ONEX_AUTH_STATUS=ONEX_AUTH_STATUS -_ONEX_REASON_CODE=ONEX_REASON_CODE -_ONEX_NOTIFICATION_TYPE=ONEX_NOTIFICATION_TYPE -_ONEX_AUTH_RESTART_REASON=ONEX_AUTH_RESTART_REASON -_ONEX_VARIABLE_BLOB=ONEX_VARIABLE_BLOB -_ONEX_AUTH_PARAMS=ONEX_AUTH_PARAMS -_ONEX_EAP_ERROR=ONEX_EAP_ERROR -_ONEX_STATUS=ONEX_STATUS -_ONEX_EAP_METHOD_BACKEND_SUPPORT=ONEX_EAP_METHOD_BACKEND_SUPPORT -_ONEX_RESULT_UPDATE_DATA=ONEX_RESULT_UPDATE_DATA -_ONEX_USER_INFO=ONEX_USER_INFO -_PNRP_SCOPE=PNRP_SCOPE -_PNRP_CLOUD_STATE=PNRP_CLOUD_STATE -_PNRP_CLOUD_FLAGS=PNRP_CLOUD_FLAGS -_PNRP_REGISTERED_ID_STATE=PNRP_REGISTERED_ID_STATE -_PNRP_RESOLVE_CRITERIA=PNRP_RESOLVE_CRITERIA -_PNRP_CLOUD_ID=PNRP_CLOUD_ID -_PNRP_EXTENDED_PAYLOAD_TYPE=PNRP_EXTENDED_PAYLOAD_TYPE -_PNRPINFO_V1=PNRPINFO_V1 -_PNRPINFO_V2=PNRPINFO_V2 -_PNRPCLOUDINFO=PNRPCLOUDINFO -tagWPCFLAG_ISBLOCKED=WPCFLAG_ISBLOCKED -tagWPCFLAG_LOGOFF_TYPE=WPCFLAG_LOGOFF_TYPE -tagWPC_ARGS_SETTINGSCHANGEEVENT=WPC_ARGS_SETTINGSCHANGEEVENT -tagWPC_ARGS_SAFERAPPBLOCKED=WPC_ARGS_SAFERAPPBLOCKED -tagWPC_ARGS_EMAILRECEIEVEDEVENT=WPC_ARGS_EMAILRECEIEVEDEVENT -tagWPC_ARGS_EMAILSENTEVENT=WPC_ARGS_EMAILSENTEVENT -tagWPC_ARGS_EMAILCONTACTEVENT=WPC_ARGS_EMAILCONTACTEVENT -tagWPC_MEDIA_TYPE=WPC_MEDIA_TYPE -tagWPC_ARGS_MEDIAPLAYBACKEVENT=WPC_ARGS_MEDIAPLAYBACKEVENT -tagWPC_ARGS_MEDIADOWNLOADEVENT=WPC_ARGS_MEDIADOWNLOADEVENT -tagWPC_ARGS_CONVERSATIONINITEVENT=WPC_ARGS_CONVERSATIONINITEVENT -tagWPC_ARGS_CONVERSATIONJOINEVENT=WPC_ARGS_CONVERSATIONJOINEVENT -tagWPC_ARGS_CONVERSATIONLEAVEEVENT=WPC_ARGS_CONVERSATIONLEAVEEVENT -tagWPCFLAG_IM_FEATURE=WPCFLAG_IM_FEATURE -tagWPC_ARGS_IMFEATUREEVENT=WPC_ARGS_IMFEATUREEVENT -tagWPC_ARGS_IMCONTACTEVENT=WPC_ARGS_IMCONTACTEVENT -tagWPC_ARGS_GAMESTARTEVENT=WPC_ARGS_GAMESTARTEVENT -tagWPC_ARGS_FILEDOWNLOADEVENT=WPC_ARGS_FILEDOWNLOADEVENT -tagWPC_ARGS_URLVISITEVENT=WPC_ARGS_URLVISITEVENT -tagWPC_ARGS_WEBSITEVISITEVENT=WPC_ARGS_WEBSITEVISITEVENT -tagWPC_ARGS_APPLICATIONEVENT=WPC_ARGS_APPLICATIONEVENT -tagWPC_ARGS_COMPUTERUSAGEEVENT=WPC_ARGS_COMPUTERUSAGEEVENT -tagWPC_ARGS_CONTENTUSAGEEVENT=WPC_ARGS_CONTENTUSAGEEVENT -tagWPC_ARGS_CUSTOMEVENT=WPC_ARGS_CUSTOMEVENT -tagWPC_ARGS_WEBOVERRIDEEVENT=WPC_ARGS_WEBOVERRIDEEVENT -tagWPC_ARGS_APPOVERRIDEEVENT=WPC_ARGS_APPOVERRIDEEVENT -tagWPC_SETTINGS=WPC_SETTINGS -_QOS_FRIENDLY_NAME=QOS_FRIENDLY_NAME -_QOS_TRAFFIC_CLASS=QOS_TRAFFIC_CLASS -_QOS_DS_CLASS=QOS_DS_CLASS -_QOS_DIFFSERV=QOS_DIFFSERV -_QOS_DIFFSERV_RULE=QOS_DIFFSERV_RULE -_QOS_TCP_TRAFFIC=QOS_TCP_TRAFFIC -_DRMID=DRMID -_DRMTIMETYPE=DRMTIMETYPE -_DRMENCODINGTYPE=DRMENCODINGTYPE -_DRMATTESTTYPE=DRMATTESTTYPE -_DRMSPECTYPE=DRMSPECTYPE -_DRMSECURITYPROVIDERTYPE=DRMSECURITYPROVIDERTYPE -_DRMGLOBALOPTIONS=DRMGLOBALOPTIONS -_DRMBOUNDLICENSEPARAMS=DRMBOUNDLICENSEPARAMS -_DRM_LICENSE_ACQ_DATA=DRM_LICENSE_ACQ_DATA -_DRM_ACTSERV_INFO=DRM_ACTSERV_INFO -_DRM_CLIENT_VERSION_INFO=DRM_CLIENT_VERSION_INFO -_DRM_STATUS_MSG=DRM_STATUS_MSG -_DRM_USAGEPOLICY_TYPE=DRM_USAGEPOLICY_TYPE -_DRM_DISTRIBUTION_POINT_INFO=DRM_DISTRIBUTION_POINT_INFO -tagDB_NUMERIC=DB_NUMERIC -tagDBVECTOR=DBVECTOR -tagDBDATE=DBDATE -tagDBTIME=DBTIME -tagDBTIMESTAMP=DBTIMESTAMP -tagDB_VARNUMERIC=DB_VARNUMERIC -_SEC_OBJECT_ELEMENT=SEC_OBJECT_ELEMENT -_SEC_OBJECT=SEC_OBJECT -tagDBIMPLICITSESSION=DBIMPLICITSESSION -tagDBOBJECT=DBOBJECT -tagDBBINDEXT=DBBINDEXT -tagDBBINDING=DBBINDING -tagDBFAILUREINFO=DBFAILUREINFO -tagDBCOLUMNINFO=DBCOLUMNINFO -tagDBBOOKMARK=DBBOOKMARK -tagDBPARAMS=DBPARAMS -tagDBPARAMINFO=DBPARAMINFO -tagDBPROPIDSET=DBPROPIDSET -tagDBPROPINFO=DBPROPINFO -tagDBPROPINFOSET=DBPROPINFOSET -tagDBPROP=DBPROP -tagDBPROPSET=DBPROPSET -tagDBINDEXCOLUMNDESC=DBINDEXCOLUMNDESC -tagDBCOLUMNDESC=DBCOLUMNDESC -tagDBCOLUMNACCESS=DBCOLUMNACCESS -tagDBCONSTRAINTDESC=DBCONSTRAINTDESC -tagMDAXISINFO=MDAXISINFO -tagRMTPACK=RMTPACK -tagDBPARAMBINDINFO=DBPARAMBINDINFO -tagDBLITERALINFO=DBLITERALINFO -tagERRORINFO=ERRORINFO -_tagITEMPROP=ITEMPROP -tagSUBSCRIPTIONITEMINFO=SUBSCRIPTIONITEMINFO -_WINBIO_VERSION=WINBIO_VERSION -_WINBIO_IDENTITY=WINBIO_IDENTITY -_WINBIO_SECURE_CONNECTION_PARAMS=WINBIO_SECURE_CONNECTION_PARAMS -_WINBIO_SECURE_CONNECTION_DATA=WINBIO_SECURE_CONNECTION_DATA -_WINBIO_BIR_DATA=WINBIO_BIR_DATA -_WINBIO_BIR=WINBIO_BIR -_WINBIO_REGISTERED_FORMAT=WINBIO_REGISTERED_FORMAT -_WINBIO_BIR_HEADER=WINBIO_BIR_HEADER -_WINBIO_BDB_ANSI_381_HEADER=WINBIO_BDB_ANSI_381_HEADER -_WINBIO_BDB_ANSI_381_RECORD=WINBIO_BDB_ANSI_381_RECORD -_WINBIO_SECURE_BUFFER_HEADER_V1=WINBIO_SECURE_BUFFER_HEADER_V1 -_WINBIO_EVENT=WINBIO_EVENT -_WINBIO_PRESENCE_PROPERTIES=WINBIO_PRESENCE_PROPERTIES -_WINBIO_PRESENCE=WINBIO_PRESENCE -_WINBIO_BSP_SCHEMA=WINBIO_BSP_SCHEMA -_WINBIO_UNIT_SCHEMA=WINBIO_UNIT_SCHEMA -_WINBIO_STORAGE_SCHEMA=WINBIO_STORAGE_SCHEMA -_WINBIO_EXTENDED_SENSOR_INFO=WINBIO_EXTENDED_SENSOR_INFO -_WINBIO_EXTENDED_ENGINE_INFO=WINBIO_EXTENDED_ENGINE_INFO -_WINBIO_EXTENDED_STORAGE_INFO=WINBIO_EXTENDED_STORAGE_INFO -_WINBIO_EXTENDED_ENROLLMENT_STATUS=WINBIO_EXTENDED_ENROLLMENT_STATUS -_WINBIO_EXTENDED_UNIT_STATUS=WINBIO_EXTENDED_UNIT_STATUS -_WINBIO_FP_BU_STATE=WINBIO_FP_BU_STATE -_WINBIO_ANTI_SPOOF_POLICY_ACTION=WINBIO_ANTI_SPOOF_POLICY_ACTION -_WINBIO_POLICY_SOURCE=WINBIO_POLICY_SOURCE -_WINBIO_ANTI_SPOOF_POLICY=WINBIO_ANTI_SPOOF_POLICY -_WINBIO_CREDENTIAL_TYPE=WINBIO_CREDENTIAL_TYPE -_WINBIO_CREDENTIAL_FORMAT=WINBIO_CREDENTIAL_FORMAT -_WINBIO_CREDENTIAL_STATE=WINBIO_CREDENTIAL_STATE -_WINBIO_EXTENDED_ENROLLMENT_PARAMETERS=WINBIO_EXTENDED_ENROLLMENT_PARAMETERS -_WINBIO_ACCOUNT_POLICY=WINBIO_ACCOUNT_POLICY -_WINBIO_PROTECTION_POLICY=WINBIO_PROTECTION_POLICY -_WINBIO_GESTURE_METADATA=WINBIO_GESTURE_METADATA -_CERTTRANSBLOB=CERTTRANSBLOB -_CERTVIEWRESTRICTION=CERTVIEWRESTRICTION -_CAINFO=CAINFO -_LLFILETIME=LLFILETIME -tagDdqAccessLevel=DdqAccessLevel -tagDIAGNOSTIC_DATA_RECORD=DIAGNOSTIC_DATA_RECORD -tagDIAGNOSTIC_DATA_SEARCH_CRITERIA=DIAGNOSTIC_DATA_SEARCH_CRITERIA -tagDIAGNOSTIC_DATA_EVENT_TAG_DESCRIPTION=DIAGNOSTIC_DATA_EVENT_TAG_DESCRIPTION -tagDIAGNOSTIC_DATA_EVENT_PRODUCER_DESCRIPTION=DIAGNOSTIC_DATA_EVENT_PRODUCER_DESCRIPTION -tagDIAGNOSTIC_DATA_EVENT_CATEGORY_DESCRIPTION=DIAGNOSTIC_DATA_EVENT_CATEGORY_DESCRIPTION -tagDIAGNOSTIC_DATA_EVENT_TAG_STATS=DIAGNOSTIC_DATA_EVENT_TAG_STATS -tagDIAGNOSTIC_DATA_EVENT_BINARY_STATS=DIAGNOSTIC_DATA_EVENT_BINARY_STATS -tagDIAGNOSTIC_DATA_GENERAL_STATS=DIAGNOSTIC_DATA_GENERAL_STATS -tagDIAGNOSTIC_DATA_EVENT_TRANSCRIPT_CONFIGURATION=DIAGNOSTIC_DATA_EVENT_TRANSCRIPT_CONFIGURATION -tagDIAGNOSTIC_REPORT_PARAMETER=DIAGNOSTIC_REPORT_PARAMETER -tagDIAGNOSTIC_REPORT_SIGNATURE=DIAGNOSTIC_REPORT_SIGNATURE -tagDIAGNOSTIC_REPORT_DATA=DIAGNOSTIC_REPORT_DATA -_WINDOWDATA=WINDOWDATA -tagHLITEM=HLITEM -_tagHLTBINFO=HLTBINFO -_tagHLBWINFO=HLBWINFO -tagCPLINFO=CPLINFO -tagNEWCPLINFOA=NEWCPLINFOA -tagNEWCPLINFOW=NEWCPLINFOW -tagCHANNEL_DEF=CHANNEL_DEF -tagCHANNEL_PDU_HEADER=CHANNEL_PDU_HEADER -tagCHANNEL_ENTRY_POINTS=CHANNEL_ENTRY_POINTS -_TSSD_AddrV46Type=TSSD_AddrV46Type -_TSSB_NOTIFICATION_TYPE=TSSB_NOTIFICATION_TYPE -_TARGET_STATE=TARGET_STATE -_TARGET_CHANGE_TYPE=TARGET_CHANGE_TYPE -_TARGET_TYPE=TARGET_TYPE -_TARGET_PATCH_STATE=TARGET_PATCH_STATE -_CLIENT_MESSAGE_TYPE=CLIENT_MESSAGE_TYPE -_CONNECTION_CHANGE_NOTIFICATION=CONNECTION_CHANGE_NOTIFICATION -_RD_FARM_TYPE=RD_FARM_TYPE -_PLUGIN_TYPE=PLUGIN_TYPE -_TSSESSION_STATE=TSSESSION_STATE -_TARGET_OWNER=TARGET_OWNER -_VM_NOTIFY_STATUS=VM_NOTIFY_STATUS -_VM_NOTIFY_ENTRY=VM_NOTIFY_ENTRY -_VM_PATCH_INFO=VM_PATCH_INFO -_VM_NOTIFY_INFO=VM_NOTIFY_INFO -_VM_HOST_NOTIFY_STATUS=VM_HOST_NOTIFY_STATUS -_RDV_TASK_STATUS=RDV_TASK_STATUS -_WTS_SOCKADDR=WTS_SOCKADDR -_WTS_SMALL_RECT=WTS_SMALL_RECT -_WTS_SERVICE_STATE=WTS_SERVICE_STATE -_WTS_SESSION_ID=WTS_SESSION_ID -_WTS_USER_CREDENTIAL=WTS_USER_CREDENTIAL -_WTS_SYSTEMTIME=WTS_SYSTEMTIME -_WTS_TIME_ZONE_INFORMATION=WTS_TIME_ZONE_INFORMATION -_WRDS_DYNAMIC_TIME_ZONE_INFORMATION=WRDS_DYNAMIC_TIME_ZONE_INFORMATION -_WTS_CLIENT_DATA=WTS_CLIENT_DATA -_WTS_USER_DATA=WTS_USER_DATA -_WTS_POLICY_DATA=WTS_POLICY_DATA -_WTS_PROTOCOL_CACHE=WTS_PROTOCOL_CACHE -_WTS_CACHE_STATS_UN=WTS_CACHE_STATS_UN -_WTS_CACHE_STATS=WTS_CACHE_STATS -_WTS_PROTOCOL_COUNTERS=WTS_PROTOCOL_COUNTERS -_WTS_PROTOCOL_STATUS=WTS_PROTOCOL_STATUS -_WTS_DISPLAY_IOCTL=WTS_DISPLAY_IOCTL -_WTS_LOGON_ERROR_REDIRECTOR_RESPONSE=WTS_LOGON_ERROR_REDIRECTOR_RESPONSE -_WTS_LICENSE_CAPABILITIES=WTS_LICENSE_CAPABILITIES -_WRDS_CONNECTION_SETTING_LEVEL=WRDS_CONNECTION_SETTING_LEVEL -_WRDS_LISTENER_SETTING_LEVEL=WRDS_LISTENER_SETTING_LEVEL -_WRDS_SETTING_TYPE=WRDS_SETTING_TYPE -_WRDS_SETTING_STATUS=WRDS_SETTING_STATUS -_WRDS_SETTING_LEVEL=WRDS_SETTING_LEVEL -_WRDS_LISTENER_SETTINGS_1=WRDS_LISTENER_SETTINGS_1 -_WRDS_LISTENER_SETTING=WRDS_LISTENER_SETTING -_WRDS_LISTENER_SETTINGS=WRDS_LISTENER_SETTINGS -_WRDS_CONNECTION_SETTINGS_1=WRDS_CONNECTION_SETTINGS_1 -_WRDS_SETTINGS_1=WRDS_SETTINGS_1 -_WRDS_CONNECTION_SETTING=WRDS_CONNECTION_SETTING -_WRDS_CONNECTION_SETTINGS=WRDS_CONNECTION_SETTINGS -_WRDS_SETTING=WRDS_SETTING -_WRDS_SETTINGS=WRDS_SETTINGS -_MAPIUID=MAPIUID -_SPropTagArray=SPropTagArray -_SPropValue=SPropValue -_SBinary=SBinary -_SShortArray=SShortArray -_SGuidArray=SGuidArray -_SRealArray=SRealArray -_SLongArray=SLongArray -_SLargeIntegerArray=SLargeIntegerArray -_SDateTimeArray=SDateTimeArray -_SAppTimeArray=SAppTimeArray -_SCurrencyArray=SCurrencyArray -_SBinaryArray=SBinaryArray -_SDoubleArray=SDoubleArray -_SWStringArray=SWStringArray -_SLPSTRArray=SLPSTRArray -_SPropProblem=SPropProblem -_SPropProblemArray=SPropProblemArray -_ADRENTRY=ADRENTRY -_ADRLIST=ADRLIST -_SRow=SRow -_SRowSet=SRowSet -_MAPIERROR=MAPIERROR -_ERROR_NOTIFICATION=ERROR_NOTIFICATION -_NEWMAIL_NOTIFICATION=NEWMAIL_NOTIFICATION -_OBJECT_NOTIFICATION=OBJECT_NOTIFICATION -_TABLE_NOTIFICATION=TABLE_NOTIFICATION -_EXTENDED_NOTIFICATION=EXTENDED_NOTIFICATION -_NOTIFICATION=NOTIFICATION -_MAPINAMEID=MAPINAMEID -_SSortOrder=SSortOrder -_SSortOrderSet=SSortOrderSet -_SAndRestriction=SAndRestriction -_SOrRestriction=SOrRestriction -_SNotRestriction=SNotRestriction -_SContentRestriction=SContentRestriction -_SBitMaskRestriction=SBitMaskRestriction -_SPropertyRestriction=SPropertyRestriction -_SComparePropsRestriction=SComparePropsRestriction -_SSizeRestriction=SSizeRestriction -_SExistRestriction=SExistRestriction -_SSubRestriction=SSubRestriction -_SCommentRestriction=SCommentRestriction -_SRestriction=SRestriction -_ADRPARM=ADRPARM -_DTBLLABEL=DTBLLABEL -_DTBLEDIT=DTBLEDIT -_DTBLLBX=DTBLLBX -_DTBLCOMBOBOX=DTBLCOMBOBOX -_DTBLDDLBX=DTBLDDLBX -_DTBLCHECKBOX=DTBLCHECKBOX -_DTBLGROUPBOX=DTBLGROUPBOX -_DTBLBUTTON=DTBLBUTTON -_DTBLPAGE=DTBLPAGE -_DTBLRADIOBUTTON=DTBLRADIOBUTTON -_DTBLMVLISTBOX=DTBLMVLISTBOX -_DTBLMVDDLBX=DTBLMVDDLBX -tagWCN_ATTRIBUTE_TYPE=WCN_ATTRIBUTE_TYPE -tagWCN_VALUE_TYPE_VERSION=WCN_VALUE_TYPE_VERSION -tagWCN_VALUE_TYPE_BOOLEAN=WCN_VALUE_TYPE_BOOLEAN -tagWCN_VALUE_TYPE_ASSOCIATION_STATE=WCN_VALUE_TYPE_ASSOCIATION_STATE -tagWCN_VALUE_TYPE_AUTHENTICATION_TYPE=WCN_VALUE_TYPE_AUTHENTICATION_TYPE -tagWCN_VALUE_TYPE_CONFIG_METHODS=WCN_VALUE_TYPE_CONFIG_METHODS -tagWCN_VALUE_TYPE_CONFIGURATION_ERROR=WCN_VALUE_TYPE_CONFIGURATION_ERROR -tagWCN_VALUE_TYPE_CONNECTION_TYPE=WCN_VALUE_TYPE_CONNECTION_TYPE -tagWCN_VALUE_TYPE_DEVICE_PASSWORD_ID=WCN_VALUE_TYPE_DEVICE_PASSWORD_ID -tagWCN_VALUE_TYPE_ENCRYPTION_TYPE=WCN_VALUE_TYPE_ENCRYPTION_TYPE -tagWCN_VALUE_TYPE_MESSAGE_TYPE=WCN_VALUE_TYPE_MESSAGE_TYPE -tagWCN_VALUE_TYPE_REQUEST_TYPE=WCN_VALUE_TYPE_REQUEST_TYPE -tagWCN_VALUE_TYPE_RESPONSE_TYPE=WCN_VALUE_TYPE_RESPONSE_TYPE -tagWCN_VALUE_TYPE_RF_BANDS=WCN_VALUE_TYPE_RF_BANDS -tagWCN_VALUE_TYPE_WI_FI_PROTECTED_SETUP_STATE=WCN_VALUE_TYPE_WI_FI_PROTECTED_SETUP_STATE -tagWCN_VALUE_TYPE_PRIMARY_DEVICE_TYPE=WCN_VALUE_TYPE_PRIMARY_DEVICE_TYPE -_VDMCONTEXT_WITHOUT_XSAVE=VDMCONTEXT_WITHOUT_XSAVE -_DCICMD=DCICMD -_DCICREATEINPUT=DCICREATEINPUT -_DCISURFACEINFO=DCISURFACEINFO -_DCIENUMINPUT=DCIENUMINPUT -_DCIOFFSCREEN=DCIOFFSCREEN -_DCIOVERLAY=DCIOVERLAY -_PROCESS_LIST=PROCESS_LIST -_DDMONITORINFO=DDMONITORINFO -_VIDMEM=VIDMEM -_VIDMEMINFO=VIDMEMINFO -_HEAPALIAS=HEAPALIAS -_HEAPALIASINFO=HEAPALIASINFO -_IUNKNOWN_LIST=IUNKNOWN_LIST -_DDHAL_DDCALLBACKS=DDHAL_DDCALLBACKS -_DDHAL_DDPALETTECALLBACKS=DDHAL_DDPALETTECALLBACKS -_DDHAL_DDSURFACECALLBACKS=DDHAL_DDSURFACECALLBACKS -_DDHAL_DDMISCELLANEOUSCALLBACKS=DDHAL_DDMISCELLANEOUSCALLBACKS -_DDHAL_DDMISCELLANEOUS2CALLBACKS=DDHAL_DDMISCELLANEOUS2CALLBACKS -_DDHAL_DDEXEBUFCALLBACKS=DDHAL_DDEXEBUFCALLBACKS -_DDHAL_DDVIDEOPORTCALLBACKS=DDHAL_DDVIDEOPORTCALLBACKS -_DDHAL_DDCOLORCONTROLCALLBACKS=DDHAL_DDCOLORCONTROLCALLBACKS -_DDHAL_DDKERNELCALLBACKS=DDHAL_DDKERNELCALLBACKS -_DDHAL_DDMOTIONCOMPCALLBACKS=DDHAL_DDMOTIONCOMPCALLBACKS -_DDNONLOCALVIDMEMCAPS=DDNONLOCALVIDMEMCAPS -_DDMORESURFACECAPS=DDMORESURFACECAPS -_DDSTEREOMODE=DDSTEREOMODE -_DDRAWI_DDRAWPALETTE_INT=DDRAWI_DDRAWPALETTE_INT -_DDRAWI_DDRAWPALETTE_GBL=DDRAWI_DDRAWPALETTE_GBL -_DDRAWI_DDRAWPALETTE_LCL=DDRAWI_DDRAWPALETTE_LCL -_DDRAWI_DDRAWCLIPPER_INT=DDRAWI_DDRAWCLIPPER_INT -_DDRAWI_DDRAWCLIPPER_GBL=DDRAWI_DDRAWCLIPPER_GBL -_DDRAWI_DDRAWCLIPPER_LCL=DDRAWI_DDRAWCLIPPER_LCL -_ATTACHLIST=ATTACHLIST -_DBLNODE=DBLNODE -_ACCESSRECTLIST=ACCESSRECTLIST -_DDRAWI_DDRAWSURFACE_INT=DDRAWI_DDRAWSURFACE_INT -_DDRAWI_DDRAWSURFACE_GBL=DDRAWI_DDRAWSURFACE_GBL -_DDRAWI_DDRAWSURFACE_GBL_MORE=DDRAWI_DDRAWSURFACE_GBL_MORE -_DDRAWI_DDRAWSURFACE_MORE=DDRAWI_DDRAWSURFACE_MORE -_DDRAWI_DDRAWSURFACE_LCL=DDRAWI_DDRAWSURFACE_LCL -_DDHALMODEINFO=DDHALMODEINFO -_DDRAWI_DIRECTDRAW_INT=DDRAWI_DIRECTDRAW_INT -_DDHAL_CALLBACKS=DDHAL_CALLBACKS -_DDCORECAPS=DDCORECAPS -_DDRAWI_DIRECTDRAW_GBL=DDRAWI_DIRECTDRAW_GBL -_DDRAWI_DIRECTDRAW_LCL=DDRAWI_DIRECTDRAW_LCL -_DDRAWI_DDVIDEOPORT_INT=DDRAWI_DDVIDEOPORT_INT -_DDRAWI_DDVIDEOPORT_LCL=DDRAWI_DDVIDEOPORT_LCL -_DDRAWI_DDMOTIONCOMP_INT=DDRAWI_DDMOTIONCOMP_INT -_DDRAWI_DDMOTIONCOMP_LCL=DDRAWI_DDMOTIONCOMP_LCL -_DDHALINFO=DDHALINFO -_DDHAL_BLTDATA=DDHAL_BLTDATA -_DDHAL_LOCKDATA=DDHAL_LOCKDATA -_DDHAL_UNLOCKDATA=DDHAL_UNLOCKDATA -_DDHAL_UPDATEOVERLAYDATA=DDHAL_UPDATEOVERLAYDATA -_DDHAL_SETOVERLAYPOSITIONDATA=DDHAL_SETOVERLAYPOSITIONDATA -_DDHAL_SETPALETTEDATA=DDHAL_SETPALETTEDATA -_DDHAL_FLIPDATA=DDHAL_FLIPDATA -_DDHAL_DESTROYSURFACEDATA=DDHAL_DESTROYSURFACEDATA -_DDHAL_SETCLIPLISTDATA=DDHAL_SETCLIPLISTDATA -_DDHAL_ADDATTACHEDSURFACEDATA=DDHAL_ADDATTACHEDSURFACEDATA -_DDHAL_SETCOLORKEYDATA=DDHAL_SETCOLORKEYDATA -_DDHAL_GETBLTSTATUSDATA=DDHAL_GETBLTSTATUSDATA -_DDHAL_GETFLIPSTATUSDATA=DDHAL_GETFLIPSTATUSDATA -_DDHAL_DESTROYPALETTEDATA=DDHAL_DESTROYPALETTEDATA -_DDHAL_SETENTRIESDATA=DDHAL_SETENTRIESDATA -_DDHAL_CREATESURFACEDATA=DDHAL_CREATESURFACEDATA -_DDHAL_CANCREATESURFACEDATA=DDHAL_CANCREATESURFACEDATA -_DDHAL_CREATEPALETTEDATA=DDHAL_CREATEPALETTEDATA -_DDHAL_WAITFORVERTICALBLANKDATA=DDHAL_WAITFORVERTICALBLANKDATA -_DDHAL_DESTROYDRIVERDATA=DDHAL_DESTROYDRIVERDATA -_DDHAL_SETMODEDATA=DDHAL_SETMODEDATA -_DDHAL_DRVSETCOLORKEYDATA=DDHAL_DRVSETCOLORKEYDATA -_DDHAL_GETSCANLINEDATA=DDHAL_GETSCANLINEDATA -_DDHAL_SETEXCLUSIVEMODEDATA=DDHAL_SETEXCLUSIVEMODEDATA -_DDHAL_FLIPTOGDISURFACEDATA=DDHAL_FLIPTOGDISURFACEDATA -_DDHAL_CANCREATEVPORTDATA=DDHAL_CANCREATEVPORTDATA -_DDHAL_CREATEVPORTDATA=DDHAL_CREATEVPORTDATA -_DDHAL_FLIPVPORTDATA=DDHAL_FLIPVPORTDATA -_DDHAL_GETVPORTBANDWIDTHDATA=DDHAL_GETVPORTBANDWIDTHDATA -_DDHAL_GETVPORTINPUTFORMATDATA=DDHAL_GETVPORTINPUTFORMATDATA -_DDHAL_GETVPORTOUTPUTFORMATDATA=DDHAL_GETVPORTOUTPUTFORMATDATA -_DDHAL_GETVPORTFIELDDATA=DDHAL_GETVPORTFIELDDATA -_DDHAL_GETVPORTLINEDATA=DDHAL_GETVPORTLINEDATA -_DDHAL_GETVPORTCONNECTDATA=DDHAL_GETVPORTCONNECTDATA -_DDHAL_DESTROYVPORTDATA=DDHAL_DESTROYVPORTDATA -_DDHAL_GETVPORTFLIPSTATUSDATA=DDHAL_GETVPORTFLIPSTATUSDATA -_DDHAL_UPDATEVPORTDATA=DDHAL_UPDATEVPORTDATA -_DDHAL_WAITFORVPORTSYNCDATA=DDHAL_WAITFORVPORTSYNCDATA -_DDHAL_GETVPORTSIGNALDATA=DDHAL_GETVPORTSIGNALDATA -_DDHAL_VPORTCOLORDATA=DDHAL_VPORTCOLORDATA -_DDHAL_COLORCONTROLDATA=DDHAL_COLORCONTROLDATA -_DDHAL_GETDRIVERINFODATA=DDHAL_GETDRIVERINFODATA -_DDHAL_GETAVAILDRIVERMEMORYDATA=DDHAL_GETAVAILDRIVERMEMORYDATA -_DDHAL_UPDATENONLOCALHEAPDATA=DDHAL_UPDATENONLOCALHEAPDATA -_DDHAL_GETHEAPALIGNMENTDATA=DDHAL_GETHEAPALIGNMENTDATA -_DDHAL_CREATESURFACEEXDATA=DDHAL_CREATESURFACEEXDATA -_DDHAL_GETDRIVERSTATEDATA=DDHAL_GETDRIVERSTATEDATA -_DDHAL_DESTROYDDLOCALDATA=DDHAL_DESTROYDDLOCALDATA -_DDHAL_SYNCSURFACEDATA=DDHAL_SYNCSURFACEDATA -_DDHAL_SYNCVIDEOPORTDATA=DDHAL_SYNCVIDEOPORTDATA -_DDHAL_GETMOCOMPGUIDSDATA=DDHAL_GETMOCOMPGUIDSDATA -_DDHAL_GETMOCOMPFORMATSDATA=DDHAL_GETMOCOMPFORMATSDATA -_DDHAL_CREATEMOCOMPDATA=DDHAL_CREATEMOCOMPDATA -_DDMCCOMPBUFFERINFO=DDMCCOMPBUFFERINFO -_DDHAL_GETMOCOMPCOMPBUFFDATA=DDHAL_GETMOCOMPCOMPBUFFDATA -_DDHAL_GETINTERNALMOCOMPDATA=DDHAL_GETINTERNALMOCOMPDATA -_DDHAL_BEGINMOCOMPFRAMEDATA=DDHAL_BEGINMOCOMPFRAMEDATA -_DDHAL_ENDMOCOMPFRAMEDATA=DDHAL_ENDMOCOMPFRAMEDATA -_DDMCBUFFERINFO=DDMCBUFFERINFO -_DDHAL_RENDERMOCOMPDATA=DDHAL_RENDERMOCOMPDATA -_DDHAL_QUERYMOCOMPSTATUSDATA=DDHAL_QUERYMOCOMPSTATUSDATA -_DDHAL_DESTROYMOCOMPDATA=DDHAL_DESTROYMOCOMPDATA -_JAVA_TRUST=JAVA_TRUST -_TDI_TL_IO_CONTROL_ENDPOINT=TDI_TL_IO_CONTROL_ENDPOINT -_RM_SEND_WINDOW=RM_SEND_WINDOW -_RM_SENDER_STATS=RM_SENDER_STATS -_RM_RECEIVER_STATS=RM_RECEIVER_STATS -_RM_FEC_INFO=RM_FEC_INFO -_IPX_ADDRESS_DATA=IPX_ADDRESS_DATA -_IPX_NETNUM_DATA=IPX_NETNUM_DATA -_IPX_SPXCONNSTATUS_DATA=IPX_SPXCONNSTATUS_DATA -_SOCKADDR_IRDA=SOCKADDR_IRDA -_WINDOWS_IRDA_DEVICE_INFO=WINDOWS_IRDA_DEVICE_INFO -_WCE_IRDA_DEVICE_INFO=WCE_IRDA_DEVICE_INFO -_WINDOWS_DEVICELIST=WINDOWS_DEVICELIST -_WCE_DEVICELIST=WCE_DEVICELIST -_WINDOWS_IAS_SET=WINDOWS_IAS_SET -_WINDOWS_IAS_QUERY=WINDOWS_IAS_QUERY -_TCPSTATE=TCPSTATE -_REAL_TIME_NOTIFICATION_SETTING_INPUT=REAL_TIME_NOTIFICATION_SETTING_INPUT -_REAL_TIME_NOTIFICATION_SETTING_INPUT_EX=REAL_TIME_NOTIFICATION_SETTING_INPUT_EX -_REAL_TIME_NOTIFICATION_SETTING_OUTPUT=REAL_TIME_NOTIFICATION_SETTING_OUTPUT -_ASSOCIATE_NAMERES_CONTEXT_INPUT=ASSOCIATE_NAMERES_CONTEXT_INPUT -_TCP_INITIAL_RTO_PARAMETERS=TCP_INITIAL_RTO_PARAMETERS -_TCP_ICW_PARAMETERS=TCP_ICW_PARAMETERS -_TCP_ACK_FREQUENCY_PARAMETERS=TCP_ACK_FREQUENCY_PARAMETERS -_TCP_INFO_v0=TCP_INFO_v0 -_TCP_INFO_v1=TCP_INFO_v1 -_INET_PORT_RANGE=INET_PORT_RANGE -_SOCKET_USAGE_TYPE=SOCKET_USAGE_TYPE -_SOCKET_SECURITY_PROTOCOL=SOCKET_SECURITY_PROTOCOL -_SOCKET_SECURITY_SETTINGS=SOCKET_SECURITY_SETTINGS -_SOCKET_SECURITY_SETTINGS_IPSEC=SOCKET_SECURITY_SETTINGS_IPSEC -_SOCKET_PEER_TARGET_NAME=SOCKET_PEER_TARGET_NAME -_SOCKET_SECURITY_QUERY_TEMPLATE=SOCKET_SECURITY_QUERY_TEMPLATE -_SOCKET_SECURITY_QUERY_TEMPLATE_IPSEC2=SOCKET_SECURITY_QUERY_TEMPLATE_IPSEC2 -_SOCKET_SECURITY_QUERY_INFO=SOCKET_SECURITY_QUERY_INFO -_SOCKET_SECURITY_QUERY_INFO_IPSEC2=SOCKET_SECURITY_QUERY_INFO_IPSEC2 -_RSS_SCALABILITY_INFO=RSS_SCALABILITY_INFO -_MTP_COMMAND_DATA_IN=MTP_COMMAND_DATA_IN -_MTP_COMMAND_DATA_OUT=MTP_COMMAND_DATA_OUT -_DL_OUI=DL_OUI -_DL_EI48=DL_EI48 -_DL_EI64=DL_EI64 -_DL_EUI64=DL_EUI64 -_SNAP_HEADER=SNAP_HEADER -_ETHERNET_HEADER=ETHERNET_HEADER -_VLAN_TAG=VLAN_TAG -_ICMP_HEADER=ICMP_HEADER -_ICMP_MESSAGE=ICMP_MESSAGE -_IPV4_HEADER=IPV4_HEADER -_IPV4_OPTION_HEADER=IPV4_OPTION_HEADER -_IPV4_TIMESTAMP_OPTION=IPV4_TIMESTAMP_OPTION -_IPV4_ROUTING_HEADER=IPV4_ROUTING_HEADER -_ICMPV4_ROUTER_SOLICIT=ICMPV4_ROUTER_SOLICIT -_ICMPV4_ROUTER_ADVERT_HEADER=ICMPV4_ROUTER_ADVERT_HEADER -_ICMPV4_ROUTER_ADVERT_ENTRY=ICMPV4_ROUTER_ADVERT_ENTRY -_ICMPV4_TIMESTAMP_MESSAGE=ICMPV4_TIMESTAMP_MESSAGE -_ICMPV4_ADDRESS_MASK_MESSAGE=ICMPV4_ADDRESS_MASK_MESSAGE -_ARP_HEADER=ARP_HEADER -_IGMP_HEADER=IGMP_HEADER -_IGMPV3_QUERY_HEADER=IGMPV3_QUERY_HEADER -_IGMPV3_REPORT_RECORD_HEADER=IGMPV3_REPORT_RECORD_HEADER -_IPV6_HEADER=IPV6_HEADER -_IPV6_FRAGMENT_HEADER=IPV6_FRAGMENT_HEADER -_IPV6_EXTENSION_HEADER=IPV6_EXTENSION_HEADER -_IPV6_OPTION_HEADER=IPV6_OPTION_HEADER -_IPV6_OPTION_JUMBOGRAM=IPV6_OPTION_JUMBOGRAM -_IPV6_OPTION_ROUTER_ALERT=IPV6_OPTION_ROUTER_ALERT -_IPV6_ROUTING_HEADER=IPV6_ROUTING_HEADER -_IPV6_ROUTER_ADVERTISEMENT_FLAGS=IPV6_ROUTER_ADVERTISEMENT_FLAGS -_IPV6_NEIGHBOR_ADVERTISEMENT_FLAGS=IPV6_NEIGHBOR_ADVERTISEMENT_FLAGS -_MLD_HEADER=MLD_HEADER -_MLDV2_QUERY_HEADER=MLDV2_QUERY_HEADER -_MLDV2_REPORT_RECORD_HEADER=MLDV2_REPORT_RECORD_HEADER -_MLDV2_REPORT_HEADER=MLDV2_REPORT_HEADER -_TUNNEL_SUB_TYPE=TUNNEL_SUB_TYPE -_IPTLS_METADATA=IPTLS_METADATA -_NPI_MODULEID_TYPE=NPI_MODULEID_TYPE -_NPI_MODULEID=NPI_MODULEID -_SURFACEALIGNMENT=SURFACEALIGNMENT -_HEAPALIGNMENT=HEAPALIGNMENT -_DD_GETHEAPALIGNMENTDATA=DD_GETHEAPALIGNMENTDATA -_VMEML=VMEML -_VMEMR=VMEMR -_VMEMHEAP=VMEMHEAP -_DDKERNELCAPS=DDKERNELCAPS -_MEMORY_PARTITION_DEDICATED_MEMORY_ATTRIBUTE=MEMORY_PARTITION_DEDICATED_MEMORY_ATTRIBUTE -_MEMORY_PARTITION_DEDICATED_MEMORY_INFORMATION=MEMORY_PARTITION_DEDICATED_MEMORY_INFORMATION -_RTL_SYSTEM_GLOBAL_DATA_ID=RTL_SYSTEM_GLOBAL_DATA_ID -_SCM_BUS_DEDICATED_MEMORY_DEVICE_INFO=SCM_BUS_DEDICATED_MEMORY_DEVICE_INFO -_SCM_BUS_DEDICATED_MEMORY_DEVICES_INFO=SCM_BUS_DEDICATED_MEMORY_DEVICES_INFO -_SCM_BUS_DEDICATED_MEMORY_STATE=SCM_BUS_DEDICATED_MEMORY_STATE -_CSV_SET_VOLUME_ID=CSV_SET_VOLUME_ID -_CSV_QUERY_VOLUME_ID=CSV_QUERY_VOLUME_ID -tagKSCAMERA_EXTENDEDPROP_DIGITALWINDOW_SETTING=KSCAMERA_EXTENDEDPROP_DIGITALWINDOW_SETTING -tagKSCAMERA_METADATA_DIGITALWINDOW=KSCAMERA_METADATA_DIGITALWINDOW -tagKSCAMERA_EXTENDEDPROP_DIGITALWINDOW_CONFIGCAPSHEADER=KSCAMERA_EXTENDEDPROP_DIGITALWINDOW_CONFIGCAPSHEADER -tagKSCAMERA_EXTENDEDPROP_DIGITALWINDOW_CONFIGCAPS=KSCAMERA_EXTENDEDPROP_DIGITALWINDOW_CONFIGCAPS -_KSPROPERTY_NETWORKCAMERACONTROL_METADATA_INFO=KSPROPERTY_NETWORKCAMERACONTROL_METADATA_INFO -_KSPROPERTY_NETWORKCAMERACONTROL_EVENT_INFO=KSPROPERTY_NETWORKCAMERACONTROL_EVENT_INFO -tagCOMPOSITION_TARGET_ID=COMPOSITION_TARGET_ID -_HTTP_CREATE_REQUEST_QUEUE_PROPERTY_ID=HTTP_CREATE_REQUEST_QUEUE_PROPERTY_ID -_HTTP_CREATE_REQUEST_QUEUE_PROPERTY_INFO=HTTP_CREATE_REQUEST_QUEUE_PROPERTY_INFO -_HTTP_PERFORMANCE_PARAM_TYPE=HTTP_PERFORMANCE_PARAM_TYPE -_HTTP_TLS_RESTRICTIONS_PARAM=HTTP_TLS_RESTRICTIONS_PARAM -_HTTP_ERROR_HEADERS_PARAM=HTTP_ERROR_HEADERS_PARAM -_HTTP_REQUEST_PROPERTY_STREAM_ERROR=HTTP_REQUEST_PROPERTY_STREAM_ERROR -_HTTP_WSK_API_TIMINGS=HTTP_WSK_API_TIMINGS -_HTTP_QUIC_STREAM_API_TIMINGS=HTTP_QUIC_STREAM_API_TIMINGS -_HTTP_QUIC_CONNECTION_API_TIMINGS=HTTP_QUIC_CONNECTION_API_TIMINGS -_HTTP_QUIC_API_TIMINGS=HTTP_QUIC_API_TIMINGS -_HTTP_FEATURE_ID=HTTP_FEATURE_ID -_SR_RESOURCE_TYPE_ADD_REPLICATION_GROUP=SR_RESOURCE_TYPE_ADD_REPLICATION_GROUP -_SR_RESOURCE_TYPE_ADD_REPLICATION_GROUP_RESULT=SR_RESOURCE_TYPE_ADD_REPLICATION_GROUP_RESULT -_SMB_COMPRESSION_INFO=SMB_COMPRESSION_INFO -_SMB_USE_OPTION_COMPRESSION_PARAMETERS=SMB_USE_OPTION_COMPRESSION_PARAMETERS -_TIMESTAMPING_CONFIG=TIMESTAMPING_CONFIG -_PRIORITY_STATUS=PRIORITY_STATUS NDR_CCONTEXT=IntPtr _NDR_SCONTEXT=NDR_SCONTEXT RO_REGISTRATION_COOKIE=IntPtr -_WINHTTP_MATCH_CONNECTION_GUID=WINHTTP_MATCH_CONNECTION_GUID PEXCEPTION_ROUTINE=EXCEPTION_ROUTINE -_cqpage=CQPAGE -__MIDL___MIDL_itf_ads_0001_0048_0003=ADS_ACEFLAG_ENUM -__MIDL___MIDL_itf_ads_0001_0048_0002=ADS_ACETYPE_ENUM -__MIDL___MIDL_itf_ads_0000_0000_0018=ADS_AUTHENTICATION_ENUM -__MIDL___MIDL_itf_ads_0000_0000_0024=ADS_CHASE_REFERRALS_ENUM -__MIDL___MIDL_itf_ads_0000_0000_0020=ADS_DEREFENUM -__MIDL___MIDL_itf_ads_0001_0078_0003=ADS_DISPLAY_ENUM -__MIDL___MIDL_itf_ads_0001_0078_0004=ADS_ESCAPE_MODE_ENUM -__MIDL___MIDL_itf_ads_0001_0048_0004=ADS_FLAGTYPE_ENUM -__MIDL___MIDL_itf_ads_0001_0078_0002=ADS_FORMAT_ENUM -__MIDL___MIDL_itf_ads_0001_0023_0001=ADS_GROUP_TYPE_ENUM -__MIDL___MIDL_itf_ads_0001_0050_0002=ADS_NAME_INITTYPE_ENUM -__MIDL___MIDL_itf_ads_0001_0050_0001=ADS_NAME_TYPE_ENUM -__MIDL___MIDL_itf_ads_0001_0077_0001=ADS_OPTION_ENUM -__MIDL___MIDL_itf_ads_0000_0000_0026=ADS_PASSWORD_ENCODING_ENUM -__MIDL___MIDL_itf_ads_0001_0088_0001=ADS_PATHTYPE_ENUM -__MIDL___MIDL_itf_ads_0000_0000_0022=ADS_PREFERENCES_ENUM -__MIDL___MIDL_itf_ads_0000_0000_0027=ADS_PROPERTY_OPERATION_ENUM -__MIDL___MIDL_itf_ads_0001_0048_0001=ADS_RIGHTS_ENUM -__MIDL___MIDL_itf_ads_0000_0000_0021=ADS_SCOPEENUM -__MIDL___MIDL_itf_ads_0001_0048_0005=ADS_SD_CONTROL_ENUM -__MIDL___MIDL_itf_ads_0001_0088_0002=ADS_SD_FORMAT_ENUM -__MIDL___MIDL_itf_ads_0001_0048_0006=ADS_SD_REVISION_ENUM -__MIDL___MIDL_itf_ads_0000_0000_0025=ADS_SEARCHPREF_ENUM -__MIDL___MIDL_itf_ads_0001_0077_0002=ADS_SECURITY_INFO_ENUM -__MIDL___MIDL_itf_ads_0001_0078_0001=ADS_SETTYPE_ENUM -__MIDL___MIDL_itf_ads_0000_0000_0019=ADS_STATUSENUM -__MIDL___MIDL_itf_ads_0001_0017_0001=ADS_SYSTEMFLAG_ENUM -ADS_USER_FLAG=ADS_USER_FLAG_ENUM -__MIDL___MIDL_itf_ads_0000_0000_0023=ADSI_DIALECT_ENUM __MIDL___MIDL_itf_ads_0000_0000_0001=ADSTYPE -_ads_attr_def=ADS_ATTR_DEF -_ads_attr_info=ADS_ATTR_INFO -__MIDL___MIDL_itf_ads_0000_0000_0008=ADS_BACKLINK -_ads_class_def=ADS_CLASS_DEF -__MIDL___MIDL_itf_ads_0000_0000_0015=ADS_DN_WITH_BINARY -__MIDL___MIDL_itf_ads_0000_0000_0016=ADS_DN_WITH_STRING -__MIDL___MIDL_itf_ads_0000_0000_0014=ADS_EMAIL -__MIDL___MIDL_itf_ads_0000_0000_0013=ADS_FAXNUMBER -__MIDL___MIDL_itf_ads_0000_0000_0010=ADS_HOLD -__MIDL___MIDL_itf_ads_0000_0000_0011=ADS_NETADDRESS -__MIDL___MIDL_itf_ads_0000_0000_0003=ADS_NT_SECURITY_DESCRIPTOR -_ads_object_info=ADS_OBJECT_INFO -__MIDL___MIDL_itf_ads_0000_0000_0002=ADS_OCTET_STRING -__MIDL___MIDL_itf_ads_0000_0000_0005=ADS_PATH -__MIDL___MIDL_itf_ads_0000_0000_0006=ADS_POSTALADDRESS -__MIDL___MIDL_itf_ads_0000_0000_0004=ADS_PROV_SPECIFIC -__MIDL___MIDL_itf_ads_0000_0000_0012=ADS_REPLICAPOINTER -_ads_sortkey=ADS_SORTKEY -__MIDL___MIDL_itf_ads_0000_0000_0007=ADS_TIMESTAMP -__MIDL___MIDL_itf_ads_0000_0000_0009=ADS_TYPEDNAME -_ads_vlv=ADS_VLV -_adsvalue=ADSVALUE __MIDL___MIDL_itf_audioenginebaseapo_0000_0011_0001=AudioFXExtensionParams -midiopendesc_tag=MIDIOPENDESC _InlineInterlockedAdd64=InterlockedAdd64 -tag_VDS_PARTITION_STYLE=__VDS_PARTITION_STYLE -_VDS_DISK_EXTENT_TYPE=VDS_DISK_EXTENT_TYPE -_VDS_DISK_FLAG=VDS_DISK_FLAG -_VDS_DISK_OFFLINE_REASON=VDS_DISK_OFFLINE_REASON -_VDS_DISK_STATUS=VDS_DISK_STATUS -_VDS_DRIVE_LETTER_FLAG=VDS_DRIVE_LETTER_FLAG -_VDS_FILE_SYSTEM_FLAG=VDS_FILE_SYSTEM_FLAG -_VDS_FILE_SYSTEM_FORMAT_SUPPORT_FLAG=VDS_FILE_SYSTEM_FORMAT_SUPPORT_FLAG -_VDS_FILE_SYSTEM_PROP_FLAG=VDS_FILE_SYSTEM_PROP_FLAG -_VDS_FORMAT_OPTION_FLAGS=VDS_FORMAT_OPTION_FLAGS -_VDS_LUN_RESERVE_MODE=VDS_LUN_RESERVE_MODE -_VDS_PACK_FLAG=VDS_PACK_FLAG -_VDS_PACK_STATUS=VDS_PACK_STATUS -_VDS_PARTITION_FLAG=VDS_PARTITION_FLAG -_VDS_PARTITION_STYLE=VDS_PARTITION_STYLE -_VDS_QUERY_PROVIDER_FLAG=VDS_QUERY_PROVIDER_FLAG -_VDS_SAN_POLICY=VDS_SAN_POLICY -_VDS_SERVICE_FLAG=VDS_SERVICE_FLAG -_VDS_VDISK_STATE=VDS_VDISK_STATE -_VDS_VOLUME_FLAG=VDS_VOLUME_FLAG -_VDS_VOLUME_PLEX_STATUS=VDS_VOLUME_PLEX_STATUS -_VDS_VOLUME_PLEX_TYPE=VDS_VOLUME_PLEX_TYPE -_VDS_VOLUME_STATUS=VDS_VOLUME_STATUS -_VDS_VOLUME_TYPE=VDS_VOLUME_TYPE -_CHANGE_ATTRIBUTES_PARAMETERS=CHANGE_ATTRIBUTES_PARAMETERS -_CHANGE_PARTITION_TYPE_PARAMETERS=CHANGE_PARTITION_TYPE_PARAMETERS -_CREATE_PARTITION_PARAMETERS=CREATE_PARTITION_PARAMETERS -_VDS_CREATE_VDISK_PARAMETERS=VDS_CREATE_VDISK_PARAMETERS -_VDS_DISK_EXTENT=VDS_DISK_EXTENT -_VDS_DISK_FREE_EXTENT=VDS_DISK_FREE_EXTENT -_VDS_DISK_PROP=VDS_DISK_PROP -_VDS_DISK_PROP2=VDS_DISK_PROP2 -_VDS_DRIVE_LETTER_PROP=VDS_DRIVE_LETTER_PROP -_VDS_FILE_SYSTEM_FORMAT_SUPPORT_PROP=VDS_FILE_SYSTEM_FORMAT_SUPPORT_PROP -_VDS_FILE_SYSTEM_PROP=VDS_FILE_SYSTEM_PROP -_VDS_FILE_SYSTEM_TYPE_PROP=VDS_FILE_SYSTEM_TYPE_PROP -_VDS_INPUT_DISK=VDS_INPUT_DISK -_VDS_PACK_PROP=VDS_PACK_PROP -_VDS_PARTITION_INFO_GPT=VDS_PARTITION_INFO_GPT -_VDS_PARTITION_INFO_MBR=VDS_PARTITION_INFO_MBR -_VDS_PARTITION_INFORMATION_EX=VDS_PARTITION_INFORMATION_EX -_VDS_PARTITION_PROP=VDS_PARTITION_PROP -_VDS_SERVICE_PROP=VDS_SERVICE_PROP -_VDS_VDISK_PROPERTIES=VDS_VDISK_PROPERTIES -_VDS_VOLUME_PLEX_PROP=VDS_VOLUME_PLEX_PROP -_VDS_VOLUME_PROP=VDS_VOLUME_PROP -_VDS_VOLUME_PROP2=VDS_VOLUME_PROP2 _BATTERY_TAG_CHANGE=BATTERY_TAG_CHANGE _BATTERY_WMI_CYCLE_COUNT=BATTERY_WMI_CYCLE_COUNT _BATTERY_WMI_FULL_CHARGED_CAPACITY=BATTERY_WMI_FULL_CHARGED_CAPACITY @@ -9549,144 +315,18 @@ _BATTERY_WMI_STATIC_DATA=BATTERY_WMI_STATIC_DATA _BATTERY_WMI_STATUS_CHANGE=BATTERY_WMI_STATUS_CHANGE _BATTERY_WMI_STATUS=BATTERY_WMI_STATUS _BATTERY_WMI_TEMPERATURE=BATTERY_WMI_TEMPERATURE -__MIDL_IBackgroundCopyJob2_0002=BG_AUTH_CREDENTIALS_UNION -__MIDL_IBackgroundCopyJob2_0003=BG_AUTH_CREDENTIALS -__MIDL_IBackgroundCopyJob2_0001=BG_BASIC_CREDENTIALS -__MIDL___MIDL_itf_bits5_0_0000_0000_0002=BITS_FILE_PROPERTY_VALUE -__MIDL___MIDL_itf_bits5_0_0000_0000_0001=BITS_JOB_PROPERTY_VALUE _CIMFS_FILE_METADATA=CIMFS_FILE_METADATA _ACTRL_ALISTA=ACTRL_ACCESSA _ACTRL_ALISTW=ACTRL_ACCESSW -__MIDL_ICallFrame_0003=CALLFRAME_COPY -__MIDL_ICallFrame_0004=CALLFRAME_MARSHALCONTEXT -__MIDL_ICallFrame_0001=CALLFRAMEINFO -__MIDL_ICallFrame_0002=CALLFRAMEPARAMINFO -__MIDL_IOleDocument_0001=DOCMISC -__MIDL_IEventObjectChange_0001=EOC_ChangeType -_HD_HITTESTINFO=HDHITTESTINFO -_HD_ITEMA=HDITEMA -_HD_ITEMW=HDITEMW -_HD_LAYOUT=HDLAYOUT -tagNMCUSTOMDRAWINFO=NMCUSTOMDRAW -tagLVDISPINFO=NMLVDISPINFOA -tagLVDISPINFOW=NMLVDISPINFOW -tagLVKEYDOWN=NMLVKEYDOWN -tagTCKEYDOWN=NMTCKEYDOWN -tagTRBTHUMBPOSCHANGING=NMTRBTHUMBPOSCHANGING -tagTVDISPINFOA=NMTVDISPINFOA -tagTVDISPINFOEXA=NMTVDISPINFOEXA -tagTVDISPINFOEXW=NMTVDISPINFOEXW -tagTVDISPINFOW=NMTVDISPINFOW -tagTVITEMCHANGE=NMTVITEMCHANGE -tagTVKEYDOWN=NMTVKEYDOWN -_NM_UPDOWN=NMUPDOWN -_RB_HITTESTINFO=RBHITTESTINFO -_TT_HITTESTINFOA=TTHITTESTINFOA -_TT_HITTESTINFOW=TTHITTESTINFOW -tagTOOLINFOA=TTTOOLINFOA -tagTOOLINFOW=TTTOOLINFOW tagIMAGEINFO=IMAGEINFO _PROPSHEETPAGEA_V4=PROPSHEETPAGEA_V4 _PROPSHEETPAGEW_V4=PROPSHEETPAGEW_V4 -tagTextMode=TEXTMODE -_undonameid=UNDONAMEID -_bidioptions=BIDIOPTIONS _charformat2a=CHARFORMAT2A _charformat2w=CHARFORMAT2W -_charformat=CHARFORMATA -_charformatw=CHARFORMATW -_charrange=CHARRANGE -_clipboardformat=CLIPBOARDFORMAT -_compcolor=COMPCOLOR -_editstream=EDITSTREAM -_encorrecttext=ENCORRECTTEXT -_endcomposition=ENDCOMPOSITIONNOTIFY -_endropfiles=ENDROPFILES -_enlink=ENLINK -_enlowfirtf=ENLOWFIRTF -_enoleopfailed=ENOLEOPFAILED -_enprotected=ENPROTECTED -_ensaveclipboard=ENSAVECLIPBOARD -_findtext=FINDTEXTA -_findtextexa=FINDTEXTEXA -_findtextexw=FINDTEXTEXW -_findtextw=FINDTEXTW -_formatrange=FORMATRANGE -_getcontextmenuex=GETCONTEXTMENUEX -_gettextex=GETTEXTEX -_gettextlengthex=GETTEXTLENGTHEX -tagHyphenateInfo=HYPHENATEINFO -_imecomptext=IMECOMPTEXT -_msgfilter=MSGFILTER _nmhdr=NMHDR -_objectpositions=OBJECTPOSITIONS -_paraformat=PARAFORMAT _paraformat2=PARAFORMAT2 -_punctuation=PUNCTUATION -_repastespecial=REPASTESPECIAL -_reqresize=REQRESIZE -_selchange=SELCHANGE -_settextex=SETTEXTEX -_tableCellParms=TABLECELLPARMS -_tableRowParms=TABLEROWPARMS -_textrange=TEXTRANGEA -_textrangew=TEXTRANGEW -_reobject=REOBJECT -__MIDL___MIDL_itf_tom_0000_0000_0003=MANCODE -__MIDL___MIDL_itf_tom_0000_0000_0002=OBJECTTYPE -__MIDL___MIDL_itf_tom_0000_0000_0001=tomConstants -__MIDL___MIDL_itf_devicetopology_0000_0000_0013=ConnectorType -__MIDL___MIDL_itf_devicetopology_0000_0000_0011=DataFlow __MIDL___MIDL_itf_devicetopology_0000_0000_0010=KSJACK_SINK_CONNECTIONTYPE -__MIDL___MIDL_itf_devicetopology_0000_0000_0012=PartType __MIDL___MIDL_itf_devicetopology_0000_0000_0009=KSJACK_DESCRIPTION -__MIDL___MIDL_itf_mmdeviceapi_0000_0000_0001=EDataFlow -__MIDL___MIDL_itf_mmdeviceapi_0000_0000_0003=EndpointFormFactor -__MIDL___MIDL_itf_mmdeviceapi_0000_0000_0002=ERole -__MIDL___MIDL_itf_mmdeviceapi_0000_0008_0001=AudioExtensionParams -__MIDL___MIDL_itf_autosvcs_0000_0034_0001=TRACKING_COLL_TYPE -__MIDL___MIDL_itf_autosvcs_0000_0013_0001=COMSVCSEVENTINFO -__MIDL___MIDL_itf_eventsys_0000_0009_0001=COMEVENTSYSCHANGEINFO -BusNumber_Des_s=BUSNUMBER_DES -BusNumber_Range_s=BUSNUMBER_RANGE -BusNumber_Resource_s=BUSNUMBER_RESOURCE -CS_Des_s=CS_DES -CS_Resource_s=CS_RESOURCE -DMA_Des_s=DMA_DES -DMA_Range_s=DMA_RANGE -DMA_Resource_s=DMA_RESOURCE -IO_Des_s=IO_DES -IO_Range_s=IO_RANGE -IO_Resource_s=IO_RESOURCE -IRQ_Des_32_s=IRQ_DES_32 -IRQ_Des_64_s=IRQ_DES_64 -IRQ_Range_s=IRQ_RANGE -IRQ_Resource_32_s=IRQ_RESOURCE_32 -IRQ_Resource_64_s=IRQ_RESOURCE_64 -Mem_Des_s=MEM_DES -Mem_Range_s=MEM_RANGE -Mem_Resource_s=MEM_RESOURCE -MfCard_Des_s=MFCARD_DES -MfCard_Resource_s=MFCARD_RESOURCE -PcCard_Des_s=PCCARD_DES -PcCard_Resource_s=PCCARD_RESOURCE -_DHCPCAPI_PARAMS_ARARAY=DHCPCAPI_PARAMS_ARRAY -_DHCP_CLIENT_SEARCH_TYPE_V6=DHCP_SEARCH_INFO_TYPE_V6 -_DHCP_CLIENT_SEARCH_TYPE=DHCP_SEARCH_INFO_TYPE -_DHCP_SUBNET_ELEMENT_TYPE_V5=DHCP_SUBNET_ELEMENT_TYPE -_DHCP_FILTER_ADD_INFOV4=DHCP_FILTER_ADD_INFO -_DHCP_CLIENT_SEARCH_INFO_V6=DHCP_SEARCH_INFO_V6 -_DHCP_CLIENT_SEARCH_INFO=DHCP_SEARCH_INFO -D3D11_SHADER_TRACKING_OPTION=D3D11_SHADER_TRACKING_OPTIONS -_avimetaindex=AVIMETAINDEX -_avioldindex=AVIOLDINDEX -_avistdindex=AVISTDINDEX -_avisuperindex=AVISUPERINDEX -tagAdapter=Adapter -tagAdapters=Adapters -tagDisplayMode=DisplayMode -tagDisplayModes=DisplayModes -tagSources=Sources _DDADDVPCAPTUREBUFF=DDADDVPCAPTUREBUFF _DDCAPBUFFINFO=DDCAPBUFFINFO _DDCLOSEHANDLE=DDCLOSEHANDLE @@ -9716,340 +356,8 @@ _DDREGISTERCALLBACK=DDREGISTERCALLBACK _DDSETFIELDNUM=DDSETFIELDNUM _DDSETSKIPFIELD=DDSETSKIPFIELD _DDSETSURFACETATE=DDSETSURFACESTATE -_DDBOBNEXTFIELDINFO=DDBOBNEXTFIELDINFO -_DDENABLEIRQINFO=DDENABLEIRQINFO -_DDFLIPOVERLAYINFO=DDFLIPOVERLAYINFO -_DDFLIPVIDEOPORTINFO=DDFLIPVIDEOPORTINFO -_DDGETCURRENTAUTOFLIPININFO=DDGETCURRENTAUTOFLIPININFO -_DDGETCURRENTAUTOFLIPOUTINFO=DDGETCURRENTAUTOFLIPOUTINFO -_DDGETIRQINFO=DDGETIRQINFO -_DDGETPOLARITYININFO=DDGETPOLARITYININFO -_DDGETPOLARITYOUTINFO=DDGETPOLARITYOUTINFO -_DDGETPREVIOUSAUTOFLIPININFO=DDGETPREVIOUSAUTOFLIPININFO -_DDGETPREVIOUSAUTOFLIPOUTINFO=DDGETPREVIOUSAUTOFLIPOUTINFO -_DDGETTRANSFERSTATUSOUTINFO=DDGETTRANSFERSTATUSOUTINFO -_DDLOCKININFO=DDLOCKININFO -_DDLOCKOUTINFO=DDLOCKOUTINFO -_DDSETSTATEININFO=DDSETSTATEININFO -_DDSETSTATEOUTINFO=DDSETSTATEOUTINFO -_DDSKIPNEXTFIELDINFO=DDSKIPNEXTFIELDINFO -_DDSURFACEDATA=DDSURFACEDATA -_DDTRANSFERININFO=DDTRANSFERININFO -_DDTRANSFEROUTINFO=DDTRANSFEROUTINFO -_DX_IRQDATA=DX_IRQDATA -_DXAPI_INTERFACE=DXAPI_INTERFACE -tagOFN_NT4A=OPENFILENAME_NT4A -tagOFN_NT4W=OPENFILENAME_NT4W -tagOFNA=OPENFILENAMEA -tagOFNW=OPENFILENAMEW -tagPSDA=PAGESETUPDLGA -tagPSDW=PAGESETUPDLGW -tagPDA=PRINTDLGA -tagPDEXA=PRINTDLGEXA -tagPDEXW=PRINTDLGEXW -tagPDW=PRINTDLGW -_DnsSection=DNS_SECTION -_DnsAddrArray=DNS_ADDR_ARRAY -_DnsAddr=DNS_ADDR -_DnsRecordFlags=DNS_RECORD_FLAGS -_DnsRecordA=DNS_RECORDA -_DnsRecordW=DNS_RECORDW -_DnsRRSet=DNS_RRSET -_tag_AMVABeginFrameInfo=AMVABeginFrameInfo -_tag_AMVABUFFERINFO=AMVABUFFERINFO -_tag_AMVACompBufferInfo=AMVACompBufferInfo -_tag_AMVAEndFrameInfo=AMVAEndFrameInfo -_tag_AMVAInternalMemInfo=AMVAInternalMemInfo -_tag_AMVAUncompBufferInfo=AMVAUncompBufferInfo -_tag_AMVAUncompDataInfo=AMVAUncompDataInfo -tagAnalogVideoInfo=ANALOGVIDEOINFO -tag_TRUECOLORINFO=TRUECOLORINFO -_tagSND_DEVICE_ERROR=SNDDEV_ERR -_avimainheader=AVIMAINHEADER -_avistdindex_entry=AVISTDINDEX_ENTRY -_avistreamheader=AVISTREAMHEADER -_DMOMediaType=DMO_MEDIA_TYPE -_MP_Type=MP_TYPE -__MIDL___MIDL_itf_mmstream_0000_0000_0002=STREAM_STATE -__MIDL___MIDL_itf_mmstream_0000_0000_0001=STREAM_TYPE -AM_SEEKING_SeekingCapabilities=AM_SEEKING_SEEKING_CAPABILITIES -__MIDL___MIDL_itf_strmif_0000_0132_0002=DVD_CMD_FLAGS -__MIDL___MIDL_itf_strmif_0000_0132_0003=DVD_OPTION_FLAG -__MIDL___MIDL_itf_strmif_0000_0132_0004=DVD_RELATIVE_BUTTON -_FilterState=FILTER_STATE -_PinDirection=PIN_DIRECTION -__MIDL___MIDL_itf_strmif_0000_0132_0001=VALID_UOP_FLAG -_AllocatorProperties=ALLOCATOR_PROPERTIES -__MIDL___MIDL_itf_strmif_0000_0138_0001=AM_DVD_RENDERSTATUS -_AMMediaType=AM_MEDIA_TYPE -tagDVD_TitleMainAttributes=DVD_TitleAttributes -_FilterInfo=FILTER_INFO -_PinInfo=PIN_INFO -_timecode=TIMECODE tagTIMECODE=TIMECODE __MIDL___MIDL_itf_vidcap_0000_0000_0001=KSTOPOLOGY_CONNECTION -__MIDL___MIDL_itf_vmr9_0000_0006_0001=VMR9AlphaBitmapFlags -__MIDL___MIDL_itf_vmr9_0000_0004_0001=VMR9AspectRatioMode -__MIDL___MIDL_itf_vmr9_0000_0013_0001=VMR9DeinterlacePrefs -__MIDL___MIDL_itf_vmr9_0000_0013_0002=VMR9DeinterlaceTech -__MIDL___MIDL_itf_vmr9_0000_0005_0001=VMR9MixerPrefs -__MIDL___MIDL_itf_vmr9_0000_0010_0001=VMR9Mode -__MIDL___MIDL_itf_vmr9_0000_0000_0002=VMR9PresentationFlags -__MIDL___MIDL_itf_vmr9_0000_0005_0002=VMR9ProcAmpControlFlags -__MIDL___MIDL_itf_vmr9_0000_0008_0001=VMR9RenderPrefs -__MIDL___MIDL_itf_vmr9_0000_0001_0001=VMR9SurfaceAllocationFlags -_RAS_AUTH_ATTRIBUTE_TYPE_=RAS_AUTH_ATTRIBUTE_TYPE -tagEapPeerMethodOuput=EapPeerMethodOutput -DiskQuotaUserInformation=DISKQUOTA_USER_INFORMATION -_CERTIFICATE_BLOB=EFS_CERTIFICATE_BLOB -__MIDL___MIDL_itf_fwpmtypes_0000_0000_0001=DL_ADDRESS_TYPE -FWPM_APPC_NETWORK_CAPABILITY_TYPE_=FWPM_APPC_NETWORK_CAPABILITY_TYPE -FWPM_CHANGE_TYPE_=FWPM_CHANGE_TYPE -FWPM_CONNECTION_EVENT_TYPE_=FWPM_CONNECTION_EVENT_TYPE -FWPM_ENGINE_OPTION_=FWPM_ENGINE_OPTION -FWPM_FIELD_TYPE_=FWPM_FIELD_TYPE -FWPM_NET_EVENT_TYPE_=FWPM_NET_EVENT_TYPE -FWPM_PROVIDER_CONTEXT_TYPE_=FWPM_PROVIDER_CONTEXT_TYPE -FWPM_SERVICE_STATE_=FWPM_SERVICE_STATE -FWPM_SYSTEM_PORT_TYPE_=FWPM_SYSTEM_PORT_TYPE -FWPM_VSWITCH_EVENT_TYPE_=FWPM_VSWITCH_EVENT_TYPE -FWPM_ACTION0_=FWPM_ACTION0 -FWPM_CALLOUT_CHANGE0_=FWPM_CALLOUT_CHANGE0 -FWPM_CALLOUT_ENUM_TEMPLATE0_=FWPM_CALLOUT_ENUM_TEMPLATE0 -FWPM_CALLOUT_SUBSCRIPTION0_=FWPM_CALLOUT_SUBSCRIPTION0 -FWPM_CALLOUT0_=FWPM_CALLOUT0 -FWPM_CLASSIFY_OPTION0_=FWPM_CLASSIFY_OPTION0 -FWPM_CLASSIFY_OPTIONS0_=FWPM_CLASSIFY_OPTIONS0 -FWPM_CONNECTION_ENUM_TEMPLATE0_=FWPM_CONNECTION_ENUM_TEMPLATE0 -FWPM_CONNECTION_SUBSCRIPTION0_=FWPM_CONNECTION_SUBSCRIPTION0 -FWPM_CONNECTION0_=FWPM_CONNECTION0 -FWPM_FIELD0_=FWPM_FIELD0 -FWPM_FILTER_CHANGE0_=FWPM_FILTER_CHANGE0 -FWPM_FILTER_CONDITION0_=FWPM_FILTER_CONDITION0 -FWPM_FILTER_ENUM_TEMPLATE0_=FWPM_FILTER_ENUM_TEMPLATE0 -FWPM_FILTER_SUBSCRIPTION0_=FWPM_FILTER_SUBSCRIPTION0 -FWPM_FILTER0_=FWPM_FILTER0 -FWPM_LAYER_ENUM_TEMPLATE0_=FWPM_LAYER_ENUM_TEMPLATE0 -FWPM_LAYER_STATISTICS0_=FWPM_LAYER_STATISTICS0 -FWPM_LAYER0_=FWPM_LAYER0 -FWPM_NET_EVENT_CAPABILITY_ALLOW0_=FWPM_NET_EVENT_CAPABILITY_ALLOW0 -FWPM_NET_EVENT_CAPABILITY_DROP0_=FWPM_NET_EVENT_CAPABILITY_DROP0 -FWPM_NET_EVENT_CLASSIFY_DROP_MAC0_=FWPM_NET_EVENT_CLASSIFY_DROP_MAC0 -FWPM_NET_EVENT_CLASSIFY_DROP0_=FWPM_NET_EVENT_CLASSIFY_DROP0 -FWPM_NET_EVENT_CLASSIFY_DROP1_=FWPM_NET_EVENT_CLASSIFY_DROP1 -FWPM_NET_EVENT_CLASSIFY_DROP2_=FWPM_NET_EVENT_CLASSIFY_DROP2 -FWPM_NET_EVENT_ENUM_TEMPLATE0_=FWPM_NET_EVENT_ENUM_TEMPLATE0 -FWPM_NET_EVENT_HEADER0_=FWPM_NET_EVENT_HEADER0 -FWPM_NET_EVENT_HEADER1_=FWPM_NET_EVENT_HEADER1 -FWPM_NET_EVENT_HEADER2_=FWPM_NET_EVENT_HEADER2 -FWPM_NET_EVENT_HEADER3_=FWPM_NET_EVENT_HEADER3 -FWPM_NET_EVENT_IKEEXT_EM_FAILURE0_=FWPM_NET_EVENT_IKEEXT_EM_FAILURE0 -FWPM_NET_EVENT_IKEEXT_EM_FAILURE1_=FWPM_NET_EVENT_IKEEXT_EM_FAILURE1 -FWPM_NET_EVENT_IKEEXT_MM_FAILURE0_=FWPM_NET_EVENT_IKEEXT_MM_FAILURE0 -FWPM_NET_EVENT_IKEEXT_MM_FAILURE1_=FWPM_NET_EVENT_IKEEXT_MM_FAILURE1 -FWPM_NET_EVENT_IKEEXT_QM_FAILURE0_=FWPM_NET_EVENT_IKEEXT_QM_FAILURE0 -FWPM_NET_EVENT_IPSEC_DOSP_DROP0_=FWPM_NET_EVENT_IPSEC_DOSP_DROP0 -FWPM_NET_EVENT_IPSEC_KERNEL_DROP0_=FWPM_NET_EVENT_IPSEC_KERNEL_DROP0 -FWPM_NET_EVENT_SUBSCRIPTION0_=FWPM_NET_EVENT_SUBSCRIPTION0 -FWPM_NET_EVENT0_=FWPM_NET_EVENT0 -FWPM_NET_EVENT1_=FWPM_NET_EVENT1 -FWPM_NET_EVENT2_=FWPM_NET_EVENT2 -FWPM_NET_EVENT3_=FWPM_NET_EVENT3 -FWPM_PROVIDER_CHANGE0_=FWPM_PROVIDER_CHANGE0 -FWPM_PROVIDER_CONTEXT_CHANGE0_=FWPM_PROVIDER_CONTEXT_CHANGE0 -FWPM_PROVIDER_CONTEXT_ENUM_TEMPLATE0_=FWPM_PROVIDER_CONTEXT_ENUM_TEMPLATE0 -FWPM_PROVIDER_CONTEXT_SUBSCRIPTION0_=FWPM_PROVIDER_CONTEXT_SUBSCRIPTION0 -FWPM_PROVIDER_CONTEXT0_=FWPM_PROVIDER_CONTEXT0 -FWPM_PROVIDER_CONTEXT1_=FWPM_PROVIDER_CONTEXT1 -FWPM_PROVIDER_CONTEXT2_=FWPM_PROVIDER_CONTEXT2 -FWPM_PROVIDER_ENUM_TEMPLATE0_=FWPM_PROVIDER_ENUM_TEMPLATE0 -FWPM_PROVIDER_SUBSCRIPTION0_=FWPM_PROVIDER_SUBSCRIPTION0 -FWPM_PROVIDER0_=FWPM_PROVIDER0 -FWPM_SESSION_ENUM_TEMPLATE0_=FWPM_SESSION_ENUM_TEMPLATE0 -FWPM_SESSION0_=FWPM_SESSION0 -FWPM_STATISTICS0_=FWPM_STATISTICS0 -FWPM_SUBLAYER_CHANGE0_=FWPM_SUBLAYER_CHANGE0 -FWPM_SUBLAYER_ENUM_TEMPLATE0_=FWPM_SUBLAYER_ENUM_TEMPLATE0 -FWPM_SUBLAYER_SUBSCRIPTION0_=FWPM_SUBLAYER_SUBSCRIPTION0 -FWPM_SUBLAYER0_=FWPM_SUBLAYER0 -FWPM_SYSTEM_PORTS_BY_TYPE0_=FWPM_SYSTEM_PORTS_BY_TYPE0 -FWPM_SYSTEM_PORTS0_=FWPM_SYSTEM_PORTS0 -FWPM_VSWITCH_EVENT_SUBSCRIPTION0_=FWPM_VSWITCH_EVENT_SUBSCRIPTION0 -FWPM_VSWITCH_EVENT0_=FWPM_VSWITCH_EVENT0 -FWP_NE_FAMILY_=FWP_AF -FWP_CLASSIFY_OPTION_TYPE_=FWP_CLASSIFY_OPTION_TYPE -FWP_DATA_TYPE_=FWP_DATA_TYPE -FWP_DIRECTION_=FWP_DIRECTION -FWP_ETHER_ENCAP_METHOD_=FWP_ETHER_ENCAP_METHOD -FWP_FILTER_ENUM_TYPE_=FWP_FILTER_ENUM_TYPE -FWP_IP_VERSION_=FWP_IP_VERSION -FWP_MATCH_TYPE_=FWP_MATCH_TYPE -FWP_VSWITCH_NETWORK_TYPE_=FWP_VSWITCH_NETWORK_TYPE -FWP_BYTE_ARRAY16_=FWP_BYTE_ARRAY16 -FWP_BYTE_ARRAY6_=FWP_BYTE_ARRAY6 -FWP_BYTE_BLOB_=FWP_BYTE_BLOB -FWP_CONDITION_VALUE0_=FWP_CONDITION_VALUE0 -FWP_RANGE0_=FWP_RANGE0 -FWP_TOKEN_INFORMATION_=FWP_TOKEN_INFORMATION -FWP_V4_ADDR_AND_MASK_=FWP_V4_ADDR_AND_MASK -FWP_V6_ADDR_AND_MASK_=FWP_V6_ADDR_AND_MASK -FWP_VALUE0_=FWP_VALUE0 -FWPM_DISPLAY_DATA0_=FWPM_DISPLAY_DATA0 -IPSEC_VIRTUAL_IF_TUNNEL_INFO0_=IPSEC_VIRTUAL_IF_TUNNEL_INFO0 -IKEEXT_AUTHENTICATION_IMPERSONATION_TYPE_=IKEEXT_AUTHENTICATION_IMPERSONATION_TYPE -IKEEXT_AUTHENTICATION_METHOD_TYPE_=IKEEXT_AUTHENTICATION_METHOD_TYPE -IKEEXT_CERT_CONFIG_TYPE_=IKEEXT_CERT_CONFIG_TYPE -IKEEXT_CERT_CRITERIA_NAME_TYPE_=IKEEXT_CERT_CRITERIA_NAME_TYPE -IKEEXT_CIPHER_TYPE_=IKEEXT_CIPHER_TYPE -IKEEXT_DH_GROUP_=IKEEXT_DH_GROUP -IKEEXT_EM_SA_STATE_=IKEEXT_EM_SA_STATE -IKEEXT_INTEGRITY_TYPE_=IKEEXT_INTEGRITY_TYPE -IKEEXT_KEY_MODULE_TYPE_=IKEEXT_KEY_MODULE_TYPE -IKEEXT_MM_SA_STATE_=IKEEXT_MM_SA_STATE -IKEEXT_QM_SA_STATE_=IKEEXT_QM_SA_STATE -IKEEXT_SA_ROLE_=IKEEXT_SA_ROLE -IKEEXT_AUTHENTICATION_METHOD0_=IKEEXT_AUTHENTICATION_METHOD0 -IKEEXT_AUTHENTICATION_METHOD1_=IKEEXT_AUTHENTICATION_METHOD1 -IKEEXT_AUTHENTICATION_METHOD2_=IKEEXT_AUTHENTICATION_METHOD2 -IKEEXT_CERT_EKUS0_=IKEEXT_CERT_EKUS0 -IKEEXT_CERT_NAME0_=IKEEXT_CERT_NAME0 -IKEEXT_CERT_ROOT_CONFIG0_=IKEEXT_CERT_ROOT_CONFIG0 -IKEEXT_CERTIFICATE_AUTHENTICATION0_=IKEEXT_CERTIFICATE_AUTHENTICATION0 -IKEEXT_CERTIFICATE_AUTHENTICATION1_=IKEEXT_CERTIFICATE_AUTHENTICATION1 -IKEEXT_CERTIFICATE_AUTHENTICATION2_=IKEEXT_CERTIFICATE_AUTHENTICATION2 -IKEEXT_CERTIFICATE_CREDENTIAL0_=IKEEXT_CERTIFICATE_CREDENTIAL0 -IKEEXT_CERTIFICATE_CREDENTIAL1_=IKEEXT_CERTIFICATE_CREDENTIAL1 -IKEEXT_CERTIFICATE_CRITERIA0_=IKEEXT_CERTIFICATE_CRITERIA0 -IKEEXT_CIPHER_ALGORITHM0_=IKEEXT_CIPHER_ALGORITHM0 -IKEEXT_COMMON_STATISTICS0_=IKEEXT_COMMON_STATISTICS0 -IKEEXT_COMMON_STATISTICS1_=IKEEXT_COMMON_STATISTICS1 -IKEEXT_COOKIE_PAIR0_=IKEEXT_COOKIE_PAIR0 -IKEEXT_CREDENTIAL_PAIR0_=IKEEXT_CREDENTIAL_PAIR0 -IKEEXT_CREDENTIAL_PAIR1_=IKEEXT_CREDENTIAL_PAIR1 -IKEEXT_CREDENTIAL_PAIR2_=IKEEXT_CREDENTIAL_PAIR2 -IKEEXT_CREDENTIAL0_=IKEEXT_CREDENTIAL0 -IKEEXT_CREDENTIAL1_=IKEEXT_CREDENTIAL1 -IKEEXT_CREDENTIAL2_=IKEEXT_CREDENTIAL2 -IKEEXT_CREDENTIALS0_=IKEEXT_CREDENTIALS0 -IKEEXT_CREDENTIALS1_=IKEEXT_CREDENTIALS1 -IKEEXT_CREDENTIALS2_=IKEEXT_CREDENTIALS2 -IKEEXT_EAP_AUTHENTICATION0__=IKEEXT_EAP_AUTHENTICATION0 -IKEEXT_EM_POLICY0_=IKEEXT_EM_POLICY0 -IKEEXT_EM_POLICY1_=IKEEXT_EM_POLICY1 -IKEEXT_EM_POLICY2_=IKEEXT_EM_POLICY2 -IKEEXT_INTEGRITY_ALGORITHM0_=IKEEXT_INTEGRITY_ALGORITHM0 -IKEEXT_IP_VERSION_SPECIFIC_COMMON_STATISTICS0_=IKEEXT_IP_VERSION_SPECIFIC_COMMON_STATISTICS0 -IKEEXT_IP_VERSION_SPECIFIC_COMMON_STATISTICS1_=IKEEXT_IP_VERSION_SPECIFIC_COMMON_STATISTICS1 -IKEEXT_IP_VERSION_SPECIFIC_KEYMODULE_STATISTICS0_=IKEEXT_IP_VERSION_SPECIFIC_KEYMODULE_STATISTICS0 -IKEEXT_IP_VERSION_SPECIFIC_KEYMODULE_STATISTICS1_=IKEEXT_IP_VERSION_SPECIFIC_KEYMODULE_STATISTICS1 -IKEEXT_IPV6_CGA_AUTHENTICATION0_=IKEEXT_IPV6_CGA_AUTHENTICATION0 -IKEEXT_KERBEROS_AUTHENTICATION0__=IKEEXT_KERBEROS_AUTHENTICATION0 -IKEEXT_KERBEROS_AUTHENTICATION1__=IKEEXT_KERBEROS_AUTHENTICATION1 -IKEEXT_KEYMODULE_STATISTICS0_=IKEEXT_KEYMODULE_STATISTICS0 -IKEEXT_KEYMODULE_STATISTICS1_=IKEEXT_KEYMODULE_STATISTICS1 -IKEEXT_NAME_CREDENTIAL0_=IKEEXT_NAME_CREDENTIAL0 -IKEEXT_NTLM_V2_AUTHENTICATION0__=IKEEXT_NTLM_V2_AUTHENTICATION0 -IKEEXT_POLICY0_=IKEEXT_POLICY0 -IKEEXT_POLICY1_=IKEEXT_POLICY1 -IKEEXT_POLICY2_=IKEEXT_POLICY2 -IKEEXT_PRESHARED_KEY_AUTHENTICATION0__=IKEEXT_PRESHARED_KEY_AUTHENTICATION0 -IKEEXT_PRESHARED_KEY_AUTHENTICATION1__=IKEEXT_PRESHARED_KEY_AUTHENTICATION1 -IKEEXT_PROPOSAL0_=IKEEXT_PROPOSAL0 -IKEEXT_RESERVED_AUTHENTICATION0__=IKEEXT_RESERVED_AUTHENTICATION0 -IKEEXT_SA_DETAILS0_=IKEEXT_SA_DETAILS0 -IKEEXT_SA_DETAILS1_=IKEEXT_SA_DETAILS1 -IKEEXT_SA_DETAILS2_=IKEEXT_SA_DETAILS2 -IKEEXT_SA_ENUM_TEMPLATE0_=IKEEXT_SA_ENUM_TEMPLATE0 -IKEEXT_STATISTICS0_=IKEEXT_STATISTICS0 -IKEEXT_STATISTICS1_=IKEEXT_STATISTICS1 -IKEEXT_TRAFFIC0_=IKEEXT_TRAFFIC0 -IPSEC_AUTH_TYPE_=IPSEC_AUTH_TYPE -IPSEC_CIPHER_TYPE_=IPSEC_CIPHER_TYPE -IPSEC_FAILURE_POINT_=IPSEC_FAILURE_POINT -IPSEC_PFS_GROUP_=IPSEC_PFS_GROUP -IPSEC_SA_CONTEXT_EVENT_TYPE0_=IPSEC_SA_CONTEXT_EVENT_TYPE0 -IPSEC_TOKEN_MODE_=IPSEC_TOKEN_MODE -IPSEC_TOKEN_PRINCIPAL_=IPSEC_TOKEN_PRINCIPAL -IPSEC_TOKEN_TYPE_=IPSEC_TOKEN_TYPE -IPSEC_TRAFFIC_TYPE_=IPSEC_TRAFFIC_TYPE -IPSEC_TRANSFORM_TYPE_=IPSEC_TRANSFORM_TYPE -IPSEC_ADDRESS_INFO0_=IPSEC_ADDRESS_INFO0 -IPSEC_AGGREGATE_DROP_PACKET_STATISTICS0_=IPSEC_AGGREGATE_DROP_PACKET_STATISTICS0 -IPSEC_AGGREGATE_DROP_PACKET_STATISTICS1_=IPSEC_AGGREGATE_DROP_PACKET_STATISTICS1 -IPSEC_AGGREGATE_SA_STATISTICS0_=IPSEC_AGGREGATE_SA_STATISTICS0 -IPSEC_AH_DROP_PACKET_STATISTICS0_=IPSEC_AH_DROP_PACKET_STATISTICS0 -IPSEC_AUTH_AND_CIPHER_TRANSFORM0_=IPSEC_AUTH_AND_CIPHER_TRANSFORM0 -IPSEC_AUTH_TRANSFORM_ID0_=IPSEC_AUTH_TRANSFORM_ID0 -IPSEC_AUTH_TRANSFORM0_=IPSEC_AUTH_TRANSFORM0 -IPSEC_CIPHER_TRANSFORM_ID0_=IPSEC_CIPHER_TRANSFORM_ID0 -IPSEC_CIPHER_TRANSFORM0_=IPSEC_CIPHER_TRANSFORM0 -IPSEC_DOSP_OPTIONS0_=IPSEC_DOSP_OPTIONS0 -IPSEC_DOSP_STATE_ENUM_TEMPLATE0_=IPSEC_DOSP_STATE_ENUM_TEMPLATE0 -IPSEC_DOSP_STATE0_=IPSEC_DOSP_STATE0 -IPSEC_DOSP_STATISTICS0_=IPSEC_DOSP_STATISTICS0 -IPSEC_ESP_DROP_PACKET_STATISTICS0_=IPSEC_ESP_DROP_PACKET_STATISTICS0 -IPSEC_GETSPI0_=IPSEC_GETSPI0 -IPSEC_GETSPI1_=IPSEC_GETSPI1 -IPSEC_ID0_=IPSEC_ID0 -IPSEC_KEYING_POLICY0_=IPSEC_KEYING_POLICY0 -IPSEC_KEYING_POLICY1_=IPSEC_KEYING_POLICY1 -IPSEC_KEYMODULE_STATE0_=IPSEC_KEYMODULE_STATE0 -IPSEC_PROPOSAL0_=IPSEC_PROPOSAL0 -IPSEC_SA_AUTH_AND_CIPHER_INFORMATION0_=IPSEC_SA_AUTH_AND_CIPHER_INFORMATION0 -IPSEC_SA_AUTH_INFORMATION0_=IPSEC_SA_AUTH_INFORMATION0 -IPSEC_SA_BUNDLE0_=IPSEC_SA_BUNDLE0 -IPSEC_SA_BUNDLE1_=IPSEC_SA_BUNDLE1 -IPSEC_SA_CIPHER_INFORMATION0_=IPSEC_SA_CIPHER_INFORMATION0 -IPSEC_SA_CONTEXT_CHANGE0_=IPSEC_SA_CONTEXT_CHANGE0 -IPSEC_SA_CONTEXT_ENUM_TEMPLATE0_=IPSEC_SA_CONTEXT_ENUM_TEMPLATE0 -IPSEC_SA_CONTEXT_SUBSCRIPTION0_=IPSEC_SA_CONTEXT_SUBSCRIPTION0 -IPSEC_SA_CONTEXT0_=IPSEC_SA_CONTEXT0 -IPSEC_SA_CONTEXT1_=IPSEC_SA_CONTEXT1 -IPSEC_SA_DETAILS0_=IPSEC_SA_DETAILS0 -IPSEC_SA_DETAILS1_=IPSEC_SA_DETAILS1 -IPSEC_SA_ENUM_TEMPLATE0_=IPSEC_SA_ENUM_TEMPLATE0 -IPSEC_SA_IDLE_TIMEOUT0_=IPSEC_SA_IDLE_TIMEOUT0 -IPSEC_SA_LIFETIME0_=IPSEC_SA_LIFETIME0 -IPSEC_SA_TRANSFORM0_=IPSEC_SA_TRANSFORM0 -IPSEC_SA0_=IPSEC_SA0 -IPSEC_STATISTICS0_=IPSEC_STATISTICS0 -IPSEC_STATISTICS1_=IPSEC_STATISTICS1 -IPSEC_TOKEN0_=IPSEC_TOKEN0 -IPSEC_TRAFFIC_STATISTICS0_=IPSEC_TRAFFIC_STATISTICS0 -IPSEC_TRAFFIC_STATISTICS1_=IPSEC_TRAFFIC_STATISTICS1 -IPSEC_TRAFFIC0_=IPSEC_TRAFFIC0 -IPSEC_TRAFFIC1_=IPSEC_TRAFFIC1 -IPSEC_TRANSPORT_POLICY0_=IPSEC_TRANSPORT_POLICY0 -IPSEC_TRANSPORT_POLICY1_=IPSEC_TRANSPORT_POLICY1 -IPSEC_TRANSPORT_POLICY2_=IPSEC_TRANSPORT_POLICY2 -IPSEC_TUNNEL_ENDPOINT0_=IPSEC_TUNNEL_ENDPOINT0 -IPSEC_TUNNEL_ENDPOINTS0_=IPSEC_TUNNEL_ENDPOINTS0 -IPSEC_TUNNEL_ENDPOINTS1_=IPSEC_TUNNEL_ENDPOINTS1 -IPSEC_TUNNEL_ENDPOINTS2_=IPSEC_TUNNEL_ENDPOINTS2 -IPSEC_TUNNEL_POLICY0_=IPSEC_TUNNEL_POLICY0 -IPSEC_TUNNEL_POLICY1_=IPSEC_TUNNEL_POLICY1 -IPSEC_TUNNEL_POLICY2_=IPSEC_TUNNEL_POLICY2 -IPSEC_V4_UDP_ENCAPSULATION0_=IPSEC_V4_UDP_ENCAPSULATION0 -__MIDL___MIDL_itf_gpmgmt_0000_0030_0001=GPMBackupType -__MIDL___MIDL_itf_gpmgmt_0000_0000_0002=GPMPermissionType -__MIDL___MIDL_itf_gpmgmt_0000_0000_0008=GPMReportingOptions -__MIDL___MIDL_itf_gpmgmt_0000_0000_0003=GPMSearchProperty -__MIDL___MIDL_itf_gpmgmt_0000_0030_0002=GPMStarterGPOType -joyreghwvalues_tag=JOYREGHWVALUES -_VM_GENCOUNTER=VM_GENCOUNTER -NET_FW_ACTION_=NET_FW_ACTION -NET_FW_AUTHENTICATE_TYPE_=NET_FW_AUTHENTICATE_TYPE -NET_FW_EDGE_TRAVERSAL_TYPE_=NET_FW_EDGE_TRAVERSAL_TYPE -NET_FW_IP_PROTOCOL_=NET_FW_IP_PROTOCOL -NET_FW_IP_VERSION_=NET_FW_IP_VERSION -NET_FW_MODIFY_STATE_=NET_FW_MODIFY_STATE -NET_FW_POLICY_TYPE_=NET_FW_POLICY_TYPE -NET_FW_PROFILE_TYPE_=NET_FW_PROFILE_TYPE -NET_FW_PROFILE_TYPE2_=NET_FW_PROFILE_TYPE2 -NET_FW_RULE_CATEGORY_=NET_FW_RULE_CATEGORY -NET_FW_RULE_DIRECTION_=NET_FW_RULE_DIRECTION -NET_FW_SCOPE_=NET_FW_SCOPE -NET_FW_SERVICE_TYPE_=NET_FW_SERVICE_TYPE tagDBBYGUID=DBBYGUID tagDBCOMMANDTREE=DBCOMMANDTREE tagDBCONTENT=DBCONTENT @@ -10066,93 +374,23 @@ tagDBSETFUNC=DBSETFUNC tagDBSORTINFO=DBSORTINFO tagDBTEXT=DBTEXT tagCIPROPERTYDEF=CIPROPERTYDEF -tagAPPLETCFG=IMEAPPLETCFG -tag_SCRIPT_JUSTIFY=SCRIPT_JUSTIFY -tag_SCRIPT_ANALYSIS=SCRIPT_ANALYSIS -tag_SCRIPT_CONTROL=SCRIPT_CONTROL -tag_SCRIPT_DIGITSUBSTITUTE=SCRIPT_DIGITSUBSTITUTE -tag_SCRIPT_ITEM=SCRIPT_ITEM -tag_SCRIPT_LOGATTR=SCRIPT_LOGATTR -tag_SCRIPT_STATE=SCRIPT_STATE -tag_SCRIPT_TABDEF=SCRIPT_TABDEF -tag_SCRIPT_VISATTR=SCRIPT_VISATTR -_nlsversioninfo=NLSVERSIONINFO -_cpinfo=CPINFO -_cpinfoexA=CPINFOEXA -_cpinfoexW=CPINFOEXW -_currencyfmtA=CURRENCYFMTA -_currencyfmtW=CURRENCYFMTW -_nlsversioninfoex=NLSVERSIONINFOEX -_numberfmtA=NUMBERFMTA -_numberfmtW=NUMBERFMTW -NET_ADDRESS_FORMAT_=NET_ADDRESS_FORMAT NET_ADDRESS_INFO_=NET_ADDRESS_INFO -_sockaddr_in6_pair=SOCKADDR_IN6_PAIR berval=LDAP_BERVAL -LdapReferralCallback=LDAP_REFERRAL_CALLBACK -l_timeval=LDAP_TIMEVAL -ldap_apifeature_infoA=LDAPAPIFeatureInfoA -ldap_apifeature_infoW=LDAPAPIFeatureInfoW -ldapmsg=LDAPMessage ColumnSortOrder=_ColumnSortOrder -MBN_SMS_CONSTANTS=WWAEXT_SMS_CONSTANTS -D3D11_AUTHENTICATED_QUERY_ACESSIBILITY_OUTPUT=D3D11_AUTHENTICATED_QUERY_ACCESSIBILITY_OUTPUT -__MIDL___MIDL_itf_dxva2api_0000_0006_0001=DXVA2_SurfaceType -_EVRFilterConfig_Prefs=EVRFilterConfigPrefs -__MIDL___MIDL_itf_evr9_0000_0002_0002=MFVideoAlphaBitmapFlags -__MIDL___MIDL_itf_mfidl_0000_0032_0001=MF_URL_TRUST_STATUS -__MIDL___MIDL_itf_mfidl_0000_0110_0003=MFSensorDeviceMode -__MIDL___MIDL_itf_mfidl_0000_0110_0001=MFSensorDeviceType -__MIDL___MIDL_itf_mfidl_0000_0110_0002=MFSensorStreamType -_ASFFlatPicture=ASF_FLAT_PICTURE -_ASFFlatSynchronisedLyrics=ASF_FLAT_SYNCHRONISED_LYRICS -__MIDL___MIDL_itf_mfidl_0000_0059_0001=MF_BYTE_STREAM_CACHE_RANGE -_MFINPUTTRUSTAUTHORITY_ACTION=MFINPUTTRUSTAUTHORITY_ACCESS_ACTION -__MIDL___MIDL_itf_mfidl_0000_0114_0001=SENSORPROFILEID __MIDL___MIDL_itf_mfobjects_0000_0017_0001=MF_FILE_ACCESSMODE __MIDL___MIDL_itf_mfobjects_0000_0017_0003=MF_FILE_FLAGS __MIDL___MIDL_itf_mfobjects_0000_0017_0002=MF_FILE_OPENMODE -__MFAYUVSample=MFAYUVSample __MIDL___MIDL_itf_mfobjects_0000_0008_0003=MFT_REGISTER_TYPE_INFO _MFP_CREATION_OPTIONS=MFP_CREATION_OPTIONS _MFT_DRAIN_TYPE=MFT_DRAIN_TYPE -MFASF_INDEXERFLAGS=MFASF_INDEXER_FLAGS -MFASF_STREAMSELECTORFLAGS=MFASF_STREAMSELECTOR_FLAGS -_MMCButton=MMCBUTTON -_RDCITEMHDR=RDITEMHDR DocumentMode=_DocumentMode ExportListOptions=_ExportListOptions ListViewMode=_ListViewMode ViewOptions=_ViewOptions -_SR_RESOURCE_TYPE_ELIGIBLE_SOURCE_DATADISKS=SR_RESOURCE_TYPE_QUERY_ELIGIBLE_SOURCE_DATADISKS -_SR_RESOURCE_TYPE_ELIGIBLE_TARGET_DATADISKS=SR_RESOURCE_TYPE_QUERY_ELIGIBLE_TARGET_DATADISKS __MIDL___MIDL_itf_msclus_0000_0000_0005=CLUS_GROUP_START_SETTING __MIDL___MIDL_itf_msclus_0000_0000_0001=CLUSGROUP_TYPE __MIDL___MIDL_itf_msclus_0000_0000_0002=CLUSTER_MGMT_POINT_TYPE -__MIDL___MIDL_itf_mpeg2structs_0000_0000_0027=MPEG_CONTEXT_TYPE -__MIDL___MIDL_itf_mpeg2structs_0000_0000_0032=MPEG_REQUEST_TYPE -__MIDL___MIDL_itf_mpeg2structs_0000_0000_0017=ATSC_FILTER_OPTIONS -__MIDL___MIDL_itf_mpeg2structs_0000_0000_0016=DSMCC_FILTER_OPTIONS -__MIDL___MIDL_itf_mpeg2structs_0000_0000_0011=DSMCC_SECTION -__MIDL___MIDL_itf_mpeg2structs_0000_0000_0018=DVB_EIT_FILTER_OPTIONS -__MIDL___MIDL_itf_mpeg2structs_0000_0000_0008=LONG_SECTION -__MIDL___MIDL_itf_mpeg2structs_0000_0000_0028=MPEG_BCS_DEMUX -__MIDL___MIDL_itf_mpeg2structs_0000_0000_0030=MPEG_CONTEXT -__MIDL___MIDL_itf_mpeg2structs_0000_0000_0026=MPEG_DATE_AND_TIME -__MIDL___MIDL_itf_mpeg2structs_0000_0000_0025=MPEG_DATE -__MIDL___MIDL_itf_mpeg2structs_0000_0000_0015=MPEG_PACKET_LIST -__MIDL___MIDL_itf_mpeg2structs_0000_0000_0014=MPEG_RQST_PACKET -__MIDL___MIDL_itf_mpeg2structs_0000_0000_0023=MPEG_STREAM_BUFFER -__MIDL___MIDL_itf_mpeg2structs_0000_0000_0024=MPEG_TIME -__MIDL___MIDL_itf_mpeg2structs_0000_0000_0029=MPEG_WINSOCK -__MIDL___MIDL_itf_mpeg2structs_0000_0000_0019=MPEG2_FILTER -__MIDL___MIDL_itf_mpeg2structs_0000_0000_0020=MPEG2_FILTER2 -__MIDL___MIDL_itf_mpeg2structs_0000_0000_0006=SECTION -__MIDL___MIDL_itf_sbe_0000_0015_0002=DVR_STREAM_DESC -__MIDL___MIDL_itf_sbe_0000_0015_0001=SBE2_STREAM_DESC joycaps_tag=JOYCAPS -joyinfo_tag=JOYINFO -joyinfoex_tag=JOYINFOEX auxcaps_tag=AUXCAPS midiincaps_tag=MIDIINCAPS midioutcaps_tag=MIDIOUTCAPS @@ -10170,38 +408,6 @@ tACMFILTERTAGDETAILS=ACMFILTERTAGDETAILS tACMFORMATCHOOSE=ACMFORMATCHOOSE tACMFORMATDETAILS=ACMFORMATDETAILS tACMFORMATTAGDETAILS=ACMFORMATTAGDETAILS -tACMSTREAMHEADER=ACMSTREAMHEADER -timecaps_tag=TIMECAPS -tagCapDriverCaps=CAPDRIVERCAPS -tagCapInfoChunk=CAPINFOCHUNK -tagCapStatus=CAPSTATUS -tagCaptureParms=CAPTUREPARMS -videohdr_tag=VIDEOHDR -tagExtendedIsolationState=ExtendedIsolationState -tagFailureCategory=FailureCategory -tagFixupState=FixupState -tagIsolationState=IsolationState -tagNapNotifyType=NapNotifyType -tagRemoteConfigurationType=RemoteConfigurationType -tagCorrelationId=CorrelationId -tagCountedString=CountedString -tagFailureCategoryMapping=FailureCategoryMapping -tagFixupInfo=FixupInfo -tagIpv4Address=Ipv4Address -tagIpv6Address=Ipv6Address -tagIsolationInfo=IsolationInfo -tagIsolationInfoEx=IsolationInfoEx -tagNapComponentRegistrationInfo=NapComponentRegistrationInfo -tagNetworkSoH=NetworkSoH -tagPrivateData=PrivateData -tagResultCodes=ResultCodes -tagSoH=SoH -tagSoHAttribute=SoHAttribute -tagSystemHealthAgentState=SystemHealthAgentState -__MIDL___MIDL_itf_wsdbase_0000_0000_0001=WSD_CONFIG_PARAM_TYPE -__MIDL___MIDL_itf_ndattrib_0000_0000_0002=REPAIR_RISK -__MIDL___MIDL_itf_ndattrib_0000_0000_0003=UI_INFO_TYPE -tagSOCK_ADDR=DIAG_SOCKADDR FWPS_DISCARD_MODULE0_=FWPS_DISCARD_MODULE0 FWPS_ACTION0_=FWPS_ACTION0 FWPS_ALE_ENDPOINT_ENUM_TEMPLATE0_=FWPS_ALE_ENDPOINT_ENUM_TEMPLATE0 @@ -10215,130 +421,7 @@ FWPS_FILTER2_=FWPS_FILTER2 FWPS_INBOUND_FRAGMENT_METADATA0_=FWPS_INBOUND_FRAGMENT_METADATA0 FWPS_INCOMING_VALUE0_=FWPS_INCOMING_VALUE0 FWPS_INCOMING_VALUES0_=FWPS_INCOMING_VALUES0 -_NDK_ADAPTER_INFO=NDK_ADAPTER_INFO _WSACMSGHDR=WSACMSGHDR -_DOMAINTYPE=IASDOMAINTYPE -__MIDL___MIDL_itf_msopc_0001_0076_0001=OPC_CANONICALIZATION_METHOD -__MIDL___MIDL_itf_msopc_0001_0076_0004=OPC_CERTIFICATE_EMBEDDING_OPTION -__MIDL___MIDL_itf_msopc_0000_0002_0002=OPC_COMPRESSION_OPTIONS -__MIDL___MIDL_itf_msopc_0000_0002_0004=OPC_READ_FLAGS -__MIDL___MIDL_itf_msopc_0001_0076_0002=OPC_RELATIONSHIP_SELECTOR -__MIDL___MIDL_itf_msopc_0001_0076_0003=OPC_RELATIONSHIPS_SIGNING_OPTION -__MIDL___MIDL_itf_msopc_0001_0076_0005=OPC_SIGNATURE_TIME_FORMAT -__MIDL___MIDL_itf_msopc_0000_0002_0003=OPC_STREAM_IO_MODE -__MIDL___MIDL_itf_msopc_0000_0002_0001=OPC_URI_TARGET_MODE -__MIDL___MIDL_itf_msopc_0000_0002_0005=OPC_WRITE_FLAGS -drt_event_type_tag=DRT_EVENT_TYPE -drt_leafset_key_change_type_tag=DRT_LEAFSET_KEY_CHANGE_TYPE -drt_match_type_tag=DRT_MATCH_TYPE -drt_scope_tag=DRT_SCOPE -drt_security_mode_tag=DRT_SECURITY_MODE -drt_status_tag=DRT_STATUS -drt_bootstrap_provider_tag=DRT_BOOTSTRAP_PROVIDER -drt_data_tag=DRT_DATA -drt_event_data_tag=DRT_EVENT_DATA -drt_registration_tag=DRT_REGISTRATION -drt_search_info_tag=DRT_SEARCH_INFO -drt_search_result_tag=DRT_SEARCH_RESULT -drt_security_provider_tag=DRT_SECURITY_PROVIDER -drt_settings_tag=DRT_SETTINGS -peer_collab_event_data_tag=PEER_COLLAB_EVENT_DATA -peer_group_event_data_tag=PEER_GROUP_EVENT_DATA -peer_application_registration_type_tag=PEER_APPLICATION_REGISTRATION_TYPE -peer_change_type_tag=PEER_CHANGE_TYPE -peer_collab_event_type_tag=PEER_COLLAB_EVENT_TYPE -peer_connection_flags_tag=PEER_CONNECTION_FLAGS -peer_connection_status_tag=PEER_CONNECTION_STATUS -peer_graph_event_type_tag=PEER_GRAPH_EVENT_TYPE -peer_graph_property_flags_tag=PEER_GRAPH_PROPERTY_FLAGS -peer_graph_scope_tag=PEER_GRAPH_SCOPE -peer_graph_status_flags_tag=PEER_GRAPH_STATUS_FLAGS -peer_group_authentication_scheme_tag=PEER_GROUP_AUTHENTICATION_SCHEME -peer_group_event_type_tag=PEER_GROUP_EVENT_TYPE -peer_issue_credential_flags_tag=PEER_GROUP_ISSUE_CREDENTIAL_FLAGS -peer_group_property_flags_tag=PEER_GROUP_PROPERTY_FLAGS -peer_group_status_tag=PEER_GROUP_STATUS -peer_invitation_response_type_tag=PEER_INVITATION_RESPONSE_TYPE -peer_member_change_type_tag=PEER_MEMBER_CHANGE_TYPE -peer_member_flags_tag=PEER_MEMBER_FLAGS -peer_node_change_type_tag=PEER_NODE_CHANGE_TYPE -peer_presence_status_tag=PEER_PRESENCE_STATUS -peer_publication_scope_tag=PEER_PUBLICATION_SCOPE -peer_record_change_type_tag=PEER_RECORD_CHANGE_TYPE -peer_record_flags_tag=PEER_RECORD_FLAGS -peer_signin_flags_tag=PEER_SIGNIN_FLAGS -peer_watch_permission_tag=PEER_WATCH_PERMISSION -peer_address_tag=PEER_ADDRESS -peer_app_launch_info_tag=PEER_APP_LAUNCH_INFO -peer_application_registration_info_tag=PEER_APPLICATION_REGISTRATION_INFO -peer_application_tag=PEER_APPLICATION -peer_collab_event_registration_tag=PEER_COLLAB_EVENT_REGISTRATION -peer_connection_info_tag=PEER_CONNECTION_INFO -peer_contact_tag=PEER_CONTACT -peer_credential_info_tag=PEER_CREDENTIAL_INFO -peer_data_tag=PEER_DATA -peer_endpoint_tag=PEER_ENDPOINT -peer_event_application_changed_data_tag=PEER_EVENT_APPLICATION_CHANGED_DATA -peer_event_connection_change_data_tag=PEER_EVENT_CONNECTION_CHANGE_DATA -peer_event_endpoint_changed_data_tag=PEER_EVENT_ENDPOINT_CHANGED_DATA -peer_event_incoming_data_tag=PEER_EVENT_INCOMING_DATA -peer_event_member_change_data_tag=PEER_EVENT_MEMBER_CHANGE_DATA -peer_event_node_change_data_tag=PEER_EVENT_NODE_CHANGE_DATA -peer_event_object_changed_data_tag=PEER_EVENT_OBJECT_CHANGED_DATA -peer_event_people_near_me_changed_data_tag=PEER_EVENT_PEOPLE_NEAR_ME_CHANGED_DATA -peer_event_presence_changed_data_tag=PEER_EVENT_PRESENCE_CHANGED_DATA -peer_event_record_change_data_tag=PEER_EVENT_RECORD_CHANGE_DATA -peer_event_request_status_changed_data_tag=PEER_EVENT_REQUEST_STATUS_CHANGED_DATA -peer_event_synchronized_data_tag=PEER_EVENT_SYNCHRONIZED_DATA -peer_event_watchlist_changed_data_tag=PEER_EVENT_WATCHLIST_CHANGED_DATA -peer_graph_event_data_tag=PEER_GRAPH_EVENT_DATA -peer_graph_event_registration_tag=PEER_GRAPH_EVENT_REGISTRATION -peer_graph_properties_tag=PEER_GRAPH_PROPERTIES -peer_group_event_registration_tag=PEER_GROUP_EVENT_REGISTRATION -peer_group_properties_tag=PEER_GROUP_PROPERTIES -peer_invitation_info_tag=PEER_INVITATION_INFO -peer_invitation_response_tag=PEER_INVITATION_RESPONSE -peer_invitation_tag=PEER_INVITATION -peer_member_tag=PEER_MEMBER -peer_name_pair_tag=PEER_NAME_PAIR -peer_node_info_tag=PEER_NODE_INFO -peer_object_tag=PEER_OBJECT -peer_people_near_me_tag=PEER_PEOPLE_NEAR_ME -peer_pnrp_cloud_info_tag=PEER_PNRP_CLOUD_INFO -peer_pnrp_endpoint_info_tag=PEER_PNRP_ENDPOINT_INFO -peer_pnrp_registration_info_tag=PEER_PNRP_REGISTRATION_INFO -peer_presence_info_tag=PEER_PRESENCE_INFO -peer_record_tag=PEER_RECORD -peer_security_interface_tag=PEER_SECURITY_INTERFACE -peer_version_data_tag=PEER_VERSION_DATA -peerdist_content_tag_tag=PEERDIST_CONTENT_TAG -peerdist_publication_options_tag=PEERDIST_PUBLICATION_OPTIONS -peerdist_retrieval_options_tag=PEERDIST_RETRIEVAL_OPTIONS -peerdist_status_info_tag=PEERDIST_STATUS_INFO -tagWPC_MEDIA_EXPLICIT_TYPE=WPC_MEDIA_EXPLICIT -tagWPCFLAG_IM_LEAVE_FLAG=WPCFLAG_IM_LEAVE -_BrowseDlgConfig_A=PDH_BROWSE_DLG_CONFIG_A -_BrowseDlgConfig_HA=PDH_BROWSE_DLG_CONFIG_HA -_BrowseDlgConfig_HW=PDH_BROWSE_DLG_CONFIG_HW -_BrowseDlgConfig_W=PDH_BROWSE_DLG_CONFIG_W -_PROVIDER_CONTEXT=PERF_PROVIDER_CONTEXT -_STRING_BUFFER_HEADER=PERF_STRING_BUFFER_HEADER -_STRING_COUNTER_HEADER=PERF_STRING_COUNTER_HEADER -__MIDL___MIDL_itf_pla_0001_0043_0003=AutoPathFormat -__MIDL___MIDL_itf_pla_0001_0043_0005=ClockType -__MIDL___MIDL_itf_pla_0001_0043_0007=CommitMode -__MIDL___MIDL_itf_pla_0001_0043_0004=DataCollectorSetStatus -__MIDL___MIDL_itf_pla_0001_0043_0001=DataCollectorType -__MIDL___MIDL_itf_pla_0001_0043_0011=DataManagerSteps -__MIDL___MIDL_itf_pla_0001_0043_0002=FileFormat -__MIDL___MIDL_itf_pla_0001_0043_0012=FolderActionSteps -__MIDL___MIDL_itf_pla_0001_0043_0010=ResourcePolicy -__MIDL___MIDL_itf_pla_0001_0043_0006=StreamMode -__MIDL___MIDL_itf_pla_0001_0043_0008=ValueMapType -__MIDL___MIDL_itf_pla_0001_0043_0009=WeekDays -tag_GPOBROWSEINFO=GPOBROWSEINFO -__MIDL___MIDL_itf_xpsobjectmodel_0000_0000_0021=XPS_GLYPH_INDEX -_POLICY_ELEMENT=POLICY_ELEMENT lpminitinfo=LPM_INIT_INFO rsvpmsgobjs=RSVP_MSG_OBJS _PS_ADAPTER_STATS=PS_ADAPTER_STATS @@ -10347,61 +430,10 @@ _PS_CONFORMER_STATS=PS_CONFORMER_STATS _PS_DRRSEQ_STATS=PS_DRRSEQ_STATS _PS_FLOW_STATS=PS_FLOW_STATS _PS_SHAPER_STATS=PS_SHAPER_STATS -_flowspec=FLOWSPEC -_IDPE_ATTR=IDPE_ATTR -_AD_GENERAL_PARAMS=AD_GENERAL_PARAMS -_CONTROL_SERVICE=CONTROL_SERVICE -_FLOWDESCRIPTOR=FLOWDESCRIPTOR -_IN_ADDR_IPV4=IN_ADDR_IPV4 -_IN_ADDR_IPV6=IN_ADDR_IPV6 -_PARAM_BUFFER=PARAM_BUFFER -_QOS_DESTADDR=QOS_DESTADDR -_RSVP_ADSPEC=RSVP_ADSPEC -_RSVP_FILTERSPEC_V4_GPI=RSVP_FILTERSPEC_V4_GPI -_RSVP_FILTERSPEC_V4=RSVP_FILTERSPEC_V4 -_RSVP_FILTERSPEC_V6_FLOW=RSVP_FILTERSPEC_V6_FLOW -_RSVP_FILTERSPEC_V6_GPI=RSVP_FILTERSPEC_V6_GPI -_RSVP_FILTERSPEC_V6=RSVP_FILTERSPEC_V6 -_RSVP_FILTERSPEC=RSVP_FILTERSPEC -_RSVP_POLICY_INFO=RSVP_POLICY_INFO -_RSVP_POLICY=RSVP_POLICY -_RSVP_RESERVE_INFO=RSVP_RESERVE_INFO -_RSVP_STATUS_INFO=RSVP_STATUS_INFO -_QualityOfService=QOS -__MIDL___MIDL_itf_msrdc_0000_0000_0002=GeneratorParametersType -__MIDL___MIDL_itf_msrdc_0000_0000_0001=RDC_ErrorCode -__MIDL___MIDL_itf_msrdc_0000_0000_0009=RdcCreatedTables -__MIDL___MIDL_itf_msrdc_0000_0000_0010=RdcMappingAccessMode -__MIDL___MIDL_itf_msrdc_0000_0000_0003=RdcNeedType -__MIDL___MIDL_itf_msrdc_0000_0000_0013=FindSimilarFileIndexResults -__MIDL___MIDL_itf_msrdc_0000_0000_0005=RdcBufferPointer -__MIDL___MIDL_itf_msrdc_0000_0000_0004=RdcNeed -__MIDL___MIDL_itf_msrdc_0000_0000_0006=RdcNeedPointer -__MIDL___MIDL_itf_msrdc_0000_0000_0007=RdcSignature -__MIDL___MIDL_itf_msrdc_0000_0000_0008=RdcSignaturePointer -__MIDL___MIDL_itf_msrdc_0000_0000_0012=SimilarityData -__MIDL___MIDL_itf_msrdc_0000_0000_0014=SimilarityDumpData -__MIDL___MIDL_itf_msrdc_0000_0000_0015=SimilarityFileId -__MIDL___MIDL_itf_msrdc_0000_0000_0011=SimilarityMappedViewInfo -__MIDL___MIDL_itf_rdpencomapi_0000_0000_0002=ATTENDEE_DISCONNECT_REASON -__MIDL___MIDL_itf_rdpencomapi_0000_0000_0005=CHANNEL_ACCESS_ENUM -__MIDL___MIDL_itf_rdpencomapi_0000_0000_0004=CHANNEL_FLAGS -__MIDL___MIDL_itf_rdpencomapi_0000_0000_0003=CHANNEL_PRIORITY -__MIDL___MIDL_itf_rdpencomapi_0000_0000_0001=CTRL_LEVEL -__MIDL___MIDL_itf_rdpencomapi_0000_0000_0006=RDPENCOMAPI_ATTENDEE_FLAGS -__MIDL___MIDL_itf_rdpencomapi_0000_0027_0001=RDPENCOMAPI_CONSTANTS -__MIDL___MIDL_itf_rdpencomapi_0000_0000_0008=RDPSRAPI_APP_FLAGS -__MIDL___MIDL_itf_rdpencomapi_0000_0000_0010=RDPSRAPI_KBD_CODE_TYPE -__MIDL___MIDL_itf_rdpencomapi_0000_0000_0011=RDPSRAPI_KBD_SYNC_FLAG -__MIDL___MIDL_itf_rdpencomapi_0000_0000_0009=RDPSRAPI_MOUSE_BUTTON_TYPE -__MIDL___MIDL_itf_rdpencomapi_0000_0000_0007=RDPSRAPI_WND_FLAGS -__MIDL___MIDL_itf_rendezvoussession_0000_0000_0002=RENDEZVOUS_SESSION_FLAGS -__MIDL___MIDL_itf_rendezvoussession_0000_0000_0001=RENDEZVOUS_SESSION_STATE _RPC_PROTSEQ_VECTOR=RPC_PROTSEQ_VECTOR _IPX_IF_INFO=IPX_IF_INFO _IPXWAN_IF_INFO=IPXWAN_IF_INFO _IKEV2_TUNNEL_CONFIG_PARAMS1=IKEV2_TUNNEL_CONFIG_PARAMS1 -RAS_UPDATE_CONNECTION_=RAS_UPDATE_CONNECTION _tagRasNapState=RASNAPSTATE _MESSAGE=MESSAGE _MPR50_ROUTING_CHARACTERISTICS=MPR50_ROUTING_CHARACTERISTICS @@ -10413,39 +445,7 @@ _IPX_SERVER_ENTRY=IPX_SERVER_ENTRY _IPX_SERVICE=IPX_SERVICE _MPR40_SERVICE_CHARACTERISTICS=MPR40_SERVICE_CHARACTERISTICS _MPR50_SERVICE_CHARACTERISTICS=MPR50_SERVICE_CHARACTERISTICS -__MIDL___MIDL_itf_searchapi_0000_0013_0001=CLUSION_REASON -__MIDL___MIDL_itf_structuredquery_0000_0012_0001=NAMED_ENTITY_CERTAINTY -_PROGRESS_INVOKE_SETTING=PROG_INVOKE_SETTING -__BCRYPT_KEY_LENGTHS_STRUCT=BCRYPT_KEY_LENGTHS_STRUCT -__MIDL___MIDL_itf_casetup_0000_0002_0001=CASetupProperty -__MIDL___MIDL_itf_casetup_0000_0005_0001=CEPSetupProperty -__MIDL___MIDL_itf_casetup_0000_0004_0001=CESSetupProperty -__MIDL___MIDL_itf_casetup_0000_0003_0001=MSCEPSetupProperty -_CREDSSP_SUBMIT_TYPE=CREDSPP_SUBMIT_TYPE -_CREDSSP_CRED=CREDSSP_CRED -_SecPkgContext_ClientCreds=SecPkgContext_ClientCreds -tagCSSA=CERT_SELECT_STRUCT_A -tagCSSW=CERT_SELECT_STRUCT_W -_CRYPTUI_WIZ_IMPORT_SUBJECT_INFO=CRYPTUI_WIZ_IMPORT_SRC_INFO -_IdentityType=IDENTITY_TYPE -_LSA_OBJECT_ATTRIBUTES=LSA_OBJECT_ATTRIBUTES -_LSA_STRING=LSA_STRING -_LSA_UNICODE_STRING=LSA_UNICODE_STRING -CATALOG_INFO_=CATALOG_INFO -CRYPTCATATTRIBUTE_=CRYPTCATATTRIBUTE -CRYPTCATCDF_=CRYPTCATCDF -CRYPTCATMEMBER_=CRYPTCATMEMBER -CRYPTCATSTORE_=CRYPTCATSTORE _POLICY_SERVER_ENABLE_STATE=POLICY_SERVER_ENABLE_STATE -_SCESVC_ANALYSIS_INFO_=SCESVC_ANALYSIS_INFO -_SCESVC_ANALYSIS_LINE_=SCESVC_ANALYSIS_LINE -_SCESVC_CALLBACK_INFO_=SCESVC_CALLBACK_INFO -_SCESVC_CONFIGURATION_INFO_=SCESVC_CONFIGURATION_INFO -_SCESVC_CONFIGURATION_LINE_=SCESVC_CONFIGURATION_LINE -_eTlsAlgorithmUsage=eTlsAlgorithmUsage -_CRYPTO_SETTINGS=CRYPTO_SETTINGS -_SCH_CREDENTIALS=SCH_CREDENTIALS -_TLS_PARAMETERS=TLS_PARAMETERS _CREDUIWIN_MARSHALED_CONTEXT=CREDUIWIN_MARSHALED_CONTEXT _SEC_WINNT_AUTH_BYTE_VECTOR=SEC_WINNT_AUTH_BYTE_VECTOR _SEC_WINNT_AUTH_CERTIFICATE_DATA=SEC_WINNT_AUTH_CERTIFICATE_DATA @@ -10457,551 +457,33 @@ _SEC_WINNT_AUTH_SHORT_VECTOR=SEC_WINNT_AUTH_SHORT_VECTOR _SEC_WINNT_CREDUI_CONTEXT_VECTOR=SEC_WINNT_CREDUI_CONTEXT_VECTOR _SEC_WINNT_CREDUI_CONTEXT=SEC_WINNT_CREDUI_CONTEXT _SECURITY_INTEGER=SECURITY_INTEGER -_SECURITY_STRING=SECURITY_STRING -_SECURITY_FUNCTION_TABLE_A=SecurityFunctionTableA -_SECURITY_FUNCTION_TABLE_W=SecurityFunctionTableW -__MIDL___MIDL_itf_tpmvscmgr_0000_0000_0002=TPMVSCMGR_ERROR -__MIDL___MIDL_itf_tpmvscmgr_0000_0000_0001=TPMVSCMGR_STATUS -_WLX_CLIENT_CREDENTIALS_INFO=WLX_CLIENT_CREDENTIALS_INFO_V1_0 -_WLX_CLIENT_CREDENTIALS_INFO_2_0=WLX_CLIENT_CREDENTIALS_INFO_V2_0 -_WLX_CONSOLESWITCH_CREDENTIALS_INFO=WLX_CONSOLESWITCH_CREDENTIALS_INFO_V1_0 -__MIDL_IAssemblyName_0004=ASM_CMP_FLAGS -__MIDL_IAssemblyName_0003=ASM_DISPLAY_FLAGS -__MIDL_IAssemblyName_0001=ASM_NAME -__MIDL___MIDL_itf_winsxs_0000_0003_0001=CREATE_ASM_NAME_OBJ_FLAGS -_FUSION_INSTALL_REFERENCE_=FUSION_INSTALL_REFERENCE __MIDL___MIDL_itf_dimm_0000_0000_0003=LOGFONTA __MIDL___MIDL_itf_dimm_0000_0000_0004=LOGFONTW -_tagAppActionFlags=APPACTIONFLAGS -_tagAppInfoFlags=APPINFODATAFLAGS -_tagPublishedAppInfoFlags=PUBAPPINFOFLAGS -_AppInfoData=APPINFODATA -_PubAppInfo=PUBAPPINFO -_tagSlowAppInfo=SLOWAPPINFO -tagFolderSetData=FOLDERSETDATA -SToolbarItem=TOOLBARITEM -_AppBarData=APPBARDATA -tagAAMENUFILENAME=AASHELLMENUFILENAME ILLoadFromStreamEx~r2=ILLoadFromStreamEx -_browseinfoA=BROWSEINFOA -_browseinfoW=BROWSEINFOW -_IDA=CIDA _tagCOMPONENT=COMPONENT _tagCOMPONENTSOPT=COMPONENTSOPT _tagCOMPPOS=COMPPOS _tagCOMPSTATEINFO=COMPSTATEINFO -tagDATABLOCKHEADER=DATABLOCK_HEADER _tagIE4COMPONENT=IE4COMPONENT -_openasinfo=OPENASINFO _tagWALLPAPEROPT=WALLPAPEROPT -SHCSCHANGENOTIFYSTRUCT=SMCSHCHANGENOTIFYSTRUCT -__MIDL___MIDL_itf_wcmconfig_0000_0000_0003=WcmDataType -__MIDL___MIDL_itf_wcmconfig_0000_0000_0007=WcmNamespaceAccess -__MIDL___MIDL_itf_wcmconfig_0000_0000_0002=WcmNamespaceEnumerationFlags -__MIDL___MIDL_itf_wcmconfig_0000_0000_0005=WcmRestrictionFacets -__MIDL___MIDL_itf_wcmconfig_0000_0000_0004=WcmSettingType -__MIDL___MIDL_itf_wcmconfig_0000_0000_0001=WcmTargetMode -__MIDL___MIDL_itf_wcmconfig_0000_0000_0006=WcmUserStatus -_RESTOREPTINFOA=RESTOREPOINTINFOA -_RESTOREPTINFOW=RESTOREPOINTINFOW -_SMGRSTATUS=STATEMGRSTATUS -eDataSourceTypeConstant=DataSourceTypeConstants -eDisplayTypeConstant=DisplayTypeConstants -eReportValueTypeConstant=ReportValueTypeConstants -__MIDL___MIDL_itf_sysmon_0000_0000_0003=SysmonBatchReason -__MIDL___MIDL_itf_sysmon_0000_0000_0002=SysmonDataType -__MIDL___MIDL_itf_sysmon_0000_0000_0001=SysmonFileType -__MIDL___MIDL_itf_micaut_0000_0000_0001=MICUIELEMENT -__MIDL___MIDL_itf_micaut_0000_0000_0002=MICUIELEMENTSTATE -ItemSelectionConstants=InkSelectionConstants -__MIDL___MIDL_itf_peninputpanel_0000_0000_0004=CorrectionMode -__MIDL___MIDL_itf_peninputpanel_0000_0000_0005=CorrectionPosition -__MIDL___MIDL_itf_peninputpanel_0000_0000_0007=EventMask -__MIDL___MIDL_itf_peninputpanel_0000_0000_0006=InPlaceDirection -__MIDL___MIDL_itf_peninputpanel_0000_0000_0002=InPlaceState -__MIDL___MIDL_itf_peninputpanel_0000_0000_0001=InteractionMode -__MIDL___MIDL_itf_peninputpanel_0000_0000_0003=PanelInputArea -enumALT_BREAKS=ALT_BREAKS -enumCONFIDENCE_LEVEL=CONFIDENCE_LEVEL -enumLINE_METRICS=LINE_METRICS __MIDL___MIDL_itf_msp_0000_0000_0001=MSP_ADDRESS_EVENT __MIDL___MIDL_itf_msp_0000_0000_0003=MSP_CALL_EVENT_CAUSE __MIDL___MIDL_itf_msp_0000_0000_0002=MSP_CALL_EVENT __MIDL___MIDL_itf_msp_0000_0000_0004=MSP_EVENT __MIDL___MIDL_itf_msp_0000_0000_0005=MSP_EVENT_INFO -lineaddresscaps_tag=LINEADDRESSCAPS -lineaddressstatus_tag=LINEADDRESSSTATUS -lineagentactivityentry_tag=LINEAGENTACTIVITYENTRY -lineagentactivitylist_tag=LINEAGENTACTIVITYLIST -lineagentcaps_tag=LINEAGENTCAPS -lineagententry_tag=LINEAGENTENTRY -lineagentgroupentry_tag=LINEAGENTGROUPENTRY -lineagentgrouplist_tag=LINEAGENTGROUPLIST -lineagentinfo_tag=LINEAGENTINFO -lineagentlist_tag=LINEAGENTLIST -lineagentsession_tag=LINEAGENTSESSIONENTRY -lineagentsessioninfo_tag=LINEAGENTSESSIONINFO -lineagentsessionlist_tag=LINEAGENTSESSIONLIST -lineagentstatus_tag=LINEAGENTSTATUS -lineappinfo_tag=LINEAPPINFO linecallhubtrackinginfo_tag=LINECALLHUBTRACKINGINFO -linecallinfo_tag=LINECALLINFO -linecalllist_tag=LINECALLLIST -linecallparams_tag=LINECALLPARAMS -linecallstatus_tag=LINECALLSTATUS -linecalltreatmententry_tag=LINECALLTREATMENTENTRY -linecardentry_tag=LINECARDENTRY -linecountryentry_tag=LINECOUNTRYENTRY -linecountrylist_tag=LINECOUNTRYLIST -linedevcaps_tag=LINEDEVCAPS -linedevstatus_tag=LINEDEVSTATUS -linedialparams_tag=LINEDIALPARAMS -lineextensionid_tag=LINEEXTENSIONID -lineforward_tag=LINEFORWARD -lineforwardlist_tag=LINEFORWARDLIST -linegeneratetone_tag=LINEGENERATETONE -lineinitializeexparams_tag=LINEINITIALIZEEXPARAMS -linelocationentry_tag=LINELOCATIONENTRY -linemediacontrolcallstate_tag=LINEMEDIACONTROLCALLSTATE -linemediacontroldigit_tag=LINEMEDIACONTROLDIGIT -linemediacontrolmedia_tag=LINEMEDIACONTROLMEDIA -linemediacontroltone_tag=LINEMEDIACONTROLTONE -linemessage_tag=LINEMESSAGE -linemonitortone_tag=LINEMONITORTONE -lineproviderentry_tag=LINEPROVIDERENTRY -lineproviderlist_tag=LINEPROVIDERLIST -lineproxyrequest_tag=LINEPROXYREQUEST -lineproxyrequestlist_tag=LINEPROXYREQUESTLIST -linequeueentry_tag=LINEQUEUEENTRY -linequeueinfo_tag=LINEQUEUEINFO -linequeuelist_tag=LINEQUEUELIST -linereqmakecall_tag=LINEREQMAKECALL -linereqmediacall_tag=LINEREQMEDIACALL -linetermcaps_tag=LINETERMCAPS -linetranslatecaps_tag=LINETRANSLATECAPS -linetranslateoutput_tag=LINETRANSLATEOUTPUT -phonebuttoninfo_tag=PHONEBUTTONINFO -phonecaps_tag=PHONECAPS -phoneextensionid_tag=PHONEEXTENSIONID -phoneinitializeexparams_tag=PHONEINITIALIZEEXPARAMS -phonemessage_tag=PHONEMESSAGE -phonestatus_tag=PHONESTATUS -varstring_tag=VARSTRING -__MIDL___MIDL_itf_tapi3_0000_0018_0001=MSP_ADDRESS_EVENT -__MIDL___MIDL_itf_tapi3_0000_0018_0003=MSP_CALL_EVENT_CAUSE -__MIDL___MIDL_itf_tapi3_0000_0018_0002=MSP_CALL_EVENT -__MIDL___MIDL_itf_tapi3_0000_0018_0004=MSP_EVENT -__MIDL___MIDL_itf_tapi3_0000_0018_0005=MSP_EVENT_INFO __MIDL___MIDL_itf_termmgr_0000_0000_0001=TMGR_DIRECTION -tuispicreatedialoginstanceparams_tag=TUISPICREATEDIALOGINSTANCEPARAMS -_TASK_PROCESSTOKENSID=TASK_PROCESSTOKENSID_TYPE -_TASK_RUNLEVEL=TASK_RUNLEVEL_TYPE -tdTBS_CONTEXT_PARAMS=TBS_CONTEXT_PARAMS -tdTBS_CONTEXT_PARAMS2=TBS_CONTEXT_PARAMS2 -__MIDL_IRemoteDesktopClientActions_0001=RemoteActionType -__MIDL_IRemoteDesktopClientActions_0002=SnapshotEncodingType -__MIDL_IRemoteDesktopClientActions_0003=SnapshotFormatType -__MIDL___MIDL_itf_sessdirpublictypes_0000_0000_0001=CLIENT_DISPLAY -__MIDL___MIDL_itf_sessdirpublictypes_0000_0000_0002=TSSD_ConnectionPoint -__MIDL___MIDL_itf_tsgpolicyengine_0000_0000_0002=AAAccountingDataType -__MIDL___MIDL_itf_tsgpolicyengine_0000_0000_0001=AAAuthSchemes -__MIDL___MIDL_itf_tsgpolicyengine_0000_0000_0005=PolicyAttributeType -__MIDL___MIDL_itf_tsgpolicyengine_0000_0000_0003=AAAccountingData -__MIDL_ItsPubPlugin2_0002=pluginResource2 -__MIDL_ItsPubPlugin2_0001=pluginResource2FileAssociation -__MIDL_ItsPubPlugin_0001=pluginResource -__MIDL_IWTSSBPlugin_0003=WTSSBX_ADDRESS_FAMILY -__MIDL_IWTSSBPlugin_0001=WTSSBX_MACHINE_DRAIN -__MIDL_IWTSSBPlugin_0002=WTSSBX_MACHINE_SESSION_MODE -__MIDL_IWTSSBPlugin_0005=WTSSBX_MACHINE_STATE -__MIDL_IWTSSBPlugin_0010=WTSSBX_NOTIFICATION_TYPE -__MIDL_IWTSSBPlugin_0008=WTSSBX_SESSION_STATE -__MIDL_IWTSSBPlugin_0004=WTSSBX_IP_ADDRESS -__MIDL_IWTSSBPlugin_0006=WTSSBX_MACHINE_CONNECT_INFO -__MIDL_IWTSSBPlugin_0007=WTSSBX_MACHINE_INFO -__MIDL_IWTSSBPlugin_0009=WTSSBX_SESSION_INFO -__BITMAP_RENDERER_STATISTICS=BITMAP_RENDERER_STATISTICS -__MIDL___MIDL_itf_wrdsgraphicschannels_0000_0002_0001=WRdsGraphicsChannelType __WTS_PROPERTY_VALUE=WTS_PROPERTY_VALUE -__MIDL_ITfCandidateList_0001=TfCandidateResult -__MIDL___MIDL_itf_ctffunc_0000_0022_0001=TfIntegratableCandidateListSelectionStyle -__MIDL___MIDL_itf_ctffunc_0000_0011_0001=TfSapiObject -__MIDL_ITfFnGetPreferredTouchKeyboardLayout_0001=TKBLayoutType -__MIDL_ITfLangBarItemBalloon_0001=TfLBBalloonStyle -__MIDL___MIDL_itf_ctfutb_0000_0010_0001=TfLBIClick -__MIDL___MIDL_itf_inputscope_0000_0000_0001=InputScope -__MIDL___MIDL_itf_msctf_0000_0070_0004=TF_DA_ATTR_INFO -__MIDL___MIDL_itf_msctf_0000_0070_0002=TF_DA_COLORTYPE -__MIDL___MIDL_itf_msctf_0000_0070_0001=TF_DA_LINESTYLE -__MIDL_ITfContext_0001=TfActiveSelEnd -__MIDL___MIDL_itf_msctf_0000_0000_0001=TfAnchor -__MIDL_ITfRange_0001=TfGravity -__MIDL_ITfTextLayoutSink_0001=TfLayoutCode -__MIDL_ITfRange_0002=TfShiftDir -__MIDL___MIDL_itf_textstor_0000_0000_0001=TsActiveSelEnd -__MIDL_IAnchor_0001=TsGravity -__MIDL___MIDL_itf_textstor_0000_0000_0002=TsLayoutCode -__MIDL___MIDL_itf_textstor_0000_0000_0003=TsRunType -__MIDL_IAnchor_0002=TsShiftDir -__MIDL___MIDL_itf_uianimation_0000_0010_0001=UI_ANIMATION_DEPENDENCIES -__MIDL___MIDL_itf_uianimation_0000_0012_0001=UI_ANIMATION_IDLE_BEHAVIOR -__MIDL___MIDL_itf_uianimation_0000_0000_0002=UI_ANIMATION_MANAGER_STATUS -__MIDL___MIDL_itf_uianimation_0000_0000_0003=UI_ANIMATION_MODE -__MIDL___MIDL_itf_uianimation_0000_0008_0001=UI_ANIMATION_PRIORITY_EFFECT -__MIDL___MIDL_itf_uianimation_0000_0000_0004=UI_ANIMATION_REPEAT_MODE -__MIDL___MIDL_itf_uianimation_0000_0001_0001=UI_ANIMATION_ROUNDING_MODE -__MIDL___MIDL_itf_uianimation_0000_0002_0002=UI_ANIMATION_SCHEDULING_RESULT -__MIDL___MIDL_itf_uianimation_0000_0009_0001=UI_ANIMATION_SLOPE -__MIDL___MIDL_itf_uianimation_0000_0002_0001=UI_ANIMATION_STORYBOARD_STATUS -__MIDL___MIDL_itf_uianimation_0000_0014_0001=UI_ANIMATION_TIMER_CLIENT_STATUS -__MIDL___MIDL_itf_uianimation_0000_0000_0001=UI_ANIMATION_UPDATE_RESULT -__MIDL___MIDL_itf_wdstptmgmt_0000_0000_0009=WDSTRANSPORT_DIAGNOSTICS_COMPONENT_FLAGS -__MIDL___MIDL_itf_wdstptmgmt_0000_0000_0004=WDSTRANSPORT_DISCONNECT_TYPE -__MIDL___MIDL_itf_wdstptmgmt_0000_0000_0001=WDSTRANSPORT_FEATURE_FLAGS -__MIDL___MIDL_itf_wdstptmgmt_0000_0000_0007=WDSTRANSPORT_IP_ADDRESS_SOURCE_TYPE -__MIDL___MIDL_itf_wdstptmgmt_0000_0000_0006=WDSTRANSPORT_IP_ADDRESS_TYPE -__MIDL___MIDL_itf_wdstptmgmt_0000_0000_0003=WDSTRANSPORT_NAMESPACE_TYPE -__MIDL___MIDL_itf_wdstptmgmt_0000_0000_0008=WDSTRANSPORT_NETWORK_PROFILE_TYPE -__MIDL___MIDL_itf_wdstptmgmt_0000_0000_0002=WDSTRANSPORT_PROTOCOL_FLAGS -__MIDL___MIDL_itf_wdstptmgmt_0000_0000_0005=WDSTRANSPORT_SERVICE_NOTIFICATION -__MIDL___MIDL_itf_wdstptmgmt_0000_0000_0010=WDSTRANSPORT_SLOW_CLIENT_HANDLING_TYPE -__MIDL___MIDL_itf_wdstptmgmt_0000_0000_0012=WDSTRANSPORT_TFTP_CAPABILITY -__MIDL___MIDL_itf_wdstptmgmt_0000_0000_0011=WDSTRANSPORT_UDP_PORT_POLICY -__MIDL___MIDL_itf_wiavideo_xp_0000_0000_0001=WIAVIDEO_STATE _WINHTTP_SECURITY_INFO=WINHTTP_SECURITY_INFO -_StrEntryA=STRENTRYA -_StrEntryW=STRENTRYW -_StrTableA=STRTABLEA -_StrTableW=STRTABLEW -_TIME_DYNAMIC_ZONE_INFORMATION=DYNAMIC_TIME_ZONE_INFORMATION -value_entA=VALENTA -value_entW=VALENTW -__MIDL___MIDL_itf_winsatcominterfacei_0000_0000_0002=WINSAT_ASSESSMENT_STATE -__MIDL___MIDL_itf_winsatcominterfacei_0000_0000_0003=WINSAT_ASSESSMENT_TYPE -__MIDL___MIDL_itf_winsatcominterfacei_0000_0000_0004=WINSAT_BITMAP_SIZE -__MIDL___MIDL_itf_sensorsapi_0000_0000_0002=SensorConnectionType -__MIDL___MIDL_itf_sensorsapi_0000_0000_0001=SensorState -napi_provider_level_tag=NAPI_PROVIDER_LEVEL -napi_provider_type_tag=NAPI_PROVIDER_TYPE -napi_domain_description_blob_tag=NAPI_DOMAIN_DESCRIPTION_BLOB -napi_provider_installation_blob_tag=NAPI_PROVIDER_INSTALLATION_BLOB -_WSAEcomparator=WSAECOMPARATOR _BLOB=BLOB -_WSANSClassInfoA=WSANSCLASSINFOA -_WSANSClassInfoW=WSANSCLASSINFOW _WSAOVERLAPPED=WSAOVERLAPPED -pollfd=WSAPOLLFD -_WSAQuerySet2A=WSAQUERYSET2A -_WSAQuerySet2W=WSAQUERYSET2W -_WSAQuerySetA=WSAQUERYSETA -_WSAQuerySetW=WSAQUERYSETW -_WSAServiceClassInfoA=WSASERVICECLASSINFOA -_WSAServiceClassInfoW=WSASERVICECLASSINFOW -_WSAVersion=WSAVERSION -addrinfo=ADDRINFOA -addrinfoex2A=ADDRINFOEX2A -addrinfoex2W=ADDRINFOEX2W -addrinfoex3=ADDRINFOEX3 -addrinfoex4=ADDRINFOEX4 -addrinfoex5=ADDRINFOEX5 -addrinfoex6=ADDRINFOEX6 -addrinfoexA=ADDRINFOEXA -addrinfoexW=ADDRINFOEXW -addrinfoW=ADDRINFOW -in6_pktinfo_ex=IN6_PKTINFO_EX -nd_neighbor_advert=ND_NEIGHBOR_ADVERT_HEADER -nd_neighbor_solicit=ND_NEIGHBOR_SOLICIT_HEADER -nd_opt_dnssl=ND_OPTION_DNSSL -nd_opt_hdr=ND_OPTION_HDR -nd_opt_mtu=ND_OPTION_MTU -nd_opt_prefix_info=ND_OPTION_PREFIX_INFO -nd_opt_rd_hdr=ND_OPTION_RD_HDR -nd_opt_route_info=ND_OPTION_ROUTE_INFO -nd_opt_rdnss=ND_OPTION_RDNSS -nd_redirect=ND_REDIRECT_HEADER -nd_router_advert=ND_ROUTER_ADVERT_HEADER -__MIDL___MIDL_itf_syncregistration_0000_0007_0001=SYNC_REGISTRATION_EVENT -__MIDL___MIDL_itf_winsync_0000_0000_0002=CONFLICT_RESOLUTION_POLICY -__MIDL___MIDL_itf_winsync_0000_0000_0008=FILTERING_TYPE -__MIDL___MIDL_itf_winsync_0000_0000_0011=KNOWLEDGE_COOKIE_COMPARISON_RESULT -__MIDL___MIDL_itf_winsync_0000_0000_0004=SYNC_FULL_ENUMERATION_ACTION -__MIDL___MIDL_itf_winsync_0000_0000_0003=SYNC_PROGRESS_STAGE -__MIDL___MIDL_itf_winsync_0000_0000_0001=SYNC_PROVIDER_ROLE -__MIDL___MIDL_itf_winsync_0000_0000_0005=SYNC_RESOLVE_ACTION -__MIDL___MIDL_itf_winsync_0000_0000_0007=SYNC_SERIALIZATION_VERSION -__MIDL___MIDL_itf_winsync_0000_0000_0006=SYNC_STATISTICS -__tagDRM_COPY_OPL=DRM_COPY_OPL -__tagDRM_MINIMUM_OUTPUT_PROTECTION_LEVELS=DRM_MINIMUM_OUTPUT_PROTECTION_LEVELS -__tagDRM_OPL_OUTPUT_IDS=DRM_OPL_OUTPUT_IDS -__tagDRM_OUTPUT_PROTECTION=DRM_OUTPUT_PROTECTION -__tagDRM_PLAY_OPL=DRM_PLAY_OPL -__tagDRM_VIDEO_OUTPUT_PROTECTION_IDS=DRM_VIDEO_OUTPUT_PROTECTION_IDS -_WMAddressAccessEntry=WM_ADDRESS_ACCESSENTRY -_WMClientPropertiesEx=WM_CLIENT_PROPERTIES_EX -_WMClientProperties=WM_CLIENT_PROPERTIES -_WMLeakyBucketPair=WM_LEAKY_BUCKET_PAIR -_WMMediaType=WM_MEDIA_TYPE -_WMPicture=WM_PICTURE -_WMPortNumberRange=WM_PORT_NUMBER_RANGE -_WMReaderClientInfo=WM_READER_CLIENTINFO -_WMReaderStatistics=WM_READER_STATISTICS -_WMStreamPrioritizationRecord=WM_STREAM_PRIORITY_RECORD -_WMStreamTypeInfo=WM_STREAM_TYPE_INFO -_WMSynchronisedLyrics=WM_SYNCHRONISED_LYRICS -_WMUserText=WM_USER_TEXT -_WMUserWebURL=WM_USER_WEB_URL -_WMWriterStatisticsEx=WM_WRITER_STATISTICS_EX -_WMWriterStatistics=WM_WRITER_STATISTICS -__WMT_VIDEOIMAGE_SAMPLE=WMT_VIDEOIMAGE_SAMPLE -__WMT_VIDEOIMAGE_SAMPLE2=WMT_VIDEOIMAGE_SAMPLE2 -__WMT_WATERMARK_ENTRY=WMT_WATERMARK_ENTRY -tag_CIMTYPE_ENUMERATION=CIMTYPE_ENUMERATION -tag_WBEM_BACKUP_RESTORE_FLAGS=WBEM_BACKUP_RESTORE_FLAGS -tag_WBEM_CHANGE_FLAG_TYPE=WBEM_CHANGE_FLAG_TYPE -tag_WBEM_COMPARISON_FLAG=WBEM_COMPARISON_FLAG -tag_WBEM_COMPILER_OPTIONS=WBEM_COMPILER_OPTIONS -tag_WBEM_CONDITION_FLAG_TYPE=WBEM_CONDITION_FLAG_TYPE -tag_WBEM_CONNECT_OPTIONS=WBEM_CONNECT_OPTIONS -tag_WBEM_FLAVOR_TYPE=WBEM_FLAVOR_TYPE -tag_WBEM_GENERIC_FLAG_TYPE=WBEM_GENERIC_FLAG_TYPE -tag_WBEM_GENUS_TYPE=WBEM_GENUS_TYPE -tag_WBEM_LIMITS=WBEM_LIMITS -tag_WBEM_QUERY_FLAG_TYPE=WBEM_QUERY_FLAG_TYPE -tag_WBEM_REFRESHER_FLAGS=WBEM_REFRESHER_FLAGS -tag_WBEM_SECURITY_FLAGS=WBEM_SECURITY_FLAGS -tag_WBEM_STATUS_TYPE=WBEM_STATUS_TYPE -tag_WBEM_TEXT_FLAG_TYPE=WBEM_TEXT_FLAG_TYPE -tag_WBEM_UNSECAPP_FLAG_TYPE=WBEM_UNSECAPP_FLAG_TYPE -tag_WBEMSTATUS=WBEMSTATUS -tag_WMI_OBJ_TEXT=WMI_OBJ_TEXT -tag_CompileStatusInfo=WBEM_COMPILE_STATUS_INFO -__MIDL___MIDL_itf_wmiutils_0000_0001_0001=WMIQ_ANALYSIS_TYPE -__MIDL___MIDL_itf_wmiutils_0000_0001_0003=WMIQ_ASSOCQ_FLAGS -__MIDL___MIDL_itf_wmiutils_0000_0001_0002=WMIQ_RPN_TOKEN_FLAGS -tag_SWbemAssocQueryInf=SWbemAssocQueryInf -tag_SWbemQueryQualifiedName=SWbemQueryQualifiedName -tag_SWbemRpnEncodedQuery=SWbemRpnEncodedQuery -tag_SWbemRpnQueryToken=SWbemRpnQueryToken -_MI_CallbackMode=MI_CallbackMode -_MI_CancellationReason=MI_CancellationReason -_MI_DestinationOptions_ImpersonationType=MI_DestinationOptions_ImpersonationType -_MI_ErrorCategory=MI_ErrorCategory -_MI_LocaleType=MI_LocaleType -_MI_OperationCallback_ResponseType=MI_OperationCallback_ResponseType -_MI_PromptType=MI_PromptType -_MI_ProviderArchitecture=MI_ProviderArchitecture -_MI_Result=MI_Result -_MI_SubscriptionDeliveryType=MI_SubscriptionDeliveryType -_MI_Type=MI_Type -_MI_Application=MI_Application -_MI_ApplicationFT=MI_ApplicationFT -_MI_Array=MI_Array -_MI_ArrayField=MI_ArrayField -_MI_BooleanA=MI_BooleanA -_MI_BooleanAField=MI_BooleanAField -_MI_BooleanField=MI_BooleanField -_MI_Char16A=MI_Char16A -_MI_Char16AField=MI_Char16AField -_MI_Char16Field=MI_Char16Field -_MI_Class=MI_Class -_MI_ClassDecl=MI_ClassDecl -_MI_ClassFT=MI_ClassFT -_MI_ClientFT_V1=MI_ClientFT_V1 -_MI_ConstBooleanA=MI_ConstBooleanA -_MI_ConstBooleanAField=MI_ConstBooleanAField -_MI_ConstBooleanField=MI_ConstBooleanField -_MI_ConstChar16A=MI_ConstChar16A -_MI_ConstChar16AField=MI_ConstChar16AField -_MI_ConstChar16Field=MI_ConstChar16Field -_MI_ConstDatetimeA=MI_ConstDatetimeA -_MI_ConstDatetimeAField=MI_ConstDatetimeAField -_MI_ConstDatetimeField=MI_ConstDatetimeField -_MI_ConstInstanceA=MI_ConstInstanceA -_MI_ConstInstanceAField=MI_ConstInstanceAField -_MI_ConstInstanceField=MI_ConstInstanceField -_MI_ConstReal32A=MI_ConstReal32A -_MI_ConstReal32AField=MI_ConstReal32AField -_MI_ConstReal32Field=MI_ConstReal32Field -_MI_ConstReal64A=MI_ConstReal64A -_MI_ConstReal64AField=MI_ConstReal64AField -_MI_ConstReal64Field=MI_ConstReal64Field -_MI_ConstReferenceA=MI_ConstReferenceA -_MI_ConstReferenceAField=MI_ConstReferenceAField -_MI_ConstReferenceField=MI_ConstReferenceField -_MI_ConstSint16A=MI_ConstSint16A -_MI_ConstSint16AField=MI_ConstSint16AField -_MI_ConstSint16Field=MI_ConstSint16Field -_MI_ConstSint32A=MI_ConstSint32A -_MI_ConstSint32AField=MI_ConstSint32AField -_MI_ConstSint32Field=MI_ConstSint32Field -_MI_ConstSint64A=MI_ConstSint64A -_MI_ConstSint64AField=MI_ConstSint64AField -_MI_ConstSint64Field=MI_ConstSint64Field -_MI_ConstSint8A=MI_ConstSint8A -_MI_ConstSint8AField=MI_ConstSint8AField -_MI_ConstSint8Field=MI_ConstSint8Field -_MI_ConstStringA=MI_ConstStringA -_MI_ConstStringAField=MI_ConstStringAField -_MI_ConstStringField=MI_ConstStringField -_MI_ConstUint16A=MI_ConstUint16A -_MI_ConstUint16AField=MI_ConstUint16AField -_MI_ConstUint16Field=MI_ConstUint16Field -_MI_ConstUint32A=MI_ConstUint32A -_MI_ConstUint32AField=MI_ConstUint32AField -_MI_ConstUint32Field=MI_ConstUint32Field -_MI_ConstUint64A=MI_ConstUint64A -_MI_ConstUint64AField=MI_ConstUint64AField -_MI_ConstUint64Field=MI_ConstUint64Field -_MI_ConstUint8A=MI_ConstUint8A -_MI_ConstUint8AField=MI_ConstUint8AField -_MI_ConstUint8Field=MI_ConstUint8Field -_MI_Context=MI_Context -_MI_ContextFT=MI_ContextFT -_MI_Datetime=MI_Datetime -_MI_DatetimeA=MI_DatetimeA -_MI_DatetimeAField=MI_DatetimeAField -_MI_DatetimeField=MI_DatetimeField -_MI_Deserializer=MI_Deserializer -_MI_DeserializerFT=MI_DeserializerFT -_MI_DestinationOptions=MI_DestinationOptions -_MI_DestinationOptionsFT=MI_DestinationOptionsFT -_MI_FeatureDecl=MI_FeatureDecl -_MI_Filter=MI_Filter -_MI_FilterFT=MI_FilterFT -_MI_HostedProvider=MI_HostedProvider -_MI_HostedProviderFT=MI_HostedProviderFT -_MI_Instance=MI_Instance -_MI_InstanceA=MI_InstanceA -_MI_InstanceAField=MI_InstanceAField -_MI_InstanceExFT=MI_InstanceExFT -_MI_InstanceField=MI_InstanceField -_MI_InstanceFT=MI_InstanceFT -_MI_Interval=MI_Interval -_MI_MethodDecl=MI_MethodDecl -_MI_Module=MI_Module -_MI_ObjectDecl=MI_ObjectDecl -_MI_Operation=MI_Operation -_MI_OperationCallbacks=MI_OperationCallbacks -_MI_OperationFT=MI_OperationFT -_MI_OperationOptions=MI_OperationOptions -_MI_OperationOptionsFT=MI_OperationOptionsFT -_MI_ParameterDecl=MI_ParameterDecl -_MI_ParameterSet=MI_ParameterSet -_MI_ParameterSetFT=MI_ParameterSetFT -_MI_PropertyDecl=MI_PropertyDecl -_MI_PropertySet=MI_PropertySet -_MI_PropertySetFT=MI_PropertySetFT -_MI_ProviderFT=MI_ProviderFT -_MI_Qualifier=MI_Qualifier -_MI_QualifierDecl=MI_QualifierDecl -_MI_QualifierSet=MI_QualifierSet -_MI_QualifierSetFT=MI_QualifierSetFT -_MI_Real32A=MI_Real32A -_MI_Real32AField=MI_Real32AField -_MI_Real32Field=MI_Real32Field -_MI_Real64A=MI_Real64A -_MI_Real64AField=MI_Real64AField -_MI_Real64Field=MI_Real64Field -_MI_ReferenceA=MI_ReferenceA -_MI_ReferenceAField=MI_ReferenceAField -_MI_ReferenceField=MI_ReferenceField -_MI_SchemaDecl=MI_SchemaDecl -_MI_Serializer=MI_Serializer -_MI_SerializerFT=MI_SerializerFT -_MI_Server=MI_Server -_MI_ServerFT=MI_ServerFT -_MI_Session=MI_Session -_MI_SessionCallbacks=MI_SessionCallbacks -_MI_SessionFT=MI_SessionFT -_MI_Sint16A=MI_Sint16A -_MI_Sint16AField=MI_Sint16AField -_MI_Sint16Field=MI_Sint16Field -_MI_Sint32A=MI_Sint32A -_MI_Sint32AField=MI_Sint32AField -_MI_Sint32Field=MI_Sint32Field -_MI_Sint64A=MI_Sint64A -_MI_Sint64AField=MI_Sint64AField -_MI_Sint64Field=MI_Sint64Field -_MI_Sint8A=MI_Sint8A -_MI_Sint8AField=MI_Sint8AField -_MI_Sint8Field=MI_Sint8Field -_MI_StringA=MI_StringA -_MI_StringAField=MI_StringAField -_MI_StringField=MI_StringField -_MI_SubscriptionDeliveryOptions=MI_SubscriptionDeliveryOptions -_MI_SubscriptionDeliveryOptionsFT=MI_SubscriptionDeliveryOptionsFT -_MI_Timestamp=MI_Timestamp -_MI_Uint16A=MI_Uint16A -_MI_Uint16AField=MI_Uint16AField -_MI_Uint16Field=MI_Uint16Field -_MI_Uint32A=MI_Uint32A -_MI_Uint32AField=MI_Uint32AField -_MI_Uint32Field=MI_Uint32Field -_MI_Uint64A=MI_Uint64A -_MI_Uint64AField=MI_Uint64AField -_MI_Uint64Field=MI_Uint64Field -_MI_Uint8A=MI_Uint8A -_MI_Uint8AField=MI_Uint8AField -_MI_Uint8Field=MI_Uint8Field -_MI_UserCredentials=MI_UserCredentials -_MI_UsernamePasswordCreds=MI_UsernamePasswordCreds -_MI_UtilitiesFT=MI_UtilitiesFT -_MI_Value=MI_Value -XAPO_LOCKFORPROCESS_BUFFER_PARAMETERS=XAPO_LOCKFORPROCESS_PARAMETERS -__MIDL___MIDL_itf_xpsdigitalsignature_0000_0000_0003=XPS_SIGN_FLAGS -__MIDL___MIDL_itf_xpsdigitalsignature_0000_0000_0002=XPS_SIGN_POLICY -__MIDL___MIDL_itf_xpsdigitalsignature_0000_0000_0001=XPS_SIGNATURE_STATUS -__MIDL___MIDL_itf_xpsobjectmodel_0000_0000_0002=XPS_COLOR_INTERPOLATION -__MIDL___MIDL_itf_xpsobjectmodel_0000_0000_0009=XPS_COLOR_TYPE -__MIDL___MIDL_itf_xpsobjectmodel_0000_0000_0006=XPS_DASH_CAP -__MIDL___MIDL_itf_xpsobjectmodel_0000_0000_0010=XPS_FILL_RULE -__MIDL___MIDL_itf_xpsobjectmodel_0000_0000_0013=XPS_FONT_EMBEDDING -__MIDL___MIDL_itf_xpsobjectmodel_0000_0000_0008=XPS_IMAGE_TYPE -__MIDL___MIDL_itf_xpsobjectmodel_0000_0000_0016=XPS_INTERLEAVING -__MIDL___MIDL_itf_xpsobjectmodel_0000_0000_0005=XPS_LINE_CAP -__MIDL___MIDL_itf_xpsobjectmodel_0000_0000_0007=XPS_LINE_JOIN -__MIDL___MIDL_itf_xpsobjectmodel_0000_0000_0014=XPS_OBJECT_TYPE -__MIDL___MIDL_itf_xpsobjectmodel_0000_0000_0012=XPS_SEGMENT_STROKE_PATTERN -__MIDL___MIDL_itf_xpsobjectmodel_0000_0000_0011=XPS_SEGMENT_TYPE -__MIDL___MIDL_itf_xpsobjectmodel_0000_0000_0003=XPS_SPREAD_METHOD -__MIDL___MIDL_itf_xpsobjectmodel_0000_0000_0004=XPS_STYLE_SIMULATION -__MIDL___MIDL_itf_xpsobjectmodel_0000_0000_0015=XPS_THUMBNAIL_SIZE -__MIDL___MIDL_itf_xpsobjectmodel_0000_0000_0001=XPS_TILE_MODE -__MIDL___MIDL_itf_xpsobjectmodel_0000_0000_0024=XPS_COLOR -__MIDL___MIDL_itf_xpsobjectmodel_0000_0000_0020=XPS_DASH -__MIDL___MIDL_itf_xpsobjectmodel_0000_0000_0022=XPS_GLYPH_MAPPING -__MIDL___MIDL_itf_xpsobjectmodel_0000_0000_0023=XPS_MATRIX -__MIDL___MIDL_itf_xpsobjectmodel_0000_0000_0017=XPS_POINT -__MIDL___MIDL_itf_xpsobjectmodel_0000_0000_0019=XPS_RECT -__MIDL___MIDL_itf_xpsobjectmodel_0000_0000_0018=XPS_SIZE -__MIDL___MIDL_itf_xpsobjectmodel_1_0000_0000_0001=XPS_DOCUMENT_TYPE -__MIDL___MIDL_itf_xpsprint_0000_0000_0001=XPS_JOB_COMPLETION -__MIDL___MIDL_itf_xpsprint_0000_0000_0002=XPS_JOB_STATUS -_IGMPV3_REPORT_HEADER_=IGMPV3_REPORT_HEADER -_D3DPRESENT_PARAMETERS_=D3DPRESENT_PARAMETERS -waveopendesc_tag=WAVEOPENDESC OLD_LARGE_INTEGER=long GetObjectA=GetObject __MIDL___MIDL_itf_amstream_0000_0000_0001=AMMSF_MMS_INIT_FLAGS __MIDL___MIDL_itf_amstream_0000_0000_0002=AMMSF_MS_FLAGS __MIDL___MIDL_itf_amstream_0000_0000_0003=AMMSF_RENDER_FLAGS -__MIDL___MIDL_itf_amstream_0000_0000_0004=OUTPUT_STATE -__MIDL___MIDL_itf_mpeg2structs_0000_0000_0001=PID_BITS_MIDL -__MIDL___MIDL_itf_mpeg2structs_0000_0000_0002=MPEG_HEADER_BITS_MIDL -__MIDL___MIDL_itf_mpeg2structs_0000_0000_0003=MPEG_HEADER_VERSION_BITS_MIDL -__MIDL___MIDL_itf_mpeg2structs_0000_0000_0004=MPEG_CURRENT_NEXT_BIT -__MIDL___MIDL_itf_mpeg2structs_0000_0000_0005=TID_EXTENSION -__MIDL___MIDL_itf_mpeg2structs_0000_0000_0033=MPEG_SERVICE_REQUEST -__MIDL___MIDL_itf_mpeg2structs_0000_0000_0034=MPEG_SERVICE_RESPONSE __MIDL___MIDL_itf_strmif_0000_0023_0001=REG_PINFLAG -__MIDL___MIDL_itf_bdaiface_0000_0019_0001=KSPROPERTY_IPSINK __MIDL___MIDL_itf_ddstream_0000_0000_0001=DDSFF_FLAGS -__MIDL___MIDL_itf_dvbsiparser_0000_0000_0001=DVB_STRCONV_MODE -__MIDL___MIDL_itf_dvbsiparser_0000_0022_0001=CRID_LOCATION -__MIDL___MIDL_itf_dvbsiparser_0000_0036_0001=DESC_LINKAGE_TYPE -__MIDL___MIDL_itf_encdec_0000_0000_0001=WMDRMProtectionInfo -__MIDL___MIDL_itf_encdec_0000_0000_0002=BadSampleInfo -__MIDL___MIDL_itf_mmstream_0000_0000_0003=COMPLETION_STATUS_FLAGS __MIDL___MIDL_itf_mmstream_0000_0000_0004=MMSSF_GET_INFORMATION_FLAGS __MIDL___MIDL_itf_mmstream_0000_0000_0005=SSUPDATE_TYPE __MIDL___MIDL_itf_sbe_0000_0001_0001=RECORDING_TYPE @@ -11010,41 +492,10 @@ __MIDL___MIDL_itf_strmif_0000_0026_0002=ADVISE_TYPE __MIDL___MIDL_itf_strmif_0000_0122_0001=STREAMIF_CONSTANTS __MIDL___MIDL_itf_tuner_0000_0000_0001=DISPID_TUNER __MIDL_IFilterMapper_0001=IFILTERMAPPER_MERIT -__MIDL_IPAT_0001=ProgramElement -_aviextheader=AVIEXTHEADER -_avifieldindex_chunk=AVIFIELDINDEX -_avitcdlindex_entry=AVITCDLINDEX_ENTRY -_avitimecodeindex=AVITIMECODEINDEX -_avitimedindex_entry=AVITIMEDINDEX_ENTRY -_BdaLockType=BDA_LockType -_BdaSignalType=BDA_SignalType -_riffchunk=RIFFCHUNK -_rifflist=RIFFLIST -_timecodedata=TIMECODEDATA -__MIDL_IAssemblyName_0002=ASM_BIND_FLAGS -__MIDL_IPrint_0001=PRINTFLAG __MIDL_IInternetZoneManager_0001=INET_ZONE_MANAGER_CONSTANTS -__MIDL___MIDL_itf_autosvcs_0001_0159_0001=LockModes -__MIDL___MIDL_itf_autosvcs_0001_0159_0002=ReleaseModes __MIDL___MIDL_itf_autosvcs_0001_0150_0001=AutoSvcs_Error_Constants -__MIDL___MIDL_itf_audioengineendpoint_0000_0000_0001=EndpointConnectorType -__MIDL___MIDL_itf_activprof_0000_0000_0001=PROFILER_SCRIPT_TYPE -__MIDL___MIDL_itf_activprof_0000_0000_0002=PROFILER_EVENT_MASK __MIDL___MIDL_itf_dbgprop_0000_0000_0002=DBGPROP_INFO -__MIDL___MIDL_itf_activprof_0000_0002_0003=PROFILER_HEAP_OBJECT_RELATIONSHIP_FLAGS -__MIDL___MIDL_itf_activprof_0000_0002_0004=PROFILER_HEAP_ENUM_FLAGS -__MIDL___MIDL_itf_activprof_0000_0004_0001=PROFILER_HEAP_SUMMARY_VERSION -__MIDL___MIDL_itf_activprof_0000_0002_0005=PROFILER_RELATIONSHIP_INFO -__MIDL___MIDL_itf_activprof_0000_0002_0002=PROFILER_HEAP_OBJECT_OPTIONAL_INFO_TYPE -__MIDL___MIDL_itf_activprof_0000_0002_0001=PROFILER_HEAP_OBJECT_FLAGS __MIDL___MIDL_itf_dbgprop_0000_0000_0001=DBGPROP_ATTRIB_FLAGS -__MIDL___MIDL_itf_gpmgmt_0000_0000_0005=GPMReportType -__MIDL___MIDL_itf_gpmgmt_0000_0000_0007=GPMDestinationOption -__MIDL_IGPMSOM_0001=GPMSOMType -__MIDL___MIDL_itf_gpmgmt_0000_0000_0006=GPMEntryType -__MIDL___MIDL_itf_gpmgmt_0000_0000_0004=GPMSearchOperation -__MIDL___MIDL_itf_gpmgmt_0000_0000_0001=GPMRSOPMode -__MIDL___MIDL_itf_inkrenderer_0000_0000_0001=INK_HIGH_CONTRAST_ADJUSTMENT __MIDL___MIDL_itf_dxva2api_0000_0000_0005=DXVA2_NoiseFilterTech __MIDL___MIDL_itf_dxva2api_0000_0000_0007=DXVA2_ProcAmp __MIDL___MIDL_itf_dxva2api_0000_0000_0009=DXVA2_VPDev @@ -11078,26 +529,10 @@ __MIDL___MIDL_itf_mmc_0000_0006_0001=CCM_INSERTIONPOINTID __MIDL___MIDL_itf_mmc_0000_0006_0003=CCM_COMMANDID_MASK_CONSTANTS __MIDL___MIDL_itf_mmc_0000_0006_0004=CCM_SPECIAL __MIDL___MIDL_itf_wsdxml_0000_0000_0001=WSDXML_OP -__MIDL_IRemoteDesktopClient_0001=KeyCombinationType -__MIDL_IRemoteDesktopClientSettings_0001=PasswordEncodingType -__MIDL___MIDL_itf_tsgpolicyengine_0000_0000_0006=AATrustClassID -__MIDL___MIDL_itf_tsgpolicyengine_0000_0000_0004=SESSION_TIMEOUT_ACTION_TYPE -__MIDL___MIDL_itf_identityprovider_0000_0003_0002=ACCOUNT_STATE -__MIDL___MIDL_itf_identityprovider_0000_0003_0001=IDENTITY_URL -__MIDL_IHlinkSite_0001=HLINKWHICHMK __MIDL_IHlinkBrowseContext_0002=HLBWIF_FLAGS __MIDL_IHlinkBrowseContext_0003=HLID_INFO __MIDL_IHlinkBrowseContext_0004=HLQF_INFO -__MIDL___MIDL_itf_dimm_0000_0000_0014=IMEINFO -__MIDL___MIDL_itf_dimm_0000_0000_0012=INPUTCONTEXT __MIDL_IHlinkBrowseContext_0001=HLTB_INFO -__MIDL_IHlink_0001=HLNF -__MIDL_IHlink_0002=HLINKGETREF -__MIDL_IHlink_0003=HLFNAMEF -__MIDL_IHlink_0004=HLINKMISC -__MIDL_IHlink_0005=HLINKSETF -__MIDL___MIDL_itf_vsmgmt_0000_0000_0001=VSS_MGMT_OBJECT_UNION -__MIDL___MIDL_itf_vss_0000_0000_0001=VSS_OBJECT_UNION __MIDL___MIDL_itf_wmsdkidl_0000_0000_0001=WEBSTREAM_SAMPLE_TYPE __MIDL___MIDL_itf_wmsdkidl_0000_0000_0002=WM_SF_TYPE __MIDL___MIDL_itf_wmsdkidl_0000_0000_0003=WM_SFEX_TYPE @@ -11105,47 +540,21 @@ __MIDL___MIDL_itf_wmsdkidl_0000_0000_0004=WM_DM_INTERLACED_TYPE __MIDL___MIDL_itf_wmsdkidl_0000_0000_0005=WM_DM_IT_FIRST_FRAME_COHERENCY __MIDL___MIDL_itf_wmsdkidl_0000_0000_0006=WM_PLAYBACK_DRC_LEVEL __MIDL___MIDL_itf_wmsdkidl_0000_0000_0007=WMT_TIMECODE_FRAMERATE -__MIDL___MIDL_itf_winsync_0000_0036_0001=FILTER_COMBINATION_TYPE -__MIDL___MIDL_itf_winsync_0000_0000_0010=CONSTRAINT_CONFLICT_REASON -__MIDL___MIDL_itf_winsync_0000_0000_0009=SYNC_CONSTRAINT_RESOLVE_ACTION -__MIDL___MIDL_itf_winsatcominterfacei_0000_0000_0001=WINSAT_OEM_CUSTOMIZATION_STATE __MIDL___MIDL_itf_xpsobjectmodel_0000_0000_0028=XPS_COLOR_VALUE -tag_WBEM_BATCH_TYPE=WBEM_BATCH_TYPE -tag_WBEM_EXTRA_RETURN_CODES=WBEM_EXTRA_RETURN_CODES tag_WBEM_GET_KEY_FLAGS=WBEM_GET_KEY_FLAGS tag_WBEM_GET_TEXT_FLAGS=WBEM_GET_TEXT_FLAGS -tag_WBEM_INFORMATION_FLAG_TYPE=WBEM_INFORMATION_FLAG_TYPE -tag_WBEM_LIMITATION_FLAG_TYPE=WBEM_LIMITATION_FLAG_TYPE tag_WBEM_PATH_CREATE_FLAG=WBEM_PATH_CREATE_FLAG tag_WBEM_PATH_STATUS_FLAG=WBEM_PATH_STATUS_FLAG -tag_WBEM_PROVIDER_FLAGS=WBEM_PROVIDER_FLAGS -tag_WBEM_PROVIDER_REQUIREMENTS_TYPE=WBEM_PROVIDER_REQUIREMENTS_TYPE -tag_WBEM_SHUTDOWN_FLAGS=WBEM_SHUTDOWN_FLAGS -tag_WBEMSTATUS_FORMAT=WBEMSTATUS_FORMAT -tag_WMIQ_LANGUAGE_FEATURES=WMIQ_LANGUAGE_FEATURES tagAM_MEDIAEVENT_FLAGS=AM_MEDIAEVENT_FLAGS tagAM_SAMPLE_PROPERTY_FLAGS=AM_SAMPLE_PROPERTY_FLAGS tagBANDSITECID=BANDSITECID -tagBREAKRESUME_ACTION=BREAKRESUMEACTION tagCDBURNINGEXTENSIONRET=CDBURNINGEXTENSIONRET -tagCONVERT_A=JET_CONVERT_A -tagCONVERT_W=JET_CONVERT_W tagDESKBANDCID=DESKBANDCID tagExtendedHeapRestrictions=ExtendedHeapRestrictions -tagKS_AnalogVideoInfo=KS_ANALOGVIDEOINFO -tagKS_MPEAUDIOINFO=KS_MPEGAUDIOINFO tagMENUBANDHANDLERCID=MENUBANDHANDLERCID tagMENUPOPUPPOPUPFLAGS=MENUPOPUPPOPUPFLAGS tagMENUPOPUPSELECT=MENUPOPUPSELECT -tagMxdcPrintTicketEscape=MXDC_PRINTTICKET_ESCAPE_T -tagMxdcPrintTicketPassthrough=MXDC_PRINTTICKET_DATA_T -tagMxdcS0PageData=MXDC_S0PAGE_DATA_T -tagMxdcS0PageEnums=MXDC_S0_PAGE_ENUMS -tagMxdcS0PagePassthroughEscape=MXDC_S0PAGE_PASSTHROUGH_ESCAPE_T -tagMxdcS0PageResourceEscape=MXDC_S0PAGE_RESOURCE_ESCAPE_T -tagMxdcXpsS0PageResource=MXDC_XPS_S0PAGE_RESOURCE_T tagNTExtendedHeapRestrictions=NTExtendedHeapRestrictions -tagOBJECT_ATTRIB_FLAG=OBJECT_ATTRIB_FLAGS tagOPEN_AS_INFO_FLAGS=OPEN_AS_INFO_FLAGS tagPRIORITIZE_FLAGS=PRIORITIZE_FLAGS tagPROPVAR_CHANGE_FLAGS=PROPVAR_CHANGE_FLAGS @@ -11206,122 +615,22 @@ tagSMINFOMASK=SMINFOMASK tagSMINFOTYPE=SMINFOTYPE tagSORTDIRECTION=SORTDIRECTION tagTLENUM=TLENUMF -tACMFILTERTAGDETAILSA=ACMFILTERTAGDETAILSA -tACMFILTERTAGDETAILSW=ACMFILTERTAGDETAILSW -tACMFORMATTAGDETAILSA=ACMFORMATTAGDETAILSA -tACMFORMATTAGDETAILSW=ACMFORMATTAGDETAILSW -tag_JET_COLUMNCREATE_A=JET_COLUMNCREATE_A -tag_JET_COLUMNCREATE_W=JET_COLUMNCREATE_W -tag_JET_USERDEFINEDDEFAULT_A=JET_USERDEFINEDDEFAULT_A -tag_JET_USERDEFINEDDEFAULT_W=JET_USERDEFINEDDEFAULT_W -tag_KS_TRUECOLORINFO=KS_TRUECOLORINFO -tag_SWbemAnalysisMatrix=SWbemAnalysisMatrix -tag_SWbemAnalysisMatrixList=SWbemAnalysisMatrixList -tag_SWbemRpnConst=SWbemRpnConst -tag_SWbemRpnTokenList=SWbemRpnTokenList tagTLENUMF=TLENUMF -_tagSubscriptionInfo=SUBSCRIPTIONINFO -__OPAQUECOMMAND=OPAQUECOMMAND -__WMDMID=WMDMID -__WMDMRIGHTS=WMDMRIGHTS -__WMDMMetadataView=WMDMMetadataView -__GENERIC_BINDING_INFO=GENERIC_BINDING_INFO tag_IdentityUpdateEvent=IdentityUpdateEvent -timerevent_tag=TIMEREVENT PRTM_ENTITY_EXPORT_METHOD=RTM_ENTITY_EXPORT_METHOD* -_MIDL_SERVER_INFO_=MIDL_SERVER_INFO WAITORTIMERCALLBACKFUNC=WAITORTIMERCALLBACK -_D3DCOLORVALUE=D3DCOLORVALUE -_REARRANGE_FILE_DATA32=REARRANGE_FILE_DATA32 -_MOVE_FILE_DATA32=MOVE_FILE_DATA32 -_DUPLICATE_EXTENTS_DATA32=DUPLICATE_EXTENTS_DATA32 -_DUPLICATE_EXTENTS_DATA_EX32=DUPLICATE_EXTENTS_DATA_EX32 -_DFS_INFO_1_32=DFS_INFO_1_32 -_DFS_INFO_2_32=DFS_INFO_2_32 -_DFS_STORAGE_INFO_0_32=DFS_STORAGE_INFO_0_32 -_DFS_INFO_3_32=DFS_INFO_3_32 -_DFS_INFO_4_32=DFS_INFO_4_32 -_SCSI_PASS_THROUGH32=SCSI_PASS_THROUGH32 -_SCSI_PASS_THROUGH_DIRECT32=SCSI_PASS_THROUGH_DIRECT32 -_SCSI_PASS_THROUGH32_EX=SCSI_PASS_THROUGH32_EX -_SCSI_PASS_THROUGH_DIRECT32_EX=SCSI_PASS_THROUGH_DIRECT32_EX -_ATA_PASS_THROUGH_EX32=ATA_PASS_THROUGH_EX32 -_ATA_PASS_THROUGH_DIRECT32=ATA_PASS_THROUGH_DIRECT32 -_MPIO_PASS_THROUGH_PATH32=MPIO_PASS_THROUGH_PATH32 -_MPIO_PASS_THROUGH_PATH_DIRECT32=MPIO_PASS_THROUGH_PATH_DIRECT32 -_MPIO_PASS_THROUGH_PATH32_EX=MPIO_PASS_THROUGH_PATH32_EX -_MPIO_PASS_THROUGH_PATH_DIRECT32_EX=MPIO_PASS_THROUGH_PATH_DIRECT32_EX -_DXVA_VideoSample32=DXVA_VideoSample32 -_DXVA_DeinterlaceBltEx32=DXVA_DeinterlaceBltEx32 -_VDMCONTEXT=VDMCONTEXT -_VDMLDT_ENTRY=VDMLDT_ENTRY DXGI_RGBA=DXGI_RGBA___ DWRITE_COLOR_F=DWRITE_COLOR_F___ D2D_COLOR_F=D2D_COLOR_F___ D2D1_COLOR_F=D2D1_COLOR_F___ -_SPAUDIOSTATE=SPAUDIOSTATE -tagSPTEXTSELECTIONINFO=SPTEXTSELECTIONINFO -tagSPPROPERTYINFO=SPPROPERTYINFO -__PUBLIC_OBJECT_TYPE_INFORMATION=PUBLIC_OBJECT_TYPE_INFORMATION -_CabInfoA=CABINFOA -_CabInfoW=CABINFOW -_GlobalFilter=GLOBAL_FILTER -_PfForwardAction=PFFORWARD_ACTION -_PfAddresType=PFADDRESSTYPE -_PfFrameType=PFFRAMETYPE -_pfLogFrame=PFLOGFRAME _WHV_PROCESSOR_XSAVE_FEATURES=WHV_PROCESSOR_XSAVE_FEATURES _WHV_HYPERCALL_CONTEXT=WHV_HYPERCALL_CONTEXT -tACMDRIVERDETAILSA=ACMDRIVERDETAILSA -tACMDRIVERDETAILSW=ACMDRIVERDETAILSW -tACMFILTERCHOOSEA=ACMFILTERCHOOSEA -tACMFILTERCHOOSEW=ACMFILTERCHOOSEW -tACMFILTERDETAILSA=ACMFILTERDETAILSA -tACMFILTERDETAILSW=ACMFILTERDETAILSW -tACMFORMATCHOOSEA=ACMFORMATCHOOSEA -tACMFORMATCHOOSEW=ACMFORMATCHOOSEW -tACMFORMATDETAILSA=ACMFORMATDETAILSA tACMFORMATDETAILSW=tACMFORMATDETAILSW sockaddr_storage=SOCKADDR_STORAGE sockaddr_in6=SOCKADDR_IN6 SOCKADDR_IN6_LH=SOCKADDR_IN6 -sockaddr_storage_xp=SOCKADDR_STORAGE_XP SOCKADDR_STORAGE_LH=SOCKADDR_STORAGE -sockaddr_in6_w2ksp1=SOCKADDR_IN6_W2KSP1 -ip_mreq=IP_MREQ -ip_mreq_source=IP_MREQ_SOURCE -ip_msfilter=IP_MSFILTER -group_filter=GROUP_FILTER -group_req=GROUP_REQ -group_source_req=GROUP_SOURCE_REQ -in_pktinfo=IN_PKTINFO -in6_pktinfo=IN6_PKTINFO -in_pktinfo_ex=IN_PKTINFO_EX -icmp_error_info=ICMP_ERROR_INFO in_addr=IN_ADDR -in_recverr=IN_RECVERR -in6_addr=IN6_ADDR -ipv6_mreq=IPV6_MREQ -sockaddr_dl=SOCKADDR_DL -sockaddr_in=SOCKADDR_IN -__NCRYPT_UI_POLICY=NCRYPT_UI_POLICY -__NCRYPT_KEY_ACCESS_POLICY_BLOB=NCRYPT_KEY_ACCESS_POLICY_BLOB -__NCRYPT_SUPPORTED_LENGTHS=NCRYPT_SUPPORTED_LENGTHS -__NCRYPT_PCP_HMAC_AUTH_SIGNATURE_INFO=NCRYPT_PCP_HMAC_AUTH_SIGNATURE_INFO -__NCRYPT_PCP_TPM_FW_VERSION_INFO=NCRYPT_PCP_TPM_FW_VERSION_INFO -__NCRYPT_PCP_RAW_POLICYDIGEST=NCRYPT_PCP_RAW_POLICYDIGEST_INFO -_DEDUP_CHUNK_INFO_HASH32=DEDUP_CHUNK_INFO_HASH32 -_DedupDataPortManagerOption=DedupDataPortManagerOption -_DedupDataPortVolumeStatus=DedupDataPortVolumeStatus -_DedupDataPortRequestStatus=DedupDataPortRequestStatus -_DedupChunkFlags=DedupChunkFlags -_DedupHash=DedupHash -_DedupChunk=DedupChunk -_DedupStreamEntry=DedupStreamEntry -_DedupStream=DedupStream -_DedupChunkingAlgorithm=DedupChunkingAlgorithm -_DedupHashingAlgorithm=DedupHashingAlgorithm -_DedupCompressionAlgorithm=DedupCompressionAlgorithm _DEDUP_SET_PARAM_TYPE=DEDUP_SET_PARAM_TYPE PUINT_PTR=UIntPtr* PULONG_PTR=UIntPtr* @@ -11342,885 +651,34 @@ DB_LRESERVE=IntPtr DB_URESERVE=UIntPtr TAPIHWND=IntPtr _NEON128=NEON128 -_DEBUG_OFFSET_REGION=DEBUG_OFFSET_REGION -_DEBUG_READ_USER_MINIDUMP_STREAM=DEBUG_READ_USER_MINIDUMP_STREAM -_DEBUG_GET_TEXT_COMPLETIONS_IN=DEBUG_GET_TEXT_COMPLETIONS_IN -_DEBUG_GET_TEXT_COMPLETIONS_OUT=DEBUG_GET_TEXT_COMPLETIONS_OUT -_DEBUG_CACHED_SYMBOL_INFO=DEBUG_CACHED_SYMBOL_INFO -_PROCESS_NAME_ENTRY=PROCESS_NAME_ENTRY -_DEBUG_THREAD_BASIC_INFORMATION=DEBUG_THREAD_BASIC_INFORMATION -_SYMBOL_INFO_EX=SYMBOL_INFO_EX -_DEBUG_BREAKPOINT_PARAMETERS=DEBUG_BREAKPOINT_PARAMETERS -_DEBUG_CREATE_PROCESS_OPTIONS=DEBUG_CREATE_PROCESS_OPTIONS -_DEBUG_CLIENT_CONTEXT=DEBUG_CLIENT_CONTEXT -_DEBUG_STACK_FRAME=DEBUG_STACK_FRAME -_DEBUG_STACK_FRAME_EX=DEBUG_STACK_FRAME_EX -_INLINE_FRAME_CONTEXT=INLINE_FRAME_CONTEXT -_STACK_SRC_INFO=STACK_SRC_INFO -_STACK_SYM_FRAME_INFO=STACK_SYM_FRAME_INFO -_DEBUG_SPECIFIC_FILTER_PARAMETERS=DEBUG_SPECIFIC_FILTER_PARAMETERS -_DEBUG_EXCEPTION_FILTER_PARAMETERS=DEBUG_EXCEPTION_FILTER_PARAMETERS -_DEBUG_LAST_EVENT_INFO_BREAKPOINT=DEBUG_LAST_EVENT_INFO_BREAKPOINT -_DEBUG_LAST_EVENT_INFO_EXCEPTION=DEBUG_LAST_EVENT_INFO_EXCEPTION -_DEBUG_LAST_EVENT_INFO_EXIT_THREAD=DEBUG_LAST_EVENT_INFO_EXIT_THREAD -_DEBUG_LAST_EVENT_INFO_EXIT_PROCESS=DEBUG_LAST_EVENT_INFO_EXIT_PROCESS -_DEBUG_LAST_EVENT_INFO_LOAD_MODULE=DEBUG_LAST_EVENT_INFO_LOAD_MODULE -_DEBUG_LAST_EVENT_INFO_UNLOAD_MODULE=DEBUG_LAST_EVENT_INFO_UNLOAD_MODULE -_DEBUG_LAST_EVENT_INFO_SYSTEM_ERROR=DEBUG_LAST_EVENT_INFO_SYSTEM_ERROR -_DEBUG_LAST_EVENT_INFO_SERVICE_EXCEPTION=DEBUG_LAST_EVENT_INFO_SERVICE_EXCEPTION -_DEBUG_VALUE=DEBUG_VALUE -_DEBUG_PROCESSOR_IDENTIFICATION_ALPHA=DEBUG_PROCESSOR_IDENTIFICATION_ALPHA -_DEBUG_PROCESSOR_IDENTIFICATION_AMD64=DEBUG_PROCESSOR_IDENTIFICATION_AMD64 -_DEBUG_PROCESSOR_IDENTIFICATION_IA64=DEBUG_PROCESSOR_IDENTIFICATION_IA64 -_DEBUG_PROCESSOR_IDENTIFICATION_X86=DEBUG_PROCESSOR_IDENTIFICATION_X86 -_DEBUG_PROCESSOR_IDENTIFICATION_ARM=DEBUG_PROCESSOR_IDENTIFICATION_ARM -_DEBUG_PROCESSOR_IDENTIFICATION_ARM64=DEBUG_PROCESSOR_IDENTIFICATION_ARM64 -_DEBUG_PROCESSOR_IDENTIFICATION_ALL=DEBUG_PROCESSOR_IDENTIFICATION_ALL -_DEBUG_HANDLE_DATA_BASIC=DEBUG_HANDLE_DATA_BASIC -_DEBUG_EVENT_CONTEXT=DEBUG_EVENT_CONTEXT -_DEBUG_REGISTER_DESCRIPTION=DEBUG_REGISTER_DESCRIPTION -_DEBUG_SYMBOL_PARAMETERS=DEBUG_SYMBOL_PARAMETERS -_DEBUG_SYMBOL_ENTRY=DEBUG_SYMBOL_ENTRY -_DEBUG_MODULE_PARAMETERS=DEBUG_MODULE_PARAMETERS -_DEBUG_MODULE_AND_ID=DEBUG_MODULE_AND_ID -_DEBUG_SYMBOL_SOURCE_ENTRY=DEBUG_SYMBOL_SOURCE_ENTRY -_EXTSTACKTRACE=EXTSTACKTRACE -_EXTSTACKTRACE32=EXTSTACKTRACE32 -_EXTSTACKTRACE64=EXTSTACKTRACE64 -_WINDBG_EXTENSION_APIS=WINDBG_EXTENSION_APIS -_WINDBG_EXTENSION_APIS32=WINDBG_EXTENSION_APIS32 -_WINDBG_EXTENSION_APIS64=WINDBG_EXTENSION_APIS64 -_WINDBG_OLD_EXTENSION_APIS=WINDBG_OLD_EXTENSION_APIS -_WINDBG_OLDKD_EXTENSION_APIS=WINDBG_OLDKD_EXTENSION_APIS -_PROCESSORINFO=PROCESSORINFO -_READCONTROLSPACE=READCONTROLSPACE -_READCONTROLSPACE32=READCONTROLSPACE32 -_READCONTROLSPACE64=READCONTROLSPACE64 -_IOSPACE=IOSPACE -_IOSPACE32=IOSPACE32 -_IOSPACE64=IOSPACE64 -_IOSPACE_EX=IOSPACE_EX -_IOSPACE_EX32=IOSPACE_EX32 -_IOSPACE_EX64=IOSPACE_EX64 -_SEARCHMEMORY=SEARCHMEMORY -_PHYSICAL=PHYSICAL -_PHYSICAL_WITH_FLAGS=PHYSICAL_WITH_FLAGS -_READ_WRITE_MSR=READ_WRITE_MSR -_GET_SET_SYMPATH=GET_SET_SYMPATH -_GET_TEB_ADDRESS=GET_TEB_ADDRESS -_GET_PEB_ADDRESS=GET_PEB_ADDRESS -_GET_CURRENT_THREAD_ADDRESS=GET_CURRENT_THREAD_ADDRESS -_GET_CURRENT_PROCESS_ADDRESS=GET_CURRENT_PROCESS_ADDRESS -_GET_INPUT_LINE=GET_INPUT_LINE -_GET_EXPRESSION_EX=GET_EXPRESSION_EX -_TRANSLATE_VIRTUAL_TO_PHYSICAL=TRANSLATE_VIRTUAL_TO_PHYSICAL -_VIRTUAL_TO_PHYSICAL=VIRTUAL_TO_PHYSICAL -_PHYSICAL_TO_VIRTUAL=PHYSICAL_TO_VIRTUAL -_GET_CONTEXT_EX=GET_CONTEXT_EX -_POINTER_SEARCH_PHYSICAL=POINTER_SEARCH_PHYSICAL -_WDBGEXTS_THREAD_OS_INFO=WDBGEXTS_THREAD_OS_INFO -_WDBGEXTS_CLR_DATA_INTERFACE=WDBGEXTS_CLR_DATA_INTERFACE -_EXT_MATCH_PATTERN_A=EXT_MATCH_PATTERN_A -_EXT_FIND_FILE=EXT_FIND_FILE -_DEBUG_TYPED_DATA=DEBUG_TYPED_DATA -_EXT_TDOP=EXT_TDOP -_EXT_TYPED_DATA=EXT_TYPED_DATA -_WDBGEXTS_QUERY_INTERFACE=WDBGEXTS_QUERY_INTERFACE -_WDBGEXTS_DISASSEMBLE_BUFFER=WDBGEXTS_DISASSEMBLE_BUFFER -_WDBGEXTS_MODULE_IN_RANGE=WDBGEXTS_MODULE_IN_RANGE -_DBGKD_MAJOR_TYPES=DBGKD_MAJOR_TYPES -_DBGKD_GET_VERSION32=DBGKD_GET_VERSION32 -_DBGKD_DEBUG_DATA_HEADER32=DBGKD_DEBUG_DATA_HEADER32 -_KDDEBUGGER_DATA32=KDDEBUGGER_DATA32 -_DBGKD_GET_VERSION64=DBGKD_GET_VERSION64 -_DBGKD_DEBUG_DATA_HEADER64=DBGKD_DEBUG_DATA_HEADER64 -_KDDEBUGGER_DATA64=KDDEBUGGER_DATA64 -_FIELD_INFO=FIELD_INFO -_SYM_DUMP_PARAM=SYM_DUMP_PARAM -_PRINT_FEATURE_OPTION=PRINT_FEATURE_OPTION -tagSHIMOPTS=SHIMOPTS -tagPrintSchemaConstrainedSetting=PrintSchemaConstrainedSetting -tagPrintSchemaSelectionType=PrintSchemaSelectionType -tagPrintSchemaParameterDataType=PrintSchemaParameterDataType -tagPrintJobStatus=PrintJobStatus -_UNIFM_HDR=UNIFM_HDR -_INVOC=INVOC -_UNIDRVINFO=UNIDRVINFO -_PRINTIFI32=PRINTIFI32 -_EXTTEXTMETRIC=EXTTEXTMETRIC -_WIDTHRUN=WIDTHRUN -_WIDTHTABLE=WIDTHTABLE -_KERNDATA=KERNDATA -_UNI_GLYPHSETDATA=UNI_GLYPHSETDATA -_UNI_CODEPAGEINFO=UNI_CODEPAGEINFO -_GLYPHRUN=GLYPHRUN -_TRANSDATA=TRANSDATA -_MAPTABLE=MAPTABLE -_UFF_FILEHEADER=UFF_FILEHEADER -_UFF_FONTDIRECTORY=UFF_FONTDIRECTORY -_DATA_HEADER=DATA_HEADER -_OEMFONTINSTPARAM=OEMFONTINSTPARAM -_PORT_DATA_1=PORT_DATA_1 -_PORT_DATA_2=PORT_DATA_2 -_PORT_DATA_LIST_1=PORT_DATA_LIST_1 -_DELETE_PORT_DATA_1=DELETE_PORT_DATA_1 -_CONFIG_INFO_DATA_1=CONFIG_INFO_DATA_1 -_PRINTER_NOTIFY_INIT=PRINTER_NOTIFY_INIT -_SPLCLIENT_INFO_1=SPLCLIENT_INFO_1 -_SPLCLIENT_INFO_3_VISTA=SPLCLIENT_INFO_3_VISTA -_PRINTPROVIDOR=PRINTPROVIDOR -_PRINTPROCESSOROPENDATA=PRINTPROCESSOROPENDATA -_MONITORREG=MONITORREG -_MONITORINIT=MONITORINIT -_MONITOR=MONITOR -_MONITOREX=MONITOREX -_MONITOR2=MONITOR2 -_MONITORUI=MONITORUI -_NOTIFICATION_CALLBACK_COMMANDS=NOTIFICATION_CALLBACK_COMMANDS -_NOTIFICATION_CONFIG_1=NOTIFICATION_CONFIG_1 -_NOTIFICATION_CONFIG_FLAGS=NOTIFICATION_CONFIG_FLAGS -__MIDL___MIDL_itf_filterpipeline_0000_0000_0001=EXpsCompressionOptions -__MIDL___MIDL_itf_filterpipeline_0000_0000_0002=EXpsFontOptions -__MIDL___MIDL_itf_filterpipeline_0000_0000_0003=EXpsJobConsumption -__MIDL___MIDL_itf_filterpipeline_0000_0000_0004=EXpsFontRestriction -__MIDL___MIDL_itf_xpsrassvc_0000_0001_0001=XPSRAS_RENDERING_MODE -__MIDL___MIDL_itf_xpsrassvc_0000_0003_0001=XPSRAS_PIXEL_FORMAT -__MIDL___MIDL_itf_xpsrassvc_0000_0004_0001=XPSRAS_BACKGROUND_COLOR LPLDT_ENTRY=LDT_ENTRY* -__MIDL___MIDL_itf_windows2Eui2Examl2Ehosting2Ereferencetracker_0000_0004_0001=XAML_REFERENCETRACKER_DISCONNECT -channel_caps_tag=CHANNEL_CAPS -joycalibrate_tag=JOYCALIBRATE -joypos_tag=JOYPOS -joyrange_tag=JOYRANGE -joyreghwconfig_tag=JOYREGHWCONFIG -joyreguservalues_tag=JOYREGUSERVALUES -joyreghwsettings_tag=JOYREGHWSETTINGS -midiopenstrmid_tag=MIDIOPENSTRMID -tMIXEROPENDESC=MIXEROPENDESC _TASKDIALOG_FLAGS=TASKDIALOG_FLAGS _SIIGBF=SIIGBF -_SLIST_ENTRY=SLIST_ENTRY -_MARK_HANDLE_INFO32=MARK_HANDLE_INFO32 -_SYSTEM_SUPPORTED_PROCESSOR_ARCHITECTURES_INFORMATION=SYSTEM_SUPPORTED_PROCESSOR_ARCHITECTURES_INFORMATION -_FS_BPIO_OPERATIONS=FS_BPIO_OPERATIONS -_FS_BPIO_INFLAGS=FS_BPIO_INFLAGS -_FS_BPIO_INPUT=FS_BPIO_INPUT -_FS_BPIO_OUTFLAGS=FS_BPIO_OUTFLAGS -_FS_BPIO_RESULTS=FS_BPIO_RESULTS -_FS_BPIO_INFO=FS_BPIO_INFO -_FS_BPIO_OUTPUT=FS_BPIO_OUTPUT -tagKSCAMERA_EXTENDEDPROP_BACKGROUNDSEGMENTATION_CONFIGCAPS=KSCAMERA_EXTENDEDPROP_BACKGROUNDSEGMENTATION_CONFIGCAPS -tagKSCAMERA_METADATA_BACKGROUNDSEGMENTATIONMASK=KSCAMERA_METADATA_BACKGROUNDSEGMENTATIONMASK -_DNS_CUSTOM_SERVER=DNS_CUSTOM_SERVER -_DNS_QUERY_REQUEST3=DNS_QUERY_REQUEST3 -_DNS_APPLICATION_SETTINGS=DNS_APPLICATION_SETTINGS -tagCOMPOSITION_FRAME_STATS=COMPOSITION_FRAME_STATS -tagCOMPOSITION_STATS=COMPOSITION_STATS -tagCOMPOSITION_TARGET_STATS=COMPOSITION_TARGET_STATS -_DISPLAYCONFIG_GET_MONITOR_SPECIALIZATION=DISPLAYCONFIG_GET_MONITOR_SPECIALIZATION -_DISPLAYCONFIG_SET_MONITOR_SPECIALIZATION=DISPLAYCONFIG_SET_MONITOR_SPECIALIZATION -_HIDP_BUTTON_ARRAY_DATA=HIDP_BUTTON_ARRAY_DATA -_KERB_CLOUD_KERBEROS_DEBUG_REQUEST=KERB_CLOUD_KERBEROS_DEBUG_REQUEST -_KERB_CLOUD_KERBEROS_DEBUG_RESPONSE=KERB_CLOUD_KERBEROS_DEBUG_RESPONSE -_KERB_CLOUD_KERBEROS_DEBUG_DATA_V0=KERB_CLOUD_KERBEROS_DEBUG_DATA_V0 -_SecPkgCred_SessionTicketKey=SecPkgCred_SessionTicketKey -_SecPkgCred_SessionTicketKeys=SecPkgCred_SessionTicketKeys -_HTTP_TLS_SESSION_TICKET_KEYS_PARAM=HTTP_TLS_SESSION_TICKET_KEYS_PARAM -_SMB_TREE_CONNECT_PARAMETERS=SMB_TREE_CONNECT_PARAMETERS -_USE_OPTION_PROPERTIES=USE_OPTION_PROPERTIES -_MACHINE_ATTRIBUTES=MACHINE_ATTRIBUTES -_PROCESS_MACHINE_INFORMATION=PROCESS_MACHINE_INFORMATION -_WINHTTP_CONNECTION_GROUP=WINHTTP_CONNECTION_GROUP -_WINHTTP_HOST_CONNECTION_GROUP=WINHTTP_HOST_CONNECTION_GROUP -_WINHTTP_QUERY_CONNECTION_GROUP_RESULT=WINHTTP_QUERY_CONNECTION_GROUP_RESULT -_WINHTTP_HTTP2_RECEIVE_WINDOW=WINHTTP_HTTP2_RECEIVE_WINDOW -_WEBAUTHN_CRED_BLOB_EXTENSION=WEBAUTHN_CRED_BLOB_EXTENSION -_WINHTTP_URL_COMPONENTS=URL_COMPONENTS -_DSPROPERTY_DIRECTSOUNDDEVICE_WAVEDEVICEMAPPING_A_DATA=DSPROPERTY_DIRECTSOUNDDEVICE_WAVEDEVICEMAPPING_A_DATA -_DSPROPERTY_DIRECTSOUNDDEVICE_WAVEDEVICEMAPPING_W_DATA=DSPROPERTY_DIRECTSOUNDDEVICE_WAVEDEVICEMAPPING_W_DATA -_DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_1_DATA=DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_1_DATA -_DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_A_DATA=DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_A_DATA -_DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_W_DATA=DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_W_DATA -_DSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_1_DATA=DSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_1_DATA -_DSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_A_DATA=DSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_A_DATA -_DSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_W_DATA=DSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_W_DATA -tagCCSTYLEA=CCSTYLEA -tagCCSTYLEW=CCSTYLEW -tagCCSTYLEFLAGA=CCSTYLEFLAGA -tagCCSTYLEFLAGW=CCSTYLEFLAGW -tagCCINFOA=CCINFOA -tagCCINFOW=CCINFOW -_CREDSSP_CRED_EX=CREDSSP_CRED_EX -_APPLICATIONTYPE=APPLICATIONTYPE -_OLE_TM_CONFIG_PARAMS_V1=OLE_TM_CONFIG_PARAMS_V1 -_OLE_TM_CONFIG_PARAMS_V2=OLE_TM_CONFIG_PARAMS_V2 -_D3D9ON12_ARGS=D3D9ON12_ARGS -_INPUT_BUTTON_ENABLE_INFO=INPUT_BUTTON_ENABLE_INFO -tagHCN_PORT_PROTOCOL=HCN_PORT_PROTOCOL -tagHCN_PORT_ACCESS=HCN_PORT_ACCESS -tagHCN_PORT_RANGE_RESERVATION=HCN_PORT_RANGE_RESERVATION -tagHCN_PORT_RANGE_ENTRY=HCN_PORT_RANGE_ENTRY -_SOCKADDR_HV=SOCKADDR_HV -_HVSOCKET_ADDRESS_INFO=HVSOCKET_ADDRESS_INFO -_DOS_IMAGE_INFO=DOS_IMAGE_INFO -_MODULE_INFO=MODULE_INFO -_STI_DEVICE_MJ_TYPE=STI_DEVICE_MJ_TYPE -_STI_DEV_CAPS=STI_DEV_CAPS -_STI_DEVICE_INFORMATIONW=STI_DEVICE_INFORMATIONW -_STI_WIA_DEVICE_INFORMATIONW=STI_WIA_DEVICE_INFORMATIONW -_STI_DEVICE_STATUS=STI_DEVICE_STATUS -_STI_DIAG=STI_DIAG -_STISUBSCRIBE=STISUBSCRIBE -_STINOTIFY=STINOTIFY -_STI_USD_CAPS=STI_USD_CAPS -tagMIMECONTF=MIMECONTF -tagMIMECPINFO=MIMECPINFO -tagMIMECSETINFO=MIMECSETINFO -tagRFC1766INFO=RFC1766INFO -tagSCRIPTCONTF=SCRIPTCONTF -tagSCRIPTINFO=SCRIPTINFO -tagMLDETECTCP=MLDETECTCP -tagDetectEncodingInfo=DetectEncodingInfo -tagSCRIPTFONTCONTF=SCRIPTFONTCONTF -tagUNICODERANGE=UNICODERANGE -tagMLSTR_FLAGS=MLSTR_FLAGS -_VSC_VK=VSC_VK -_VK_VSC=VK_VSC -_VK_TO_WCHARS1=VK_TO_WCHARS1 -_VK_TO_WCHARS2=VK_TO_WCHARS2 -_VK_TO_WCHARS3=VK_TO_WCHARS3 -_VK_TO_WCHARS4=VK_TO_WCHARS4 -_VK_TO_WCHARS5=VK_TO_WCHARS5 -_VK_TO_WCHARS6=VK_TO_WCHARS6 -_VK_TO_WCHARS7=VK_TO_WCHARS7 -_VK_TO_WCHARS8=VK_TO_WCHARS8 -_VK_TO_WCHARS9=VK_TO_WCHARS9 -_VK_TO_WCHARS10=VK_TO_WCHARS10 -_VK_TO_WCHAR_TABLE=VK_TO_WCHAR_TABLE -_LIGATURE1=LIGATURE1 -_LIGATURE2=LIGATURE2 -_LIGATURE3=LIGATURE3 -_LIGATURE4=LIGATURE4 -_LIGATURE5=LIGATURE5 -tagKBDTABLE_DESC=KBDTABLE_DESC -tagKBDTABLE_MULTI=KBDTABLE_MULTI -tagKBD_TYPE_INFO=KBD_TYPE_INFO -tagNapTracingLevel=NapTracingLevel -_NDK_RDMA_TECHNOLOGY=NDK_RDMA_TECHNOLOGY -_DOT11_MSSECURITY_SETTINGS=DOT11_MSSECURITY_SETTINGS -_DOT11EXT_IHV_SSID_LIST=DOT11EXT_IHV_SSID_LIST -_DOT11EXT_IHV_PROFILE_PARAMS=DOT11EXT_IHV_PROFILE_PARAMS -_DOT11EXT_IHV_PARAMS=DOT11EXT_IHV_PARAMS -_DOT11EXT_APIS=DOT11EXT_APIS -_DOT11EXT_IHV_HANDLERS=DOT11EXT_IHV_HANDLERS -_DOT11EXT_VIRTUAL_STATION_APIS=DOT11EXT_VIRTUAL_STATION_APIS -_DOT11_IHV_VERSION_INFO=DOT11_IHV_VERSION_INFO -_DOT11EXT_IHV_CONNECTION_PHASE=DOT11EXT_IHV_CONNECTION_PHASE -_DOT11EXT_IHV_UI_REQUEST=DOT11EXT_IHV_UI_REQUEST -_DOT11_MSONEX_RESULT=DOT11_MSONEX_RESULT -_DOT11_EAP_RESULT=DOT11_EAP_RESULT -_DOT11_MSONEX_RESULT_PARAMS=DOT11_MSONEX_RESULT_PARAMS -_DOT11EXT_IHV_CONNECTIVITY_PROFILE=DOT11EXT_IHV_CONNECTIVITY_PROFILE -_DOT11EXT_IHV_SECURITY_PROFILE=DOT11EXT_IHV_SECURITY_PROFILE -_DOT11EXT_IHV_DISCOVERY_PROFILE=DOT11EXT_IHV_DISCOVERY_PROFILE -_DOT11EXT_IHV_DISCOVERY_PROFILE_LIST=DOT11EXT_IHV_DISCOVERY_PROFILE_LIST -_DOT11EXT_IHV_INDICATION_TYPE=DOT11EXT_IHV_INDICATION_TYPE -_DOT11EXT_VIRTUAL_STATION_AP_PROPERTY=DOT11EXT_VIRTUAL_STATION_AP_PROPERTY -_WDIAG_IHV_WLAN_ID=WDIAG_IHV_WLAN_ID -_DSKTLSYSTEMTIME=DSKTLSYSTEMTIME -_WINBIO_SENSOR_ATTRIBUTES=WINBIO_SENSOR_ATTRIBUTES -_WINBIO_DATA=WINBIO_DATA -_WINBIO_UPDATE_FIRMWARE=WINBIO_UPDATE_FIRMWARE -_WINBIO_CALIBRATION_INFO=WINBIO_CALIBRATION_INFO -_WINBIO_DIAGNOSTICS=WINBIO_DIAGNOSTICS -_WINBIO_BLANK_PAYLOAD=WINBIO_BLANK_PAYLOAD -_WINBIO_CAPTURE_PARAMETERS=WINBIO_CAPTURE_PARAMETERS -_WINBIO_CAPTURE_DATA=WINBIO_CAPTURE_DATA -_WINBIO_SUPPORTED_ALGORITHMS=WINBIO_SUPPORTED_ALGORITHMS -_WINBIO_GET_INDICATOR=WINBIO_GET_INDICATOR -_WINBIO_SET_INDICATOR=WINBIO_SET_INDICATOR -_WINBIO_PRIVATE_SENSOR_TYPE_INFO=WINBIO_PRIVATE_SENSOR_TYPE_INFO -_WINBIO_ENCRYPTED_CAPTURE_PARAMS=WINBIO_ENCRYPTED_CAPTURE_PARAMS -_WINBIO_NOTIFY_WAKE=WINBIO_NOTIFY_WAKE -_msidbLocatorType=msidbLocatorType -_msidbIniFileAction=msidbIniFileAction -_msidbODBCDataSourceRegistration=msidbODBCDataSourceRegistration -_tagTILE_TEMPLATE_TYPE=TILE_TEMPLATE_TYPE -_PM_APPLICATION_INSTALL_TYPE=PM_APPLICATION_INSTALL_TYPE -_PM_APPLICATION_STATE=PM_APPLICATION_STATE -_PM_APPLICATION_HUBTYPE=PM_APPLICATION_HUBTYPE -_PM_TILE_HUBTYPE=PM_TILE_HUBTYPE -_PM_STARTTILE_TYPE=PM_STARTTILE_TYPE -_tagPM_TASK_TYPE=PM_TASK_TYPE -_PACKMAN_RUNTIME=PACKMAN_RUNTIME -_PM_ACTIVATION_POLICY=PM_ACTIVATION_POLICY -_PM_TASK_TRANSITION=PM_TASK_TRANSITION -_tagPM_ENUM_APP_FILTER=PM_ENUM_APP_FILTER -_tagPM_ENUM_TILE_FILTER=PM_ENUM_TILE_FILTER -_tagPM_ENUM_TASK_FILTER=PM_ENUM_TASK_FILTER -_tagPM_ENUM_EXTENSION_FILTER=PM_ENUM_EXTENSION_FILTER -_tagPM_ENUM_BSA_FILTER=PM_ENUM_BSA_FILTER -_tagPM_ENUM_BW_FILTER=PM_ENUM_BW_FILTER -_tagPM_EXTENSIONCONSUMER=PM_EXTENSIONCONSUMER -_tagPM_BSATASKID=PM_BSATASKID -_tagPM_BWTASKID=PM_BWTASKID -_PM_ENUM_FILTER=PM_ENUM_FILTER -_tagPM_LIVETILE_RECURRENCE_TYPE=PM_LIVETILE_RECURRENCE_TYPE -_tagPM_TILE_SIZE=PM_TILE_SIZE -_tagPM_LOGO_SIZE=PM_LOGO_SIZE -_tagPM_STARTAPPBLOB=PM_STARTAPPBLOB -_tagPM_INVOCATIONINFO=PM_INVOCATIONINFO -_tagPM_STARTTILEBLOB=PM_STARTTILEBLOB -_tagPM_INSTALLINFO=PM_INSTALLINFO -_tagPM_UPDATEINFO_LEGACY=PM_UPDATEINFO_LEGACY -_tagPM_UPDATEINFO=PM_UPDATEINFO -_PATCH_IGNORE_RANGE=PATCH_IGNORE_RANGE -_PATCH_RETAIN_RANGE=PATCH_RETAIN_RANGE -_PATCH_OLD_FILE_INFO_A=PATCH_OLD_FILE_INFO_A -_PATCH_OLD_FILE_INFO_W=PATCH_OLD_FILE_INFO_W -_PATCH_OLD_FILE_INFO_H=PATCH_OLD_FILE_INFO_H -_PATCH_OLD_FILE_INFO=PATCH_OLD_FILE_INFO -_PATCH_INTERLEAVE_MAP=PATCH_INTERLEAVE_MAP -_PATCH_OPTION_DATA=PATCH_OPTION_DATA -_DELAYLOAD_PROC_DESCRIPTOR=DELAYLOAD_PROC_DESCRIPTOR -_DELAYLOAD_INFO=DELAYLOAD_INFO -_IMAGEHLP_STATUS_REASON=IMAGEHLP_STATUS_REASON -tagAPPLICATION_NODE_EVENT_FILTER=APPLICATION_NODE_EVENT_FILTER -tagTEXT_DOCUMENT_ARRAY=TEXT_DOCUMENT_ARRAY -tagSCRIPT_ERROR_DEBUG_EXCEPTION_THROWN_KIND=SCRIPT_ERROR_DEBUG_EXCEPTION_THROWN_KIND -tagSCRIPT_INVOCATION_CONTEXT_TYPE=SCRIPT_INVOCATION_CONTEXT_TYPE -tagDEBUG_STACKFRAME_TYPE=DEBUG_STACKFRAME_TYPE -tagDEBUG_EVENT_INFO_TYPE=DEBUG_EVENT_INFO_TYPE -tagJsDebugPropertyInfo=JsDebugPropertyInfo -_PHYSICAL_MEMORY_RUN32=PHYSICAL_MEMORY_RUN32 -_PHYSICAL_MEMORY_DESCRIPTOR32=PHYSICAL_MEMORY_DESCRIPTOR32 -_PHYSICAL_MEMORY_RUN64=PHYSICAL_MEMORY_RUN64 -_PHYSICAL_MEMORY_DESCRIPTOR64=PHYSICAL_MEMORY_DESCRIPTOR64 -_DUMP_FILE_ATTRIBUTES=DUMP_FILE_ATTRIBUTES -_DUMP_HEADER32=DUMP_HEADER32 -_DUMP_HEADER64=DUMP_HEADER64 -_WHEA_ERROR_SOURCE_TYPE=WHEA_ERROR_SOURCE_TYPE -_WHEA_ERROR_SOURCE_STATE=WHEA_ERROR_SOURCE_STATE -_WHEA_ERROR_SOURCE_CONFIGURATION_DD=WHEA_ERROR_SOURCE_CONFIGURATION_DD -_WHEA_ERROR_SOURCE_CONFIGURATION_DEVICE_DRIVER_V1=WHEA_ERROR_SOURCE_CONFIGURATION_DEVICE_DRIVER_V1 -_WHEA_ERROR_SOURCE_CONFIGURATION_DEVICE_DRIVER=WHEA_ERROR_SOURCE_CONFIGURATION_DEVICE_DRIVER -_WHEA_DRIVER_BUFFER_SET=WHEA_DRIVER_BUFFER_SET -_WHEA_NOTIFICATION_FLAGS=WHEA_NOTIFICATION_FLAGS -_XPF_MC_BANK_FLAGS=XPF_MC_BANK_FLAGS -_XPF_MCE_FLAGS=XPF_MCE_FLAGS -_AER_ROOTPORT_DESCRIPTOR_FLAGS=AER_ROOTPORT_DESCRIPTOR_FLAGS -_AER_ENDPOINT_DESCRIPTOR_FLAGS=AER_ENDPOINT_DESCRIPTOR_FLAGS -_AER_BRIDGE_DESCRIPTOR_FLAGS=AER_BRIDGE_DESCRIPTOR_FLAGS -_WHEA_NOTIFICATION_DESCRIPTOR=WHEA_NOTIFICATION_DESCRIPTOR -_WHEA_XPF_MC_BANK_DESCRIPTOR=WHEA_XPF_MC_BANK_DESCRIPTOR -_WHEA_XPF_MCE_DESCRIPTOR=WHEA_XPF_MCE_DESCRIPTOR -_WHEA_XPF_CMC_DESCRIPTOR=WHEA_XPF_CMC_DESCRIPTOR -_WHEA_PCI_SLOT_NUMBER=WHEA_PCI_SLOT_NUMBER -_WHEA_XPF_NMI_DESCRIPTOR=WHEA_XPF_NMI_DESCRIPTOR -_WHEA_AER_ROOTPORT_DESCRIPTOR=WHEA_AER_ROOTPORT_DESCRIPTOR -_WHEA_AER_ENDPOINT_DESCRIPTOR=WHEA_AER_ENDPOINT_DESCRIPTOR -_WHEA_AER_BRIDGE_DESCRIPTOR=WHEA_AER_BRIDGE_DESCRIPTOR -_WHEA_GENERIC_ERROR_DESCRIPTOR=WHEA_GENERIC_ERROR_DESCRIPTOR -_WHEA_GENERIC_ERROR_DESCRIPTOR_V2=WHEA_GENERIC_ERROR_DESCRIPTOR_V2 -_WHEA_DEVICE_DRIVER_DESCRIPTOR=WHEA_DEVICE_DRIVER_DESCRIPTOR -_WHEA_IPF_MCA_DESCRIPTOR=WHEA_IPF_MCA_DESCRIPTOR -_WHEA_IPF_CMC_DESCRIPTOR=WHEA_IPF_CMC_DESCRIPTOR -_WHEA_IPF_CPE_DESCRIPTOR=WHEA_IPF_CPE_DESCRIPTOR -_WHEA_ERROR_SOURCE_DESCRIPTOR=WHEA_ERROR_SOURCE_DESCRIPTOR -_IPMI_OS_SEL_RECORD_TYPE=IPMI_OS_SEL_RECORD_TYPE -_IPMI_OS_SEL_RECORD=IPMI_OS_SEL_RECORD -_VBS_BASIC_ENCLAVE_THREAD_DESCRIPTOR32=VBS_BASIC_ENCLAVE_THREAD_DESCRIPTOR32 -_VBS_BASIC_ENCLAVE_THREAD_DESCRIPTOR64=VBS_BASIC_ENCLAVE_THREAD_DESCRIPTOR64 -_VBS_BASIC_ENCLAVE_EXCEPTION_AMD64=VBS_BASIC_ENCLAVE_EXCEPTION_AMD64 -_ENCLAVE_VBS_BASIC_KEY_REQUEST=ENCLAVE_VBS_BASIC_KEY_REQUEST -_VBS_BASIC_ENCLAVE_SYSCALL_PAGE=VBS_BASIC_ENCLAVE_SYSCALL_PAGE -tagVFW_FILTERLIST=VFW_FILTERLIST -_DXVA2_SampleFlags=DXVA2_SampleFlags -_DXVA2_DestinationFlags=DXVA2_DestinationFlags -_DXVA2_VIDEOSAMPLE=DXVA2_VIDEOSAMPLE -_DXVA2_VIDEOPROCESSBLT=DXVA2_VIDEOPROCESSBLT -_DXVA2SW_CALLBACKS=DXVA2SW_CALLBACKS -_CONTACT_AGGREGATION_BLOB=CONTACT_AGGREGATION_BLOB -_FTP_ACCESS=FTP_ACCESS -_FTP_PROCESS_STATUS=FTP_PROCESS_STATUS -_METADATA_RECORD=METADATA_RECORD -_METADATA_GETALL_RECORD=METADATA_GETALL_RECORD -_METADATA_GETALL_INTERNAL_RECORD=METADATA_GETALL_INTERNAL_RECORD -_METADATA_HANDLE_INFO=METADATA_HANDLE_INFO -_MD_CHANGE_OBJECT_W=MD_CHANGE_OBJECT_W -tagSCROLLABLECONTEXTMENU_PLACEMENT=SCROLLABLECONTEXTMENU_PLACEMENT -_IELAUNCHURLINFO=IELAUNCHURLINFO -tagDOCHOSTUITYPE=DOCHOSTUITYPE -tagDOCHOSTUIDBLCLK=DOCHOSTUIDBLCLK -tagDOCHOSTUIFLAG=DOCHOSTUIFLAG -_DOCHOSTUIINFO=DOCHOSTUIINFO -_ADDURL_FLAG=ADDURL_FLAG -_STATURL=STATURL -_SPropAttrArray=SPropAttrArray -tagIMMPID_MP_ENUM=IMMPID_MP_ENUM -tagIMMPID_RP_ENUM=IMMPID_RP_ENUM -tagIMMPID_MPV_ENUM=IMMPID_MPV_ENUM -tagIMMP_MPV_STORE_DRIVER_HANDLE=IMMP_MPV_STORE_DRIVER_HANDLE -tagIMMPID_RPV_ENUM=IMMPID_RPV_ENUM -tagIMMPID_NMP_ENUM=IMMPID_NMP_ENUM -tagIMMPID_CPV_ENUM=IMMPID_CPV_ENUM -_FLAT_STRING=FLAT_STRING -_NETWORK_NAME=NETWORK_NAME -_HARDWARE_ADDRESS=HARDWARE_ADDRESS -tagOBO_TOKEN_TYPE=OBO_TOKEN_TYPE -tagOBO_TOKEN=OBO_TOKEN -tagCOMPONENT_CHARACTERISTICS=COMPONENT_CHARACTERISTICS -tagNCRP_FLAGS=NCRP_FLAGS -tagSUPPORTS_BINDING_INTERFACE_FLAGS=SUPPORTS_BINDING_INTERFACE_FLAGS -tagENUM_BINDING_PATHS_FLAGS=ENUM_BINDING_PATHS_FLAGS -tagNCPNP_RECONFIG_LAYER=NCPNP_RECONFIG_LAYER -tagNETWORK_INSTALL_TIME=NETWORK_INSTALL_TIME -tagNETWORK_UPGRADE_TYPE=NETWORK_UPGRADE_TYPE -tagDEFAULT_PAGES=DEFAULT_PAGES -tagBIND_FLAGS1=BIND_FLAGS1 -tagRASCON_IPUI=RASCON_IPUI -_RTR_TOC_ENTRY=RTR_TOC_ENTRY -_RTR_INFO_BLOCK_HEADER=RTR_INFO_BLOCK_HEADER -_MPR_PROTOCOL_0=MPR_PROTOCOL_0 -_AD_GUARANTEED=AD_GUARANTEED -_WBCL_Iterator=WBCL_Iterator -_TCG_PCClientPCREventStruct=TCG_PCClientPCREventStruct -_TCG_PCClientTaggedEventStruct=TCG_PCClientTaggedEventStruct -_WBCL_LogHdr=WBCL_LogHdr -_STnefProblem=STnefProblem -_STnefProblemArray=STnefProblemArray -_NSID=NSID -tagDCINFO=DCINFO -tagEBindInfoOptions=EBindInfoOptions -tagDBPROMPTOPTIONSENUM=DBPROMPTOPTIONSENUM -tagKAGREQDIAG=KAGREQDIAG -tagKAGGETDIAG=KAGGETDIAG -tagDATE_STRUCT=DATE_STRUCT -tagTIME_STRUCT=TIME_STRUCT -tagTIMESTAMP_STRUCT=TIMESTAMP_STRUCT -tagSQL_INTERVAL_STRUCT=SQL_INTERVAL_STRUCT -tagSQL_NUMERIC_STRUCT=SQL_NUMERIC_STRUCT -tagDBCOST=DBCOST -tagRESTRICTION=RESTRICTION -tagNOTRESTRICTION=NOTRESTRICTION -tagNODERESTRICTION=NODERESTRICTION -tagVECTORRESTRICTION=VECTORRESTRICTION -tagCONTENTRESTRICTION=CONTENTRESTRICTION -tagNATLANGUAGERESTRICTION=NATLANGUAGERESTRICTION -tagPROPERTYRESTRICTION=PROPERTYRESTRICTION -tagCOLUMNSET=COLUMNSET -tagSORTKEY=SORTKEY -tagSORTSET=SORTSET -tagBUCKETCATEGORIZE=BUCKETCATEGORIZE -tagRANGECATEGORIZE=RANGECATEGORIZE -tagCATEGORIZATION=CATEGORIZATION -tagCATEGORIZATIONSET=CATEGORIZATIONSET -tagODBC_VS_ARGS=ODBC_VS_ARGS -tagSIDESHOW_SCREEN_TYPE=SIDESHOW_SCREEN_TYPE -tagSIDESHOW_COLOR_TYPE=SIDESHOW_COLOR_TYPE -tagSCF_EVENT_IDS=SCF_EVENT_IDS -tagSCF_BUTTON_IDS=SCF_BUTTON_IDS -tagSCF_EVENT_HEADER=SCF_EVENT_HEADER -tagSCF_NAVIGATION_EVENT=SCF_NAVIGATION_EVENT -tagSCF_MENUACTION_EVENT=SCF_MENUACTION_EVENT -tagSCF_CONTEXTMENU_EVENT=SCF_CONTEXTMENU_EVENT -_CONTENT_MISSING_EVENT_DATA=CONTENT_MISSING_EVENT_DATA -_APPLICATION_EVENT_DATA=APPLICATION_EVENT_DATA -_DEVICE_USER_CHANGE_EVENT_DATA=DEVICE_USER_CHANGE_EVENT_DATA -_NEW_EVENT_DATA_AVAILABLE=NEW_EVENT_DATA_AVAILABLE -_EVENT_DATA_HEADER=EVENT_DATA_HEADER -_WiaTransferParams=WiaTransferParams -_MINIDRV_TRANSFER_CONTEXT=MINIDRV_TRANSFER_CONTEXT -_WIA_DEV_CAP_DRV=WIA_DEV_CAP_DRV -_WIA_PROPERTY_INFO=WIA_PROPERTY_INFO -_WIA_PROPERTY_CONTEXT=WIA_PROPERTY_CONTEXT -_WIAS_CHANGED_VALUE_INFO=WIAS_CHANGED_VALUE_INFO -_WIAS_DOWN_SAMPLE_INFO=WIAS_DOWN_SAMPLE_INFO -_WIAS_ENDORSER_VALUE=WIAS_ENDORSER_VALUE -_WIAS_ENDORSER_INFO=WIAS_ENDORSER_INFO -tagDEVICEDIALOGDATA2=DEVICEDIALOGDATA2 -tagDEVICEDIALOGDATA=DEVICEDIALOGDATA -_RANGEVALUE=RANGEVALUE -_SCANWINDOW=SCANWINDOW -_SCANINFO=SCANINFO -_TWAIN_CAPABILITY=TWAIN_CAPABILITY _BMP_IMAGE_INFO=BMP_IMAGE_INFO -_DEVICE_RADIO_STATE=DEVICE_RADIO_STATE -_SYSTEM_RADIO_STATE=SYSTEM_RADIO_STATE -_USBFN_EVENT=USBFN_EVENT -_USBFN_PORT_TYPE=USBFN_PORT_TYPE -_USBFN_BUS_SPEED=USBFN_BUS_SPEED -_USBFN_DIRECTION=USBFN_DIRECTION -_USBFN_DEVICE_STATE=USBFN_DEVICE_STATE -_ALTERNATE_INTERFACE=ALTERNATE_INTERFACE -_USBFN_NOTIFICATION=USBFN_NOTIFICATION -_USBFN_PIPE_INFORMATION=USBFN_PIPE_INFORMATION -_USBFN_CLASS_INTERFACE=USBFN_CLASS_INTERFACE -_USBFN_CLASS_INFORMATION_PACKET=USBFN_CLASS_INFORMATION_PACKET -_USBFN_CLASS_INTERFACE_EX=USBFN_CLASS_INTERFACE_EX -_USBFN_CLASS_INFORMATION_PACKET_EX=USBFN_CLASS_INFORMATION_PACKET_EX -_USBFN_INTERFACE_INFO=USBFN_INTERFACE_INFO -_USBFN_USB_STRING=USBFN_USB_STRING -_USBFN_BUS_CONFIGURATION_INFO=USBFN_BUS_CONFIGURATION_INFO -_DRV_VERSION=DRV_VERSION -_IO_BLOCK=IO_BLOCK -_IO_BLOCK_EX=IO_BLOCK_EX -_CHANNEL_INFO=CHANNEL_INFO -_USBSCAN_GET_DESCRIPTOR=USBSCAN_GET_DESCRIPTOR -_DEVICE_DESCRIPTOR=DEVICE_DESCRIPTOR -_RAW_PIPE_TYPE=RAW_PIPE_TYPE -_USBSCAN_PIPE_INFORMATION=USBSCAN_PIPE_INFORMATION -_USBSCAN_PIPE_CONFIGURATION=USBSCAN_PIPE_CONFIGURATION -_USBSCAN_TIMEOUT=USBSCAN_TIMEOUT -_HandleType=HandleType -_PaddingMode=PaddingMode -_Direction=Direction -_INFORMATIONCARD_ASYMMETRIC_CRYPTO_PARAMETERS=INFORMATIONCARD_ASYMMETRIC_CRYPTO_PARAMETERS -_INFORMATIONCARD_SYMMETRIC_CRYPTO_PARAMETERS=INFORMATIONCARD_SYMMETRIC_CRYPTO_PARAMETERS -_INFORMATIONCARD_TRANSFORM_CRYPTO_PARAMETERS=INFORMATIONCARD_TRANSFORM_CRYPTO_PARAMETERS -_INFORMATIONCARD_HASH_CRYPTO_PARAMETERS=INFORMATIONCARD_HASH_CRYPTO_PARAMETERS -_INFORMATIONCARD_CRYPTO_HANDLE=INFORMATIONCARD_CRYPTO_HANDLE -_GENERIC_XML_TOKEN=GENERIC_XML_TOKEN -_ENDPOINTADDRESS=ENDPOINTADDRESS -_ENDPOINTADDRESS2=ENDPOINTADDRESS2 -_CERTIFICATE_CHAIN_BLOB=CERTIFICATE_CHAIN_BLOB -_CLAIMLIST=CLAIMLIST -_RECIPIENTPOLICY=RECIPIENTPOLICY -_RECIPIENTPOLICY2=RECIPIENTPOLICY2 -_NDR64_PROC_FLAGS=NDR64_PROC_FLAGS -_NDR64_RPC_FLAGS=NDR64_RPC_FLAGS -_NDR64_PROC_FORMAT=NDR64_PROC_FORMAT -_NDR64_PARAM_FLAGS=NDR64_PARAM_FLAGS -_NDR64_PARAM_FORMAT=NDR64_PARAM_FORMAT -_NDR64_RANGE_FORMAT=NDR64_RANGE_FORMAT -_NDR64_CONTEXT_HANDLE_FLAGS=NDR64_CONTEXT_HANDLE_FLAGS -_NDR64_CONTEXT_HANDLE_FORMAT=NDR64_CONTEXT_HANDLE_FORMAT -_NDR64_BIND_PRIMITIVE=NDR64_BIND_PRIMITIVE -_NDR64_BIND_GENERIC=NDR64_BIND_GENERIC -_NDR64_BIND_CONTEXT=NDR64_BIND_CONTEXT -_NDR64_BINDINGS=NDR64_BINDINGS -_NDR64_BIND_AND_NOTIFY_EXTENSION=NDR64_BIND_AND_NOTIFY_EXTENSION -_NDR64_SYSTEM_HANDLE_FORMAT=NDR64_SYSTEM_HANDLE_FORMAT -_NDR64_POINTER_FORMAT=NDR64_POINTER_FORMAT -_NDR64_NO_REPEAT_FORMAT=NDR64_NO_REPEAT_FORMAT -_NDR64_POINTER_INSTANCE_HEADER_FORMAT=NDR64_POINTER_INSTANCE_HEADER_FORMAT -_NDR64_POINTER_REPEAT_FLAGS=NDR64_POINTER_REPEAT_FLAGS -_NDR64_REPEAT_FORMAT=NDR64_REPEAT_FORMAT -_NDR64_FIXED_REPEAT_FORMAT=NDR64_FIXED_REPEAT_FORMAT -_NDR64_IID_FLAGS=NDR64_IID_FLAGS -_NDR64_CONSTANT_IID_FORMAT=NDR64_CONSTANT_IID_FORMAT -_NDR64_IID_FORMAT=NDR64_IID_FORMAT -_NDR64_STRUCTURE_FLAGS=NDR64_STRUCTURE_FLAGS -_NDR64_STRUCTURE_HEADER_FORMAT=NDR64_STRUCTURE_HEADER_FORMAT -_NDR64_CONF_STRUCTURE_HEADER_FORMAT=NDR64_CONF_STRUCTURE_HEADER_FORMAT -_NDR64_BOGUS_STRUCTURE_HEADER_FORMAT=NDR64_BOGUS_STRUCTURE_HEADER_FORMAT -_NDR64_CONF_BOGUS_STRUCTURE_HEADER_FORMAT=NDR64_CONF_BOGUS_STRUCTURE_HEADER_FORMAT -_NDR64_SIMPLE_MEMBER_FORMAT=NDR64_SIMPLE_MEMBER_FORMAT -_NDR64_MEMPAD_FORMAT=NDR64_MEMPAD_FORMAT -_NDR64_EMBEDDED_COMPLEX_FORMAT=NDR64_EMBEDDED_COMPLEX_FORMAT -_NDR64_BUFFER_ALIGN_FORMAT=NDR64_BUFFER_ALIGN_FORMAT -_NDR64_SIMPLE_REGION_FORMAT=NDR64_SIMPLE_REGION_FORMAT -_NDR64_ENCAPSULATED_UNION=NDR64_ENCAPSULATED_UNION -_NDR64_NON_ENCAPSULATED_UNION=NDR64_NON_ENCAPSULATED_UNION -_NDR64_UNION_ARM_SELECTOR=NDR64_UNION_ARM_SELECTOR -_NDR64_UNION_ARM=NDR64_UNION_ARM -_NDR64_ARRAY_FLAGS=NDR64_ARRAY_FLAGS -_NDR64_ARRAY_ELEMENT_INFO=NDR64_ARRAY_ELEMENT_INFO -_NDR64_FIX_ARRAY_HEADER_FORMAT=NDR64_FIX_ARRAY_HEADER_FORMAT -_NDR64_CONF_ARRAY_HEADER_FORMAT=NDR64_CONF_ARRAY_HEADER_FORMAT -_NDR64_CONF_VAR_ARRAY_HEADER_FORMAT=NDR64_CONF_VAR_ARRAY_HEADER_FORMAT -_NDR64_VAR_ARRAY_HEADER_FORMAT=NDR64_VAR_ARRAY_HEADER_FORMAT -_NDR64_BOGUS_ARRAY_HEADER_FORMAT=NDR64_BOGUS_ARRAY_HEADER_FORMAT -_NDR64_CONF_VAR_BOGUS_ARRAY_HEADER_FORMAT=NDR64_CONF_VAR_BOGUS_ARRAY_HEADER_FORMAT -_NDR64_STRING_FLAGS=NDR64_STRING_FLAGS -_NDR64_NON_CONFORMANT_STRING_FORMAT=NDR64_NON_CONFORMANT_STRING_FORMAT -_NDR64_RANGED_STRING_FORMAT=NDR64_RANGED_STRING_FORMAT -_NDR64_CONFORMANT_STRING_FORMAT=NDR64_CONFORMANT_STRING_FORMAT -_tagEXPR_TOKEN=EXPR_TOKEN -_NDR64_EXPR_OPERATOR=NDR64_EXPR_OPERATOR -_NDR64_EXPR_CONST32=NDR64_EXPR_CONST32 -_NDR64_EXPR_CONST64=NDR64_EXPR_CONST64 -_NDR64_EXPR_VAR=NDR64_EXPR_VAR -_NDR64_EXPR_NOOP=NDR64_EXPR_NOOP -_NDR64_TRANSMIT_AS_FLAGS=NDR64_TRANSMIT_AS_FLAGS -_NDR64_TRANSMIT_AS_FORMAT=NDR64_TRANSMIT_AS_FORMAT -_NDR64_USER_MARSHAL_FLAGS=NDR64_USER_MARSHAL_FLAGS -_NDR64_USER_MARSHAL_FORMAT=NDR64_USER_MARSHAL_FORMAT -_NDR64_PIPE_FORMAT=NDR64_PIPE_FORMAT -_NDR64_RANGE_PIPE_FORMAT=NDR64_RANGE_PIPE_FORMAT -_NDR64_TYPE_STRICT_CONTEXT_HANDLE=NDR64_TYPE_STRICT_CONTEXT_HANDLE -_LicenseProtectionStatus=LicenseProtectionStatus -_DOT11_ADAPTER=DOT11_ADAPTER -_DOT11_BSS_LIST=DOT11_BSS_LIST -_DOT11_PORT_STATE=DOT11_PORT_STATE -_DOT11_SECURITY_PACKET_HEADER=DOT11_SECURITY_PACKET_HEADER -_HSE_VERSION_INFO=HSE_VERSION_INFO -_EXTENSION_CONTROL_BLOCK=EXTENSION_CONTROL_BLOCK -_HSE_URL_MAPEX_INFO=HSE_URL_MAPEX_INFO -_HSE_UNICODE_URL_MAPEX_INFO=HSE_UNICODE_URL_MAPEX_INFO -_HSE_TF_INFO=HSE_TF_INFO -_HSE_SEND_HEADER_EX_INFO=HSE_SEND_HEADER_EX_INFO -_HSE_EXEC_URL_USER_INFO=HSE_EXEC_URL_USER_INFO -_HSE_EXEC_URL_ENTITY_INFO=HSE_EXEC_URL_ENTITY_INFO -_HSE_EXEC_URL_STATUS=HSE_EXEC_URL_STATUS -_HSE_EXEC_URL_INFO=HSE_EXEC_URL_INFO -_HSE_EXEC_UNICODE_URL_USER_INFO=HSE_EXEC_UNICODE_URL_USER_INFO -_HSE_EXEC_UNICODE_URL_INFO=HSE_EXEC_UNICODE_URL_INFO -_HSE_CUSTOM_ERROR_INFO=HSE_CUSTOM_ERROR_INFO -_HSE_VECTOR_ELEMENT=HSE_VECTOR_ELEMENT -_HSE_RESPONSE_VECTOR=HSE_RESPONSE_VECTOR -_CERT_CONTEXT_EX=CERT_CONTEXT_EX -_HSE_TRACE_INFO=HSE_TRACE_INFO -_HTTP_FILTER_CONTEXT=HTTP_FILTER_CONTEXT -_HTTP_FILTER_RAW_DATA=HTTP_FILTER_RAW_DATA -_HTTP_FILTER_PREPROC_HEADERS=HTTP_FILTER_PREPROC_HEADERS -_HTTP_FILTER_AUTHENT=HTTP_FILTER_AUTHENT -_HTTP_FILTER_URL_MAP=HTTP_FILTER_URL_MAP -_HTTP_FILTER_URL_MAP_EX=HTTP_FILTER_URL_MAP_EX -_HTTP_FILTER_ACCESS_DENIED=HTTP_FILTER_ACCESS_DENIED -_HTTP_FILTER_LOG=HTTP_FILTER_LOG -_HTTP_FILTER_AUTH_COMPLETE_INFO=HTTP_FILTER_AUTH_COMPLETE_INFO -_HTTP_FILTER_VERSION=HTTP_FILTER_VERSION -_DELTA_INPUT=DELTA_INPUT -_DELTA_OUTPUT=DELTA_OUTPUT -_DELTA_HASH=DELTA_HASH -_DELTA_HEADER_INFO=DELTA_HEADER_INFO -tACMDRVSTREAMINSTANCE=ACMDRVSTREAMINSTANCE -tACMDRVSTREAMHEADER=ACMDRVSTREAMHEADER -tACMDRVSTREAMSIZE=ACMDRVSTREAMSIZE -tACMDRVFORMATSUGGEST=ACMDRVFORMATSUGGEST _PROPERTYUI_NAME_FLAGS=PROPERTYUI_NAME_FLAGS _PROPERTYUI_FLAGS=PROPERTYUI_FLAGS _PROPERTYUI_FORMAT_FLAGS=PROPERTYUI_FORMAT_FLAGS -CM_Power_Data_s=CM_POWER_DATA _TREEITEM*=HTREEITEM _IMAGELIST*=HIMAGELIST _DSA*=HDSA _DPA*=HDPA -__NCRYPT_PCP_TPM_WEB_AUTHN_ATTESTATION_STATEMENT=NCRYPT_PCP_TPM_WEB_AUTHN_ATTESTATION_STATEMENT _FILEOPENDIALOGOPTIONS=FILEOPENDIALOGOPTIONS KSPROPERYT_NETWORKCAMERACONTROL_NTPINFO_TYPE_CUSTOM=KSPROPERTY_NETWORKCAMERACONTROL_NTPINFO_TYPE_CUSTOM _BITMAPINFOHEADER=BITMAPINFOHEADER _VIDEOINFOHEADER=VIDEOINFOHEADER _WAVEFORMATEX=WAVEFORMATEX -__MIDL___MIDL_itf_mfvirtualcamera_0000_0000_0001=MFVirtualCameraType -__MIDL___MIDL_itf_mfvirtualcamera_0000_0000_0002=MFVirtualCameraLifetime -__MIDL___MIDL_itf_mfvirtualcamera_0000_0000_0003=MFVirtualCameraAccess -__MIDL___MIDL_itf_imgerror_0000_0000_0001=ImgErrorInfo -__MIDL___MIDL_itf_mmdeviceapi_0000_0008_0002=AUDIO_SYSTEMEFFECTS_PROPERTYSTORE_TYPE -__MIDL___MIDL_itf_jscript9diag_0000_0007_0001=JS_NATIVE_FRAME -__MIDL___MIDL_itf_mtxadmin_0107_0001=MTSPackageInstallOptions -__MIDL___MIDL_itf_mtxadmin_0107_0002=MTSPackageExportOptions -__MIDL___MIDL_itf_mtxadmin_0107_0003=MTSAdminErrorCodes -__MIDL_ITargetFrame2_0001=FINDFRAME_FLAGS -__MIDL_ITargetFrame2_0002=FRAMEOPTIONS_FLAGS -__MIDL_ITargetFrame_0001=NAVIGATEFRAME_FLAGS _SHGDNF=SHGDNF ADSTYPEENUM=ADSTYPE -tcp_opt_mss=TCP_OPT_MSS -tcp_opt_ws=TCP_OPT_WS -tcp_opt_sack_permitted=TCP_OPT_SACK_PERMITTED -tcp_opt_sack=TCP_OPT_SACK -tcp_opt_ts=TCP_OPT_TS -tcp_opt_unknown=TCP_OPT_UNKNOWN -tcp_opt_fastopen=TCP_OPT_FASTOPEN -tACMDRVOPENDESCA=ACMDRVOPENDESCA -tACMDRVOPENDESCW=ACMDRVOPENDESCW JOBOBJECT_IO_RATE_CONTROL_INFORMATION_NATIVE=JOBOBJECT_IO_RATE_CONTROL_INFORMATION_NATIVE_V1 -_grouptypingchange=GROUPTYPINGCHANGE -hyphresult=HYPHRESULT -_IMAGEHLP_JIT_SYMBOL_MAP=IMAGEHLP_JIT_SYMBOLMAP -_DUMP_TYPES=DUMP_TYPE -Mem_Large_Range_s=MEM_LARGE_RANGE -Mem_Large_Des_s=MEM_LARGE_DES -Mem_Large_Resource_s=MEM_LARGE_RESOURCE -DevPrivate_Range_s=DEVPRIVATE_RANGE -DevPrivate_Des_s=DEVPRIVATE_DES -DevPrivate_Resource_s=DEVPRIVATE_RESOURCE -Connection_Des_s=CONNECTION_DES -Connection_Resource_s=CONNECTION_RESOURCE -HWProfileInfo_sA=HWPROFILEINFO_A -HWProfileInfo_sW=HWPROFILEINFO_W -_DnsRecordOptW=DNS_RECORD_OPTW -_DEVICEDUMP_COLLECTION_TYPE=DEVICEDUMP_COLLECTION_TYPEIDE_NOTIFICATION_TYPE -ip_option_information=IP_OPTION_INFORMATION -ip_option_information32=IP_OPTION_INFORMATION32 -icmp_echo_reply=ICMP_ECHO_REPLY -icmp_echo_reply32=ICMP_ECHO_REPLY32 -icmpv6_echo_reply_lh=ICMPV6_ECHO_REPLY_LH -arp_send_reply=ARP_SEND_REPLY -tcp_reserve_port_range=TCP_RESERVE_PORT_RANGE -ip_interface_name_info_w2ksp1=IP_INTERFACE_NAME_INFO_W2KSP1 -_KSAUDIO_PACKETSIZE_SIGNALPROCESSINGMODE_CONSTRAINT=KSAUDIO_PACKETSIZE_PROCESSINGMODE_CONSTRAINT -_TunerDecoderLockType=TunerLockType -_SPLCLIENT_INFO_2_V1=SPLCLIENT_INFO_2_W2K -_SPLCLIENT_INFO_2_V2=SPLCLIENT_INFO_2_WINXP -tagMxdcLandscapeRotationEnums=MXDC_LANDSCAPE_ROTATION_ENUMS -tagMxdcImageTypeEnums=MXDC_IMAGE_TYPE_ENUMS -tagMxdcEscapeHeader=MXDC_ESCAPE_HEADER_T -tagMxdcGetFileNameData=MXDC_GET_FILENAME_DATA_T -_MPR_VPN_SELECTOR=MPR_VPN_TRAFFIC_SELECTOR -tagSQL_YEAR_MONTH=SQL_YEAR_MONTH_STRUCT -tagSQL_DAY_SECOND=SQL_DAY_SECOND_STRUCT -dbvarychar=DBVARYCHAR -dbvarybin=DBVARYBIN -dbmoney=DBMONEY -dbdatetime=DBDATETIME -dbdatetime4=DBDATETIM4 -sqlperf=SQLPERF -tagDBROWWATCHRANGE=DBROWWATCHCHANGE -tagSSErrorInfo=SSERRORINFO -_FN_OBJECT_MGR_FUNCTIONS=FN_OBJECT_MGR_FUNCTS -_HLSR_NOREDEF10=HLSR -_HLSHORTCUTF__NOREDEF10=HLSHORTCUTF -_HLTRANSLATEF_NOREDEF10=HLTRANSLATEF -iurl_seturl_flags=IURL_SETURL_FLAGS -iurl_invokecommand_flags=IURL_INVOKECOMMAND_FLAGS -urlinvokecommandinfoA=URLINVOKECOMMANDINFOA -urlinvokecommandinfoW=URLINVOKECOMMANDINFOW -translateurl_in_flags=TRANSLATEURL_IN_FLAGS -urlassociationdialog_in_flags=URLASSOCIATIONDIALOG_IN_FLAGS -mimeassociationdialog_in_flags=MIMEASSOCIATIONDIALOG_IN_FLAGS -tag_WBEM_LOCKING=WBEM_LOCKING_FLAG_TYPE -_WinHttpProxyNetworkKey=WINHTTP_PROXY_NETWORKING_KEY -tcp_request_query_information_ex_xp=TCP_REQUEST_QUERY_INFORMATION_EX_XP -tcp_request_query_information_ex32_xp=TCP_REQUEST_QUERY_INFORMATION_EX32_XP -tcp_request_query_information_ex_w2k=TCP_REQUEST_QUERY_INFORMATION_EX_W2K -tcp_request_set_information_ex=TCP_REQUEST_SET_INFORMATION_EX cmsghdr=CMSGHDR -addrinfo_dns_server=ADDRINFO_DNS_SERVER -WSAData=WSADATA -linger=LINGER fd_set=FD_SET -hostent=HOSTENT -servent=SERVENT -protoent=PROTOENT -timeval=TIMEVAL sockaddr_atm=SOCKADDR_ATM -WSPData=WSPDATA -sockaddr_un=SOCKADDR_UN -sockaddr_ipx=SOCKADDR_IPX -sockaddr_tp=SOCKADDR_TP -sockaddr_nb=SOCKADDR_NB -sockaddr_vns=SOCKADDR_VNS -nd_router_solicit=ND_ROUTER_SOLICIT_HEADER -tcp_hdr=TCP_HDR -ads_searchpref_info=ADS_SEARCHPREF_INFO -ads_search_column=ADS_SEARCH_COLUMN -_rwsmp=WSMPL -_rloop=WLOOP -_DMUS_PORTPARAMS=DMUS_PORTPARAMS7 -Tag_DVAudInfo=DVAudInfo _BLUETOOTH_ADDRESS=BLUETOOTH_ADDRESS _BLUETOOTH_LOCAL_SERVICE_INFO=BLUETOOTH_LOCAL_SERVICE_INFO _BLUETOOTH_DEVICE_INFO=BLUETOOTH_DEVICE_INFO -_wireSAFEARR_BSTR=SAFEARR_BSTR -_wireSAFEARR_UNKNOWN=SAFEARR_UNKNOWN -_wireSAFEARR_DISPATCH=SAFEARR_DISPATCH -_wireSAFEARR_VARIANT=SAFEARR_VARIANT -_wireSAFEARR_BRECORD=SAFEARR_BRECORD -_wireSAFEARR_HAVEIID=SAFEARR_HAVEIID -_wireSAFEARRAY_UNION=SAFEARRAYUNION -CAppStatistics=APPSTATISTICS -CAppData=APPDATA -CCLSIDData=CLSIDDATA -CCLSIDData2=CLSIDDATA2 -_GETSETBUSDATA=BUSDATA -xid_t=XID -_ProxyConfigParams=PROXY_CONFIG_PARAMS -_DtcLu_LocalRecovery_Work=DTCINITIATEDRECOVERYWORK -_DtcLu_Xln=DTCLUXLN -_DtcLu_Xln_Confirmation=DTCLUXLNCONFIRMATION -_DtcLu_Xln_Response=DTCLUXLNRESPONSE -_DtcLu_Xln_Error=DTCLUXLNERROR -_DtcLu_CompareState=DTCLUCOMPARESTATE -_DtcLu_CompareStates_Confirmation=DTCLUCOMPARESTATESCONFIRMATION -_DtcLu_CompareStates_Error=DTCLUCOMPARESTATESERROR -_DtcLu_CompareStates_Response=DTCLUCOMPARESTATESRESPONSE -tabIMESTRINGINFO=IMESTRINGINFO -tabIMEFAREASTINFO=IMEFAREASTINFO -tagNavigateData=NAVIGATEDATA -MediaActivityNotifyType=MEDIA_ACTIVITY_NOTIFY_TYPE -opentype_feature_record=OPENTYPE_FEATURE_RECORD -textrange_properties=TEXTRANGE_PROPERTIES -script_charprop=SCRIPT_CHARPROP -script_glyphprop=SCRIPT_GLYPHPROP -tagMLCONVCHARF=MLCONVCHAR -tagMLCPF=MLCP -tagSCRIPFONTINFO=SCRIPTFONTINFO -tagKbdLayer=KBDTABLES -_VK_FUNCTION_PARAM=VK_FPARAM -_VK_TO_FUNCTION_TABLE=VK_F -tagKbdNlsLayer=KBDNLSTABLES -ldap=LDAP -ldapcontrolA=LDAPControlA -ldapcontrolW=LDAPControlW -ldapmodW=LDAPModW -ldapmodA=LDAPModA -berelement=BerElement -ldap_version_info=LDAP_VERSION_INFO -ldapapiinfoA=LDAPAPIInfoA -ldapapiinfoW=LDAPAPIInfoW -ldapsortkeyW=LDAPSortKeyW -ldapsortkeyA=LDAPSortKeyA -ldapvlvinfo=LDAPVLVInfo -_reconcilef=RECONCILEF -tag_WMIQ_RPNQ_FEATURE=WMIQ_RPNF_FEATURE -AM_SEEKING_SeekingFlags=AM_SEEKING_SEEKING_FLAGS -_avitimedindex=AVITIMEDINDEX -_avitcdlindex=AVITCDLINDEX -_DOT11_WME_AC_PARAMTERS_LIST=DOT11_WME_AC_PARAMETERS_LIST flow_desc=FLOW_DESC policy_decision=POLICY_DECISION lpmiptable=LPMIPTABLE -tag_SIPAEVENT_VSM_IDK_RSA_INFO=SIPAEVENT_VSM_IDK_RSA_INFO -tag_SIPAEVENT_VSM_IDK_INFO_PAYLOAD=SIPAEVENT_VSM_IDK_INFO_PAYLOAD -tag_SIPAEVENT_SI_POLICY_PAYLOAD=SIPAEVENT_SI_POLICY_PAYLOAD -tag_SIPAEVENT_REVOCATION_LIST_PAYLOAD=SIPAEVENT_REVOCATION_LIST_PAYLOAD -tag_SIPAEVENT_KSR_SIGNATURE_PAYLOAD=SIPAEVENT_KSR_SIGNATURE_PAYLOAD -tag_SIPAEVENT_SBCP_INFO_PAYLOAD_V1=SIPAEVENT_SBCP_INFO_PAYLOAD_V1 -pvalueA=PVALUEA -pvalueW=PVALUEW -provider_info=REG_PROVIDER -RpcProxyPerfCounters=RpcPerfCounters -tagCMOID=CERT_FILTER_EXTENSION_MATCH -tagCMFLTR=CERT_FILTER_DATA -_tagAPPTASKTYPE=PM_APPTASKTYPE -tagINSTALLOGMODE=INSTALLLOGMODE -SPDISPLYATTRIBUTES=SPDISPLAYATTRIBUTES -SPWAVEFORMATTYPE=SPSTREAMFORMATTYPE -_RESTOREPTINFOEX=RESTOREPOINTINFOEX -enumINKMETRIC_FLAGS=INK_METRIC_FLAGS -enumGetCandidateFlags=GET_DANDIDATE_FLAGS -enumRECO_TYPE=RECO_TYPE -linereqmakecallW_tag=LINEREQMAKECALLW -linereqmediacallW_tag=LINEREQMEDIACALLW -_renddata=RENDDATA -_dtr=DTR -_trp=TRP -_ADDR_ALIAS=ADDRALIAS -tdTPM_WNF_PROVISIONING=TPM_WNF_PROVISIONING -_WTS_PRODUCT_INFOA=PRODUCT_INFOA -_WTS_PRODUCT_INFOW=PRODUCT_INFOW -_PV=__UPV -_flaglist=FlagList -IPSEC_TRAFFIC_SELECTOR0_=IPSEC_TRAFFIC_SELECTOR0 -IPSEC_TRAFFIC_SELECTOR_POLICY0_=IPSEC_TRAFFIC_SELECTOR_POLICY0 -IPSEC_TUNNEL_POLICY3_=IPSEC_TUNNEL_POLICY3 -FWPM_PROVIDER_CONTEXT3_=FWPM_PROVIDER_CONTEXT3 -FWPM_NET_EVENT_IKEEXT_MM_FAILURE2_=FWPM_NET_EVENT_IKEEXT_MM_FAILURE2 -FWPM_NET_EVENT_IKEEXT_QM_FAILURE1_=FWPM_NET_EVENT_IKEEXT_QM_FAILURE1 -FWPM_NET_EVENT_LPM_PACKET_ARRIVAL0_=FWPM_NET_EVENT_LPM_PACKET_ARRIVAL0 -FWPM_NET_EVENT4_=FWPM_NET_EVENT4 -FWPM_NET_EVENT5_=FWPM_NET_EVENT5 -_tag_FW_DYNAMIC_KEYWORD_ORIGIN_TYPE=FW_DYNAMIC_KEYWORD_ORIGIN_TYPE -_tag_FW_DYNAMIC_KEYWORD_ADDRESS0=FW_DYNAMIC_KEYWORD_ADDRESS0 -_tag_FW_DYNAMIC_KEYWORD_ADDRESS_DATA0=FW_DYNAMIC_KEYWORD_ADDRESS_DATA0 -_tag_FW_DYNAMIC_KEYWORD_ADDRESS_FLAGS=FW_DYNAMIC_KEYWORD_ADDRESS_FLAGS -_tag_FW_DYNAMIC_KEYWORD_ADDRESS_ENUM_FLAGS=FW_DYNAMIC_KEYWORD_ADDRESS_ENUM_FLAGS -__MACINFO=MACINFO -tag_WBEM_LOGIN_TYPE=WBEM_LOGIN_TYPE -tagRASCON_IPUI_FLAGS=RASCON_UIINFO_FLAGS VARIANT_BOOL=VARIANT_BOOL DEVPROP_BOOLEAN=DEVPROP_BOOLEAN _IFaxAccountNotify=IFaxAccountNotify @@ -12229,64 +687,8 @@ PLSA_HANDLE=LSA_HANDLE* PDEVPROPTYPE=DEVPROPTYPE* PBSTR=BSTR* LPBSTR=BSTR* -_VDS_ADVANCEDDISK_PROP=VDS_ADVANCEDDISK_PROP PVDS_ADVANCEDDISK_PROP=VDS_ADVANCEDDISK_PROP* -tagMQPROPERTYRESTRICTION=MQPROPERTYRESTRICTION -tagMQRESTRICTION=MQRESTRICTION -tagMQCOLUMNSET=MQCOLUMNSET -tagMQSORTKEY=MQSORTKEY -tagMQSORTSET=MQSORTSET -tagMQMSGPROPS=MQMSGPROPS -tagMQQUEUEPROPS=MQQUEUEPROPS -tagMQQMPROPS=MQQMPROPS -tagMQPRIVATEPROPS=MQPRIVATEPROPS -tagMQMGMTPROPS=MQMGMTPROPS -tagSEQUENCE_INFO=SEQUENCE_INFO -tagMQConnectionState=MQConnectionState -_PROCESS_MITIGATION_SEHOP_POLICY=PROCESS_MITIGATION_SEHOP_POLICY -_PROCESS_MITIGATION_USER_POINTER_AUTH_POLICY=PROCESS_MITIGATION_USER_POINTER_AUTH_POLICY -_FILE_NOTIFY_FULL_INFORMATION=FILE_NOTIFY_FULL_INFORMATION -_IMAGE_FUNCTION_OVERRIDE_HEADER=IMAGE_FUNCTION_OVERRIDE_HEADER -_IMAGE_FUNCTION_OVERRIDE_DYNAMIC_RELOCATION=IMAGE_FUNCTION_OVERRIDE_DYNAMIC_RELOCATION -_IMAGE_BDD_INFO=IMAGE_BDD_INFO -_IMAGE_BDD_DYNAMIC_RELOCATION=IMAGE_BDD_DYNAMIC_RELOCATION -_DNS_SVCB_PARAM_TYPE=DNS_SVCB_PARAM_TYPE -_DNS_SVCB_PARAM_MANDATORY=DNS_SVCB_PARAM_MANDATORY -_DNS_SVCB_PARAM_ALPN_ID=DNS_SVCB_PARAM_ALPN_ID -_DNS_SVCB_PARAM_ALPN=DNS_SVCB_PARAM_ALPN -_DNS_SVCB_PARAM_IPV4=DNS_SVCB_PARAM_IPV4 -_DNS_SVCB_PARAM_IPV6=DNS_SVCB_PARAM_IPV6 -_DNS_SVCB_PARAM_UNKNOWN=DNS_SVCB_PARAM_UNKNOWN -_DNS_SVCB_PARAM=DNS_SVCB_PARAM -_DNS_SVCB_DATA=DNS_SVCB_DATA -_STORAGE_ENCRYPTION_TYPE=STORAGE_ENCRYPTION_TYPE -_STORAGE_DEVICE_SELF_ENCRYPTION_PROPERTY_V2=STORAGE_DEVICE_SELF_ENCRYPTION_PROPERTY_V2 -_LMR_QUERY_INFO_CLASS=LMR_QUERY_INFO_CLASS -_LMR_QUERY_INFO_PARAM=LMR_QUERY_INFO_PARAM -_LMR_QUERY_SESSION_INFO=LMR_QUERY_SESSION_INFO -_DNS_INTERFACE_SETTINGS4=DNS_INTERFACE_SETTINGS4 -_tagKSJACK_DESCRIPTION3=KSJACK_DESCRIPTION3 -_tagKSAUDIOENGINE_DEVICECONTROLS=KSAUDIOENGINE_DEVICECONTROLS -tagGETCLIPBMETADATA=GETCLIPBMETADATA -__MIDL___MIDL_itf_mfidl_0000_0136_0001=MF_CAMERA_CONTROL_CONFIGURATION_TYPE -__MIDL___MIDL_itf_mfidl_0000_0136_0002=MF_CAMERA_CONTROL_RANGE_INFO -_DOC_INFO_INTERNAL=DOC_INFO_INTERNAL -_WINHTTP_PROXY_SETTINGS_TYPE=WINHTTP_PROXY_SETTINGS_TYPE -_WINHTTP_PROXY_SETTINGS_EX=WINHTTP_PROXY_SETTINGS_EX -_WINHTTP_PROXY_SETTINGS_PARAM=WINHTTP_PROXY_SETTINGS_PARAM -_HTTP_QUIC_STREAM_REQUEST_STATS=HTTP_QUIC_STREAM_REQUEST_STATS -_LSA_FOREST_TRUST_SCANNER_INFO=LSA_FOREST_TRUST_SCANNER_INFO -_LSA_FOREST_TRUST_RECORD2=LSA_FOREST_TRUST_RECORD2 -_LSA_FOREST_TRUST_INFORMATION2=LSA_FOREST_TRUST_INFORMATION2 -_KERB_CLOUD_KERBEROS_DEBUG_DATA=KERB_CLOUD_KERBEROS_DEBUG_DATA -_SEC_CERTIFICATE_REQUEST_CONTEXT=SEC_CERTIFICATE_REQUEST_CONTEXT -_SECPKG_CLIENT_INFO_EX=SECPKG_CLIENT_INFO_EX -_SECPKG_NTLM_TARGETINFO=SECPKG_NTLM_TARGETINFO -_CLUSAPI_REASON_HANDLER=CLUSAPI_REASON_HANDLER -_ACPI_TIME_RESOLUTION=ACPI_TIME_RESOLUTION -_ACPI_TIME_AND_ALARM_CAPABILITIES=ACPI_TIME_AND_ALARM_CAPABILITIES _HSP_UPGRADE_IMAGEDATA=HSP_UPGRADE_IMAGEDATA -_APC_CALLBACK_DATA=APC_CALLBACK_DATA __MIDL___MIDL_itf_UIAnimation_0000_0000_0001=UI_ANIMATION_UPDATE_RESULT __MIDL___MIDL_itf_UIAnimation_0000_0000_0002=UI_ANIMATION_MANAGER_STATUS __MIDL___MIDL_itf_UIAnimation_0000_0000_0003=UI_ANIMATION_MODE @@ -12299,114 +701,6 @@ __MIDL___MIDL_itf_UIAnimation_0000_0009_0001=UI_ANIMATION_SLOPE __MIDL___MIDL_itf_UIAnimation_0000_0010_0001=UI_ANIMATION_DEPENDENCIES __MIDL___MIDL_itf_UIAnimation_0000_0012_0001=UI_ANIMATION_IDLE_BEHAVIOR __MIDL___MIDL_itf_UIAnimation_0000_0014_0001=UI_ANIMATION_TIMER_CLIENT_STATUS -FWP_NETWORK_CONNECTION_POLICY_SETTING_TYPE_=FWP_NETWORK_CONNECTION_POLICY_SETTING_TYPE -FWPM_NETWORK_CONNECTION_POLICY_SETTING0_=FWPM_NETWORK_CONNECTION_POLICY_SETTING0 -FWPM_NETWORK_CONNECTION_POLICY_SETTINGS0_=FWPM_NETWORK_CONNECTION_POLICY_SETTINGS0 -_WEBAUTHN_CREDENTIAL_DETAILS=WEBAUTHN_CREDENTIAL_DETAILS -_WEBAUTHN_CREDENTIAL_DETAILS_LIST=WEBAUTHN_CREDENTIAL_DETAILS_LIST -_WEBAUTHN_GET_CREDENTIALS_OPTIONS=WEBAUTHN_GET_CREDENTIALS_OPTIONS -_WEBAUTHN_HMAC_SECRET_SALT=WEBAUTHN_HMAC_SECRET_SALT -_WEBAUTHN_CRED_WITH_HMAC_SECRET_SALT=WEBAUTHN_CRED_WITH_HMAC_SECRET_SALT -_WEBAUTHN_HMAC_SECRET_SALT_VALUES=WEBAUTHN_HMAC_SECRET_SALT_VALUES -__MIDL___MIDL_itf_documenttarget_0000_0002_0001=PrintDocumentPackageStatus -_DEBUG_DEVICE_OBJECT_INFO=DEBUG_DEVICE_OBJECT_INFO -_DEBUG_DRIVER_OBJECT_INFO=DEBUG_DRIVER_OBJECT_INFO -_PROCESS_COMMIT_USAGE=PROCESS_COMMIT_USAGE -_DEBUG_CPU_SPEED_INFO=DEBUG_CPU_SPEED_INFO -_DEBUG_CPU_MICROCODE_VERSION=DEBUG_CPU_MICROCODE_VERSION -_DEBUG_SMBIOS_INFO=DEBUG_SMBIOS_INFO -_DEBUG_IRP_STACK_INFO=DEBUG_IRP_STACK_INFO -_DEBUG_IRP_INFO=DEBUG_IRP_INFO -_DDEBUG_PNP_TRIAGE_INFO=DEBUG_PNP_TRIAGE_INFO -_DEBUG_POOL_DATA=DEBUG_POOL_DATA -_DEBUG_POOL_REGION=DEBUG_POOL_REGION -_KDEXT_THREAD_FIND_PARAMS=KDEXT_THREAD_FIND_PARAMS -_KDEXT_PROCESS_FIND_PARAMS=KDEXT_PROCESS_FIND_PARAMS -_KDEXT_HANDLE_INFORMATION=KDEXT_HANDLE_INFORMATION -_KDEXT_FILELOCK_OWNER=KDEXT_FILELOCK_OWNER -_KDEXTS_LOCK_INFO=KDEXTS_LOCK_INFO -_KDEXTS_PTE_INFO=KDEXTS_PTE_INFO -_DEBUG_POOLTAG_DESCRIPTION=DEBUG_POOLTAG_DESCRIPTION -_DEBUG_FAILURE_TYPE=DEBUG_FAILURE_TYPE -_DEBUG_FLR_PARAM_TYPE=DEBUG_FLR_PARAM_TYPE -_DBG_THREAD_ATTRIBUTES=DBG_THREAD_ATTRIBUTES -_FA_ENTRY_TYPE=FA_ENTRY_TYPE -_FA_ENTRY=FA_ENTRY -_FA_EXTENSION_PLUGIN_PHASE=FA_EXTENSION_PLUGIN_PHASE -_OS_TYPE=OS_TYPE -_OS_INFO=OS_INFO -_CPU_INFO=CPU_INFO -_TARGET_DEBUG_INFO=TARGET_DEBUG_INFO -_CPU_INFO_v2=CPU_INFO_v2 -_TARGET_DEBUG_INFO_v2=TARGET_DEBUG_INFO_v2 -_OS_INFO_v1=OS_INFO_v1 -_CPU_INFO_v1=CPU_INFO_v1 -_TARGET_DEBUG_INFO_v1=TARGET_DEBUG_INFO_v1 -_DEBUG_DECODE_ERROR=DEBUG_DECODE_ERROR -_DEBUG_TRIAGE_FOLLOWUP_INFO=DEBUG_TRIAGE_FOLLOWUP_INFO -_DEBUG_TRIAGE_FOLLOWUP_INFO_2=DEBUG_TRIAGE_FOLLOWUP_INFO_2 -_EXT_CAB_XML_DATA=EXT_CAB_XML_DATA -_DEBUG_ANALYSIS_PROCESSOR_INFO=DEBUG_ANALYSIS_PROCESSOR_INFO -_TANALYZE_RETURN=TANALYZE_RETURN -_CKCL_DATA=CKCL_DATA -_CKCL_LISTHEAD=CKCL_LISTHEAD -_USB_TOPOLOGY_ADDRESS=USB_TOPOLOGY_ADDRESS -_USB_HUB_NODE=USB_HUB_NODE -_USB_HUB_INFORMATION=USB_HUB_INFORMATION -_USB_MI_PARENT_INFORMATION=USB_MI_PARENT_INFORMATION -_USB_NODE_INFORMATION=USB_NODE_INFORMATION -_USB_PIPE_INFO=USB_PIPE_INFO -_USB_CONNECTION_STATUS=USB_CONNECTION_STATUS -_USB_NODE_CONNECTION_INFORMATION=USB_NODE_CONNECTION_INFORMATION -_USB_NODE_CONNECTION_DRIVERKEY_NAME=USB_NODE_CONNECTION_DRIVERKEY_NAME -_USB_NODE_CONNECTION_NAME=USB_NODE_CONNECTION_NAME -_USB_HUB_NAME=USB_HUB_NAME -_USB_ROOT_HUB_NAME=USB_ROOT_HUB_NAME -_USB_HCD_DRIVERKEY_NAME=USB_HCD_DRIVERKEY_NAME -_USB_DESCRIPTOR_REQUEST=USB_DESCRIPTOR_REQUEST -_USB_HUB_CAPABILITIES=USB_HUB_CAPABILITIES -_USB_NODE_CONNECTION_ATTRIBUTES=USB_NODE_CONNECTION_ATTRIBUTES -_USB_NODE_CONNECTION_INFORMATION_EX=USB_NODE_CONNECTION_INFORMATION_EX -_USB_HUB_CAP_FLAGS=USB_HUB_CAP_FLAGS -_USB_HUB_CAPABILITIES_EX=USB_HUB_CAPABILITIES_EX -_USB_CYCLE_PORT_PARAMS=USB_CYCLE_PORT_PARAMS -_USB_ID_STRING=USB_ID_STRING -_USB_HUB_DEVICE_UXD_SETTINGS=USB_HUB_DEVICE_UXD_SETTINGS -_HUB_DEVICE_CONFIG_INFO_V1=HUB_DEVICE_CONFIG_INFO -_HCD_STAT_COUNTERS=HCD_STAT_COUNTERS -_HCD_ISO_STAT_COUNTERS=HCD_ISO_STAT_COUNTERS -_HCD_STAT_INFORMATION_1=HCD_STAT_INFORMATION_1 -_HCD_STAT_INFORMATION_2=HCD_STAT_INFORMATION_2 -_USB_NOTIFICATION_TYPE=USB_NOTIFICATION_TYPE -_USB_NOTIFICATION=USB_NOTIFICATION -_USB_CONNECTION_NOTIFICATION=USB_CONNECTION_NOTIFICATION -_USB_BUS_NOTIFICATION=USB_BUS_NOTIFICATION -_USB_ACQUIRE_INFO=USB_ACQUIRE_INFO -_USB_WMI_DEVICE_NODE_TYPE=USB_WMI_DEVICE_NODE_TYPE -_USB_DEVICE_STATE=USB_DEVICE_STATE -_USB_HUB_PORT_INFORMATION=USB_HUB_PORT_INFORMATION -_USB_HUB_DEVICE_INFO=USB_HUB_DEVICE_INFO -_USB_COMPOSITE_FUNCTION_INFO=USB_COMPOSITE_FUNCTION_INFO -_USB_COMPOSITE_DEVICE_INFO=USB_COMPOSITE_DEVICE_INFO -_USB_CONTROLLER_DEVICE_INFO=USB_CONTROLLER_DEVICE_INFO -_USB_DEVICE_INFO=USB_DEVICE_INFO -_USB_DEVICE_NODE_INFO=USB_DEVICE_NODE_INFO -_USB_DEVICE_PERFORMANCE_INFO=USB_DEVICE_PERFORMANCE_INFO -_USB_HUB_TYPE=USB_HUB_TYPE -_USB_HUB_INFORMATION_EX=USB_HUB_INFORMATION_EX -_USB_PORT_PROPERTIES=USB_PORT_PROPERTIES -_USB_PORT_CONNECTOR_PROPERTIES=USB_PORT_CONNECTOR_PROPERTIES -_USB_PROTOCOLS=USB_PROTOCOLS -_USB_NODE_CONNECTION_INFORMATION_EX_V2_FLAGS=USB_NODE_CONNECTION_INFORMATION_EX_V2_FLAGS -_USB_NODE_CONNECTION_INFORMATION_EX_V2=USB_NODE_CONNECTION_INFORMATION_EX_V2 -_USB_TRANSPORT_CHARACTERISTICS=USB_TRANSPORT_CHARACTERISTICS -_USB_TRANSPORT_CHARACTERISTICS_CHANGE_REGISTRATION=USB_TRANSPORT_CHARACTERISTICS_CHANGE_REGISTRATION -_USB_TRANSPORT_CHARACTERISTICS_CHANGE_NOTIFICATION=USB_TRANSPORT_CHARACTERISTICS_CHANGE_NOTIFICATION -_USB_TRANSPORT_CHARACTERISTICS_CHANGE_UNREGISTRATION=USB_TRANSPORT_CHARACTERISTICS_CHANGE_UNREGISTRATION -_USB_DEVICE_CHARACTERISTICS=USB_DEVICE_CHARACTERISTICS -tagCOINITCOR=COINITICOR -tagCOINITEE=COINITIEE -tagCOUNINITEE=COUNINITIEE CorDebugJITCompilerFlagsDecprecated=CorDebugJITCompilerFlagsDeprecated _COR_VERSION=COR_VERSION _COR_HEAPOBJECT=COR_HEAPOBJECT @@ -12415,477 +709,19 @@ _COR_HEAPINFO=COR_HEAPINFO _COR_ACTIVE_FUNCTION=COR_ACTIVE_FUNCTION _CodeChunkInfo=CodeChunkInfo _CorDebugEHClause=CorDebugEHClause -__MIDL___MIDL_itf_corprof_0000_0000_0003=FunctionIDOrClientID -_COR_PRF_SNAPSHOT_INFO=COR_PRF_SNAPSHOT_INFO -_COR_PRF_FUNCTION_ARGUMENT_RANGE=COR_PRF_FUNCTION_ARGUMENT_RANGE -_COR_PRF_FUNCTION_ARGUMENT_INFO=COR_PRF_FUNCTION_ARGUMENT_INFO -_COR_PRF_CODE_INFO=COR_PRF_CODE_INFO -__MIDL___MIDL_itf_corprof_0000_0000_0004=COR_PRF_STATIC_TYPE -_COR_PRF_FUNCTION=COR_PRF_FUNCTION -_COR_PRF_ASSEMBLY_REFERENCE_INFO=COR_PRF_ASSEMBLY_REFERENCE_INFO -_COR_PRF_METHOD=COR_PRF_METHOD -__MIDL___MIDL_itf_corprof_0000_0000_0005=COR_PRF_MONITOR -__MIDL___MIDL_itf_corprof_0000_0000_0006=COR_PRF_HIGH_MONITOR -__MIDL___MIDL_itf_corprof_0000_0000_0007=COR_PRF_MISC -__MIDL___MIDL_itf_corprof_0000_0000_0008=COR_PRF_JIT_CACHE -__MIDL___MIDL_itf_corprof_0000_0000_0009=COR_PRF_TRANSITION_REASON -__MIDL___MIDL_itf_corprof_0000_0000_0010=COR_PRF_SUSPEND_REASON -__MIDL___MIDL_itf_corprof_0000_0000_0011=COR_PRF_RUNTIME_TYPE -__MIDL___MIDL_itf_corprof_0000_0001_0001=COR_PRF_GC_ROOT_KIND -__MIDL___MIDL_itf_corprof_0000_0001_0002=COR_PRF_GC_ROOT_FLAGS -__MIDL___MIDL_itf_corprof_0000_0001_0003=COR_PRF_FINALIZER_FLAGS -__MIDL___MIDL_itf_corprof_0000_0001_0004=COR_PRF_GC_GENERATION -__MIDL___MIDL_itf_corprof_0000_0001_0005=COR_PRF_CLAUSE_TYPE -__MIDL___MIDL_itf_corprof_0000_0001_0006=COR_PRF_GC_REASON -__MIDL___MIDL_itf_corprof_0000_0001_0007=COR_PRF_MODULE_FLAGS __MIDL___MIDL_itf_corprof_0000_0009_0001=COR_PRF_CODEGEN_FLAGS RPC_WSTR=PWSTR RPC_CSTR=PSTR -_KSSTREAM_SEGMENT=KSSTREAM_SEGMENT -tagContextProperty=ContextProperty -_SIGNER_ATTR_AUTHCODE=SIGNER_ATTR_AUTHCODE -_SIGNER_BLOB_INFO=SIGNER_BLOB_INFO -_SIGNER_CERT_STORE_INFO=SIGNER_CERT_STORE_INFO -_SIGNER_SPC_CHAIN_INFO=SIGNER_SPC_CHAIN_INFO -_SIGNER_CERT=SIGNER_CERT -_SIGNER_CONTEXT=SIGNER_CONTEXT -_SIGNER_DIGEST_SIGN_INFO=SIGNER_DIGEST_SIGN_INFO -_SIGNER_FILE_INFO=SIGNER_FILE_INFO -_SIGNER_PROVIDER_INFO=SIGNER_PROVIDER_INFO -_SIGNER_SIGNATURE_INFO=SIGNER_SIGNATURE_INFO -_SIGNER_SUBJECT_INFO=SIGNER_SUBJECT_INFO -_D3DPrimCaps=D3DPRIMCAPS -_D3DDeviceDesc=D3DDEVICEDESC -_D3DDeviceDesc7=D3DDEVICEDESC7 -_D3DExecuteBufferDesc=D3DEXECUTEBUFFERDESC -_MENUEX_TEMPLATE_HEADER=MENUEX_TEMPLATE_HEADER -_MENUEX_TEMPLATE_ITEM=MENUEX_TEMPLATE_ITEM -_MENUTEMPLATEEX=MENUTEMPLATEEX -__MIDL___MIDL_itf_corprof_0000_0000_0012=COR_PRF_REJIT_FLAGS -__MIDL___MIDL_itf_corprof_0000_0000_0013=COR_PRF_EVENTPIPE_PARAM_TYPE -__MIDL___MIDL_itf_corprof_0000_0000_0014=COR_PRF_EVENTPIPE_LEVEL -__MIDL___MIDL_itf_corprof_0000_0000_0015=COR_PRF_EVENTPIPE_PROVIDER_CONFIG -__MIDL___MIDL_itf_corprof_0000_0000_0016=COR_PRF_EVENTPIPE_PARAM_DESC -__MIDL___MIDL_itf_corprof_0000_0000_0017=COR_PRF_EVENT_DATA -__MIDL___MIDL_itf_corprof_0000_0000_0018=COR_PRF_FILTER_DATA -__MIDL___MIDL_itf_corprof_0000_0011_0001=COR_PRF_CODEGEN_FLAGS -_COR_PRF_HANDLE_TYPE=COR_PRF_HANDLE_TYPE -_NVME_NVM_SUBSYSTEM_RESET=NVME_NVM_SUBSYSTEM_RESET -_NVME_WCS_DEVICE_RESET_ACTION=NVME_WCS_DEVICE_RESET_ACTION -_NVME_WCS_DEVICE_CAPABILITIES=NVME_WCS_DEVICE_CAPABILITIES -_NVME_WCS_DEVICE_RECOVERY_ACTION1=NVME_WCS_DEVICE_RECOVERY_ACTION1 -_NVME_WCS_DEVICE_RECOVERY_ACTION2=NVME_WCS_DEVICE_RECOVERY_ACTION2 -_NVME_WCS_DEVICE_SMART_ATTRIBUTES_LOG=NVME_WCS_DEVICE_SMART_ATTRIBUTES_LOG -_NVME_WCS_DEVICE_SMART_ATTRIBUTES_LOG_V2=NVME_WCS_DEVICE_SMART_ATTRIBUTES_LOG_V2 -_NVME_OCP_DEVICE_SMART_INFORMATION_LOG_V3=NVME_OCP_DEVICE_SMART_INFORMATION_LOG_V3 -_NVME_WCS_DEVICE_ERROR_RECOVERY_LOG=NVME_WCS_DEVICE_ERROR_RECOVERY_LOG -_NVME_OCP_DEVICE_ERROR_RECOVERY_LOG_V2=NVME_OCP_DEVICE_ERROR_RECOVERY_LOG_V2 -_FIRMWARE_ACTIVATION_HISTORY_ENTRY=FIRMWARE_ACTIVATION_HISTORY_ENTRY -_NVME_OCP_DEVICE_FIRMWARE_ACTIVATION_HISTORY_LOG=NVME_OCP_DEVICE_FIRMWARE_ACTIVATION_HISTORY_LOG -_LATENCY_MONITOR_FEATURE_STATUS=LATENCY_MONITOR_FEATURE_STATUS -_ACTIVE_LATENCY_CONFIGURATION=ACTIVE_LATENCY_CONFIGURATION -_BUCKET_COUNTER=BUCKET_COUNTER -_LATENCY_STAMP=LATENCY_STAMP -_MEASURED_LATENCY=MEASURED_LATENCY -_LATENCY_STAMP_UNITS=LATENCY_STAMP_UNITS -_DEBUG_BIT_FIELD=DEBUG_BIT_FIELD -_NVME_OCP_DEVICE_LATENCY_MONITOR_LOG=NVME_OCP_DEVICE_LATENCY_MONITOR_LOG -_DSSD_POWER_STATE_DESCRIPTOR=DSSD_POWER_STATE_DESCRIPTOR -_NVME_OCP_DEVICE_CAPABILITIES_LOG=NVME_OCP_DEVICE_CAPABILITIES_LOG -_UNSUPPORTED_REQUIREMENT=UNSUPPORTED_REQUIREMENT -_NVME_OCP_DEVICE_UNSUPPORTED_REQUIREMENTS_LOG=NVME_OCP_DEVICE_UNSUPPORTED_REQUIREMENTS_LOG -_NVME_OCP_DEVICE_TCG_CONFIGURATION_LOG=NVME_OCP_DEVICE_TCG_CONFIGURATION_LOG -_TCG_HISTORY_ENTRY=TCG_HISTORY_ENTRY -_TCG_AUTH_METHOD_SPECIFIC=TCG_AUTH_METHOD_SPECIFIC -_TCG_ACTIVATE_METHOD_SPECIFIC=TCG_ACTIVATE_METHOD_SPECIFIC -_TCG_REACTIVATE_METHOD_SPECIFIC=TCG_REACTIVATE_METHOD_SPECIFIC -_TCG_ASSIGN_METHOD_SPECIFIC=TCG_ASSIGN_METHOD_SPECIFIC -_TCG_BLOCKSID_METHOD_SPECIFIC=TCG_BLOCKSID_METHOD_SPECIFIC -_NVME_OCP_DEVICE_TCG_HISTORY_LOG=NVME_OCP_DEVICE_TCG_HISTORY_LOG NVME_CDW11_FEATURE_ERROR_INJECTION=NVME_CDW0_FEATURE_ERROR_INJECTION -_NVME_TELEMETRY_HOST_INITIATED_LOG=NVME_TELEMETRY_HOST_INITIATED_LOG -_NVME_TELEMETRY_CONTROLLER_INITIATED_LOG=NVME_TELEMETRY_CONTROLLER_INITIATED_LOG -_SERIALPERF_STATS=SERIALPERF_STATS -_SERIALCONFIG=SERIALCONFIG -_SERIAL_LINE_CONTROL=SERIAL_LINE_CONTROL -_SERIAL_TIMEOUTS=SERIAL_TIMEOUTS -_SERIAL_QUEUE_SIZE=SERIAL_QUEUE_SIZE -_SERIAL_BAUD_RATE=SERIAL_BAUD_RATE -_SERIAL_CHARS=SERIAL_CHARS -_SERIAL_HANDFLOW=SERIAL_HANDFLOW -_SERIAL_BASIC_SETTINGS=SERIAL_BASIC_SETTINGS -_SERIAL_STATUS=SERIAL_STATUS -_SERIAL_XOFF_COUNTER=SERIAL_XOFF_COUNTER -_SERIAL_COMMPROP=SERIAL_COMMPROP -_SERENUM_PORT_DESC=SERENUM_PORT_DESC -_SERENUM_PORTION=SERENUM_PORTION -_SERENUM_PORT_PARAMETERS=SERENUM_PORT_PARAMETERS -tagSPPHRASEALT=SPPHRASEALT -tagSPPHRASEALTREQUEST=SPPHRASEALTREQUEST _PROCESS_MITIGATION_ACTIVATION_CONTEXT_TRUST_POLICY=PROCESS_MITIGATION_ACTIVATION_CONTEXT_TRUST_POLICY -_DNS_QUERY_RAW_RESULT=DNS_QUERY_RAW_RESULT -_DNS_QUERY_RAW_REQUEST=DNS_QUERY_RAW_REQUEST -_DNS_QUERY_RAW_CANCEL=DNS_QUERY_RAW_CANCEL -_SPLCLIENT_INFO_INTERNAL=SPLCLIENT_INFO_INTERNAL -_POLICY_MACHINE_ACCT_INFO2=POLICY_MACHINE_ACCT_INFO2 -_SEC_CHANNEL_BINDINGS_EX=SEC_CHANNEL_BINDINGS_EX -_SEC_CHANNEL_BINDINGS_RESULT=SEC_CHANNEL_BINDINGS_RESULT -_PROCESS_MEMORY_COUNTERS_EX2=PROCESS_MEMORY_COUNTERS_EX2 -CONFIG_CI_PROV_INFO_RESULT2_=CONFIG_CI_PROV_INFO_RESULT2 -_CTAPCBOR_HYBRID_STORAGE_LINKED_DATA=CTAPCBOR_HYBRID_STORAGE_LINKED_DATA -_caldatetime=CALDATETIME -_CONSOLECONTROL=CONSOLECONTROL -_CONSOLEENDTASK=CONSOLEENDTASK -_CONSOLEWINDOWOWNER=CONSOLEWINDOWOWNER -_CONSOLESETFOREGROUND=CONSOLESETFOREGROUND -_CONSOLE_PROCESS_INFO=CONSOLE_PROCESS_INFO -_CONSOLE_CARET_INFO=CONSOLE_CARET_INFO PREGHANDLE=REGHANDLE* -_LLCP_SOCKET_OPTION=NFC_LLCP_SOCKET_OPTION -_SUBSCRIBED_MESSAGE=SUBSCRIBED_MESSAGE -_SECURE_ELEMENT_TYPE=SECURE_ELEMENT_TYPE -_SECURE_ELEMENT_EVENT_TYPE=SECURE_ELEMENT_EVENT_TYPE -_SECURE_ELEMENT_CARD_EMULATION_MODE=SECURE_ELEMENT_CARD_EMULATION_MODE -_SECURE_ELEMENT_ENDPOINT_INFO=SECURE_ELEMENT_ENDPOINT_INFO -_SECURE_ELEMENT_ENDPOINT_LIST=SECURE_ELEMENT_ENDPOINT_LIST -_SECURE_ELEMENT_EVENT_SUBSCRIPTION_INFO=SECURE_ELEMENT_EVENT_SUBSCRIPTION_INFO -_SECURE_ELEMENT_EVENT_INFO=SECURE_ELEMENT_EVENT_INFO -_SECURE_ELEMENT_SET_CARD_EMULATION_MODE_INFO=SECURE_ELEMENT_SET_CARD_EMULATION_MODE_INFO -_SECURE_ELEMENT_NFCC_CAPABILITIES=SECURE_ELEMENT_NFCC_CAPABILITIES -_SECURE_ELEMENT_ROUTING_TYPE=SECURE_ELEMENT_ROUTING_TYPE -_SECURE_ELEMENT_TECH_ROUTING_INFO=SECURE_ELEMENT_TECH_ROUTING_INFO -_SECURE_ELEMENT_PROTO_ROUTING_INFO=SECURE_ELEMENT_PROTO_ROUTING_INFO -_SECURE_ELEMENT_AID_ROUTING_INFO=SECURE_ELEMENT_AID_ROUTING_INFO -_SECURE_ELEMENT_ROUTING_TABLE_ENTRY=SECURE_ELEMENT_ROUTING_TABLE_ENTRY -_SECURE_ELEMENT_ROUTING_TABLE=SECURE_ELEMENT_ROUTING_TABLE -_SECURE_ELEMENT_HCE_ACTIVATION_PAYLOAD=SECURE_ELEMENT_HCE_ACTIVATION_PAYLOAD -_SECURE_ELEMENT_HCE_DATA_PACKET=SECURE_ELEMENT_HCE_DATA_PACKET -_SECURE_ELEMENT_POWER_MODE=SECURE_ELEMENT_POWER_MODE -_SECURE_ELEMENT_SET_POWER_MODE_INFO=SECURE_ELEMENT_SET_POWER_MODE_INFO -_NFC_RF_DISCOVERY_MODE=NFC_RF_DISCOVERY_MODE -_NFC_RF_DISCOVERY_CONFIG=NFC_RF_DISCOVERY_CONFIG -_NFC_P2P_MODE=NFC_P2P_MODE -_NFC_P2P_PARAM_CONFIG=NFC_P2P_PARAM_CONFIG -_NFC_DEVICE_TYPE=NFC_DEVICE_TYPE -_NFC_REMOTE_DEV_INFO=NFC_REMOTE_DEV_INFO -_NFC_RELEASE_TYPE=NFC_RELEASE_TYPE -_NFC_REMOTE_DEVICE_DISCONNET=NFC_REMOTE_DEVICE_DISCONNET -_NFC_DATA_BUFFER=NFC_DATA_BUFFER -_NFC_REMOTE_DEV_SEND_INFO=NFC_REMOTE_DEV_SEND_INFO -_NFC_REMOTE_DEV_RECV_INFO=NFC_REMOTE_DEV_RECV_INFO -_NFC_NDEF_INFO=NFC_NDEF_INFO -_NFC_LLCP_CONFIG=NFC_LLCP_CONFIG -_NFC_LLCP_SERVICE_NAME_ENTRY=NFC_LLCP_SERVICE_NAME_ENTRY -_NFC_LLCP_SERVICE_DISCOVER_REQUEST=NFC_LLCP_SERVICE_DISCOVER_REQUEST -_NFC_LLCP_SERVICE_DISCOVER_SAP=NFC_LLCP_SERVICE_DISCOVER_SAP -_NFC_LLCP_SOCKET_TYPE=NFC_LLCP_SOCKET_TYPE -_NFC_LLCP_LINK_STATUS=NFC_LLCP_LINK_STATUS -_NFC_LLCP_SOCKET_INFO=NFC_LLCP_SOCKET_INFO -_NFC_LLCP_SOCKET_SERVICE_INFO=NFC_LLCP_SOCKET_SERVICE_INFO -_NFC_LLCP_SOCKET_PAYLOAD=NFC_LLCP_SOCKET_PAYLOAD -_NFC_LLCP_SOCKET_ACCEPT_INFO=NFC_LLCP_SOCKET_ACCEPT_INFO -_NFC_LLCP_SOCKET_CONNECT_TYPE=NFC_LLCP_SOCKET_CONNECT_TYPE -_NFC_LLCP_SOCKET_CONNECT_INFO=NFC_LLCP_SOCKET_CONNECT_INFO -_NFC_LLCP_SOCKET_CL_PAYLOAD=NFC_LLCP_SOCKET_CL_PAYLOAD -_NFC_LLCP_SOCKET_ERROR=NFC_LLCP_SOCKET_ERROR -_NFC_LLCP_SOCKET_ERROR_INFO=NFC_LLCP_SOCKET_ERROR_INFO -_NFC_SNEP_SERVER_TYPE=NFC_SNEP_SERVER_TYPE -_NFC_SNEP_REQUEST_TYPE=NFC_SNEP_REQUEST_TYPE -_NFC_SNEP_SERVER_INFO=NFC_SNEP_SERVER_INFO -_NFC_SNEP_SERVER_ACCEPT_INFO=NFC_SNEP_SERVER_ACCEPT_INFO -_NFC_SNEP_SERVER_REQUEST=NFC_SNEP_SERVER_REQUEST -_NFC_SNEP_SERVER_RESPONSE_INFO=NFC_SNEP_SERVER_RESPONSE_INFO -_NFC_SNEP_CLIENT_INFO=NFC_SNEP_CLIENT_INFO -_NFC_SNEP_CLIENT_PUT_INFO=NFC_SNEP_CLIENT_PUT_INFO -_NFC_SNEP_CLIENT_GET_INFO=NFC_SNEP_CLIENT_GET_INFO -_NFC_SE_EMULATION_MODE=NFC_SE_EMULATION_MODE -_NFC_SE_INFO=NFC_SE_INFO -_NFC_SE_LIST=NFC_SE_LIST -_NFC_SE_EMULATION_MODE_INFO=NFC_SE_EMULATION_MODE_INFO -_NFC_SE_TECH_ROUTING_INFO=NFC_SE_TECH_ROUTING_INFO -_NFC_SE_PROTO_ROUTING_INFO=NFC_SE_PROTO_ROUTING_INFO -_NFC_SE_AID_ROUTING_INFO=NFC_SE_AID_ROUTING_INFO -_NFC_SE_ROUTING_TABLE_ENTRY=NFC_SE_ROUTING_TABLE_ENTRY -_NFC_SE_ROUTING_TABLE=NFC_SE_ROUTING_TABLE -_NFC_SE_EVENT_INFO=NFC_SE_EVENT_INFO -_NFCRM_SET_RADIO_STATE=NFCRM_SET_RADIO_STATE -_NFCRM_RADIO_STATE=NFCRM_RADIO_STATE -_GROUP_AFFINITY32=GROUP_AFFINITY32 -_GROUP_AFFINITY64=GROUP_AFFINITY64 -_XSAVE_ARM64_SVE_HEADER=XSAVE_ARM64_SVE_HEADER -_ATTRIBUTES_AND_SID=ATTRIBUTES_AND_SID -_TOKEN_LOGGING_INFORMATION=TOKEN_LOGGING_INFORMATION -_PROCESS_NETWORK_COUNTERS=PROCESS_NETWORK_COUNTERS -_JOBOBJECT_NETWORK_ACCOUNTING_INFORMATION=JOBOBJECT_NETWORK_ACCOUNTING_INFORMATION -_SERVERSILO_DIAGNOSTIC_INFORMATION=SERVERSILO_DIAGNOSTIC_INFORMATION -_FILE_STAT_INFORMATION=FILE_STAT_INFORMATION -_FILE_STAT_LX_INFORMATION=FILE_STAT_LX_INFORMATION -_FILE_STAT_BASIC_INFORMATION=FILE_STAT_BASIC_INFORMATION -_FILE_CASE_SENSITIVE_INFORMATION=FILE_CASE_SENSITIVE_INFORMATION -_ENERGY_SAVER_STATUS=ENERGY_SAVER_STATUS -_POWER_LIMIT_TYPES=POWER_LIMIT_TYPES -_POWER_LIMIT_ATTRIBUTES=POWER_LIMIT_ATTRIBUTES -_POWER_LIMIT_VALUE=POWER_LIMIT_VALUE -_IMAGE_IMPORT_CONTROL_TRANSFER_ARM64_RELOCATION=IMAGE_IMPORT_CONTROL_TRANSFER_ARM64_RELOCATION -_IMAGE_HOT_PATCH_MACHINE=IMAGE_HOT_PATCH_MACHINE -_MINIDUMP_SYSTEM_PERFORMANCE_INFORMATION_2=MINIDUMP_SYSTEM_PERFORMANCE_INFORMATION_2 -_MINIDUMP_SYSTEM_MEMORY_INFO_2=MINIDUMP_SYSTEM_MEMORY_INFO_2 -_DISCRIMINATEDUNION_TAG_VALUE=DISCRIMINATEDUNION_TAG_VALUE -_TI_GET_DISCRIMINATEDUNION_TAG_RANGES_PARAMS=TI_GET_DISCRIMINATEDUNION_TAG_RANGES_PARAMS -_DIMM_ADDRESS=DIMM_ADDRESS -_PAGE_OFFLINE_ERROR_TYPES=PAGE_OFFLINE_ERROR_TYPES -_PAGE_OFFLINE_VALID_BITS=PAGE_OFFLINE_VALID_BITS -_DIMM_ADDR_VALID_BITS_DDR4=DIMM_ADDR_VALID_BITS_DDR4 -_DIMM_ADDR_VALID_BITS_DDR5=DIMM_ADDR_VALID_BITS_DDR5 -_DIMM_ADDR_VALID_BITS=DIMM_ADDR_VALID_BITS -_DIMM_INFO=DIMM_INFO -_MEMORY_DEFECT=MEMORY_DEFECT -_PS_TRUSTLET_TKSESSION_ID=PS_TRUSTLET_TKSESSION_ID -_TRUSTLET_BINDING_DATA=TRUSTLET_BINDING_DATA -_STORAGE_CRYPTO_CAPABILITY_V2=STORAGE_CRYPTO_CAPABILITY_V2 -_STORAGE_ICE_TYPE=STORAGE_ICE_TYPE -_STORAGE_CRYPTO_DESCRIPTOR_V2=STORAGE_CRYPTO_DESCRIPTOR_V2 -_STORAGE_STACK_TYPE=STORAGE_STACK_TYPE -_STORAGE_STACK_DESCRIPTOR=STORAGE_STACK_DESCRIPTOR -_DEVICE_DSM_QUERY_PREFER_LOCAL_REPAIR_OUTPUT=DEVICE_DSM_QUERY_PREFER_LOCAL_REPAIR_OUTPUT -_DNS_DOT_SERVER_SETTINGS=DNS_DOT_SERVER_SETTINGS -_NET_FL_VIRTUAL_INTERFACE_ORIGIN=NET_FL_VIRTUAL_INTERFACE_ORIGIN -_NET_FL_ISOLATION_MODE=NET_FL_ISOLATION_MODE -_MIB_FL_VIRTUAL_INTERFACE_ROW=MIB_FL_VIRTUAL_INTERFACE_ROW -_MIB_FL_VIRTUAL_INTERFACE_TABLE=MIB_FL_VIRTUAL_INTERFACE_TABLE -tagKSCAMERA_EXTENDEDPROP_FIELDOFVIEW2_CONFIGCAPS=KSCAMERA_EXTENDEDPROP_FIELDOFVIEW2_CONFIGCAPS -tagAUDIOLOOPBACK_TAPPOINT_TYPE=AUDIOLOOPBACK_TAPPOINT_TYPE -tagKSATTRIBUTE_AUDIOLOOPBACK_TAPPOINT=KSATTRIBUTE_AUDIOLOOPBACK_TAPPOINT TOUCHPAD_PARAMETERS=TOUCHPAD_PARAMETERS_V1 -__MIDL___MIDL_itf_mfobjects_0000_0009_0003=MFT_REGISTER_TYPE_INFO -__MIDL___MIDL_itf_mfobjects_0000_0018_0001=MF_FILE_ACCESSMODE -__MIDL___MIDL_itf_mfobjects_0000_0018_0002=MF_FILE_OPENMODE -__MIDL___MIDL_itf_mfobjects_0000_0018_0003=MF_FILE_FLAGS -__MIDL___MIDL_itf_mfidl_0000_0139_0001=DetectedFaceBound -_WINHTTP_PROTOCOL_OPERATION=WINHTTP_PROTOCOL_OPERATION -_WINHTTP_PROTOCOL_ASYNC_RESULT=WINHTTP_PROTOCOL_ASYNC_RESULT -_WINHTTP_FAST_FORWARDING_STATE=WINHTTP_FAST_FORWARDING_STATE -_WINHTTP_FAST_FORWARDING_STATUS=WINHTTP_FAST_FORWARDING_STATUS -_PROCESS_CREATION_SVE_VECTOR_LENGTH=PROCESS_CREATION_SVE_VECTOR_LENGTH -_COPYFILE2_CREATE_OPLOCK_KEYS=COPYFILE2_CREATE_OPLOCK_KEYS -addrinfoex7=ADDRINFOEX7 -_TCP_INFO_v2=TCP_INFO_v2 -__MIDL___MIDL_itf_audioenginebaseapo_0000_0012_0001=AudioFXExtensionParams -_FILE_INFO_BY_NAME_CLASS=FILE_INFO_BY_NAME_CLASS -_USBD_ENDPOINT_OFFLOAD_INFORMATION_V1=USBD_ENDPOINT_OFFLOAD_INFORMATION_V1 -_USB_NODE_CONNECTION_SUPERSPEEDPLUS_INFORMATION=USB_NODE_CONNECTION_SUPERSPEEDPLUS_INFORMATION -_POOL_HEADER_SIZE_64=POOL_HEADER_SIZE_64 -_POOL_HEADER_FIELD_NAME=POOL_HEADER_FIELD_NAME IDxcBlobWide=IDxcBlobUtf16 -_DISPLAYCONFIG_ADVANCED_COLOR_MODE=DISPLAYCONFIG_ADVANCED_COLOR_MODE -_DISPLAYCONFIG_GET_ADVANCED_COLOR_INFO_2=DISPLAYCONFIG_GET_ADVANCED_COLOR_INFO_2 -_DISPLAYCONFIG_SET_HDR_STATE=DISPLAYCONFIG_SET_HDR_STATE -_DISPLAYCONFIG_SET_WCG_STATE=DISPLAYCONFIG_SET_WCG_STATE -_HTTP_FAST_FORWARD_INFO=HTTP_FAST_FORWARD_INFO -_HTTP_WINHTTP_FAST_FORWARDING_DATA=HTTP_WINHTTP_FAST_FORWARDING_DATA -_HTTP_CERT_CONFIG_ENTRY=HTTP_CERT_CONFIG_ENTRY -_HTTP_CERT_CONFIG_PARAM=HTTP_CERT_CONFIG_PARAM -_KERB_CHANGEMACHINEPASSWORD_REQUEST=KERB_CHANGEMACHINEPASSWORD_REQUEST -_SEC_APP_SESSION_STATE=SEC_APP_SESSION_STATE -_SEC_SESSION_TICKET=SEC_SESSION_TICKET -_SecPkgCredentials_KdcNetworkSettingsW=SecPkgCredentials_KdcNetworkSettingsW -_NETLOGON_TARGET_INFO=NETLOGON_TARGET_INFO -_WIN32_MEMORY_NUMA_PERFORMANCE_ENTRY=WIN32_MEMORY_NUMA_PERFORMANCE_ENTRY -_WIN32_MEMORY_NUMA_PERFORMANCE_INFORMATION_OUTPUT=WIN32_MEMORY_NUMA_PERFORMANCE_INFORMATION_OUTPUT -_REPAIR_CLUSTER_NAME_ACCOUNT_CONFIG=REPAIR_CLUSTER_NAME_ACCOUNT_CONFIG -_MSA_INFO_ACCOUNT_TYPE=MSA_INFO_ACCOUNT_TYPE -_MSA_INFO_1=MSA_INFO_1 -_TRANSPORT_INFO_FLAG=TRANSPORT_INFO_FLAG -_BLOCK_NTLM_INFO=BLOCK_NTLM_INFO -_USE_OPTION_BLOCK_NTLM_PARAMETERS=USE_OPTION_BLOCK_NTLM_PARAMETERS -_WLAN_QOS_CAPABILITIES=WLAN_QOS_CAPABILITIES -_WLAN_CONNECTION_QOS_INFO=WLAN_CONNECTION_QOS_INFO -_WLAN_QOS_INFO=WLAN_QOS_INFO -_WLAN_REALTIME_CONNECTION_QUALITY_LINK_INFO=WLAN_REALTIME_CONNECTION_QUALITY_LINK_INFO -_WLAN_REALTIME_CONNECTION_QUALITY=WLAN_REALTIME_CONNECTION_QUALITY -_SIPAEVENT_REFS_ROLLBACK_PROTECTION_USER_PAYLOAD_HASH_DATA=SIPAEVENT_REFS_ROLLBACK_PROTECTION_USER_PAYLOAD_HASH_DATA -_PLUTON_UPGRADE_IMAGEDATA=PLUTON_UPGRADE_IMAGEDATA -tag_SIPAEVENT_SI_POLICY_CERTIFICATE_PAYLOAD=SIPAEVENT_SI_POLICY_CERTIFICATE_PAYLOAD -tag_SIPAEVENT_SI_POLICY_SIGNER_PAYLOAD=SIPAEVENT_SI_POLICY_SIGNER_PAYLOAD -_BCRYPT_PKCS11_RSA_AES_WRAP_BLOB=BCRYPT_PKCS11_RSA_AES_WRAP_BLOB -_NCRYPT_VBS_ROOT_ATTESTATION_HEADER=NCRYPT_VBS_ROOT_ATTESTATION_HEADER -_NCRYPT_VBS_IDENTITY_ATTESTATION_PADDING=NCRYPT_VBS_IDENTITY_ATTESTATION_PADDING -_NCRYPT_VBS_IDENTITY_ATTESTATION_HEADER=NCRYPT_VBS_IDENTITY_ATTESTATION_HEADER -_NCRYPT_VBS_KEY_ATTESTATION_STATEMENT=NCRYPT_VBS_KEY_ATTESTATION_STATEMENT -_NCRYPT_VBS_ROOT_KEY_ATTESTATION_CLAIM_DETAILS=NCRYPT_VBS_ROOT_KEY_ATTESTATION_CLAIM_DETAILS -_NCRYPT_VBS_IDENTITY_KEY_ATTESTATION_CLAIM_DETAILS=NCRYPT_VBS_IDENTITY_KEY_ATTESTATION_CLAIM_DETAILS -_CT_EXTRA_CERT_CHAIN_POLICY_STATUS=CT_EXTRA_CERT_CHAIN_POLICY_STATUS -MS_ADDINFO_DETACHEDSIG_=MS_ADDINFO_DETACHEDSIG -WINTRUST_DETACHED_SIG_HANDLES_=WINTRUST_DETACHED_SIG_FILE_HANDLES -WINTRUST_DETACHED_SIG_BLOBS_=WINTRUST_DETACHED_SIG_BLOBS -WINTRUST_DETACHED_SIG_INFO_=WINTRUST_DETACHED_SIG_INFO -_NVME_CONTROLLER_TYPE=NVME_CONTROLLER_TYPE -_NVME_PROPERTY_OFFSET=NVME_PROPERTY_OFFSET -_NVME_NVM_SUBSYSTEM_SHUTDOWN=NVME_NVM_SUBSYSTEM_SHUTDOWN -_NVME_CONTROLLER_READY_TIMEOUTS=NVME_CONTROLLER_READY_TIMEOUTS -_NVME_SGL_DESC_TYPE=NVME_SGL_DESC_TYPE -_NVME_SGL_DESC_SUBTYPE=NVME_SGL_DESC_SUBTYPE -_NVME_SGL_DESC=NVME_SGL_DESC -_NVME_SGL_DATABLOCK_DESC=NVME_SGL_DATABLOCK_DESC -_NVME_SGL_BITBUCKET_DESC=NVME_SGL_BITBUCKET_DESC -_NVME_SGL_SEGMENT_DESC=NVME_SGL_SEGMENT_DESC -_NVME_SGL_LASTSEG_DESC=NVME_SGL_LASTSEG_DESC -_NVME_SGL_KEYDATABLOCK_DESC=NVME_SGL_KEYDATABLOCK_DESC -_NVME_SGL_TRANSPORTDATA_DESC=NVME_SGL_TRANSPORTDATA_DESC -_NVMEOF_TRANSPORT_TYPE=NVMEOF_TRANSPORT_TYPE -_NVMEOF_ADDRESS_FAMILY=NVMEOF_ADDRESS_FAMILY -_NVMEOF_SUBSYSTEM_TYPE=NVMEOF_SUBSYSTEM_TYPE -_NVMEOF_SECURE_CHANNEL=NVMEOF_SECURE_CHANNEL -_NVMEOF_FABRICS_COMMAND=NVMEOF_FABRICS_COMMAND -_NVMEOF_FABRICS_RESPONSE=NVMEOF_FABRICS_RESPONSE -_NVMEOF_CONNECT_COMMAND=NVMEOF_CONNECT_COMMAND -_NVMEOF_CONNECT_DATA=NVMEOF_CONNECT_DATA -_NVMEOF_CONNECT_RESPONSE=NVMEOF_CONNECT_RESPONSE -_NVMEOF_DISCONNECT_COMMAND=NVMEOF_DISCONNECT_COMMAND -_NVMEOF_DISCONNECT_RESPONSE=NVMEOF_DISCONNECT_RESPONSE -_NVMEOF_PROPERTY_GET_COMMAND=NVMEOF_PROPERTY_GET_COMMAND -_NVMEOF_PROPERTY_GET_RESPONSE=NVMEOF_PROPERTY_GET_RESPONSE -_NVMEOF_PROPERTY_SET_COMMAND=NVMEOF_PROPERTY_SET_COMMAND -_NVMEOF_PROPERTY_SET_RESPONSE=NVMEOF_PROPERTY_SET_RESPONSE -_NVMEOF_AUTH_RECEIVE_COMMAND=NVMEOF_AUTH_RECEIVE_COMMAND -_NVMEOF_AUTH_RECEIVE_RESPONSE=NVMEOF_AUTH_RECEIVE_RESPONSE -_NVMEOF_AUTH_SEND_COMMAND=NVMEOF_AUTH_SEND_COMMAND -_NVMEOF_AUTH_SEND_RESPONSE=NVMEOF_AUTH_SEND_RESPONSE _NVMEOF_DISC_LPE=NVMEOF_DISC_LPE _NVMEOF_DISC_LOGPAGE=NVMEOF_DISC_LOGPAGE -FWPM_LAYER_STATISTICS1_=FWPM_LAYER_STATISTICS1 -FWPM_STATISTICS1_=FWPM_STATISTICS1 -_PROOF_OF_POSSESSION_FLAGS=PROOF_OF_POSSESSION_FLAGS -_EXPERIMENTAL_PLUGIN_AUTHENTICATOR_STATE=EXPERIMENTAL_PLUGIN_AUTHENTICATOR_STATE -_EXPERIMENTAL_WEBAUTHN_PLUGIN_ADD_AUTHENTICATOR_OPTIONS=EXPERIMENTAL_WEBAUTHN_PLUGIN_ADD_AUTHENTICATOR_OPTIONS -_EXPERIMENTAL_WEBAUTHN_PLUGIN_ADD_AUTHENTICATOR_RESPONSE=EXPERIMENTAL_WEBAUTHN_PLUGIN_ADD_AUTHENTICATOR_RESPONSE _EXPERIMENTAL_WEBAUTHN_PLUGIN_REMOVE_AUTHENTICATOR_OPTIONS=EXPERIMENTAL_WEBAUTHN_PLUGIN_REMOVE_AUTHENTICATOR_OPTIONS -_EXPERIMENTAL_WEBAUTHN_PLUGIN_UPDATE_AUTHENTICATOR_DETAILS=EXPERIMENTAL_WEBAUTHN_PLUGIN_UPDATE_AUTHENTICATOR_DETAILS -_EXPERIMENTAL_WEBAUTHN_PLUGIN_CREDENTIAL_DETAILS=EXPERIMENTAL_WEBAUTHN_PLUGIN_CREDENTIAL_DETAILS -_EXPERIMENTAL_WEBAUTHN_PLUGIN_CREDENTIAL_DETAILS_LIST=EXPERIMENTAL_WEBAUTHN_PLUGIN_CREDENTIAL_DETAILS_LIST -_EXPERIMENTAL_WEBAUTHN_PLUGIN_PERFORM_UV_OPERATION_TYPE=EXPERIMENTAL_WEBAUTHN_PLUGIN_PERFORM_UV_OPERATION_TYPE -_EXPERIMENTAL_WEBAUTHN_PLUGIN_PERFORM_UV=EXPERIMENTAL_WEBAUTHN_PLUGIN_PERFORM_UV -_EXPERIMENTAL_WEBAUTHN_PLUGIN_PERFORM_UV_RESPONSE=EXPERIMENTAL_WEBAUTHN_PLUGIN_PERFORM_UV_RESPONSE -_EXPERIMENTAL_WEBAUTHN_CTAPCBOR_AUTHENTICATOR_OPTIONS=EXPERIMENTAL_WEBAUTHN_CTAPCBOR_AUTHENTICATOR_OPTIONS -_EXPERIMENTAL_WEBAUTHN_CTAPCBOR_ECC_PUBLIC_KEY=EXPERIMENTAL_WEBAUTHN_CTAPCBOR_ECC_PUBLIC_KEY -_EXPERIMENTAL_WEBAUTHN_CTAPCBOR_HMAC_SALT_EXTENSION=EXPERIMENTAL_WEBAUTHN_CTAPCBOR_HMAC_SALT_EXTENSION -_EXPERIMENTAL_WEBAUTHN_CTAPCBOR_MAKE_CREDENTIAL_REQUEST=EXPERIMENTAL_WEBAUTHN_CTAPCBOR_MAKE_CREDENTIAL_REQUEST -_EXPERIMENTAL_WEBAUTHN_CTAPCBOR_GET_ASSERTION_REQUEST=EXPERIMENTAL_WEBAUTHN_CTAPCBOR_GET_ASSERTION_REQUEST -_EXPERIMENTAL_WEBAUTHN_CTAPCBOR_GET_ASSERTION_RESPONSE=EXPERIMENTAL_WEBAUTHN_CTAPCBOR_GET_ASSERTION_RESPONSE -tagDownloadType=DownloadType -_USB4_HRD_DEBUG_ROUTE_STRING=USB4_HRD_DEBUG_ROUTE_STRING -_USB4_HRD_DEBUG_READ_CONFIGURATION_SPACE_INPUT=USB4_HRD_DEBUG_READ_CONFIGURATION_SPACE_INPUT -_USB4_HRD_DEBUG_READ_CONFIGURATION_SPACE_OUTPUT=USB4_HRD_DEBUG_READ_CONFIGURATION_SPACE_OUTPUT -__MIDL___MIDL_itf_searchapi_0000_0024_0001=ROWSETEVENT_ITEMSTATE -__MIDL___MIDL_itf_searchapi_0000_0024_0002=ROWSETEVENT_TYPE -__MIDL___MIDL_itf_searchapi_0000_0023_0001=PRIORITY_LEVEL -_SYSTEM_BASICPROCESS_INFORMATION=SYSTEM_BASICPROCESS_INFORMATION -_SYSTEM_HANDLECOUNT_INFORMATION=SYSTEM_HANDLECOUNT_INFORMATION -nd_opt_pref64_info=ND_OPTION_PREF64 -_EUSB2_ISOCH_ENDPOINT_COMPANION_DESCRIPTOR=EUSB2_ISOCH_ENDPOINT_COMPANION_DESCRIPTOR -_CREATEFILE3_EXTENDED_PARAMETERS=CREATEFILE3_EXTENDED_PARAMETERS -_HTTP_REQUEST_TRANSPORT_IDLE_CONNECTION_TIMEOUT_INFO=HTTP_REQUEST_TRANSPORT_IDLE_CONNECTION_TIMEOUT_INFO -_HTTP_REQUEST_DSCP_INFO=HTTP_REQUEST_DSCP_INFO -_HTTP_REQUEST_INITIAL_PACKET_TTL_INFO=HTTP_REQUEST_INITIAL_PACKET_TTL_INFO -_SECPKG_FAILURE_SPECIAL_REASON=SECPKG_FAILURE_SPECIAL_REASON -_SECPKG_FAILURE_REASON=SECPKG_FAILURE_REASON -_POWER_ADAPTER_POWER_STATES=POWER_ADAPTER_POWER_STATES -_POWER_ADAPTER_STATUS=POWER_ADAPTER_STATUS -_POWER_ADAPTER_SET_STATUS_BUFFER=POWER_ADAPTER_SET_STATUS_BUFFER -_POWER_ADAPTER_CHARGE_REQUIREMENT=POWER_ADAPTER_CHARGE_REQUIREMENT -_CUSTOMIZED_IO_CAPABILITIES=CUSTOMIZED_IO_CAPABILITIES -_CUSTOMIZED_IO_QUERY_INPUT_RETURN=CUSTOMIZED_IO_QUERY_INPUT_RETURN -_CUSTOMIZED_IO_SEND_OUTPUT_BUFFER=CUSTOMIZED_IO_SEND_OUTPUT_BUFFER -_NVME_COMMAND_STATUS=NVME_COMMAND_STATUS -_NVME_DISC_CTRL_TYPE=NVME_DISC_CTRL_TYPE -_NVME_RDMA_KEYED_SGL_DESC_SUBTYPE=NVME_RDMA_KEYED_SGL_DESC_SUBTYPE -_NVMEOF_AUTH_SECURE_CHANNEL=NVMEOF_AUTH_SECURE_CHANNEL -_NVME_DISCOVERY_ENTRY=NVME_DISCOVERY_ENTRY -_NVME_EXTENDED_DISCOVERY_ENTRY=NVME_EXTENDED_DISCOVERY_ENTRY -_NVME_EXTENDED_ATTR_TYPE=NVME_EXTENDED_ATTR_TYPE -_NVME_EXTENDED_ATTR=NVME_EXTENDED_ATTR -_NVME_DISCOVERY_HEADER=NVME_DISCOVERY_HEADER -_NVME_DISCOVERY_INFO_MGMT_HEADER=NVME_DISCOVERY_INFO_MGMT_HEADER -_NVMEOF_AUTH_PROTOCOL=NVMEOF_AUTH_PROTOCOL -_NVMEOF_AUTH_TYPE=NVMEOF_AUTH_TYPE -_NVMEOF_AUTH_ID=NVMEOF_AUTH_ID -_NVMEOF_SECURE_CHANNEL_PROTOCOL=NVMEOF_SECURE_CHANNEL_PROTOCOL -_NVMEOF_AUTH_FAIL_REASON_CODE=NVMEOF_AUTH_FAIL_REASON_CODE -_NVMEOF_AUTH_FAIL_REASON_EXPLANATION=NVMEOF_AUTH_FAIL_REASON_EXPLANATION -_NVMEOF_AUTH_NEGOTIATE=NVMEOF_AUTH_NEGOTIATE -_NVMEOF_AUTH_FAILURE=NVMEOF_AUTH_FAILURE -_NVMEOF_AUTH_DHCHAP_HASH_ID=NVMEOF_AUTH_DHCHAP_HASH_ID -_NVMEOF_AUTH_DHCHAP_GROUP_ID=NVMEOF_AUTH_DHCHAP_GROUP_ID -_NVMEOF_AUTH_DHCHAP_DESCRIPTOR=NVMEOF_AUTH_DHCHAP_DESCRIPTOR -_NVMEOF_AUTH_DHCHAP_CHALLENGE=NVMEOF_AUTH_DHCHAP_CHALLENGE -_NVMEOF_AUTH_DHCHAP_REPLY=NVMEOF_AUTH_DHCHAP_REPLY -_NVMEOF_AUTH_DHCHAP_SUCCESS1=NVMEOF_AUTH_DHCHAP_SUCCESS1 -_NVMEOF_AUTH_DHCHAP_SUCCESS2=NVMEOF_AUTH_DHCHAP_SUCCESS2 -_WTS_SERIALIZED_USER_CREDENTIAL=WTS_SERIALIZED_USER_CREDENTIAL -tagCloudCampaignSpec=CloudCampaignAssessment _EXPERIMENTAL2_PLUGIN_AUTHENTICATOR_STATE=EXPERIMENTAL2_PLUGIN_AUTHENTICATOR_STATE _EXPERIMENTAL2_WEBAUTHN_PLUGIN_ADD_AUTHENTICATOR_OPTIONS=EXPERIMENTAL2_WEBAUTHN_PLUGIN_ADD_AUTHENTICATOR_OPTIONS _EXPERIMENTAL2_WEBAUTHN_PLUGIN_UPDATE_AUTHENTICATOR_DETAILS=EXPERIMENTAL2_WEBAUTHN_PLUGIN_UPDATE_AUTHENTICATOR_DETAILS _EXPERIMENTAL2_WEBAUTHN_PLUGIN_CREDENTIAL_DETAILS=EXPERIMENTAL2_WEBAUTHN_PLUGIN_CREDENTIAL_DETAILS _EXPERIMENTAL2_WEBAUTHN_PLUGIN_USER_VERIFICATION_REQUEST=EXPERIMENTAL2_WEBAUTHN_PLUGIN_USER_VERIFICATION_REQUEST -_SYSTEM_POWER_SOURCE_STATE=SYSTEM_POWER_SOURCE_STATE -_COLORSPACE_SCALAR_MULTIPLIER_CAPS=COLORSPACE_SCALAR_MULTIPLIER_CAPS -_STORAGE_FEATURE_SUPPORT=STORAGE_FEATURE_SUPPORT -_STORAGE_SECURITY_COMPLIANCE_BITMASK=STORAGE_SECURITY_COMPLIANCE_BITMASK -_STORAGE_CRYPTO_KEY_TYPE=STORAGE_CRYPTO_KEY_TYPE -_STORAGE_HW_CRYPTO_CAPABILITY=STORAGE_HW_CRYPTO_CAPABILITY -_STORAGE_HW_CRYPTO_DESCRIPTOR=STORAGE_HW_CRYPTO_DESCRIPTOR -_VideoDXFormat=VIDEOFORMAT_DX12 -_WINDOW_PLACEMENT_STATE=WINDOW_PLACEMENT_STATE -_WINDOW_ACTION_KINDS=WINDOW_ACTION_KINDS -_WINDOW_ACTION_MODIFIERS=WINDOW_ACTION_MODIFIERS -_WINDOW_ACTION=WINDOW_ACTION -_MOVESIZE_OPERATION=MOVESIZE_OPERATION -_MFSampleExtensionPsnrYuv=MFSampleExtensionPsnrYuv -_DO_DOWNLOAD_RANGE=DO_DOWNLOAD_RANGE -_DO_DOWNLOAD_RANGES_INFO=DO_DOWNLOAD_RANGES_INFO -_DODownloadState=DODownloadState -_DO_DOWNLOAD_STATUS=DO_DOWNLOAD_STATUS -_DODownloadCostPolicy=DODownloadCostPolicy -_DODownloadProperty=DODownloadProperty -_DO_DOWNLOAD_ENUM_CATEGORY=DO_DOWNLOAD_ENUM_CATEGORY -_RUNTIME_REPORT_TYPE=RUNTIME_REPORT_TYPE -_RUNTIME_REPORT_PACKAGE_HEADER=RUNTIME_REPORT_PACKAGE_HEADER -_RUNTIME_REPORT_DIGEST_HEADER=RUNTIME_REPORT_DIGEST_HEADER -_RUNTIME_REPORT_HEADER=RUNTIME_REPORT_HEADER -_DRIVER_INFO_ENTRY=DRIVER_INFO_ENTRY -_DRIVER_RUNTIME_REPORT=DRIVER_RUNTIME_REPORT -tagTOUCHPAD_PARAMETERS_V2=TOUCHPAD_PARAMETERS_V2 -_eAVEncVideoQPMapElementDataType=eAVEncVideoQPMapElementDataType -_inputQPSettings=InputQPSettings -_HTTP_REQUEST_INFO_PROPERTY_INFO=HTTP_REQUEST_INFO_PROPERTY_INFO -_WINBIO_CONNECTED_SENSOR=WINBIO_CONNECTED_SENSOR -_BCRYPT_PQDSA_PADDING_INFO=BCRYPT_PQDSA_PADDING_INFO -_NCRYPT_PQ_BLOB=NCRYPT_PQ_BLOB -_WEBAUTHN_AUTHENTICATOR_DETAILS_OPTIONS=WEBAUTHN_AUTHENTICATOR_DETAILS_OPTIONS -_WEBAUTHN_AUTHENTICATOR_DETAILS=WEBAUTHN_AUTHENTICATOR_DETAILS -_WEBAUTHN_AUTHENTICATOR_DETAILS_LIST=WEBAUTHN_AUTHENTICATOR_DETAILS_LIST -_PLUGIN_AUTHENTICATOR_STATE=AUTHENTICATOR_STATE -_WEBAUTHN_PLUGIN_ADD_AUTHENTICATOR_OPTIONS=WEBAUTHN_PLUGIN_ADD_AUTHENTICATOR_OPTIONS -_EXPERIMENTAL_WEBAUTHN_PLUGIN_ADD_AUTHENTICATOR_OPTIONS_2=EXPERIMENTAL_WEBAUTHN_PLUGIN_ADD_AUTHENTICATOR_OPTIONS_2 -_WEBAUTHN_PLUGIN_ADD_AUTHENTICATOR_RESPONSE=WEBAUTHN_PLUGIN_ADD_AUTHENTICATOR_RESPONSE -_WEBAUTHN_PLUGIN_UPDATE_AUTHENTICATOR_DETAILS=WEBAUTHN_PLUGIN_UPDATE_AUTHENTICATOR_DETAILS -_EXPERIMENTAL_WEBAUTHN_PLUGIN_UPDATE_AUTHENTICATOR_DETAILS_2=EXPERIMENTAL_WEBAUTHN_PLUGIN_UPDATE_AUTHENTICATOR_DETAILS_2 -_WEBAUTHN_PLUGIN_CREDENTIAL_DETAILS=WEBAUTHN_PLUGIN_CREDENTIAL_DETAILS -_WEBAUTHN_PLUGIN_PERFORM_UV_OPERATION_TYPE=WEBAUTHN_PLUGIN_PERFORM_UV_OPERATION_TYPE -_WEBAUTHN_PLUGIN_USER_VERIFICATION_REQUEST=WEBAUTHN_PLUGIN_USER_VERIFICATION_REQUEST -_EXPERIMENTAL_WEBAUTHN_PLUGIN_USER_VERIFICATION_REQUEST_2=EXPERIMENTAL_WEBAUTHN_PLUGIN_USER_VERIFICATION_REQUEST_2 -_WEBAUTHN_CTAPCBOR_AUTHENTICATOR_OPTIONS=WEBAUTHN_CTAPCBOR_AUTHENTICATOR_OPTIONS -_WEBAUTHN_CTAPCBOR_ECC_PUBLIC_KEY=WEBAUTHN_CTAPCBOR_ECC_PUBLIC_KEY -_WEBAUTHN_CTAPCBOR_HMAC_SALT_EXTENSION=WEBAUTHN_CTAPCBOR_HMAC_SALT_EXTENSION -_WEBAUTHN_CTAPCBOR_MAKE_CREDENTIAL_REQUEST=WEBAUTHN_CTAPCBOR_MAKE_CREDENTIAL_REQUEST -_WEBAUTHN_CTAPCBOR_GET_ASSERTION_REQUEST=WEBAUTHN_CTAPCBOR_GET_ASSERTION_REQUEST -_WEBAUTHN_CTAPCBOR_GET_ASSERTION_RESPONSE=WEBAUTHN_CTAPCBOR_GET_ASSERTION_RESPONSE -_WEBAUTHN_PLUGIN_REQUEST_TYPE=WEBAUTHN_PLUGIN_REQUEST_TYPE -_EXPERIMENTAL_WEBAUTHN_PLUGIN_OPERATION_REQUEST=EXPERIMENTAL_WEBAUTHN_PLUGIN_OPERATION_REQUEST -_WEBAUTHN_PLUGIN_OPERATION_REQUEST=WEBAUTHN_PLUGIN_OPERATION_REQUEST -_EXPERIMENTAL_WEBAUTHN_PLUGIN_OPERATION_RESPONSE=EXPERIMENTAL_WEBAUTHN_PLUGIN_OPERATION_RESPONSE -_WEBAUTHN_PLUGIN_OPERATION_RESPONSE=WEBAUTHN_PLUGIN_OPERATION_RESPONSE -_EXPERIMENTAL_WEBAUTHN_PLUGIN_CANCEL_OPERATION_REQUEST=EXPERIMENTAL_WEBAUTHN_PLUGIN_CANCEL_OPERATION_REQUEST -_WEBAUTHN_PLUGIN_CANCEL_OPERATION_REQUEST=WEBAUTHN_PLUGIN_CANCEL_OPERATION_REQUEST -_PLUGIN_LOCK_STATUS=PLUGIN_LOCK_STATUS diff --git a/scripts/DoTests.ps1 b/scripts/DoTests.ps1 index d07d4bad6..465c8201a 100644 --- a/scripts/DoTests.ps1 +++ b/scripts/DoTests.ps1 @@ -15,4 +15,9 @@ Write-Host "*** Running metadata utils tests..." -ForegroundColor Blue dotnet test "$PSScriptRoot\..\tests\MetadataUtils.Tests" -c Release ThrowOnNativeProcessError +Write-Host "*** Running scraper discovery tests..." -ForegroundColor Blue + +dotnet test "$PSScriptRoot\..\tests\Win32MetadataScraperTests" -c Release +ThrowOnNativeProcessError + & $PSScriptRoot\TestWinmdBinary.ps1 -SkipInstallTools diff --git a/sources/GeneratorSdk/MetadataTasks/ScrapeHeaders.cs b/sources/GeneratorSdk/MetadataTasks/ScrapeHeaders.cs index 9cc93f5c0..e2fb70f06 100644 --- a/sources/GeneratorSdk/MetadataTasks/ScrapeHeaders.cs +++ b/sources/GeneratorSdk/MetadataTasks/ScrapeHeaders.cs @@ -17,11 +17,20 @@ public class ScrapeHeaders : Task, ICancelableTask private static readonly string[] allArches = new string[] { "x86", "x64", "arm64" }; private bool canceled; - private string clangSharpToolPath; + private string win32MetadataScraperPath; private string[] defaultIncDirs; private HashSet partitionSettingsValidSwitches = new HashSet(System.StringComparer.OrdinalIgnoreCase); private HashSet partitionsToExcludeFromCrossarch = new HashSet(System.StringComparer.OrdinalIgnoreCase); private Dictionary suggestedRemaps = new(); + private Dictionary discoveredRemaps = new(); + private Dictionary discoveredRemapHeaders = new(); // tag → header file path + private HashSet discoveredFnPtrExcludes = new(); + private HashSet discoveredReducePointerLevel = new(); + private Dictionary manualFnPtrRemaps = new(StringComparer.Ordinal); + private HashSet manualFnPtrExcludes = new(StringComparer.Ordinal); + private HashSet manualReducePointerLevel = new(StringComparer.Ordinal); + // Per-partition: which tag remaps each partition discovered from its own AST + private Dictionary> perPartitionRemaps = new(); [Required] @@ -32,6 +41,12 @@ public class ScrapeHeaders : Task, ICancelableTask public ITaskItem[] ResponseFiles { get; set; } + [Required] + public string ScraperFunctionPointerFixupsRsp { get; set; } + + [Required] + public string EmitterFunctionPointerFixupsRsp { get; set; } + [Required] public string WinSdkRoot { get; set; } @@ -145,7 +160,8 @@ public override bool Execute() Path.Combine(this.SdkIncRoot, "winrt"), }; - this.partitionSettingsValidSwitches = new HashSet(new string[] { "--exclude", "--remap", "--with-librarypath", "--with-type", "--with-attribute", "--config" }); + this.partitionSettingsValidSwitches = new HashSet(new string[] { "--exclude", "--exclude-auto-remap", "--remap", "--with-librarypath", "--with-type", "--with-attribute", "--config" }); + this.LoadManualFunctionPointerFixups(); int failureCount = 0; @@ -172,6 +188,13 @@ public override bool Execute() } } + // Write auto-discovered remaps to generated RSP + if (ret) + { + this.WriteAutoRemapsRsp(); + this.CheckCrossPartitionRemapConsistency(); + } + if (ret && string.IsNullOrEmpty(this.PartitionFilter)) { File.WriteAllText(this.MarkerFileName, string.Empty); @@ -187,55 +210,21 @@ public void Cancel() private bool EnsureClangSharpInstalled() { - // Restore ClangSharp as a local tool with the pinned version, so we are - // not affected by whatever version is installed globally on the machine. - // A tool manifest is generated in the scratch directory so this works both - // in-repo and when the GeneratorSdk is consumed as a NuGet MSBuild SDK. - string toolManifestDir = Path.Combine(this.ScratchDir, ".config"); - string toolManifest = Path.Combine(toolManifestDir, "dotnet-tools.json"); - - Directory.CreateDirectory(toolManifestDir); - File.WriteAllText(toolManifest, -$@"{{ - ""version"": 1, - ""isRoot"": true, - ""tools"": {{ - ""clangsharppinvokegenerator"": {{ - ""version"": ""{ClangSharpVersion}"", - ""commands"": [""ClangSharpPInvokeGenerator""] - }} - }} -}}"); - - int exitCode = TaskUtils.ExecuteCmd("dotnet", $"tool restore --tool-manifest \"{toolManifest}\"", out var output, this.Log); - if (exitCode != 0) - { - this.Log.LogError($"Failed to restore ClangSharpPInvokeGenerator {ClangSharpVersion}. Exit code: {exitCode}. Output: {output}"); - return false; - } - - // Resolve the tool DLL path so we can invoke it directly via 'dotnet ' - // instead of 'dotnet tool run' which has per-invocation overhead. - string userProfile = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile); - string storeRoot = Path.Combine(userProfile, ".dotnet", "tools", ".store", "clangsharppinvokegenerator"); - if (Directory.Exists(storeRoot)) + string rid = System.Runtime.InteropServices.RuntimeInformation.RuntimeIdentifier; + string[] candidatePaths = { - var found = Directory.GetFiles(storeRoot, "ClangSharpPInvokeGenerator.dll", SearchOption.AllDirectories); - if (found.Length > 0) - { - this.clangSharpToolPath = found[0]; - } - } + Path.Combine(this.ToolsBinDir, rid, "Win32MetadataScraper.dll"), + Path.Combine(this.ToolsBinDir, "Win32MetadataScraper.dll"), + }; - if (this.clangSharpToolPath != null) + this.win32MetadataScraperPath = candidatePaths.FirstOrDefault(File.Exists); + if (this.win32MetadataScraperPath is null) { - this.Log.LogMessage(MessageImportance.High, $"Using ClangSharp {ClangSharpVersion} from {this.clangSharpToolPath}"); - } - else - { - this.Log.LogWarning($"Could not resolve ClangSharpPInvokeGenerator.dll path; falling back to 'dotnet tool run'"); + this.Log.LogError($"Win32MetadataScraper not found. Checked: {string.Join(", ", candidatePaths)}"); + return false; } + this.Log.LogMessage(MessageImportance.High, $"Using Win32MetadataScraper from {this.win32MetadataScraperPath}"); return true; } @@ -454,14 +443,12 @@ private bool ProcessPartition(Partition partition, string arch) string output; int exitCode; - if (this.clangSharpToolPath != null) - { - exitCode = TaskUtils.ExecuteCmd("dotnet", $"\"{this.clangSharpToolPath}\" {args}", out output, this.Log); - } - else - { - exitCode = TaskUtils.ExecuteCmd("dotnet", $"tool run ClangSharpPInvokeGenerator -- {args}", out output, this.Log, workingDirectory: this.ScratchDir); - } + string remapsFile = Path.Combine(currentScraperOutputDir, $"{partitionName}.remaps"); + + // Use Win32MetadataScraper — hosts PInvokeGenerator as a library, + // walks the AST to discover remaps, and generates output in a single pass + string scraperArgs = $"\"{this.win32MetadataScraperPath}\" \"{remapsFile}\" {args}"; + exitCode = TaskUtils.ExecuteCmd("dotnet", scraperArgs, out output, this.Log); if (output == null) { output = string.Empty; @@ -519,6 +506,88 @@ private bool ProcessPartition(Partition partition, string arch) } } } + + // Read discovered remaps from sidecar file (written by Win32MetadataScraper) + if (File.Exists(remapsFile)) + { + foreach (var line in File.ReadLines(remapsFile)) + { + string trimmed = line.Trim(); + if (string.IsNullOrEmpty(trimmed)) continue; + + if (trimmed.StartsWith("FNPTR_EXCLUDE:")) + { + string exclude = trimmed.Substring("FNPTR_EXCLUDE:".Length); + if (this.manualFnPtrExcludes.Contains(exclude)) + { + continue; + } + + lock (this.discoveredFnPtrExcludes) + { + this.discoveredFnPtrExcludes.Add(exclude); + } + } + else if (trimmed.StartsWith("REDUCE_PTR_LEVEL:")) + { + string reducePointerLevel = trimmed.Substring("REDUCE_PTR_LEVEL:".Length); + if (this.manualReducePointerLevel.Contains(reducePointerLevel)) + { + continue; + } + + lock (this.discoveredReducePointerLevel) + { + this.discoveredReducePointerLevel.Add(reducePointerLevel); + } + } + else + { + int eq = trimmed.IndexOf('='); + if (eq > 0) + { + string key = trimmed.Substring(0, eq); + string rest = trimmed.Substring(eq + 1); + + // Parse optional header info: value|HEADER:path + string value = rest; + string headerFile = null; + int headerMarker = rest.IndexOf("|HEADER:"); + if (headerMarker >= 0) + { + value = rest.Substring(0, headerMarker); + headerFile = rest.Substring(headerMarker + "|HEADER:".Length); + } + + if (this.manualFnPtrRemaps.TryGetValue(key, out string manualValue) && + string.Equals(manualValue, value, StringComparison.Ordinal)) + { + continue; + } + + lock (this.discoveredRemaps) + { + if (!this.discoveredRemaps.ContainsKey(key)) + { + this.discoveredRemaps[key] = value; + if (headerFile != null) + this.discoveredRemapHeaders[key] = headerFile; + } + } + + // Track per-partition for consistency checking + lock (this.perPartitionRemaps) + { + if (!this.perPartitionRemaps.TryGetValue(partitionName, out var partRemaps)) + { + this.perPartitionRemaps[partitionName] = partRemaps = new Dictionary(); + } + partRemaps[key] = value; + } + } + } + } + } } return true; @@ -548,5 +617,242 @@ private string[] GetFilesFromMetadata(ITaskItem item, string name) return items; } + private void LoadManualFunctionPointerFixups() + { + this.manualFnPtrRemaps.Clear(); + this.manualFnPtrExcludes.Clear(); + this.manualReducePointerLevel.Clear(); + + ParseFunctionPointerFixupsRsp( + this.GetAbsolutePath(this.ScraperFunctionPointerFixupsRsp), + (currentSwitch, value) => + { + if (currentSwitch == "--exclude") + { + this.manualFnPtrExcludes.Add(value); + } + else if (currentSwitch == "--remap") + { + int eq = value.IndexOf('='); + if (eq > 0) + { + this.manualFnPtrRemaps[value.Substring(0, eq)] = value.Substring(eq + 1); + } + } + }); + + ParseFunctionPointerFixupsRsp( + this.GetAbsolutePath(this.EmitterFunctionPointerFixupsRsp), + (currentSwitch, value) => + { + if (currentSwitch == "--reducePointerLevel") + { + this.manualReducePointerLevel.Add(value); + } + }); + } + + private string GetAbsolutePath(string path) + { + if (string.IsNullOrEmpty(path) || Path.IsPathRooted(path)) + { + return path; + } + + return Path.Combine(this.MSBuildProjectDirectory, path); + } + + private static void ParseFunctionPointerFixupsRsp(string rspPath, Action onItem) + { + if (string.IsNullOrEmpty(rspPath) || !File.Exists(rspPath)) + { + return; + } + + string currentSwitch = null; + foreach (string line in File.ReadLines(rspPath)) + { + string trimmed = line.Trim(); + if (string.IsNullOrEmpty(trimmed)) + { + continue; + } + + if (trimmed.StartsWith("--")) + { + currentSwitch = trimmed; + continue; + } + + if (currentSwitch != null) + { + onItem(currentSwitch, trimmed); + } + } + } + + /// + /// Writes the auto-discovered remaps and function pointer fixups to generated RSP files. + /// + private void WriteAutoRemapsRsp() + { + Directory.CreateDirectory(this.GeneratedDir); + + if (this.discoveredRemaps.Count > 0 || this.discoveredFnPtrExcludes.Count > 0) + { + string autoRemapsRsp = Path.Combine(this.GeneratedDir, "scraper.autoRemaps.generated.rsp"); + + using (var writer = new StreamWriter(autoRemapsRsp)) + { + if (this.discoveredFnPtrExcludes.Count > 0) + { + writer.WriteLine("--exclude"); + foreach (var excl in this.discoveredFnPtrExcludes.OrderBy(x => x, StringComparer.OrdinalIgnoreCase)) + { + writer.WriteLine(excl); + } + } + + if (this.discoveredRemaps.Count > 0) + { + writer.WriteLine("--remap"); + foreach (var kv in this.discoveredRemaps.OrderBy(kv => kv.Key, StringComparer.OrdinalIgnoreCase)) + { + writer.WriteLine($"{kv.Key}={kv.Value}"); + } + } + } + + this.Log.LogMessage(MessageImportance.High, $"Wrote {this.discoveredRemaps.Count} auto-remaps and {this.discoveredFnPtrExcludes.Count} fn-ptr excludes to {autoRemapsRsp}"); + } + + if (this.discoveredReducePointerLevel.Count > 0) + { + string autoEmitterRsp = Path.Combine(this.GeneratedDir, $"emitter.autoFnPtr.{this.ScanArch}.generated.rsp"); + + using (var writer = new StreamWriter(autoEmitterRsp)) + { + writer.WriteLine("--reducePointerLevel"); + foreach (var rpl in this.discoveredReducePointerLevel.OrderBy(x => x, StringComparer.OrdinalIgnoreCase)) + { + writer.WriteLine(rpl); + } + } + + this.Log.LogMessage(MessageImportance.High, $"Wrote {this.discoveredReducePointerLevel.Count} reduce-pointer-level entries to {autoEmitterRsp}"); + } + } + + /// + /// Checks for cross-partition remap inconsistencies. After all partitions are + /// scraped, collects the set of type names declared in the generated C# files. + /// If any declared type name matches a tag that was remapped in another partition, + /// it means this partition didn't discover the remap and used the raw tag name. + /// + private void CheckCrossPartitionRemapConsistency() + { + if (this.discoveredRemaps.Count == 0) + { + return; + } + + // Collect all declared type names from all generated .cs files. + // Pattern: "partial struct FOO" / "enum FOO" / "delegate ... FOO(" + var declaredTypeNames = new HashSet(StringComparer.Ordinal); + string[] archDirs = new string[] { "common", "x86", "x64", "arm64" }; + var typeNameToFile = new Dictionary(); + + foreach (string archDir in archDirs) + { + string dir = Path.Combine(this.GeneratedDir, archDir); + if (!Directory.Exists(dir)) continue; + + foreach (string csFile in Directory.GetFiles(dir, "*.cs")) + { + foreach (var line in File.ReadLines(csFile)) + { + // Match: public partial struct FOO / public enum FOO / public delegate ... FOO( + string trimmed = line.TrimStart(); + if (trimmed.StartsWith("public ")) + { + // Extract the type name after struct/enum/delegate keywords + string typeName = null; + int idx; + if ((idx = trimmed.IndexOf(" struct ")) >= 0) + typeName = ExtractIdentifier(trimmed, idx + 8); + else if ((idx = trimmed.IndexOf(" enum ")) >= 0) + typeName = ExtractIdentifier(trimmed, idx + 6); + else if ((idx = trimmed.IndexOf(" interface ")) >= 0) + typeName = ExtractIdentifier(trimmed, idx + 11); + + if (typeName != null) + { + declaredTypeNames.Add(typeName); + if (!typeNameToFile.ContainsKey(typeName)) + { + string partName = Path.GetFileNameWithoutExtension(csFile); + typeNameToFile[typeName] = $"{partName} ({archDir})"; + } + } + } + } + } + } + + // Check: does any declared type name match a remap TAG? + // If so, that type was declared with its raw tag name instead of the typedef. + bool consistent = true; + foreach (var kv in this.discoveredRemaps) + { + string tagName = kv.Key; + string typedefName = kv.Value; + + if (declaredTypeNames.Contains(tagName)) + { + // Find which partition discovered this remap + string definingPartition = null; + foreach (var pp in this.perPartitionRemaps) + { + if (pp.Value.ContainsKey(tagName)) + { + definingPartition = pp.Key; + break; + } + } + + typeNameToFile.TryGetValue(tagName, out string location); + this.discoveredRemapHeaders.TryGetValue(tagName, out string headerFile); + string headerHint = headerFile != null + ? $" Add '#include \"{Path.GetFileName(headerFile)}\"' to that partition's main.cpp." + : ""; + + this.Log.LogWarning( + $"Inconsistent remap: type '{tagName}' is declared in {location} but should be " + + $"'{typedefName}' (remap discovered in partition '{definingPartition}').{headerHint}"); + consistent = false; + } + } + + if (!consistent) + { + this.Log.LogWarning( + "Cross-partition remap inconsistencies detected. See warnings above. " + + "Fix by adding the missing #include directives to the affected partition's main.cpp " + + "so the typedef is visible during scraping."); + } + } + + /// + /// Extracts a C# identifier starting at the given position in a line. + /// + private static string ExtractIdentifier(string line, int startIndex) + { + if (startIndex >= line.Length) return null; + int end = startIndex; + while (end < line.Length && (char.IsLetterOrDigit(line[end]) || line[end] == '_')) + end++; + return end > startIndex ? line.Substring(startIndex, end - startIndex) : null; + } + } } diff --git a/sources/GeneratorSdk/nuget/BuildSdk.nuspec b/sources/GeneratorSdk/nuget/BuildSdk.nuspec index 9e7adff5e..848d18ad6 100644 --- a/sources/GeneratorSdk/nuget/BuildSdk.nuspec +++ b/sources/GeneratorSdk/nuget/BuildSdk.nuspec @@ -25,6 +25,7 @@ + diff --git a/sources/GeneratorSdk/sdk/sdk.targets b/sources/GeneratorSdk/sdk/sdk.targets index 03540f200..1e5ab9a99 100644 --- a/sources/GeneratorSdk/sdk/sdk.targets +++ b/sources/GeneratorSdk/sdk/sdk.targets @@ -31,7 +31,9 @@ $(GeneratedDir)\scraper.functionPointerFixups.generated.rsp $(GeneratedDir)\emitter.functionPointerFixups.generated.rsp + $(GeneratedDir)\emitter.autoFnPtr.$(ScanArch).generated.rsp $(GeneratedDir)\scraper.autoTypes.generated.rsp + $(GeneratedDir)\scraper.autoRemaps.generated.rsp $(GeneratedDir)\ConstantsScraper.header.generated.txt $(GeneratedDir)\scraper.header.generated.txt @@ -177,12 +179,15 @@ - - - - - - + + + + + + + + + @@ -195,7 +200,9 @@ + + + + diff --git a/sources/Win32MetadataScraper/Program.cs b/sources/Win32MetadataScraper/Program.cs new file mode 100644 index 000000000..20d908c91 --- /dev/null +++ b/sources/Win32MetadataScraper/Program.cs @@ -0,0 +1,382 @@ +// Win32MetadataScraper: Single-pass scraper that wraps ClangSharp PInvokeGenerator. +// +// Hosts PInvokeGenerator as a library (via NuGet package references). Parses the +// translation unit, walks the AST to discover typedef-tag remappings, merges them +// with the configured --remap entries, then runs PInvokeGenerator.GenerateBindings +// with the full merged remap set — all in a single parse pass. +// +// Usage: dotnet Win32MetadataScraper.dll @rsp1 @rsp2 ... + +using System; +using System.Collections.Generic; +using System.Diagnostics; +using System.IO; +using System.Linq; +using System.Runtime.InteropServices; +using ClangSharp; +using ClangSharp.Interop; +using Win32MetadataScraper; +using static ClangSharp.Interop.CXDiagnosticSeverity; +using static ClangSharp.Interop.CXErrorCode; +using static ClangSharp.Interop.CXTranslationUnit_Flags; + +class Program +{ + static int Main(string[] args) + { + if (args.Length < 2) + { + Console.Error.WriteLine("Usage: dotnet Win32MetadataScraper.dll @rsp1 @rsp2 ..."); + return 1; + } + + string remapsOutputPath = args[0]; + string[] rspArgs = args.Skip(1).ToArray(); + + try + { + // Parse RSP files + var settings = new Dictionary>(StringComparer.OrdinalIgnoreCase); + foreach (var arg in rspArgs) + { + string rspPath = arg.StartsWith("@") ? arg.Substring(1).Trim('"') : arg; + ParseRspFile(rspPath, settings); + } + + string sourceFile = settings.GetValueOrDefault("--file")?.LastOrDefault(); + string outputFile = settings.GetValueOrDefault("--output")?.LastOrDefault(); + string ns = settings.GetValueOrDefault("--namespace")?.LastOrDefault(); + string headerFile = settings.GetValueOrDefault("--headerFile")?.LastOrDefault(); + + if (sourceFile == null || outputFile == null || ns == null) + { + Console.Error.WriteLine("Error: Missing required --file, --output, or --namespace in RSP files"); + return 1; + } + + var clangArgs = BuildClangArgs(settings); + var configOptions = BuildOptionsFlags(settings); + var configuredRemaps = ParseKeyValuePairs(settings.GetValueOrDefault("--remap")); + var configuredAutoRemapExcludes = new HashSet( + settings.GetValueOrDefault("--exclude-auto-remap") ?? new List(), + StringComparer.Ordinal); + var configuredExcludes = new HashSet( + settings.GetValueOrDefault("--exclude") ?? new List(), + StringComparer.Ordinal); + + var translationFlags = CXTranslationUnit_IncludeAttributedTypes + | CXTranslationUnit_VisitImplicitAttributes; + + // ── Parse translation unit ── + // We parse once with our own CXIndex, walk the AST to discover remaps, + // then pass the same TranslationUnit to PInvokeGenerator.GenerateBindings. + using var index = CXIndex.Create(excludeDeclarationsFromPch: false, displayDiagnostics: false); + var parseError = CXTranslationUnit.TryParse( + index, sourceFile, clangArgs, ReadOnlySpan.Empty, + translationFlags, out var cxHandle); + + if (parseError != CXError_Success) + { + Console.Error.WriteLine($"Error: Failed to parse '{sourceFile}': {parseError}"); + return -1; + } + + bool skipProcessing = false; + if (cxHandle.NumDiagnostics != 0) + { + Console.WriteLine($"Diagnostics for '{sourceFile}':"); + for (uint i = 0; i < cxHandle.NumDiagnostics; i++) + { + using var diag = cxHandle.GetDiagnostic(i); + Console.Write(" "); + Console.WriteLine(diag.Format(CXDiagnostic.DefaultDisplayOptions).ToString()); + skipProcessing |= diag.Severity == CXDiagnostic_Error; + skipProcessing |= diag.Severity == CXDiagnostic_Fatal; + } + } + + if (skipProcessing) + { + Console.Error.WriteLine($"Skipping '{sourceFile}' due to one or more errors listed above."); + return -1; + } + + using var translationUnit = TranslationUnit.GetOrCreate(cxHandle); + Debug.Assert(translationUnit is not null); + + // ── Walk AST to discover all typedef-tag and function pointer relationships ── + var discovery = RemapDiscovery.WalkTranslationUnit(translationUnit.TranslationUnitDecl); + + // Resolve tag remaps using disambiguation, then apply opt-outs for + // compatibility cases where we intentionally keep the historical public name. + var resolvedTagRemaps = RemapDiscovery.ResolveTagRemaps(discovery.TagToTypedefs, configuredRemaps); + var autoRemaps = RemapDiscovery.FilterTagRemaps( + resolvedTagRemaps, + configuredRemaps, + discovery.EnumTags, + configuredAutoRemapExcludes); + + // Resolve function pointer fixups + var fnPtrResult = RemapDiscovery.ResolveFunctionPointerFixups(discovery, configuredExcludes); + + // Merge all remaps: auto tag remaps + fn ptr remaps + configured (configured wins) + var mergedRemaps = new Dictionary(autoRemaps); + foreach (var kv in fnPtrResult.FnPtrRemaps) + mergedRemaps[kv.Key] = kv.Value; + foreach (var kv in configuredRemaps) + mergedRemaps[kv.Key] = kv.Value; + + // Merge excludes from function pointer fixups into the configured excludes + var allExcludes = new List(settings.GetValueOrDefault("--exclude") ?? new List()); + foreach (var excl in fnPtrResult.FnPtrExcludes) + { + if (!allExcludes.Contains(excl)) + allExcludes.Add(excl); + } + + // ── Run PInvokeGenerator with merged remaps on the same TranslationUnit ── + var config = CreateConfig(settings, ns, outputFile, headerFile, configOptions, mergedRemaps, allExcludes); + + var capturedStreams = new Dictionary(); + Func streamFactory = (path) => + { + var ms = new MemoryStream(); + capturedStreams[path] = ms; + return ms; + }; + + int exitCode = 0; + using (var generator = new PInvokeGenerator(config, streamFactory)) + { + Console.WriteLine($"Processing '{sourceFile}'"); + generator.GenerateBindings(translationUnit, sourceFile, clangArgs, translationFlags); + + generator.Close(); + + // Write output to disk + foreach (var kvp in capturedStreams) + { + var dir = Path.GetDirectoryName(kvp.Key); + if (!string.IsNullOrEmpty(dir)) + Directory.CreateDirectory(dir); + File.WriteAllBytes(kvp.Key, kvp.Value.ToArray()); + } + + // Write diagnostics + foreach (var diag in generator.Diagnostics) + { + Console.WriteLine($" {diag}"); + if (diag.Level == DiagnosticLevel.Warning && exitCode >= 0) + exitCode++; + else if (diag.Level == DiagnosticLevel.Error) + { + if (exitCode >= 0) exitCode = -1; + else exitCode--; + } + } + } + + // Write auto-discovered remaps + fn ptr remaps to sidecar file + var allAutoRemaps = new Dictionary(autoRemaps); + foreach (var kv in fnPtrResult.FnPtrRemaps) + allAutoRemaps[kv.Key] = kv.Value; + + if (allAutoRemaps.Count > 0 || fnPtrResult.FnPtrExcludes.Count > 0 || fnPtrResult.ReducePointerLevel.Count > 0) + { + var remapDir = Path.GetDirectoryName(remapsOutputPath); + if (!string.IsNullOrEmpty(remapDir)) + Directory.CreateDirectory(remapDir); + + using var writer = new StreamWriter(remapsOutputPath); + + // Tag remaps (with header file info) + foreach (var kv in allAutoRemaps.OrderBy(kv => kv.Key, StringComparer.OrdinalIgnoreCase)) + { + discovery.TagToHeaderFile.TryGetValue(kv.Key, out string srcHeader); + if (srcHeader != null) + writer.WriteLine($"{kv.Key}={kv.Value}|HEADER:{srcHeader}"); + else + writer.WriteLine($"{kv.Key}={kv.Value}"); + } + + // Function pointer excludes (prefixed for downstream parsing) + foreach (var excl in fnPtrResult.FnPtrExcludes.OrderBy(x => x, StringComparer.OrdinalIgnoreCase)) + writer.WriteLine($"FNPTR_EXCLUDE:{excl}"); + + // Reduce pointer level entries + foreach (var rpl in fnPtrResult.ReducePointerLevel.OrderBy(x => x, StringComparer.OrdinalIgnoreCase)) + writer.WriteLine($"REDUCE_PTR_LEVEL:{rpl}"); + } + + return exitCode; + } + catch (Exception ex) + { + Console.Error.WriteLine($"Error: {ex.Message}"); + Console.Error.WriteLine(ex.StackTrace); + return 1; + } + } + static PInvokeGeneratorConfiguration CreateConfig( + Dictionary> settings, + string ns, string outputFile, string headerFile, + PInvokeGeneratorConfigurationOptions options, + Dictionary remaps, + List excludes) + { + string defaultClass = null; + if (settings.TryGetValue("--methodClassName", out var classNames) && classNames.Count > 0) + defaultClass = classNames.Last(); + + string libraryPath = null; + if (settings.TryGetValue("--libraryPath", out var libPaths) && libPaths.Count > 0) + libraryPath = libPaths.Last(); + + var config = new PInvokeGeneratorConfiguration("c++", "c++17", ns, outputFile, headerFile ?? string.Empty, + PInvokeGeneratorOutputMode.CSharp, options) + { + DefaultClass = defaultClass ?? "Methods", + TraversalNames = settings.GetValueOrDefault("--traverse")?.ToArray() ?? Array.Empty(), + ExcludedNames = excludes.ToArray(), + RemappedNames = remaps, + WithAttributes = ParseKeyValueMultiPairs(settings.GetValueOrDefault("--with-attribute")), + WithTypes = ParseKeyValuePairs(settings.GetValueOrDefault("--with-type")), + WithLibraryPaths = ParseKeyValuePairs(settings.GetValueOrDefault("--with-librarypath")), + WithCallConvs = ParseKeyValuePairs(settings.GetValueOrDefault("--with-callconv")), + WithUsings = ParseKeyValueMultiPairs(settings.GetValueOrDefault("--with-using")), + WithSetLastErrors = settings.GetValueOrDefault("--with-setlasterror")?.ToArray() ?? Array.Empty(), + WithSuppressGCTransitions = settings.GetValueOrDefault("--with-suppressgctransition")?.ToArray() ?? Array.Empty(), + LibraryPath = libraryPath ?? string.Empty, + }; + + return config; + } + + static string[] BuildClangArgs(Dictionary> settings) + { + var clangArgs = new List { "--language=c++", "--std=c++17", "-Wno-pragma-once-outside-header" }; + if (settings.TryGetValue("--include-directory", out var incDirs)) + foreach (var dir in incDirs) + clangArgs.Add($"--include-directory={dir}"); + if (settings.TryGetValue("--additional", out var additionals)) + clangArgs.AddRange(additionals); + return clangArgs.ToArray(); + } + + static PInvokeGeneratorConfigurationOptions BuildOptionsFlags(Dictionary> settings) + { + var options = RuntimeInformation.IsOSPlatform(OSPlatform.Windows) + ? PInvokeGeneratorConfigurationOptions.None + : PInvokeGeneratorConfigurationOptions.GenerateUnixTypes; + + if (settings.TryGetValue("--config", out var configs)) + { + foreach (var cfg in configs) + { + options |= cfg switch + { + "compatible-codegen" => PInvokeGeneratorConfigurationOptions.GenerateCompatibleCode, + "log-visited-files" => PInvokeGeneratorConfigurationOptions.LogVisitedFiles, + "log-exclusions" => PInvokeGeneratorConfigurationOptions.LogExclusions, + "log-potential-typedef-remappings" => PInvokeGeneratorConfigurationOptions.LogPotentialTypedefRemappings, + "exclude-funcs-with-body" => PInvokeGeneratorConfigurationOptions.ExcludeFunctionsWithBody, + "generate-cpp-attributes" => PInvokeGeneratorConfigurationOptions.GenerateCppAttributes, + "generate-native-bitfield-attribute" => PInvokeGeneratorConfigurationOptions.GenerateNativeBitfieldAttribute, + "generate-native-inheritance-attribute" => PInvokeGeneratorConfigurationOptions.GenerateNativeInheritanceAttribute, + "dont-use-using-statics-for-enums" or + "exclude-using-statics-for-enums" => PInvokeGeneratorConfigurationOptions.DontUseUsingStaticsForEnums, + "exclude-anonymous-field-helpers" => PInvokeGeneratorConfigurationOptions.ExcludeAnonymousFieldHelpers, + "exclude-empty-records" => PInvokeGeneratorConfigurationOptions.ExcludeEmptyRecords, + "exclude-enum-operators" => PInvokeGeneratorConfigurationOptions.ExcludeEnumOperators, + "exclude-com-proxies" => PInvokeGeneratorConfigurationOptions.ExcludeComProxies, + "generate-marker-interfaces" => PInvokeGeneratorConfigurationOptions.GenerateMarkerInterfaces, + "generate-explicit-vtbls" => PInvokeGeneratorConfigurationOptions.GenerateExplicitVtbls, + "generate-trimmable-vtbls" => PInvokeGeneratorConfigurationOptions.GenerateTrimmableVtbls, + "generate-aggressive-inlining" => PInvokeGeneratorConfigurationOptions.GenerateAggressiveInlining, + "multi-file" => PInvokeGeneratorConfigurationOptions.GenerateMultipleFiles, + "generate-macro-bindings" => PInvokeGeneratorConfigurationOptions.GenerateMacroBindings, + "generate-file-scoped-namespaces" => PInvokeGeneratorConfigurationOptions.GenerateFileScopedNamespaces, + "generate-disable-runtime-marshalling" => PInvokeGeneratorConfigurationOptions.GenerateDisableRuntimeMarshalling, + "generate-guid-member" => PInvokeGeneratorConfigurationOptions.GenerateGuidMember, + "generate-helper-types" => PInvokeGeneratorConfigurationOptions.GenerateHelperTypes, + "generate-vtbl-index-attribute" => PInvokeGeneratorConfigurationOptions.GenerateVtblIndexAttribute, + "generate-setslasterror-attribute" or + "generate-sets-last-system-error-attribute" => PInvokeGeneratorConfigurationOptions.GenerateSetsLastSystemErrorAttribute, + "generate-unmanaged-constants" => PInvokeGeneratorConfigurationOptions.GenerateUnmanagedConstants, + "generate-latest-code" => PInvokeGeneratorConfigurationOptions.GenerateLatestCode, + "generate-template-bindings" => PInvokeGeneratorConfigurationOptions.GenerateTemplateBindings, + "generate-source-location-attribute" => PInvokeGeneratorConfigurationOptions.GenerateSourceLocationAttribute, + "generate-callconv-member-function" => PInvokeGeneratorConfigurationOptions.GenerateCallConvMemberFunction, + "generate-doc-includes" => PInvokeGeneratorConfigurationOptions.GenerateDocIncludes, + "preview-codegen" => PInvokeGeneratorConfigurationOptions.GeneratePreviewCode, + "unix-types" => PInvokeGeneratorConfigurationOptions.GenerateUnixTypes, + _ => PInvokeGeneratorConfigurationOptions.None + }; + } + } + return options; + } + + static void ParseRspFile(string path, Dictionary> settings) + { + if (!File.Exists(path)) return; + string currentSwitch = null; + foreach (var rawLine in File.ReadLines(path)) + { + string line = rawLine.Trim(); + if (string.IsNullOrEmpty(line)) continue; + if (line.StartsWith("#", StringComparison.Ordinal)) continue; + + if (line.StartsWith("@")) + { + string nestedPath = line.Substring(1).Trim('"'); + ParseRspFile(nestedPath, settings); + } + else if (line.StartsWith("--")) + { + currentSwitch = line; + if (!settings.ContainsKey(currentSwitch)) + settings[currentSwitch] = new List(); + } + else if (currentSwitch != null) + { + settings[currentSwitch].Add(line); + } + } + } + + static Dictionary ParseKeyValuePairs(List items) + { + var dict = new Dictionary(); + if (items == null) return dict; + foreach (var item in items) + { + int eq = item.IndexOf('='); + if (eq > 0) + dict[item.Substring(0, eq)] = item.Substring(eq + 1); + } + return dict; + } + + static Dictionary> ParseKeyValueMultiPairs(List items) + { + var dict = new Dictionary>(); + if (items == null) return dict; + var temp = new Dictionary>(); + foreach (var item in items) + { + int eq = item.IndexOf('='); + if (eq > 0) + { + string key = item.Substring(0, eq); + string val = item.Substring(eq + 1); + if (!temp.TryGetValue(key, out var list)) + temp[key] = list = new List(); + list.Add(val); + } + } + foreach (var kv in temp) + dict[kv.Key] = kv.Value; + return dict; + } +} diff --git a/sources/Win32MetadataScraper/RemapDiscovery.cs b/sources/Win32MetadataScraper/RemapDiscovery.cs new file mode 100644 index 000000000..a6822da8f --- /dev/null +++ b/sources/Win32MetadataScraper/RemapDiscovery.cs @@ -0,0 +1,438 @@ +// RemapDiscovery: AST-based discovery of typedef-tag and function pointer remappings. +// +// This class walks a ClangSharp TranslationUnit AST to find: +// 1. Tag-typedef pairs (struct _FOO → FOO) +// 2. Function pointer prototype/alias pairs (TIMECALLBACK → LPTIMECALLBACK) +// +// The discovery results can be used to auto-generate --remap, --exclude, and +// --reducePointerLevel entries for PInvokeGenerator. + +using System; +using System.Collections.Generic; +using System.Linq; +using ClangSharp; + +namespace Win32MetadataScraper +{ + +/// +/// Results from walking a translation unit's AST for typedef-tag and +/// function pointer relationships. +/// +public class DiscoveryResult +{ + /// Tag name → list of typedef names. One tag may have multiple typedefs. + public Dictionary> TagToTypedefs { get; } = new(); + + /// Names of tags that are enums. + public HashSet EnumTags { get; } = new(); + + /// Tag name → header file where the typedef was found. + public Dictionary TagToHeaderFile { get; } = new(); + + /// + /// Function typedef name → list of pointer-adding alias names. + /// These are aliases declared as typedef NAME *ALIAS; (adds one level of pointer). + /// + public Dictionary> FnProtoToPointerTypedefs { get; } = new(); + + /// + /// Function typedef name → list of same-level alias names. + /// These are aliases declared as typedef NAME ALIAS; (no added pointer). + /// + public Dictionary> FnSameLevelAliases { get; } = new(); + + /// Names of typedefs whose underlying type is a bare FunctionProtoType (no pointer). + public HashSet FnBareFunctionTypedefs { get; } = new(); + + /// Names of typedefs whose underlying type is PointerType → FunctionProtoType (already a pointer). + public HashSet FnPointerFunctionTypedefs { get; } = new(); + + /// All fn proto typedef names (bare + pointer). Convenience accessor. + public IEnumerable FnProtoTypedefNames => FnBareFunctionTypedefs.Concat(FnPointerFunctionTypedefs); +} + +/// +/// Resolved remap entries ready for use with PInvokeGenerator. +/// +public class ResolvedRemaps +{ + /// Tag → typedef remaps (e.g., _FOO=FOO). + public Dictionary TagRemaps { get; set; } = new(); + + /// Function pointer prototype → pointer typedef remaps (e.g., TIMECALLBACK=LPTIMECALLBACK). + public Dictionary FnPtrRemaps { get; set; } = new(); + + /// Function pointer typedef names to exclude from generation. + public HashSet FnPtrExcludes { get; set; } = new(); + + /// Function pointer typedef names that need pointer level reduction in the emitter. + public HashSet ReducePointerLevel { get; set; } = new(); +} + +public static class RemapDiscovery +{ + /// + /// Walks the AST starting from the given declaration to collect all typedef-tag + /// relationships and function pointer typedef pairs. + /// + public static DiscoveryResult WalkTranslationUnit(Decl rootDecl) + { + var result = new DiscoveryResult(); + WalkDecl(rootDecl, result); + return result; + } + + /// + /// Resolves discovered tag-typedef mappings into a flat remap dictionary. + /// For tags with multiple typedefs, uses disambiguation rules to pick the best one, + /// or skips the tag if ambiguous (requiring manual override). + /// + public static Dictionary ResolveTagRemaps( + Dictionary> tagToTypedefs, + Dictionary configuredRemaps) + { + var result = new Dictionary(); + + foreach (var kv in tagToTypedefs) + { + string tag = kv.Key; + var typedefs = kv.Value; + + if (typedefs.Count == 1) + { + if (!string.Equals(tag, typedefs[0], StringComparison.Ordinal)) + { + result[tag] = typedefs[0]; + } + } + else + { + // Multiple typedefs — try to disambiguate + + // If one matches the manual config, use that + if (configuredRemaps.TryGetValue(tag, out string manualValue) && typedefs.Contains(manualValue)) + { + result[tag] = manualValue; + continue; + } + + // Heuristic: prefer the typedef that is the "cleaned" version of the tag + string stripped = null; + if (tag.StartsWith("_") && tag.Length > 1) + stripped = tag.Substring(1); + else if (tag.StartsWith("tag") && tag.Length > 3 && char.IsUpper(tag[3])) + stripped = tag.Substring(3); + + if (stripped != null) + { + var match = typedefs.FirstOrDefault(t => string.Equals(t, stripped, StringComparison.OrdinalIgnoreCase)); + if (match != null) + { + result[tag] = match; + continue; + } + } + + // Try case-insensitive match of the tag name itself (e.g., in6_addr → IN6_ADDR) + { + var match = typedefs.FirstOrDefault(t => string.Equals(t, tag, StringComparison.OrdinalIgnoreCase)); + if (match != null) + { + result[tag] = match; + continue; + } + } + + // Can't disambiguate — skip (conservative: no auto-remap for ambiguous tags) + } + } + + return result; + } + + /// + /// Filters resolved tag remaps, removing built-in defaults and entries that + /// conflict with configured manual remaps. + /// + public static Dictionary FilterTagRemaps( + Dictionary discovered, + Dictionary configuredRemaps, + ISet enumTags = null, + ISet autoRemapExcludes = null) + { + autoRemapExcludes ??= new HashSet(StringComparer.Ordinal); + var builtins = new HashSet(StringComparer.OrdinalIgnoreCase) + { "intptr_t", "ptrdiff_t", "size_t", "uintptr_t", "_GUID" }; + var result = new Dictionary(); + + foreach (var kv in discovered) + { + string tag = kv.Key; + string typedef = kv.Value; + + if (builtins.Contains(tag)) continue; + if (tag == typedef) continue; + if (autoRemapExcludes.Contains(tag)) continue; + if (configuredRemaps.TryGetValue(tag, out string configuredValue) && configuredValue != typedef) + continue; + if (IsLikelyComInterfaceTag(tag)) + continue; + + // Skip remaps where the typedef is LONGER than the tag (adds a suffix). + // Normal remaps strip prefixes (_FOO→FOO, tagFOO→FOO). + // Suffix-adding remaps (GLUnurbs→GLUnurbsObj) indicate the tag name + // is already the canonical name used in function signatures. + // A small exception is warranted for enum aliases like + // ADS_USER_FLAG→ADS_USER_FLAG_ENUM and + // D3D11_SHADER_TRACKING_OPTION→D3D11_SHADER_TRACKING_OPTIONS. + if (ShouldSkipSuffixAddingRemap(tag, typedef, enumTags)) + continue; + + result[tag] = typedef; + } + + return result; + } + + private static bool IsLikelyComInterfaceTag(string name) + { + if (string.IsNullOrEmpty(name) || name.Length < 2) + { + return false; + } + + if (name[0] != 'I' || !char.IsUpper(name[1])) + { + return false; + } + + if (name.EndsWith("Vtbl", StringComparison.Ordinal) || name.Contains('_')) + { + return false; + } + + return name.Any(char.IsLower); + } + + private static bool ShouldSkipSuffixAddingRemap(string tag, string typedef, ISet enumTags) + { + if (typedef.Length <= tag.Length || !typedef.StartsWith(tag, StringComparison.Ordinal)) + { + return false; + } + + if (enumTags?.Contains(tag) == true) + { + string suffix = typedef.Substring(tag.Length); + if (suffix == "S" || suffix == "_ENUM") + { + return false; + } + } + + return true; + } + + /// + /// Resolves function pointer typedef pairs into remap, exclude, and + /// reducePointerLevel entries. Uses AST structure (bare vs pointer-to-function) + /// to determine direction, replacing the old name-prefix heuristic. + /// + /// Only the "bare function + pointer alias" pattern generates fixups: + /// typedef void CALLBACK(int x); // bare function proto + /// typedef CALLBACK *LPCALLBACK; // pointer alias (adds *) + /// → remap proto→alias, exclude alias, reducePointerLevel alias + /// + /// Already-pointer typedefs with a pointer-adding alias also generate fixups: + /// typedef DWORD (*ACMDRIVERPROC)(...); // already a pointer + /// typedef ACMDRIVERPROC *LPACMDRIVERPROC; // adds another * + /// → remap proto→alias, exclude alias, reducePointerLevel alias + /// + /// Already-pointer typedefs with same-level aliases (typedef PFOO LPFOO) are + /// left to manual configuration — the AST alone cannot determine which name + /// should be canonical. + /// + public static ResolvedRemaps ResolveFunctionPointerFixups( + DiscoveryResult discovery, + ISet configuredExcludes = null) + { + configuredExcludes ??= new HashSet(StringComparer.Ordinal); + var result = new ResolvedRemaps(); + + // Pass 1: bare function typedefs with pointer aliases + foreach (var protoName in discovery.FnBareFunctionTypedefs) + { + if (!discovery.FnProtoToPointerTypedefs.TryGetValue(protoName, out var aliasNames)) + continue; + + // Filter out aliases that are already manually excluded + var candidates = aliasNames.Where(a => !configuredExcludes.Contains(a)).ToList(); + + if (candidates.Count != 1) + continue; // Ambiguous or all excluded — skip + + string aliasName = candidates[0]; + + // Bare function proto + pointer alias → standard fixup + result.FnPtrRemaps[protoName] = aliasName; + result.FnPtrExcludes.Add(aliasName); + result.ReducePointerLevel.Add(aliasName); + } + + // Pass 2: already-pointer typedefs with pointer-adding aliases + // e.g., typedef LRESULT (*ACMDRIVERPROC)(...); typedef ACMDRIVERPROC *LPACMDRIVERPROC; + // The alias adds another *, so reducePointerLevel is needed. + foreach (var protoName in discovery.FnPointerFunctionTypedefs) + { + if (!discovery.FnProtoToPointerTypedefs.TryGetValue(protoName, out var ptrAliasNames)) + continue; + + var candidates = ptrAliasNames.Where(a => !configuredExcludes.Contains(a)).ToList(); + + if (candidates.Count != 1) + continue; + + string aliasName = candidates[0]; + + result.FnPtrRemaps[protoName] = aliasName; + result.FnPtrExcludes.Add(aliasName); + result.ReducePointerLevel.Add(aliasName); + } + + // Already-pointer typedefs with same-level aliases (typedef PFOO LPFOO) + // are NOT auto-discovered — left to manual configuration. + + return result; + } + + /// + /// Unwraps sugar types (ElaboratedType, AttributedType, ParenType) to get to + /// the semantically meaningful type underneath. + /// + public static ClangSharp.Type UnwrapType(ClangSharp.Type type) + { + while (true) + { + if (type is ElaboratedType elab) + type = elab.NamedType; + else if (type is AttributedType attr) + type = attr.ModifiedType; + else if (type is ParenType paren) + type = paren.InnerType; + else + return type; + } + } + + private static void WalkDecl(Decl decl, DiscoveryResult result) + { + if (decl is TypedefDecl typedefDecl) + { + var underlyingType = UnwrapType(typedefDecl.UnderlyingType); + + if (underlyingType is TagType tagType) + { + var tagDecl = tagType.Decl; + // Skip tags inside C++ namespaces — PInvokeGenerator handles + // namespace-qualified types (Gdiplus::, ABI::) internally. + // Only discover remaps for top-level tags. + if (tagDecl != null && tagDecl.DeclContext is not NamespaceDecl) + { + string tagName = tagDecl.Name; + if (tagDecl.DeclContext is NamedDecl parent) + tagName = $"{parent.Name}::{tagName}"; + + string typedefName = typedefDecl.Name; + if (!string.IsNullOrEmpty(tagName)) + { + if (tagDecl is EnumDecl) + { + result.EnumTags.Add(tagName); + } + + if (!result.TagToTypedefs.TryGetValue(tagName, out var list)) + result.TagToTypedefs[tagName] = list = new List(); + + // Anonymous tags can inherit their first typedef name as a + // synthesized tag name. Preserve that identity typedef so a + // later alias does not become the auto-selected canonical name. + if (!list.Contains(typedefName)) + { + list.Add(typedefName); + } + + if (!result.TagToHeaderFile.ContainsKey(tagName)) + { + var location = typedefDecl.Location; + location.GetPresumedLocation(out var fileName, out _, out _); + string headerPath = fileName.ToString(); + if (!string.IsNullOrEmpty(headerPath)) + { + result.TagToHeaderFile[tagName] = headerPath; + } + } + } + } + } + else if (underlyingType is FunctionProtoType) + { + result.FnBareFunctionTypedefs.Add(typedefDecl.Name); + } + else if (underlyingType is PointerType ptrType) + { + var pointee = UnwrapType(ptrType.PointeeType); + + if (pointee is FunctionProtoType) + { + result.FnPointerFunctionTypedefs.Add(typedefDecl.Name); + } + else if (pointee is TypedefType tdType) + { + string pointedTypedefName = tdType.Decl?.Name; + if (pointedTypedefName != null) + { + if (!result.FnProtoToPointerTypedefs.TryGetValue(pointedTypedefName, out var ptrList)) + result.FnProtoToPointerTypedefs[pointedTypedefName] = ptrList = new List(); + if (!ptrList.Contains(typedefDecl.Name)) + ptrList.Add(typedefDecl.Name); + } + } + } + else if (underlyingType is TypedefType tdType2) + { + // Same-level alias: typedef EXISTING_NAME NEW_ALIAS; + string sourceTypedefName = tdType2.Decl?.Name; + if (sourceTypedefName != null) + { + if (!result.FnSameLevelAliases.TryGetValue(sourceTypedefName, out var aliasList)) + result.FnSameLevelAliases[sourceTypedefName] = aliasList = new List(); + if (!aliasList.Contains(typedefDecl.Name)) + aliasList.Add(typedefDecl.Name); + } + } + } + + if (decl is IDeclContext context) + { + // Walk Decls first (direct declarations) + foreach (var child in context.Decls) + { + WalkDecl(child, result); + } + + // Also walk CursorChildren to find typedefs from transitively included + // headers that don't appear in Decls. PInvokeGenerator uses both traversals. + foreach (var cursor in decl.CursorChildren) + { + if (cursor is TypedefDecl && !context.Decls.Contains((Decl)cursor)) + { + WalkDecl((Decl)cursor, result); + } + } + } + } +} +} + + diff --git a/sources/Win32MetadataScraper/Win32MetadataScraper.csproj b/sources/Win32MetadataScraper/Win32MetadataScraper.csproj new file mode 100644 index 000000000..b8fe37bb8 --- /dev/null +++ b/sources/Win32MetadataScraper/Win32MetadataScraper.csproj @@ -0,0 +1,20 @@ + + + + Exe + net8.0 + $(NETCoreSdkRuntimeIdentifier) + false + 5 + 1701;1702; + + + + + + + + + + + diff --git a/tests/Win32MetadataScraperTests/HeaderSnippetParser.cs b/tests/Win32MetadataScraperTests/HeaderSnippetParser.cs new file mode 100644 index 000000000..e005713fc --- /dev/null +++ b/tests/Win32MetadataScraperTests/HeaderSnippetParser.cs @@ -0,0 +1,128 @@ +using System; +using System.Collections.Generic; +using System.Diagnostics; +using System.IO; +using ClangSharp; +using ClangSharp.Interop; +using Win32MetadataScraper; + +namespace Win32MetadataScraperTests +{ + /// + /// Parses a C/C++ header snippet using ClangSharp and returns the AST discovery results. + /// Handles temp file creation/cleanup and native library loading. + /// + public static class HeaderSnippetParser + { + + /// + /// Ensures native libraries are available. With RuntimeIdentifiers set in the + /// project, the .NET host resolves libclang/libClangSharp from the NuGet cache + /// at execution time — no manual loading needed. + /// + public static void EnsureNativeLibsLoaded() + { + // Native libs are resolved automatically by the .NET host via deps.json + // and the NuGet runtime package graph. No manual loading required. + } + + /// + /// Parses a C header snippet and returns the AST discovery results. + /// + public static DiscoveryResult ParseAndDiscover(string headerContent) + { + return ParseAndDiscover(new Dictionary { ["test.h"] = headerContent }, "#include \"test.h\"\n"); + } + + /// + /// Parses multiple header files with a custom main source and returns discovery results. + /// + public static DiscoveryResult ParseAndDiscover(Dictionary files, string mainSource) + { + EnsureNativeLibsLoaded(); + + string tempDir = Path.Combine(Path.GetTempPath(), $"scraper-test-{Guid.NewGuid():N}"); + Directory.CreateDirectory(tempDir); + + try + { + foreach (var kv in files) + File.WriteAllText(Path.Combine(tempDir, kv.Key), kv.Value); + + string sourceFile = Path.Combine(tempDir, "test.cpp"); + File.WriteAllText(sourceFile, mainSource); + + var clangArgs = new string[] + { + "--language=c++", + "--std=c++17", + $"--include-directory={tempDir}", + "-Wno-pragma-once-outside-header" + }; + + var flags = CXTranslationUnit_Flags.CXTranslationUnit_IncludeAttributedTypes + | CXTranslationUnit_Flags.CXTranslationUnit_VisitImplicitAttributes; + + using var index = CXIndex.Create(excludeDeclarationsFromPch: false, displayDiagnostics: false); + var error = CXTranslationUnit.TryParse( + index, sourceFile, clangArgs, ReadOnlySpan.Empty, flags, out var handle); + + if (error != CXErrorCode.CXError_Success) + throw new InvalidOperationException($"Failed to parse: {error}"); + + // Check for fatal errors + for (uint i = 0; i < handle.NumDiagnostics; i++) + { + using var diag = handle.GetDiagnostic(i); + if (diag.Severity == CXDiagnosticSeverity.CXDiagnostic_Error || + diag.Severity == CXDiagnosticSeverity.CXDiagnostic_Fatal) + { + throw new InvalidOperationException( + $"Parse error: {diag.Format(CXDiagnostic.DefaultDisplayOptions)}"); + } + } + + using var tu = TranslationUnit.GetOrCreate(handle); + Debug.Assert(tu is not null); + + return RemapDiscovery.WalkTranslationUnit(tu.TranslationUnitDecl); + } + finally + { + try { Directory.Delete(tempDir, true); } catch { } + } + } + + /// + /// Convenience: parse, discover, resolve tag remaps, and filter — all in one call. + /// Returns the final auto-remap dictionary. + /// + public static Dictionary ParseAndResolveTagRemaps( + string headerContent, + Dictionary configuredRemaps = null, + IEnumerable autoRemapExcludes = null) + { + configuredRemaps ??= new Dictionary(); + var autoRemapExcludeSet = autoRemapExcludes is null + ? null + : new HashSet(autoRemapExcludes, StringComparer.Ordinal); + var discovery = ParseAndDiscover(headerContent); + var resolved = RemapDiscovery.ResolveTagRemaps(discovery.TagToTypedefs, configuredRemaps); + return RemapDiscovery.FilterTagRemaps(resolved, configuredRemaps, discovery.EnumTags, autoRemapExcludeSet); + } + + /// + /// Convenience: parse, discover, and resolve function pointer fixups. + /// + public static ResolvedRemaps ParseAndResolveFnPtrFixups( + string headerContent, + IEnumerable configuredExcludes = null) + { + var discovery = ParseAndDiscover(headerContent); + var excludeSet = configuredExcludes is null + ? null + : new HashSet(configuredExcludes, StringComparer.Ordinal); + return RemapDiscovery.ResolveFunctionPointerFixups(discovery, excludeSet); + } + } +} diff --git a/tests/Win32MetadataScraperTests/RemapDiscoveryTests.cs b/tests/Win32MetadataScraperTests/RemapDiscoveryTests.cs new file mode 100644 index 000000000..b18f5aa1b --- /dev/null +++ b/tests/Win32MetadataScraperTests/RemapDiscoveryTests.cs @@ -0,0 +1,826 @@ +using System.Collections.Generic; +using Xunit; + +namespace Win32MetadataScraperTests +{ + /// + /// Tests for tag-typedef remap discovery heuristics. + /// Each test uses a minimal C header snippet that mirrors a real SDK pattern. + /// + public class TagTypedefDiscoveryTests + { + // ── Simple tag-typedef patterns ────────────────────────────────────── + + [Fact] + public void UnderscoreUppercase_DiscoversSingleTypedef() + { + // Pattern: typedef struct _FOO { ... } FOO; + // e.g., typedef struct _RECT { LONG left; ... } RECT; + var remaps = HeaderSnippetParser.ParseAndResolveTagRemaps(@" + typedef struct _RECT { + long left; + long top; + long right; + long bottom; + } RECT; + "); + + Assert.True(remaps.ContainsKey("_RECT")); + Assert.Equal("RECT", remaps["_RECT"]); + } + + [Fact] + public void UnderscoreLowercase_DiscoversSingleTypedef() + { + // Pattern: typedef struct _cpinfo { ... } CPINFO; + // Real SDK: winnls.h — _cpinfo → CPINFO + var remaps = HeaderSnippetParser.ParseAndResolveTagRemaps(@" + typedef struct _cpinfo { + unsigned int MaxCharSize; + unsigned char DefaultChar[2]; + unsigned char LeadByte[12]; + } CPINFO; + "); + + Assert.True(remaps.ContainsKey("_cpinfo")); + Assert.Equal("CPINFO", remaps["_cpinfo"]); + } + + [Fact] + public void TagPrefix_DiscoversSingleTypedef() + { + // Pattern: typedef struct tagFOO { ... } FOO; + // Real SDK: wingdi.h — tagBITMAP → BITMAP + var remaps = HeaderSnippetParser.ParseAndResolveTagRemaps(@" + typedef struct tagBITMAP { + int bmType; + int bmWidth; + int bmHeight; + } BITMAP; + "); + + Assert.True(remaps.ContainsKey("tagBITMAP")); + Assert.Equal("BITMAP", remaps["tagBITMAP"]); + } + + [Fact] + public void LowercaseTag_DiscoversSingleTypedef() + { + // Pattern: typedef struct waveformat_tag { ... } WAVEFORMAT; + // Real SDK: mmreg.h — waveformat_tag → WAVEFORMAT + var remaps = HeaderSnippetParser.ParseAndResolveTagRemaps(@" + typedef struct waveformat_tag { + unsigned short wFormatTag; + unsigned short nChannels; + unsigned long nSamplesPerSec; + } WAVEFORMAT; + "); + + Assert.True(remaps.ContainsKey("waveformat_tag")); + Assert.Equal("WAVEFORMAT", remaps["waveformat_tag"]); + } + + [Fact] + public void TrailingUnderscore_DiscoversSingleTypedef() + { + // Pattern: typedef struct FOO_ { ... } FOO; + // Real SDK: CONFIG_CI_PROV_INFO_ → CONFIG_CI_PROV_INFO + var remaps = HeaderSnippetParser.ParseAndResolveTagRemaps(@" + typedef struct CONFIG_CI_PROV_INFO_ { + unsigned long cbSize; + } CONFIG_CI_PROV_INFO; + "); + + Assert.True(remaps.ContainsKey("CONFIG_CI_PROV_INFO_")); + Assert.Equal("CONFIG_CI_PROV_INFO", remaps["CONFIG_CI_PROV_INFO_"]); + } + + [Fact] + public void EnumTypedef_DiscoveredCorrectly() + { + // Pattern: typedef enum _FOO { ... } FOO; + var remaps = HeaderSnippetParser.ParseAndResolveTagRemaps(@" + typedef enum _PROCESS_DPI_AWARENESS { + PROCESS_DPI_UNAWARE = 0, + PROCESS_SYSTEM_DPI_AWARE = 1, + PROCESS_PER_MONITOR_DPI_AWARE = 2 + } PROCESS_DPI_AWARENESS; + "); + + Assert.True(remaps.ContainsKey("_PROCESS_DPI_AWARENESS")); + Assert.Equal("PROCESS_DPI_AWARENESS", remaps["_PROCESS_DPI_AWARENESS"]); + } + + // ── Multi-typedef disambiguation ───────────────────────────────────── + + [Fact] + public void MultipleTypedefs_DisambiguatesByStrippingPrefix() + { + // Pattern: struct _FOO has both FOO and PFOO typedefs + // Should pick FOO (stripped _ prefix), not PFOO + // Real SDK: winnt.h — many types have both direct and pointer typedefs + var remaps = HeaderSnippetParser.ParseAndResolveTagRemaps(@" + typedef struct _SECURITY_ATTRIBUTES { + unsigned long nLength; + void* lpSecurityDescriptor; + int bInheritHandle; + } SECURITY_ATTRIBUTES, *PSECURITY_ATTRIBUTES, *LPSECURITY_ATTRIBUTES; + "); + + Assert.True(remaps.ContainsKey("_SECURITY_ATTRIBUTES")); + Assert.Equal("SECURITY_ATTRIBUTES", remaps["_SECURITY_ATTRIBUTES"]); + } + + [Fact] + public void MultipleTypedefs_DisambiguatesByCaseInsensitiveMatch() + { + // Pattern from in6addr.h: struct in6_addr has typedefs IN6_ADDR and IPv6Addr. + // The disambiguator should pick IN6_ADDR (case-insensitive match of tag name). + var files = new Dictionary + { + ["test.h"] = @" + typedef struct in6_addr { + unsigned char Byte[16]; + } IN6_ADDR; + typedef struct in6_addr IPv6Addr; + " + }; + + var discovery = HeaderSnippetParser.ParseAndDiscover(files, "#include \"test.h\"\n"); + var resolved = Win32MetadataScraper.RemapDiscovery.ResolveTagRemaps( + discovery.TagToTypedefs, new Dictionary()); + + Assert.True(resolved.ContainsKey("in6_addr")); + Assert.Equal("IN6_ADDR", resolved["in6_addr"]); + } + + [Fact] + public void MultipleTypedefs_PrefersFirstTypedefWhenTagMatchesIt() + { + // Pattern from ks.h: an anonymous struct's first typedef becomes the + // synthesized tag name, and later aliases should not trigger an auto-remap. + var discovery = HeaderSnippetParser.ParseAndDiscover(@" + typedef struct { + unsigned long FormatSize; + unsigned long Flags; + } KSDATAFORMAT, *PKSDATAFORMAT, KSDATARANGE, *PKSDATARANGE; + "); + + Assert.True(discovery.TagToTypedefs.ContainsKey("KSDATAFORMAT")); + + var resolved = Win32MetadataScraper.RemapDiscovery.ResolveTagRemaps( + discovery.TagToTypedefs, new Dictionary()); + Assert.True(resolved.ContainsKey("KSDATAFORMAT")); + Assert.Equal("KSDATAFORMAT", resolved["KSDATAFORMAT"]); + + var filtered = Win32MetadataScraper.RemapDiscovery.FilterTagRemaps( + resolved, new Dictionary()); + Assert.False(filtered.ContainsKey("KSDATAFORMAT")); + } + + [Fact] + public void AmbiguousTypedefs_SkippedWithoutManualHint() + { + // When a tag has multiple typedefs and none is the "stripped" version, + // the heuristic should skip it (conservative) + var remaps = HeaderSnippetParser.ParseAndResolveTagRemaps(@" + typedef struct _AMBIGUOUS { + int x; + } ALPHA_NAME, BETA_NAME; + "); + + // Neither ALPHA_NAME nor BETA_NAME matches _AMBIGUOUS stripped + Assert.False(remaps.ContainsKey("_AMBIGUOUS")); + } + + [Fact] + public void AmbiguousTypedefs_ResolvedByManualHint() + { + // When manual config specifies which typedef to use for an ambiguous tag, + // the heuristic should use that + var configured = new Dictionary + { + ["_IMAGE_RUNTIME_FUNCTION_ENTRY"] = "IMAGE_RUNTIME_FUNCTION_ENTRY" + }; + + var remaps = HeaderSnippetParser.ParseAndResolveTagRemaps(@" + typedef struct _IMAGE_RUNTIME_FUNCTION_ENTRY { + unsigned long BeginAddress; + unsigned long EndAddress; + unsigned long UnwindInfoAddress; + } IMAGE_RUNTIME_FUNCTION_ENTRY, IMAGE_IA64_RUNTIME_FUNCTION_ENTRY; + ", configured); + + Assert.True(remaps.ContainsKey("_IMAGE_RUNTIME_FUNCTION_ENTRY")); + Assert.Equal("IMAGE_RUNTIME_FUNCTION_ENTRY", remaps["_IMAGE_RUNTIME_FUNCTION_ENTRY"]); + } + + // ── Semantic override protection ───────────────────────────────────── + + [Fact] + public void SemanticOverride_ManualWins() + { + // When manual remap maps to a C# primitive (e.g., _LARGE_INTEGER=long), + // auto-discovery finds the C typedef but the manual override takes priority + var configured = new Dictionary + { + ["_LARGE_INTEGER"] = "long" + }; + + var remaps = HeaderSnippetParser.ParseAndResolveTagRemaps(@" + typedef union _LARGE_INTEGER { + struct { + unsigned long LowPart; + long HighPart; + }; + long long QuadPart; + } LARGE_INTEGER; + ", configured); + + // Auto-discovers _LARGE_INTEGER=LARGE_INTEGER, but filter skips it + // because configured says _LARGE_INTEGER=long (different value) + Assert.False(remaps.ContainsKey("_LARGE_INTEGER")); + } + + // ── C++ namespace types skipped ────────────────────────────────────── + + [Fact] + public void CppNamespaceTypes_NotRemapped() + { + // Types inside C++ namespaces (like Gdiplus::Status) should not be + // auto-remapped — PInvokeGenerator handles these internally. + // Pattern from gdiplusenums.h / gdiplusgpstubs.h + var remaps = HeaderSnippetParser.ParseAndResolveTagRemaps(@" + namespace Gdiplus { + enum Status { Ok = 0, GenericError = 1 }; + typedef Status GpStatus; + enum FillMode { FillModeAlternate = 0 }; + typedef FillMode GpFillMode; + } + "); + + Assert.False(remaps.ContainsKey("Status")); + Assert.False(remaps.ContainsKey("Gdiplus::Status")); + Assert.False(remaps.ContainsKey("FillMode")); + Assert.False(remaps.ContainsKey("Gdiplus::FillMode")); + } + + // ── Built-in type filtering ────────────────────────────────────────── + + [Fact] + public void BuiltinTypes_NotRemapped() + { + var remaps = HeaderSnippetParser.ParseAndResolveTagRemaps(@" + typedef struct _GUID { + unsigned long Data1; + unsigned short Data2; + unsigned short Data3; + unsigned char Data4[8]; + } GUID; + "); + + // _GUID is a built-in default that should be filtered out + Assert.False(remaps.ContainsKey("_GUID")); + } + + // ── Identity remap filtering ───────────────────────────────────────── + + [Fact] + public void IdentityRemap_Filtered() + { + // When tag name equals typedef name, no remap needed + var discovery = HeaderSnippetParser.ParseAndDiscover(@" + typedef struct ALREADY_NAMED { + int x; + } ALREADY_NAMED; + "); + + // The tag and typedef are the same — should not appear in remaps + var resolved = Win32MetadataScraper.RemapDiscovery.ResolveTagRemaps( + discovery.TagToTypedefs, new Dictionary()); + Assert.False(resolved.ContainsKey("ALREADY_NAMED")); + } + + [Fact] + public void SuffixAdding_Filtered() + { + // When the typedef adds a suffix to the tag name (e.g., GLUnurbs→GLUnurbsObj), + // the tag name is the canonical name used in function signatures. + // The remap should be filtered out. + var remaps = HeaderSnippetParser.ParseAndResolveTagRemaps(@" + typedef struct GLUnurbs GLUnurbsObj; + "); + + Assert.False(remaps.ContainsKey("GLUnurbs")); + } + + [Fact] + public void InterfaceAlias_Filtered() + { + var filtered = Win32MetadataScraper.RemapDiscovery.FilterTagRemaps( + new Dictionary + { + ["ID2D1SimplifiedGeometrySink"] = "IDWriteGeometrySink", + }, + new Dictionary()); + + Assert.False(filtered.ContainsKey("ID2D1SimplifiedGeometrySink")); + } + + [Fact] + public void InterfaceAlias_WithManualConfigStillNotAutoEmitted() + { + var filtered = Win32MetadataScraper.RemapDiscovery.FilterTagRemaps( + new Dictionary + { + ["ID3D10Blob"] = "ID3DBlob", + }, + new Dictionary + { + ["ID3D10Blob"] = "ID3DBlob", + }); + + Assert.False(filtered.ContainsKey("ID3D10Blob")); + } + + [Fact] + public void AutoRemapExclude_SkipsConfiguredTag() + { + var remaps = HeaderSnippetParser.ParseAndResolveTagRemaps(@" + typedef struct DxcBuffer { + void* Ptr; + unsigned long long Size; + } DxcText; + ", autoRemapExcludes: new[] { "DxcBuffer" }); + + Assert.False(remaps.ContainsKey("DxcBuffer")); + } + + [Fact] + public void EnumSuffixAdding_EnumAliasSuffixAllowed() + { + var remaps = HeaderSnippetParser.ParseAndResolveTagRemaps(@" + typedef enum ADS_USER_FLAG { + ADS_UF_SCRIPT = 0x1 + } ADS_USER_FLAG_ENUM; + "); + + Assert.True(remaps.ContainsKey("ADS_USER_FLAG")); + Assert.Equal("ADS_USER_FLAG_ENUM", remaps["ADS_USER_FLAG"]); + } + + [Fact] + public void EnumSuffixAdding_PluralSuffixAllowed() + { + var remaps = HeaderSnippetParser.ParseAndResolveTagRemaps(@" + typedef enum D3D11_SHADER_TRACKING_OPTION { + D3D11_SHADER_TRACKING_OPTION_IGNORE = 0 + } D3D11_SHADER_TRACKING_OPTIONS; + "); + + Assert.True(remaps.ContainsKey("D3D11_SHADER_TRACKING_OPTION")); + Assert.Equal("D3D11_SHADER_TRACKING_OPTIONS", remaps["D3D11_SHADER_TRACKING_OPTION"]); + } + + // ── Transitive include discovery ───────────────────────────────────── + + [Fact] + public void TransitiveInclude_TypedefDiscoveredAcrossHeaders() + { + // Pattern from in6addr.h / ws2ipdef.h: + // Header A defines: typedef struct in6_addr { ... } IN6_ADDR; + // Header B includes Header A and uses: struct in6_addr *addr; + // Main.cpp includes Header B. + // The typedef should be discovered even though it's in a transitively + // included header, not the directly included one. + var files = new Dictionary + { + ["inner.h"] = @" + typedef struct in6_addr { + unsigned char Byte[16]; + } IN6_ADDR; + ", + ["outer.h"] = @" + #include ""inner.h"" + typedef struct _SOME_STRUCT { + struct in6_addr addr; + } SOME_STRUCT; + " + }; + + var discovery = HeaderSnippetParser.ParseAndDiscover(files, "#include \"outer.h\"\n"); + var resolved = Win32MetadataScraper.RemapDiscovery.ResolveTagRemaps( + discovery.TagToTypedefs, new Dictionary()); + var filtered = Win32MetadataScraper.RemapDiscovery.FilterTagRemaps( + resolved, new Dictionary()); + + Assert.True(filtered.ContainsKey("in6_addr"), + "in6_addr remap should be discovered from transitively included header"); + Assert.Equal("IN6_ADDR", filtered["in6_addr"]); + } + + [Fact] + public void TransitiveInclude_WithIncludeGuardStillDiscovered() + { + // Reproduce the in6addr.h pattern: the typedef is guarded by + // #ifndef s6_addr, and s6_addr is #defined WITHIN the same header + // after the typedef. The typedef should still be visible. + var files = new Dictionary + { + ["guarded.h"] = @" + #ifndef s6_addr + #pragma once + typedef struct in6_addr { + union { + unsigned char Byte[16]; + unsigned short Word[8]; + } u; + } IN6_ADDR; + #define s6_addr u.Byte + #endif + ", + ["consumer.h"] = @" + #include ""guarded.h"" + typedef struct _USES_ADDR { + struct in6_addr addr; + } USES_ADDR; + " + }; + + var discovery = HeaderSnippetParser.ParseAndDiscover(files, "#include \"consumer.h\"\n"); + var resolved = Win32MetadataScraper.RemapDiscovery.ResolveTagRemaps( + discovery.TagToTypedefs, new Dictionary()); + var filtered = Win32MetadataScraper.RemapDiscovery.FilterTagRemaps( + resolved, new Dictionary()); + + Assert.True(filtered.ContainsKey("in6_addr"), + "in6_addr remap should be discovered even with include guard"); + } + + [Fact] + public void TransitiveInclude_MultipleTypedefsSameTag() + { + // Pattern: struct has both IN6_ADDR and *PIN6_ADDR typedefs. + // Multiple typedefs for same tag — disambiguator should pick IN6_ADDR. + var files = new Dictionary + { + ["types.h"] = @" + typedef struct in6_addr { + unsigned char Byte[16]; + } IN6_ADDR, *PIN6_ADDR; + ", + ["user.h"] = @" + #include ""types.h"" + void do_something(IN6_ADDR* addr); + " + }; + + var discovery = HeaderSnippetParser.ParseAndDiscover(files, "#include \"user.h\"\n"); + + // Should find in6_addr with multiple typedefs + Assert.True(discovery.TagToTypedefs.ContainsKey("in6_addr")); + + var resolved = Win32MetadataScraper.RemapDiscovery.ResolveTagRemaps( + discovery.TagToTypedefs, new Dictionary()); + var filtered = Win32MetadataScraper.RemapDiscovery.FilterTagRemaps( + resolved, new Dictionary()); + + // Should pick IN6_ADDR (not PIN6_ADDR) since it strips the prefix + Assert.True(filtered.ContainsKey("in6_addr")); + Assert.Equal("IN6_ADDR", filtered["in6_addr"]); + } + } + + /// + /// Tests for function pointer typedef pair discovery. + /// + public class FunctionPointerDiscoveryTests + { + // ── Two-step function pointer pattern ──────────────────────────────── + + [Fact] + public void TwoStepFnPtr_PrototypeAndPointerTypedef() + { + // Pattern from mmiscapi2.h: + // typedef void (CALLBACK TIMECALLBACK)(UINT, UINT, ...); + // typedef TIMECALLBACK *LPTIMECALLBACK; + // Simplified for standalone compilation: + var result = HeaderSnippetParser.ParseAndResolveFnPtrFixups(@" + typedef void TIMECALLBACK(unsigned int uTimerID, unsigned int uMsg); + typedef TIMECALLBACK *LPTIMECALLBACK; + "); + + Assert.True(result.FnPtrRemaps.ContainsKey("TIMECALLBACK")); + Assert.Equal("LPTIMECALLBACK", result.FnPtrRemaps["TIMECALLBACK"]); + Assert.Contains("LPTIMECALLBACK", result.FnPtrExcludes); + Assert.Contains("LPTIMECALLBACK", result.ReducePointerLevel); + } + + [Fact] + public void TwoStepFnPtr_PPrefix() + { + // Pattern from winnt.h: + // typedef VOID TP_WORK_CALLBACK(PTP_CALLBACK_INSTANCE, PVOID, PTP_WORK); + // typedef TP_WORK_CALLBACK *PTP_WORK_CALLBACK; + var result = HeaderSnippetParser.ParseAndResolveFnPtrFixups(@" + typedef void TP_WORK_CALLBACK(void* Instance, void* Context, void* Work); + typedef TP_WORK_CALLBACK *PTP_WORK_CALLBACK; + "); + + Assert.True(result.FnPtrRemaps.ContainsKey("TP_WORK_CALLBACK")); + Assert.Equal("PTP_WORK_CALLBACK", result.FnPtrRemaps["TP_WORK_CALLBACK"]); + } + + [Fact] + public void TwoStepFnPtr_PFNPrefix() + { + // Pattern: typedef RPCNOTIFICATION_ROUTINE *PFN_RPCNOTIFICATION_ROUTINE; + var result = HeaderSnippetParser.ParseAndResolveFnPtrFixups(@" + typedef void RPCNOTIFICATION_ROUTINE(void* pAsync, void* Context, int Event); + typedef RPCNOTIFICATION_ROUTINE *PFN_RPCNOTIFICATION_ROUTINE; + "); + + Assert.True(result.FnPtrRemaps.ContainsKey("RPCNOTIFICATION_ROUTINE")); + Assert.Equal("PFN_RPCNOTIFICATION_ROUTINE", result.FnPtrRemaps["RPCNOTIFICATION_ROUTINE"]); + } + + // ── Direct pointer-to-function typedef ─────────────────────────────── + + [Fact] + public void DirectFnPtr_NoPrototypeSeparation() + { + // Pattern from commdlg.h: + // typedef unsigned int (*LPOFNHOOKPROC)(void*, unsigned int, ...); + // No separate prototype typedef — just the pointer typedef directly + var result = HeaderSnippetParser.ParseAndResolveFnPtrFixups(@" + typedef unsigned int (*LPOFNHOOKPROC)(void* hdlg, unsigned int msg, void* wParam, void* lParam); + "); + + // Should be recognized as a function pointer typedef + var discovery = HeaderSnippetParser.ParseAndDiscover(@" + typedef unsigned int (*LPOFNHOOKPROC)(void* hdlg, unsigned int msg, void* wParam, void* lParam); + "); + Assert.Contains("LPOFNHOOKPROC", discovery.FnProtoTypedefNames); + + // But no pair to resolve — no remap generated + Assert.Empty(result.FnPtrRemaps); + } + + // ── Calling convention (AttributedType) ────────────────────────────── + + [Fact] + public void FnPtr_WithCallingConvention() + { + // Pattern: typedef void (__stdcall CALLBACK_FN)(int x); + // typedef CALLBACK_FN *PCALLBACK_FN; + // The __stdcall creates an AttributedType wrapper + var result = HeaderSnippetParser.ParseAndResolveFnPtrFixups(@" + typedef void (__stdcall CALLBACK_FN)(int x); + typedef CALLBACK_FN *PCALLBACK_FN; + "); + + Assert.True(result.FnPtrRemaps.ContainsKey("CALLBACK_FN")); + Assert.Equal("PCALLBACK_FN", result.FnPtrRemaps["CALLBACK_FN"]); + } + + // ── Non-standard naming skipped ────────────────────────────────────── + + [Fact] + public void FnPtr_NonStandardPointerName_Resolved() + { + // When the pointer typedef doesn't follow naming conventions, the structural + // approach still resolves it correctly based on AST structure. + var result = HeaderSnippetParser.ParseAndResolveFnPtrFixups(@" + typedef void MY_CALLBACK(int x); + typedef MY_CALLBACK *MY_CALLBACK_HANDLER; + "); + + // Bare function + pointer alias → standard fixup + Assert.True(result.FnPtrRemaps.ContainsKey("MY_CALLBACK")); + Assert.Equal("MY_CALLBACK_HANDLER", result.FnPtrRemaps["MY_CALLBACK"]); + Assert.Contains("MY_CALLBACK_HANDLER", result.FnPtrExcludes); + Assert.Contains("MY_CALLBACK_HANDLER", result.ReducePointerLevel); + } + + [Fact] + public void FnPtr_ConfiguredExclude_SuppressesAutoFixup() + { + // Partition/manual settings already exclude these WAB aliases, so the + // scraper should not emit duplicate auto fixups for them. + var result = HeaderSnippetParser.ParseAndResolveFnPtrFixups(@" + typedef int MAPIALLOCATEBUFFER(unsigned long cbSize, void** lppBuffer); + typedef MAPIALLOCATEBUFFER *LPMAPIALLOCATEBUFFER; + ", new[] { "LPMAPIALLOCATEBUFFER" }); + + Assert.Empty(result.FnPtrRemaps); + Assert.Empty(result.FnPtrExcludes); + Assert.Empty(result.ReducePointerLevel); + } + + // ── Typedef-to-typedef alias pattern ───────────────────────────────── + + [Fact] + public void FnPtr_TypedefAlias() + { + // Pattern from minwinbase.h: + // typedef DWORD (*PTHREAD_START_ROUTINE)(LPVOID); + // typedef PTHREAD_START_ROUTINE LPTHREAD_START_ROUTINE; + // PTHREAD_START_ROUTINE is already a function pointer (not a prototype) + // LPTHREAD_START_ROUTINE is a typedef alias (not a pointer-to-typedef) + var discovery = HeaderSnippetParser.ParseAndDiscover(@" + typedef unsigned long (*PTHREAD_START_ROUTINE)(void* lpThreadParameter); + typedef PTHREAD_START_ROUTINE LPTHREAD_START_ROUTINE; + "); + + // PTHREAD_START_ROUTINE is a pointer-to-function typedef + Assert.Contains("PTHREAD_START_ROUTINE", discovery.FnPointerFunctionTypedefs); + Assert.Contains("PTHREAD_START_ROUTINE", discovery.FnProtoTypedefNames); + // LPTHREAD_START_ROUTINE is a same-level alias (not pointer-adding) + Assert.True(discovery.FnSameLevelAliases.ContainsKey("PTHREAD_START_ROUTINE")); + Assert.Contains("LPTHREAD_START_ROUTINE", discovery.FnSameLevelAliases["PTHREAD_START_ROUTINE"]); + // Should NOT be in FnProtoToPointerTypedefs (which is for pointer-adding aliases) + Assert.False(discovery.FnProtoToPointerTypedefs.ContainsKey("PTHREAD_START_ROUTINE")); + + // Resolution: same-level aliases for already-pointer types → no fixup generated + var result = HeaderSnippetParser.ParseAndResolveFnPtrFixups(@" + typedef unsigned long (*PTHREAD_START_ROUTINE)(void* lpThreadParameter); + typedef PTHREAD_START_ROUTINE LPTHREAD_START_ROUTINE; + "); + Assert.Empty(result.FnPtrRemaps); + } + + // ── Ambiguous pointer targets skipped ──────────────────────────────── + + [Fact] + public void FnPtr_AlreadyPointer_NoAutoFixupGenerated() + { + // Pattern from winnt.h: + // typedef DWORD (*PEXCEPTION_ROUTINE)(...); // already a fn pointer + // typedef PEXCEPTION_ROUTINE EXCEPTION_ROUTINE; // non-pointer alias + // Discovery intentionally skips auto-fixing this shape because the AST + // alone does not tell us which public name should win. The repo's + // current baseline still canonicalizes this one manually with: + // --exclude PEXCEPTION_ROUTINE + // --remap PEXCEPTION_ROUTINE=EXCEPTION_ROUTINE + var result = HeaderSnippetParser.ParseAndResolveFnPtrFixups(@" + typedef unsigned long (*PEXCEPTION_ROUTINE)(void* EstablisherFrame, unsigned long long DispatcherContext); + typedef PEXCEPTION_ROUTINE EXCEPTION_ROUTINE; + "); + + Assert.Empty(result.FnPtrRemaps); + } + + [Fact] + public void FnPtr_BothHavePointerPrefix_NoFixupForAlreadyPointer() + { + // When the proto is already a pointer (typedef DWORD (*P...)(...)) + // and the alias is a typedef-to-typedef, no fixup is generated — + // both names are valid aliases for the same pointer-to-function type. + var result = HeaderSnippetParser.ParseAndResolveFnPtrFixups(@" + typedef unsigned long (*PTHREAD_START_ROUTINE)(void* lpThreadParameter); + typedef PTHREAD_START_ROUTINE LPTHREAD_START_ROUTINE; + "); + + Assert.Empty(result.FnPtrRemaps); + } + + [Fact] + public void FnPtr_AlreadyPointer_VersionedProtoWithUnversionedAlias() + { + // Pattern from powrprof.h: + // typedef BOOLEAN (CALLBACK* PWRSCHEMESENUMPROC_V2)(UINT, DWORD, ...); + // typedef PWRSCHEMESENUMPROC_V2 PWRSCHEMESENUMPROC; + // Both names are valid aliases — no fixup generated. + var result = HeaderSnippetParser.ParseAndResolveFnPtrFixups(@" + typedef unsigned char (*PWRSCHEMESENUMPROC_V2)(unsigned int uiIndex, unsigned long dwName); + typedef PWRSCHEMESENUMPROC_V2 PWRSCHEMESENUMPROC; + "); + + Assert.Empty(result.FnPtrRemaps); + } + + [Fact] + public void FnPtr_AlreadyPointer_PrefixedProtoWithPrefixedAlias() + { + // Pattern from patchapi.h — both are already-pointer aliases. + // No fixup generated. + var result = HeaderSnippetParser.ParseAndResolveFnPtrFixups(@" + typedef int (*PPATCH_PROGRESS_CALLBACK)(void* CallbackContext, unsigned long CurrentPosition, unsigned long MaximumPosition); + typedef PPATCH_PROGRESS_CALLBACK PATCH_PROGRESS_CALLBACK; + "); + + Assert.Empty(result.FnPtrRemaps); + } + + [Fact] + public void FnPtr_BareFunction_DistinguishedFromPointerFunction() + { + // Verify that bare function typedefs and pointer-to-function typedefs + // are correctly classified in the discovery result. + var discovery = HeaderSnippetParser.ParseAndDiscover(@" + typedef void BARE_CALLBACK(int x); + typedef void (*PTR_CALLBACK)(int x); + "); + + Assert.Contains("BARE_CALLBACK", discovery.FnBareFunctionTypedefs); + Assert.DoesNotContain("BARE_CALLBACK", discovery.FnPointerFunctionTypedefs); + Assert.Contains("PTR_CALLBACK", discovery.FnPointerFunctionTypedefs); + Assert.DoesNotContain("PTR_CALLBACK", discovery.FnBareFunctionTypedefs); + } + + [Fact] + public void FnPtr_MultiplePointerNames_Skipped() + { + // If a prototype has multiple pointer aliases, skip (ambiguous) + var result = HeaderSnippetParser.ParseAndResolveFnPtrFixups(@" + typedef void MY_FUNC(int x); + typedef MY_FUNC *PMY_FUNC; + typedef MY_FUNC *LPMY_FUNC; + "); + + // Two pointer aliases — ambiguous, should skip + Assert.Empty(result.FnPtrRemaps); + } + + [Fact] + public void FnPtr_MultiplePointerNames_DisambiguatedByExclude() + { + // Pattern from mmsyscom.h: + // typedef void (CALLBACK DRVCALLBACK)(...); + // typedef DRVCALLBACK *LPDRVCALLBACK; + // typedef DRVCALLBACK *PDRVCALLBACK; + // Two pointer aliases → ambiguous, but if one is in configuredExcludes, + // it's filtered out, leaving exactly one candidate. + var result = HeaderSnippetParser.ParseAndResolveFnPtrFixups(@" + typedef void DRVCALLBACK(unsigned int hdrvr, unsigned int uMsg); + typedef DRVCALLBACK *LPDRVCALLBACK; + typedef DRVCALLBACK *PDRVCALLBACK; + ", new[] { "PDRVCALLBACK" }); + + Assert.True(result.FnPtrRemaps.ContainsKey("DRVCALLBACK")); + Assert.Equal("LPDRVCALLBACK", result.FnPtrRemaps["DRVCALLBACK"]); + Assert.Contains("LPDRVCALLBACK", result.FnPtrExcludes); + Assert.Contains("LPDRVCALLBACK", result.ReducePointerLevel); + } + + [Fact] + public void FnPtr_AlreadyPointer_WithPointerAddingAlias() + { + // Pattern from MSAcm.h: + // typedef LRESULT (*ACMDRIVERPROC)(...); + // typedef ACMDRIVERPROC *LPACMDRIVERPROC; + // ACMDRIVERPROC is already a pointer-to-function. LPACMDRIVERPROC adds + // another * level. This should generate remap + exclude + reducePointerLevel. + var result = HeaderSnippetParser.ParseAndResolveFnPtrFixups(@" + typedef long (*ACMDRIVERPROC)(unsigned long dwId, unsigned int uMsg); + typedef ACMDRIVERPROC *LPACMDRIVERPROC; + "); + + Assert.True(result.FnPtrRemaps.ContainsKey("ACMDRIVERPROC")); + Assert.Equal("LPACMDRIVERPROC", result.FnPtrRemaps["ACMDRIVERPROC"]); + Assert.Contains("LPACMDRIVERPROC", result.FnPtrExcludes); + Assert.Contains("LPACMDRIVERPROC", result.ReducePointerLevel); + } + + [Fact] + public void FnPtr_AlreadyPointer_SameLevelAlias_NoFixup() + { + // Pattern: typedef DWORD (*PFOO)(...); typedef PFOO LPFOO; + // Same-level alias — no fixup generated (needs manual curation). + var result = HeaderSnippetParser.ParseAndResolveFnPtrFixups(@" + typedef unsigned long (*PFOO)(void* param); + typedef PFOO LPFOO; + "); + + Assert.Empty(result.FnPtrRemaps); + } + } + + /// + /// Tests for the UnwrapType helper that peels sugar types. + /// + public class UnwrapTypeTests + { + [Fact] + public void ElaboratedType_UnwrappedCorrectly() + { + // typedef struct _FOO { int x; } FOO; creates ElaboratedType → RecordType + var discovery = HeaderSnippetParser.ParseAndDiscover(@" + typedef struct _FOO { int x; } FOO; + "); + + Assert.True(discovery.TagToTypedefs.ContainsKey("_FOO")); + } + + [Fact] + public void AttributedType_UnwrappedForFnPtr() + { + // __stdcall creates AttributedType wrapping FunctionProtoType + var discovery = HeaderSnippetParser.ParseAndDiscover(@" + typedef void (__stdcall MY_CALLBACK)(int x); + "); + + Assert.Contains("MY_CALLBACK", discovery.FnBareFunctionTypedefs); + } + } +} diff --git a/tests/Win32MetadataScraperTests/RspFileParserTests.cs b/tests/Win32MetadataScraperTests/RspFileParserTests.cs new file mode 100644 index 000000000..1c173f950 --- /dev/null +++ b/tests/Win32MetadataScraperTests/RspFileParserTests.cs @@ -0,0 +1,53 @@ +using System; +using System.Collections.Generic; +using System.IO; +using System.Reflection; +using Win32MetadataScraper; +using Xunit; + +namespace Win32MetadataScraperTests +{ + public class RspFileParserTests + { + [Fact] + public void ParseRspFile_IgnoresHashCommentLines() + { + string tempFile = Path.GetTempFileName(); + + try + { + File.WriteAllText(tempFile, @" +--remap +# Compatibility pin +DxcBuffer=DxcBuffer + +--exclude +# Preserve the baseline public name +PEXCEPTION_ROUTINE +"); + + var settings = new Dictionary>(StringComparer.OrdinalIgnoreCase); + InvokeParseRspFile(tempFile, settings); + + Assert.Collection( + settings["--remap"], + item => Assert.Equal("DxcBuffer=DxcBuffer", item)); + Assert.Collection( + settings["--exclude"], + item => Assert.Equal("PEXCEPTION_ROUTINE", item)); + } + finally + { + File.Delete(tempFile); + } + } + + private static void InvokeParseRspFile(string path, Dictionary> settings) + { + MethodInfo parseRspFile = typeof(RemapDiscovery).Assembly.GetType("Program", throwOnError: true)! + .GetMethod("ParseRspFile", BindingFlags.Static | BindingFlags.NonPublic)!; + + parseRspFile.Invoke(null, new object[] { path, settings }); + } + } +} diff --git a/tests/Win32MetadataScraperTests/Win32MetadataScraperTests.csproj b/tests/Win32MetadataScraperTests/Win32MetadataScraperTests.csproj new file mode 100644 index 000000000..e19956cc9 --- /dev/null +++ b/tests/Win32MetadataScraperTests/Win32MetadataScraperTests.csproj @@ -0,0 +1,23 @@ + + + + net8.0 + $(NETCoreSdkRuntimeIdentifier) + false + false + + + + + + + runtime; build; native; contentfiles; analyzers; buildtransitive + all + + + + + + + +